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