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