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