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