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