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