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