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