DwarfDebug.cpp revision 028f3478a510ef0855abc891237882b3c6123671
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 [7.27] 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 Hash.update(Str); 992 Hash.update(makeArrayRef((uint8_t)'\0')); 993} 994 995// FIXME: These are copied and only slightly modified out of LEB128.h. 996 997/// \brief Adds the unsigned in \p N to the hash in \p Hash. This also encodes 998/// the unsigned as a ULEB128. 999static void addULEB128ToHash(MD5 &Hash, uint64_t Value) { 1000 DEBUG(dbgs() << "Adding ULEB128 " << Value << " to hash.\n"); 1001 do { 1002 uint8_t Byte = Value & 0x7f; 1003 Value >>= 7; 1004 if (Value != 0) 1005 Byte |= 0x80; // Mark this byte to show that more bytes will follow. 1006 Hash.update(Byte); 1007 } while (Value != 0); 1008} 1009 1010/// \brief Including \p Parent adds the context of Parent to \p Hash. 1011static void addParentContextToHash(MD5 &Hash, DIE *Parent) { 1012 1013 DEBUG(dbgs() << "Adding parent context to hash...\n"); 1014 1015 // [7.27.2] For each surrounding type or namespace beginning with the 1016 // outermost such construct... 1017 SmallVector<DIE *, 1> Parents; 1018 while (Parent->getTag() != dwarf::DW_TAG_compile_unit) { 1019 Parents.push_back(Parent); 1020 Parent = Parent->getParent(); 1021 } 1022 1023 // Reverse iterate over our list to go from the outermost construct to the 1024 // innermost. 1025 for (SmallVectorImpl<DIE *>::reverse_iterator I = Parents.rbegin(), 1026 E = Parents.rend(); 1027 I != E; ++I) { 1028 DIE *Die = *I; 1029 1030 // ... Append the letter "C" to the sequence... 1031 addULEB128ToHash(Hash, 'C'); 1032 1033 // ... Followed by the DWARF tag of the construct... 1034 addULEB128ToHash(Hash, Die->getTag()); 1035 1036 // ... Then the name, taken from the DW_AT_name attribute. 1037 StringRef Name = getDIEStringAttr(Die, dwarf::DW_AT_name); 1038 DEBUG(dbgs() << "... adding context: " << Name << "\n"); 1039 if (!Name.empty()) 1040 addStringToHash(Hash, Name); 1041 } 1042} 1043 1044/// This is based on the type signature computation given in section 7.27 of the 1045/// DWARF4 standard. It is the md5 hash of a flattened description of the DIE with 1046/// the exception that we are hashing only the context and the name of the type. 1047static void addDIEODRSignature(MD5 &Hash, CompileUnit *CU, DIE *Die) { 1048 1049 // Add the contexts to the hash. We won't be computing the ODR hash for 1050 // function local types so it's safe to use the generic context hashing 1051 // algorithm here. 1052 // FIXME: If we figure out how to account for linkage in some way we could 1053 // actually do this with a slight modification to the parent hash algorithm. 1054 DIE *Parent = Die->getParent(); 1055 if (Parent) 1056 addParentContextToHash(Hash, Parent); 1057 1058 // Add the current DIE information. 1059 1060 // Add the DWARF tag of the DIE. 1061 addULEB128ToHash(Hash, Die->getTag()); 1062 1063 // Add the name of the type to the hash. 1064 addStringToHash(Hash, getDIEStringAttr(Die, dwarf::DW_AT_name)); 1065 1066 // Now get the result. 1067 MD5::MD5Result Result; 1068 Hash.final(Result); 1069 1070 // ... take the least significant 8 bytes and store those as the attribute. 1071 // Our MD5 implementation always returns its results in little endian, swap 1072 // bytes appropriately. 1073 uint64_t Signature = *reinterpret_cast<support::ulittle64_t *>(Result + 8); 1074 1075 // FIXME: This should be added onto the type unit, not the type, but this 1076 // works as an intermediate stage. 1077 CU->addUInt(Die, dwarf::DW_AT_GNU_odr_signature, dwarf::DW_FORM_data8, 1078 Signature); 1079} 1080 1081/// Return true if the current DIE is contained within an anonymous namespace. 1082static bool isContainedInAnonNamespace(DIE *Die) { 1083 DIE *Parent = Die->getParent(); 1084 1085 while (Parent) { 1086 if (Parent->getTag() == dwarf::DW_TAG_namespace && 1087 getDIEStringAttr(Parent, dwarf::DW_AT_name) == "") 1088 return true; 1089 Parent = Parent->getParent(); 1090 } 1091 1092 return false; 1093} 1094 1095/// Test if the current CU language is C++ and that we have 1096/// a named type that is not contained in an anonymous namespace. 1097static bool shouldAddODRHash(CompileUnit *CU, DIE *Die) { 1098 return (CU->getLanguage() == dwarf::DW_LANG_C_plus_plus && 1099 getDIEStringAttr(Die, dwarf::DW_AT_name) != "" && 1100 !isContainedInAnonNamespace(Die)); 1101} 1102 1103void DwarfDebug::finalizeModuleInfo() { 1104 // Collect info for variables that were optimized out. 1105 collectDeadVariables(); 1106 1107 // Attach DW_AT_inline attribute with inlined subprogram DIEs. 1108 computeInlinedDIEs(); 1109 1110 // Emit DW_AT_containing_type attribute to connect types with their 1111 // vtable holding type. 1112 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(), 1113 CUE = CUMap.end(); CUI != CUE; ++CUI) { 1114 CompileUnit *TheCU = CUI->second; 1115 TheCU->constructContainingTypeDIEs(); 1116 } 1117 1118 // Split out type units and conditionally add an ODR tag to the split 1119 // out type. 1120 // FIXME: Do type splitting. 1121 for (unsigned i = 0, e = TypeUnits.size(); i != e; ++i) { 1122 MD5 Hash; 1123 DIE *Die = TypeUnits[i]; 1124 // If we've requested ODR hashes and it's applicable for an ODR hash then 1125 // add the ODR signature now. 1126 if (GenerateODRHash && shouldAddODRHash(CUMap.begin()->second, Die)) 1127 addDIEODRSignature(Hash, CUMap.begin()->second, Die); 1128 } 1129 1130 // Compute DIE offsets and sizes. 1131 InfoHolder.computeSizeAndOffsets(); 1132 if (useSplitDwarf()) 1133 SkeletonHolder.computeSizeAndOffsets(); 1134} 1135 1136void DwarfDebug::endSections() { 1137 // Standard sections final addresses. 1138 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection()); 1139 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end")); 1140 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection()); 1141 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end")); 1142 1143 // End text sections. 1144 for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) { 1145 Asm->OutStreamer.SwitchSection(SectionMap[I]); 1146 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1)); 1147 } 1148} 1149 1150// Emit all Dwarf sections that should come after the content. 1151void DwarfDebug::endModule() { 1152 1153 if (!FirstCU) return; 1154 1155 // End any existing sections. 1156 // TODO: Does this need to happen? 1157 endSections(); 1158 1159 // Finalize the debug info for the module. 1160 finalizeModuleInfo(); 1161 1162 if (!useSplitDwarf()) { 1163 // Emit all the DIEs into a debug info section. 1164 emitDebugInfo(); 1165 1166 // Corresponding abbreviations into a abbrev section. 1167 emitAbbreviations(); 1168 1169 // Emit info into a debug loc section. 1170 emitDebugLoc(); 1171 1172 // Emit info into a debug aranges section. 1173 emitDebugARanges(); 1174 1175 // Emit info into a debug ranges section. 1176 emitDebugRanges(); 1177 1178 // Emit info into a debug macinfo section. 1179 emitDebugMacInfo(); 1180 1181 // Emit inline info. 1182 // TODO: When we don't need the option anymore we 1183 // can remove all of the code that this section 1184 // depends upon. 1185 if (useDarwinGDBCompat()) 1186 emitDebugInlineInfo(); 1187 } else { 1188 // TODO: Fill this in for separated debug sections and separate 1189 // out information into new sections. 1190 1191 // Emit the debug info section and compile units. 1192 emitDebugInfo(); 1193 emitDebugInfoDWO(); 1194 1195 // Corresponding abbreviations into a abbrev section. 1196 emitAbbreviations(); 1197 emitDebugAbbrevDWO(); 1198 1199 // Emit info into a debug loc section. 1200 emitDebugLoc(); 1201 1202 // Emit info into a debug aranges section. 1203 emitDebugARanges(); 1204 1205 // Emit info into a debug ranges section. 1206 emitDebugRanges(); 1207 1208 // Emit info into a debug macinfo section. 1209 emitDebugMacInfo(); 1210 1211 // Emit DWO addresses. 1212 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection()); 1213 1214 // Emit inline info. 1215 // TODO: When we don't need the option anymore we 1216 // can remove all of the code that this section 1217 // depends upon. 1218 if (useDarwinGDBCompat()) 1219 emitDebugInlineInfo(); 1220 } 1221 1222 // Emit info into the dwarf accelerator table sections. 1223 if (useDwarfAccelTables()) { 1224 emitAccelNames(); 1225 emitAccelObjC(); 1226 emitAccelNamespaces(); 1227 emitAccelTypes(); 1228 } 1229 1230 // Emit info into a debug pubnames section, if requested. 1231 if (GenerateDwarfPubNamesSection) 1232 emitDebugPubnames(); 1233 1234 // Emit info into a debug pubtypes section. 1235 // TODO: When we don't need the option anymore we can 1236 // remove all of the code that adds to the table. 1237 if (useDarwinGDBCompat()) 1238 emitDebugPubTypes(); 1239 1240 // Finally emit string information into a string table. 1241 emitDebugStr(); 1242 if (useSplitDwarf()) 1243 emitDebugStrDWO(); 1244 1245 // clean up. 1246 SPMap.clear(); 1247 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 1248 E = CUMap.end(); I != E; ++I) 1249 delete I->second; 1250 1251 for (SmallVectorImpl<CompileUnit *>::iterator I = SkeletonCUs.begin(), 1252 E = SkeletonCUs.end(); I != E; ++I) 1253 delete *I; 1254 1255 // Reset these for the next Module if we have one. 1256 FirstCU = NULL; 1257} 1258 1259// Find abstract variable, if any, associated with Var. 1260DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV, 1261 DebugLoc ScopeLoc) { 1262 LLVMContext &Ctx = DV->getContext(); 1263 // More then one inlined variable corresponds to one abstract variable. 1264 DIVariable Var = cleanseInlinedVariable(DV, Ctx); 1265 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var); 1266 if (AbsDbgVariable) 1267 return AbsDbgVariable; 1268 1269 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx)); 1270 if (!Scope) 1271 return NULL; 1272 1273 AbsDbgVariable = new DbgVariable(Var, NULL); 1274 addScopeVariable(Scope, AbsDbgVariable); 1275 AbstractVariables[Var] = AbsDbgVariable; 1276 return AbsDbgVariable; 1277} 1278 1279// If Var is a current function argument then add it to CurrentFnArguments list. 1280bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF, 1281 DbgVariable *Var, LexicalScope *Scope) { 1282 if (!LScopes.isCurrentFunctionScope(Scope)) 1283 return false; 1284 DIVariable DV = Var->getVariable(); 1285 if (DV.getTag() != dwarf::DW_TAG_arg_variable) 1286 return false; 1287 unsigned ArgNo = DV.getArgNumber(); 1288 if (ArgNo == 0) 1289 return false; 1290 1291 size_t Size = CurrentFnArguments.size(); 1292 if (Size == 0) 1293 CurrentFnArguments.resize(MF->getFunction()->arg_size()); 1294 // llvm::Function argument size is not good indicator of how many 1295 // arguments does the function have at source level. 1296 if (ArgNo > Size) 1297 CurrentFnArguments.resize(ArgNo * 2); 1298 CurrentFnArguments[ArgNo - 1] = Var; 1299 return true; 1300} 1301 1302// Collect variable information from side table maintained by MMI. 1303void 1304DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF, 1305 SmallPtrSet<const MDNode *, 16> &Processed) { 1306 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo(); 1307 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(), 1308 VE = VMap.end(); VI != VE; ++VI) { 1309 const MDNode *Var = VI->first; 1310 if (!Var) continue; 1311 Processed.insert(Var); 1312 DIVariable DV(Var); 1313 const std::pair<unsigned, DebugLoc> &VP = VI->second; 1314 1315 LexicalScope *Scope = LScopes.findLexicalScope(VP.second); 1316 1317 // If variable scope is not found then skip this variable. 1318 if (Scope == 0) 1319 continue; 1320 1321 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second); 1322 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable); 1323 RegVar->setFrameIndex(VP.first); 1324 if (!addCurrentFnArgument(MF, RegVar, Scope)) 1325 addScopeVariable(Scope, RegVar); 1326 if (AbsDbgVariable) 1327 AbsDbgVariable->setFrameIndex(VP.first); 1328 } 1329} 1330 1331// Return true if debug value, encoded by DBG_VALUE instruction, is in a 1332// defined reg. 1333static bool isDbgValueInDefinedReg(const MachineInstr *MI) { 1334 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!"); 1335 return MI->getNumOperands() == 3 && 1336 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() && 1337 (MI->getOperand(1).isImm() || 1338 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U)); 1339} 1340 1341// Get .debug_loc entry for the instruction range starting at MI. 1342static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm, 1343 const MCSymbol *FLabel, 1344 const MCSymbol *SLabel, 1345 const MachineInstr *MI) { 1346 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata(); 1347 1348 assert(MI->getNumOperands() == 3); 1349 if (MI->getOperand(0).isReg()) { 1350 MachineLocation MLoc; 1351 // If the second operand is an immediate, this is a 1352 // register-indirect address. 1353 if (!MI->getOperand(1).isImm()) 1354 MLoc.set(MI->getOperand(0).getReg()); 1355 else 1356 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm()); 1357 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var); 1358 } 1359 if (MI->getOperand(0).isImm()) 1360 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm()); 1361 if (MI->getOperand(0).isFPImm()) 1362 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm()); 1363 if (MI->getOperand(0).isCImm()) 1364 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm()); 1365 1366 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!"); 1367} 1368 1369// Find variables for each lexical scope. 1370void 1371DwarfDebug::collectVariableInfo(const MachineFunction *MF, 1372 SmallPtrSet<const MDNode *, 16> &Processed) { 1373 1374 // Grab the variable info that was squirreled away in the MMI side-table. 1375 collectVariableInfoFromMMITable(MF, Processed); 1376 1377 for (SmallVectorImpl<const MDNode*>::const_iterator 1378 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE; 1379 ++UVI) { 1380 const MDNode *Var = *UVI; 1381 if (Processed.count(Var)) 1382 continue; 1383 1384 // History contains relevant DBG_VALUE instructions for Var and instructions 1385 // clobbering it. 1386 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var]; 1387 if (History.empty()) 1388 continue; 1389 const MachineInstr *MInsn = History.front(); 1390 1391 DIVariable DV(Var); 1392 LexicalScope *Scope = NULL; 1393 if (DV.getTag() == dwarf::DW_TAG_arg_variable && 1394 DISubprogram(DV.getContext()).describes(MF->getFunction())) 1395 Scope = LScopes.getCurrentFunctionScope(); 1396 else if (MDNode *IA = DV.getInlinedAt()) 1397 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA)); 1398 else 1399 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1))); 1400 // If variable scope is not found then skip this variable. 1401 if (!Scope) 1402 continue; 1403 1404 Processed.insert(DV); 1405 assert(MInsn->isDebugValue() && "History must begin with debug value"); 1406 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc()); 1407 DbgVariable *RegVar = new DbgVariable(DV, AbsVar); 1408 if (!addCurrentFnArgument(MF, RegVar, Scope)) 1409 addScopeVariable(Scope, RegVar); 1410 if (AbsVar) 1411 AbsVar->setMInsn(MInsn); 1412 1413 // Simplify ranges that are fully coalesced. 1414 if (History.size() <= 1 || (History.size() == 2 && 1415 MInsn->isIdenticalTo(History.back()))) { 1416 RegVar->setMInsn(MInsn); 1417 continue; 1418 } 1419 1420 // Handle multiple DBG_VALUE instructions describing one variable. 1421 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size()); 1422 1423 for (SmallVectorImpl<const MachineInstr*>::const_iterator 1424 HI = History.begin(), HE = History.end(); HI != HE; ++HI) { 1425 const MachineInstr *Begin = *HI; 1426 assert(Begin->isDebugValue() && "Invalid History entry"); 1427 1428 // Check if DBG_VALUE is truncating a range. 1429 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() 1430 && !Begin->getOperand(0).getReg()) 1431 continue; 1432 1433 // Compute the range for a register location. 1434 const MCSymbol *FLabel = getLabelBeforeInsn(Begin); 1435 const MCSymbol *SLabel = 0; 1436 1437 if (HI + 1 == HE) 1438 // If Begin is the last instruction in History then its value is valid 1439 // until the end of the function. 1440 SLabel = FunctionEndSym; 1441 else { 1442 const MachineInstr *End = HI[1]; 1443 DEBUG(dbgs() << "DotDebugLoc Pair:\n" 1444 << "\t" << *Begin << "\t" << *End << "\n"); 1445 if (End->isDebugValue()) 1446 SLabel = getLabelBeforeInsn(End); 1447 else { 1448 // End is a normal instruction clobbering the range. 1449 SLabel = getLabelAfterInsn(End); 1450 assert(SLabel && "Forgot label after clobber instruction"); 1451 ++HI; 1452 } 1453 } 1454 1455 // The value is valid until the next DBG_VALUE or clobber. 1456 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel, 1457 Begin)); 1458 } 1459 DotDebugLocEntries.push_back(DotDebugLocEntry()); 1460 } 1461 1462 // Collect info for variables that were optimized out. 1463 LexicalScope *FnScope = LScopes.getCurrentFunctionScope(); 1464 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables(); 1465 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) { 1466 DIVariable DV(Variables.getElement(i)); 1467 if (!DV || !DV.isVariable() || !Processed.insert(DV)) 1468 continue; 1469 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext())) 1470 addScopeVariable(Scope, new DbgVariable(DV, NULL)); 1471 } 1472} 1473 1474// Return Label preceding the instruction. 1475MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) { 1476 MCSymbol *Label = LabelsBeforeInsn.lookup(MI); 1477 assert(Label && "Didn't insert label before instruction"); 1478 return Label; 1479} 1480 1481// Return Label immediately following the instruction. 1482MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) { 1483 return LabelsAfterInsn.lookup(MI); 1484} 1485 1486// Process beginning of an instruction. 1487void DwarfDebug::beginInstruction(const MachineInstr *MI) { 1488 // Check if source location changes, but ignore DBG_VALUE locations. 1489 if (!MI->isDebugValue()) { 1490 DebugLoc DL = MI->getDebugLoc(); 1491 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) { 1492 unsigned Flags = 0; 1493 PrevInstLoc = DL; 1494 if (DL == PrologEndLoc) { 1495 Flags |= DWARF2_FLAG_PROLOGUE_END; 1496 PrologEndLoc = DebugLoc(); 1497 } 1498 if (PrologEndLoc.isUnknown()) 1499 Flags |= DWARF2_FLAG_IS_STMT; 1500 1501 if (!DL.isUnknown()) { 1502 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext()); 1503 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags); 1504 } else 1505 recordSourceLine(0, 0, 0, 0); 1506 } 1507 } 1508 1509 // Insert labels where requested. 1510 DenseMap<const MachineInstr*, MCSymbol*>::iterator I = 1511 LabelsBeforeInsn.find(MI); 1512 1513 // No label needed. 1514 if (I == LabelsBeforeInsn.end()) 1515 return; 1516 1517 // Label already assigned. 1518 if (I->second) 1519 return; 1520 1521 if (!PrevLabel) { 1522 PrevLabel = MMI->getContext().CreateTempSymbol(); 1523 Asm->OutStreamer.EmitLabel(PrevLabel); 1524 } 1525 I->second = PrevLabel; 1526} 1527 1528// Process end of an instruction. 1529void DwarfDebug::endInstruction(const MachineInstr *MI) { 1530 // Don't create a new label after DBG_VALUE instructions. 1531 // They don't generate code. 1532 if (!MI->isDebugValue()) 1533 PrevLabel = 0; 1534 1535 DenseMap<const MachineInstr*, MCSymbol*>::iterator I = 1536 LabelsAfterInsn.find(MI); 1537 1538 // No label needed. 1539 if (I == LabelsAfterInsn.end()) 1540 return; 1541 1542 // Label already assigned. 1543 if (I->second) 1544 return; 1545 1546 // We need a label after this instruction. 1547 if (!PrevLabel) { 1548 PrevLabel = MMI->getContext().CreateTempSymbol(); 1549 Asm->OutStreamer.EmitLabel(PrevLabel); 1550 } 1551 I->second = PrevLabel; 1552} 1553 1554// Each LexicalScope has first instruction and last instruction to mark 1555// beginning and end of a scope respectively. Create an inverse map that list 1556// scopes starts (and ends) with an instruction. One instruction may start (or 1557// end) multiple scopes. Ignore scopes that are not reachable. 1558void DwarfDebug::identifyScopeMarkers() { 1559 SmallVector<LexicalScope *, 4> WorkList; 1560 WorkList.push_back(LScopes.getCurrentFunctionScope()); 1561 while (!WorkList.empty()) { 1562 LexicalScope *S = WorkList.pop_back_val(); 1563 1564 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren(); 1565 if (!Children.empty()) 1566 for (SmallVectorImpl<LexicalScope *>::const_iterator SI = Children.begin(), 1567 SE = Children.end(); SI != SE; ++SI) 1568 WorkList.push_back(*SI); 1569 1570 if (S->isAbstractScope()) 1571 continue; 1572 1573 const SmallVectorImpl<InsnRange> &Ranges = S->getRanges(); 1574 if (Ranges.empty()) 1575 continue; 1576 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(), 1577 RE = Ranges.end(); RI != RE; ++RI) { 1578 assert(RI->first && "InsnRange does not have first instruction!"); 1579 assert(RI->second && "InsnRange does not have second instruction!"); 1580 requestLabelBeforeInsn(RI->first); 1581 requestLabelAfterInsn(RI->second); 1582 } 1583 } 1584} 1585 1586// Get MDNode for DebugLoc's scope. 1587static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) { 1588 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx)) 1589 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx); 1590 return DL.getScope(Ctx); 1591} 1592 1593// Walk up the scope chain of given debug loc and find line number info 1594// for the function. 1595static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) { 1596 const MDNode *Scope = getScopeNode(DL, Ctx); 1597 DISubprogram SP = getDISubprogram(Scope); 1598 if (SP.isSubprogram()) { 1599 // Check for number of operands since the compatibility is 1600 // cheap here. 1601 if (SP->getNumOperands() > 19) 1602 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP); 1603 else 1604 return DebugLoc::get(SP.getLineNumber(), 0, SP); 1605 } 1606 1607 return DebugLoc(); 1608} 1609 1610// Gather pre-function debug information. Assumes being called immediately 1611// after the function entry point has been emitted. 1612void DwarfDebug::beginFunction(const MachineFunction *MF) { 1613 if (!MMI->hasDebugInfo()) return; 1614 LScopes.initialize(*MF); 1615 if (LScopes.empty()) return; 1616 identifyScopeMarkers(); 1617 1618 // Set DwarfCompileUnitID in MCContext to the Compile Unit this function 1619 // belongs to. 1620 LexicalScope *FnScope = LScopes.getCurrentFunctionScope(); 1621 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode()); 1622 assert(TheCU && "Unable to find compile unit!"); 1623 if (Asm->TM.hasMCUseLoc() && 1624 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer) 1625 // Use a single line table if we are using .loc and generating assembly. 1626 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0); 1627 else 1628 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID()); 1629 1630 FunctionBeginSym = Asm->GetTempSymbol("func_begin", 1631 Asm->getFunctionNumber()); 1632 // Assumes in correct section after the entry point. 1633 Asm->OutStreamer.EmitLabel(FunctionBeginSym); 1634 1635 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned"); 1636 1637 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo(); 1638 // LiveUserVar - Map physreg numbers to the MDNode they contain. 1639 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs()); 1640 1641 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); 1642 I != E; ++I) { 1643 bool AtBlockEntry = true; 1644 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 1645 II != IE; ++II) { 1646 const MachineInstr *MI = II; 1647 1648 if (MI->isDebugValue()) { 1649 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!"); 1650 1651 // Keep track of user variables. 1652 const MDNode *Var = 1653 MI->getOperand(MI->getNumOperands() - 1).getMetadata(); 1654 1655 // Variable is in a register, we need to check for clobbers. 1656 if (isDbgValueInDefinedReg(MI)) 1657 LiveUserVar[MI->getOperand(0).getReg()] = Var; 1658 1659 // Check the history of this variable. 1660 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var]; 1661 if (History.empty()) { 1662 UserVariables.push_back(Var); 1663 // The first mention of a function argument gets the FunctionBeginSym 1664 // label, so arguments are visible when breaking at function entry. 1665 DIVariable DV(Var); 1666 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable && 1667 DISubprogram(getDISubprogram(DV.getContext())) 1668 .describes(MF->getFunction())) 1669 LabelsBeforeInsn[MI] = FunctionBeginSym; 1670 } else { 1671 // We have seen this variable before. Try to coalesce DBG_VALUEs. 1672 const MachineInstr *Prev = History.back(); 1673 if (Prev->isDebugValue()) { 1674 // Coalesce identical entries at the end of History. 1675 if (History.size() >= 2 && 1676 Prev->isIdenticalTo(History[History.size() - 2])) { 1677 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n" 1678 << "\t" << *Prev 1679 << "\t" << *History[History.size() - 2] << "\n"); 1680 History.pop_back(); 1681 } 1682 1683 // Terminate old register assignments that don't reach MI; 1684 MachineFunction::const_iterator PrevMBB = Prev->getParent(); 1685 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) && 1686 isDbgValueInDefinedReg(Prev)) { 1687 // Previous register assignment needs to terminate at the end of 1688 // its basic block. 1689 MachineBasicBlock::const_iterator LastMI = 1690 PrevMBB->getLastNonDebugInstr(); 1691 if (LastMI == PrevMBB->end()) { 1692 // Drop DBG_VALUE for empty range. 1693 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n" 1694 << "\t" << *Prev << "\n"); 1695 History.pop_back(); 1696 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end()) 1697 // Terminate after LastMI. 1698 History.push_back(LastMI); 1699 } 1700 } 1701 } 1702 History.push_back(MI); 1703 } else { 1704 // Not a DBG_VALUE instruction. 1705 if (!MI->isLabel()) 1706 AtBlockEntry = false; 1707 1708 // First known non-DBG_VALUE and non-frame setup location marks 1709 // the beginning of the function body. 1710 if (!MI->getFlag(MachineInstr::FrameSetup) && 1711 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown())) 1712 PrologEndLoc = MI->getDebugLoc(); 1713 1714 // Check if the instruction clobbers any registers with debug vars. 1715 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(), 1716 MOE = MI->operands_end(); MOI != MOE; ++MOI) { 1717 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg()) 1718 continue; 1719 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true); 1720 AI.isValid(); ++AI) { 1721 unsigned Reg = *AI; 1722 const MDNode *Var = LiveUserVar[Reg]; 1723 if (!Var) 1724 continue; 1725 // Reg is now clobbered. 1726 LiveUserVar[Reg] = 0; 1727 1728 // Was MD last defined by a DBG_VALUE referring to Reg? 1729 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var); 1730 if (HistI == DbgValues.end()) 1731 continue; 1732 SmallVectorImpl<const MachineInstr*> &History = HistI->second; 1733 if (History.empty()) 1734 continue; 1735 const MachineInstr *Prev = History.back(); 1736 // Sanity-check: Register assignments are terminated at the end of 1737 // their block. 1738 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent()) 1739 continue; 1740 // Is the variable still in Reg? 1741 if (!isDbgValueInDefinedReg(Prev) || 1742 Prev->getOperand(0).getReg() != Reg) 1743 continue; 1744 // Var is clobbered. Make sure the next instruction gets a label. 1745 History.push_back(MI); 1746 } 1747 } 1748 } 1749 } 1750 } 1751 1752 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end(); 1753 I != E; ++I) { 1754 SmallVectorImpl<const MachineInstr*> &History = I->second; 1755 if (History.empty()) 1756 continue; 1757 1758 // Make sure the final register assignments are terminated. 1759 const MachineInstr *Prev = History.back(); 1760 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) { 1761 const MachineBasicBlock *PrevMBB = Prev->getParent(); 1762 MachineBasicBlock::const_iterator LastMI = 1763 PrevMBB->getLastNonDebugInstr(); 1764 if (LastMI == PrevMBB->end()) 1765 // Drop DBG_VALUE for empty range. 1766 History.pop_back(); 1767 else if (PrevMBB != &PrevMBB->getParent()->back()) { 1768 // Terminate after LastMI. 1769 History.push_back(LastMI); 1770 } 1771 } 1772 // Request labels for the full history. 1773 for (unsigned i = 0, e = History.size(); i != e; ++i) { 1774 const MachineInstr *MI = History[i]; 1775 if (MI->isDebugValue()) 1776 requestLabelBeforeInsn(MI); 1777 else 1778 requestLabelAfterInsn(MI); 1779 } 1780 } 1781 1782 PrevInstLoc = DebugLoc(); 1783 PrevLabel = FunctionBeginSym; 1784 1785 // Record beginning of function. 1786 if (!PrologEndLoc.isUnknown()) { 1787 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc, 1788 MF->getFunction()->getContext()); 1789 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(), 1790 FnStartDL.getScope(MF->getFunction()->getContext()), 1791 // We'd like to list the prologue as "not statements" but GDB behaves 1792 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing. 1793 DWARF2_FLAG_IS_STMT); 1794 } 1795} 1796 1797void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) { 1798 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS]; 1799 DIVariable DV = Var->getVariable(); 1800 // Variables with positive arg numbers are parameters. 1801 if (unsigned ArgNum = DV.getArgNumber()) { 1802 // Keep all parameters in order at the start of the variable list to ensure 1803 // function types are correct (no out-of-order parameters) 1804 // 1805 // This could be improved by only doing it for optimized builds (unoptimized 1806 // builds have the right order to begin with), searching from the back (this 1807 // would catch the unoptimized case quickly), or doing a binary search 1808 // rather than linear search. 1809 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin(); 1810 while (I != Vars.end()) { 1811 unsigned CurNum = (*I)->getVariable().getArgNumber(); 1812 // A local (non-parameter) variable has been found, insert immediately 1813 // before it. 1814 if (CurNum == 0) 1815 break; 1816 // A later indexed parameter has been found, insert immediately before it. 1817 if (CurNum > ArgNum) 1818 break; 1819 ++I; 1820 } 1821 Vars.insert(I, Var); 1822 return; 1823 } 1824 1825 Vars.push_back(Var); 1826} 1827 1828// Gather and emit post-function debug information. 1829void DwarfDebug::endFunction(const MachineFunction *MF) { 1830 if (!MMI->hasDebugInfo() || LScopes.empty()) return; 1831 1832 // Define end label for subprogram. 1833 FunctionEndSym = Asm->GetTempSymbol("func_end", 1834 Asm->getFunctionNumber()); 1835 // Assumes in correct section after the entry point. 1836 Asm->OutStreamer.EmitLabel(FunctionEndSym); 1837 // Set DwarfCompileUnitID in MCContext to default value. 1838 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0); 1839 1840 SmallPtrSet<const MDNode *, 16> ProcessedVars; 1841 collectVariableInfo(MF, ProcessedVars); 1842 1843 LexicalScope *FnScope = LScopes.getCurrentFunctionScope(); 1844 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode()); 1845 assert(TheCU && "Unable to find compile unit!"); 1846 1847 // Construct abstract scopes. 1848 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList(); 1849 for (unsigned i = 0, e = AList.size(); i != e; ++i) { 1850 LexicalScope *AScope = AList[i]; 1851 DISubprogram SP(AScope->getScopeNode()); 1852 if (SP.isSubprogram()) { 1853 // Collect info for variables that were optimized out. 1854 DIArray Variables = SP.getVariables(); 1855 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) { 1856 DIVariable DV(Variables.getElement(i)); 1857 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV)) 1858 continue; 1859 // Check that DbgVariable for DV wasn't created earlier, when 1860 // findAbstractVariable() was called for inlined instance of DV. 1861 LLVMContext &Ctx = DV->getContext(); 1862 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx); 1863 if (AbstractVariables.lookup(CleanDV)) 1864 continue; 1865 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext())) 1866 addScopeVariable(Scope, new DbgVariable(DV, NULL)); 1867 } 1868 } 1869 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0) 1870 constructScopeDIE(TheCU, AScope); 1871 } 1872 1873 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope); 1874 1875 if (!MF->getTarget().Options.DisableFramePointerElim(*MF)) 1876 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr); 1877 1878 // Clear debug info 1879 for (ScopeVariablesMap::iterator 1880 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I) 1881 DeleteContainerPointers(I->second); 1882 ScopeVariables.clear(); 1883 DeleteContainerPointers(CurrentFnArguments); 1884 UserVariables.clear(); 1885 DbgValues.clear(); 1886 AbstractVariables.clear(); 1887 LabelsBeforeInsn.clear(); 1888 LabelsAfterInsn.clear(); 1889 PrevLabel = NULL; 1890} 1891 1892// Register a source line with debug info. Returns the unique label that was 1893// emitted and which provides correspondence to the source line list. 1894void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S, 1895 unsigned Flags) { 1896 StringRef Fn; 1897 StringRef Dir; 1898 unsigned Src = 1; 1899 if (S) { 1900 DIDescriptor Scope(S); 1901 1902 if (Scope.isCompileUnit()) { 1903 DICompileUnit CU(S); 1904 Fn = CU.getFilename(); 1905 Dir = CU.getDirectory(); 1906 } else if (Scope.isFile()) { 1907 DIFile F(S); 1908 Fn = F.getFilename(); 1909 Dir = F.getDirectory(); 1910 } else if (Scope.isSubprogram()) { 1911 DISubprogram SP(S); 1912 Fn = SP.getFilename(); 1913 Dir = SP.getDirectory(); 1914 } else if (Scope.isLexicalBlockFile()) { 1915 DILexicalBlockFile DBF(S); 1916 Fn = DBF.getFilename(); 1917 Dir = DBF.getDirectory(); 1918 } else if (Scope.isLexicalBlock()) { 1919 DILexicalBlock DB(S); 1920 Fn = DB.getFilename(); 1921 Dir = DB.getDirectory(); 1922 } else 1923 llvm_unreachable("Unexpected scope info"); 1924 1925 Src = getOrCreateSourceID(Fn, Dir, 1926 Asm->OutStreamer.getContext().getDwarfCompileUnitID()); 1927 } 1928 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn); 1929} 1930 1931//===----------------------------------------------------------------------===// 1932// Emit Methods 1933//===----------------------------------------------------------------------===// 1934 1935// Compute the size and offset of a DIE. 1936unsigned 1937DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) { 1938 // Get the children. 1939 const std::vector<DIE *> &Children = Die->getChildren(); 1940 1941 // Record the abbreviation. 1942 assignAbbrevNumber(Die->getAbbrev()); 1943 1944 // Get the abbreviation for this DIE. 1945 unsigned AbbrevNumber = Die->getAbbrevNumber(); 1946 const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1); 1947 1948 // Set DIE offset 1949 Die->setOffset(Offset); 1950 1951 // Start the size with the size of abbreviation code. 1952 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber); 1953 1954 const SmallVectorImpl<DIEValue*> &Values = Die->getValues(); 1955 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData(); 1956 1957 // Size the DIE attribute values. 1958 for (unsigned i = 0, N = Values.size(); i < N; ++i) 1959 // Size attribute value. 1960 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm()); 1961 1962 // Size the DIE children if any. 1963 if (!Children.empty()) { 1964 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes && 1965 "Children flag not set"); 1966 1967 for (unsigned j = 0, M = Children.size(); j < M; ++j) 1968 Offset = computeSizeAndOffset(Children[j], Offset); 1969 1970 // End of children marker. 1971 Offset += sizeof(int8_t); 1972 } 1973 1974 Die->setSize(Offset - Die->getOffset()); 1975 return Offset; 1976} 1977 1978// Compute the size and offset of all the DIEs. 1979void DwarfUnits::computeSizeAndOffsets() { 1980 // Offset from the beginning of debug info section. 1981 unsigned SecOffset = 0; 1982 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(), 1983 E = CUs.end(); I != E; ++I) { 1984 (*I)->setDebugInfoOffset(SecOffset); 1985 unsigned Offset = 1986 sizeof(int32_t) + // Length of Compilation Unit Info 1987 sizeof(int16_t) + // DWARF version number 1988 sizeof(int32_t) + // Offset Into Abbrev. Section 1989 sizeof(int8_t); // Pointer Size (in bytes) 1990 1991 unsigned EndOffset = computeSizeAndOffset((*I)->getCUDie(), Offset); 1992 SecOffset += EndOffset; 1993 } 1994} 1995 1996// Emit initial Dwarf sections with a label at the start of each one. 1997void DwarfDebug::emitSectionLabels() { 1998 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); 1999 2000 // Dwarf sections base addresses. 2001 DwarfInfoSectionSym = 2002 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info"); 2003 DwarfAbbrevSectionSym = 2004 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev"); 2005 if (useSplitDwarf()) 2006 DwarfAbbrevDWOSectionSym = 2007 emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(), 2008 "section_abbrev_dwo"); 2009 emitSectionSym(Asm, TLOF.getDwarfARangesSection()); 2010 2011 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection()) 2012 emitSectionSym(Asm, MacroInfo); 2013 2014 DwarfLineSectionSym = 2015 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line"); 2016 emitSectionSym(Asm, TLOF.getDwarfLocSection()); 2017 if (GenerateDwarfPubNamesSection) 2018 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection()); 2019 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection()); 2020 DwarfStrSectionSym = 2021 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string"); 2022 if (useSplitDwarf()) { 2023 DwarfStrDWOSectionSym = 2024 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string"); 2025 DwarfAddrSectionSym = 2026 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec"); 2027 } 2028 DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(), 2029 "debug_range"); 2030 2031 DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(), 2032 "section_debug_loc"); 2033 2034 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin"); 2035 emitSectionSym(Asm, TLOF.getDataSection()); 2036} 2037 2038// Recursively emits a debug information entry. 2039void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) { 2040 // Get the abbreviation for this DIE. 2041 unsigned AbbrevNumber = Die->getAbbrevNumber(); 2042 const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1); 2043 2044 // Emit the code (index) for the abbreviation. 2045 if (Asm->isVerbose()) 2046 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" + 2047 Twine::utohexstr(Die->getOffset()) + ":0x" + 2048 Twine::utohexstr(Die->getSize()) + " " + 2049 dwarf::TagString(Abbrev->getTag())); 2050 Asm->EmitULEB128(AbbrevNumber); 2051 2052 const SmallVectorImpl<DIEValue*> &Values = Die->getValues(); 2053 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData(); 2054 2055 // Emit the DIE attribute values. 2056 for (unsigned i = 0, N = Values.size(); i < N; ++i) { 2057 unsigned Attr = AbbrevData[i].getAttribute(); 2058 unsigned Form = AbbrevData[i].getForm(); 2059 assert(Form && "Too many attributes for DIE (check abbreviation)"); 2060 2061 if (Asm->isVerbose()) 2062 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr)); 2063 2064 switch (Attr) { 2065 case dwarf::DW_AT_abstract_origin: { 2066 DIEEntry *E = cast<DIEEntry>(Values[i]); 2067 DIE *Origin = E->getEntry(); 2068 unsigned Addr = Origin->getOffset(); 2069 if (Form == dwarf::DW_FORM_ref_addr) { 2070 // For DW_FORM_ref_addr, output the offset from beginning of debug info 2071 // section. Origin->getOffset() returns the offset from start of the 2072 // compile unit. 2073 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder; 2074 Addr += Holder.getCUOffset(Origin->getCompileUnit()); 2075 } 2076 Asm->OutStreamer.EmitIntValue(Addr, 2077 Form == dwarf::DW_FORM_ref_addr ? DIEEntry::getRefAddrSize(Asm) : 4); 2078 break; 2079 } 2080 case dwarf::DW_AT_ranges: { 2081 // DW_AT_range Value encodes offset in debug_range section. 2082 DIEInteger *V = cast<DIEInteger>(Values[i]); 2083 2084 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) { 2085 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym, 2086 V->getValue(), 2087 4); 2088 } else { 2089 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym, 2090 V->getValue(), 2091 DwarfDebugRangeSectionSym, 2092 4); 2093 } 2094 break; 2095 } 2096 case dwarf::DW_AT_location: { 2097 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) { 2098 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) 2099 Asm->EmitLabelReference(L->getValue(), 4); 2100 else 2101 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4); 2102 } else { 2103 Values[i]->EmitValue(Asm, Form); 2104 } 2105 break; 2106 } 2107 case dwarf::DW_AT_accessibility: { 2108 if (Asm->isVerbose()) { 2109 DIEInteger *V = cast<DIEInteger>(Values[i]); 2110 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue())); 2111 } 2112 Values[i]->EmitValue(Asm, Form); 2113 break; 2114 } 2115 default: 2116 // Emit an attribute using the defined form. 2117 Values[i]->EmitValue(Asm, Form); 2118 break; 2119 } 2120 } 2121 2122 // Emit the DIE children if any. 2123 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) { 2124 const std::vector<DIE *> &Children = Die->getChildren(); 2125 2126 for (unsigned j = 0, M = Children.size(); j < M; ++j) 2127 emitDIE(Children[j], Abbrevs); 2128 2129 if (Asm->isVerbose()) 2130 Asm->OutStreamer.AddComment("End Of Children Mark"); 2131 Asm->EmitInt8(0); 2132 } 2133} 2134 2135// Emit the various dwarf units to the unit section USection with 2136// the abbreviations going into ASection. 2137void DwarfUnits::emitUnits(DwarfDebug *DD, 2138 const MCSection *USection, 2139 const MCSection *ASection, 2140 const MCSymbol *ASectionSym) { 2141 Asm->OutStreamer.SwitchSection(USection); 2142 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(), 2143 E = CUs.end(); I != E; ++I) { 2144 CompileUnit *TheCU = *I; 2145 DIE *Die = TheCU->getCUDie(); 2146 2147 // Emit the compile units header. 2148 Asm->OutStreamer 2149 .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(), 2150 TheCU->getUniqueID())); 2151 2152 // Emit size of content not including length itself 2153 unsigned ContentSize = Die->getSize() + 2154 sizeof(int16_t) + // DWARF version number 2155 sizeof(int32_t) + // Offset Into Abbrev. Section 2156 sizeof(int8_t); // Pointer Size (in bytes) 2157 2158 Asm->OutStreamer.AddComment("Length of Compilation Unit Info"); 2159 Asm->EmitInt32(ContentSize); 2160 Asm->OutStreamer.AddComment("DWARF version number"); 2161 Asm->EmitInt16(DD->getDwarfVersion()); 2162 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section"); 2163 Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()), 2164 ASectionSym); 2165 Asm->OutStreamer.AddComment("Address Size (in bytes)"); 2166 Asm->EmitInt8(Asm->getDataLayout().getPointerSize()); 2167 2168 DD->emitDIE(Die, Abbreviations); 2169 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(), 2170 TheCU->getUniqueID())); 2171 } 2172} 2173 2174/// For a given compile unit DIE, returns offset from beginning of debug info. 2175unsigned DwarfUnits::getCUOffset(DIE *Die) { 2176 assert(Die->getTag() == dwarf::DW_TAG_compile_unit && 2177 "Input DIE should be compile unit in getCUOffset."); 2178 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(), 2179 E = CUs.end(); I != E; ++I) { 2180 CompileUnit *TheCU = *I; 2181 if (TheCU->getCUDie() == Die) 2182 return TheCU->getDebugInfoOffset(); 2183 } 2184 llvm_unreachable("The compile unit DIE should belong to CUs in DwarfUnits."); 2185} 2186 2187// Emit the debug info section. 2188void DwarfDebug::emitDebugInfo() { 2189 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder; 2190 2191 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(), 2192 Asm->getObjFileLowering().getDwarfAbbrevSection(), 2193 DwarfAbbrevSectionSym); 2194} 2195 2196// Emit the abbreviation section. 2197void DwarfDebug::emitAbbreviations() { 2198 if (!useSplitDwarf()) 2199 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(), 2200 &Abbreviations); 2201 else 2202 emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection()); 2203} 2204 2205void DwarfDebug::emitAbbrevs(const MCSection *Section, 2206 std::vector<DIEAbbrev *> *Abbrevs) { 2207 // Check to see if it is worth the effort. 2208 if (!Abbrevs->empty()) { 2209 // Start the debug abbrev section. 2210 Asm->OutStreamer.SwitchSection(Section); 2211 2212 MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName()); 2213 Asm->OutStreamer.EmitLabel(Begin); 2214 2215 // For each abbrevation. 2216 for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) { 2217 // Get abbreviation data 2218 const DIEAbbrev *Abbrev = Abbrevs->at(i); 2219 2220 // Emit the abbrevations code (base 1 index.) 2221 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code"); 2222 2223 // Emit the abbreviations data. 2224 Abbrev->Emit(Asm); 2225 } 2226 2227 // Mark end of abbreviations. 2228 Asm->EmitULEB128(0, "EOM(3)"); 2229 2230 MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName()); 2231 Asm->OutStreamer.EmitLabel(End); 2232 } 2233} 2234 2235// Emit the last address of the section and the end of the line matrix. 2236void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) { 2237 // Define last address of section. 2238 Asm->OutStreamer.AddComment("Extended Op"); 2239 Asm->EmitInt8(0); 2240 2241 Asm->OutStreamer.AddComment("Op size"); 2242 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1); 2243 Asm->OutStreamer.AddComment("DW_LNE_set_address"); 2244 Asm->EmitInt8(dwarf::DW_LNE_set_address); 2245 2246 Asm->OutStreamer.AddComment("Section end label"); 2247 2248 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd), 2249 Asm->getDataLayout().getPointerSize()); 2250 2251 // Mark end of matrix. 2252 Asm->OutStreamer.AddComment("DW_LNE_end_sequence"); 2253 Asm->EmitInt8(0); 2254 Asm->EmitInt8(1); 2255 Asm->EmitInt8(1); 2256} 2257 2258// Emit visible names into a hashed accelerator table section. 2259void DwarfDebug::emitAccelNames() { 2260 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset, 2261 dwarf::DW_FORM_data4)); 2262 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 2263 E = CUMap.end(); I != E; ++I) { 2264 CompileUnit *TheCU = I->second; 2265 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames(); 2266 for (StringMap<std::vector<DIE*> >::const_iterator 2267 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) { 2268 StringRef Name = GI->getKey(); 2269 const std::vector<DIE *> &Entities = GI->second; 2270 for (std::vector<DIE *>::const_iterator DI = Entities.begin(), 2271 DE = Entities.end(); DI != DE; ++DI) 2272 AT.AddName(Name, (*DI)); 2273 } 2274 } 2275 2276 AT.FinalizeTable(Asm, "Names"); 2277 Asm->OutStreamer.SwitchSection( 2278 Asm->getObjFileLowering().getDwarfAccelNamesSection()); 2279 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin"); 2280 Asm->OutStreamer.EmitLabel(SectionBegin); 2281 2282 // Emit the full data. 2283 AT.Emit(Asm, SectionBegin, &InfoHolder); 2284} 2285 2286// Emit objective C classes and categories into a hashed accelerator table 2287// section. 2288void DwarfDebug::emitAccelObjC() { 2289 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset, 2290 dwarf::DW_FORM_data4)); 2291 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 2292 E = CUMap.end(); I != E; ++I) { 2293 CompileUnit *TheCU = I->second; 2294 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC(); 2295 for (StringMap<std::vector<DIE*> >::const_iterator 2296 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) { 2297 StringRef Name = GI->getKey(); 2298 const std::vector<DIE *> &Entities = GI->second; 2299 for (std::vector<DIE *>::const_iterator DI = Entities.begin(), 2300 DE = Entities.end(); DI != DE; ++DI) 2301 AT.AddName(Name, (*DI)); 2302 } 2303 } 2304 2305 AT.FinalizeTable(Asm, "ObjC"); 2306 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering() 2307 .getDwarfAccelObjCSection()); 2308 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin"); 2309 Asm->OutStreamer.EmitLabel(SectionBegin); 2310 2311 // Emit the full data. 2312 AT.Emit(Asm, SectionBegin, &InfoHolder); 2313} 2314 2315// Emit namespace dies into a hashed accelerator table. 2316void DwarfDebug::emitAccelNamespaces() { 2317 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset, 2318 dwarf::DW_FORM_data4)); 2319 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 2320 E = CUMap.end(); I != E; ++I) { 2321 CompileUnit *TheCU = I->second; 2322 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace(); 2323 for (StringMap<std::vector<DIE*> >::const_iterator 2324 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) { 2325 StringRef Name = GI->getKey(); 2326 const std::vector<DIE *> &Entities = GI->second; 2327 for (std::vector<DIE *>::const_iterator DI = Entities.begin(), 2328 DE = Entities.end(); DI != DE; ++DI) 2329 AT.AddName(Name, (*DI)); 2330 } 2331 } 2332 2333 AT.FinalizeTable(Asm, "namespac"); 2334 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering() 2335 .getDwarfAccelNamespaceSection()); 2336 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin"); 2337 Asm->OutStreamer.EmitLabel(SectionBegin); 2338 2339 // Emit the full data. 2340 AT.Emit(Asm, SectionBegin, &InfoHolder); 2341} 2342 2343// Emit type dies into a hashed accelerator table. 2344void DwarfDebug::emitAccelTypes() { 2345 std::vector<DwarfAccelTable::Atom> Atoms; 2346 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset, 2347 dwarf::DW_FORM_data4)); 2348 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag, 2349 dwarf::DW_FORM_data2)); 2350 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags, 2351 dwarf::DW_FORM_data1)); 2352 DwarfAccelTable AT(Atoms); 2353 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 2354 E = CUMap.end(); I != E; ++I) { 2355 CompileUnit *TheCU = I->second; 2356 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names 2357 = TheCU->getAccelTypes(); 2358 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator 2359 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) { 2360 StringRef Name = GI->getKey(); 2361 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second; 2362 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI 2363 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI) 2364 AT.AddName(Name, (*DI).first, (*DI).second); 2365 } 2366 } 2367 2368 AT.FinalizeTable(Asm, "types"); 2369 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering() 2370 .getDwarfAccelTypesSection()); 2371 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin"); 2372 Asm->OutStreamer.EmitLabel(SectionBegin); 2373 2374 // Emit the full data. 2375 AT.Emit(Asm, SectionBegin, &InfoHolder); 2376} 2377 2378/// emitDebugPubnames - Emit visible names into a debug pubnames section. 2379/// 2380void DwarfDebug::emitDebugPubnames() { 2381 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection(); 2382 2383 typedef DenseMap<const MDNode*, CompileUnit*> CUMapType; 2384 for (CUMapType::iterator I = CUMap.begin(), E = CUMap.end(); I != E; ++I) { 2385 CompileUnit *TheCU = I->second; 2386 unsigned ID = TheCU->getUniqueID(); 2387 2388 if (TheCU->getGlobalNames().empty()) 2389 continue; 2390 2391 // Start the dwarf pubnames section. 2392 Asm->OutStreamer.SwitchSection( 2393 Asm->getObjFileLowering().getDwarfPubNamesSection()); 2394 2395 Asm->OutStreamer.AddComment("Length of Public Names Info"); 2396 Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID), 2397 Asm->GetTempSymbol("pubnames_begin", ID), 4); 2398 2399 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID)); 2400 2401 Asm->OutStreamer.AddComment("DWARF Version"); 2402 Asm->EmitInt16(DwarfVersion); 2403 2404 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info"); 2405 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID), 2406 DwarfInfoSectionSym); 2407 2408 Asm->OutStreamer.AddComment("Compilation Unit Length"); 2409 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID), 2410 Asm->GetTempSymbol(ISec->getLabelBeginName(), ID), 2411 4); 2412 2413 const StringMap<DIE*> &Globals = TheCU->getGlobalNames(); 2414 for (StringMap<DIE*>::const_iterator 2415 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) { 2416 const char *Name = GI->getKeyData(); 2417 const DIE *Entity = GI->second; 2418 2419 Asm->OutStreamer.AddComment("DIE offset"); 2420 Asm->EmitInt32(Entity->getOffset()); 2421 2422 if (Asm->isVerbose()) 2423 Asm->OutStreamer.AddComment("External Name"); 2424 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1)); 2425 } 2426 2427 Asm->OutStreamer.AddComment("End Mark"); 2428 Asm->EmitInt32(0); 2429 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID)); 2430 } 2431} 2432 2433void DwarfDebug::emitDebugPubTypes() { 2434 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 2435 E = CUMap.end(); I != E; ++I) { 2436 CompileUnit *TheCU = I->second; 2437 // Start the dwarf pubtypes section. 2438 Asm->OutStreamer.SwitchSection( 2439 Asm->getObjFileLowering().getDwarfPubTypesSection()); 2440 Asm->OutStreamer.AddComment("Length of Public Types Info"); 2441 Asm->EmitLabelDifference( 2442 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()), 2443 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4); 2444 2445 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin", 2446 TheCU->getUniqueID())); 2447 2448 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version"); 2449 Asm->EmitInt16(DwarfVersion); 2450 2451 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info"); 2452 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection(); 2453 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), 2454 TheCU->getUniqueID()), 2455 DwarfInfoSectionSym); 2456 2457 Asm->OutStreamer.AddComment("Compilation Unit Length"); 2458 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), 2459 TheCU->getUniqueID()), 2460 Asm->GetTempSymbol(ISec->getLabelBeginName(), 2461 TheCU->getUniqueID()), 2462 4); 2463 2464 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes(); 2465 for (StringMap<DIE*>::const_iterator 2466 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) { 2467 const char *Name = GI->getKeyData(); 2468 DIE *Entity = GI->second; 2469 2470 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset"); 2471 Asm->EmitInt32(Entity->getOffset()); 2472 2473 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name"); 2474 // Emit the name with a terminating null byte. 2475 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1)); 2476 } 2477 2478 Asm->OutStreamer.AddComment("End Mark"); 2479 Asm->EmitInt32(0); 2480 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end", 2481 TheCU->getUniqueID())); 2482 } 2483} 2484 2485// Emit strings into a string section. 2486void DwarfUnits::emitStrings(const MCSection *StrSection, 2487 const MCSection *OffsetSection = NULL, 2488 const MCSymbol *StrSecSym = NULL) { 2489 2490 if (StringPool.empty()) return; 2491 2492 // Start the dwarf str section. 2493 Asm->OutStreamer.SwitchSection(StrSection); 2494 2495 // Get all of the string pool entries and put them in an array by their ID so 2496 // we can sort them. 2497 SmallVector<std::pair<unsigned, 2498 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries; 2499 2500 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator 2501 I = StringPool.begin(), E = StringPool.end(); 2502 I != E; ++I) 2503 Entries.push_back(std::make_pair(I->second.second, &*I)); 2504 2505 array_pod_sort(Entries.begin(), Entries.end()); 2506 2507 for (unsigned i = 0, e = Entries.size(); i != e; ++i) { 2508 // Emit a label for reference from debug information entries. 2509 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first); 2510 2511 // Emit the string itself with a terminating null byte. 2512 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(), 2513 Entries[i].second->getKeyLength()+1)); 2514 } 2515 2516 // If we've got an offset section go ahead and emit that now as well. 2517 if (OffsetSection) { 2518 Asm->OutStreamer.SwitchSection(OffsetSection); 2519 unsigned offset = 0; 2520 unsigned size = 4; // FIXME: DWARF64 is 8. 2521 for (unsigned i = 0, e = Entries.size(); i != e; ++i) { 2522 Asm->OutStreamer.EmitIntValue(offset, size); 2523 offset += Entries[i].second->getKeyLength() + 1; 2524 } 2525 } 2526} 2527 2528// Emit strings into a string section. 2529void DwarfUnits::emitAddresses(const MCSection *AddrSection) { 2530 2531 if (AddressPool.empty()) return; 2532 2533 // Start the dwarf addr section. 2534 Asm->OutStreamer.SwitchSection(AddrSection); 2535 2536 // Order the address pool entries by ID 2537 SmallVector<const MCExpr *, 64> Entries(AddressPool.size()); 2538 2539 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(), 2540 E = AddressPool.end(); 2541 I != E; ++I) 2542 Entries[I->second] = I->first; 2543 2544 for (unsigned i = 0, e = Entries.size(); i != e; ++i) { 2545 // Emit an expression for reference from debug information entries. 2546 if (const MCExpr *Expr = Entries[i]) 2547 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize()); 2548 else 2549 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize()); 2550 } 2551 2552} 2553 2554// Emit visible names into a debug str section. 2555void DwarfDebug::emitDebugStr() { 2556 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder; 2557 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection()); 2558} 2559 2560// Emit locations into the debug loc section. 2561void DwarfDebug::emitDebugLoc() { 2562 if (DotDebugLocEntries.empty()) 2563 return; 2564 2565 for (SmallVectorImpl<DotDebugLocEntry>::iterator 2566 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end(); 2567 I != E; ++I) { 2568 DotDebugLocEntry &Entry = *I; 2569 if (I + 1 != DotDebugLocEntries.end()) 2570 Entry.Merge(I+1); 2571 } 2572 2573 // Start the dwarf loc section. 2574 Asm->OutStreamer.SwitchSection( 2575 Asm->getObjFileLowering().getDwarfLocSection()); 2576 unsigned char Size = Asm->getDataLayout().getPointerSize(); 2577 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0)); 2578 unsigned index = 1; 2579 for (SmallVectorImpl<DotDebugLocEntry>::iterator 2580 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end(); 2581 I != E; ++I, ++index) { 2582 DotDebugLocEntry &Entry = *I; 2583 if (Entry.isMerged()) continue; 2584 if (Entry.isEmpty()) { 2585 Asm->OutStreamer.EmitIntValue(0, Size); 2586 Asm->OutStreamer.EmitIntValue(0, Size); 2587 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index)); 2588 } else { 2589 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size); 2590 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size); 2591 DIVariable DV(Entry.getVariable()); 2592 Asm->OutStreamer.AddComment("Loc expr size"); 2593 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol(); 2594 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol(); 2595 Asm->EmitLabelDifference(end, begin, 2); 2596 Asm->OutStreamer.EmitLabel(begin); 2597 if (Entry.isInt()) { 2598 DIBasicType BTy(DV.getType()); 2599 if (BTy.Verify() && 2600 (BTy.getEncoding() == dwarf::DW_ATE_signed 2601 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) { 2602 Asm->OutStreamer.AddComment("DW_OP_consts"); 2603 Asm->EmitInt8(dwarf::DW_OP_consts); 2604 Asm->EmitSLEB128(Entry.getInt()); 2605 } else { 2606 Asm->OutStreamer.AddComment("DW_OP_constu"); 2607 Asm->EmitInt8(dwarf::DW_OP_constu); 2608 Asm->EmitULEB128(Entry.getInt()); 2609 } 2610 } else if (Entry.isLocation()) { 2611 MachineLocation Loc = Entry.getLoc(); 2612 if (!DV.hasComplexAddress()) 2613 // Regular entry. 2614 Asm->EmitDwarfRegOp(Loc, DV.isIndirect()); 2615 else { 2616 // Complex address entry. 2617 unsigned N = DV.getNumAddrElements(); 2618 unsigned i = 0; 2619 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) { 2620 if (Loc.getOffset()) { 2621 i = 2; 2622 Asm->EmitDwarfRegOp(Loc, DV.isIndirect()); 2623 Asm->OutStreamer.AddComment("DW_OP_deref"); 2624 Asm->EmitInt8(dwarf::DW_OP_deref); 2625 Asm->OutStreamer.AddComment("DW_OP_plus_uconst"); 2626 Asm->EmitInt8(dwarf::DW_OP_plus_uconst); 2627 Asm->EmitSLEB128(DV.getAddrElement(1)); 2628 } else { 2629 // If first address element is OpPlus then emit 2630 // DW_OP_breg + Offset instead of DW_OP_reg + Offset. 2631 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1)); 2632 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect()); 2633 i = 2; 2634 } 2635 } else { 2636 Asm->EmitDwarfRegOp(Loc, DV.isIndirect()); 2637 } 2638 2639 // Emit remaining complex address elements. 2640 for (; i < N; ++i) { 2641 uint64_t Element = DV.getAddrElement(i); 2642 if (Element == DIBuilder::OpPlus) { 2643 Asm->EmitInt8(dwarf::DW_OP_plus_uconst); 2644 Asm->EmitULEB128(DV.getAddrElement(++i)); 2645 } else if (Element == DIBuilder::OpDeref) { 2646 if (!Loc.isReg()) 2647 Asm->EmitInt8(dwarf::DW_OP_deref); 2648 } else 2649 llvm_unreachable("unknown Opcode found in complex address"); 2650 } 2651 } 2652 } 2653 // else ... ignore constant fp. There is not any good way to 2654 // to represent them here in dwarf. 2655 Asm->OutStreamer.EmitLabel(end); 2656 } 2657 } 2658} 2659 2660// Emit visible names into a debug aranges section. 2661void DwarfDebug::emitDebugARanges() { 2662 // Start the dwarf aranges section. 2663 Asm->OutStreamer.SwitchSection( 2664 Asm->getObjFileLowering().getDwarfARangesSection()); 2665} 2666 2667// Emit visible names into a debug ranges section. 2668void DwarfDebug::emitDebugRanges() { 2669 // Start the dwarf ranges section. 2670 Asm->OutStreamer.SwitchSection( 2671 Asm->getObjFileLowering().getDwarfRangesSection()); 2672 unsigned char Size = Asm->getDataLayout().getPointerSize(); 2673 for (SmallVectorImpl<const MCSymbol *>::iterator 2674 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end(); 2675 I != E; ++I) { 2676 if (*I) 2677 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size); 2678 else 2679 Asm->OutStreamer.EmitIntValue(0, Size); 2680 } 2681} 2682 2683// Emit visible names into a debug macinfo section. 2684void DwarfDebug::emitDebugMacInfo() { 2685 if (const MCSection *LineInfo = 2686 Asm->getObjFileLowering().getDwarfMacroInfoSection()) { 2687 // Start the dwarf macinfo section. 2688 Asm->OutStreamer.SwitchSection(LineInfo); 2689 } 2690} 2691 2692// Emit inline info using following format. 2693// Section Header: 2694// 1. length of section 2695// 2. Dwarf version number 2696// 3. address size. 2697// 2698// Entries (one "entry" for each function that was inlined): 2699// 2700// 1. offset into __debug_str section for MIPS linkage name, if exists; 2701// otherwise offset into __debug_str for regular function name. 2702// 2. offset into __debug_str section for regular function name. 2703// 3. an unsigned LEB128 number indicating the number of distinct inlining 2704// instances for the function. 2705// 2706// The rest of the entry consists of a {die_offset, low_pc} pair for each 2707// inlined instance; the die_offset points to the inlined_subroutine die in the 2708// __debug_info section, and the low_pc is the starting address for the 2709// inlining instance. 2710void DwarfDebug::emitDebugInlineInfo() { 2711 if (!Asm->MAI->doesDwarfUseInlineInfoSection()) 2712 return; 2713 2714 if (!FirstCU) 2715 return; 2716 2717 Asm->OutStreamer.SwitchSection( 2718 Asm->getObjFileLowering().getDwarfDebugInlineSection()); 2719 2720 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry"); 2721 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1), 2722 Asm->GetTempSymbol("debug_inlined_begin", 1), 4); 2723 2724 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1)); 2725 2726 Asm->OutStreamer.AddComment("Dwarf Version"); 2727 Asm->EmitInt16(DwarfVersion); 2728 Asm->OutStreamer.AddComment("Address Size (in bytes)"); 2729 Asm->EmitInt8(Asm->getDataLayout().getPointerSize()); 2730 2731 for (SmallVectorImpl<const MDNode *>::iterator I = InlinedSPNodes.begin(), 2732 E = InlinedSPNodes.end(); I != E; ++I) { 2733 2734 const MDNode *Node = *I; 2735 InlineInfoMap::iterator II = InlineInfo.find(Node); 2736 SmallVectorImpl<InlineInfoLabels> &Labels = II->second; 2737 DISubprogram SP(Node); 2738 StringRef LName = SP.getLinkageName(); 2739 StringRef Name = SP.getName(); 2740 2741 Asm->OutStreamer.AddComment("MIPS linkage name"); 2742 if (LName.empty()) 2743 Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name), 2744 DwarfStrSectionSym); 2745 else 2746 Asm->EmitSectionOffset( 2747 InfoHolder.getStringPoolEntry(Function::getRealLinkageName(LName)), 2748 DwarfStrSectionSym); 2749 2750 Asm->OutStreamer.AddComment("Function name"); 2751 Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name), 2752 DwarfStrSectionSym); 2753 Asm->EmitULEB128(Labels.size(), "Inline count"); 2754 2755 for (SmallVectorImpl<InlineInfoLabels>::iterator LI = Labels.begin(), 2756 LE = Labels.end(); LI != LE; ++LI) { 2757 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset"); 2758 Asm->EmitInt32(LI->second->getOffset()); 2759 2760 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc"); 2761 Asm->OutStreamer.EmitSymbolValue(LI->first, 2762 Asm->getDataLayout().getPointerSize()); 2763 } 2764 } 2765 2766 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1)); 2767} 2768 2769// DWARF5 Experimental Separate Dwarf emitters. 2770 2771// This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list, 2772// DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id, 2773// DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present, 2774// DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa. 2775CompileUnit *DwarfDebug::constructSkeletonCU(const MDNode *N) { 2776 DICompileUnit DIUnit(N); 2777 CompilationDir = DIUnit.getDirectory(); 2778 2779 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit); 2780 CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++, 2781 DIUnit.getLanguage(), Die, N, Asm, 2782 this, &SkeletonHolder); 2783 2784 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name, 2785 DIUnit.getSplitDebugFilename()); 2786 2787 // This should be a unique identifier when we want to build .dwp files. 2788 NewCU->addUInt(Die, dwarf::DW_AT_GNU_dwo_id, dwarf::DW_FORM_data8, 0); 2789 2790 // Relocate to the beginning of the addr_base section, else 0 for the 2791 // beginning of the one for this compile unit. 2792 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) 2793 NewCU->addLabel(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset, 2794 DwarfAddrSectionSym); 2795 else 2796 NewCU->addUInt(Die, dwarf::DW_AT_GNU_addr_base, 2797 dwarf::DW_FORM_sec_offset, 0); 2798 2799 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point 2800 // into an entity. We're using 0, or a NULL label for this. 2801 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0); 2802 2803 // DW_AT_stmt_list is a offset of line number information for this 2804 // compile unit in debug_line section. 2805 // FIXME: Should handle multiple compile units. 2806 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) 2807 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 2808 DwarfLineSectionSym); 2809 else 2810 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 0); 2811 2812 if (!CompilationDir.empty()) 2813 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir); 2814 2815 SkeletonHolder.addUnit(NewCU); 2816 SkeletonCUs.push_back(NewCU); 2817 2818 return NewCU; 2819} 2820 2821void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) { 2822 assert(useSplitDwarf() && "No split dwarf debug info?"); 2823 emitAbbrevs(Section, &SkeletonAbbrevs); 2824} 2825 2826// Emit the .debug_info.dwo section for separated dwarf. This contains the 2827// compile units that would normally be in debug_info. 2828void DwarfDebug::emitDebugInfoDWO() { 2829 assert(useSplitDwarf() && "No split dwarf debug info?"); 2830 InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(), 2831 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(), 2832 DwarfAbbrevDWOSectionSym); 2833} 2834 2835// Emit the .debug_abbrev.dwo section for separated dwarf. This contains the 2836// abbreviations for the .debug_info.dwo section. 2837void DwarfDebug::emitDebugAbbrevDWO() { 2838 assert(useSplitDwarf() && "No split dwarf?"); 2839 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(), 2840 &Abbreviations); 2841} 2842 2843// Emit the .debug_str.dwo section for separated dwarf. This contains the 2844// string section and is identical in format to traditional .debug_str 2845// sections. 2846void DwarfDebug::emitDebugStrDWO() { 2847 assert(useSplitDwarf() && "No split dwarf?"); 2848 const MCSection *OffSec = Asm->getObjFileLowering() 2849 .getDwarfStrOffDWOSection(); 2850 const MCSymbol *StrSym = DwarfStrSectionSym; 2851 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(), 2852 OffSec, StrSym); 2853} 2854