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