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