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