Elaborate on comment for skeleton CU construction.
[oota-llvm.git] / lib / CodeGen / AsmPrinter / DwarfDebug.cpp
index f7723007e17ee3cbb97b88b69e75634b48a3a638..44163d20f4c1114aa31233240e88197d1e1e7881 100644 (file)
@@ -106,8 +106,12 @@ DwarfPubSections("generate-dwarf-pub-sections", cl::Hidden,
 
 static cl::opt<unsigned>
 DwarfVersionNumber("dwarf-version", cl::Hidden,
-                   cl::desc("Generate DWARF for dwarf version."),
-                   cl::init(0));
+                   cl::desc("Generate DWARF for dwarf version."), cl::init(0));
+
+static cl::opt<bool>
+DwarfCURanges("generate-dwarf-cu-ranges", cl::Hidden,
+              cl::desc("Generate DW_AT_ranges for compile units"),
+              cl::init(false));
 
 static const char *const DWARFGroupName = "DWARF Emission";
 static const char *const DbgTimerName = "DWARF Debug Writer";
@@ -189,7 +193,8 @@ DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
   DwarfAddrSectionSym = 0;
   DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
   FunctionBeginSym = FunctionEndSym = 0;
-  CurFn = 0; CurMI = 0;
+  CurFn = 0;
+  CurMI = 0;
 
   // Turn on accelerator tables for Darwin by default, pubnames by
   // default for non-Darwin, and handle split dwarf.
@@ -234,8 +239,8 @@ static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
 }
 
 DwarfFile::~DwarfFile() {
-  for (SmallVectorImpl<Unit *>::iterator I = CUs.begin(), E = CUs.end(); I != E;
-       ++I)
+  for (SmallVectorImpl<DwarfUnit *>::iterator I = CUs.begin(), E = CUs.end();
+       I != E; ++I)
     delete *I;
 }
 
@@ -334,7 +339,7 @@ static bool SectionSort(const MCSection *A, const MCSection *B) {
 // TODO: Determine whether or not we should add names for programs
 // that do not have a DW_AT_name or DW_AT_linkage_name field - this
 // is only slightly different than the lookup of non-standard ObjC names.
-static void addSubprogramNames(Unit *TheU, DISubprogram SP, DIE *Die) {
+static void addSubprogramNames(DwarfUnit *TheU, DISubprogram SP, DIE *Die) {
   if (!SP.isDefinition())
     return;
   TheU->addAccelName(SP.getName(), Die);
@@ -373,7 +378,8 @@ bool DwarfDebug::isSubprogramContext(const MDNode *Context) {
 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
 // and DW_AT_high_pc attributes. If there are global variables in this
 // scope then create and insert DIEs for these variables.
-DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU, DISubprogram SP) {
+DIE *DwarfDebug::updateSubprogramScopeDIE(DwarfCompileUnit *SPCU,
+                                          DISubprogram SP) {
   DIE *SPDie = SPCU->getDIE(SP);
 
   assert(SPDie && "Unable to find subprogram DIE!");
@@ -425,6 +431,10 @@ DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU, DISubprogram SP) {
   SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc, FunctionBeginSym);
   SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc, FunctionEndSym);
 
+  // Add this range to the list of ranges for the CU.
+  RangeSpan Span(FunctionBeginSym, FunctionEndSym);
+  SPCU->addRange(llvm_move(Span));
+
   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
   MachineLocation Location(RI->getFrameRegister(*Asm->MF));
   SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
@@ -457,7 +467,7 @@ bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
   return !End;
 }
 
-static void addSectionLabel(AsmPrinter *Asm, Unit *U, DIE *D,
+static void addSectionLabel(AsmPrinter *Asm, DwarfUnit *U, DIE *D,
                             dwarf::Attribute A, const MCSymbol *L,
                             const MCSymbol *Sec) {
   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
@@ -466,7 +476,7 @@ static void addSectionLabel(AsmPrinter *Asm, Unit *U, DIE *D,
     U->addSectionDelta(D, A, L, Sec);
 }
 
-void DwarfDebug::addScopeRangeList(CompileUnit *TheCU, DIE *ScopeDIE,
+void DwarfDebug::addScopeRangeList(DwarfCompileUnit *TheCU, DIE *ScopeDIE,
                                    const SmallVectorImpl<InsnRange> &Range) {
   // Emit offset in .debug_range as a relocatable label. emitDIE will handle
   // emitting it appropriately.
@@ -489,7 +499,7 @@ void DwarfDebug::addScopeRangeList(CompileUnit *TheCU, DIE *ScopeDIE,
 
 // Construct new DW_TAG_lexical_block for this scope and attach
 // DW_AT_low_pc/DW_AT_high_pc labels.
-DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
+DIE *DwarfDebug::constructLexicalScopeDIE(DwarfCompileUnit *TheCU,
                                           LexicalScope *Scope) {
   if (isLexicalScopeDIENull(Scope))
     return 0;
@@ -523,7 +533,7 @@ DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
 
 // This scope represents inlined body of a function. Construct DIE to
 // represent this concrete inlined copy of the function.
-DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
+DIE *DwarfDebug::constructInlinedScopeDIE(DwarfCompileUnit *TheCU,
                                           LexicalScope *Scope) {
   const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
   assert(!ScopeRanges.empty() &&
@@ -577,7 +587,8 @@ DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
   return ScopeDIE;
 }
 
-DIE *DwarfDebug::createScopeChildrenDIE(CompileUnit *TheCU, LexicalScope *Scope,
+DIE *DwarfDebug::createScopeChildrenDIE(DwarfCompileUnit *TheCU,
+                                        LexicalScope *Scope,
                                         SmallVectorImpl<DIE *> &Children) {
   DIE *ObjectPointer = NULL;
 
@@ -610,7 +621,8 @@ DIE *DwarfDebug::createScopeChildrenDIE(CompileUnit *TheCU, LexicalScope *Scope,
 }
 
 // Construct a DIE for this scope.
-DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
+DIE *DwarfDebug::constructScopeDIE(DwarfCompileUnit *TheCU,
+                                   LexicalScope *Scope) {
   if (!Scope || !Scope->getScopeNode())
     return NULL;
 
@@ -727,7 +739,7 @@ unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName, StringRef DirName,
   return SrcId;
 }
 
-void DwarfDebug::addGnuPubAttributes(Unit *U, DIE *D) const {
+void DwarfDebug::addGnuPubAttributes(DwarfUnit *U, DIE *D) const {
   if (!GenerateGnuPubSections)
     return;
 
@@ -740,18 +752,17 @@ void DwarfDebug::addGnuPubAttributes(Unit *U, DIE *D) const {
                   DwarfGnuPubTypesSectionSym);
 }
 
-// Create new CompileUnit for the given metadata node with tag
+// Create new DwarfCompileUnit for the given metadata node with tag
 // DW_TAG_compile_unit.
-CompileUnit *DwarfDebug::constructCompileUnit(DICompileUnit DIUnit) {
+DwarfCompileUnit *DwarfDebug::constructDwarfCompileUnit(DICompileUnit DIUnit) {
   StringRef FN = DIUnit.getFilename();
   CompilationDir = DIUnit.getDirectory();
 
   DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
-  CompileUnit *NewCU = new CompileUnit(InfoHolder.getUnits().size(), Die,
-                                       DIUnit, Asm, this, &InfoHolder);
+  DwarfCompileUnit *NewCU = new DwarfCompileUnit(
+      InfoHolder.getUnits().size(), Die, DIUnit, Asm, this, &InfoHolder);
   InfoHolder.addUnit(NewCU);
 
-
   FileIDCUMap[NewCU->getUniqueID()] = 0;
   // Call this to emit a .file directive if it wasn't emitted for the source
   // file this CU comes from yet.
@@ -762,12 +773,6 @@ CompileUnit *DwarfDebug::constructCompileUnit(DICompileUnit DIUnit) {
                  DIUnit.getLanguage());
   NewCU->addString(Die, dwarf::DW_AT_name, FN);
 
-  // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
-  // into an entity. We're using 0 (or a NULL label) for this. For
-  // split dwarf it's in the skeleton CU so omit it here.
-  if (!useSplitDwarf())
-    NewCU->addLabelAddress(Die, dwarf::DW_AT_low_pc, NULL);
-
   // Define start line table label for each Compile Unit.
   MCSymbol *LineTableStartSym =
       Asm->GetTempSymbol("line_table_start", NewCU->getUniqueID());
@@ -786,15 +791,14 @@ CompileUnit *DwarfDebug::constructCompileUnit(DICompileUnit DIUnit) {
     // The line table entries are not always emitted in assembly, so it
     // is not okay to use line_table_start here.
     if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
-      NewCU->addSectionLabel(
-          Die, dwarf::DW_AT_stmt_list,
-          UseTheFirstCU ? Asm->GetTempSymbol("section_line")
-                        : LineTableStartSym);
+      NewCU->addSectionLabel(Die, dwarf::DW_AT_stmt_list,
+                             UseTheFirstCU ? Asm->GetTempSymbol("section_line")
+                                           : LineTableStartSym);
     else if (UseTheFirstCU)
       NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
     else
-      NewCU->addSectionDelta(Die, dwarf::DW_AT_stmt_list,
-                             LineTableStartSym, DwarfLineSectionSym);
+      NewCU->addSectionDelta(Die, dwarf::DW_AT_stmt_list, LineTableStartSym,
+                             DwarfLineSectionSym);
 
     // If we're using split dwarf the compilation dir is going to be in the
     // skeleton CU and so we don't need to duplicate it here.
@@ -818,18 +822,31 @@ CompileUnit *DwarfDebug::constructCompileUnit(DICompileUnit DIUnit) {
   if (!FirstCU)
     FirstCU = NewCU;
 
+  if (useSplitDwarf()) {
+    NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoDWOSection(),
+                       DwarfInfoDWOSectionSym);
+    // If we're splitting the dwarf then construct the skeleton CU now
+    // since we'll need to be able to reference the symbols in the skeleton
+    // CU during various emission passes - in particular aranges need
+    // to reference the skeleton CU.
+    NewCU->setSkeleton(constructSkeletonCU(NewCU));
+  } else
+    NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
+                       DwarfInfoSectionSym);
+
   CUMap.insert(std::make_pair(DIUnit, NewCU));
   CUDieMap.insert(std::make_pair(Die, NewCU));
   return NewCU;
 }
 
 // Construct subprogram DIE.
-void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU, const MDNode *N) {
+void DwarfDebug::constructSubprogramDIE(DwarfCompileUnit *TheCU,
+                                        const MDNode *N) {
   // FIXME: We should only call this routine once, however, during LTO if a
   // program is defined in multiple CUs we could end up calling it out of
   // beginModule as we walk the CUs.
 
-  CompileUnit *&CURef = SPMap[N];
+  DwarfCompileUnit *&CURef = SPMap[N];
   if (CURef)
     return;
   CURef = TheCU;
@@ -846,7 +863,7 @@ void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU, const MDNode *N) {
   TheCU->addGlobalName(SP.getName(), SubprogramDie, resolve(SP.getContext()));
 }
 
-void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
+void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
                                             const MDNode *N) {
   DIImportedEntity Module(N);
   if (!Module.Verify())
@@ -855,15 +872,15 @@ void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
     constructImportedEntityDIE(TheCU, Module, D);
 }
 
-void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU, const MDNode *N,
-                                            DIE *Context) {
+void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
+                                            const MDNode *N, DIE *Context) {
   DIImportedEntity Module(N);
   if (!Module.Verify())
     return;
   return constructImportedEntityDIE(TheCU, Module, Context);
 }
 
-void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
+void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
                                             const DIImportedEntity &Module,
                                             DIE *Context) {
   assert(Module.Verify() &&
@@ -914,7 +931,7 @@ void DwarfDebug::beginModule() {
 
   for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
     DICompileUnit CUNode(CU_Nodes->getOperand(i));
-    CompileUnit *CU = constructCompileUnit(CUNode);
+    DwarfCompileUnit *CU = constructDwarfCompileUnit(CUNode);
     DIArray ImportedEntities = CUNode.getImportedEntities();
     for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
       ScopesWithImportedEntities.push_back(std::make_pair(
@@ -987,7 +1004,8 @@ void DwarfDebug::collectDeadVariables() {
           continue;
 
         // Construct subprogram DIE and add variables DIEs.
-        CompileUnit *SPCU = static_cast<CompileUnit *>(CUMap.lookup(TheCU));
+        DwarfCompileUnit *SPCU =
+            static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
         assert(SPCU && "Unable to find Compile Unit!");
         // FIXME: See the comment in constructSubprogramDIE about duplicate
         // subprogram DIEs.
@@ -1035,7 +1053,7 @@ static bool isContainedInAnonNamespace(DIE *Die) {
 
 /// Test if the current CU language is C++ and that we have
 /// a named type that is not contained in an anonymous namespace.
-static bool shouldAddODRHash(TypeUnit *CU, DIE *Die) {
+static bool shouldAddODRHash(DwarfTypeUnit *CU, DIE *Die) {
   return CU->getLanguage() == dwarf::DW_LANG_C_plus_plus &&
          getDIEStringAttr(Die, dwarf::DW_AT_name) != "" &&
          !isContainedInAnonNamespace(Die);
@@ -1050,31 +1068,44 @@ void DwarfDebug::finalizeModuleInfo() {
 
   // Handle anything that needs to be done on a per-unit basis after
   // all other generation.
-  for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
-                                               E = getUnits().end();
+  for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
+                                                    E = getUnits().end();
        I != E; ++I) {
-    Unit *TheU = *I;
+    DwarfUnit *TheU = *I;
     // Emit DW_AT_containing_type attribute to connect types with their
     // vtable holding type.
     TheU->constructContainingTypeDIEs();
 
-    // If we're splitting the dwarf out now that we've got the entire
-    // CU then construct a skeleton CU based upon it.
-    if (useSplitDwarf() &&
-        TheU->getUnitDie()->getTag() == dwarf::DW_TAG_compile_unit) {
-      uint64_t ID = 0;
-      if (GenerateCUHash) {
-        DIEHash CUHash;
-        ID = CUHash.computeCUSignature(*TheU->getUnitDie());
+    // Add CU specific attributes if we need to add any.
+    if (TheU->getUnitDie()->getTag() == dwarf::DW_TAG_compile_unit) {
+      // If we're splitting the dwarf out now that we've got the entire
+      // CU then add the dwo id to it.
+      DwarfCompileUnit *SkCU =
+          static_cast<DwarfCompileUnit *>(TheU->getSkeleton());
+      if (useSplitDwarf()) {
+        // This should be a unique identifier when we want to build .dwp files.
+        uint64_t ID = 0;
+        if (GenerateCUHash) {
+          DIEHash CUHash;
+          ID = CUHash.computeCUSignature(*TheU->getUnitDie());
+        }
+        TheU->addUInt(TheU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
+                      dwarf::DW_FORM_data8, ID);
+        SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
+                      dwarf::DW_FORM_data8, ID);
       }
-      // This should be a unique identifier when we want to build .dwp files.
-      TheU->addUInt(TheU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
-                    dwarf::DW_FORM_data8, ID);
-      // Now construct the skeleton CU associated.
-      CompileUnit *SkCU = constructSkeletonCU(static_cast<CompileUnit *>(TheU));
-      // This should be a unique identifier when we want to build .dwp files.
-      SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
-                    dwarf::DW_FORM_data8, ID);
+
+      // If we've requested ranges and have them emit a DW_AT_ranges attribute
+      // on the unit that will remain in the .o file, otherwise add a DW_AT_low_pc.
+      // FIXME: Also add a high pc if we can.
+      // FIXME: We should use ranges if we have multiple compile units.
+      DwarfCompileUnit *U = SkCU ? SkCU : static_cast<DwarfCompileUnit *>(TheU);
+      if (DwarfCURanges && TheU->getRanges().size())
+        addSectionLabel(Asm, U, U->getUnitDie(), dwarf::DW_AT_ranges,
+                        Asm->GetTempSymbol("cu_ranges", U->getUniqueID()),
+                        DwarfDebugRangeSectionSym);
+      else
+        U->addUInt(U->getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
     }
   }
 
@@ -1167,9 +1198,6 @@ void DwarfDebug::endModule() {
   // Emit info into a debug ranges section.
   emitDebugRanges();
 
-  // Emit info into a debug macinfo section.
-  emitDebugMacInfo();
-
   if (useSplitDwarf()) {
     emitDebugStrDWO();
     emitDebugInfoDWO();
@@ -1579,11 +1607,11 @@ void DwarfDebug::beginFunction(const MachineFunction *MF) {
   // Make sure that each lexical scope will have a begin/end label.
   identifyScopeMarkers();
 
-  // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
+  // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
   // belongs to so that we add to the correct per-cu line table in the
   // non-asm case.
   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
-  CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
+  DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
   assert(TheCU && "Unable to find compile unit!");
   if (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport())
     // Use a single line table if we are using .loc and generating assembly.
@@ -1808,14 +1836,14 @@ void DwarfDebug::endFunction(const MachineFunction *MF) {
   FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
   // Assumes in correct section after the entry point.
   Asm->OutStreamer.EmitLabel(FunctionEndSym);
-  // Set DwarfCompileUnitID in MCContext to default value.
+  // Set DwarfDwarfCompileUnitID in MCContext to default value.
   Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
 
   SmallPtrSet<const MDNode *, 16> ProcessedVars;
   collectVariableInfo(ProcessedVars);
 
   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
-  CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
+  DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
   assert(TheCU && "Unable to find compile unit!");
 
   // Construct abstract scopes.
@@ -1957,7 +1985,8 @@ void DwarfFile::computeSizeAndOffsets() {
 
   // Iterate over each compile unit and set the size and offsets for each
   // DIE within each compile unit. All offsets are CU relative.
-  for (SmallVectorImpl<Unit *>::const_iterator I = CUs.begin(), E = CUs.end();
+  for (SmallVectorImpl<DwarfUnit *>::const_iterator I = CUs.begin(),
+                                                    E = CUs.end();
        I != E; ++I) {
     (*I)->setDebugInfoOffset(SecOffset);
 
@@ -1979,6 +2008,9 @@ void DwarfDebug::emitSectionLabels() {
   // Dwarf sections base addresses.
   DwarfInfoSectionSym =
       emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
+  if (useSplitDwarf())
+    DwarfInfoDWOSectionSym =
+        emitSectionSym(Asm, TLOF.getDwarfInfoDWOSection(), "section_info_dwo");
   DwarfAbbrevSectionSym =
       emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
   if (useSplitDwarf())
@@ -2017,7 +2049,6 @@ void DwarfDebug::emitSectionLabels() {
       emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
 
   TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
-  emitSectionSym(Asm, TLOF.getDataSection());
 }
 
 // Recursively emits a debug information entry.
@@ -2060,15 +2091,15 @@ void DwarfDebug::emitDIE(DIE *Die) {
         // For DW_FORM_ref_addr, output the offset from beginning of debug info
         // section. Origin->getOffset() returns the offset from start of the
         // compile unit.
-        CompileUnit *CU = CUDieMap.lookup(Origin->getUnit());
+        DwarfCompileUnit *CU = CUDieMap.lookup(Origin->getUnit());
         assert(CU && "CUDie should belong to a CU.");
         Addr += CU->getDebugInfoOffset();
         if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
-          Asm->EmitLabelPlusOffset(DwarfInfoSectionSym, Addr,
+          Asm->EmitLabelPlusOffset(CU->getSectionSym(), Addr,
                                    DIEEntry::getRefAddrSize(Asm));
         else
-          Asm->EmitLabelOffsetDifference(DwarfInfoSectionSym, Addr,
-                                         DwarfInfoSectionSym,
+          Asm->EmitLabelOffsetDifference(CU->getSectionSym(), Addr,
+                                         CU->getSectionSym(),
                                          DIEEntry::getRefAddrSize(Asm));
       } else {
         // Make sure Origin belong to the same CU.
@@ -2118,18 +2149,17 @@ void DwarfDebug::emitDIE(DIE *Die) {
 
 // Emit the various dwarf units to the unit section USection with
 // the abbreviations going into ASection.
-void DwarfFile::emitUnits(DwarfDebug *DD, const MCSection *USection,
-                           const MCSection *ASection,
-                           const MCSymbol *ASectionSym) {
-  Asm->OutStreamer.SwitchSection(USection);
-  for (SmallVectorImpl<Unit *>::iterator I = CUs.begin(), E = CUs.end(); I != E;
-       ++I) {
-    Unit *TheU = *I;
+void DwarfFile::emitUnits(DwarfDebug *DD, const MCSection *ASection,
+                          const MCSymbol *ASectionSym) {
+  for (SmallVectorImpl<DwarfUnit *>::iterator I = CUs.begin(), E = CUs.end();
+       I != E; ++I) {
+    DwarfUnit *TheU = *I;
     DIE *Die = TheU->getUnitDie();
+    const MCSection *USection = TheU->getSection();
+    Asm->OutStreamer.SwitchSection(USection);
 
     // Emit the compile units header.
-    Asm->OutStreamer.EmitLabel(
-        Asm->GetTempSymbol(USection->getLabelBeginName(), TheU->getUniqueID()));
+    Asm->OutStreamer.EmitLabel(TheU->getLabelBegin());
 
     // Emit size of content not including length itself
     Asm->OutStreamer.AddComment("Length of Unit");
@@ -2138,8 +2168,7 @@ void DwarfFile::emitUnits(DwarfDebug *DD, const MCSection *USection,
     TheU->emitHeader(ASection, ASectionSym);
 
     DD->emitDIE(Die);
-    Asm->OutStreamer.EmitLabel(
-        Asm->GetTempSymbol(USection->getLabelEndName(), TheU->getUniqueID()));
+    Asm->OutStreamer.EmitLabel(TheU->getLabelEnd());
   }
 }
 
@@ -2147,8 +2176,7 @@ void DwarfFile::emitUnits(DwarfDebug *DD, const MCSection *USection,
 void DwarfDebug::emitDebugInfo() {
   DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
 
-  Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
-                   Asm->getObjFileLowering().getDwarfAbbrevSection(),
+  Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfAbbrevSection(),
                    DwarfAbbrevSectionSym);
 }
 
@@ -2210,10 +2238,10 @@ void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
 void DwarfDebug::emitAccelNames() {
   DwarfAccelTable AT(
       DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
-  for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
-                                               E = getUnits().end();
+  for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
+                                                    E = getUnits().end();
        I != E; ++I) {
-    Unit *TheU = *I;
+    DwarfUnit *TheU = *I;
     const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelNames();
     for (StringMap<std::vector<const DIE *> >::const_iterator
              GI = Names.begin(),
@@ -2243,10 +2271,10 @@ void DwarfDebug::emitAccelNames() {
 void DwarfDebug::emitAccelObjC() {
   DwarfAccelTable AT(
       DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
-  for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
-                                               E = getUnits().end();
+  for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
+                                                    E = getUnits().end();
        I != E; ++I) {
-    Unit *TheU = *I;
+    DwarfUnit *TheU = *I;
     const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelObjC();
     for (StringMap<std::vector<const DIE *> >::const_iterator
              GI = Names.begin(),
@@ -2275,10 +2303,10 @@ void DwarfDebug::emitAccelObjC() {
 void DwarfDebug::emitAccelNamespaces() {
   DwarfAccelTable AT(
       DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
-  for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
-                                               E = getUnits().end();
+  for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
+                                                    E = getUnits().end();
        I != E; ++I) {
-    Unit *TheU = *I;
+    DwarfUnit *TheU = *I;
     const StringMap<std::vector<const DIE *> > &Names =
         TheU->getAccelNamespace();
     for (StringMap<std::vector<const DIE *> >::const_iterator
@@ -2314,10 +2342,10 @@ void DwarfDebug::emitAccelTypes() {
   Atoms.push_back(
       DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1));
   DwarfAccelTable AT(Atoms);
-  for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
-                                               E = getUnits().end();
+  for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
+                                                    E = getUnits().end();
        I != E; ++I) {
-    Unit *TheU = *I;
+    DwarfUnit *TheU = *I;
     const StringMap<std::vector<std::pair<const DIE *, unsigned> > > &Names =
         TheU->getAccelTypes();
     for (StringMap<
@@ -2361,7 +2389,7 @@ void DwarfDebug::emitAccelTypes() {
 // reference in the pubname header doesn't change.
 
 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
-static dwarf::PubIndexEntryDescriptor computeIndexValue(Unit *CU,
+static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
                                                         const DIE *Die) {
   dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
 
@@ -2406,15 +2434,14 @@ static dwarf::PubIndexEntryDescriptor computeIndexValue(Unit *CU,
 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
 ///
 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
-  const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
   const MCSection *PSec =
       GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
                : Asm->getObjFileLowering().getDwarfPubNamesSection();
 
   DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
-  const SmallVectorImpl<Unit *> &Units = Holder.getUnits();
+  const SmallVectorImpl<DwarfUnit *> &Units = Holder.getUnits();
   for (unsigned i = 0; i != Units.size(); ++i) {
-    Unit *TheU = Units[i];
+    DwarfUnit *TheU = Units[i];
     unsigned ID = TheU->getUniqueID();
 
     // Start the dwarf pubnames section.
@@ -2436,13 +2463,10 @@ void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
     Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
 
     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
-    Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
-                           DwarfInfoSectionSym);
+    Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
 
     Asm->OutStreamer.AddComment("Compilation Unit Length");
-    Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
-                             Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
-                             4);
+    Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
 
     // Emit the pubnames for this compilation unit.
     const StringMap<const DIE *> &Globals = getUnits()[ID]->getGlobalNames();
@@ -2474,15 +2498,14 @@ void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
 }
 
 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
-  const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
   const MCSection *PSec =
       GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
                : Asm->getObjFileLowering().getDwarfPubTypesSection();
 
   DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
-  const SmallVectorImpl<Unit *> &Units = Holder.getUnits();
+  const SmallVectorImpl<DwarfUnit *> &Units = Holder.getUnits();
   for (unsigned i = 0; i != Units.size(); ++i) {
-    Unit *TheU = Units[i];
+    DwarfUnit *TheU = Units[i];
     unsigned ID = TheU->getUniqueID();
 
     // Start the dwarf pubtypes section.
@@ -2504,14 +2527,10 @@ void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
     Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
 
     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
-    Asm->EmitSectionOffset(
-        Asm->GetTempSymbol(ISec->getLabelBeginName(), TheU->getUniqueID()),
-        DwarfInfoSectionSym);
+    Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
 
     Asm->OutStreamer.AddComment("Compilation Unit Length");
-    Asm->EmitLabelDifference(
-        Asm->GetTempSymbol(ISec->getLabelEndName(), TheU->getUniqueID()),
-        Asm->GetTempSymbol(ISec->getLabelBeginName(), TheU->getUniqueID()), 4);
+    Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
 
     // Emit the pubtypes.
     const StringMap<const DIE *> &Globals = getUnits()[ID]->getGlobalTypes();
@@ -2546,8 +2565,8 @@ void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
 
 // Emit strings into a string section.
 void DwarfFile::emitStrings(const MCSection *StrSection,
-                             const MCSection *OffsetSection = NULL,
-                             const MCSymbol *StrSecSym = NULL) {
+                            const MCSection *OffsetSection = NULL,
+                            const MCSymbol *StrSecSym = NULL) {
 
   if (StringPool.empty())
     return;
@@ -2591,7 +2610,6 @@ void DwarfFile::emitStrings(const MCSection *StrSection,
   }
 }
 
-
 // Emit addresses into the section given.
 void DwarfFile::emitAddresses(const MCSection *AddrSection) {
 
@@ -2744,7 +2762,7 @@ struct SymbolCUSorter {
   }
 };
 
-static bool CUSort(const Unit *A, const Unit *B) {
+static bool CUSort(const DwarfUnit *A, const DwarfUnit *B) {
   return (A->getUniqueID() < B->getUniqueID());
 }
 
@@ -2759,7 +2777,7 @@ void DwarfDebug::emitDebugARanges() {
   Asm->OutStreamer.SwitchSection(
       Asm->getObjFileLowering().getDwarfARangesSection());
 
-  typedef DenseMap<CompileUnit *, std::vector<ArangeSpan> > SpansType;
+  typedef DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan> > SpansType;
 
   SpansType Spans;
 
@@ -2817,13 +2835,12 @@ void DwarfDebug::emitDebugARanges() {
     }
   }
 
-  const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
   unsigned PtrSize = Asm->getDataLayout().getPointerSize();
 
   // Build a list of CUs used.
-  std::vector<CompileUnit *> CUs;
+  std::vector<DwarfCompileUnit *> CUs;
   for (SpansType::iterator it = Spans.begin(); it != Spans.end(); it++) {
-    CompileUnit *CU = it->first;
+    DwarfCompileUnit *CU = it->first;
     CUs.push_back(CU);
   }
 
@@ -2832,7 +2849,7 @@ void DwarfDebug::emitDebugARanges() {
 
   // Emit an arange table for each CU we used.
   for (size_t CUIdx = 0; CUIdx < CUs.size(); CUIdx++) {
-    CompileUnit *CU = CUs[CUIdx];
+    DwarfCompileUnit *CU = CUs[CUIdx];
     std::vector<ArangeSpan> &List = Spans[CU];
 
     // Emit size of content not including length itself.
@@ -2858,9 +2875,7 @@ void DwarfDebug::emitDebugARanges() {
     Asm->OutStreamer.AddComment("DWARF Arange version number");
     Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
     Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
-    Asm->EmitSectionOffset(
-        Asm->GetTempSymbol(ISec->getLabelBeginName(), CU->getUniqueID()),
-        DwarfInfoSectionSym);
+    Asm->EmitSectionOffset(CU->getLocalLabelBegin(), CU->getLocalSectionSym());
     Asm->OutStreamer.AddComment("Address Size (in bytes)");
     Asm->EmitInt8(PtrSize);
     Asm->OutStreamer.AddComment("Segment Size (in bytes)");
@@ -2903,20 +2918,18 @@ void DwarfDebug::emitDebugRanges() {
   unsigned char Size = Asm->getDataLayout().getPointerSize();
 
   // Grab the specific ranges for the compile units in the module.
-  for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
-                                                         E = CUMap.end();
+  for (DenseMap<const MDNode *, DwarfCompileUnit *>::iterator I = CUMap.begin(),
+                                                              E = CUMap.end();
        I != E; ++I) {
-    CompileUnit *TheCU = I->second;
-    unsigned ID = TheCU->getUniqueID();
+    DwarfCompileUnit *TheCU = I->second;
 
     // Emit a symbol so we can find the beginning of our ranges.
-    Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_ranges", ID));
+    Asm->OutStreamer.EmitLabel(TheCU->getLabelRange());
 
     // Iterate over the misc ranges for the compile units in the module.
     const SmallVectorImpl<RangeSpanList> &RangeLists = TheCU->getRangeLists();
-    for (SmallVectorImpl<RangeSpanList>::const_iterator
-             I = RangeLists.begin(),
-             E = RangeLists.end();
+    for (SmallVectorImpl<RangeSpanList>::const_iterator I = RangeLists.begin(),
+                                                        E = RangeLists.end();
          I != E; ++I) {
       const RangeSpanList &List = *I;
 
@@ -2928,29 +2941,37 @@ void DwarfDebug::emitDebugRanges() {
                RE = List.getRanges().end();
            RI != RE; ++RI) {
         const RangeSpan &Range = *RI;
-        // We occasionally have ranges without begin/end labels.
-        // FIXME: Verify and fix.
         const MCSymbol *Begin = Range.getStart();
         const MCSymbol *End = Range.getEnd();
-        Begin ? Asm->OutStreamer.EmitSymbolValue(Begin, Size)
-              : Asm->OutStreamer.EmitIntValue(0, Size);
-        End ? Asm->OutStreamer.EmitSymbolValue(End, Size)
-            : Asm->OutStreamer.EmitIntValue(0, Size);
+        assert(Begin && "Range without a begin symbol?");
+        assert(End && "Range without an end symbol?");
+        Asm->OutStreamer.EmitSymbolValue(Begin, Size);
+        Asm->OutStreamer.EmitSymbolValue(End, Size);
       }
 
       // And terminate the list with two 0 values.
       Asm->OutStreamer.EmitIntValue(0, Size);
       Asm->OutStreamer.EmitIntValue(0, Size);
     }
-  }
-}
 
-// Emit visible names into a debug macinfo section.
-void DwarfDebug::emitDebugMacInfo() {
-  if (const MCSection *LineInfo =
-          Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
-    // Start the dwarf macinfo section.
-    Asm->OutStreamer.SwitchSection(LineInfo);
+    // Now emit a range for the CU itself.
+    if (DwarfCURanges) {
+      Asm->OutStreamer.EmitLabel(
+          Asm->GetTempSymbol("cu_ranges", TheCU->getUniqueID()));
+      const SmallVectorImpl<RangeSpan> &Ranges = TheCU->getRanges();
+      for (uint32_t i = 0, e = Ranges.size(); i != e; ++i) {
+        RangeSpan Range = Ranges[i];
+        const MCSymbol *Begin = Range.getStart();
+        const MCSymbol *End = Range.getEnd();
+        assert(Begin && "Range without a begin symbol?");
+        assert(End && "Range without an end symbol?");
+        Asm->OutStreamer.EmitSymbolValue(Begin, Size);
+        Asm->OutStreamer.EmitSymbolValue(End, Size);
+      }
+      // And terminate the list with two 0 values.
+      Asm->OutStreamer.EmitIntValue(0, Size);
+      Asm->OutStreamer.EmitIntValue(0, Size);
+    }
   }
 }
 
@@ -2959,11 +2980,14 @@ void DwarfDebug::emitDebugMacInfo() {
 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
 // DW_AT_ranges_base, DW_AT_addr_base.
-CompileUnit *DwarfDebug::constructSkeletonCU(const CompileUnit *CU) {
+// TODO: Implement DW_AT_ranges_base.
+DwarfCompileUnit *DwarfDebug::constructSkeletonCU(const DwarfCompileUnit *CU) {
 
   DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
-  CompileUnit *NewCU = new CompileUnit(CU->getUniqueID(), Die, CU->getNode(),
-                                       Asm, this, &SkeletonHolder);
+  DwarfCompileUnit *NewCU = new DwarfCompileUnit(
+      CU->getUniqueID(), Die, CU->getNode(), Asm, this, &SkeletonHolder);
+  NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
+                     DwarfInfoSectionSym);
 
   NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
                         CU->getNode().getSplitDebugFilename());
@@ -2976,16 +3000,11 @@ CompileUnit *DwarfDebug::constructSkeletonCU(const CompileUnit *CU) {
   else
     NewCU->addSectionOffset(Die, dwarf::DW_AT_GNU_addr_base, 0);
 
-  // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
-  // into an entity. We're using 0, or a NULL label for this.
-  NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
-
   // DW_AT_stmt_list is a offset of line number information for this
   // compile unit in debug_line section.
   // FIXME: Should handle multiple compile units.
   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
-    NewCU->addSectionLabel(Die, dwarf::DW_AT_stmt_list,
-                           DwarfLineSectionSym);
+    NewCU->addSectionLabel(Die, dwarf::DW_AT_stmt_list, DwarfLineSectionSym);
   else
     NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
 
@@ -2994,13 +3013,6 @@ CompileUnit *DwarfDebug::constructSkeletonCU(const CompileUnit *CU) {
 
   addGnuPubAttributes(NewCU, Die);
 
-  // Attribute if we've emitted any ranges and their location for the compile
-  // unit.
-  if (!CU->getRangeLists().empty())
-    addSectionLabel(Asm, NewCU, Die, dwarf::DW_AT_GNU_ranges_base,
-                    Asm->GetTempSymbol("gnu_ranges", NewCU->getUniqueID()),
-                    DwarfDebugRangeSectionSym);
-
   SkeletonHolder.addUnit(NewCU);
 
   return NewCU;
@@ -3010,7 +3022,7 @@ CompileUnit *DwarfDebug::constructSkeletonCU(const CompileUnit *CU) {
 // compile units that would normally be in debug_info.
 void DwarfDebug::emitDebugInfoDWO() {
   assert(useSplitDwarf() && "No split dwarf debug info?");
-  InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
+  InfoHolder.emitUnits(this,
                        Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
                        DwarfAbbrevDWOSectionSym);
 }
@@ -3034,35 +3046,20 @@ void DwarfDebug::emitDebugStrDWO() {
                          OffSec, StrSym);
 }
 
-void DwarfDebug::addTypeUnitType(uint16_t Language, DIE *RefDie,
-                                 DICompositeType CTy) {
-  DenseMap<const MDNode *,
-           std::pair<uint64_t, SmallVectorImpl<DIE *> *> >::iterator I =
-      TypeUnits.find(CTy);
-  SmallVector<DIE *, 8> References;
-  References.push_back(RefDie);
-  if (I != TypeUnits.end()) {
-    if (I->second.second) {
-      I->second.second->push_back(RefDie);
-      return;
-    }
-  } else {
+void DwarfDebug::addDwarfTypeUnitType(uint16_t Language, DIE *RefDie,
+                                      DICompositeType CTy) {
+  const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
+  if (!TU) {
     DIE *UnitDie = new DIE(dwarf::DW_TAG_type_unit);
-    TypeUnit *NewTU = new TypeUnit(InfoHolder.getUnits().size(), UnitDie,
-                                   Language, Asm, this, &InfoHolder);
+    DwarfTypeUnit *NewTU =
+        new DwarfTypeUnit(InfoHolder.getUnits().size(), UnitDie, Language, Asm,
+                          this, &InfoHolder);
+    TU = NewTU;
     InfoHolder.addUnit(NewTU);
 
     NewTU->addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
                    Language);
 
-    // Register the type in the TypeUnits map with a vector of references to be
-    // populated whenever a reference is required.
-    I = TypeUnits.insert(std::make_pair(CTy, std::make_pair(0, &References)))
-            .first;
-
-    // Construct the type, this may, recursively, require more type units that
-    // may in turn require this type again - in which case they will add DIEs to
-    // the References vector.
     DIE *Die = NewTU->createTypeDIE(CTy);
 
     if (GenerateODRHash && shouldAddODRHash(NewTU, Die))
@@ -3075,15 +3072,14 @@ void DwarfDebug::addTypeUnitType(uint16_t Language, DIE *RefDie,
     // referenced type, or possibly walk the precomputed hashes of related types
     // at the end.
     uint64_t Signature = DIEHash().computeTypeSignature(*Die);
+    NewTU->setTypeSignature(Signature);
+    NewTU->setType(Die);
 
-    // Remove the References vector and add the type hash.
-    I->second.first = Signature;
-    I->second.second = NULL;
+    NewTU->initSection(
+        useSplitDwarf()
+            ? Asm->getObjFileLowering().getDwarfTypesDWOSection(Signature)
+            : Asm->getObjFileLowering().getDwarfTypesSection(Signature));
   }
 
-  // Populate all the signatures.
-  for (unsigned i = 0, e = References.size(); i != e; ++i) {
-    CUMap.begin()->second->addUInt(References[i], dwarf::DW_AT_signature,
-                                   dwarf::DW_FORM_ref_sig8, I->second.first);
-  }
+  CUMap.begin()->second->addDIETypeSignature(RefDie, *TU);
 }