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