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" 47 using namespace llvm; 48 49 static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print", 50 cl::Hidden, 51 cl::desc("Disable debug info printing")); 52 53 static 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 57 static cl::opt<bool> GenerateDwarfPubNamesSection("generate-dwarf-pubnames", 58 cl::Hidden, cl::ZeroOrMore, cl::init(false), 59 cl::desc("Generate DWARF pubnames section")); 60 61 namespace { 62 enum DefaultOnOff { 63 Default, Enable, Disable 64 }; 65 } 66 67 static 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 76 static 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 85 static 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 94 namespace { 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 // 103 static const unsigned InitAbbreviationsSetSize = 9; // log2(512) 104 105 namespace llvm { 106 107 DIType 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 159 DwarfDebug::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 } 205 DwarfDebug::~DwarfDebug() { 206 } 207 208 // Switch to the specified MCSection and emit an assembler 209 // temporary label to it if SymbolStem is specified. 210 static 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 220 MCSymbol *DwarfUnits::getStringPoolSym() { 221 return Asm->GetTempSymbol(StringPref); 222 } 223 224 MCSymbol *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 233 unsigned 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 243 unsigned 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 // 254 void 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. 278 static 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 285 static bool isObjCClass(StringRef Name) { 286 return Name.startswith("+") || Name.startswith("-"); 287 } 288 289 static 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 300 static 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 313 static 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. 318 static 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. 345 DIE *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. 423 DIE *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. 467 DIE *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. 548 DIE *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. 625 unsigned 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. 665 CompileUnit *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 if (useSplitDwarf()) { 725 // This should be a unique identifier when we want to build .dwp files. 726 NewCU->addUInt(Die, dwarf::DW_AT_GNU_dwo_id, dwarf::DW_FORM_data8, 0); 727 // Now construct the skeleton CU associated. 728 constructSkeletonCU(N); 729 } 730 731 InfoHolder.addUnit(NewCU); 732 733 CUMap.insert(std::make_pair(N, NewCU)); 734 return NewCU; 735 } 736 737 // Construct subprogram DIE. 738 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU, 739 const MDNode *N) { 740 CompileUnit *&CURef = SPMap[N]; 741 if (CURef) 742 return; 743 CURef = TheCU; 744 745 DISubprogram SP(N); 746 if (!SP.isDefinition()) 747 // This is a method declaration which will be handled while constructing 748 // class type. 749 return; 750 751 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP); 752 753 // Add to map. 754 TheCU->insertDIE(N, SubprogramDie); 755 756 // Add to context owner. 757 TheCU->addToContextOwner(SubprogramDie, SP.getContext()); 758 759 // Expose as global, if requested. 760 if (GenerateDwarfPubNamesSection) 761 TheCU->addGlobalName(SP.getName(), SubprogramDie); 762 } 763 764 // Emit all Dwarf sections that should come prior to the content. Create 765 // global DIEs and emit initial debug info sections. This is invoked by 766 // the target AsmPrinter. 767 void DwarfDebug::beginModule() { 768 if (DisableDebugInfoPrinting) 769 return; 770 771 const Module *M = MMI->getModule(); 772 773 // If module has named metadata anchors then use them, otherwise scan the 774 // module using debug info finder to collect debug info. 775 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu"); 776 if (!CU_Nodes) 777 return; 778 779 // Emit initial sections so we can reference labels later. 780 emitSectionLabels(); 781 782 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) { 783 DICompileUnit CUNode(CU_Nodes->getOperand(i)); 784 CompileUnit *CU = constructCompileUnit(CUNode); 785 DIArray GVs = CUNode.getGlobalVariables(); 786 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i) 787 CU->createGlobalVariableDIE(GVs.getElement(i)); 788 DIArray SPs = CUNode.getSubprograms(); 789 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i) 790 constructSubprogramDIE(CU, SPs.getElement(i)); 791 DIArray EnumTypes = CUNode.getEnumTypes(); 792 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i) 793 CU->getOrCreateTypeDIE(EnumTypes.getElement(i)); 794 DIArray RetainedTypes = CUNode.getRetainedTypes(); 795 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i) 796 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i)); 797 } 798 799 // Tell MMI that we have debug info. 800 MMI->setDebugInfoAvailability(true); 801 802 // Prime section data. 803 SectionMap.insert(Asm->getObjFileLowering().getTextSection()); 804 } 805 806 // Attach DW_AT_inline attribute with inlined subprogram DIEs. 807 void DwarfDebug::computeInlinedDIEs() { 808 // Attach DW_AT_inline attribute with inlined subprogram DIEs. 809 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(), 810 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) { 811 DIE *ISP = *AI; 812 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined); 813 } 814 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(), 815 AE = AbstractSPDies.end(); AI != AE; ++AI) { 816 DIE *ISP = AI->second; 817 if (InlinedSubprogramDIEs.count(ISP)) 818 continue; 819 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined); 820 } 821 } 822 823 // Collect info for variables that were optimized out. 824 void DwarfDebug::collectDeadVariables() { 825 const Module *M = MMI->getModule(); 826 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap; 827 828 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) { 829 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) { 830 DICompileUnit TheCU(CU_Nodes->getOperand(i)); 831 DIArray Subprograms = TheCU.getSubprograms(); 832 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) { 833 DISubprogram SP(Subprograms.getElement(i)); 834 if (ProcessedSPNodes.count(SP) != 0) continue; 835 if (!SP.Verify()) continue; 836 if (!SP.isDefinition()) continue; 837 DIArray Variables = SP.getVariables(); 838 if (Variables.getNumElements() == 0) continue; 839 840 LexicalScope *Scope = 841 new LexicalScope(NULL, DIDescriptor(SP), NULL, false); 842 DeadFnScopeMap[SP] = Scope; 843 844 // Construct subprogram DIE and add variables DIEs. 845 CompileUnit *SPCU = CUMap.lookup(TheCU); 846 assert(SPCU && "Unable to find Compile Unit!"); 847 constructSubprogramDIE(SPCU, SP); 848 DIE *ScopeDIE = SPCU->getDIE(SP); 849 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) { 850 DIVariable DV(Variables.getElement(vi)); 851 if (!DV.Verify()) continue; 852 DbgVariable *NewVar = new DbgVariable(DV, NULL); 853 if (DIE *VariableDIE = 854 SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope())) 855 ScopeDIE->addChild(VariableDIE); 856 } 857 } 858 } 859 } 860 DeleteContainerSeconds(DeadFnScopeMap); 861 } 862 863 void DwarfDebug::finalizeModuleInfo() { 864 // Collect info for variables that were optimized out. 865 collectDeadVariables(); 866 867 // Attach DW_AT_inline attribute with inlined subprogram DIEs. 868 computeInlinedDIEs(); 869 870 // Emit DW_AT_containing_type attribute to connect types with their 871 // vtable holding type. 872 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(), 873 CUE = CUMap.end(); CUI != CUE; ++CUI) { 874 CompileUnit *TheCU = CUI->second; 875 TheCU->constructContainingTypeDIEs(); 876 } 877 878 // Compute DIE offsets and sizes. 879 InfoHolder.computeSizeAndOffsets(); 880 if (useSplitDwarf()) 881 SkeletonHolder.computeSizeAndOffsets(); 882 } 883 884 void DwarfDebug::endSections() { 885 // Standard sections final addresses. 886 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection()); 887 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end")); 888 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection()); 889 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end")); 890 891 // End text sections. 892 for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) { 893 Asm->OutStreamer.SwitchSection(SectionMap[I]); 894 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1)); 895 } 896 } 897 898 // Emit all Dwarf sections that should come after the content. 899 void DwarfDebug::endModule() { 900 901 if (!FirstCU) return; 902 903 // End any existing sections. 904 // TODO: Does this need to happen? 905 endSections(); 906 907 // Finalize the debug info for the module. 908 finalizeModuleInfo(); 909 910 if (!useSplitDwarf()) { 911 // Emit all the DIEs into a debug info section. 912 emitDebugInfo(); 913 914 // Corresponding abbreviations into a abbrev section. 915 emitAbbreviations(); 916 917 // Emit info into a debug loc section. 918 emitDebugLoc(); 919 920 // Emit info into a debug aranges section. 921 emitDebugARanges(); 922 923 // Emit info into a debug ranges section. 924 emitDebugRanges(); 925 926 // Emit info into a debug macinfo section. 927 emitDebugMacInfo(); 928 929 // Emit inline info. 930 // TODO: When we don't need the option anymore we 931 // can remove all of the code that this section 932 // depends upon. 933 if (useDarwinGDBCompat()) 934 emitDebugInlineInfo(); 935 } else { 936 // TODO: Fill this in for separated debug sections and separate 937 // out information into new sections. 938 939 // Emit the debug info section and compile units. 940 emitDebugInfo(); 941 emitDebugInfoDWO(); 942 943 // Corresponding abbreviations into a abbrev section. 944 emitAbbreviations(); 945 emitDebugAbbrevDWO(); 946 947 // Emit info into a debug loc section. 948 emitDebugLoc(); 949 950 // Emit info into a debug aranges section. 951 emitDebugARanges(); 952 953 // Emit info into a debug ranges section. 954 emitDebugRanges(); 955 956 // Emit info into a debug macinfo section. 957 emitDebugMacInfo(); 958 959 // Emit DWO addresses. 960 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection()); 961 962 // Emit inline info. 963 // TODO: When we don't need the option anymore we 964 // can remove all of the code that this section 965 // depends upon. 966 if (useDarwinGDBCompat()) 967 emitDebugInlineInfo(); 968 } 969 970 // Emit info into the dwarf accelerator table sections. 971 if (useDwarfAccelTables()) { 972 emitAccelNames(); 973 emitAccelObjC(); 974 emitAccelNamespaces(); 975 emitAccelTypes(); 976 } 977 978 // Emit info into a debug pubnames section, if requested. 979 if (GenerateDwarfPubNamesSection) 980 emitDebugPubnames(); 981 982 // Emit info into a debug pubtypes section. 983 // TODO: When we don't need the option anymore we can 984 // remove all of the code that adds to the table. 985 if (useDarwinGDBCompat()) 986 emitDebugPubTypes(); 987 988 // Finally emit string information into a string table. 989 emitDebugStr(); 990 if (useSplitDwarf()) 991 emitDebugStrDWO(); 992 993 // clean up. 994 SPMap.clear(); 995 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 996 E = CUMap.end(); I != E; ++I) 997 delete I->second; 998 999 for (SmallVector<CompileUnit *, 1>::iterator I = SkeletonCUs.begin(), 1000 E = SkeletonCUs.end(); I != E; ++I) 1001 delete *I; 1002 1003 // Reset these for the next Module if we have one. 1004 FirstCU = NULL; 1005 } 1006 1007 // Find abstract variable, if any, associated with Var. 1008 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV, 1009 DebugLoc ScopeLoc) { 1010 LLVMContext &Ctx = DV->getContext(); 1011 // More then one inlined variable corresponds to one abstract variable. 1012 DIVariable Var = cleanseInlinedVariable(DV, Ctx); 1013 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var); 1014 if (AbsDbgVariable) 1015 return AbsDbgVariable; 1016 1017 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx)); 1018 if (!Scope) 1019 return NULL; 1020 1021 AbsDbgVariable = new DbgVariable(Var, NULL); 1022 addScopeVariable(Scope, AbsDbgVariable); 1023 AbstractVariables[Var] = AbsDbgVariable; 1024 return AbsDbgVariable; 1025 } 1026 1027 // If Var is a current function argument then add it to CurrentFnArguments list. 1028 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF, 1029 DbgVariable *Var, LexicalScope *Scope) { 1030 if (!LScopes.isCurrentFunctionScope(Scope)) 1031 return false; 1032 DIVariable DV = Var->getVariable(); 1033 if (DV.getTag() != dwarf::DW_TAG_arg_variable) 1034 return false; 1035 unsigned ArgNo = DV.getArgNumber(); 1036 if (ArgNo == 0) 1037 return false; 1038 1039 size_t Size = CurrentFnArguments.size(); 1040 if (Size == 0) 1041 CurrentFnArguments.resize(MF->getFunction()->arg_size()); 1042 // llvm::Function argument size is not good indicator of how many 1043 // arguments does the function have at source level. 1044 if (ArgNo > Size) 1045 CurrentFnArguments.resize(ArgNo * 2); 1046 CurrentFnArguments[ArgNo - 1] = Var; 1047 return true; 1048 } 1049 1050 // Collect variable information from side table maintained by MMI. 1051 void 1052 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF, 1053 SmallPtrSet<const MDNode *, 16> &Processed) { 1054 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo(); 1055 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(), 1056 VE = VMap.end(); VI != VE; ++VI) { 1057 const MDNode *Var = VI->first; 1058 if (!Var) continue; 1059 Processed.insert(Var); 1060 DIVariable DV(Var); 1061 const std::pair<unsigned, DebugLoc> &VP = VI->second; 1062 1063 LexicalScope *Scope = LScopes.findLexicalScope(VP.second); 1064 1065 // If variable scope is not found then skip this variable. 1066 if (Scope == 0) 1067 continue; 1068 1069 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second); 1070 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable); 1071 RegVar->setFrameIndex(VP.first); 1072 if (!addCurrentFnArgument(MF, RegVar, Scope)) 1073 addScopeVariable(Scope, RegVar); 1074 if (AbsDbgVariable) 1075 AbsDbgVariable->setFrameIndex(VP.first); 1076 } 1077 } 1078 1079 // Return true if debug value, encoded by DBG_VALUE instruction, is in a 1080 // defined reg. 1081 static bool isDbgValueInDefinedReg(const MachineInstr *MI) { 1082 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!"); 1083 return MI->getNumOperands() == 3 && 1084 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() && 1085 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0; 1086 } 1087 1088 // Get .debug_loc entry for the instruction range starting at MI. 1089 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm, 1090 const MCSymbol *FLabel, 1091 const MCSymbol *SLabel, 1092 const MachineInstr *MI) { 1093 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata(); 1094 1095 if (MI->getNumOperands() != 3) { 1096 MachineLocation MLoc = Asm->getDebugValueLocation(MI); 1097 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var); 1098 } 1099 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) { 1100 MachineLocation MLoc; 1101 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm()); 1102 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var); 1103 } 1104 if (MI->getOperand(0).isImm()) 1105 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm()); 1106 if (MI->getOperand(0).isFPImm()) 1107 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm()); 1108 if (MI->getOperand(0).isCImm()) 1109 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm()); 1110 1111 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!"); 1112 } 1113 1114 // Find variables for each lexical scope. 1115 void 1116 DwarfDebug::collectVariableInfo(const MachineFunction *MF, 1117 SmallPtrSet<const MDNode *, 16> &Processed) { 1118 1119 // collection info from MMI table. 1120 collectVariableInfoFromMMITable(MF, Processed); 1121 1122 for (SmallVectorImpl<const MDNode*>::const_iterator 1123 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE; 1124 ++UVI) { 1125 const MDNode *Var = *UVI; 1126 if (Processed.count(Var)) 1127 continue; 1128 1129 // History contains relevant DBG_VALUE instructions for Var and instructions 1130 // clobbering it. 1131 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var]; 1132 if (History.empty()) 1133 continue; 1134 const MachineInstr *MInsn = History.front(); 1135 1136 DIVariable DV(Var); 1137 LexicalScope *Scope = NULL; 1138 if (DV.getTag() == dwarf::DW_TAG_arg_variable && 1139 DISubprogram(DV.getContext()).describes(MF->getFunction())) 1140 Scope = LScopes.getCurrentFunctionScope(); 1141 else if (MDNode *IA = DV.getInlinedAt()) 1142 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA)); 1143 else 1144 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1))); 1145 // If variable scope is not found then skip this variable. 1146 if (!Scope) 1147 continue; 1148 1149 Processed.insert(DV); 1150 assert(MInsn->isDebugValue() && "History must begin with debug value"); 1151 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc()); 1152 DbgVariable *RegVar = new DbgVariable(DV, AbsVar); 1153 if (!addCurrentFnArgument(MF, RegVar, Scope)) 1154 addScopeVariable(Scope, RegVar); 1155 if (AbsVar) 1156 AbsVar->setMInsn(MInsn); 1157 1158 // Simplify ranges that are fully coalesced. 1159 if (History.size() <= 1 || (History.size() == 2 && 1160 MInsn->isIdenticalTo(History.back()))) { 1161 RegVar->setMInsn(MInsn); 1162 continue; 1163 } 1164 1165 // Handle multiple DBG_VALUE instructions describing one variable. 1166 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size()); 1167 1168 for (SmallVectorImpl<const MachineInstr*>::const_iterator 1169 HI = History.begin(), HE = History.end(); HI != HE; ++HI) { 1170 const MachineInstr *Begin = *HI; 1171 assert(Begin->isDebugValue() && "Invalid History entry"); 1172 1173 // Check if DBG_VALUE is truncating a range. 1174 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() 1175 && !Begin->getOperand(0).getReg()) 1176 continue; 1177 1178 // Compute the range for a register location. 1179 const MCSymbol *FLabel = getLabelBeforeInsn(Begin); 1180 const MCSymbol *SLabel = 0; 1181 1182 if (HI + 1 == HE) 1183 // If Begin is the last instruction in History then its value is valid 1184 // until the end of the function. 1185 SLabel = FunctionEndSym; 1186 else { 1187 const MachineInstr *End = HI[1]; 1188 DEBUG(dbgs() << "DotDebugLoc Pair:\n" 1189 << "\t" << *Begin << "\t" << *End << "\n"); 1190 if (End->isDebugValue()) 1191 SLabel = getLabelBeforeInsn(End); 1192 else { 1193 // End is a normal instruction clobbering the range. 1194 SLabel = getLabelAfterInsn(End); 1195 assert(SLabel && "Forgot label after clobber instruction"); 1196 ++HI; 1197 } 1198 } 1199 1200 // The value is valid until the next DBG_VALUE or clobber. 1201 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel, 1202 Begin)); 1203 } 1204 DotDebugLocEntries.push_back(DotDebugLocEntry()); 1205 } 1206 1207 // Collect info for variables that were optimized out. 1208 LexicalScope *FnScope = LScopes.getCurrentFunctionScope(); 1209 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables(); 1210 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) { 1211 DIVariable DV(Variables.getElement(i)); 1212 if (!DV || !DV.Verify() || !Processed.insert(DV)) 1213 continue; 1214 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext())) 1215 addScopeVariable(Scope, new DbgVariable(DV, NULL)); 1216 } 1217 } 1218 1219 // Return Label preceding the instruction. 1220 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) { 1221 MCSymbol *Label = LabelsBeforeInsn.lookup(MI); 1222 assert(Label && "Didn't insert label before instruction"); 1223 return Label; 1224 } 1225 1226 // Return Label immediately following the instruction. 1227 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) { 1228 return LabelsAfterInsn.lookup(MI); 1229 } 1230 1231 // Process beginning of an instruction. 1232 void DwarfDebug::beginInstruction(const MachineInstr *MI) { 1233 // Check if source location changes, but ignore DBG_VALUE locations. 1234 if (!MI->isDebugValue()) { 1235 DebugLoc DL = MI->getDebugLoc(); 1236 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) { 1237 unsigned Flags = 0; 1238 PrevInstLoc = DL; 1239 if (DL == PrologEndLoc) { 1240 Flags |= DWARF2_FLAG_PROLOGUE_END; 1241 PrologEndLoc = DebugLoc(); 1242 } 1243 if (PrologEndLoc.isUnknown()) 1244 Flags |= DWARF2_FLAG_IS_STMT; 1245 1246 if (!DL.isUnknown()) { 1247 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext()); 1248 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags); 1249 } else 1250 recordSourceLine(0, 0, 0, 0); 1251 } 1252 } 1253 1254 // Insert labels where requested. 1255 DenseMap<const MachineInstr*, MCSymbol*>::iterator I = 1256 LabelsBeforeInsn.find(MI); 1257 1258 // No label needed. 1259 if (I == LabelsBeforeInsn.end()) 1260 return; 1261 1262 // Label already assigned. 1263 if (I->second) 1264 return; 1265 1266 if (!PrevLabel) { 1267 PrevLabel = MMI->getContext().CreateTempSymbol(); 1268 Asm->OutStreamer.EmitLabel(PrevLabel); 1269 } 1270 I->second = PrevLabel; 1271 } 1272 1273 // Process end of an instruction. 1274 void DwarfDebug::endInstruction(const MachineInstr *MI) { 1275 // Don't create a new label after DBG_VALUE instructions. 1276 // They don't generate code. 1277 if (!MI->isDebugValue()) 1278 PrevLabel = 0; 1279 1280 DenseMap<const MachineInstr*, MCSymbol*>::iterator I = 1281 LabelsAfterInsn.find(MI); 1282 1283 // No label needed. 1284 if (I == LabelsAfterInsn.end()) 1285 return; 1286 1287 // Label already assigned. 1288 if (I->second) 1289 return; 1290 1291 // We need a label after this instruction. 1292 if (!PrevLabel) { 1293 PrevLabel = MMI->getContext().CreateTempSymbol(); 1294 Asm->OutStreamer.EmitLabel(PrevLabel); 1295 } 1296 I->second = PrevLabel; 1297 } 1298 1299 // Each LexicalScope has first instruction and last instruction to mark 1300 // beginning and end of a scope respectively. Create an inverse map that list 1301 // scopes starts (and ends) with an instruction. One instruction may start (or 1302 // end) multiple scopes. Ignore scopes that are not reachable. 1303 void DwarfDebug::identifyScopeMarkers() { 1304 SmallVector<LexicalScope *, 4> WorkList; 1305 WorkList.push_back(LScopes.getCurrentFunctionScope()); 1306 while (!WorkList.empty()) { 1307 LexicalScope *S = WorkList.pop_back_val(); 1308 1309 const SmallVector<LexicalScope *, 4> &Children = S->getChildren(); 1310 if (!Children.empty()) 1311 for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(), 1312 SE = Children.end(); SI != SE; ++SI) 1313 WorkList.push_back(*SI); 1314 1315 if (S->isAbstractScope()) 1316 continue; 1317 1318 const SmallVector<InsnRange, 4> &Ranges = S->getRanges(); 1319 if (Ranges.empty()) 1320 continue; 1321 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(), 1322 RE = Ranges.end(); RI != RE; ++RI) { 1323 assert(RI->first && "InsnRange does not have first instruction!"); 1324 assert(RI->second && "InsnRange does not have second instruction!"); 1325 requestLabelBeforeInsn(RI->first); 1326 requestLabelAfterInsn(RI->second); 1327 } 1328 } 1329 } 1330 1331 // Get MDNode for DebugLoc's scope. 1332 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) { 1333 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx)) 1334 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx); 1335 return DL.getScope(Ctx); 1336 } 1337 1338 // Walk up the scope chain of given debug loc and find line number info 1339 // for the function. 1340 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) { 1341 const MDNode *Scope = getScopeNode(DL, Ctx); 1342 DISubprogram SP = getDISubprogram(Scope); 1343 if (SP.Verify()) { 1344 // Check for number of operands since the compatibility is 1345 // cheap here. 1346 if (SP->getNumOperands() > 19) 1347 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP); 1348 else 1349 return DebugLoc::get(SP.getLineNumber(), 0, SP); 1350 } 1351 1352 return DebugLoc(); 1353 } 1354 1355 // Gather pre-function debug information. Assumes being called immediately 1356 // after the function entry point has been emitted. 1357 void DwarfDebug::beginFunction(const MachineFunction *MF) { 1358 if (!MMI->hasDebugInfo()) return; 1359 LScopes.initialize(*MF); 1360 if (LScopes.empty()) return; 1361 identifyScopeMarkers(); 1362 1363 // Set DwarfCompileUnitID in MCContext to the Compile Unit this function 1364 // belongs to. 1365 LexicalScope *FnScope = LScopes.getCurrentFunctionScope(); 1366 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode()); 1367 assert(TheCU && "Unable to find compile unit!"); 1368 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID()); 1369 1370 FunctionBeginSym = Asm->GetTempSymbol("func_begin", 1371 Asm->getFunctionNumber()); 1372 // Assumes in correct section after the entry point. 1373 Asm->OutStreamer.EmitLabel(FunctionBeginSym); 1374 1375 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned"); 1376 1377 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo(); 1378 // LiveUserVar - Map physreg numbers to the MDNode they contain. 1379 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs()); 1380 1381 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); 1382 I != E; ++I) { 1383 bool AtBlockEntry = true; 1384 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 1385 II != IE; ++II) { 1386 const MachineInstr *MI = II; 1387 1388 if (MI->isDebugValue()) { 1389 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!"); 1390 1391 // Keep track of user variables. 1392 const MDNode *Var = 1393 MI->getOperand(MI->getNumOperands() - 1).getMetadata(); 1394 1395 // Variable is in a register, we need to check for clobbers. 1396 if (isDbgValueInDefinedReg(MI)) 1397 LiveUserVar[MI->getOperand(0).getReg()] = Var; 1398 1399 // Check the history of this variable. 1400 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var]; 1401 if (History.empty()) { 1402 UserVariables.push_back(Var); 1403 // The first mention of a function argument gets the FunctionBeginSym 1404 // label, so arguments are visible when breaking at function entry. 1405 DIVariable DV(Var); 1406 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable && 1407 DISubprogram(getDISubprogram(DV.getContext())) 1408 .describes(MF->getFunction())) 1409 LabelsBeforeInsn[MI] = FunctionBeginSym; 1410 } else { 1411 // We have seen this variable before. Try to coalesce DBG_VALUEs. 1412 const MachineInstr *Prev = History.back(); 1413 if (Prev->isDebugValue()) { 1414 // Coalesce identical entries at the end of History. 1415 if (History.size() >= 2 && 1416 Prev->isIdenticalTo(History[History.size() - 2])) { 1417 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n" 1418 << "\t" << *Prev 1419 << "\t" << *History[History.size() - 2] << "\n"); 1420 History.pop_back(); 1421 } 1422 1423 // Terminate old register assignments that don't reach MI; 1424 MachineFunction::const_iterator PrevMBB = Prev->getParent(); 1425 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) && 1426 isDbgValueInDefinedReg(Prev)) { 1427 // Previous register assignment needs to terminate at the end of 1428 // its basic block. 1429 MachineBasicBlock::const_iterator LastMI = 1430 PrevMBB->getLastNonDebugInstr(); 1431 if (LastMI == PrevMBB->end()) { 1432 // Drop DBG_VALUE for empty range. 1433 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n" 1434 << "\t" << *Prev << "\n"); 1435 History.pop_back(); 1436 } 1437 else { 1438 // Terminate after LastMI. 1439 History.push_back(LastMI); 1440 } 1441 } 1442 } 1443 } 1444 History.push_back(MI); 1445 } else { 1446 // Not a DBG_VALUE instruction. 1447 if (!MI->isLabel()) 1448 AtBlockEntry = false; 1449 1450 // First known non-DBG_VALUE and non-frame setup location marks 1451 // the beginning of the function body. 1452 if (!MI->getFlag(MachineInstr::FrameSetup) && 1453 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown())) 1454 PrologEndLoc = MI->getDebugLoc(); 1455 1456 // Check if the instruction clobbers any registers with debug vars. 1457 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(), 1458 MOE = MI->operands_end(); MOI != MOE; ++MOI) { 1459 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg()) 1460 continue; 1461 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true); 1462 AI.isValid(); ++AI) { 1463 unsigned Reg = *AI; 1464 const MDNode *Var = LiveUserVar[Reg]; 1465 if (!Var) 1466 continue; 1467 // Reg is now clobbered. 1468 LiveUserVar[Reg] = 0; 1469 1470 // Was MD last defined by a DBG_VALUE referring to Reg? 1471 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var); 1472 if (HistI == DbgValues.end()) 1473 continue; 1474 SmallVectorImpl<const MachineInstr*> &History = HistI->second; 1475 if (History.empty()) 1476 continue; 1477 const MachineInstr *Prev = History.back(); 1478 // Sanity-check: Register assignments are terminated at the end of 1479 // their block. 1480 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent()) 1481 continue; 1482 // Is the variable still in Reg? 1483 if (!isDbgValueInDefinedReg(Prev) || 1484 Prev->getOperand(0).getReg() != Reg) 1485 continue; 1486 // Var is clobbered. Make sure the next instruction gets a label. 1487 History.push_back(MI); 1488 } 1489 } 1490 } 1491 } 1492 } 1493 1494 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end(); 1495 I != E; ++I) { 1496 SmallVectorImpl<const MachineInstr*> &History = I->second; 1497 if (History.empty()) 1498 continue; 1499 1500 // Make sure the final register assignments are terminated. 1501 const MachineInstr *Prev = History.back(); 1502 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) { 1503 const MachineBasicBlock *PrevMBB = Prev->getParent(); 1504 MachineBasicBlock::const_iterator LastMI = 1505 PrevMBB->getLastNonDebugInstr(); 1506 if (LastMI == PrevMBB->end()) 1507 // Drop DBG_VALUE for empty range. 1508 History.pop_back(); 1509 else { 1510 // Terminate after LastMI. 1511 History.push_back(LastMI); 1512 } 1513 } 1514 // Request labels for the full history. 1515 for (unsigned i = 0, e = History.size(); i != e; ++i) { 1516 const MachineInstr *MI = History[i]; 1517 if (MI->isDebugValue()) 1518 requestLabelBeforeInsn(MI); 1519 else 1520 requestLabelAfterInsn(MI); 1521 } 1522 } 1523 1524 PrevInstLoc = DebugLoc(); 1525 PrevLabel = FunctionBeginSym; 1526 1527 // Record beginning of function. 1528 if (!PrologEndLoc.isUnknown()) { 1529 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc, 1530 MF->getFunction()->getContext()); 1531 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(), 1532 FnStartDL.getScope(MF->getFunction()->getContext()), 1533 // We'd like to list the prologue as "not statements" but GDB behaves 1534 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing. 1535 DWARF2_FLAG_IS_STMT); 1536 } 1537 } 1538 1539 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) { 1540 // SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS); 1541 ScopeVariables[LS].push_back(Var); 1542 // Vars.push_back(Var); 1543 } 1544 1545 // Gather and emit post-function debug information. 1546 void DwarfDebug::endFunction(const MachineFunction *MF) { 1547 if (!MMI->hasDebugInfo() || LScopes.empty()) return; 1548 1549 // Define end label for subprogram. 1550 FunctionEndSym = Asm->GetTempSymbol("func_end", 1551 Asm->getFunctionNumber()); 1552 // Assumes in correct section after the entry point. 1553 Asm->OutStreamer.EmitLabel(FunctionEndSym); 1554 // Set DwarfCompileUnitID in MCContext to default value. 1555 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0); 1556 1557 SmallPtrSet<const MDNode *, 16> ProcessedVars; 1558 collectVariableInfo(MF, ProcessedVars); 1559 1560 LexicalScope *FnScope = LScopes.getCurrentFunctionScope(); 1561 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode()); 1562 assert(TheCU && "Unable to find compile unit!"); 1563 1564 // Construct abstract scopes. 1565 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList(); 1566 for (unsigned i = 0, e = AList.size(); i != e; ++i) { 1567 LexicalScope *AScope = AList[i]; 1568 DISubprogram SP(AScope->getScopeNode()); 1569 if (SP.Verify()) { 1570 // Collect info for variables that were optimized out. 1571 DIArray Variables = SP.getVariables(); 1572 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) { 1573 DIVariable DV(Variables.getElement(i)); 1574 if (!DV || !DV.Verify() || !ProcessedVars.insert(DV)) 1575 continue; 1576 // Check that DbgVariable for DV wasn't created earlier, when 1577 // findAbstractVariable() was called for inlined instance of DV. 1578 LLVMContext &Ctx = DV->getContext(); 1579 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx); 1580 if (AbstractVariables.lookup(CleanDV)) 1581 continue; 1582 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext())) 1583 addScopeVariable(Scope, new DbgVariable(DV, NULL)); 1584 } 1585 } 1586 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0) 1587 constructScopeDIE(TheCU, AScope); 1588 } 1589 1590 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope); 1591 1592 if (!MF->getTarget().Options.DisableFramePointerElim(*MF)) 1593 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr); 1594 1595 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(), 1596 MMI->getFrameMoves())); 1597 1598 // Clear debug info 1599 for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator 1600 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I) 1601 DeleteContainerPointers(I->second); 1602 ScopeVariables.clear(); 1603 DeleteContainerPointers(CurrentFnArguments); 1604 UserVariables.clear(); 1605 DbgValues.clear(); 1606 AbstractVariables.clear(); 1607 LabelsBeforeInsn.clear(); 1608 LabelsAfterInsn.clear(); 1609 PrevLabel = NULL; 1610 } 1611 1612 // Register a source line with debug info. Returns the unique label that was 1613 // emitted and which provides correspondence to the source line list. 1614 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S, 1615 unsigned Flags) { 1616 StringRef Fn; 1617 StringRef Dir; 1618 unsigned Src = 1; 1619 if (S) { 1620 DIDescriptor Scope(S); 1621 1622 if (Scope.isCompileUnit()) { 1623 DICompileUnit CU(S); 1624 Fn = CU.getFilename(); 1625 Dir = CU.getDirectory(); 1626 } else if (Scope.isFile()) { 1627 DIFile F(S); 1628 Fn = F.getFilename(); 1629 Dir = F.getDirectory(); 1630 } else if (Scope.isSubprogram()) { 1631 DISubprogram SP(S); 1632 Fn = SP.getFilename(); 1633 Dir = SP.getDirectory(); 1634 } else if (Scope.isLexicalBlockFile()) { 1635 DILexicalBlockFile DBF(S); 1636 Fn = DBF.getFilename(); 1637 Dir = DBF.getDirectory(); 1638 } else if (Scope.isLexicalBlock()) { 1639 DILexicalBlock DB(S); 1640 Fn = DB.getFilename(); 1641 Dir = DB.getDirectory(); 1642 } else 1643 llvm_unreachable("Unexpected scope info"); 1644 1645 Src = getOrCreateSourceID(Fn, Dir, 1646 Asm->OutStreamer.getContext().getDwarfCompileUnitID()); 1647 } 1648 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn); 1649 } 1650 1651 //===----------------------------------------------------------------------===// 1652 // Emit Methods 1653 //===----------------------------------------------------------------------===// 1654 1655 // Compute the size and offset of a DIE. 1656 unsigned 1657 DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) { 1658 // Get the children. 1659 const std::vector<DIE *> &Children = Die->getChildren(); 1660 1661 // Record the abbreviation. 1662 assignAbbrevNumber(Die->getAbbrev()); 1663 1664 // Get the abbreviation for this DIE. 1665 unsigned AbbrevNumber = Die->getAbbrevNumber(); 1666 const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1); 1667 1668 // Set DIE offset 1669 Die->setOffset(Offset); 1670 1671 // Start the size with the size of abbreviation code. 1672 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber); 1673 1674 const SmallVector<DIEValue*, 32> &Values = Die->getValues(); 1675 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData(); 1676 1677 // Size the DIE attribute values. 1678 for (unsigned i = 0, N = Values.size(); i < N; ++i) 1679 // Size attribute value. 1680 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm()); 1681 1682 // Size the DIE children if any. 1683 if (!Children.empty()) { 1684 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes && 1685 "Children flag not set"); 1686 1687 for (unsigned j = 0, M = Children.size(); j < M; ++j) 1688 Offset = computeSizeAndOffset(Children[j], Offset); 1689 1690 // End of children marker. 1691 Offset += sizeof(int8_t); 1692 } 1693 1694 Die->setSize(Offset - Die->getOffset()); 1695 return Offset; 1696 } 1697 1698 // Compute the size and offset of all the DIEs. 1699 void DwarfUnits::computeSizeAndOffsets() { 1700 // Offset from the beginning of debug info section. 1701 unsigned AccuOffset = 0; 1702 for (SmallVector<CompileUnit *, 1>::iterator I = CUs.begin(), 1703 E = CUs.end(); I != E; ++I) { 1704 (*I)->setDebugInfoOffset(AccuOffset); 1705 unsigned Offset = 1706 sizeof(int32_t) + // Length of Compilation Unit Info 1707 sizeof(int16_t) + // DWARF version number 1708 sizeof(int32_t) + // Offset Into Abbrev. Section 1709 sizeof(int8_t); // Pointer Size (in bytes) 1710 1711 unsigned EndOffset = computeSizeAndOffset((*I)->getCUDie(), Offset); 1712 AccuOffset += EndOffset; 1713 } 1714 } 1715 1716 // Emit initial Dwarf sections with a label at the start of each one. 1717 void DwarfDebug::emitSectionLabels() { 1718 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); 1719 1720 // Dwarf sections base addresses. 1721 DwarfInfoSectionSym = 1722 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info"); 1723 DwarfAbbrevSectionSym = 1724 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev"); 1725 if (useSplitDwarf()) 1726 DwarfAbbrevDWOSectionSym = 1727 emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(), 1728 "section_abbrev_dwo"); 1729 emitSectionSym(Asm, TLOF.getDwarfARangesSection()); 1730 1731 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection()) 1732 emitSectionSym(Asm, MacroInfo); 1733 1734 DwarfLineSectionSym = 1735 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line"); 1736 emitSectionSym(Asm, TLOF.getDwarfLocSection()); 1737 if (GenerateDwarfPubNamesSection) 1738 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection()); 1739 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection()); 1740 DwarfStrSectionSym = 1741 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string"); 1742 if (useSplitDwarf()) 1743 DwarfStrDWOSectionSym = 1744 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string"); 1745 DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(), 1746 "debug_range"); 1747 1748 DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(), 1749 "section_debug_loc"); 1750 1751 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin"); 1752 emitSectionSym(Asm, TLOF.getDataSection()); 1753 } 1754 1755 // Recursively emits a debug information entry. 1756 void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) { 1757 // Get the abbreviation for this DIE. 1758 unsigned AbbrevNumber = Die->getAbbrevNumber(); 1759 const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1); 1760 1761 // Emit the code (index) for the abbreviation. 1762 if (Asm->isVerbose()) 1763 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" + 1764 Twine::utohexstr(Die->getOffset()) + ":0x" + 1765 Twine::utohexstr(Die->getSize()) + " " + 1766 dwarf::TagString(Abbrev->getTag())); 1767 Asm->EmitULEB128(AbbrevNumber); 1768 1769 const SmallVector<DIEValue*, 32> &Values = Die->getValues(); 1770 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData(); 1771 1772 // Emit the DIE attribute values. 1773 for (unsigned i = 0, N = Values.size(); i < N; ++i) { 1774 unsigned Attr = AbbrevData[i].getAttribute(); 1775 unsigned Form = AbbrevData[i].getForm(); 1776 assert(Form && "Too many attributes for DIE (check abbreviation)"); 1777 1778 if (Asm->isVerbose()) 1779 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr)); 1780 1781 switch (Attr) { 1782 case dwarf::DW_AT_abstract_origin: { 1783 DIEEntry *E = cast<DIEEntry>(Values[i]); 1784 DIE *Origin = E->getEntry(); 1785 unsigned Addr = Origin->getOffset(); 1786 if (Form == dwarf::DW_FORM_ref_addr) { 1787 // For DW_FORM_ref_addr, output the offset from beginning of debug info 1788 // section. Origin->getOffset() returns the offset from start of the 1789 // compile unit. 1790 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder; 1791 Addr += Holder.getCUOffset(Origin->getCompileUnit()); 1792 } 1793 Asm->EmitInt32(Addr); 1794 break; 1795 } 1796 case dwarf::DW_AT_ranges: { 1797 // DW_AT_range Value encodes offset in debug_range section. 1798 DIEInteger *V = cast<DIEInteger>(Values[i]); 1799 1800 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) { 1801 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym, 1802 V->getValue(), 1803 4); 1804 } else { 1805 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym, 1806 V->getValue(), 1807 DwarfDebugRangeSectionSym, 1808 4); 1809 } 1810 break; 1811 } 1812 case dwarf::DW_AT_location: { 1813 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) { 1814 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) 1815 Asm->EmitLabelReference(L->getValue(), 4); 1816 else 1817 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4); 1818 } else { 1819 Values[i]->EmitValue(Asm, Form); 1820 } 1821 break; 1822 } 1823 case dwarf::DW_AT_accessibility: { 1824 if (Asm->isVerbose()) { 1825 DIEInteger *V = cast<DIEInteger>(Values[i]); 1826 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue())); 1827 } 1828 Values[i]->EmitValue(Asm, Form); 1829 break; 1830 } 1831 default: 1832 // Emit an attribute using the defined form. 1833 Values[i]->EmitValue(Asm, Form); 1834 break; 1835 } 1836 } 1837 1838 // Emit the DIE children if any. 1839 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) { 1840 const std::vector<DIE *> &Children = Die->getChildren(); 1841 1842 for (unsigned j = 0, M = Children.size(); j < M; ++j) 1843 emitDIE(Children[j], Abbrevs); 1844 1845 if (Asm->isVerbose()) 1846 Asm->OutStreamer.AddComment("End Of Children Mark"); 1847 Asm->EmitInt8(0); 1848 } 1849 } 1850 1851 // Emit the various dwarf units to the unit section USection with 1852 // the abbreviations going into ASection. 1853 void DwarfUnits::emitUnits(DwarfDebug *DD, 1854 const MCSection *USection, 1855 const MCSection *ASection, 1856 const MCSymbol *ASectionSym) { 1857 Asm->OutStreamer.SwitchSection(USection); 1858 for (SmallVector<CompileUnit *, 1>::iterator I = CUs.begin(), 1859 E = CUs.end(); I != E; ++I) { 1860 CompileUnit *TheCU = *I; 1861 DIE *Die = TheCU->getCUDie(); 1862 1863 // Emit the compile units header. 1864 Asm->OutStreamer 1865 .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(), 1866 TheCU->getUniqueID())); 1867 1868 // Emit size of content not including length itself 1869 unsigned ContentSize = Die->getSize() + 1870 sizeof(int16_t) + // DWARF version number 1871 sizeof(int32_t) + // Offset Into Abbrev. Section 1872 sizeof(int8_t); // Pointer Size (in bytes) 1873 1874 Asm->OutStreamer.AddComment("Length of Compilation Unit Info"); 1875 Asm->EmitInt32(ContentSize); 1876 Asm->OutStreamer.AddComment("DWARF version number"); 1877 Asm->EmitInt16(dwarf::DWARF_VERSION); 1878 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section"); 1879 Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()), 1880 ASectionSym); 1881 Asm->OutStreamer.AddComment("Address Size (in bytes)"); 1882 Asm->EmitInt8(Asm->getDataLayout().getPointerSize()); 1883 1884 DD->emitDIE(Die, Abbreviations); 1885 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(), 1886 TheCU->getUniqueID())); 1887 } 1888 } 1889 1890 /// For a given compile unit DIE, returns offset from beginning of debug info. 1891 unsigned DwarfUnits::getCUOffset(DIE *Die) { 1892 assert(Die->getTag() == dwarf::DW_TAG_compile_unit && 1893 "Input DIE should be compile unit in getCUOffset."); 1894 for (SmallVector<CompileUnit *, 1>::iterator I = CUs.begin(), 1895 E = CUs.end(); I != E; ++I) { 1896 CompileUnit *TheCU = *I; 1897 if (TheCU->getCUDie() == Die) 1898 return TheCU->getDebugInfoOffset(); 1899 } 1900 llvm_unreachable("The compile unit DIE should belong to CUs in DwarfUnits."); 1901 } 1902 1903 // Emit the debug info section. 1904 void DwarfDebug::emitDebugInfo() { 1905 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder; 1906 1907 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(), 1908 Asm->getObjFileLowering().getDwarfAbbrevSection(), 1909 DwarfAbbrevSectionSym); 1910 } 1911 1912 // Emit the abbreviation section. 1913 void DwarfDebug::emitAbbreviations() { 1914 if (!useSplitDwarf()) 1915 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(), 1916 &Abbreviations); 1917 else 1918 emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection()); 1919 } 1920 1921 void DwarfDebug::emitAbbrevs(const MCSection *Section, 1922 std::vector<DIEAbbrev *> *Abbrevs) { 1923 // Check to see if it is worth the effort. 1924 if (!Abbrevs->empty()) { 1925 // Start the debug abbrev section. 1926 Asm->OutStreamer.SwitchSection(Section); 1927 1928 MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName()); 1929 Asm->OutStreamer.EmitLabel(Begin); 1930 1931 // For each abbrevation. 1932 for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) { 1933 // Get abbreviation data 1934 const DIEAbbrev *Abbrev = Abbrevs->at(i); 1935 1936 // Emit the abbrevations code (base 1 index.) 1937 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code"); 1938 1939 // Emit the abbreviations data. 1940 Abbrev->Emit(Asm); 1941 } 1942 1943 // Mark end of abbreviations. 1944 Asm->EmitULEB128(0, "EOM(3)"); 1945 1946 MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName()); 1947 Asm->OutStreamer.EmitLabel(End); 1948 } 1949 } 1950 1951 // Emit the last address of the section and the end of the line matrix. 1952 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) { 1953 // Define last address of section. 1954 Asm->OutStreamer.AddComment("Extended Op"); 1955 Asm->EmitInt8(0); 1956 1957 Asm->OutStreamer.AddComment("Op size"); 1958 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1); 1959 Asm->OutStreamer.AddComment("DW_LNE_set_address"); 1960 Asm->EmitInt8(dwarf::DW_LNE_set_address); 1961 1962 Asm->OutStreamer.AddComment("Section end label"); 1963 1964 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd), 1965 Asm->getDataLayout().getPointerSize()); 1966 1967 // Mark end of matrix. 1968 Asm->OutStreamer.AddComment("DW_LNE_end_sequence"); 1969 Asm->EmitInt8(0); 1970 Asm->EmitInt8(1); 1971 Asm->EmitInt8(1); 1972 } 1973 1974 // Emit visible names into a hashed accelerator table section. 1975 void DwarfDebug::emitAccelNames() { 1976 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset, 1977 dwarf::DW_FORM_data4)); 1978 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 1979 E = CUMap.end(); I != E; ++I) { 1980 CompileUnit *TheCU = I->second; 1981 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames(); 1982 for (StringMap<std::vector<DIE*> >::const_iterator 1983 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) { 1984 const char *Name = GI->getKeyData(); 1985 const std::vector<DIE *> &Entities = GI->second; 1986 for (std::vector<DIE *>::const_iterator DI = Entities.begin(), 1987 DE = Entities.end(); DI != DE; ++DI) 1988 AT.AddName(Name, (*DI)); 1989 } 1990 } 1991 1992 AT.FinalizeTable(Asm, "Names"); 1993 Asm->OutStreamer.SwitchSection( 1994 Asm->getObjFileLowering().getDwarfAccelNamesSection()); 1995 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin"); 1996 Asm->OutStreamer.EmitLabel(SectionBegin); 1997 1998 // Emit the full data. 1999 AT.Emit(Asm, SectionBegin, &InfoHolder); 2000 } 2001 2002 // Emit objective C classes and categories into a hashed accelerator table 2003 // section. 2004 void DwarfDebug::emitAccelObjC() { 2005 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset, 2006 dwarf::DW_FORM_data4)); 2007 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 2008 E = CUMap.end(); I != E; ++I) { 2009 CompileUnit *TheCU = I->second; 2010 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC(); 2011 for (StringMap<std::vector<DIE*> >::const_iterator 2012 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) { 2013 const char *Name = GI->getKeyData(); 2014 const std::vector<DIE *> &Entities = GI->second; 2015 for (std::vector<DIE *>::const_iterator DI = Entities.begin(), 2016 DE = Entities.end(); DI != DE; ++DI) 2017 AT.AddName(Name, (*DI)); 2018 } 2019 } 2020 2021 AT.FinalizeTable(Asm, "ObjC"); 2022 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering() 2023 .getDwarfAccelObjCSection()); 2024 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin"); 2025 Asm->OutStreamer.EmitLabel(SectionBegin); 2026 2027 // Emit the full data. 2028 AT.Emit(Asm, SectionBegin, &InfoHolder); 2029 } 2030 2031 // Emit namespace dies into a hashed accelerator table. 2032 void DwarfDebug::emitAccelNamespaces() { 2033 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset, 2034 dwarf::DW_FORM_data4)); 2035 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 2036 E = CUMap.end(); I != E; ++I) { 2037 CompileUnit *TheCU = I->second; 2038 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace(); 2039 for (StringMap<std::vector<DIE*> >::const_iterator 2040 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) { 2041 const char *Name = GI->getKeyData(); 2042 const std::vector<DIE *> &Entities = GI->second; 2043 for (std::vector<DIE *>::const_iterator DI = Entities.begin(), 2044 DE = Entities.end(); DI != DE; ++DI) 2045 AT.AddName(Name, (*DI)); 2046 } 2047 } 2048 2049 AT.FinalizeTable(Asm, "namespac"); 2050 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering() 2051 .getDwarfAccelNamespaceSection()); 2052 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin"); 2053 Asm->OutStreamer.EmitLabel(SectionBegin); 2054 2055 // Emit the full data. 2056 AT.Emit(Asm, SectionBegin, &InfoHolder); 2057 } 2058 2059 // Emit type dies into a hashed accelerator table. 2060 void DwarfDebug::emitAccelTypes() { 2061 std::vector<DwarfAccelTable::Atom> Atoms; 2062 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset, 2063 dwarf::DW_FORM_data4)); 2064 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag, 2065 dwarf::DW_FORM_data2)); 2066 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags, 2067 dwarf::DW_FORM_data1)); 2068 DwarfAccelTable AT(Atoms); 2069 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 2070 E = CUMap.end(); I != E; ++I) { 2071 CompileUnit *TheCU = I->second; 2072 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names 2073 = TheCU->getAccelTypes(); 2074 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator 2075 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) { 2076 const char *Name = GI->getKeyData(); 2077 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second; 2078 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI 2079 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI) 2080 AT.AddName(Name, (*DI).first, (*DI).second); 2081 } 2082 } 2083 2084 AT.FinalizeTable(Asm, "types"); 2085 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering() 2086 .getDwarfAccelTypesSection()); 2087 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin"); 2088 Asm->OutStreamer.EmitLabel(SectionBegin); 2089 2090 // Emit the full data. 2091 AT.Emit(Asm, SectionBegin, &InfoHolder); 2092 } 2093 2094 /// emitDebugPubnames - Emit visible names into a debug pubnames section. 2095 /// 2096 void DwarfDebug::emitDebugPubnames() { 2097 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection(); 2098 2099 typedef DenseMap<const MDNode*, CompileUnit*> CUMapType; 2100 for (CUMapType::iterator I = CUMap.begin(), E = CUMap.end(); I != E; ++I) { 2101 CompileUnit *TheCU = I->second; 2102 unsigned ID = TheCU->getUniqueID(); 2103 2104 if (TheCU->getGlobalNames().empty()) 2105 continue; 2106 2107 // Start the dwarf pubnames section. 2108 Asm->OutStreamer.SwitchSection( 2109 Asm->getObjFileLowering().getDwarfPubNamesSection()); 2110 2111 Asm->OutStreamer.AddComment("Length of Public Names Info"); 2112 Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID), 2113 Asm->GetTempSymbol("pubnames_begin", ID), 4); 2114 2115 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID)); 2116 2117 Asm->OutStreamer.AddComment("DWARF Version"); 2118 Asm->EmitInt16(dwarf::DWARF_VERSION); 2119 2120 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info"); 2121 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID), 2122 DwarfInfoSectionSym); 2123 2124 Asm->OutStreamer.AddComment("Compilation Unit Length"); 2125 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID), 2126 Asm->GetTempSymbol(ISec->getLabelBeginName(), ID), 2127 4); 2128 2129 const StringMap<DIE*> &Globals = TheCU->getGlobalNames(); 2130 for (StringMap<DIE*>::const_iterator 2131 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) { 2132 const char *Name = GI->getKeyData(); 2133 const DIE *Entity = GI->second; 2134 2135 Asm->OutStreamer.AddComment("DIE offset"); 2136 Asm->EmitInt32(Entity->getOffset()); 2137 2138 if (Asm->isVerbose()) 2139 Asm->OutStreamer.AddComment("External Name"); 2140 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0); 2141 } 2142 2143 Asm->OutStreamer.AddComment("End Mark"); 2144 Asm->EmitInt32(0); 2145 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID)); 2146 } 2147 } 2148 2149 void DwarfDebug::emitDebugPubTypes() { 2150 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), 2151 E = CUMap.end(); I != E; ++I) { 2152 CompileUnit *TheCU = I->second; 2153 // Start the dwarf pubtypes section. 2154 Asm->OutStreamer.SwitchSection( 2155 Asm->getObjFileLowering().getDwarfPubTypesSection()); 2156 Asm->OutStreamer.AddComment("Length of Public Types Info"); 2157 Asm->EmitLabelDifference( 2158 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()), 2159 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4); 2160 2161 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin", 2162 TheCU->getUniqueID())); 2163 2164 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version"); 2165 Asm->EmitInt16(dwarf::DWARF_VERSION); 2166 2167 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info"); 2168 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection(); 2169 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), 2170 TheCU->getUniqueID()), 2171 DwarfInfoSectionSym); 2172 2173 Asm->OutStreamer.AddComment("Compilation Unit Length"); 2174 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), 2175 TheCU->getUniqueID()), 2176 Asm->GetTempSymbol(ISec->getLabelBeginName(), 2177 TheCU->getUniqueID()), 2178 4); 2179 2180 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes(); 2181 for (StringMap<DIE*>::const_iterator 2182 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) { 2183 const char *Name = GI->getKeyData(); 2184 DIE *Entity = GI->second; 2185 2186 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset"); 2187 Asm->EmitInt32(Entity->getOffset()); 2188 2189 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name"); 2190 // Emit the name with a terminating null byte. 2191 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1)); 2192 } 2193 2194 Asm->OutStreamer.AddComment("End Mark"); 2195 Asm->EmitInt32(0); 2196 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end", 2197 TheCU->getUniqueID())); 2198 } 2199 } 2200 2201 // Emit strings into a string section. 2202 void DwarfUnits::emitStrings(const MCSection *StrSection, 2203 const MCSection *OffsetSection = NULL, 2204 const MCSymbol *StrSecSym = NULL) { 2205 2206 if (StringPool.empty()) return; 2207 2208 // Start the dwarf str section. 2209 Asm->OutStreamer.SwitchSection(StrSection); 2210 2211 // Get all of the string pool entries and put them in an array by their ID so 2212 // we can sort them. 2213 SmallVector<std::pair<unsigned, 2214 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries; 2215 2216 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator 2217 I = StringPool.begin(), E = StringPool.end(); 2218 I != E; ++I) 2219 Entries.push_back(std::make_pair(I->second.second, &*I)); 2220 2221 array_pod_sort(Entries.begin(), Entries.end()); 2222 2223 for (unsigned i = 0, e = Entries.size(); i != e; ++i) { 2224 // Emit a label for reference from debug information entries. 2225 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first); 2226 2227 // Emit the string itself with a terminating null byte. 2228 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(), 2229 Entries[i].second->getKeyLength()+1)); 2230 } 2231 2232 // If we've got an offset section go ahead and emit that now as well. 2233 if (OffsetSection) { 2234 Asm->OutStreamer.SwitchSection(OffsetSection); 2235 unsigned offset = 0; 2236 unsigned size = 4; // FIXME: DWARF64 is 8. 2237 for (unsigned i = 0, e = Entries.size(); i != e; ++i) { 2238 Asm->OutStreamer.EmitIntValue(offset, size); 2239 offset += Entries[i].second->getKeyLength() + 1; 2240 } 2241 } 2242 } 2243 2244 // Emit strings into a string section. 2245 void DwarfUnits::emitAddresses(const MCSection *AddrSection) { 2246 2247 if (AddressPool.empty()) return; 2248 2249 // Start the dwarf addr section. 2250 Asm->OutStreamer.SwitchSection(AddrSection); 2251 2252 // Get all of the string pool entries and put them in an array by their ID so 2253 // we can sort them. 2254 SmallVector<std::pair<unsigned, 2255 std::pair<MCSymbol*, unsigned>* >, 64> Entries; 2256 2257 for (DenseMap<MCSymbol*, std::pair<MCSymbol*, unsigned> >::iterator 2258 I = AddressPool.begin(), E = AddressPool.end(); 2259 I != E; ++I) 2260 Entries.push_back(std::make_pair(I->second.second, &(I->second))); 2261 2262 array_pod_sort(Entries.begin(), Entries.end()); 2263 2264 for (unsigned i = 0, e = Entries.size(); i != e; ++i) { 2265 // Emit a label for reference from debug information entries. 2266 MCSymbol *Sym = Entries[i].second->first; 2267 if (Sym) 2268 Asm->EmitLabelReference(Entries[i].second->first, 2269 Asm->getDataLayout().getPointerSize()); 2270 else 2271 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize()); 2272 } 2273 2274 } 2275 2276 // Emit visible names into a debug str section. 2277 void DwarfDebug::emitDebugStr() { 2278 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder; 2279 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection()); 2280 } 2281 2282 // Emit visible names into a debug loc section. 2283 void DwarfDebug::emitDebugLoc() { 2284 if (DotDebugLocEntries.empty()) 2285 return; 2286 2287 for (SmallVector<DotDebugLocEntry, 4>::iterator 2288 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end(); 2289 I != E; ++I) { 2290 DotDebugLocEntry &Entry = *I; 2291 if (I + 1 != DotDebugLocEntries.end()) 2292 Entry.Merge(I+1); 2293 } 2294 2295 // Start the dwarf loc section. 2296 Asm->OutStreamer.SwitchSection( 2297 Asm->getObjFileLowering().getDwarfLocSection()); 2298 unsigned char Size = Asm->getDataLayout().getPointerSize(); 2299 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0)); 2300 unsigned index = 1; 2301 for (SmallVector<DotDebugLocEntry, 4>::iterator 2302 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end(); 2303 I != E; ++I, ++index) { 2304 DotDebugLocEntry &Entry = *I; 2305 if (Entry.isMerged()) continue; 2306 if (Entry.isEmpty()) { 2307 Asm->OutStreamer.EmitIntValue(0, Size); 2308 Asm->OutStreamer.EmitIntValue(0, Size); 2309 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index)); 2310 } else { 2311 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size); 2312 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size); 2313 DIVariable DV(Entry.Variable); 2314 Asm->OutStreamer.AddComment("Loc expr size"); 2315 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol(); 2316 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol(); 2317 Asm->EmitLabelDifference(end, begin, 2); 2318 Asm->OutStreamer.EmitLabel(begin); 2319 if (Entry.isInt()) { 2320 DIBasicType BTy(DV.getType()); 2321 if (BTy.Verify() && 2322 (BTy.getEncoding() == dwarf::DW_ATE_signed 2323 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) { 2324 Asm->OutStreamer.AddComment("DW_OP_consts"); 2325 Asm->EmitInt8(dwarf::DW_OP_consts); 2326 Asm->EmitSLEB128(Entry.getInt()); 2327 } else { 2328 Asm->OutStreamer.AddComment("DW_OP_constu"); 2329 Asm->EmitInt8(dwarf::DW_OP_constu); 2330 Asm->EmitULEB128(Entry.getInt()); 2331 } 2332 } else if (Entry.isLocation()) { 2333 if (!DV.hasComplexAddress()) 2334 // Regular entry. 2335 Asm->EmitDwarfRegOp(Entry.Loc); 2336 else { 2337 // Complex address entry. 2338 unsigned N = DV.getNumAddrElements(); 2339 unsigned i = 0; 2340 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) { 2341 if (Entry.Loc.getOffset()) { 2342 i = 2; 2343 Asm->EmitDwarfRegOp(Entry.Loc); 2344 Asm->OutStreamer.AddComment("DW_OP_deref"); 2345 Asm->EmitInt8(dwarf::DW_OP_deref); 2346 Asm->OutStreamer.AddComment("DW_OP_plus_uconst"); 2347 Asm->EmitInt8(dwarf::DW_OP_plus_uconst); 2348 Asm->EmitSLEB128(DV.getAddrElement(1)); 2349 } else { 2350 // If first address element is OpPlus then emit 2351 // DW_OP_breg + Offset instead of DW_OP_reg + Offset. 2352 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1)); 2353 Asm->EmitDwarfRegOp(Loc); 2354 i = 2; 2355 } 2356 } else { 2357 Asm->EmitDwarfRegOp(Entry.Loc); 2358 } 2359 2360 // Emit remaining complex address elements. 2361 for (; i < N; ++i) { 2362 uint64_t Element = DV.getAddrElement(i); 2363 if (Element == DIBuilder::OpPlus) { 2364 Asm->EmitInt8(dwarf::DW_OP_plus_uconst); 2365 Asm->EmitULEB128(DV.getAddrElement(++i)); 2366 } else if (Element == DIBuilder::OpDeref) { 2367 if (!Entry.Loc.isReg()) 2368 Asm->EmitInt8(dwarf::DW_OP_deref); 2369 } else 2370 llvm_unreachable("unknown Opcode found in complex address"); 2371 } 2372 } 2373 } 2374 // else ... ignore constant fp. There is not any good way to 2375 // to represent them here in dwarf. 2376 Asm->OutStreamer.EmitLabel(end); 2377 } 2378 } 2379 } 2380 2381 // Emit visible names into a debug aranges section. 2382 void DwarfDebug::emitDebugARanges() { 2383 // Start the dwarf aranges section. 2384 Asm->OutStreamer.SwitchSection( 2385 Asm->getObjFileLowering().getDwarfARangesSection()); 2386 } 2387 2388 // Emit visible names into a debug ranges section. 2389 void DwarfDebug::emitDebugRanges() { 2390 // Start the dwarf ranges section. 2391 Asm->OutStreamer.SwitchSection( 2392 Asm->getObjFileLowering().getDwarfRangesSection()); 2393 unsigned char Size = Asm->getDataLayout().getPointerSize(); 2394 for (SmallVector<const MCSymbol *, 8>::iterator 2395 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end(); 2396 I != E; ++I) { 2397 if (*I) 2398 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size); 2399 else 2400 Asm->OutStreamer.EmitIntValue(0, Size); 2401 } 2402 } 2403 2404 // Emit visible names into a debug macinfo section. 2405 void DwarfDebug::emitDebugMacInfo() { 2406 if (const MCSection *LineInfo = 2407 Asm->getObjFileLowering().getDwarfMacroInfoSection()) { 2408 // Start the dwarf macinfo section. 2409 Asm->OutStreamer.SwitchSection(LineInfo); 2410 } 2411 } 2412 2413 // Emit inline info using following format. 2414 // Section Header: 2415 // 1. length of section 2416 // 2. Dwarf version number 2417 // 3. address size. 2418 // 2419 // Entries (one "entry" for each function that was inlined): 2420 // 2421 // 1. offset into __debug_str section for MIPS linkage name, if exists; 2422 // otherwise offset into __debug_str for regular function name. 2423 // 2. offset into __debug_str section for regular function name. 2424 // 3. an unsigned LEB128 number indicating the number of distinct inlining 2425 // instances for the function. 2426 // 2427 // The rest of the entry consists of a {die_offset, low_pc} pair for each 2428 // inlined instance; the die_offset points to the inlined_subroutine die in the 2429 // __debug_info section, and the low_pc is the starting address for the 2430 // inlining instance. 2431 void DwarfDebug::emitDebugInlineInfo() { 2432 if (!Asm->MAI->doesDwarfUseInlineInfoSection()) 2433 return; 2434 2435 if (!FirstCU) 2436 return; 2437 2438 Asm->OutStreamer.SwitchSection( 2439 Asm->getObjFileLowering().getDwarfDebugInlineSection()); 2440 2441 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry"); 2442 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1), 2443 Asm->GetTempSymbol("debug_inlined_begin", 1), 4); 2444 2445 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1)); 2446 2447 Asm->OutStreamer.AddComment("Dwarf Version"); 2448 Asm->EmitInt16(dwarf::DWARF_VERSION); 2449 Asm->OutStreamer.AddComment("Address Size (in bytes)"); 2450 Asm->EmitInt8(Asm->getDataLayout().getPointerSize()); 2451 2452 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(), 2453 E = InlinedSPNodes.end(); I != E; ++I) { 2454 2455 const MDNode *Node = *I; 2456 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II 2457 = InlineInfo.find(Node); 2458 SmallVector<InlineInfoLabels, 4> &Labels = II->second; 2459 DISubprogram SP(Node); 2460 StringRef LName = SP.getLinkageName(); 2461 StringRef Name = SP.getName(); 2462 2463 Asm->OutStreamer.AddComment("MIPS linkage name"); 2464 if (LName.empty()) 2465 Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name), 2466 DwarfStrSectionSym); 2467 else 2468 Asm->EmitSectionOffset(InfoHolder 2469 .getStringPoolEntry(getRealLinkageName(LName)), 2470 DwarfStrSectionSym); 2471 2472 Asm->OutStreamer.AddComment("Function name"); 2473 Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name), 2474 DwarfStrSectionSym); 2475 Asm->EmitULEB128(Labels.size(), "Inline count"); 2476 2477 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(), 2478 LE = Labels.end(); LI != LE; ++LI) { 2479 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset"); 2480 Asm->EmitInt32(LI->second->getOffset()); 2481 2482 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc"); 2483 Asm->OutStreamer.EmitSymbolValue(LI->first, 2484 Asm->getDataLayout().getPointerSize()); 2485 } 2486 } 2487 2488 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1)); 2489 } 2490 2491 // DWARF5 Experimental Separate Dwarf emitters. 2492 2493 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list, 2494 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id, 2495 // DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present, 2496 // DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa. 2497 CompileUnit *DwarfDebug::constructSkeletonCU(const MDNode *N) { 2498 DICompileUnit DIUnit(N); 2499 CompilationDir = DIUnit.getDirectory(); 2500 2501 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit); 2502 CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++, 2503 DIUnit.getLanguage(), Die, Asm, 2504 this, &SkeletonHolder); 2505 2506 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name, 2507 DIUnit.getSplitDebugFilename()); 2508 2509 // This should be a unique identifier when we want to build .dwp files. 2510 NewCU->addUInt(Die, dwarf::DW_AT_GNU_dwo_id, dwarf::DW_FORM_data8, 0); 2511 2512 // FIXME: The addr base should be relative for each compile unit, however, 2513 // this one is going to be 0 anyhow. 2514 NewCU->addUInt(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset, 0); 2515 2516 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point 2517 // into an entity. We're using 0, or a NULL label for this. 2518 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0); 2519 2520 // DW_AT_stmt_list is a offset of line number information for this 2521 // compile unit in debug_line section. 2522 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) 2523 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 2524 DwarfLineSectionSym); 2525 else 2526 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 0); 2527 2528 if (!CompilationDir.empty()) 2529 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir); 2530 2531 SkeletonHolder.addUnit(NewCU); 2532 SkeletonCUs.push_back(NewCU); 2533 2534 return NewCU; 2535 } 2536 2537 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) { 2538 assert(useSplitDwarf() && "No split dwarf debug info?"); 2539 emitAbbrevs(Section, &SkeletonAbbrevs); 2540 } 2541 2542 // Emit the .debug_info.dwo section for separated dwarf. This contains the 2543 // compile units that would normally be in debug_info. 2544 void DwarfDebug::emitDebugInfoDWO() { 2545 assert(useSplitDwarf() && "No split dwarf debug info?"); 2546 InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(), 2547 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(), 2548 DwarfAbbrevDWOSectionSym); 2549 } 2550 2551 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the 2552 // abbreviations for the .debug_info.dwo section. 2553 void DwarfDebug::emitDebugAbbrevDWO() { 2554 assert(useSplitDwarf() && "No split dwarf?"); 2555 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(), 2556 &Abbreviations); 2557 } 2558 2559 // Emit the .debug_str.dwo section for separated dwarf. This contains the 2560 // string section and is identical in format to traditional .debug_str 2561 // sections. 2562 void DwarfDebug::emitDebugStrDWO() { 2563 assert(useSplitDwarf() && "No split dwarf?"); 2564 const MCSection *OffSec = Asm->getObjFileLowering() 2565 .getDwarfStrOffDWOSection(); 2566 const MCSymbol *StrSym = DwarfStrSectionSym; 2567 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(), 2568 OffSec, StrSym); 2569 } 2570