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