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