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