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