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