lib/CodeGen/AsmPrinter/DwarfDebug.cpp

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