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