 @@ -1,836 +1,1956 @@
 //===-- llvm/CodeGen/DwarfCompileUnit.cpp - Dwarf Compile Unit ------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains support for constructing a dwarf compile unit.
 //
 //===----------------------------------------------------------------------===//
 #define DEBUG_TYPE "dwarfdebug"
 #include "DwarfCompileUnit.h"
-#include "DwarfExpression.h"
+#include "DwarfAccelTable.h"
-#include "llvm/CodeGen/MachineFunction.h"
+#include "DwarfDebug.h"
 #include "llvm/ADT/APFloat.h"
 #include "llvm/DIBuilder.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/GlobalVariable.h"
-#include "llvm/IR/Instruction.h"
+#include "llvm/IR/Instructions.h"
-#include "llvm/MC/MCAsmInfo.h"
+#include "llvm/MC/MCSection.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/Target/Mangler.h"
 #include "llvm/Target/TargetFrameLowering.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
 #include "llvm/Target/TargetRegisterInfo.h"
 #include "llvm/Target/TargetSubtargetInfo.h"
-namespace llvm {
+using namespace llvm;
-DwarfCompileUnit::DwarfCompileUnit(unsigned UID, DICompileUnit Node,
+/// CompileUnit - Compile unit constructor.
-                                   AsmPrinter *A, DwarfDebug *DW,
+CompileUnit::CompileUnit(unsigned UID, DIE *D, DICompileUnit Node,
-                                   DwarfFile *DWU)
+                         AsmPrinter *A, DwarfDebug *DW, DwarfUnits *DWU)
-    : DwarfUnit(UID, dwarf::DW_TAG_compile_unit, Node, A, DW, DWU),
+    : UniqueID(UID), Node(Node), CUDie(D), Asm(A), DD(DW), DU(DWU),
-      Skeleton(nullptr), LabelBegin(nullptr), BaseAddress(nullptr) {
+      IndexTyDie(0), DebugInfoOffset(0) {
-  insertDIE(Node, &getUnitDie());
+  DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
   insertDIE(Node, D);
+}
 /// ~CompileUnit - Destructor for compile unit.
 CompileUnit::~CompileUnit() {
   for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
     DIEBlocks[j]->~DIEBlock();
+}
 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
 /// information entry.
 DIEEntry *CompileUnit::createDIEEntry(DIE *Entry) {
   DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
   return Value;
+}
 /// getDefaultLowerBound - Return the default lower bound for an array. If the
 /// DWARF version doesn't handle the language, return -1.
 int64_t CompileUnit::getDefaultLowerBound() const {
   switch (getLanguage()) {
   default:
     break;
   case dwarf::DW_LANG_C89:
   case dwarf::DW_LANG_C99:
   case dwarf::DW_LANG_C:
   case dwarf::DW_LANG_C_plus_plus:
   case dwarf::DW_LANG_ObjC:
   case dwarf::DW_LANG_ObjC_plus_plus:
     return 0;
   case dwarf::DW_LANG_Fortran77:
   case dwarf::DW_LANG_Fortran90:
   case dwarf::DW_LANG_Fortran95:
     return 1;
   // The languages below have valid values only if the DWARF version >= 4.
   case dwarf::DW_LANG_Java:
   case dwarf::DW_LANG_Python:
   case dwarf::DW_LANG_UPC:
   case dwarf::DW_LANG_D:
     if (dwarf::DWARF_VERSION >= 4)
       return 0;
     break;
   case dwarf::DW_LANG_Ada83:
   case dwarf::DW_LANG_Ada95:
   case dwarf::DW_LANG_Cobol74:
   case dwarf::DW_LANG_Cobol85:
   case dwarf::DW_LANG_Modula2:
   case dwarf::DW_LANG_Pascal83:
   case dwarf::DW_LANG_PLI:
     if (dwarf::DWARF_VERSION >= 4)
       return 1;
     break;
+  }
   return -1;
+}
-/// addLabelAddress - Add a dwarf label attribute data and value using
+/// Check whether the DIE for this MDNode can be shared across CUs.
-/// DW_FORM_addr or DW_FORM_GNU_addr_index.
+static bool isShareableAcrossCUs(DIDescriptor D) {
   // When the MDNode can be part of the type system, the DIE can be
   // shared across CUs.
   return D.isType() ||
          (D.isSubprogram() && !DISubprogram(D).isDefinition());
+}
 /// getDIE - Returns the debug information entry map slot for the
 /// specified debug variable. We delegate the request to DwarfDebug
 /// when the DIE for this MDNode can be shared across CUs. The mappings
 /// will be kept in DwarfDebug for shareable DIEs.
 DIE *CompileUnit::getDIE(DIDescriptor D) const {
   if (isShareableAcrossCUs(D))
     return DD->getDIE(D);
   return MDNodeToDieMap.lookup(D);
+}
 /// insertDIE - Insert DIE into the map. We delegate the request to DwarfDebug
 /// when the DIE for this MDNode can be shared across CUs. The mappings
 /// will be kept in DwarfDebug for shareable DIEs.
 void CompileUnit::insertDIE(DIDescriptor Desc, DIE *D) {
   if (isShareableAcrossCUs(Desc)) {
     DD->insertDIE(Desc, D);
     return;
+  }
   MDNodeToDieMap.insert(std::make_pair(Desc, D));
+}
 /// addFlag - Add a flag that is true.
 void CompileUnit::addFlag(DIE *Die, dwarf::Attribute Attribute) {
   if (DD->getDwarfVersion() >= 4)
     Die->addValue(Attribute, dwarf::DW_FORM_flag_present, DIEIntegerOne);
   else
     Die->addValue(Attribute, dwarf::DW_FORM_flag, DIEIntegerOne);
+}
 /// addUInt - Add an unsigned integer attribute data and value.
 ///
-void DwarfCompileUnit::addLabelAddress(DIE &Die, dwarf::Attribute Attribute,
+void CompileUnit::addUInt(DIE *Die, dwarf::Attribute Attribute,
-                                       const MCSymbol *Label) {
+                          Optional<dwarf::Form> Form, uint64_t Integer) {
   if (!Form)
     Form = DIEInteger::BestForm(false, Integer);
   DIEValue *Value = Integer == 1 ? DIEIntegerOne : new (DIEValueAllocator)
                         DIEInteger(Integer);
   Die->addValue(Attribute, *Form, Value);
+}
-  // Don't use the address pool in non-fission or in the skeleton unit itself.
+void CompileUnit::addUInt(DIEBlock *Block, dwarf::Form Form, uint64_t Integer) {
-  // FIXME: Once GDB supports this, it's probably worthwhile using the address
+  addUInt(Block, (dwarf::Attribute)0, Form, Integer);
   // pool from the skeleton - maybe even in non-fission (possibly fewer
   // relocations by sharing them in the pool, but we have other ideas about how
   // to reduce the number of relocations as well/instead).
   if (!DD->useSplitDwarf() || !Skeleton)
     return addLocalLabelAddress(Die, Attribute, Label);
-  if (Label)
+/// addSInt - Add an signed integer attribute data and value.
-    DD->addArangeLabel(SymbolCU(this, Label));
+///
 void CompileUnit::addSInt(DIE *Die, dwarf::Attribute Attribute,
                           Optional<dwarf::Form> Form, int64_t Integer) {
   if (!Form)
     Form = DIEInteger::BestForm(true, Integer);
   DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
   Die->addValue(Attribute, *Form, Value);
+}
 void CompileUnit::addSInt(DIEBlock *Die, Optional<dwarf::Form> Form,
                           int64_t Integer) {
   addSInt(Die, (dwarf::Attribute)0, Form, Integer);
+}
 /// addString - Add a string attribute data and value. We always emit a
 /// reference to the string pool instead of immediate strings so that DIEs have
 /// more predictable sizes. In the case of split dwarf we emit an index
 /// into another table which gets us the static offset into the string
 /// table.
 void CompileUnit::addString(DIE *Die, dwarf::Attribute Attribute,
                             StringRef String) {
   DIEValue *Value;
   dwarf::Form Form;
   if (!DD->useSplitDwarf()) {
     MCSymbol *Symb = DU->getStringPoolEntry(String);
     if (Asm->needsRelocationsForDwarfStringPool())
       Value = new (DIEValueAllocator) DIELabel(Symb);
     else {
       MCSymbol *StringPool = DU->getStringPoolSym();
       Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool);
+    }
     Form = dwarf::DW_FORM_strp;
   } else {
     unsigned idx = DU->getStringPoolIndex(String);
     Value = new (DIEValueAllocator) DIEInteger(idx);
     Form = dwarf::DW_FORM_GNU_str_index;
+  }
   DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String);
   Die->addValue(Attribute, Form, Str);
+}
-  unsigned idx = DD->getAddressPool().getIndex(Label);
+/// addLocalString - Add a string attribute data and value. This is guaranteed
-  DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
+/// to be in the local string pool instead of indirected.
-  Die.addValue(Attribute, dwarf::DW_FORM_GNU_addr_index, Value);
+void CompileUnit::addLocalString(DIE *Die, dwarf::Attribute Attribute,
                                  StringRef String) {
   MCSymbol *Symb = DU->getStringPoolEntry(String);
   DIEValue *Value;
   if (Asm->needsRelocationsForDwarfStringPool())
     Value = new (DIEValueAllocator) DIELabel(Symb);
   else {
     MCSymbol *StringPool = DU->getStringPoolSym();
     Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool);
+  }
   Die->addValue(Attribute, dwarf::DW_FORM_strp, Value);
+}
-void DwarfCompileUnit::addLocalLabelAddress(DIE &Die,
+/// addExpr - Add a Dwarf expression attribute data and value.
-                                            dwarf::Attribute Attribute,
+///
-                                            const MCSymbol *Label) {
+void CompileUnit::addExpr(DIEBlock *Die, dwarf::Form Form, const MCExpr *Expr) {
   DIEValue *Value = new (DIEValueAllocator) DIEExpr(Expr);
   Die->addValue((dwarf::Attribute)0, Form, Value);
+}
 /// addLabel - Add a Dwarf label attribute data and value.
 ///
 void CompileUnit::addLabel(DIE *Die, dwarf::Attribute Attribute,
                            dwarf::Form Form, const MCSymbol *Label) {
   DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
   Die->addValue(Attribute, Form, Value);
+}
 void CompileUnit::addLabel(DIEBlock *Die, dwarf::Form Form,
                            const MCSymbol *Label) {
   addLabel(Die, (dwarf::Attribute)0, Form, Label);
+}
 /// addLabelAddress - Add a dwarf label attribute data and value using
 /// DW_FORM_addr or DW_FORM_GNU_addr_index.
 ///
 void CompileUnit::addLabelAddress(DIE *Die, dwarf::Attribute Attribute,
                                   MCSymbol *Label) {
   if (Label)
     DD->addArangeLabel(SymbolCU(this, Label));
-  Die.addValue(Attribute, dwarf::DW_FORM_addr,
+  if (!DD->useSplitDwarf()) {
-               Label ? (DIEValue *)new (DIEValueAllocator) DIELabel(Label)
+    if (Label != NULL) {
-                     : new (DIEValueAllocator) DIEInteger(0));
+      DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
       Die->addValue(Attribute, dwarf::DW_FORM_addr, Value);
     } else {
       DIEValue *Value = new (DIEValueAllocator) DIEInteger(0);
       Die->addValue(Attribute, dwarf::DW_FORM_addr, Value);
+    }
   } else {
     unsigned idx = DU->getAddrPoolIndex(Label);
     DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx);
     Die->addValue(Attribute, dwarf::DW_FORM_GNU_addr_index, Value);
+  }
+}
 /// addOpAddress - Add a dwarf op address data and value using the
 /// form given and an op of either DW_FORM_addr or DW_FORM_GNU_addr_index.
 ///
 void CompileUnit::addOpAddress(DIEBlock *Die, const MCSymbol *Sym) {
   DD->addArangeLabel(SymbolCU(this, Sym));
   if (!DD->useSplitDwarf()) {
     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
     addLabel(Die, dwarf::DW_FORM_udata, Sym);
   } else {
     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
     addUInt(Die, dwarf::DW_FORM_GNU_addr_index, DU->getAddrPoolIndex(Sym));
+  }
+}
 /// addDelta - Add a label delta attribute data and value.
 ///
 void CompileUnit::addDelta(DIE *Die, dwarf::Attribute Attribute,
                            dwarf::Form Form, const MCSymbol *Hi,
                            const MCSymbol *Lo) {
   DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
   Die->addValue(Attribute, Form, Value);
+}
 /// addDIEEntry - Add a DIE attribute data and value.
 ///
 void CompileUnit::addDIEEntry(DIE *Die, dwarf::Attribute Attribute,
                               DIE *Entry) {
   addDIEEntry(Die, Attribute, createDIEEntry(Entry));
+}
 void CompileUnit::addDIEEntry(DIE *Die, dwarf::Attribute Attribute,
                               DIEEntry *Entry) {
   const DIE *DieCU = Die->getCompileUnitOrNull();
   const DIE *EntryCU = Entry->getEntry()->getCompileUnitOrNull();
   if (!DieCU)
     // We assume that Die belongs to this CU, if it is not linked to any CU yet.
     DieCU = getCUDie();
   if (!EntryCU)
     EntryCU = getCUDie();
   Die->addValue(Attribute, EntryCU == DieCU ? dwarf::DW_FORM_ref4
                                             : dwarf::DW_FORM_ref_addr,
                 Entry);
+}
 /// Create a DIE with the given Tag, add the DIE to its parent, and
 /// call insertDIE if MD is not null.
 DIE *CompileUnit::createAndAddDIE(unsigned Tag, DIE &Parent, DIDescriptor N) {
   DIE *Die = new DIE(Tag);
   Parent.addChild(Die);
   if (N)
     insertDIE(N, Die);
   return Die;
+}
 /// addBlock - Add block data.
 ///
 void CompileUnit::addBlock(DIE *Die, dwarf::Attribute Attribute,
                            DIEBlock *Block) {
   Block->ComputeSize(Asm);
   DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
   Die->addValue(Attribute, Block->BestForm(), Block);
+}
 /// addSourceLine - Add location information to specified debug information
 /// entry.
 void CompileUnit::addSourceLine(DIE *Die, DIVariable V) {
   // Verify variable.
   if (!V.isVariable())
     return;
   unsigned Line = V.getLineNumber();
   if (Line == 0)
     return;
   unsigned FileID =
       DD->getOrCreateSourceID(V.getContext().getFilename(),
                               V.getContext().getDirectory(), getUniqueID());
   assert(FileID && "Invalid file id");
   addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
   addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
+}
 /// addSourceLine - Add location information to specified debug information
 /// entry.
 void CompileUnit::addSourceLine(DIE *Die, DIGlobalVariable G) {
   // Verify global variable.
   if (!G.isGlobalVariable())
     return;
   unsigned Line = G.getLineNumber();
   if (Line == 0)
     return;
   unsigned FileID =
       DD->getOrCreateSourceID(G.getFilename(), G.getDirectory(), getUniqueID());
   assert(FileID && "Invalid file id");
   addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
   addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
+}
 /// addSourceLine - Add location information to specified debug information
 /// entry.
 void CompileUnit::addSourceLine(DIE *Die, DISubprogram SP) {
   // Verify subprogram.
   if (!SP.isSubprogram())
     return;
   // If the line number is 0, don't add it.
   unsigned Line = SP.getLineNumber();
   if (Line == 0)
     return;
   unsigned FileID = DD->getOrCreateSourceID(SP.getFilename(), SP.getDirectory(),
                                             getUniqueID());
   assert(FileID && "Invalid file id");
   addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
   addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
+}
 /// addSourceLine - Add location information to specified debug information
 /// entry.
 void CompileUnit::addSourceLine(DIE *Die, DIType Ty) {
   // Verify type.
   if (!Ty.isType())
     return;
   unsigned Line = Ty.getLineNumber();
   if (Line == 0)
     return;
   unsigned FileID = DD->getOrCreateSourceID(Ty.getFilename(), Ty.getDirectory(),
                                             getUniqueID());
   assert(FileID && "Invalid file id");
   addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
   addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
+}
 /// addSourceLine - Add location information to specified debug information
 /// entry.
 void CompileUnit::addSourceLine(DIE *Die, DIObjCProperty Ty) {
   // Verify type.
   if (!Ty.isObjCProperty())
     return;
   unsigned Line = Ty.getLineNumber();
   if (Line == 0)
     return;
   DIFile File = Ty.getFile();
   unsigned FileID = DD->getOrCreateSourceID(File.getFilename(),
                                             File.getDirectory(), getUniqueID());
   assert(FileID && "Invalid file id");
   addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
   addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
+}
 /// addSourceLine - Add location information to specified debug information
 /// entry.
 void CompileUnit::addSourceLine(DIE *Die, DINameSpace NS) {
   // Verify namespace.
   if (!NS.Verify())
     return;
   unsigned Line = NS.getLineNumber();
   if (Line == 0)
     return;
   StringRef FN = NS.getFilename();
   unsigned FileID =
       DD->getOrCreateSourceID(FN, NS.getDirectory(), getUniqueID());
   assert(FileID && "Invalid file id");
   addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
   addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
+}
 /// addVariableAddress - Add DW_AT_location attribute for a
 /// DbgVariable based on provided MachineLocation.
 void CompileUnit::addVariableAddress(const DbgVariable &DV, DIE *Die,
                                      MachineLocation Location) {
   if (DV.variableHasComplexAddress())
     addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
   else if (DV.isBlockByrefVariable())
     addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
   else
     addAddress(Die, dwarf::DW_AT_location, Location,
                DV.getVariable().isIndirect());
+}
 /// addRegisterOp - Add register operand.
 void CompileUnit::addRegisterOp(DIEBlock *TheDie, unsigned Reg) {
   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
   unsigned DWReg = RI->getDwarfRegNum(Reg, false);
   if (DWReg < 32)
     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + DWReg);
   else {
     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
     addUInt(TheDie, dwarf::DW_FORM_udata, DWReg);
+  }
+}
 /// addRegisterOffset - Add register offset.
 void CompileUnit::addRegisterOffset(DIEBlock *TheDie, unsigned Reg,
                                     int64_t Offset) {
   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
   unsigned DWReg = RI->getDwarfRegNum(Reg, false);
   const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
   if (Reg == TRI->getFrameRegister(*Asm->MF))
     // If variable offset is based in frame register then use fbreg.
     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
   else if (DWReg < 32)
     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + DWReg);
   else {
     addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
     addUInt(TheDie, dwarf::DW_FORM_udata, DWReg);
+  }
   addSInt(TheDie, dwarf::DW_FORM_sdata, Offset);
+}
 /// addAddress - Add an address attribute to a die based on the location
 /// provided.
 void CompileUnit::addAddress(DIE *Die, dwarf::Attribute Attribute,
                              const MachineLocation &Location, bool Indirect) {
   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
   if (Location.isReg() && !Indirect)
     addRegisterOp(Block, Location.getReg());
   else {
     addRegisterOffset(Block, Location.getReg(), Location.getOffset());
     if (Indirect && !Location.isReg()) {
       addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
+    }
+  }
   // Now attach the location information to the DIE.
   addBlock(Die, Attribute, Block);
+}
 /// addComplexAddress - Start with the address based on the location provided,
 /// and generate the DWARF information necessary to find the actual variable
 /// given the extra address information encoded in the DIVariable, starting from
 /// the starting location.  Add the DWARF information to the die.
 ///
 void CompileUnit::addComplexAddress(const DbgVariable &DV, DIE *Die,
                                     dwarf::Attribute Attribute,
                                     const MachineLocation &Location) {
   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
   unsigned N = DV.getNumAddrElements();
   unsigned i = 0;
   if (Location.isReg()) {
     if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
       // If first address element is OpPlus then emit
       // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
       addRegisterOffset(Block, Location.getReg(), DV.getAddrElement(1));
       i = 2;
     } else
       addRegisterOp(Block, Location.getReg());
   } else
     addRegisterOffset(Block, Location.getReg(), Location.getOffset());
   for (; i < N; ++i) {
     uint64_t Element = DV.getAddrElement(i);
     if (Element == DIBuilder::OpPlus) {
       addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
       addUInt(Block, dwarf::DW_FORM_udata, DV.getAddrElement(++i));
     } else if (Element == DIBuilder::OpDeref) {
       if (!Location.isReg())
         addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
     } else
       llvm_unreachable("unknown DIBuilder Opcode");
+  }
   // Now attach the location information to the DIE.
   addBlock(Die, Attribute, Block);
+}
 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
    VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
    gives the variable VarName either the struct, or a pointer to the struct, as
    its type.  This is necessary for various behind-the-scenes things the
    compiler needs to do with by-reference variables in Blocks.
    However, as far as the original *programmer* is concerned, the variable
    should still have type 'SomeType', as originally declared.
    The function getBlockByrefType dives into the __Block_byref_x_VarName
    struct to find the original type of the variable, which is then assigned to
    the variable's Debug Information Entry as its real type.  So far, so good.
    However now the debugger will expect the variable VarName to have the type
    SomeType.  So we need the location attribute for the variable to be an
    expression that explains to the debugger how to navigate through the
    pointers and struct to find the actual variable of type SomeType.
    The following function does just that.  We start by getting
    the "normal" location for the variable. This will be the location
    of either the struct __Block_byref_x_VarName or the pointer to the
    struct __Block_byref_x_VarName.
    The struct will look something like:
    struct __Block_byref_x_VarName {
      ... <various fields>
      struct __Block_byref_x_VarName *forwarding;
      ... <various other fields>
      SomeType VarName;
      ... <maybe more fields>
    };
    If we are given the struct directly (as our starting point) we
    need to tell the debugger to:
 ).  Add the offset of the forwarding field.
 ).  Follow that pointer to get the real __Block_byref_x_VarName
    struct to use (the real one may have been copied onto the heap).
 ).  Add the offset for the field VarName, to find the actual variable.
    If we started with a pointer to the struct, then we need to
    dereference that pointer first, before the other steps.
    Translating this into DWARF ops, we will need to append the following
    to the current location description for the variable:
    DW_OP_deref                    -- optional, if we start with a pointer
    DW_OP_plus_uconst <forward_fld_offset>
    DW_OP_deref
    DW_OP_plus_uconst <varName_fld_offset>
    That is what this function does.  */
 /// addBlockByrefAddress - Start with the address based on the location
 /// provided, and generate the DWARF information necessary to find the
 /// actual Block variable (navigating the Block struct) based on the
 /// starting location.  Add the DWARF information to the die.  For
 /// more information, read large comment just above here.
 ///
 void CompileUnit::addBlockByrefAddress(const DbgVariable &DV, DIE *Die,
                                        dwarf::Attribute Attribute,
                                        const MachineLocation &Location) {
   DIType Ty = DV.getType();
   DIType TmpTy = Ty;
   uint16_t Tag = Ty.getTag();
   bool isPointer = false;
   StringRef varName = DV.getName();
   if (Tag == dwarf::DW_TAG_pointer_type) {
     DIDerivedType DTy(Ty);
     TmpTy = resolve(DTy.getTypeDerivedFrom());
     isPointer = true;
+  }
   DICompositeType blockStruct(TmpTy);
   // Find the __forwarding field and the variable field in the __Block_byref
   // struct.
   DIArray Fields = blockStruct.getTypeArray();
   DIDerivedType varField;
   DIDerivedType forwardingField;
   for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
     DIDerivedType DT(Fields.getElement(i));
     StringRef fieldName = DT.getName();
     if (fieldName == "__forwarding")
       forwardingField = DT;
     else if (fieldName == varName)
       varField = DT;
+  }
   // Get the offsets for the forwarding field and the variable field.
   unsigned forwardingFieldOffset = forwardingField.getOffsetInBits() >> 3;
   unsigned varFieldOffset = varField.getOffsetInBits() >> 2;
   // Decode the original location, and use that as the start of the byref
   // variable's location.
   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
   if (Location.isReg())
     addRegisterOp(Block, Location.getReg());
   else
     addRegisterOffset(Block, Location.getReg(), Location.getOffset());
   // If we started with a pointer to the __Block_byref... struct, then
   // the first thing we need to do is dereference the pointer (DW_OP_deref).
   if (isPointer)
     addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
   // Next add the offset for the '__forwarding' field:
   // DW_OP_plus_uconst ForwardingFieldOffset.  Note there's no point in
   // adding the offset if it's 0.
   if (forwardingFieldOffset > 0) {
     addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
     addUInt(Block, dwarf::DW_FORM_udata, forwardingFieldOffset);
+  }
   // Now dereference the __forwarding field to get to the real __Block_byref
   // struct:  DW_OP_deref.
   addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
   // Now that we've got the real __Block_byref... struct, add the offset
   // for the variable's field to get to the location of the actual variable:
   // DW_OP_plus_uconst varFieldOffset.  Again, don't add if it's 0.
   if (varFieldOffset > 0) {
     addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
     addUInt(Block, dwarf::DW_FORM_udata, varFieldOffset);
+  }
   // Now attach the location information to the DIE.
   addBlock(Die, Attribute, Block);
+}
 /// isTypeSigned - Return true if the type is signed.
 static bool isTypeSigned(DwarfDebug *DD, DIType Ty, int *SizeInBits) {
   if (Ty.isDerivedType())
     return isTypeSigned(DD, DD->resolve(DIDerivedType(Ty).getTypeDerivedFrom()),
                         SizeInBits);
   if (Ty.isBasicType())
     if (DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed ||
         DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed_char) {
       *SizeInBits = Ty.getSizeInBits();
       return true;
+    }
   return false;
+}
 /// Return true if type encoding is unsigned.
 static bool isUnsignedDIType(DwarfDebug *DD, DIType Ty) {
   DIDerivedType DTy(Ty);
   if (DTy.isDerivedType())
     return isUnsignedDIType(DD, DD->resolve(DTy.getTypeDerivedFrom()));
   DIBasicType BTy(Ty);
   if (BTy.isBasicType()) {
     unsigned Encoding = BTy.getEncoding();
     if (Encoding == dwarf::DW_ATE_unsigned ||
         Encoding == dwarf::DW_ATE_unsigned_char ||
         Encoding == dwarf::DW_ATE_boolean)
       return true;
+  }
   return false;
+}
 /// If this type is derived from a base type then return base type size.
 static uint64_t getBaseTypeSize(DwarfDebug *DD, DIDerivedType Ty) {
   unsigned Tag = Ty.getTag();
   if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
       Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
       Tag != dwarf::DW_TAG_restrict_type)
     return Ty.getSizeInBits();
   DIType BaseType = DD->resolve(Ty.getTypeDerivedFrom());
   // If this type is not derived from any type then take conservative approach.
   if (!BaseType.isValid())
     return Ty.getSizeInBits();
   // If this is a derived type, go ahead and get the base type, unless it's a
   // reference then it's just the size of the field. Pointer types have no need
   // of this since they're a different type of qualification on the type.
   if (BaseType.getTag() == dwarf::DW_TAG_reference_type ||
       BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type)
     return Ty.getSizeInBits();
   if (BaseType.isDerivedType())
     return getBaseTypeSize(DD, DIDerivedType(BaseType));
   return BaseType.getSizeInBits();
+}
 /// addConstantValue - Add constant value entry in variable DIE.
 void CompileUnit::addConstantValue(DIE *Die, const MachineOperand &MO,
                                    DIType Ty) {
   // FIXME: This is a bit conservative/simple - it emits negative values at
   // their maximum bit width which is a bit unfortunate (& doesn't prefer
   // udata/sdata over dataN as suggested by the DWARF spec)
   assert(MO.isImm() && "Invalid machine operand!");
   int SizeInBits = -1;
   bool SignedConstant = isTypeSigned(DD, Ty, &SizeInBits);
   dwarf::Form Form;
   // If we're a signed constant definitely use sdata.
   if (SignedConstant) {
     addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, MO.getImm());
     return;
+  }
   // Else use data for now unless it's larger than we can deal with.
   switch (SizeInBits) {
   case 8:
     Form = dwarf::DW_FORM_data1;
     break;
   case 16:
     Form = dwarf::DW_FORM_data2;
     break;
   case 32:
     Form = dwarf::DW_FORM_data4;
     break;
   case 64:
     Form = dwarf::DW_FORM_data8;
     break;
   default:
     Form = dwarf::DW_FORM_udata;
     addUInt(Die, dwarf::DW_AT_const_value, Form, MO.getImm());
     return;
+  }
   addUInt(Die, dwarf::DW_AT_const_value, Form, MO.getImm());
+}
 /// addConstantFPValue - Add constant value entry in variable DIE.
 void CompileUnit::addConstantFPValue(DIE *Die, const MachineOperand &MO) {
   assert(MO.isFPImm() && "Invalid machine operand!");
   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
   APFloat FPImm = MO.getFPImm()->getValueAPF();
   // Get the raw data form of the floating point.
   const APInt FltVal = FPImm.bitcastToAPInt();
   const char *FltPtr = (const char *)FltVal.getRawData();
   int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
   int Incr = (LittleEndian ? 1 : -1);
   int Start = (LittleEndian ? 0 : NumBytes - 1);
   int Stop = (LittleEndian ? NumBytes : -1);
   // Output the constant to DWARF one byte at a time.
   for (; Start != Stop; Start += Incr)
     addUInt(Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
   addBlock(Die, dwarf::DW_AT_const_value, Block);
+}
 /// addConstantFPValue - Add constant value entry in variable DIE.
 void CompileUnit::addConstantFPValue(DIE *Die, const ConstantFP *CFP) {
   // Pass this down to addConstantValue as an unsigned bag of bits.
   addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
+}
 /// addConstantValue - Add constant value entry in variable DIE.
 void CompileUnit::addConstantValue(DIE *Die, const ConstantInt *CI,
                                    bool Unsigned) {
   addConstantValue(Die, CI->getValue(), Unsigned);
+}
 // addConstantValue - Add constant value entry in variable DIE.
 void CompileUnit::addConstantValue(DIE *Die, const APInt &Val, bool Unsigned) {
   unsigned CIBitWidth = Val.getBitWidth();
   if (CIBitWidth <= 64) {
     // If we're a signed constant definitely use sdata.
     if (!Unsigned) {
       addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
               Val.getSExtValue());
       return;
+    }
     // Else use data for now unless it's larger than we can deal with.
     dwarf::Form Form;
     switch (CIBitWidth) {
     case 8:
       Form = dwarf::DW_FORM_data1;
       break;
     case 16:
       Form = dwarf::DW_FORM_data2;
       break;
     case 32:
       Form = dwarf::DW_FORM_data4;
       break;
     case 64:
       Form = dwarf::DW_FORM_data8;
       break;
     default:
       addUInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
               Val.getZExtValue());
       return;
+    }
     addUInt(Die, dwarf::DW_AT_const_value, Form, Val.getZExtValue());
     return;
+  }
   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
   // Get the raw data form of the large APInt.
   const uint64_t *Ptr64 = Val.getRawData();
   int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
   // Output the constant to DWARF one byte at a time.
   for (int i = 0; i < NumBytes; i++) {
     uint8_t c;
     if (LittleEndian)
       c = Ptr64[i / 8] >> (8 * (i & 7));
     else
       c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
     addUInt(Block, dwarf::DW_FORM_data1, c);
+  }
   addBlock(Die, dwarf::DW_AT_const_value, Block);
+}
 /// addTemplateParams - Add template parameters into buffer.
 void CompileUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
   // Add template parameters.
   for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
     DIDescriptor Element = TParams.getElement(i);
     if (Element.isTemplateTypeParameter())
       constructTemplateTypeParameterDIE(Buffer,
                                         DITemplateTypeParameter(Element));
     else if (Element.isTemplateValueParameter())
       constructTemplateValueParameterDIE(Buffer,
                                          DITemplateValueParameter(Element));
+  }
+}
 /// getOrCreateContextDIE - Get context owner's DIE.
 DIE *CompileUnit::getOrCreateContextDIE(DIScope Context) {
   if (!Context || Context.isFile())
     return getCUDie();
   if (Context.isType())
     return getOrCreateTypeDIE(DIType(Context));
   if (Context.isNameSpace())
     return getOrCreateNameSpace(DINameSpace(Context));
   if (Context.isSubprogram())
     return getOrCreateSubprogramDIE(DISubprogram(Context));
   return getDIE(Context);
+}
 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
 /// given DIType.
 DIE *CompileUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
   if (!TyNode)
     return NULL;
   DIType Ty(TyNode);
   assert(Ty.isType());
   // Construct the context before querying for the existence of the DIE in case
   // such construction creates the DIE.
   DIE *ContextDIE = getOrCreateContextDIE(resolve(Ty.getContext()));
   assert(ContextDIE);
   DIE *TyDIE = getDIE(Ty);
   if (TyDIE)
     return TyDIE;
   // Create new type.
   TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty);
   if (Ty.isBasicType())
     constructTypeDIE(*TyDIE, DIBasicType(Ty));
   else if (Ty.isCompositeType())
     constructTypeDIE(*TyDIE, DICompositeType(Ty));
   else {
     assert(Ty.isDerivedType() && "Unknown kind of DIType");
     constructTypeDIE(*TyDIE, DIDerivedType(Ty));
+  }
   // If this is a named finished type then include it in the list of types
   // for the accelerator tables.
   if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
     bool IsImplementation = 0;
     if (Ty.isCompositeType()) {
       DICompositeType CT(Ty);
       // A runtime language of 0 actually means C/C++ and that any
       // non-negative value is some version of Objective-C/C++.
       IsImplementation = (CT.getRunTimeLang() == 0) || CT.isObjcClassComplete();
+    }
     unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
     addAccelType(Ty.getName(), std::make_pair(TyDIE, Flags));
+  }
   return TyDIE;
+}
 /// addType - Add a new type attribute to the specified entity.
 void CompileUnit::addType(DIE *Entity, DIType Ty, dwarf::Attribute Attribute) {
   assert(Ty && "Trying to add a type that doesn't exist?");
   // Check for pre-existence.
   DIEEntry *Entry = getDIEEntry(Ty);
   // If it exists then use the existing value.
   if (Entry) {
     addDIEEntry(Entity, Attribute, Entry);
     return;
+  }
   // Construct type.
   DIE *Buffer = getOrCreateTypeDIE(Ty);
   // Set up proxy.
   Entry = createDIEEntry(Buffer);
   insertDIEEntry(Ty, Entry);
   addDIEEntry(Entity, Attribute, Entry);
   // If this is a complete composite type then include it in the
   // list of global types.
   addGlobalType(Ty);
+}
 // Accelerator table mutators - add each name along with its companion
 // DIE to the proper table while ensuring that the name that we're going
 // to reference is in the string table. We do this since the names we
 // add may not only be identical to the names in the DIE.
 void CompileUnit::addAccelName(StringRef Name, DIE *Die) {
   DU->getStringPoolEntry(Name);
   std::vector<DIE *> &DIEs = AccelNames[Name];
   DIEs.push_back(Die);
+}
 void CompileUnit::addAccelObjC(StringRef Name, DIE *Die) {
   DU->getStringPoolEntry(Name);
   std::vector<DIE *> &DIEs = AccelObjC[Name];
   DIEs.push_back(Die);
+}
 void CompileUnit::addAccelNamespace(StringRef Name, DIE *Die) {
   DU->getStringPoolEntry(Name);
   std::vector<DIE *> &DIEs = AccelNamespace[Name];
   DIEs.push_back(Die);
+}
 void CompileUnit::addAccelType(StringRef Name, std::pair<DIE *, unsigned> Die) {
   DU->getStringPoolEntry(Name);
   std::vector<std::pair<DIE *, unsigned> > &DIEs = AccelTypes[Name];
   DIEs.push_back(Die);
+}
 /// addGlobalName - Add a new global name to the compile unit.
 void CompileUnit::addGlobalName(StringRef Name, DIE *Die, DIScope Context) {
   std::string FullName = getParentContextString(Context) + Name.str();
   GlobalNames[FullName] = Die;
+}
 /// addGlobalType - Add a new global type to the compile unit.
 ///
 void CompileUnit::addGlobalType(DIType Ty) {
   DIScope Context = resolve(Ty.getContext());
   if (!Ty.getName().empty() && !Ty.isForwardDecl() &&
       (!Context || Context.isCompileUnit() || Context.isFile() ||
        Context.isNameSpace()))
     if (DIEEntry *Entry = getDIEEntry(Ty)) {
       std::string FullName =
           getParentContextString(Context) + Ty.getName().str();
       GlobalTypes[FullName] = Entry->getEntry();
+    }
+}
 /// getParentContextString - Walks the metadata parent chain in a language
 /// specific manner (using the compile unit language) and returns
 /// it as a string. This is done at the metadata level because DIEs may
 /// not currently have been added to the parent context and walking the
 /// DIEs looking for names is more expensive than walking the metadata.
 std::string CompileUnit::getParentContextString(DIScope Context) const {
   if (!Context)
     return "";
   // FIXME: Decide whether to implement this for non-C++ languages.
   if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
     return "";
   std::string CS;
   SmallVector<DIScope, 1> Parents;
   while (!Context.isCompileUnit()) {
     Parents.push_back(Context);
     if (Context.getContext())
       Context = resolve(Context.getContext());
     else
       // Structure, etc types will have a NULL context if they're at the top
       // level.
       break;
+  }
   // Reverse iterate over our list to go from the outermost construct to the
   // innermost.
   for (SmallVectorImpl<DIScope>::reverse_iterator I = Parents.rbegin(),
                                                   E = Parents.rend();
        I != E; ++I) {
     DIScope Ctx = *I;
     StringRef Name = Ctx.getName();
     if (!Name.empty()) {
       CS += Name;
       CS += "::";
+    }
+  }
   return CS;
+}
 /// addPubTypes - Add subprogram argument types for pubtypes section.
 void CompileUnit::addPubTypes(DISubprogram SP) {
   DICompositeType SPTy = SP.getType();
   uint16_t SPTag = SPTy.getTag();
   if (SPTag != dwarf::DW_TAG_subroutine_type)
     return;
   DIArray Args = SPTy.getTypeArray();
   for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
     DIType ATy(Args.getElement(i));
     if (!ATy.isType())
       continue;
     addGlobalType(ATy);
+  }
+}
-unsigned DwarfCompileUnit::getOrCreateSourceID(StringRef FileName,
+/// constructTypeDIE - Construct basic type die from DIBasicType.
-                                               StringRef DirName) {
+void CompileUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
-  // If we print assembly, we can't separate .file entries according to
+  // Get core information.
-  // compile units. Thus all files will belong to the default compile unit.
+  StringRef Name = BTy.getName();
   // Add name if not anonymous or intermediate type.
-  // FIXME: add a better feature test than hasRawTextSupport. Even better,
+  if (!Name.empty())
-  // extend .file to support this.
+    addString(&Buffer, dwarf::DW_AT_name, Name);
   return Asm->OutStreamer.EmitDwarfFileDirective(
-, DirName, FileName,
+  // An unspecified type only has a name attribute.
-      Asm->OutStreamer.hasRawTextSupport() ? 0 : getUniqueID());
+  if (BTy.getTag() == dwarf::DW_TAG_unspecified_type)
     return;
   addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
           BTy.getEncoding());
   uint64_t Size = BTy.getSizeInBits() >> 3;
   addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
+}
 /// constructTypeDIE - Construct derived type die from DIDerivedType.
 void CompileUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
   // Get core information.
   StringRef Name = DTy.getName();
   uint64_t Size = DTy.getSizeInBits() >> 3;
   uint16_t Tag = Buffer.getTag();
   // Map to main type, void will not have a type.
   DIType FromTy = resolve(DTy.getTypeDerivedFrom());
   if (FromTy)
     addType(&Buffer, FromTy);
   // Add name if not anonymous or intermediate type.
   if (!Name.empty())
     addString(&Buffer, dwarf::DW_AT_name, Name);
   // Add size if non-zero (derived types might be zero-sized.)
   if (Size && Tag != dwarf::DW_TAG_pointer_type)
     addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
   if (Tag == dwarf::DW_TAG_ptr_to_member_type)
     addDIEEntry(&Buffer, dwarf::DW_AT_containing_type,
                 getOrCreateTypeDIE(resolve(DTy.getClassType())));
   // Add source line info if available and TyDesc is not a forward declaration.
   if (!DTy.isForwardDecl())
     addSourceLine(&Buffer, DTy);
+}
 /// Return true if the type is appropriately scoped to be contained inside
 /// its own type unit.
 static bool isTypeUnitScoped(DIType Ty, const DwarfDebug *DD) {
   DIScope Parent = DD->resolve(Ty.getContext());
   while (Parent) {
     // Don't generate a hash for anything scoped inside a function.
     if (Parent.isSubprogram())
       return false;
     Parent = DD->resolve(Parent.getContext());
+  }
   return true;
+}
 /// Return true if the type should be split out into a type unit.
 static bool shouldCreateTypeUnit(DICompositeType CTy, const DwarfDebug *DD) {
   uint16_t Tag = CTy.getTag();
   switch (Tag) {
   case dwarf::DW_TAG_structure_type:
   case dwarf::DW_TAG_union_type:
   case dwarf::DW_TAG_enumeration_type:
   case dwarf::DW_TAG_class_type:
     // If this is a class, structure, union, or enumeration type
     // that is a definition (not a declaration), and not scoped
     // inside a function then separate this out as a type unit.
     return !CTy.isForwardDecl() && isTypeUnitScoped(CTy, DD);
   default:
     return false;
+  }
+}
 /// constructTypeDIE - Construct type DIE from DICompositeType.
 void CompileUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
   // Get core information.
   StringRef Name = CTy.getName();
   uint64_t Size = CTy.getSizeInBits() >> 3;
   uint16_t Tag = Buffer.getTag();
   switch (Tag) {
   case dwarf::DW_TAG_array_type:
     constructArrayTypeDIE(Buffer, CTy);
     break;
   case dwarf::DW_TAG_enumeration_type:
     constructEnumTypeDIE(Buffer, CTy);
     break;
   case dwarf::DW_TAG_subroutine_type: {
     // Add return type. A void return won't have a type.
     DIArray Elements = CTy.getTypeArray();
     DIType RTy(Elements.getElement(0));
     if (RTy)
       addType(&Buffer, RTy);
     bool isPrototyped = true;
     // Add arguments.
     for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
       DIDescriptor Ty = Elements.getElement(i);
       if (Ty.isUnspecifiedParameter()) {
         createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
         isPrototyped = false;
       } else {
         DIE *Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
         addType(Arg, DIType(Ty));
         if (DIType(Ty).isArtificial())
           addFlag(Arg, dwarf::DW_AT_artificial);
+      }
+    }
     // Add prototype flag if we're dealing with a C language and the
     // function has been prototyped.
     uint16_t Language = getLanguage();
     if (isPrototyped &&
         (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
          Language == dwarf::DW_LANG_ObjC))
       addFlag(&Buffer, dwarf::DW_AT_prototyped);
   } break;
   case dwarf::DW_TAG_structure_type:
   case dwarf::DW_TAG_union_type:
   case dwarf::DW_TAG_class_type: {
     // Add elements to structure type.
     DIArray Elements = CTy.getTypeArray();
     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
       DIDescriptor Element = Elements.getElement(i);
       DIE *ElemDie = NULL;
       if (Element.isSubprogram()) {
         DISubprogram SP(Element);
         ElemDie = getOrCreateSubprogramDIE(SP);
         if (SP.isProtected())
           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
                   dwarf::DW_ACCESS_protected);
         else if (SP.isPrivate())
           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
                   dwarf::DW_ACCESS_private);
         else
           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
                   dwarf::DW_ACCESS_public);
         if (SP.isExplicit())
           addFlag(ElemDie, dwarf::DW_AT_explicit);
       } else if (Element.isDerivedType()) {
         DIDerivedType DDTy(Element);
         if (DDTy.getTag() == dwarf::DW_TAG_friend) {
           ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
           addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()),
                   dwarf::DW_AT_friend);
         } else if (DDTy.isStaticMember()) {
           getOrCreateStaticMemberDIE(DDTy);
         } else {
           constructMemberDIE(Buffer, DDTy);
+        }
       } else if (Element.isObjCProperty()) {
         DIObjCProperty Property(Element);
         ElemDie = createAndAddDIE(Property.getTag(), Buffer);
         StringRef PropertyName = Property.getObjCPropertyName();
         addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
         addType(ElemDie, Property.getType());
         addSourceLine(ElemDie, Property);
         StringRef GetterName = Property.getObjCPropertyGetterName();
         if (!GetterName.empty())
           addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
         StringRef SetterName = Property.getObjCPropertySetterName();
         if (!SetterName.empty())
           addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
         unsigned PropertyAttributes = 0;
         if (Property.isReadOnlyObjCProperty())
           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
         if (Property.isReadWriteObjCProperty())
           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
         if (Property.isAssignObjCProperty())
           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
         if (Property.isRetainObjCProperty())
           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
         if (Property.isCopyObjCProperty())
           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
         if (Property.isNonAtomicObjCProperty())
           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
         if (PropertyAttributes)
           addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
                   PropertyAttributes);
         DIEEntry *Entry = getDIEEntry(Element);
         if (!Entry) {
           Entry = createDIEEntry(ElemDie);
           insertDIEEntry(Element, Entry);
+        }
       } else
         continue;
+    }
     if (CTy.isAppleBlockExtension())
       addFlag(&Buffer, dwarf::DW_AT_APPLE_block);
     DICompositeType ContainingType(resolve(CTy.getContainingType()));
     if (ContainingType)
       addDIEEntry(&Buffer, dwarf::DW_AT_containing_type,
                   getOrCreateTypeDIE(ContainingType));
     if (CTy.isObjcClassComplete())
       addFlag(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
     // Add template parameters to a class, structure or union types.
     // FIXME: The support isn't in the metadata for this yet.
     if (Tag == dwarf::DW_TAG_class_type ||
         Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
       addTemplateParams(Buffer, CTy.getTemplateParams());
     break;
+  }
   default:
     break;
+  }
   // Add name if not anonymous or intermediate type.
   if (!Name.empty())
     addString(&Buffer, dwarf::DW_AT_name, Name);
   if (Tag == dwarf::DW_TAG_enumeration_type ||
       Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
       Tag == dwarf::DW_TAG_union_type) {
     // Add size if non-zero (derived types might be zero-sized.)
     // TODO: Do we care about size for enum forward declarations?
     if (Size)
       addUInt(&Buffer, dwarf::DW_AT_byte_size, None, Size);
     else if (!CTy.isForwardDecl())
       // Add zero size if it is not a forward declaration.
       addUInt(&Buffer, dwarf::DW_AT_byte_size, None, 0);
     // If we're a forward decl, say so.
     if (CTy.isForwardDecl())
       addFlag(&Buffer, dwarf::DW_AT_declaration);
     // Add source line info if available.
     if (!CTy.isForwardDecl())
       addSourceLine(&Buffer, CTy);
     // No harm in adding the runtime language to the declaration.
     unsigned RLang = CTy.getRunTimeLang();
     if (RLang)
       addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
               RLang);
+  }
   // If this is a type applicable to a type unit it then add it to the
   // list of types we'll compute a hash for later.
   if (shouldCreateTypeUnit(CTy, DD))
     DD->addTypeUnitType(&Buffer);
+}
 /// constructTemplateTypeParameterDIE - Construct new DIE for the given
 /// DITemplateTypeParameter.
 void
 CompileUnit::constructTemplateTypeParameterDIE(DIE &Buffer,
                                                DITemplateTypeParameter TP) {
   DIE *ParamDIE =
       createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
   // Add the type if it exists, it could be void and therefore no type.
   if (TP.getType())
     addType(ParamDIE, resolve(TP.getType()));
   if (!TP.getName().empty())
     addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
+}
 /// constructTemplateValueParameterDIE - Construct new DIE for the given
 /// DITemplateValueParameter.
 void
 CompileUnit::constructTemplateValueParameterDIE(DIE &Buffer,
                                                 DITemplateValueParameter VP) {
   DIE *ParamDIE = createAndAddDIE(VP.getTag(), Buffer);
   // Add the type if there is one, template template and template parameter
   // packs will not have a type.
   if (VP.getTag() == dwarf::DW_TAG_template_value_parameter)
     addType(ParamDIE, resolve(VP.getType()));
   if (!VP.getName().empty())
     addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
   if (Value *Val = VP.getValue()) {
     if (ConstantInt *CI = dyn_cast<ConstantInt>(Val))
       addConstantValue(ParamDIE, CI,
                        isUnsignedDIType(DD, resolve(VP.getType())));
     else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) {
       // For declaration non-type template parameters (such as global values and
       // functions)
       DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
       addOpAddress(Block, Asm->getSymbol(GV));
       // Emit DW_OP_stack_value to use the address as the immediate value of the
       // parameter, rather than a pointer to it.
       addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
       addBlock(ParamDIE, dwarf::DW_AT_location, Block);
     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
       assert(isa<MDString>(Val));
       addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
                 cast<MDString>(Val)->getString());
     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
       assert(isa<MDNode>(Val));
       DIArray A(cast<MDNode>(Val));
       addTemplateParams(*ParamDIE, A);
+    }
+  }
+}
 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
   // Construct the context before querying for the existence of the DIE in case
   // such construction creates the DIE.
   DIE *ContextDIE = getOrCreateContextDIE(NS.getContext());
   DIE *NDie = getDIE(NS);
   if (NDie)
     return NDie;
   NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
   if (!NS.getName().empty()) {
     addString(NDie, dwarf::DW_AT_name, NS.getName());
     addAccelNamespace(NS.getName(), NDie);
     addGlobalName(NS.getName(), NDie, NS.getContext());
   } else
     addAccelNamespace("(anonymous namespace)", NDie);
   addSourceLine(NDie, NS);
   return NDie;
+}
 /// getOrCreateSubprogramDIE - Create new DIE using SP.
 DIE *CompileUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
   // Construct the context before querying for the existence of the DIE in case
   // such construction creates the DIE (as is the case for member function
   // declarations).
   DIE *ContextDIE = getOrCreateContextDIE(resolve(SP.getContext()));
   DIE *SPDie = getDIE(SP);
   if (SPDie)
     return SPDie;
   DISubprogram SPDecl = SP.getFunctionDeclaration();
   if (SPDecl.isSubprogram())
     // Add subprogram definitions to the CU die directly.
     ContextDIE = CUDie.get();
   // DW_TAG_inlined_subroutine may refer to this DIE.
   SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
   DIE *DeclDie = NULL;
   if (SPDecl.isSubprogram())
     DeclDie = getOrCreateSubprogramDIE(SPDecl);
   // Add function template parameters.
   addTemplateParams(*SPDie, SP.getTemplateParams());
   // If this DIE is going to refer declaration info using AT_specification
   // then there is no need to add other attributes.
   if (DeclDie) {
     // Refer function declaration directly.
     addDIEEntry(SPDie, dwarf::DW_AT_specification, DeclDie);
     return SPDie;
+  }
   // Add the linkage name if we have one.
   StringRef LinkageName = SP.getLinkageName();
   if (!LinkageName.empty())
     addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
               GlobalValue::getRealLinkageName(LinkageName));
   // Constructors and operators for anonymous aggregates do not have names.
   if (!SP.getName().empty())
     addString(SPDie, dwarf::DW_AT_name, SP.getName());
   addSourceLine(SPDie, SP);
   // Add the prototype if we have a prototype and we have a C like
   // language.
   uint16_t Language = getLanguage();
   if (SP.isPrototyped() &&
       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
        Language == dwarf::DW_LANG_ObjC))
     addFlag(SPDie, dwarf::DW_AT_prototyped);
   DICompositeType SPTy = SP.getType();
   assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
          "the type of a subprogram should be a subroutine");
   DIArray Args = SPTy.getTypeArray();
   // Add a return type. If this is a type like a C/C++ void type we don't add a
   // return type.
   if (Args.getElement(0))
     addType(SPDie, DIType(Args.getElement(0)));
   unsigned VK = SP.getVirtuality();
   if (VK) {
     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
     DIEBlock *Block = getDIEBlock();
     addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
     addUInt(Block, dwarf::DW_FORM_udata, SP.getVirtualIndex());
     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
     ContainingTypeMap.insert(
         std::make_pair(SPDie, resolve(SP.getContainingType())));
+  }
   if (!SP.isDefinition()) {
     addFlag(SPDie, dwarf::DW_AT_declaration);
     // Add arguments. Do not add arguments for subprogram definition. They will
     // be handled while processing variables.
     for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
       DIE *Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, *SPDie);
       DIType ATy(Args.getElement(i));
       addType(Arg, ATy);
       if (ATy.isArtificial())
         addFlag(Arg, dwarf::DW_AT_artificial);
+    }
+  }
   if (SP.isArtificial())
     addFlag(SPDie, dwarf::DW_AT_artificial);
   if (!SP.isLocalToUnit())
     addFlag(SPDie, dwarf::DW_AT_external);
   if (SP.isOptimized())
     addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
   if (unsigned isa = Asm->getISAEncoding()) {
     addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
+  }
   return SPDie;
+}
 // Return const expression if value is a GEP to access merged global
 // constant. e.g.
 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
   const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
   if (!CE || CE->getNumOperands() != 3 ||
       CE->getOpcode() != Instruction::GetElementPtr)
-    return nullptr;
+    return NULL;
   // First operand points to a global struct.
   Value *Ptr = CE->getOperand(0);
   if (!isa<GlobalValue>(Ptr) ||
       !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
-    return nullptr;
+    return NULL;
   // Second operand is zero.
   const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
   if (!CI || !CI->isZero())
-    return nullptr;
+    return NULL;
   // Third operand is offset.
   if (!isa<ConstantInt>(CE->getOperand(2)))
-    return nullptr;
+    return NULL;
   return CE;
+}
-/// getOrCreateGlobalVariableDIE - get or create global variable DIE.
+/// createGlobalVariableDIE - create global variable DIE.
-DIE *DwarfCompileUnit::getOrCreateGlobalVariableDIE(DIGlobalVariable GV) {
+void CompileUnit::createGlobalVariableDIE(DIGlobalVariable GV) {
   // Check for pre-existence.
-  if (DIE *Die = getDIE(GV))
+  if (getDIE(GV))
-    return Die;
+    return;
-  assert(GV.isGlobalVariable());
+  if (!GV.isGlobalVariable())
     return;
   DIScope GVContext = GV.getContext();
-  DIType GTy = DD->resolve(GV.getType());
+  DIType GTy = GV.getType();
   // Construct the context before querying for the existence of the DIE in
   // case such construction creates the DIE.
   DIE *ContextDIE = getOrCreateContextDIE(GVContext);
   // Add to map.
   DIE *VariableDIE = &createAndAddDIE(GV.getTag(), *ContextDIE, GV);
   DIScope DeclContext;
-  if (DIDerivedType SDMDecl = GV.getStaticDataMemberDeclaration()) {
+  // If this is a static data member definition, some attributes belong
-    DeclContext = resolve(SDMDecl.getContext());
+  // to the declaration DIE.
   DIE *VariableDIE = NULL;
   bool IsStaticMember = false;
   DIDerivedType SDMDecl = GV.getStaticDataMemberDeclaration();
   if (SDMDecl.Verify()) {
     assert(SDMDecl.isStaticMember() && "Expected static member decl");
     assert(GV.isDefinition());
     // We need the declaration DIE that is in the static member's class.
-    DIE *VariableSpecDIE = getOrCreateStaticMemberDIE(SDMDecl);
+    VariableDIE = getOrCreateStaticMemberDIE(SDMDecl);
-    addDIEEntry(*VariableDIE, dwarf::DW_AT_specification, *VariableSpecDIE);
+    IsStaticMember = true;
   } else {
     DeclContext = GV.getContext();
   // If this is not a static data member definition, create the variable
   // DIE and add the initial set of attributes to it.
   if (!VariableDIE) {
     // Construct the context before querying for the existence of the DIE in
     // case such construction creates the DIE.
     DIE *ContextDIE = getOrCreateContextDIE(GVContext);
     // Add to map.
     VariableDIE = createAndAddDIE(GV.getTag(), *ContextDIE, GV);
     // Add name and type.
-    addString(*VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
+    addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
-    addType(*VariableDIE, GTy);
+    addType(VariableDIE, GTy);
     // Add scoping info.
     if (!GV.isLocalToUnit())
-      addFlag(*VariableDIE, dwarf::DW_AT_external);
+      addFlag(VariableDIE, dwarf::DW_AT_external);
     // Add line number info.
-    addSourceLine(*VariableDIE, GV);
+    addSourceLine(VariableDIE, GV);
+  }
   if (!GV.isDefinition())
     addFlag(*VariableDIE, dwarf::DW_AT_declaration);
   // Add location.
   bool addToAccelTable = false;
-  bool isGlobalVariable = GV.getGlobal() != nullptr;
+  DIE *VariableSpecDIE = NULL;
   bool isGlobalVariable = GV.getGlobal() != NULL;
   if (isGlobalVariable) {
     addToAccelTable = true;
-    DIELoc *Loc = new (DIEValueAllocator) DIELoc();
+    DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
     const MCSymbol *Sym = Asm->getSymbol(GV.getGlobal());
     if (GV.getGlobal()->isThreadLocal()) {
       // FIXME: Make this work with -gsplit-dwarf.
       unsigned PointerSize = Asm->getDataLayout().getPointerSize();
       assert((PointerSize == 4 || PointerSize == 8) &&
              "Add support for other sizes if necessary");
       const MCExpr *Expr =
           Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym);
       // Based on GCC's support for TLS:
       if (!DD->useSplitDwarf()) {
         // 1) Start with a constNu of the appropriate pointer size
-        addUInt(*Loc, dwarf::DW_FORM_data1,
+        addUInt(Block, dwarf::DW_FORM_data1,
                 PointerSize == 4 ? dwarf::DW_OP_const4u : dwarf::DW_OP_const8u);
         // 2) containing the (relocated) offset of the TLS variable
         //    within the module's TLS block.
-        addExpr(*Loc, dwarf::DW_FORM_udata,
+        addExpr(Block, dwarf::DW_FORM_udata, Expr);
                 Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym));
       } else {
-        addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
+        addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
-        addUInt(*Loc, dwarf::DW_FORM_udata,
+        addUInt(Block, dwarf::DW_FORM_udata, DU->getAddrPoolIndex(Expr));
                 DD->getAddressPool().getIndex(Sym, /* TLS */ true));
+      }
       // 3) followed by a custom OP to make the debugger do a TLS lookup.
-      addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_push_tls_address);
+      addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_push_tls_address);
     } else
       addOpAddress(Block, Sym);
     // Do not create specification DIE if context is either compile unit
     // or a subprogram.
     if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
         !GVContext.isFile() && !DD->isSubprogramContext(GVContext)) {
       // Create specification DIE.
       VariableSpecDIE = createAndAddDIE(dwarf::DW_TAG_variable, *CUDie);
       addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification, VariableDIE);
       addBlock(VariableSpecDIE, dwarf::DW_AT_location, Block);
       // A static member's declaration is already flagged as such.
       if (!SDMDecl.Verify())
         addFlag(VariableDIE, dwarf::DW_AT_declaration);
     } else {
-      DD->addArangeLabel(SymbolCU(this, Sym));
+      addBlock(VariableDIE, dwarf::DW_AT_location, Block);
       addOpAddress(*Loc, Sym);
+    }
     addBlock(*VariableDIE, dwarf::DW_AT_location, Loc);
     // Add the linkage name.
     StringRef LinkageName = GV.getLinkageName();
     if (!LinkageName.empty())
       // From DWARF4: DIEs to which DW_AT_linkage_name may apply include:
       // TAG_common_block, TAG_constant, TAG_entry_point, TAG_subprogram and
       // TAG_variable.
-      addString(*VariableDIE,
+      addString(IsStaticMember && VariableSpecDIE ? VariableSpecDIE
-                DD->getDwarfVersion() >= 4 ? dwarf::DW_AT_linkage_name
+                                                  : VariableDIE,
-                                           : dwarf::DW_AT_MIPS_linkage_name,
+                dwarf::DW_AT_MIPS_linkage_name,
                 GlobalValue::getRealLinkageName(LinkageName));
   } else if (const ConstantInt *CI =
                  dyn_cast_or_null<ConstantInt>(GV.getConstant())) {
-    addConstantValue(*VariableDIE, CI, GTy);
+    // AT_const_value was added when the static member was created. To avoid
-  } else if (const ConstantExpr *CE = getMergedGlobalExpr(GV.getConstant())) {
+    // emitting AT_const_value multiple times, we only add AT_const_value when
     // it is not a static member.
     if (!IsStaticMember)
       addConstantValue(VariableDIE, CI, isUnsignedDIType(DD, GTy));
   } else if (const ConstantExpr *CE = getMergedGlobalExpr(GV->getOperand(11))) {
     addToAccelTable = true;
     // GV is a merged global.
-    DIELoc *Loc = new (DIEValueAllocator) DIELoc();
+    DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
     Value *Ptr = CE->getOperand(0);
-    MCSymbol *Sym = Asm->getSymbol(cast<GlobalValue>(Ptr));
+    addOpAddress(Block, Asm->getSymbol(cast<GlobalValue>(Ptr)));
-    DD->addArangeLabel(SymbolCU(this, Sym));
+    addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
     addOpAddress(*Loc, Sym);
     addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
     SmallVector<Value *, 3> Idx(CE->op_begin() + 1, CE->op_end());
-    addUInt(*Loc, dwarf::DW_FORM_udata,
+    addUInt(Block, dwarf::DW_FORM_udata,
             Asm->getDataLayout().getIndexedOffset(Ptr->getType(), Idx));
-    addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
+    addUInt(Block, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
-    addBlock(*VariableDIE, dwarf::DW_AT_location, Loc);
+    addBlock(VariableDIE, dwarf::DW_AT_location, Block);
+  }
   if (addToAccelTable) {
-    DD->addAccelName(GV.getName(), *VariableDIE);
+    DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
     addAccelName(GV.getName(), AddrDIE);
     // If the linkage name is different than the name, go ahead and output
     // that as well into the name table.
     if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
-      DD->addAccelName(GV.getLinkageName(), *VariableDIE);
+      addAccelName(GV.getLinkageName(), AddrDIE);
+  }
-  addGlobalName(GV.getName(), *VariableDIE, DeclContext);
+  if (!GV.isLocalToUnit())
-  return VariableDIE;
+    addGlobalName(GV.getName(), VariableSpecDIE ? VariableSpecDIE : VariableDIE,
                   GV.getContext());
+}
 void DwarfCompileUnit::addRange(RangeSpan Range) {
-  bool SameAsPrevCU = this == DD->getPrevCU();
+/// constructSubrangeDIE - Construct subrange DIE from DISubrange.
-  DD->setPrevCU(this);
+void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR,
-  // If we have no current ranges just add the range and return, otherwise,
+                                       DIE *IndexTy) {
-  // check the current section and CU against the previous section and CU we
+  DIE *DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
-  // emitted into and the subprogram was contained within. If these are the
+  addDIEEntry(DW_Subrange, dwarf::DW_AT_type, IndexTy);
   // same then extend our current range, otherwise add this as a new range.
-  if (CURanges.empty() || !SameAsPrevCU ||
+  // The LowerBound value defines the lower bounds which is typically zero for
-      (&CURanges.back().getEnd()->getSection() !=
+  // C/C++. The Count value is the number of elements.  Values are 64 bit. If
-       &Range.getEnd()->getSection())) {
+  // Count == -1 then the array is unbounded and we do not emit
-    CURanges.push_back(Range);
+  // DW_AT_lower_bound and DW_AT_upper_bound attributes. If LowerBound == 0 and
-    return;
+  // Count == 0, then the array has zero elements in which case we do not emit
   // an upper bound.
   int64_t LowerBound = SR.getLo();
   int64_t DefaultLowerBound = getDefaultLowerBound();
   int64_t Count = SR.getCount();
   if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
   if (Count != -1 && Count != 0)
     // FIXME: An unbounded array should reference the expression that defines
     // the array.
     addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, None,
             LowerBound + Count - 1);
+}
 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
 void CompileUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) {
   if (CTy.isVector())
     addFlag(&Buffer, dwarf::DW_AT_GNU_vector);
   // Emit the element type.
   addType(&Buffer, resolve(CTy.getTypeDerivedFrom()));
   // Get an anonymous type for index type.
   // FIXME: This type should be passed down from the front end
   // as different languages may have different sizes for indexes.
   DIE *IdxTy = getIndexTyDie();
   if (!IdxTy) {
     // Construct an anonymous type for index type.
     IdxTy = createAndAddDIE(dwarf::DW_TAG_base_type, *CUDie.get());
     addString(IdxTy, dwarf::DW_AT_name, "int");
     addUInt(IdxTy, dwarf::DW_AT_byte_size, None, sizeof(int32_t));
     addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
             dwarf::DW_ATE_signed);
     setIndexTyDie(IdxTy);
+  }
-  CURanges.back().setEnd(Range.getEnd());
+  // Add subranges to array type.
   DIArray Elements = CTy.getTypeArray();
   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
-void DwarfCompileUnit::addSectionLabel(DIE &Die, dwarf::Attribute Attribute,
+    DIDescriptor Element = Elements.getElement(i);
-                                       const MCSymbol *Label,
+    if (Element.getTag() == dwarf::DW_TAG_subrange_type)
-                                       const MCSymbol *Sec) {
+      constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
     addLabel(Die, Attribute,
              DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
                                         : dwarf::DW_FORM_data4,
              Label);
   else
     addSectionDelta(Die, Attribute, Label, Sec);
 void DwarfCompileUnit::initStmtList(MCSymbol *DwarfLineSectionSym) {
   // Define start line table label for each Compile Unit.
   MCSymbol *LineTableStartSym =
       Asm->OutStreamer.getDwarfLineTableSymbol(getUniqueID());
   stmtListIndex = UnitDie.getValues().size();
   // DW_AT_stmt_list is a offset of line number information for this
   // compile unit in debug_line section. For split dwarf this is
   // left in the skeleton CU and so not included.
   // The line table entries are not always emitted in assembly, so it
   // is not okay to use line_table_start here.
   addSectionLabel(UnitDie, dwarf::DW_AT_stmt_list, LineTableStartSym,
                   DwarfLineSectionSym);
 void DwarfCompileUnit::applyStmtList(DIE &D) {
   D.addValue(dwarf::DW_AT_stmt_list,
              UnitDie.getAbbrev().getData()[stmtListIndex].getForm(),
              UnitDie.getValues()[stmtListIndex]);
 void DwarfCompileUnit::attachLowHighPC(DIE &D, const MCSymbol *Begin,
                                        const MCSymbol *End) {
   assert(Begin && "Begin label should not be null!");
   assert(End && "End label should not be null!");
   assert(Begin->isDefined() && "Invalid starting label");
   assert(End->isDefined() && "Invalid end label");
   addLabelAddress(D, dwarf::DW_AT_low_pc, Begin);
   if (DD->getDwarfVersion() < 4)
     addLabelAddress(D, dwarf::DW_AT_high_pc, End);
   else
     addLabelDelta(D, dwarf::DW_AT_high_pc, End, Begin);
 // 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 &DwarfCompileUnit::updateSubprogramScopeDIE(DISubprogram SP) {
   DIE *SPDie = getOrCreateSubprogramDIE(SP, includeMinimalInlineScopes());
   attachLowHighPC(*SPDie, DD->getFunctionBeginSym(), DD->getFunctionEndSym());
   if (!DD->getCurrentFunction()->getTarget().Options.DisableFramePointerElim(
           *DD->getCurrentFunction()))
     addFlag(*SPDie, dwarf::DW_AT_APPLE_omit_frame_ptr);
   // Only include DW_AT_frame_base in full debug info
   if (!includeMinimalInlineScopes()) {
     const TargetRegisterInfo *RI =
         Asm->TM.getSubtargetImpl()->getRegisterInfo();
     MachineLocation Location(RI->getFrameRegister(*Asm->MF));
     if (RI->isPhysicalRegister(Location.getReg()))
       addAddress(*SPDie, dwarf::DW_AT_frame_base, Location);
+  }
   // Add name to the name table, we do this here because we're guaranteed
   // to have concrete versions of our DW_TAG_subprogram nodes.
   DD->addSubprogramNames(SP, *SPDie);
   return *SPDie;
+}
-// Construct a DIE for this scope.
+/// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType.
-void DwarfCompileUnit::constructScopeDIE(
+void CompileUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) {
-    LexicalScope *Scope, SmallVectorImpl<std::unique_ptr<DIE>> &FinalChildren) {
+  DIArray Elements = CTy.getTypeArray();
   if (!Scope || !Scope->getScopeNode())
-    return;
+  // Add enumerators to enumeration type.
   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
-  DIScope DS(Scope->getScopeNode());
+    DIEnumerator Enum(Elements.getElement(i));
     if (Enum.isEnumerator()) {
-  assert((Scope->getInlinedAt() || !DS.isSubprogram()) &&
+      DIE *Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
-         "Only handle inlined subprograms here, use "
+      StringRef Name = Enum.getName();
-         "constructSubprogramScopeDIE for non-inlined "
+      addString(Enumerator, dwarf::DW_AT_name, Name);
-         "subprograms");
+      int64_t Value = Enum.getEnumValue();
       addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
   SmallVector<std::unique_ptr<DIE>, 8> Children;
   // We try to create the scope DIE first, then the children DIEs. This will
   // avoid creating un-used children then removing them later when we find out
   // the scope DIE is null.
   std::unique_ptr<DIE> ScopeDIE;
   if (Scope->getParent() && DS.isSubprogram()) {
     ScopeDIE = constructInlinedScopeDIE(Scope);
     if (!ScopeDIE)
       return;
     // We create children when the scope DIE is not null.
     createScopeChildrenDIE(Scope, Children);
   } else {
     // Early exit when we know the scope DIE is going to be null.
     if (DD->isLexicalScopeDIENull(Scope))
       return;
     unsigned ChildScopeCount;
     // We create children here when we know the scope DIE is not going to be
     // null and the children will be added to the scope DIE.
     createScopeChildrenDIE(Scope, Children, &ChildScopeCount);
     // Skip imported directives in gmlt-like data.
     if (!includeMinimalInlineScopes()) {
       // There is no need to emit empty lexical block DIE.
       for (const auto &E : DD->findImportedEntitiesForScope(DS))
         Children.push_back(
             constructImportedEntityDIE(DIImportedEntity(E.second)));
     // If there are only other scopes as children, put them directly in the
     // parent instead, as this scope would serve no purpose.
     if (Children.size() == ChildScopeCount) {
       FinalChildren.insert(FinalChildren.end(),
                            std::make_move_iterator(Children.begin()),
                            std::make_move_iterator(Children.end()));
       return;
+    }
     ScopeDIE = constructLexicalScopeDIE(Scope);
     assert(ScopeDIE && "Scope DIE should not be null.");
+  }
   DIType DTy = resolve(CTy.getTypeDerivedFrom());
-  // Add children
+  if (DTy) {
-  for (auto &I : Children)
+    addType(&Buffer, DTy);
-    ScopeDIE->addChild(std::move(I));
+    addFlag(&Buffer, dwarf::DW_AT_enum_class);
+  }
   FinalChildren.push_back(std::move(ScopeDIE));
 void DwarfCompileUnit::addSectionDelta(DIE &Die, dwarf::Attribute Attribute,
                                        const MCSymbol *Hi, const MCSymbol *Lo) {
   DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
   Die.addValue(Attribute, DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
                                                      : dwarf::DW_FORM_data4,
                Value);
 void DwarfCompileUnit::addScopeRangeList(DIE &ScopeDIE,
                                          SmallVector<RangeSpan, 2> Range) {
   // Emit offset in .debug_range as a relocatable label. emitDIE will handle
   // emitting it appropriately.
   auto *RangeSectionSym = DD->getRangeSectionSym();
   RangeSpanList List(
       Asm->GetTempSymbol("debug_ranges", DD->getNextRangeNumber()),
       std::move(Range));
   // Under fission, ranges are specified by constant offsets relative to the
   // CU's DW_AT_GNU_ranges_base.
   if (isDwoUnit())
     addSectionDelta(ScopeDIE, dwarf::DW_AT_ranges, List.getSym(),
                     RangeSectionSym);
   else
     addSectionLabel(ScopeDIE, dwarf::DW_AT_ranges, List.getSym(),
                     RangeSectionSym);
   // Add the range list to the set of ranges to be emitted.
   (Skeleton ? Skeleton : this)->CURangeLists.push_back(std::move(List));
 void DwarfCompileUnit::attachRangesOrLowHighPC(
     DIE &Die, SmallVector<RangeSpan, 2> Ranges) {
   if (Ranges.size() == 1) {
     const auto &single = Ranges.front();
     attachLowHighPC(Die, single.getStart(), single.getEnd());
   } else
     addScopeRangeList(Die, std::move(Ranges));
+}
-void DwarfCompileUnit::attachRangesOrLowHighPC(
+/// constructContainingTypeDIEs - Construct DIEs for types that contain
-    DIE &Die, const SmallVectorImpl<InsnRange> &Ranges) {
+/// vtables.
-  SmallVector<RangeSpan, 2> List;
+void CompileUnit::constructContainingTypeDIEs() {
-  List.reserve(Ranges.size());
+  for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
-  for (const InsnRange &R : Ranges)
+                                                 CE = ContainingTypeMap.end();
-    List.push_back(RangeSpan(DD->getLabelBeforeInsn(R.first),
+       CI != CE; ++CI) {
-                             DD->getLabelAfterInsn(R.second)));
+    DIE *SPDie = CI->first;
-  attachRangesOrLowHighPC(Die, std::move(List));
+    DIDescriptor D(CI->second);
     if (!D)
       continue;
-// This scope represents inlined body of a function. Construct DIE to
+    DIE *NDie = getDIE(D);
-// represent this concrete inlined copy of the function.
+    if (!NDie)
-std::unique_ptr<DIE>
+      continue;
-DwarfCompileUnit::constructInlinedScopeDIE(LexicalScope *Scope) {
+    addDIEEntry(SPDie, dwarf::DW_AT_containing_type, NDie);
   assert(Scope->getScopeNode());
   DIScope DS(Scope->getScopeNode());
   DISubprogram InlinedSP = getDISubprogram(DS);
   // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram
   // was inlined from another compile unit.
   DIE *OriginDIE = DU->getAbstractSPDies()[InlinedSP];
   assert(OriginDIE && "Unable to find original DIE for an inlined subprogram.");
   auto ScopeDIE = make_unique<DIE>(dwarf::DW_TAG_inlined_subroutine);
   addDIEEntry(*ScopeDIE, dwarf::DW_AT_abstract_origin, *OriginDIE);
   attachRangesOrLowHighPC(*ScopeDIE, Scope->getRanges());
   // Add the call site information to the DIE.
   DILocation DL(Scope->getInlinedAt());
   addUInt(*ScopeDIE, dwarf::DW_AT_call_file, None,
           getOrCreateSourceID(DL.getFilename(), DL.getDirectory()));
   addUInt(*ScopeDIE, dwarf::DW_AT_call_line, None, DL.getLineNumber());
   // Add name to the name table, we do this here because we're guaranteed
   // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
   DD->addSubprogramNames(InlinedSP, *ScopeDIE);
   return ScopeDIE;
 // Construct new DW_TAG_lexical_block for this scope and attach
 // DW_AT_low_pc/DW_AT_high_pc labels.
 std::unique_ptr<DIE>
 DwarfCompileUnit::constructLexicalScopeDIE(LexicalScope *Scope) {
   if (DD->isLexicalScopeDIENull(Scope))
     return nullptr;
   auto ScopeDIE = make_unique<DIE>(dwarf::DW_TAG_lexical_block);
   if (Scope->isAbstractScope())
     return ScopeDIE;
   attachRangesOrLowHighPC(*ScopeDIE, Scope->getRanges());
   return ScopeDIE;
+}
 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
-std::unique_ptr<DIE> DwarfCompileUnit::constructVariableDIE(DbgVariable &DV,
+DIE *CompileUnit::constructVariableDIE(DbgVariable &DV, bool isScopeAbstract) {
-                                                            bool Abstract) {
+  StringRef Name = DV.getName();
   auto D = constructVariableDIEImpl(DV, Abstract);
   DV.setDIE(*D);
   return D;
 std::unique_ptr<DIE>
 DwarfCompileUnit::constructVariableDIEImpl(const DbgVariable &DV,
                                            bool Abstract) {
   // Define variable debug information entry.
-  auto VariableDie = make_unique<DIE>(DV.getTag());
+  DIE *VariableDie = new DIE(DV.getTag());
   DbgVariable *AbsVar = DV.getAbstractVariable();
   DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
   if (AbsDIE)
     addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin, AbsDIE);
   else {
     if (!Name.empty())
       addString(VariableDie, dwarf::DW_AT_name, Name);
     addSourceLine(VariableDie, DV.getVariable());
     addType(VariableDie, DV.getType());
+  }
   if (DV.isArtificial())
     addFlag(VariableDie, dwarf::DW_AT_artificial);
-  if (Abstract) {
+  if (isScopeAbstract) {
-    applyVariableAttributes(DV, *VariableDie);
+    DV.setDIE(VariableDie);
     return VariableDie;
+  }
   // Add variable address.
   unsigned Offset = DV.getDotDebugLocOffset();
   if (Offset != ~0U) {
-    addLocationList(*VariableDie, dwarf::DW_AT_location, Offset);
+    addLabel(VariableDie, dwarf::DW_AT_location,
              DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
                                         : dwarf::DW_FORM_data4,
              Asm->GetTempSymbol("debug_loc", Offset));
     DV.setDIE(VariableDie);
     return VariableDie;
+  }
   // Check if variable is described by a DBG_VALUE instruction.
   if (const MachineInstr *DVInsn = DV.getMInsn()) {
-    assert(DVInsn->getNumOperands() == 4);
+    assert(DVInsn->getNumOperands() == 3);
     if (DVInsn->getOperand(0).isReg()) {
       const MachineOperand RegOp = DVInsn->getOperand(0);
       // If the second operand is an immediate, this is an indirect value.
       if (DVInsn->getOperand(1).isImm()) {
         MachineLocation Location(RegOp.getReg(),
                                  DVInsn->getOperand(1).getImm());
-        addVariableAddress(DV, *VariableDie, Location);
+        addVariableAddress(DV, VariableDie, Location);
       } else if (RegOp.getReg())
-        addVariableAddress(DV, *VariableDie, MachineLocation(RegOp.getReg()));
+        addVariableAddress(DV, VariableDie, MachineLocation(RegOp.getReg()));
     } else if (DVInsn->getOperand(0).isImm())
-      addConstantValue(*VariableDie, DVInsn->getOperand(0), DV.getType());
+      addConstantValue(VariableDie, DVInsn->getOperand(0), DV.getType());
     else if (DVInsn->getOperand(0).isFPImm())
-      addConstantFPValue(*VariableDie, DVInsn->getOperand(0));
+      addConstantFPValue(VariableDie, DVInsn->getOperand(0));
     else if (DVInsn->getOperand(0).isCImm())
-      addConstantValue(*VariableDie, DVInsn->getOperand(0).getCImm(),
+      addConstantValue(VariableDie, DVInsn->getOperand(0).getCImm(),
-                       DV.getType());
+                       isUnsignedDIType(DD, DV.getType()));
     DV.setDIE(VariableDie);
     return VariableDie;
   } else {
     // .. else use frame index.
     int FI = DV.getFrameIndex();
     if (FI != ~0) {
       unsigned FrameReg = 0;
       const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
       int Offset = TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
       MachineLocation Location(FrameReg, Offset);
       addVariableAddress(DV, VariableDie, Location);
+    }
+  }
-  // .. else use frame index.
+  DV.setDIE(VariableDie);
   int FI = DV.getFrameIndex();
   if (FI != ~0) {
     unsigned FrameReg = 0;
     const TargetFrameLowering *TFI =
         Asm->TM.getSubtargetImpl()->getFrameLowering();
     int Offset = TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
     MachineLocation Location(FrameReg, Offset);
     addVariableAddress(DV, *VariableDie, Location);
   return VariableDie;
+}
-std::unique_ptr<DIE> DwarfCompileUnit::constructVariableDIE(
+/// constructMemberDIE - Construct member DIE from DIDerivedType.
-    DbgVariable &DV, const LexicalScope &Scope, DIE *&ObjectPointer) {
+void CompileUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) {
-  auto Var = constructVariableDIE(DV, Scope.isAbstractScope());
+  DIE *MemberDie = createAndAddDIE(DT.getTag(), Buffer);
-  if (DV.isObjectPointer())
+  StringRef Name = DT.getName();
-    ObjectPointer = Var.get();
+  if (!Name.empty())
-  return Var;
+    addString(MemberDie, dwarf::DW_AT_name, Name);
 DIE *DwarfCompileUnit::createScopeChildrenDIE(
     LexicalScope *Scope, SmallVectorImpl<std::unique_ptr<DIE>> &Children,
     unsigned *ChildScopeCount) {
   DIE *ObjectPointer = nullptr;
   for (DbgVariable *DV : DU->getScopeVariables().lookup(Scope))
     Children.push_back(constructVariableDIE(*DV, *Scope, ObjectPointer));
   unsigned ChildCountWithoutScopes = Children.size();
   for (LexicalScope *LS : Scope->getChildren())
     constructScopeDIE(LS, Children);
   if (ChildScopeCount)
     *ChildScopeCount = Children.size() - ChildCountWithoutScopes;
   return ObjectPointer;
 void DwarfCompileUnit::constructSubprogramScopeDIE(LexicalScope *Scope) {
   assert(Scope && Scope->getScopeNode());
   assert(!Scope->getInlinedAt());
   assert(!Scope->isAbstractScope());
   DISubprogram Sub(Scope->getScopeNode());
   assert(Sub.isSubprogram());
   DD->getProcessedSPNodes().insert(Sub);
-  DIE &ScopeDIE = updateSubprogramScopeDIE(Sub);
+  addType(MemberDie, resolve(DT.getTypeDerivedFrom()));
-  // If this is a variadic function, add an unspecified parameter.
+  addSourceLine(MemberDie, DT);
   DITypeArray FnArgs = Sub.getType().getTypeArray();
-  // Collect lexical scope children first.
+  DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
-  // ObjectPointer might be a local (non-argument) local variable if it's a
+  addUInt(MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
   // block's synthetic this pointer.
   if (DIE *ObjectPointer = createAndAddScopeChildren(Scope, ScopeDIE))
     addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, *ObjectPointer);
-  // If we have a single element of null, it is a function that returns void.
+  if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) {
   // If we have more than one elements and the last one is null, it is a
   // variadic function.
   if (FnArgs.getNumElements() > 1 &&
       !FnArgs.getElement(FnArgs.getNumElements() - 1) &&
       !includeMinimalInlineScopes())
     ScopeDIE.addChild(make_unique<DIE>(dwarf::DW_TAG_unspecified_parameters));
-DIE *DwarfCompileUnit::createAndAddScopeChildren(LexicalScope *Scope,
+    // For C++, virtual base classes are not at fixed offset. Use following
-                                                 DIE &ScopeDIE) {
+    // expression to extract appropriate offset from vtable.
-  // We create children when the scope DIE is not null.
+    // BaseAddr = ObAddr + *((*ObAddr) - Offset)
   SmallVector<std::unique_ptr<DIE>, 8> Children;
   DIE *ObjectPointer = createScopeChildrenDIE(Scope, Children);
-  // Add children
+    DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
-  for (auto &I : Children)
+    addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
-    ScopeDIE.addChild(std::move(I));
+    addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
     addUInt(VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits());
     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
     addUInt(VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
-  return ObjectPointer;
+    addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
 void
 DwarfCompileUnit::constructAbstractSubprogramScopeDIE(LexicalScope *Scope) {
   DIE *&AbsDef = DU->getAbstractSPDies()[Scope->getScopeNode()];
   if (AbsDef)
     return;
   DISubprogram SP(Scope->getScopeNode());
   DIE *ContextDIE;
   if (includeMinimalInlineScopes())
     ContextDIE = &getUnitDie();
   // Some of this is duplicated from DwarfUnit::getOrCreateSubprogramDIE, with
   // the important distinction that the DIDescriptor is not associated with the
   // DIE (since the DIDescriptor will be associated with the concrete DIE, if
   // any). It could be refactored to some common utility function.
   else if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
     ContextDIE = &getUnitDie();
     getOrCreateSubprogramDIE(SPDecl);
   } else
     ContextDIE = getOrCreateContextDIE(resolve(SP.getContext()));
   // Passing null as the associated DIDescriptor because the abstract definition
   // shouldn't be found by lookup.
   AbsDef =
       &createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, DIDescriptor());
   applySubprogramAttributesToDefinition(SP, *AbsDef);
   if (!includeMinimalInlineScopes())
     addUInt(*AbsDef, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
   if (DIE *ObjectPointer = createAndAddScopeChildren(Scope, *AbsDef))
     addDIEEntry(*AbsDef, dwarf::DW_AT_object_pointer, *ObjectPointer);
 std::unique_ptr<DIE>
 DwarfCompileUnit::constructImportedEntityDIE(const DIImportedEntity &Module) {
   assert(Module.Verify() &&
          "Use one of the MDNode * overloads to handle invalid metadata");
   std::unique_ptr<DIE> IMDie = make_unique<DIE>((dwarf::Tag)Module.getTag());
   insertDIE(Module, IMDie.get());
   DIE *EntityDie;
   DIDescriptor Entity = resolve(Module.getEntity());
   if (Entity.isNameSpace())
     EntityDie = getOrCreateNameSpace(DINameSpace(Entity));
   else if (Entity.isSubprogram())
     EntityDie = getOrCreateSubprogramDIE(DISubprogram(Entity));
   else if (Entity.isType())
     EntityDie = getOrCreateTypeDIE(DIType(Entity));
   else if (Entity.isGlobalVariable())
     EntityDie = getOrCreateGlobalVariableDIE(DIGlobalVariable(Entity));
   else
     EntityDie = getDIE(Entity);
   assert(EntityDie);
   addSourceLine(*IMDie, Module.getLineNumber(),
                 Module.getContext().getFilename(),
                 Module.getContext().getDirectory());
   addDIEEntry(*IMDie, dwarf::DW_AT_import, *EntityDie);
   StringRef Name = Module.getName();
   if (!Name.empty())
     addString(*IMDie, dwarf::DW_AT_name, Name);
   return IMDie;
 void DwarfCompileUnit::finishSubprogramDefinition(DISubprogram SP) {
   DIE *D = getDIE(SP);
   if (DIE *AbsSPDIE = DU->getAbstractSPDies().lookup(SP)) {
     if (D)
       // If this subprogram has an abstract definition, reference that
       addDIEEntry(*D, dwarf::DW_AT_abstract_origin, *AbsSPDIE);
   } else {
-    if (!D && !includeMinimalInlineScopes())
+    uint64_t Size = DT.getSizeInBits();
-      // Lazily construct the subprogram if we didn't see either concrete or
+    uint64_t FieldSize = getBaseTypeSize(DD, DT);
-      // inlined versions during codegen. (except in -gmlt ^ where we want
+    uint64_t OffsetInBytes;
       // to omit these entirely)
-      D = getOrCreateSubprogramDIE(SP);
+    if (Size != FieldSize) {
-    if (D)
+      // Handle bitfield.
-      // And attach the attributes
+      addUInt(MemberDie, dwarf::DW_AT_byte_size, None,
-      applySubprogramAttributesToDefinition(SP, *D);
+              getBaseTypeSize(DD, DT) >> 3);
       addUInt(MemberDie, dwarf::DW_AT_bit_size, None, DT.getSizeInBits());
-void DwarfCompileUnit::collectDeadVariables(DISubprogram SP) {
+      uint64_t Offset = DT.getOffsetInBits();
-  assert(SP.isSubprogram() && "CU's subprogram list contains a non-subprogram");
+      uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
-  assert(SP.isDefinition() &&
+      uint64_t HiMark = (Offset + FieldSize) & AlignMask;
-         "CU's subprogram list contains a subprogram declaration");
+      uint64_t FieldOffset = (HiMark - FieldSize);
-  DIArray Variables = SP.getVariables();
+      Offset -= FieldOffset;
   if (Variables.getNumElements() == 0)
-    return;
+      // Maybe we need to work from the other end.
       if (Asm->getDataLayout().isLittleEndian())
-  DIE *SPDIE = DU->getAbstractSPDies().lookup(SP);
+        Offset = FieldSize - (Offset + Size);
-  if (!SPDIE)
+      addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
     SPDIE = getDIE(SP);
-  assert(SPDIE);
+      // Here WD_AT_data_member_location points to the anonymous
-  for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
+      // field that includes this bit field.
-    DIVariable DV(Variables.getElement(vi));
+      OffsetInBytes = FieldOffset >> 3;
-    assert(DV.isVariable());
+    } else
-    DbgVariable NewVar(DV, DIExpression(nullptr), DD);
+      // This is not a bitfield.
-    auto VariableDie = constructVariableDIE(NewVar);
+      OffsetInBytes = DT.getOffsetInBits() >> 3;
-    applyVariableAttributes(NewVar, *VariableDie);
+    addUInt(MemberDie, dwarf::DW_AT_data_member_location, None, OffsetInBytes);
     SPDIE->addChild(std::move(VariableDie));
+  }
 void DwarfCompileUnit::emitHeader(const MCSymbol *ASectionSym) const {
   // Don't bother labeling the .dwo unit, as its offset isn't used.
   if (!Skeleton)
     Asm->OutStreamer.EmitLabel(LabelBegin);
   DwarfUnit::emitHeader(ASectionSym);
 /// addGlobalName - Add a new global name to the compile unit.
 void DwarfCompileUnit::addGlobalName(StringRef Name, DIE &Die,
                                      DIScope Context) {
   if (includeMinimalInlineScopes())
     return;
   std::string FullName = getParentContextString(Context) + Name.str();
   GlobalNames[FullName] = &Die;
 /// Add a new global type to the unit.
 void DwarfCompileUnit::addGlobalType(DIType Ty, const DIE &Die,
                                      DIScope Context) {
   if (includeMinimalInlineScopes())
     return;
   std::string FullName = getParentContextString(Context) + Ty.getName().str();
   GlobalTypes[FullName] = &Die;
-/// addVariableAddress - Add DW_AT_location attribute for a
+  if (DT.isProtected())
-/// DbgVariable based on provided MachineLocation.
+    addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
-void DwarfCompileUnit::addVariableAddress(const DbgVariable &DV, DIE &Die,
+            dwarf::DW_ACCESS_protected);
-                                          MachineLocation Location) {
+  else if (DT.isPrivate())
-  if (DV.variableHasComplexAddress())
+    addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
-    addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
+            dwarf::DW_ACCESS_private);
-  else if (DV.isBlockByrefVariable())
+  // Otherwise C++ member and base classes are considered public.
     addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
   else
-    addAddress(Die, dwarf::DW_AT_location, Location,
+    addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
-               DV.getVariable().isIndirect());
+            dwarf::DW_ACCESS_public);
   if (DT.isVirtual())
     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
-/// Add an address attribute to a die based on the location provided.
+            dwarf::DW_VIRTUALITY_virtual);
 void DwarfCompileUnit::addAddress(DIE &Die, dwarf::Attribute Attribute,
-                                  const MachineLocation &Location,
+  // Objective-C properties.
-                                  bool Indirect) {
+  if (MDNode *PNode = DT.getObjCProperty())
-  DIELoc *Loc = new (DIEValueAllocator) DIELoc();
+    if (DIEEntry *PropertyDie = getDIEEntry(PNode))
       MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
-  bool validReg;
+                          PropertyDie);
   if (Location.isReg() && !Indirect)
-    validReg = addRegisterOpPiece(*Loc, Location.getReg());
+  if (DT.isArtificial())
     addFlag(MemberDie, dwarf::DW_AT_artificial);
+}
 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member.
 DIE *CompileUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) {
   if (!DT.Verify())
     return NULL;
   // Construct the context before querying for the existence of the DIE in case
   // such construction creates the DIE.
   DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext()));
   assert(dwarf::isType(ContextDIE->getTag()) &&
          "Static member should belong to a type.");
   DIE *StaticMemberDIE = getDIE(DT);
   if (StaticMemberDIE)
     return StaticMemberDIE;
   StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT);
   DIType Ty = resolve(DT.getTypeDerivedFrom());
   addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
   addType(StaticMemberDIE, Ty);
   addSourceLine(StaticMemberDIE, DT);
   addFlag(StaticMemberDIE, dwarf::DW_AT_external);
   addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
   // FIXME: We could omit private if the parent is a class_type, and
   // public if the parent is something else.
   if (DT.isProtected())
     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
             dwarf::DW_ACCESS_protected);
   else if (DT.isPrivate())
     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
             dwarf::DW_ACCESS_private);
   else
-    validReg = addRegisterOffset(*Loc, Location.getReg(), Location.getOffset());
+    addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
             dwarf::DW_ACCESS_public);
   if (!validReg)
     return;
   if (!Location.isReg() && Indirect)
     addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
   // Now attach the location information to the DIE.
   addBlock(Die, Attribute, Loc);
 /// Start with the address based on the location provided, and generate the
 /// DWARF information necessary to find the actual variable given the extra
 /// address information encoded in the DbgVariable, starting from the starting
 /// location.  Add the DWARF information to the die.
 void DwarfCompileUnit::addComplexAddress(const DbgVariable &DV, DIE &Die,
                                          dwarf::Attribute Attribute,
                                          const MachineLocation &Location) {
   DIELoc *Loc = new (DIEValueAllocator) DIELoc();
   DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
   DIExpression Expr = DV.getExpression();
   if (Location.getOffset()) {
     if (DwarfExpr.AddMachineRegIndirect(Location.getReg(),
                                         Location.getOffset())) {
       DwarfExpr.AddExpression(Expr);
       assert(!DV.getVariable().isIndirect()
              && "double indirection not handled");
   } else {
     if (DwarfExpr.AddMachineRegExpression(Expr, Location.getReg()))
       if (DV.getVariable().isIndirect())
         DwarfExpr.EmitOp(dwarf::DW_OP_deref);
   // Now attach the location information to the DIE.
   addBlock(Die, Attribute, Loc);
 /// Add a Dwarf loclistptr attribute data and value.
 void DwarfCompileUnit::addLocationList(DIE &Die, dwarf::Attribute Attribute,
                                        unsigned Index) {
   DIEValue *Value = new (DIEValueAllocator) DIELocList(Index);
   dwarf::Form Form = DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
                                                 : dwarf::DW_FORM_data4;
   Die.addValue(Attribute, Form, Value);
 void DwarfCompileUnit::applyVariableAttributes(const DbgVariable &Var,
                                                DIE &VariableDie) {
   StringRef Name = Var.getName();
   if (!Name.empty())
     addString(VariableDie, dwarf::DW_AT_name, Name);
   addSourceLine(VariableDie, Var.getVariable());
   addType(VariableDie, Var.getType());
   if (Var.isArtificial())
     addFlag(VariableDie, dwarf::DW_AT_artificial);
 /// Add a Dwarf expression attribute data and value.
 void DwarfCompileUnit::addExpr(DIELoc &Die, dwarf::Form Form,
                                const MCExpr *Expr) {
   DIEValue *Value = new (DIEValueAllocator) DIEExpr(Expr);
   Die.addValue((dwarf::Attribute)0, Form, Value);
 void DwarfCompileUnit::applySubprogramAttributesToDefinition(DISubprogram SP,
                                                              DIE &SPDie) {
   DISubprogram SPDecl = SP.getFunctionDeclaration();
   DIScope Context = resolve(SPDecl ? SPDecl.getContext() : SP.getContext());
   applySubprogramAttributes(SP, SPDie, includeMinimalInlineScopes());
   addGlobalName(SP.getName(), SPDie, Context);
 bool DwarfCompileUnit::isDwoUnit() const {
   return DD->useSplitDwarf() && Skeleton;
-bool DwarfCompileUnit::includeMinimalInlineScopes() const {
+  if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
-  return getCUNode().getEmissionKind() == DIBuilder::LineTablesOnly ||
+    addConstantValue(StaticMemberDIE, CI, isUnsignedDIType(DD, Ty));
-         (DD->useSplitDwarf() && !Skeleton);
+  if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
     addConstantFPValue(StaticMemberDIE, CFP);
   return StaticMemberDIE;
+}
 void CompileUnit::emitHeader(const MCSection *ASection,
                              const MCSymbol *ASectionSym) {
   Asm->OutStreamer.AddComment("DWARF version number");
   Asm->EmitInt16(DD->getDwarfVersion());
   Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
   Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
                          ASectionSym);
   Asm->OutStreamer.AddComment("Address Size (in bytes)");
   Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
+}
 } // end llvm namespace

 @@ -1,250 +1,409 @@
 //===-- llvm/CodeGen/DwarfCompileUnit.h - Dwarf Compile Unit ---*- C++ -*--===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains support for writing dwarf compile unit.
 //
 //===----------------------------------------------------------------------===//
-#ifndef LLVM_LIB_CODEGEN_ASMPRINTER_DWARFCOMPILEUNIT_H
+#ifndef CODEGEN_ASMPRINTER_DWARFCOMPILEUNIT_H
-#define LLVM_LIB_CODEGEN_ASMPRINTER_DWARFCOMPILEUNIT_H
+#define CODEGEN_ASMPRINTER_DWARFCOMPILEUNIT_H
-#include "DwarfUnit.h"
+#include "DIE.h"
-#include "llvm/ADT/StringRef.h"
+#include "DwarfDebug.h"
-#include "llvm/IR/DebugInfo.h"
+#include "llvm/ADT/DenseMap.h"
-#include "llvm/Support/Dwarf.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/OwningPtr.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/DebugInfo.h"
 #include "llvm/MC/MCExpr.h"
 namespace llvm {
-class AsmPrinter;
+class MachineLocation;
-class DIE;
+class MachineOperand;
-class DwarfDebug;
+class ConstantInt;
-class DwarfFile;
+class ConstantFP;
-class MCSymbol;
+class DbgVariable;
 class LexicalScope;
 class DwarfCompileUnit : public DwarfUnit {
   /// The attribute index of DW_AT_stmt_list in the compile unit DIE, avoiding
   /// the need to search for it in applyStmtList.
   unsigned stmtListIndex;
-  /// Skeleton unit associated with this unit.
+//===----------------------------------------------------------------------===//
-  DwarfCompileUnit *Skeleton;
+/// CompileUnit - This dwarf writer support class manages information associated
 /// with a source file.
 class CompileUnit {
   /// UniqueID - a numeric ID unique among all CUs in the module
   ///
   unsigned UniqueID;
-  /// A label at the start of the non-dwo section related to this unit.
+  /// Node - MDNode for the compile unit.
-  MCSymbol *SectionSym;
+  DICompileUnit Node;
-  /// The start of the unit within its section.
+  /// CUDie - Compile unit debug information entry.
-  MCSymbol *LabelBegin;
+  ///
   const OwningPtr<DIE> CUDie;
-  /// GlobalNames - A map of globally visible named entities for this unit.
+  /// Asm - Target of Dwarf emission.
-  StringMap<const DIE *> GlobalNames;
+  AsmPrinter *Asm;
-  /// GlobalTypes - A map of globally visible types for this unit.
+  // Holders for some common dwarf information.
-  StringMap<const DIE *> GlobalTypes;
+  DwarfDebug *DD;
   DwarfUnits *DU;
-  // List of range lists for a given compile unit, separate from the ranges for
+  /// IndexTyDie - An anonymous type for index type.  Owned by CUDie.
-  // the CU itself.
+  DIE *IndexTyDie;
   SmallVector<RangeSpanList, 1> CURangeLists;
-  // List of ranges for a given compile unit.
+  /// MDNodeToDieMap - Tracks the mapping of unit level debug information
-  SmallVector<RangeSpan, 2> CURanges;
+  /// variables to debug information entries.
   DenseMap<const MDNode *, DIE *> MDNodeToDieMap;
-  // The base address of this unit, if any. Used for relative references in
+  /// MDNodeToDIEEntryMap - Tracks the mapping of unit level debug information
-  // ranges/locs.
+  /// descriptors to debug information entries using a DIEEntry proxy.
-  const MCSymbol *BaseAddress;
+  DenseMap<const MDNode *, DIEEntry *> MDNodeToDIEEntryMap;
-  /// \brief Construct a DIE for the given DbgVariable without initializing the
+  /// GlobalNames - A map of globally visible named entities for this unit.
-  /// DbgVariable's DIE reference.
+  ///
-  std::unique_ptr<DIE> constructVariableDIEImpl(const DbgVariable &DV,
+  StringMap<DIE *> GlobalNames;
                                                 bool Abstract);
-  bool isDwoUnit() const override;
+  /// GlobalTypes - A map of globally visible types for this unit.
   ///
   StringMap<DIE *> GlobalTypes;
   /// AccelNames - A map of names for the name accelerator table.
   ///
   StringMap<std::vector<DIE *> > AccelNames;
   StringMap<std::vector<DIE *> > AccelObjC;
   StringMap<std::vector<DIE *> > AccelNamespace;
   StringMap<std::vector<std::pair<DIE *, unsigned> > > AccelTypes;
   /// DIEBlocks - A list of all the DIEBlocks in use.
   std::vector<DIEBlock *> DIEBlocks;
   /// ContainingTypeMap - This map is used to keep track of subprogram DIEs that
   /// need DW_AT_containing_type attribute. This attribute points to a DIE that
   /// corresponds to the MDNode mapped with the subprogram DIE.
   DenseMap<DIE *, const MDNode *> ContainingTypeMap;
   // DIEValueAllocator - All DIEValues are allocated through this allocator.
   BumpPtrAllocator DIEValueAllocator;
-  bool includeMinimalInlineScopes() const;
+  // DIEIntegerOne - A preallocated DIEValue because 1 is used frequently.
   DIEInteger *DIEIntegerOne;
 public:
-  DwarfCompileUnit(unsigned UID, DICompileUnit Node, AsmPrinter *A,
+  CompileUnit(unsigned UID, DIE *D, DICompileUnit CU, AsmPrinter *A,
-                   DwarfDebug *DW, DwarfFile *DWU);
+              DwarfDebug *DW, DwarfUnits *DWU);
   ~CompileUnit();
   // Accessors.
   unsigned getUniqueID() const { return UniqueID; }
   uint16_t getLanguage() const { return Node.getLanguage(); }
   DICompileUnit getNode() const { return Node; }
   DIE *getCUDie() const { return CUDie.get(); }
   const StringMap<DIE *> &getGlobalNames() const { return GlobalNames; }
   const StringMap<DIE *> &getGlobalTypes() const { return GlobalTypes; }
-  DwarfCompileUnit *getSkeleton() const {
+  const StringMap<std::vector<DIE *> > &getAccelNames() const {
-    return Skeleton;
+    return AccelNames;
+  }
   const StringMap<std::vector<DIE *> > &getAccelObjC() const {
     return AccelObjC;
+  }
   const StringMap<std::vector<DIE *> > &getAccelNamespace() const {
     return AccelNamespace;
+  }
   const StringMap<std::vector<std::pair<DIE *, unsigned> > > &
   getAccelTypes() const {
     return AccelTypes;
+  }
-  void initStmtList(MCSymbol *DwarfLineSectionSym);
+  unsigned getDebugInfoOffset() const { return DebugInfoOffset; }
   void setDebugInfoOffset(unsigned DbgInfoOff) { DebugInfoOffset = DbgInfoOff; }
-  /// Apply the DW_AT_stmt_list from this compile unit to the specified DIE.
+  /// hasContent - Return true if this compile unit has something to write out.
-  void applyStmtList(DIE &D);
+  ///
   bool hasContent() const { return !CUDie->getChildren().empty(); }
-  /// getOrCreateGlobalVariableDIE - get or create global variable DIE.
+  /// getParentContextString - Get a string containing the language specific
-  DIE *getOrCreateGlobalVariableDIE(DIGlobalVariable GV);
+  /// context for a global name.
   std::string getParentContextString(DIScope Context) const;
-  /// addLabelAddress - Add a dwarf label attribute data and value using
+  /// addGlobalName - Add a new global entity to the compile unit.
-  /// either DW_FORM_addr or DW_FORM_GNU_addr_index.
+  ///
-  void addLabelAddress(DIE &Die, dwarf::Attribute Attribute,
+  void addGlobalName(StringRef Name, DIE *Die, DIScope Context);
                        const MCSymbol *Label);
   /// addGlobalType - Add a new global type to the compile unit.
   ///
   void addGlobalType(DIType Ty);
   /// addPubTypes - Add a set of types from the subprogram to the global types.
   void addPubTypes(DISubprogram SP);
-  /// addLocalLabelAddress - Add a dwarf label attribute data and value using
+  /// addAccelName - Add a new name to the name accelerator table.
-  /// DW_FORM_addr only.
+  void addAccelName(StringRef Name, DIE *Die);
   void addLocalLabelAddress(DIE &Die, dwarf::Attribute Attribute,
                             const MCSymbol *Label);
-  /// addSectionDelta - Add a label delta attribute data and value.
+  /// addAccelObjC - Add a new name to the ObjC accelerator table.
-  void addSectionDelta(DIE &Die, dwarf::Attribute Attribute, const MCSymbol *Hi,
+  void addAccelObjC(StringRef Name, DIE *Die);
                        const MCSymbol *Lo);
-  DwarfCompileUnit &getCU() override { return *this; }
+  /// addAccelNamespace - Add a new name to the namespace accelerator table.
   void addAccelNamespace(StringRef Name, DIE *Die);
-  unsigned getOrCreateSourceID(StringRef FileName, StringRef DirName) override;
+  /// addAccelType - Add a new type to the type accelerator table.
   void addAccelType(StringRef Name, std::pair<DIE *, unsigned> Die);
-  /// addRange - Add an address range to the list of ranges for this unit.
+  /// getDIE - Returns the debug information entry map slot for the
-  void addRange(RangeSpan Range);
+  /// specified debug variable. We delegate the request to DwarfDebug
   /// when the MDNode can be part of the type system, since DIEs for
   /// the type system can be shared across CUs and the mappings are
   /// kept in DwarfDebug.
   DIE *getDIE(DIDescriptor D) const;
-  void attachLowHighPC(DIE &D, const MCSymbol *Begin, const MCSymbol *End);
+  DIEBlock *getDIEBlock() { return new (DIEValueAllocator) DIEBlock(); }
-  /// addSectionLabel - Add a Dwarf section label attribute data and value.
+  /// insertDIE - Insert DIE into the map. We delegate the request to DwarfDebug
   /// when the MDNode can be part of the type system, since DIEs for
   /// the type system can be shared across CUs and the mappings are
   /// kept in DwarfDebug.
   void insertDIE(DIDescriptor Desc, DIE *D);
   /// addDie - Adds or interns the DIE to the compile unit.
   ///
-  void addSectionLabel(DIE &Die, dwarf::Attribute Attribute,
+  void addDie(DIE *Buffer) { CUDie->addChild(Buffer); }
                        const MCSymbol *Label, const MCSymbol *Sec);
-  /// \brief Find DIE for the given subprogram and attach appropriate
+  /// addFlag - Add a flag that is true to the DIE.
-  /// DW_AT_low_pc and DW_AT_high_pc attributes. If there are global
+  void addFlag(DIE *Die, dwarf::Attribute Attribute);
   /// variables in this scope then create and insert DIEs for these
   /// variables.
   DIE &updateSubprogramScopeDIE(DISubprogram SP);
-  void constructScopeDIE(LexicalScope *Scope,
+  /// addUInt - Add an unsigned integer attribute data and value.
-                         SmallVectorImpl<std::unique_ptr<DIE>> &FinalChildren);
+  ///
   void addUInt(DIE *Die, dwarf::Attribute Attribute, Optional<dwarf::Form> Form,
                uint64_t Integer);
-  /// \brief A helper function to construct a RangeSpanList for a given
+  void addUInt(DIEBlock *Block, dwarf::Form Form, uint64_t Integer);
   /// lexical scope.
   void addScopeRangeList(DIE &ScopeDIE, SmallVector<RangeSpan, 2> Range);
-  void attachRangesOrLowHighPC(DIE &D, SmallVector<RangeSpan, 2> Ranges);
+  /// addSInt - Add an signed integer attribute data and value.
   ///
   void addSInt(DIE *Die, dwarf::Attribute Attribute, Optional<dwarf::Form> Form,
                int64_t Integer);
-  void attachRangesOrLowHighPC(DIE &D,
+  void addSInt(DIEBlock *Die, Optional<dwarf::Form> Form, int64_t Integer);
                                const SmallVectorImpl<InsnRange> &Ranges);
   /// \brief This scope represents inlined body of a function. Construct
   /// DIE to represent this concrete inlined copy of the function.
   std::unique_ptr<DIE> constructInlinedScopeDIE(LexicalScope *Scope);
-  /// \brief Construct new DW_TAG_lexical_block for this scope and
+  /// addString - Add a string attribute data and value.
-  /// attach DW_AT_low_pc/DW_AT_high_pc labels.
+  ///
-  std::unique_ptr<DIE> constructLexicalScopeDIE(LexicalScope *Scope);
+  void addString(DIE *Die, dwarf::Attribute Attribute, const StringRef Str);
-  /// constructVariableDIE - Construct a DIE for the given DbgVariable.
+  /// addLocalString - Add a string attribute data and value.
-  std::unique_ptr<DIE> constructVariableDIE(DbgVariable &DV,
+  ///
-                                            bool Abstract = false);
+  void addLocalString(DIE *Die, dwarf::Attribute Attribute, const StringRef Str);
   /// addExpr - Add a Dwarf expression attribute data and value.
   ///
   void addExpr(DIEBlock *Die, dwarf::Form Form, const MCExpr *Expr);
-  std::unique_ptr<DIE> constructVariableDIE(DbgVariable &DV,
+  /// addLabel - Add a Dwarf label attribute data and value.
-                                            const LexicalScope &Scope,
+  ///
-                                            DIE *&ObjectPointer);
+  void addLabel(DIE *Die, dwarf::Attribute Attribute, dwarf::Form Form,
                 const MCSymbol *Label);
-  /// A helper function to create children of a Scope DIE.
+  void addLabel(DIEBlock *Die, dwarf::Form Form, const MCSymbol *Label);
   DIE *createScopeChildrenDIE(LexicalScope *Scope,
                               SmallVectorImpl<std::unique_ptr<DIE>> &Children,
                               unsigned *ChildScopeCount = nullptr);
-  /// \brief Construct a DIE for this subprogram scope.
+  /// addLabelAddress - Add a dwarf label attribute data and value using
-  void constructSubprogramScopeDIE(LexicalScope *Scope);
+  /// either DW_FORM_addr or DW_FORM_GNU_addr_index.
   ///
   void addLabelAddress(DIE *Die, dwarf::Attribute Attribute, MCSymbol *Label);
-  DIE *createAndAddScopeChildren(LexicalScope *Scope, DIE &ScopeDIE);
+  /// addOpAddress - Add a dwarf op address data and value using the
   /// form given and an op of either DW_FORM_addr or DW_FORM_GNU_addr_index.
   ///
   void addOpAddress(DIEBlock *Die, const MCSymbol *Label);
-  void constructAbstractSubprogramScopeDIE(LexicalScope *Scope);
+  /// addDelta - Add a label delta attribute data and value.
   ///
   void addDelta(DIE *Die, dwarf::Attribute Attribute, dwarf::Form Form, const MCSymbol *Hi,
                 const MCSymbol *Lo);
-  /// \brief Construct import_module DIE.
+  /// addDIEEntry - Add a DIE attribute data and value.
-  std::unique_ptr<DIE>
+  ///
-  constructImportedEntityDIE(const DIImportedEntity &Module);
+  void addDIEEntry(DIE *Die, dwarf::Attribute Attribute, DIE *Entry);
-  void finishSubprogramDefinition(DISubprogram SP);
+  /// addDIEEntry - Add a DIE attribute data and value.
   ///
   void addDIEEntry(DIE *Die, dwarf::Attribute Attribute, DIEEntry *Entry);
-  void collectDeadVariables(DISubprogram SP);
+  /// addBlock - Add block data.
   ///
   void addBlock(DIE *Die, dwarf::Attribute Attribute, DIEBlock *Block);
-  /// Set the skeleton unit associated with this unit.
+  /// addSourceLine - Add location information to specified debug information
-  void setSkeleton(DwarfCompileUnit &Skel) { Skeleton = &Skel; }
+  /// entry.
   void addSourceLine(DIE *Die, DIVariable V);
   void addSourceLine(DIE *Die, DIGlobalVariable G);
   void addSourceLine(DIE *Die, DISubprogram SP);
   void addSourceLine(DIE *Die, DIType Ty);
   void addSourceLine(DIE *Die, DINameSpace NS);
   void addSourceLine(DIE *Die, DIObjCProperty Ty);
   /// addAddress - Add an address attribute to a die based on the location
   /// provided.
   void addAddress(DIE *Die, dwarf::Attribute Attribute, const MachineLocation &Location,
                   bool Indirect = false);
   /// addConstantValue - Add constant value entry in variable DIE.
   void addConstantValue(DIE *Die, const MachineOperand &MO, DIType Ty);
   void addConstantValue(DIE *Die, const ConstantInt *CI, bool Unsigned);
   void addConstantValue(DIE *Die, const APInt &Val, bool Unsigned);
   /// addConstantFPValue - Add constant value entry in variable DIE.
   void addConstantFPValue(DIE *Die, const MachineOperand &MO);
   void addConstantFPValue(DIE *Die, const ConstantFP *CFP);
   /// addTemplateParams - Add template parameters in buffer.
   void addTemplateParams(DIE &Buffer, DIArray TParams);
   /// addRegisterOp - Add register operand.
   void addRegisterOp(DIEBlock *TheDie, unsigned Reg);
   /// addRegisterOffset - Add register offset.
   void addRegisterOffset(DIEBlock *TheDie, unsigned Reg, int64_t Offset);
   /// addComplexAddress - Start with the address based on the location provided,
   /// and generate the DWARF information necessary to find the actual variable
   /// (navigating the extra location information encoded in the type) based on
   /// the starting location.  Add the DWARF information to the die.
   ///
   void addComplexAddress(const DbgVariable &DV, DIE *Die, dwarf::Attribute Attribute,
                          const MachineLocation &Location);
-  MCSymbol *getSectionSym() const {
+  // FIXME: Should be reformulated in terms of addComplexAddress.
-    assert(Section);
+  /// addBlockByrefAddress - Start with the address based on the location
-    return SectionSym;
+  /// provided, and generate the DWARF information necessary to find the
   /// actual Block variable (navigating the Block struct) based on the
   /// starting location.  Add the DWARF information to the die.  Obsolete,
   /// please use addComplexAddress instead.
   ///
   void addBlockByrefAddress(const DbgVariable &DV, DIE *Die, dwarf::Attribute Attribute,
                             const MachineLocation &Location);
-  /// Pass in the SectionSym even though we could recreate it in every compile
+  /// addVariableAddress - Add DW_AT_location attribute for a
-  /// unit (type units will have actually distinct symbols once they're in
+  /// DbgVariable based on provided MachineLocation.
-  /// comdat sections).
+  void addVariableAddress(const DbgVariable &DV, DIE *Die,
-  void initSection(const MCSection *Section, MCSymbol *SectionSym) {
+                          MachineLocation Location);
     DwarfUnit::initSection(Section);
     this->SectionSym = SectionSym;
-    // Don't bother labeling the .dwo unit, as its offset isn't used.
+  /// addType - Add a new type attribute to the specified entity. This takes
-    if (!Skeleton)
+  /// and attribute parameter because DW_AT_friend attributes are also
-      LabelBegin =
+  /// type references.
-          Asm->GetTempSymbol(Section->getLabelBeginName(), getUniqueID());
+  void addType(DIE *Entity, DIType Ty, dwarf::Attribute Attribute = dwarf::DW_AT_type);
   /// getOrCreateNameSpace - Create a DIE for DINameSpace.
   DIE *getOrCreateNameSpace(DINameSpace NS);
   /// getOrCreateSubprogramDIE - Create new DIE using SP.
   DIE *getOrCreateSubprogramDIE(DISubprogram SP);
   /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
   /// given DIType.
   DIE *getOrCreateTypeDIE(const MDNode *N);
   /// getOrCreateContextDIE - Get context owner's DIE.
   DIE *getOrCreateContextDIE(DIScope Context);
   /// createGlobalVariableDIE - create global variable DIE.
   void createGlobalVariableDIE(DIGlobalVariable GV);
   /// constructContainingTypeDIEs - Construct DIEs for types that contain
   /// vtables.
   void constructContainingTypeDIEs();
   /// constructVariableDIE - Construct a DIE for the given DbgVariable.
   DIE *constructVariableDIE(DbgVariable &DV, bool isScopeAbstract);
-  unsigned getLength() {
+  /// Create a DIE with the given Tag, add the DIE to its parent, and
-    return sizeof(uint32_t) + // Length field
+  /// call insertDIE if MD is not null.
-        getHeaderSize() + UnitDie.getSize();
+  DIE *createAndAddDIE(unsigned Tag, DIE &Parent, DIDescriptor N = DIDescriptor());
   /// Compute the size of a header for this unit, not including the initial
   /// length field.
   unsigned getHeaderSize() const {
     return sizeof(int16_t) + // DWARF version number
            sizeof(int32_t) + // Offset Into Abbrev. Section
            sizeof(int8_t);   // Pointer Size (in bytes)
+  }
-  void emitHeader(const MCSymbol *ASectionSym) const override;
+  /// Emit the header for this unit, not including the initial length field.
   void emitHeader(const MCSection *ASection, const MCSymbol *ASectionSym);
-  MCSymbol *getLabelBegin() const {
+private:
-    assert(Section);
+  /// constructTypeDIE - Construct basic type die from DIBasicType.
-    return LabelBegin;
+  void constructTypeDIE(DIE &Buffer, DIBasicType BTy);
-  /// Add a new global name to the compile unit.
+  /// constructTypeDIE - Construct derived type die from DIDerivedType.
-  void addGlobalName(StringRef Name, DIE &Die, DIScope Context) override;
+  void constructTypeDIE(DIE &Buffer, DIDerivedType DTy);
-  /// Add a new global type to the compile unit.
+  /// constructTypeDIE - Construct type DIE from DICompositeType.
-  void addGlobalType(DIType Ty, const DIE &Die, DIScope Context) override;
+  void constructTypeDIE(DIE &Buffer, DICompositeType CTy);
-  const StringMap<const DIE *> &getGlobalNames() const { return GlobalNames; }
+  /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
-  const StringMap<const DIE *> &getGlobalTypes() const { return GlobalTypes; }
+  void constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy);
-  /// Add DW_AT_location attribute for a DbgVariable based on provided
+  /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
-  /// MachineLocation.
+  void constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy);
   void addVariableAddress(const DbgVariable &DV, DIE &Die,
-                          MachineLocation Location);
+  /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
-  /// Add an address attribute to a die based on the location provided.
+  void constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy);
   void addAddress(DIE &Die, dwarf::Attribute Attribute,
                   const MachineLocation &Location, bool Indirect = false);
   /// Start with the address based on the location provided, and generate the
   /// DWARF information necessary to find the actual variable (navigating the
   /// extra location information encoded in the type) based on the starting
   /// location.  Add the DWARF information to the die.
   void addComplexAddress(const DbgVariable &DV, DIE &Die,
                          dwarf::Attribute Attribute,
                          const MachineLocation &Location);
-  /// Add a Dwarf loclistptr attribute data and value.
+  /// constructMemberDIE - Construct member DIE from DIDerivedType.
-  void addLocationList(DIE &Die, dwarf::Attribute Attribute, unsigned Index);
+  void constructMemberDIE(DIE &Buffer, DIDerivedType DT);
   void applyVariableAttributes(const DbgVariable &Var, DIE &VariableDie);
-  /// Add a Dwarf expression attribute data and value.
+  /// constructTemplateTypeParameterDIE - Construct new DIE for the given
-  void addExpr(DIELoc &Die, dwarf::Form Form, const MCExpr *Expr);
+  /// DITemplateTypeParameter.
   void constructTemplateTypeParameterDIE(DIE &Buffer,
                                          DITemplateTypeParameter TP);
-  void applySubprogramAttributesToDefinition(DISubprogram SP, DIE &SPDie);
+  /// constructTemplateValueParameterDIE - Construct new DIE for the given
   /// DITemplateValueParameter.
   void constructTemplateValueParameterDIE(DIE &Buffer,
                                           DITemplateValueParameter TVP);
-  /// getRangeLists - Get the vector of range lists.
+  /// getOrCreateStaticMemberDIE - Create new static data member DIE.
-  const SmallVectorImpl<RangeSpanList> &getRangeLists() const {
+  DIE *getOrCreateStaticMemberDIE(DIDerivedType DT);
     return (Skeleton ? Skeleton : this)->CURangeLists;
   /// Offset of the CUDie from beginning of debug info section.
   unsigned DebugInfoOffset;
   /// getLowerBoundDefault - Return the default lower bound for an array. If the
   /// DWARF version doesn't handle the language, return -1.
   int64_t getDefaultLowerBound() const;
   /// getDIEEntry - Returns the debug information entry for the specified
   /// debug variable.
   DIEEntry *getDIEEntry(const MDNode *N) const {
     return MDNodeToDIEEntryMap.lookup(N);
+  }
-  /// getRanges - Get the list of ranges for this unit.
+  /// insertDIEEntry - Insert debug information entry into the map.
-  const SmallVectorImpl<RangeSpan> &getRanges() const { return CURanges; }
+  void insertDIEEntry(const MDNode *N, DIEEntry *E) {
-  SmallVector<RangeSpan, 2> takeRanges() { return std::move(CURanges); }
+    MDNodeToDIEEntryMap.insert(std::make_pair(N, E));
+  }
-  void setBaseAddress(const MCSymbol *Base) { BaseAddress = Base; }
+  // getIndexTyDie - Get an anonymous type for index type.
-  const MCSymbol *getBaseAddress() const { return BaseAddress; }
+  DIE *getIndexTyDie() { return IndexTyDie; }
   // setIndexTyDie - Set D as anonymous type for index which can be reused
   // later.
   void setIndexTyDie(DIE *D) { IndexTyDie = D; }
   /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
   /// information entry.
   DIEEntry *createDIEEntry(DIE *Entry);
   /// resolve - Look in the DwarfDebug map for the MDNode that
   /// corresponds to the reference.
   template <typename T> T resolve(DIRef<T> Ref) const {
     return DD->resolve(Ref);
+  }
 };
 } // end llvm namespace
 #endif