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