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