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