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