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