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