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(A->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,
 826                   dwarf::DW_FORM_data8, 0);
 827       // Now construct the skeleton CU associated.
 828       constructSkeletonCU(CUNode);
 829     }
 830   }
 831
 832   // Tell MMI that we have debug info.
 833   MMI->setDebugInfoAvailability(true);
 834
 835   // Prime section data.
 836   SectionMap.insert(Asm->getObjFileLowering().getTextSection());
 837 }
 838
 839 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
 840 void DwarfDebug::computeInlinedDIEs() {
 841   // Attach DW_AT_inline attribute with inlined subprogram DIEs.
 842   for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
 843          AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
 844     DIE *ISP = *AI;
 845     FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
 846   }
 847   for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
 848          AE = AbstractSPDies.end(); AI != AE; ++AI) {
 849     DIE *ISP = AI->second;
 850     if (InlinedSubprogramDIEs.count(ISP))
 851       continue;
 852     FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
 853   }
 854 }
 855
 856 // Collect info for variables that were optimized out.
 857 void DwarfDebug::collectDeadVariables() {
 858   const Module *M = MMI->getModule();
 859   DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
 860
 861   if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
 862     for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
 863       DICompileUnit TheCU(CU_Nodes->getOperand(i));
 864       DIArray Subprograms = TheCU.getSubprograms();
 865       for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
 866         DISubprogram SP(Subprograms.getElement(i));
 867         if (ProcessedSPNodes.count(SP) != 0) continue;
 868         if (!SP.Verify()) continue;
 869         if (!SP.isDefinition()) continue;
 870         DIArray Variables = SP.getVariables();
 871         if (Variables.getNumElements() == 0) continue;
 872
 873         LexicalScope *Scope =
 874           new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
 875         DeadFnScopeMap[SP] = Scope;
 876
 877         // Construct subprogram DIE and add variables DIEs.
 878         CompileUnit *SPCU = CUMap.lookup(TheCU);
 879         assert(SPCU && "Unable to find Compile Unit!");
 880         constructSubprogramDIE(SPCU, SP);
 881         DIE *ScopeDIE = SPCU->getDIE(SP);
 882         for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
 883           DIVariable DV(Variables.getElement(vi));
 884           if (!DV.Verify()) continue;
 885           DbgVariable *NewVar = new DbgVariable(DV, NULL);
 886           if (DIE *VariableDIE =
 887               SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
 888             ScopeDIE->addChild(VariableDIE);
 889         }
 890       }
 891     }
 892   }
 893   DeleteContainerSeconds(DeadFnScopeMap);
 894 }
 895
 896 void DwarfDebug::finalizeModuleInfo() {
 897   // Collect info for variables that were optimized out.
 898   collectDeadVariables();
 899
 900   // Attach DW_AT_inline attribute with inlined subprogram DIEs.
 901   computeInlinedDIEs();
 902
 903   // Emit DW_AT_containing_type attribute to connect types with their
 904   // vtable holding type.
 905   for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
 906          CUE = CUMap.end(); CUI != CUE; ++CUI) {
 907     CompileUnit *TheCU = CUI->second;
 908     TheCU->constructContainingTypeDIEs();
 909   }
 910
 911    // Compute DIE offsets and sizes.
 912   InfoHolder.computeSizeAndOffsets();
 913   if (useSplitDwarf())
 914     SkeletonHolder.computeSizeAndOffsets();
 915 }
 916
 917 void DwarfDebug::endSections() {
 918   // Standard sections final addresses.
 919   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
 920   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
 921   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
 922   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
 923
 924   // End text sections.
 925   for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) {
 926     Asm->OutStreamer.SwitchSection(SectionMap[I]);
 927     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1));
 928   }
 929 }
 930
 931 // Emit all Dwarf sections that should come after the content.
 932 void DwarfDebug::endModule() {
 933
 934   if (!FirstCU) return;
 935
 936   // End any existing sections.
 937   // TODO: Does this need to happen?
 938   endSections();
 939
 940   // Finalize the debug info for the module.
 941   finalizeModuleInfo();
 942
 943   if (!useSplitDwarf()) {
 944     // Emit all the DIEs into a debug info section.
 945     emitDebugInfo();
 946
 947     // Corresponding abbreviations into a abbrev section.
 948     emitAbbreviations();
 949
 950     // Emit info into a debug loc section.
 951     emitDebugLoc();
 952
 953     // Emit info into a debug aranges section.
 954     emitDebugARanges();
 955
 956     // Emit info into a debug ranges section.
 957     emitDebugRanges();
 958
 959     // Emit info into a debug macinfo section.
 960     emitDebugMacInfo();
 961
 962     // Emit inline info.
 963     // TODO: When we don't need the option anymore we
 964     // can remove all of the code that this section
 965     // depends upon.
 966     if (useDarwinGDBCompat())
 967       emitDebugInlineInfo();
 968   } else {
 969     // TODO: Fill this in for separated debug sections and separate
 970     // out information into new sections.
 971
 972     // Emit the debug info section and compile units.
 973     emitDebugInfo();
 974     emitDebugInfoDWO();
 975
 976     // Corresponding abbreviations into a abbrev section.
 977     emitAbbreviations();
 978     emitDebugAbbrevDWO();
 979
 980     // Emit info into a debug loc section.
 981     emitDebugLoc();
 982
 983     // Emit info into a debug aranges section.
 984     emitDebugARanges();
 985
 986     // Emit info into a debug ranges section.
 987     emitDebugRanges();
 988
 989     // Emit info into a debug macinfo section.
 990     emitDebugMacInfo();
 991
 992     // Emit DWO addresses.
 993     InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
 994
 995     // Emit inline info.
 996     // TODO: When we don't need the option anymore we
 997     // can remove all of the code that this section
 998     // depends upon.
 999     if (useDarwinGDBCompat())
1000       emitDebugInlineInfo();
1001   }
1002
1003   // Emit info into the dwarf accelerator table sections.
1004   if (useDwarfAccelTables()) {
1005     emitAccelNames();
1006     emitAccelObjC();
1007     emitAccelNamespaces();
1008     emitAccelTypes();
1009   }
1010
1011   // Emit info into a debug pubnames section, if requested.
1012   if (GenerateDwarfPubNamesSection)
1013     emitDebugPubnames();
1014
1015   // Emit info into a debug pubtypes section.
1016   // TODO: When we don't need the option anymore we can
1017   // remove all of the code that adds to the table.
1018   if (useDarwinGDBCompat())
1019     emitDebugPubTypes();
1020
1021   // Finally emit string information into a string table.
1022   emitDebugStr();
1023   if (useSplitDwarf())
1024     emitDebugStrDWO();
1025
1026   // clean up.
1027   SPMap.clear();
1028   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1029          E = CUMap.end(); I != E; ++I)
1030     delete I->second;
1031
1032   for (SmallVector<CompileUnit *, 1>::iterator I = SkeletonCUs.begin(),
1033          E = SkeletonCUs.end(); I != E; ++I)
1034     delete *I;
1035
1036   // Reset these for the next Module if we have one.
1037   FirstCU = NULL;
1038 }
1039
1040 // Find abstract variable, if any, associated with Var.
1041 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1042                                               DebugLoc ScopeLoc) {
1043   LLVMContext &Ctx = DV->getContext();
1044   // More then one inlined variable corresponds to one abstract variable.
1045   DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1046   DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1047   if (AbsDbgVariable)
1048     return AbsDbgVariable;
1049
1050   LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1051   if (!Scope)
1052     return NULL;
1053
1054   AbsDbgVariable = new DbgVariable(Var, NULL);
1055   addScopeVariable(Scope, AbsDbgVariable);
1056   AbstractVariables[Var] = AbsDbgVariable;
1057   return AbsDbgVariable;
1058 }
1059
1060 // If Var is a current function argument then add it to CurrentFnArguments list.
1061 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1062                                       DbgVariable *Var, LexicalScope *Scope) {
1063   if (!LScopes.isCurrentFunctionScope(Scope))
1064     return false;
1065   DIVariable DV = Var->getVariable();
1066   if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1067     return false;
1068   unsigned ArgNo = DV.getArgNumber();
1069   if (ArgNo == 0)
1070     return false;
1071
1072   size_t Size = CurrentFnArguments.size();
1073   if (Size == 0)
1074     CurrentFnArguments.resize(MF->getFunction()->arg_size());
1075   // llvm::Function argument size is not good indicator of how many
1076   // arguments does the function have at source level.
1077   if (ArgNo > Size)
1078     CurrentFnArguments.resize(ArgNo * 2);
1079   CurrentFnArguments[ArgNo - 1] = Var;
1080   return true;
1081 }
1082
1083 // Collect variable information from side table maintained by MMI.
1084 void
1085 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1086                                    SmallPtrSet<const MDNode *, 16> &Processed) {
1087   MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1088   for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1089          VE = VMap.end(); VI != VE; ++VI) {
1090     const MDNode *Var = VI->first;
1091     if (!Var) continue;
1092     Processed.insert(Var);
1093     DIVariable DV(Var);
1094     const std::pair<unsigned, DebugLoc> &VP = VI->second;
1095
1096     LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1097
1098     // If variable scope is not found then skip this variable.
1099     if (Scope == 0)
1100       continue;
1101
1102     DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1103     DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1104     RegVar->setFrameIndex(VP.first);
1105     if (!addCurrentFnArgument(MF, RegVar, Scope))
1106       addScopeVariable(Scope, RegVar);
1107     if (AbsDbgVariable)
1108       AbsDbgVariable->setFrameIndex(VP.first);
1109   }
1110 }
1111
1112 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1113 // defined reg.
1114 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1115   assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1116   return MI->getNumOperands() == 3 &&
1117          MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1118          (MI->getOperand(1).isImm() ||
1119           (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1120 }
1121
1122 // Get .debug_loc entry for the instruction range starting at MI.
1123 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1124                                          const MCSymbol *FLabel,
1125                                          const MCSymbol *SLabel,
1126                                          const MachineInstr *MI) {
1127   const MDNode *Var =  MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1128
1129   if (MI->getNumOperands() != 3) {
1130     MachineLocation MLoc = Asm->getDebugValueLocation(MI);
1131     return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1132   }
1133   if (MI->getOperand(0).isReg()) {
1134     MachineLocation MLoc;
1135     // If the second operand is an immediate, this is a
1136     // register-indirect address.
1137     if (!MI->getOperand(1).isImm())
1138       MLoc.set(MI->getOperand(0).getReg());
1139     else
1140       MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1141     return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1142   }
1143   if (MI->getOperand(0).isImm())
1144     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1145   if (MI->getOperand(0).isFPImm())
1146     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1147   if (MI->getOperand(0).isCImm())
1148     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1149
1150   llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1151 }
1152
1153 // Find variables for each lexical scope.
1154 void
1155 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1156                                 SmallPtrSet<const MDNode *, 16> &Processed) {
1157
1158   // collection info from MMI table.
1159   collectVariableInfoFromMMITable(MF, Processed);
1160
1161   for (SmallVectorImpl<const MDNode*>::const_iterator
1162          UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1163          ++UVI) {
1164     const MDNode *Var = *UVI;
1165     if (Processed.count(Var))
1166       continue;
1167
1168     // History contains relevant DBG_VALUE instructions for Var and instructions
1169     // clobbering it.
1170     SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1171     if (History.empty())
1172       continue;
1173     const MachineInstr *MInsn = History.front();
1174
1175     DIVariable DV(Var);
1176     LexicalScope *Scope = NULL;
1177     if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1178         DISubprogram(DV.getContext()).describes(MF->getFunction()))
1179       Scope = LScopes.getCurrentFunctionScope();
1180     else if (MDNode *IA = DV.getInlinedAt())
1181       Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1182     else
1183       Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1184     // If variable scope is not found then skip this variable.
1185     if (!Scope)
1186       continue;
1187
1188     Processed.insert(DV);
1189     assert(MInsn->isDebugValue() && "History must begin with debug value");
1190     DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1191     DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1192     if (!addCurrentFnArgument(MF, RegVar, Scope))
1193       addScopeVariable(Scope, RegVar);
1194     if (AbsVar)
1195       AbsVar->setMInsn(MInsn);
1196
1197     // Simplify ranges that are fully coalesced.
1198     if (History.size() <= 1 || (History.size() == 2 &&
1199                                 MInsn->isIdenticalTo(History.back()))) {
1200       RegVar->setMInsn(MInsn);
1201       continue;
1202     }
1203
1204     // Handle multiple DBG_VALUE instructions describing one variable.
1205     RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1206
1207     for (SmallVectorImpl<const MachineInstr*>::const_iterator
1208            HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1209       const MachineInstr *Begin = *HI;
1210       assert(Begin->isDebugValue() && "Invalid History entry");
1211
1212       // Check if DBG_VALUE is truncating a range.
1213       if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1214           && !Begin->getOperand(0).getReg())
1215         continue;
1216
1217       // Compute the range for a register location.
1218       const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1219       const MCSymbol *SLabel = 0;
1220
1221       if (HI + 1 == HE)
1222         // If Begin is the last instruction in History then its value is valid
1223         // until the end of the function.
1224         SLabel = FunctionEndSym;
1225       else {
1226         const MachineInstr *End = HI[1];
1227         DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1228               << "\t" << *Begin << "\t" << *End << "\n");
1229         if (End->isDebugValue())
1230           SLabel = getLabelBeforeInsn(End);
1231         else {
1232           // End is a normal instruction clobbering the range.
1233           SLabel = getLabelAfterInsn(End);
1234           assert(SLabel && "Forgot label after clobber instruction");
1235           ++HI;
1236         }
1237       }
1238
1239       // The value is valid until the next DBG_VALUE or clobber.
1240       DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1241                                                     Begin));
1242     }
1243     DotDebugLocEntries.push_back(DotDebugLocEntry());
1244   }
1245
1246   // Collect info for variables that were optimized out.
1247   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1248   DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1249   for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1250     DIVariable DV(Variables.getElement(i));
1251     if (!DV || !DV.Verify() || !Processed.insert(DV))
1252       continue;
1253     if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1254       addScopeVariable(Scope, new DbgVariable(DV, NULL));
1255   }
1256 }
1257
1258 // Return Label preceding the instruction.
1259 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1260   MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1261   assert(Label && "Didn't insert label before instruction");
1262   return Label;
1263 }
1264
1265 // Return Label immediately following the instruction.
1266 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1267   return LabelsAfterInsn.lookup(MI);
1268 }
1269
1270 // Process beginning of an instruction.
1271 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1272   // Check if source location changes, but ignore DBG_VALUE locations.
1273   if (!MI->isDebugValue()) {
1274     DebugLoc DL = MI->getDebugLoc();
1275     if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1276       unsigned Flags = 0;
1277       PrevInstLoc = DL;
1278       if (DL == PrologEndLoc) {
1279         Flags |= DWARF2_FLAG_PROLOGUE_END;
1280         PrologEndLoc = DebugLoc();
1281       }
1282       if (PrologEndLoc.isUnknown())
1283         Flags |= DWARF2_FLAG_IS_STMT;
1284
1285       if (!DL.isUnknown()) {
1286         const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1287         recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1288       } else
1289         recordSourceLine(0, 0, 0, 0);
1290     }
1291   }
1292
1293   // Insert labels where requested.
1294   DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1295     LabelsBeforeInsn.find(MI);
1296
1297   // No label needed.
1298   if (I == LabelsBeforeInsn.end())
1299     return;
1300
1301   // Label already assigned.
1302   if (I->second)
1303     return;
1304
1305   if (!PrevLabel) {
1306     PrevLabel = MMI->getContext().CreateTempSymbol();
1307     Asm->OutStreamer.EmitLabel(PrevLabel);
1308   }
1309   I->second = PrevLabel;
1310 }
1311
1312 // Process end of an instruction.
1313 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1314   // Don't create a new label after DBG_VALUE instructions.
1315   // They don't generate code.
1316   if (!MI->isDebugValue())
1317     PrevLabel = 0;
1318
1319   DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1320     LabelsAfterInsn.find(MI);
1321
1322   // No label needed.
1323   if (I == LabelsAfterInsn.end())
1324     return;
1325
1326   // Label already assigned.
1327   if (I->second)
1328     return;
1329
1330   // We need a label after this instruction.
1331   if (!PrevLabel) {
1332     PrevLabel = MMI->getContext().CreateTempSymbol();
1333     Asm->OutStreamer.EmitLabel(PrevLabel);
1334   }
1335   I->second = PrevLabel;
1336 }
1337
1338 // Each LexicalScope has first instruction and last instruction to mark
1339 // beginning and end of a scope respectively. Create an inverse map that list
1340 // scopes starts (and ends) with an instruction. One instruction may start (or
1341 // end) multiple scopes. Ignore scopes that are not reachable.
1342 void DwarfDebug::identifyScopeMarkers() {
1343   SmallVector<LexicalScope *, 4> WorkList;
1344   WorkList.push_back(LScopes.getCurrentFunctionScope());
1345   while (!WorkList.empty()) {
1346     LexicalScope *S = WorkList.pop_back_val();
1347
1348     const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1349     if (!Children.empty())
1350       for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1351              SE = Children.end(); SI != SE; ++SI)
1352         WorkList.push_back(*SI);
1353
1354     if (S->isAbstractScope())
1355       continue;
1356
1357     const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1358     if (Ranges.empty())
1359       continue;
1360     for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1361            RE = Ranges.end(); RI != RE; ++RI) {
1362       assert(RI->first && "InsnRange does not have first instruction!");
1363       assert(RI->second && "InsnRange does not have second instruction!");
1364       requestLabelBeforeInsn(RI->first);
1365       requestLabelAfterInsn(RI->second);
1366     }
1367   }
1368 }
1369
1370 // Get MDNode for DebugLoc's scope.
1371 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1372   if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1373     return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1374   return DL.getScope(Ctx);
1375 }
1376
1377 // Walk up the scope chain of given debug loc and find line number info
1378 // for the function.
1379 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1380   const MDNode *Scope = getScopeNode(DL, Ctx);
1381   DISubprogram SP = getDISubprogram(Scope);
1382   if (SP.Verify()) {
1383     // Check for number of operands since the compatibility is
1384     // cheap here.
1385     if (SP->getNumOperands() > 19)
1386       return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1387     else
1388       return DebugLoc::get(SP.getLineNumber(), 0, SP);
1389   }
1390
1391   return DebugLoc();
1392 }
1393
1394 // Gather pre-function debug information.  Assumes being called immediately
1395 // after the function entry point has been emitted.
1396 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1397   if (!MMI->hasDebugInfo()) return;
1398   LScopes.initialize(*MF);
1399   if (LScopes.empty()) return;
1400   identifyScopeMarkers();
1401
1402   // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
1403   // belongs to.
1404   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1405   CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1406   assert(TheCU && "Unable to find compile unit!");
1407   Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1408
1409   FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1410                                         Asm->getFunctionNumber());
1411   // Assumes in correct section after the entry point.
1412   Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1413
1414   assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1415
1416   const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1417   // LiveUserVar - Map physreg numbers to the MDNode they contain.
1418   std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1419
1420   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1421        I != E; ++I) {
1422     bool AtBlockEntry = true;
1423     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1424          II != IE; ++II) {
1425       const MachineInstr *MI = II;
1426
1427       if (MI->isDebugValue()) {
1428         assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1429
1430         // Keep track of user variables.
1431         const MDNode *Var =
1432           MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1433
1434         // Variable is in a register, we need to check for clobbers.
1435         if (isDbgValueInDefinedReg(MI))
1436           LiveUserVar[MI->getOperand(0).getReg()] = Var;
1437
1438         // Check the history of this variable.
1439         SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1440         if (History.empty()) {
1441           UserVariables.push_back(Var);
1442           // The first mention of a function argument gets the FunctionBeginSym
1443           // label, so arguments are visible when breaking at function entry.
1444           DIVariable DV(Var);
1445           if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1446               DISubprogram(getDISubprogram(DV.getContext()))
1447                 .describes(MF->getFunction()))
1448             LabelsBeforeInsn[MI] = FunctionBeginSym;
1449         } else {
1450           // We have seen this variable before. Try to coalesce DBG_VALUEs.
1451           const MachineInstr *Prev = History.back();
1452           if (Prev->isDebugValue()) {
1453             // Coalesce identical entries at the end of History.
1454             if (History.size() >= 2 &&
1455                 Prev->isIdenticalTo(History[History.size() - 2])) {
1456               DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1457                     << "\t" << *Prev
1458                     << "\t" << *History[History.size() - 2] << "\n");
1459               History.pop_back();
1460             }
1461
1462             // Terminate old register assignments that don't reach MI;
1463             MachineFunction::const_iterator PrevMBB = Prev->getParent();
1464             if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1465                 isDbgValueInDefinedReg(Prev)) {
1466               // Previous register assignment needs to terminate at the end of
1467               // its basic block.
1468               MachineBasicBlock::const_iterator LastMI =
1469                 PrevMBB->getLastNonDebugInstr();
1470               if (LastMI == PrevMBB->end()) {
1471                 // Drop DBG_VALUE for empty range.
1472                 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1473                       << "\t" << *Prev << "\n");
1474                 History.pop_back();
1475               }
1476               else {
1477                 // Terminate after LastMI.
1478                 History.push_back(LastMI);
1479               }
1480             }
1481           }
1482         }
1483         History.push_back(MI);
1484       } else {
1485         // Not a DBG_VALUE instruction.
1486         if (!MI->isLabel())
1487           AtBlockEntry = false;
1488
1489         // First known non-DBG_VALUE and non-frame setup location marks
1490         // the beginning of the function body.
1491         if (!MI->getFlag(MachineInstr::FrameSetup) &&
1492             (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1493           PrologEndLoc = MI->getDebugLoc();
1494
1495         // Check if the instruction clobbers any registers with debug vars.
1496         for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1497                MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1498           if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1499             continue;
1500           for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1501                AI.isValid(); ++AI) {
1502             unsigned Reg = *AI;
1503             const MDNode *Var = LiveUserVar[Reg];
1504             if (!Var)
1505               continue;
1506             // Reg is now clobbered.
1507             LiveUserVar[Reg] = 0;
1508
1509             // Was MD last defined by a DBG_VALUE referring to Reg?
1510             DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1511             if (HistI == DbgValues.end())
1512               continue;
1513             SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1514             if (History.empty())
1515               continue;
1516             const MachineInstr *Prev = History.back();
1517             // Sanity-check: Register assignments are terminated at the end of
1518             // their block.
1519             if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1520               continue;
1521             // Is the variable still in Reg?
1522             if (!isDbgValueInDefinedReg(Prev) ||
1523                 Prev->getOperand(0).getReg() != Reg)
1524               continue;
1525             // Var is clobbered. Make sure the next instruction gets a label.
1526             History.push_back(MI);
1527           }
1528         }
1529       }
1530     }
1531   }
1532
1533   for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1534        I != E; ++I) {
1535     SmallVectorImpl<const MachineInstr*> &History = I->second;
1536     if (History.empty())
1537       continue;
1538
1539     // Make sure the final register assignments are terminated.
1540     const MachineInstr *Prev = History.back();
1541     if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1542       const MachineBasicBlock *PrevMBB = Prev->getParent();
1543       MachineBasicBlock::const_iterator LastMI =
1544         PrevMBB->getLastNonDebugInstr();
1545       if (LastMI == PrevMBB->end())
1546         // Drop DBG_VALUE for empty range.
1547         History.pop_back();
1548       else {
1549         // Terminate after LastMI.
1550         History.push_back(LastMI);
1551       }
1552     }
1553     // Request labels for the full history.
1554     for (unsigned i = 0, e = History.size(); i != e; ++i) {
1555       const MachineInstr *MI = History[i];
1556       if (MI->isDebugValue())
1557         requestLabelBeforeInsn(MI);
1558       else
1559         requestLabelAfterInsn(MI);
1560     }
1561   }
1562
1563   PrevInstLoc = DebugLoc();
1564   PrevLabel = FunctionBeginSym;
1565
1566   // Record beginning of function.
1567   if (!PrologEndLoc.isUnknown()) {
1568     DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1569                                        MF->getFunction()->getContext());
1570     recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1571                      FnStartDL.getScope(MF->getFunction()->getContext()),
1572     // We'd like to list the prologue as "not statements" but GDB behaves
1573     // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1574                      DWARF2_FLAG_IS_STMT);
1575   }
1576 }
1577
1578 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1579 //  SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1580   ScopeVariables[LS].push_back(Var);
1581 //  Vars.push_back(Var);
1582 }
1583
1584 // Gather and emit post-function debug information.
1585 void DwarfDebug::endFunction(const MachineFunction *MF) {
1586   if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1587
1588   // Define end label for subprogram.
1589   FunctionEndSym = Asm->GetTempSymbol("func_end",
1590                                       Asm->getFunctionNumber());
1591   // Assumes in correct section after the entry point.
1592   Asm->OutStreamer.EmitLabel(FunctionEndSym);
1593   // Set DwarfCompileUnitID in MCContext to default value.
1594   Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1595
1596   SmallPtrSet<const MDNode *, 16> ProcessedVars;
1597   collectVariableInfo(MF, ProcessedVars);
1598
1599   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1600   CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1601   assert(TheCU && "Unable to find compile unit!");
1602
1603   // Construct abstract scopes.
1604   ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1605   for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1606     LexicalScope *AScope = AList[i];
1607     DISubprogram SP(AScope->getScopeNode());
1608     if (SP.Verify()) {
1609       // Collect info for variables that were optimized out.
1610       DIArray Variables = SP.getVariables();
1611       for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1612         DIVariable DV(Variables.getElement(i));
1613         if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1614           continue;
1615         // Check that DbgVariable for DV wasn't created earlier, when
1616         // findAbstractVariable() was called for inlined instance of DV.
1617         LLVMContext &Ctx = DV->getContext();
1618         DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1619         if (AbstractVariables.lookup(CleanDV))
1620           continue;
1621         if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1622           addScopeVariable(Scope, new DbgVariable(DV, NULL));
1623       }
1624     }
1625     if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1626       constructScopeDIE(TheCU, AScope);
1627   }
1628
1629   DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1630
1631   if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1632     TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1633
1634   DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1635                                                MMI->getFrameMoves()));
1636
1637   // Clear debug info
1638   for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1639          I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1640     DeleteContainerPointers(I->second);
1641   ScopeVariables.clear();
1642   DeleteContainerPointers(CurrentFnArguments);
1643   UserVariables.clear();
1644   DbgValues.clear();
1645   AbstractVariables.clear();
1646   LabelsBeforeInsn.clear();
1647   LabelsAfterInsn.clear();
1648   PrevLabel = NULL;
1649 }
1650
1651 // Register a source line with debug info. Returns the  unique label that was
1652 // emitted and which provides correspondence to the source line list.
1653 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1654                                   unsigned Flags) {
1655   StringRef Fn;
1656   StringRef Dir;
1657   unsigned Src = 1;
1658   if (S) {
1659     DIDescriptor Scope(S);
1660
1661     if (Scope.isCompileUnit()) {
1662       DICompileUnit CU(S);
1663       Fn = CU.getFilename();
1664       Dir = CU.getDirectory();
1665     } else if (Scope.isFile()) {
1666       DIFile F(S);
1667       Fn = F.getFilename();
1668       Dir = F.getDirectory();
1669     } else if (Scope.isSubprogram()) {
1670       DISubprogram SP(S);
1671       Fn = SP.getFilename();
1672       Dir = SP.getDirectory();
1673     } else if (Scope.isLexicalBlockFile()) {
1674       DILexicalBlockFile DBF(S);
1675       Fn = DBF.getFilename();
1676       Dir = DBF.getDirectory();
1677     } else if (Scope.isLexicalBlock()) {
1678       DILexicalBlock DB(S);
1679       Fn = DB.getFilename();
1680       Dir = DB.getDirectory();
1681     } else
1682       llvm_unreachable("Unexpected scope info");
1683
1684     Src = getOrCreateSourceID(Fn, Dir,
1685             Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1686   }
1687   Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1688 }
1689
1690 //===----------------------------------------------------------------------===//
1691 // Emit Methods
1692 //===----------------------------------------------------------------------===//
1693
1694 // Compute the size and offset of a DIE.
1695 unsigned
1696 DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1697   // Get the children.
1698   const std::vector<DIE *> &Children = Die->getChildren();
1699
1700   // Record the abbreviation.
1701   assignAbbrevNumber(Die->getAbbrev());
1702
1703   // Get the abbreviation for this DIE.
1704   unsigned AbbrevNumber = Die->getAbbrevNumber();
1705   const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1);
1706
1707   // Set DIE offset
1708   Die->setOffset(Offset);
1709
1710   // Start the size with the size of abbreviation code.
1711   Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1712
1713   const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1714   const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1715
1716   // Size the DIE attribute values.
1717   for (unsigned i = 0, N = Values.size(); i < N; ++i)
1718     // Size attribute value.
1719     Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1720
1721   // Size the DIE children if any.
1722   if (!Children.empty()) {
1723     assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1724            "Children flag not set");
1725
1726     for (unsigned j = 0, M = Children.size(); j < M; ++j)
1727       Offset = computeSizeAndOffset(Children[j], Offset);
1728
1729     // End of children marker.
1730     Offset += sizeof(int8_t);
1731   }
1732
1733   Die->setSize(Offset - Die->getOffset());
1734   return Offset;
1735 }
1736
1737 // Compute the size and offset of all the DIEs.
1738 void DwarfUnits::computeSizeAndOffsets() {
1739   // Offset from the beginning of debug info section.
1740   unsigned AccuOffset = 0;
1741   for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1742          E = CUs.end(); I != E; ++I) {
1743     (*I)->setDebugInfoOffset(AccuOffset);
1744     unsigned Offset =
1745       sizeof(int32_t) + // Length of Compilation Unit Info
1746       sizeof(int16_t) + // DWARF version number
1747       sizeof(int32_t) + // Offset Into Abbrev. Section
1748       sizeof(int8_t);   // Pointer Size (in bytes)
1749
1750     unsigned EndOffset = computeSizeAndOffset((*I)->getCUDie(), Offset);
1751     AccuOffset += EndOffset;
1752   }
1753 }
1754
1755 // Emit initial Dwarf sections with a label at the start of each one.
1756 void DwarfDebug::emitSectionLabels() {
1757   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1758
1759   // Dwarf sections base addresses.
1760   DwarfInfoSectionSym =
1761     emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1762   DwarfAbbrevSectionSym =
1763     emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1764   if (useSplitDwarf())
1765     DwarfAbbrevDWOSectionSym =
1766       emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(),
1767                      "section_abbrev_dwo");
1768   emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1769
1770   if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1771     emitSectionSym(Asm, MacroInfo);
1772
1773   DwarfLineSectionSym =
1774     emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1775   emitSectionSym(Asm, TLOF.getDwarfLocSection());
1776   if (GenerateDwarfPubNamesSection)
1777     emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1778   emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1779   DwarfStrSectionSym =
1780     emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1781   if (useSplitDwarf()) {
1782     DwarfStrDWOSectionSym =
1783       emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1784     DwarfAddrSectionSym =
1785       emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1786   }
1787   DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1788                                              "debug_range");
1789
1790   DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
1791                                            "section_debug_loc");
1792
1793   TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1794   emitSectionSym(Asm, TLOF.getDataSection());
1795 }
1796
1797 // Recursively emits a debug information entry.
1798 void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) {
1799   // Get the abbreviation for this DIE.
1800   unsigned AbbrevNumber = Die->getAbbrevNumber();
1801   const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1);
1802
1803   // Emit the code (index) for the abbreviation.
1804   if (Asm->isVerbose())
1805     Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1806                                 Twine::utohexstr(Die->getOffset()) + ":0x" +
1807                                 Twine::utohexstr(Die->getSize()) + " " +
1808                                 dwarf::TagString(Abbrev->getTag()));
1809   Asm->EmitULEB128(AbbrevNumber);
1810
1811   const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1812   const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1813
1814   // Emit the DIE attribute values.
1815   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1816     unsigned Attr = AbbrevData[i].getAttribute();
1817     unsigned Form = AbbrevData[i].getForm();
1818     assert(Form && "Too many attributes for DIE (check abbreviation)");
1819
1820     if (Asm->isVerbose())
1821       Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1822
1823     switch (Attr) {
1824     case dwarf::DW_AT_abstract_origin: {
1825       DIEEntry *E = cast<DIEEntry>(Values[i]);
1826       DIE *Origin = E->getEntry();
1827       unsigned Addr = Origin->getOffset();
1828       if (Form == dwarf::DW_FORM_ref_addr) {
1829         // For DW_FORM_ref_addr, output the offset from beginning of debug info
1830         // section. Origin->getOffset() returns the offset from start of the
1831         // compile unit.
1832         DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1833         Addr += Holder.getCUOffset(Origin->getCompileUnit());
1834       }
1835       Asm->EmitInt32(Addr);
1836       break;
1837     }
1838     case dwarf::DW_AT_ranges: {
1839       // DW_AT_range Value encodes offset in debug_range section.
1840       DIEInteger *V = cast<DIEInteger>(Values[i]);
1841
1842       if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
1843         Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1844                                  V->getValue(),
1845                                  4);
1846       } else {
1847         Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1848                                        V->getValue(),
1849                                        DwarfDebugRangeSectionSym,
1850                                        4);
1851       }
1852       break;
1853     }
1854     case dwarf::DW_AT_location: {
1855       if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
1856         if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1857           Asm->EmitLabelReference(L->getValue(), 4);
1858         else
1859           Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1860       } else {
1861         Values[i]->EmitValue(Asm, Form);
1862       }
1863       break;
1864     }
1865     case dwarf::DW_AT_accessibility: {
1866       if (Asm->isVerbose()) {
1867         DIEInteger *V = cast<DIEInteger>(Values[i]);
1868         Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1869       }
1870       Values[i]->EmitValue(Asm, Form);
1871       break;
1872     }
1873     default:
1874       // Emit an attribute using the defined form.
1875       Values[i]->EmitValue(Asm, Form);
1876       break;
1877     }
1878   }
1879
1880   // Emit the DIE children if any.
1881   if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1882     const std::vector<DIE *> &Children = Die->getChildren();
1883
1884     for (unsigned j = 0, M = Children.size(); j < M; ++j)
1885       emitDIE(Children[j], Abbrevs);
1886
1887     if (Asm->isVerbose())
1888       Asm->OutStreamer.AddComment("End Of Children Mark");
1889     Asm->EmitInt8(0);
1890   }
1891 }
1892
1893 // Emit the various dwarf units to the unit section USection with
1894 // the abbreviations going into ASection.
1895 void DwarfUnits::emitUnits(DwarfDebug *DD,
1896                            const MCSection *USection,
1897                            const MCSection *ASection,
1898                            const MCSymbol *ASectionSym) {
1899   Asm->OutStreamer.SwitchSection(USection);
1900   for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1901          E = CUs.end(); I != E; ++I) {
1902     CompileUnit *TheCU = *I;
1903     DIE *Die = TheCU->getCUDie();
1904
1905     // Emit the compile units header.
1906     Asm->OutStreamer
1907       .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(),
1908                                     TheCU->getUniqueID()));
1909
1910     // Emit size of content not including length itself
1911     unsigned ContentSize = Die->getSize() +
1912       sizeof(int16_t) + // DWARF version number
1913       sizeof(int32_t) + // Offset Into Abbrev. Section
1914       sizeof(int8_t);   // Pointer Size (in bytes)
1915
1916     Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1917     Asm->EmitInt32(ContentSize);
1918     Asm->OutStreamer.AddComment("DWARF version number");
1919     Asm->EmitInt16(dwarf::DWARF_VERSION);
1920     Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1921     Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
1922                            ASectionSym);
1923     Asm->OutStreamer.AddComment("Address Size (in bytes)");
1924     Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1925
1926     DD->emitDIE(Die, Abbreviations);
1927     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(),
1928                                                   TheCU->getUniqueID()));
1929   }
1930 }
1931
1932 /// For a given compile unit DIE, returns offset from beginning of debug info.
1933 unsigned DwarfUnits::getCUOffset(DIE *Die) {
1934   assert(Die->getTag() == dwarf::DW_TAG_compile_unit  &&
1935          "Input DIE should be compile unit in getCUOffset.");
1936   for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1937        E = CUs.end(); I != E; ++I) {
1938     CompileUnit *TheCU = *I;
1939     if (TheCU->getCUDie() == Die)
1940       return TheCU->getDebugInfoOffset();
1941   }
1942   llvm_unreachable("The compile unit DIE should belong to CUs in DwarfUnits.");
1943 }
1944
1945 // Emit the debug info section.
1946 void DwarfDebug::emitDebugInfo() {
1947   DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1948
1949   Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
1950                    Asm->getObjFileLowering().getDwarfAbbrevSection(),
1951                    DwarfAbbrevSectionSym);
1952 }
1953
1954 // Emit the abbreviation section.
1955 void DwarfDebug::emitAbbreviations() {
1956   if (!useSplitDwarf())
1957     emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
1958                 &Abbreviations);
1959   else
1960     emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
1961 }
1962
1963 void DwarfDebug::emitAbbrevs(const MCSection *Section,
1964                              std::vector<DIEAbbrev *> *Abbrevs) {
1965   // Check to see if it is worth the effort.
1966   if (!Abbrevs->empty()) {
1967     // Start the debug abbrev section.
1968     Asm->OutStreamer.SwitchSection(Section);
1969
1970     MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
1971     Asm->OutStreamer.EmitLabel(Begin);
1972
1973     // For each abbrevation.
1974     for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
1975       // Get abbreviation data
1976       const DIEAbbrev *Abbrev = Abbrevs->at(i);
1977
1978       // Emit the abbrevations code (base 1 index.)
1979       Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1980
1981       // Emit the abbreviations data.
1982       Abbrev->Emit(Asm);
1983     }
1984
1985     // Mark end of abbreviations.
1986     Asm->EmitULEB128(0, "EOM(3)");
1987
1988     MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
1989     Asm->OutStreamer.EmitLabel(End);
1990   }
1991 }
1992
1993 // Emit the last address of the section and the end of the line matrix.
1994 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1995   // Define last address of section.
1996   Asm->OutStreamer.AddComment("Extended Op");
1997   Asm->EmitInt8(0);
1998
1999   Asm->OutStreamer.AddComment("Op size");
2000   Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2001   Asm->OutStreamer.AddComment("DW_LNE_set_address");
2002   Asm->EmitInt8(dwarf::DW_LNE_set_address);
2003
2004   Asm->OutStreamer.AddComment("Section end label");
2005
2006   Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2007                                    Asm->getDataLayout().getPointerSize());
2008
2009   // Mark end of matrix.
2010   Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2011   Asm->EmitInt8(0);
2012   Asm->EmitInt8(1);
2013   Asm->EmitInt8(1);
2014 }
2015
2016 // Emit visible names into a hashed accelerator table section.
2017 void DwarfDebug::emitAccelNames() {
2018   DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2019                                            dwarf::DW_FORM_data4));
2020   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2021          E = CUMap.end(); I != E; ++I) {
2022     CompileUnit *TheCU = I->second;
2023     const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
2024     for (StringMap<std::vector<DIE*> >::const_iterator
2025            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2026       const char *Name = GI->getKeyData();
2027       const std::vector<DIE *> &Entities = GI->second;
2028       for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2029              DE = Entities.end(); DI != DE; ++DI)
2030         AT.AddName(Name, (*DI));
2031     }
2032   }
2033
2034   AT.FinalizeTable(Asm, "Names");
2035   Asm->OutStreamer.SwitchSection(
2036     Asm->getObjFileLowering().getDwarfAccelNamesSection());
2037   MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2038   Asm->OutStreamer.EmitLabel(SectionBegin);
2039
2040   // Emit the full data.
2041   AT.Emit(Asm, SectionBegin, &InfoHolder);
2042 }
2043
2044 // Emit objective C classes and categories into a hashed accelerator table
2045 // section.
2046 void DwarfDebug::emitAccelObjC() {
2047   DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2048                                            dwarf::DW_FORM_data4));
2049   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2050          E = CUMap.end(); I != E; ++I) {
2051     CompileUnit *TheCU = I->second;
2052     const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
2053     for (StringMap<std::vector<DIE*> >::const_iterator
2054            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2055       const char *Name = GI->getKeyData();
2056       const std::vector<DIE *> &Entities = GI->second;
2057       for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2058              DE = Entities.end(); DI != DE; ++DI)
2059         AT.AddName(Name, (*DI));
2060     }
2061   }
2062
2063   AT.FinalizeTable(Asm, "ObjC");
2064   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2065                                  .getDwarfAccelObjCSection());
2066   MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2067   Asm->OutStreamer.EmitLabel(SectionBegin);
2068
2069   // Emit the full data.
2070   AT.Emit(Asm, SectionBegin, &InfoHolder);
2071 }
2072
2073 // Emit namespace dies into a hashed accelerator table.
2074 void DwarfDebug::emitAccelNamespaces() {
2075   DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2076                                            dwarf::DW_FORM_data4));
2077   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2078          E = CUMap.end(); I != E; ++I) {
2079     CompileUnit *TheCU = I->second;
2080     const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
2081     for (StringMap<std::vector<DIE*> >::const_iterator
2082            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2083       const char *Name = GI->getKeyData();
2084       const std::vector<DIE *> &Entities = GI->second;
2085       for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2086              DE = Entities.end(); DI != DE; ++DI)
2087         AT.AddName(Name, (*DI));
2088     }
2089   }
2090
2091   AT.FinalizeTable(Asm, "namespac");
2092   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2093                                  .getDwarfAccelNamespaceSection());
2094   MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2095   Asm->OutStreamer.EmitLabel(SectionBegin);
2096
2097   // Emit the full data.
2098   AT.Emit(Asm, SectionBegin, &InfoHolder);
2099 }
2100
2101 // Emit type dies into a hashed accelerator table.
2102 void DwarfDebug::emitAccelTypes() {
2103   std::vector<DwarfAccelTable::Atom> Atoms;
2104   Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2105                                         dwarf::DW_FORM_data4));
2106   Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
2107                                         dwarf::DW_FORM_data2));
2108   Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
2109                                         dwarf::DW_FORM_data1));
2110   DwarfAccelTable AT(Atoms);
2111   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2112          E = CUMap.end(); I != E; ++I) {
2113     CompileUnit *TheCU = I->second;
2114     const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2115       = TheCU->getAccelTypes();
2116     for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2117            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2118       const char *Name = GI->getKeyData();
2119       const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2120       for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2121              = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2122         AT.AddName(Name, (*DI).first, (*DI).second);
2123     }
2124   }
2125
2126   AT.FinalizeTable(Asm, "types");
2127   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2128                                  .getDwarfAccelTypesSection());
2129   MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2130   Asm->OutStreamer.EmitLabel(SectionBegin);
2131
2132   // Emit the full data.
2133   AT.Emit(Asm, SectionBegin, &InfoHolder);
2134 }
2135
2136 /// emitDebugPubnames - Emit visible names into a debug pubnames section.
2137 ///
2138 void DwarfDebug::emitDebugPubnames() {
2139   const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2140
2141   typedef DenseMap<const MDNode*, CompileUnit*> CUMapType;
2142   for (CUMapType::iterator I = CUMap.begin(), E = CUMap.end(); I != E; ++I) {
2143     CompileUnit *TheCU = I->second;
2144     unsigned ID = TheCU->getUniqueID();
2145
2146     if (TheCU->getGlobalNames().empty())
2147       continue;
2148
2149     // Start the dwarf pubnames section.
2150     Asm->OutStreamer.SwitchSection(
2151       Asm->getObjFileLowering().getDwarfPubNamesSection());
2152
2153     Asm->OutStreamer.AddComment("Length of Public Names Info");
2154     Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID),
2155                              Asm->GetTempSymbol("pubnames_begin", ID), 4);
2156
2157     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID));
2158
2159     Asm->OutStreamer.AddComment("DWARF Version");
2160     Asm->EmitInt16(dwarf::DWARF_VERSION);
2161
2162     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2163     Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2164                            DwarfInfoSectionSym);
2165
2166     Asm->OutStreamer.AddComment("Compilation Unit Length");
2167     Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2168                              Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2169                              4);
2170
2171     const StringMap<DIE*> &Globals = TheCU->getGlobalNames();
2172     for (StringMap<DIE*>::const_iterator
2173            GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2174       const char *Name = GI->getKeyData();
2175       const DIE *Entity = GI->second;
2176
2177       Asm->OutStreamer.AddComment("DIE offset");
2178       Asm->EmitInt32(Entity->getOffset());
2179
2180       if (Asm->isVerbose())
2181         Asm->OutStreamer.AddComment("External Name");
2182       Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2183     }
2184
2185     Asm->OutStreamer.AddComment("End Mark");
2186     Asm->EmitInt32(0);
2187     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID));
2188   }
2189 }
2190
2191 void DwarfDebug::emitDebugPubTypes() {
2192   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2193          E = CUMap.end(); I != E; ++I) {
2194     CompileUnit *TheCU = I->second;
2195     // Start the dwarf pubtypes section.
2196     Asm->OutStreamer.SwitchSection(
2197       Asm->getObjFileLowering().getDwarfPubTypesSection());
2198     Asm->OutStreamer.AddComment("Length of Public Types Info");
2199     Asm->EmitLabelDifference(
2200       Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2201       Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2202
2203     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2204                                                   TheCU->getUniqueID()));
2205
2206     if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2207     Asm->EmitInt16(dwarf::DWARF_VERSION);
2208
2209     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2210     const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2211     Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(),
2212                                               TheCU->getUniqueID()),
2213                            DwarfInfoSectionSym);
2214
2215     Asm->OutStreamer.AddComment("Compilation Unit Length");
2216     Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(),
2217                                                 TheCU->getUniqueID()),
2218                              Asm->GetTempSymbol(ISec->getLabelBeginName(),
2219                                                 TheCU->getUniqueID()),
2220                              4);
2221
2222     const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2223     for (StringMap<DIE*>::const_iterator
2224            GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2225       const char *Name = GI->getKeyData();
2226       DIE *Entity = GI->second;
2227
2228       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2229       Asm->EmitInt32(Entity->getOffset());
2230
2231       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2232       // Emit the name with a terminating null byte.
2233       Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2234     }
2235
2236     Asm->OutStreamer.AddComment("End Mark");
2237     Asm->EmitInt32(0);
2238     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2239                                                   TheCU->getUniqueID()));
2240   }
2241 }
2242
2243 // Emit strings into a string section.
2244 void DwarfUnits::emitStrings(const MCSection *StrSection,
2245                              const MCSection *OffsetSection = NULL,
2246                              const MCSymbol *StrSecSym = NULL) {
2247
2248   if (StringPool.empty()) return;
2249
2250   // Start the dwarf str section.
2251   Asm->OutStreamer.SwitchSection(StrSection);
2252
2253   // Get all of the string pool entries and put them in an array by their ID so
2254   // we can sort them.
2255   SmallVector<std::pair<unsigned,
2256                  StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2257
2258   for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2259          I = StringPool.begin(), E = StringPool.end();
2260        I != E; ++I)
2261     Entries.push_back(std::make_pair(I->second.second, &*I));
2262
2263   array_pod_sort(Entries.begin(), Entries.end());
2264
2265   for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2266     // Emit a label for reference from debug information entries.
2267     Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2268
2269     // Emit the string itself with a terminating null byte.
2270     Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2271                                          Entries[i].second->getKeyLength()+1));
2272   }
2273
2274   // If we've got an offset section go ahead and emit that now as well.
2275   if (OffsetSection) {
2276     Asm->OutStreamer.SwitchSection(OffsetSection);
2277     unsigned offset = 0;
2278     unsigned size = 4; // FIXME: DWARF64 is 8.
2279     for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2280       Asm->OutStreamer.EmitIntValue(offset, size);
2281       offset += Entries[i].second->getKeyLength() + 1;
2282     }
2283   }
2284 }
2285
2286 // Emit strings into a string section.
2287 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2288
2289   if (AddressPool.empty()) return;
2290
2291   // Start the dwarf addr section.
2292   Asm->OutStreamer.SwitchSection(AddrSection);
2293
2294   // Get all of the string pool entries and put them in an array by their ID so
2295   // we can sort them.
2296   SmallVector<std::pair<unsigned,
2297                         std::pair<MCSymbol*, unsigned>* >, 64> Entries;
2298
2299   for (DenseMap<MCSymbol*, std::pair<MCSymbol*, unsigned> >::iterator
2300          I = AddressPool.begin(), E = AddressPool.end();
2301        I != E; ++I)
2302     Entries.push_back(std::make_pair(I->second.second, &(I->second)));
2303
2304   array_pod_sort(Entries.begin(), Entries.end());
2305
2306   for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2307     // Emit a label for reference from debug information entries.
2308     MCSymbol *Sym = Entries[i].second->first;
2309     if (Sym)
2310       Asm->EmitLabelReference(Entries[i].second->first,
2311                               Asm->getDataLayout().getPointerSize());
2312     else
2313       Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2314   }
2315
2316 }
2317
2318 // Emit visible names into a debug str section.
2319 void DwarfDebug::emitDebugStr() {
2320   DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2321   Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2322 }
2323
2324 // Emit visible names into a debug loc section.
2325 void DwarfDebug::emitDebugLoc() {
2326   if (DotDebugLocEntries.empty())
2327     return;
2328
2329   for (SmallVectorImpl<DotDebugLocEntry>::iterator
2330          I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2331        I != E; ++I) {
2332     DotDebugLocEntry &Entry = *I;
2333     if (I + 1 != DotDebugLocEntries.end())
2334       Entry.Merge(I+1);
2335   }
2336
2337   // Start the dwarf loc section.
2338   Asm->OutStreamer.SwitchSection(
2339     Asm->getObjFileLowering().getDwarfLocSection());
2340   unsigned char Size = Asm->getDataLayout().getPointerSize();
2341   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2342   unsigned index = 1;
2343   for (SmallVectorImpl<DotDebugLocEntry>::iterator
2344          I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2345        I != E; ++I, ++index) {
2346     DotDebugLocEntry &Entry = *I;
2347     if (Entry.isMerged()) continue;
2348     if (Entry.isEmpty()) {
2349       Asm->OutStreamer.EmitIntValue(0, Size);
2350       Asm->OutStreamer.EmitIntValue(0, Size);
2351       Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2352     } else {
2353       Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size);
2354       Asm->OutStreamer.EmitSymbolValue(Entry.End, Size);
2355       DIVariable DV(Entry.Variable);
2356       Asm->OutStreamer.AddComment("Loc expr size");
2357       MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2358       MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2359       Asm->EmitLabelDifference(end, begin, 2);
2360       Asm->OutStreamer.EmitLabel(begin);
2361       if (Entry.isInt()) {
2362         DIBasicType BTy(DV.getType());
2363         if (BTy.Verify() &&
2364             (BTy.getEncoding()  == dwarf::DW_ATE_signed
2365              || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2366           Asm->OutStreamer.AddComment("DW_OP_consts");
2367           Asm->EmitInt8(dwarf::DW_OP_consts);
2368           Asm->EmitSLEB128(Entry.getInt());
2369         } else {
2370           Asm->OutStreamer.AddComment("DW_OP_constu");
2371           Asm->EmitInt8(dwarf::DW_OP_constu);
2372           Asm->EmitULEB128(Entry.getInt());
2373         }
2374       } else if (Entry.isLocation()) {
2375         if (!DV.hasComplexAddress())
2376           // Regular entry.
2377           Asm->EmitDwarfRegOp(Entry.Loc);
2378         else {
2379           // Complex address entry.
2380           unsigned N = DV.getNumAddrElements();
2381           unsigned i = 0;
2382           if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2383             if (Entry.Loc.getOffset()) {
2384               i = 2;
2385               Asm->EmitDwarfRegOp(Entry.Loc);
2386               Asm->OutStreamer.AddComment("DW_OP_deref");
2387               Asm->EmitInt8(dwarf::DW_OP_deref);
2388               Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2389               Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2390               Asm->EmitSLEB128(DV.getAddrElement(1));
2391             } else {
2392               // If first address element is OpPlus then emit
2393               // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2394               MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2395               Asm->EmitDwarfRegOp(Loc);
2396               i = 2;
2397             }
2398           } else {
2399             Asm->EmitDwarfRegOp(Entry.Loc);
2400           }
2401
2402           // Emit remaining complex address elements.
2403           for (; i < N; ++i) {
2404             uint64_t Element = DV.getAddrElement(i);
2405             if (Element == DIBuilder::OpPlus) {
2406               Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2407               Asm->EmitULEB128(DV.getAddrElement(++i));
2408             } else if (Element == DIBuilder::OpDeref) {
2409               if (!Entry.Loc.isReg())
2410                 Asm->EmitInt8(dwarf::DW_OP_deref);
2411             } else
2412               llvm_unreachable("unknown Opcode found in complex address");
2413           }
2414         }
2415       }
2416       // else ... ignore constant fp. There is not any good way to
2417       // to represent them here in dwarf.
2418       Asm->OutStreamer.EmitLabel(end);
2419     }
2420   }
2421 }
2422
2423 // Emit visible names into a debug aranges section.
2424 void DwarfDebug::emitDebugARanges() {
2425   // Start the dwarf aranges section.
2426   Asm->OutStreamer.SwitchSection(
2427                           Asm->getObjFileLowering().getDwarfARangesSection());
2428 }
2429
2430 // Emit visible names into a debug ranges section.
2431 void DwarfDebug::emitDebugRanges() {
2432   // Start the dwarf ranges section.
2433   Asm->OutStreamer.SwitchSection(
2434     Asm->getObjFileLowering().getDwarfRangesSection());
2435   unsigned char Size = Asm->getDataLayout().getPointerSize();
2436   for (SmallVectorImpl<const MCSymbol *>::iterator
2437          I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2438        I != E; ++I) {
2439     if (*I)
2440       Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size);
2441     else
2442       Asm->OutStreamer.EmitIntValue(0, Size);
2443   }
2444 }
2445
2446 // Emit visible names into a debug macinfo section.
2447 void DwarfDebug::emitDebugMacInfo() {
2448   if (const MCSection *LineInfo =
2449       Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2450     // Start the dwarf macinfo section.
2451     Asm->OutStreamer.SwitchSection(LineInfo);
2452   }
2453 }
2454
2455 // Emit inline info using following format.
2456 // Section Header:
2457 // 1. length of section
2458 // 2. Dwarf version number
2459 // 3. address size.
2460 //
2461 // Entries (one "entry" for each function that was inlined):
2462 //
2463 // 1. offset into __debug_str section for MIPS linkage name, if exists;
2464 //   otherwise offset into __debug_str for regular function name.
2465 // 2. offset into __debug_str section for regular function name.
2466 // 3. an unsigned LEB128 number indicating the number of distinct inlining
2467 // instances for the function.
2468 //
2469 // The rest of the entry consists of a {die_offset, low_pc} pair for each
2470 // inlined instance; the die_offset points to the inlined_subroutine die in the
2471 // __debug_info section, and the low_pc is the starting address for the
2472 // inlining instance.
2473 void DwarfDebug::emitDebugInlineInfo() {
2474   if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2475     return;
2476
2477   if (!FirstCU)
2478     return;
2479
2480   Asm->OutStreamer.SwitchSection(
2481                         Asm->getObjFileLowering().getDwarfDebugInlineSection());
2482
2483   Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2484   Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2485                            Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2486
2487   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2488
2489   Asm->OutStreamer.AddComment("Dwarf Version");
2490   Asm->EmitInt16(dwarf::DWARF_VERSION);
2491   Asm->OutStreamer.AddComment("Address Size (in bytes)");
2492   Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2493
2494   for (SmallVectorImpl<const MDNode *>::iterator I = InlinedSPNodes.begin(),
2495          E = InlinedSPNodes.end(); I != E; ++I) {
2496
2497     const MDNode *Node = *I;
2498     DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2499       = InlineInfo.find(Node);
2500     SmallVectorImpl<InlineInfoLabels> &Labels = II->second;
2501     DISubprogram SP(Node);
2502     StringRef LName = SP.getLinkageName();
2503     StringRef Name = SP.getName();
2504
2505     Asm->OutStreamer.AddComment("MIPS linkage name");
2506     if (LName.empty())
2507       Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2508                              DwarfStrSectionSym);
2509     else
2510       Asm->EmitSectionOffset(InfoHolder
2511                              .getStringPoolEntry(getRealLinkageName(LName)),
2512                              DwarfStrSectionSym);
2513
2514     Asm->OutStreamer.AddComment("Function name");
2515     Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2516                            DwarfStrSectionSym);
2517     Asm->EmitULEB128(Labels.size(), "Inline count");
2518
2519     for (SmallVectorImpl<InlineInfoLabels>::iterator LI = Labels.begin(),
2520            LE = Labels.end(); LI != LE; ++LI) {
2521       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2522       Asm->EmitInt32(LI->second->getOffset());
2523
2524       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2525       Asm->OutStreamer.EmitSymbolValue(LI->first,
2526                                        Asm->getDataLayout().getPointerSize());
2527     }
2528   }
2529
2530   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2531 }
2532
2533 // DWARF5 Experimental Separate Dwarf emitters.
2534
2535 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2536 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2537 // DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present,
2538 // DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa.
2539 CompileUnit *DwarfDebug::constructSkeletonCU(const MDNode *N) {
2540   DICompileUnit DIUnit(N);
2541   CompilationDir = DIUnit.getDirectory();
2542
2543   DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2544   CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
2545                                        DIUnit.getLanguage(), Die, Asm,
2546                                        this, &SkeletonHolder);
2547
2548   NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2549                         DIUnit.getSplitDebugFilename());
2550
2551   // This should be a unique identifier when we want to build .dwp files.
2552   NewCU->addUInt(Die, dwarf::DW_AT_GNU_dwo_id, dwarf::DW_FORM_data8, 0);
2553
2554   // Relocate to the beginning of the addr_base section, else 0 for the
2555   // beginning of the one for this compile unit.
2556   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2557     NewCU->addLabel(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset,
2558                     DwarfAddrSectionSym);
2559   else
2560     NewCU->addUInt(Die, dwarf::DW_AT_GNU_addr_base,
2561                    dwarf::DW_FORM_sec_offset, 0);
2562
2563   // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2564   // into an entity. We're using 0, or a NULL label for this.
2565   NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2566
2567   // DW_AT_stmt_list is a offset of line number information for this
2568   // compile unit in debug_line section.
2569   // FIXME: Should handle multiple compile units.
2570   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2571     NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
2572                     DwarfLineSectionSym);
2573   else
2574     NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 0);
2575
2576   if (!CompilationDir.empty())
2577     NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2578
2579   SkeletonHolder.addUnit(NewCU);
2580   SkeletonCUs.push_back(NewCU);
2581
2582   return NewCU;
2583 }
2584
2585 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
2586   assert(useSplitDwarf() && "No split dwarf debug info?");
2587   emitAbbrevs(Section, &SkeletonAbbrevs);
2588 }
2589
2590 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2591 // compile units that would normally be in debug_info.
2592 void DwarfDebug::emitDebugInfoDWO() {
2593   assert(useSplitDwarf() && "No split dwarf debug info?");
2594   InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
2595                        Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2596                        DwarfAbbrevDWOSectionSym);
2597 }
2598
2599 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2600 // abbreviations for the .debug_info.dwo section.
2601 void DwarfDebug::emitDebugAbbrevDWO() {
2602   assert(useSplitDwarf() && "No split dwarf?");
2603   emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2604               &Abbreviations);
2605 }
2606
2607 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2608 // string section and is identical in format to traditional .debug_str
2609 // sections.
2610 void DwarfDebug::emitDebugStrDWO() {
2611   assert(useSplitDwarf() && "No split dwarf?");
2612   const MCSection *OffSec = Asm->getObjFileLowering()
2613                             .getDwarfStrOffDWOSection();
2614   const MCSymbol *StrSym = DwarfStrSectionSym;
2615   InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
2616                          OffSec, StrSym);
2617 }