DWZ 02/11: Move the codebase to use: DWARFCompileUnit -> DWARFUnit

[jankratochvil]

Summary

Now the codebase can use the DWARFUnit superclass. It will make it later seamlessly work also with DWARFPartialUnit for DWZ.

This patch is only a search-and-replace easily undone, nothing interesting in it.

All DWZ patches are also applied in: git clone -b dwz git://git.jankratochvil.net/lldb

[davide]

LGTM.

[clayborg]

source/Plugins/SymbolFile/DWARF/DWARFUnit.h

34 ↗

(On Diff #135048)

DWARFCompileUnit inherits from this class. This isn't needed right?

[jankratochvil]

source/Plugins/SymbolFile/DWARF/DWARFUnit.h

34 ↗

(On Diff #135048)

It is needed now as DWARFCompileUnit::GetFunctionAranges() calls m_dwo_symbol_file->GetCompileUnit()->DIEPtr();:

llvm-git/tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp: In member function ‘const DWARFDebugAranges& DWARFCompileUnit::GetFunctionAranges()’:
llvm-git/tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp:504:59: error: ‘const DWARFDebugInfoEntry* DWARFUnit::DIEPtr()’ is protected within this context
       const DWARFDebugInfoEntry *dwo_die = dwo_cu->DIEPtr();
                                                           ^
In file included from llvm-git/tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.h:13:0,
                 from llvm-git/tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp:10:
llvm-git/tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.h:173:30: note: declared protected here
   const DWARFDebugInfoEntry *DIEPtr();
                              ^~~~~~

DIEPtr() cannot be even protected, it would need to be public. I do not like moving DWARFCompileUnit::GetFunctionAranges() implementation to DWARFUnit to access it as private as after such move it needs to access members by the Data() indirection and there is no need of GetFunctionAranges() for DWZ DWARFPartialUnit (as those units cannot contain code).
Going to check in the split now when it is approved, I can fix up the friend class upon request later, thanks.

lldb/trunk/include/lldb/Expression/DWARFExpression.h

 #include "lldb/Core/Address.h"
 #include "lldb/Core/Disassembler.h"
 #include "lldb/Core/Scalar.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-private.h"
 #include <functional>
 
-class DWARFCompileUnit;
+class DWARFUnit;
 
 namespace lldb_private {
 
 //----------------------------------------------------------------------
 /// @class DWARFExpression DWARFExpression.h "lldb/Expression/DWARFExpression.h"
 /// @brief Encapsulates a DWARF location expression and interprets it.
 ///
 /// DWARF location expressions are used in two ways by LLDB.  The first
enum LocationListFormat : uint8_t {
     NonLocationList,     // Not a location list
     RegularLocationList, // Location list format used in non-split dwarf files
     SplitDwarfLocationList, // Location list format used in split dwarf files
   };
 
   //------------------------------------------------------------------
   /// Constructor
   //------------------------------------------------------------------
-  explicit DWARFExpression(DWARFCompileUnit *dwarf_cu);
+  explicit DWARFExpression(DWARFUnit *dwarf_cu);
 
   //------------------------------------------------------------------
   /// Constructor
   ///
   /// @param[in] data
   ///     A data extractor configured to read the DWARF location expression's
   ///     bytecode.
   ///
   /// @param[in] data_offset
   ///     The offset of the location expression in the extractor.
   ///
   /// @param[in] data_length
   ///     The byte length of the location expression.
   //------------------------------------------------------------------
   DWARFExpression(lldb::ModuleSP module, const DataExtractor &data,
-                  DWARFCompileUnit *dwarf_cu, lldb::offset_t data_offset,
+                  DWARFUnit *dwarf_cu, lldb::offset_t data_offset,
                   lldb::offset_t data_length);
 
   //------------------------------------------------------------------
   /// Copy constructor
   //------------------------------------------------------------------
   DWARFExpression(const DWARFExpression &rhs);
 
   //------------------------------------------------------------------
public:
   ///     If non-NULL, used to report errors in expression evaluation.
   ///
   /// @return
   ///     True on success; false otherwise.  If error_ptr is non-NULL,
   ///     details of the failure are provided through it.
   //------------------------------------------------------------------
   static bool Evaluate(ExecutionContext *exe_ctx, RegisterContext *reg_ctx,
                        lldb::ModuleSP opcode_ctx, const DataExtractor &opcodes,
-                       DWARFCompileUnit *dwarf_cu, const lldb::offset_t offset,
+                       DWARFUnit *dwarf_cu, const lldb::offset_t offset,
                        const lldb::offset_t length,
                        const lldb::RegisterKind reg_set,
                        const Value *initial_value_ptr,
                        const Value *object_address_ptr, Value &result,
                        Status *error_ptr);
 
   bool GetExpressionData(DataExtractor &data) const {
     data = m_data;
     return data.GetByteSize() > 0;
   }
 
   bool DumpLocationForAddress(Stream *s, lldb::DescriptionLevel level,
                               lldb::addr_t loclist_base_load_addr,
                               lldb::addr_t address, ABI *abi);
 
-  static size_t LocationListSize(const DWARFCompileUnit *dwarf_cu,
+  static size_t LocationListSize(const DWARFUnit *dwarf_cu,
                                  const DataExtractor &debug_loc_data,
                                  lldb::offset_t offset);
 
   static bool PrintDWARFExpression(Stream &s, const DataExtractor &data,
                                    int address_size, int dwarf_ref_size,
                                    bool location_expression);
 
-  static void PrintDWARFLocationList(Stream &s, const DWARFCompileUnit *cu,
+  static void PrintDWARFLocationList(Stream &s, const DWARFUnit *cu,
                                      const DataExtractor &debug_loc_data,
                                      lldb::offset_t offset);
 
   bool MatchesOperand(StackFrame &frame, const Instruction::Operand &op);
 
 protected:
   //------------------------------------------------------------------
   /// Pretty-prints the location expression to a stream
protected:
   //------------------------------------------------------------------
   void DumpLocation(Stream *s, lldb::offset_t offset, lldb::offset_t length,
                     lldb::DescriptionLevel level, ABI *abi) const;
 
   bool GetLocation(lldb::addr_t base_addr, lldb::addr_t pc,
                    lldb::offset_t &offset, lldb::offset_t &len);
 
   static bool AddressRangeForLocationListEntry(
-      const DWARFCompileUnit *dwarf_cu, const DataExtractor &debug_loc_data,
+      const DWARFUnit *dwarf_cu, const DataExtractor &debug_loc_data,
       lldb::offset_t *offset_ptr, lldb::addr_t &low_pc, lldb::addr_t &high_pc);
 
   bool GetOpAndEndOffsets(StackFrame &frame, lldb::offset_t &op_offset,
                           lldb::offset_t &end_offset);
 
   //------------------------------------------------------------------
   /// Classes that inherit from DWARFExpression can see and modify these
   //------------------------------------------------------------------
 
   lldb::ModuleWP m_module_wp; ///< Module which defined this expression.
   DataExtractor m_data; ///< A data extractor capable of reading opcode bytes
-  DWARFCompileUnit *m_dwarf_cu; ///< The DWARF compile unit this expression
+  DWARFUnit *m_dwarf_cu; ///< The DWARF compile unit this expression
                                 ///belongs to. It is used
   ///< to evaluate values indexing into the .debug_addr section (e.g.
   ///< DW_OP_GNU_addr_index, DW_OP_GNU_const_index)
   lldb::RegisterKind
       m_reg_kind; ///< One of the defines that starts with LLDB_REGKIND_
   lldb::addr_t m_loclist_slide; ///< A value used to slide the location list
                                 ///offsets so that
   ///< they are relative to the object that owns the location list
   ///< (the function for frame base and variable location lists)
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_DWARFExpression_h_

lldb/trunk/source/Expression/DWARFExpression.cpp

 #include "lldb/Target/ABI.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/StackID.h"
 #include "lldb/Target/Thread.h"
 
-#include "Plugins/SymbolFile/DWARF/DWARFCompileUnit.h"
+#include "Plugins/SymbolFile/DWARF/DWARFUnit.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 static lldb::addr_t
-ReadAddressFromDebugAddrSection(const DWARFCompileUnit *dwarf_cu,
+ReadAddressFromDebugAddrSection(const DWARFUnit *dwarf_cu,
                                 uint32_t index) {
   uint32_t index_size = dwarf_cu->GetAddressByteSize();
   dw_offset_t addr_base = dwarf_cu->GetAddrBase();
   lldb::offset_t offset = addr_base + index * index_size;
   return dwarf_cu->GetSymbolFileDWARF()->get_debug_addr_data().GetMaxU64(
       &offset, index_size);
 }
 
 //----------------------------------------------------------------------
 // DWARFExpression constructor
 //----------------------------------------------------------------------
-DWARFExpression::DWARFExpression(DWARFCompileUnit *dwarf_cu)
+DWARFExpression::DWARFExpression(DWARFUnit *dwarf_cu)
     : m_module_wp(), m_data(), m_dwarf_cu(dwarf_cu),
       m_reg_kind(eRegisterKindDWARF), m_loclist_slide(LLDB_INVALID_ADDRESS) {}
 
 DWARFExpression::DWARFExpression(const DWARFExpression &rhs)
     : m_module_wp(rhs.m_module_wp), m_data(rhs.m_data),
       m_dwarf_cu(rhs.m_dwarf_cu), m_reg_kind(rhs.m_reg_kind),
       m_loclist_slide(rhs.m_loclist_slide) {}
 
 DWARFExpression::DWARFExpression(lldb::ModuleSP module_sp,
                                  const DataExtractor &data,
-                                 DWARFCompileUnit *dwarf_cu,
+                                 DWARFUnit *dwarf_cu,
                                  lldb::offset_t data_offset,
                                  lldb::offset_t data_length)
     : m_module_wp(), m_data(data, data_offset, data_length),
       m_dwarf_cu(dwarf_cu), m_reg_kind(eRegisterKindDWARF),
       m_loclist_slide(LLDB_INVALID_ADDRESS) {
   if (module_sp)
     m_module_wp = module_sp;
 }
bool DWARFExpression::Evaluate(ExecutionContext *exe_ctx,
   return DWARFExpression::Evaluate(
       exe_ctx, reg_ctx, module_sp, m_data, m_dwarf_cu, 0, m_data.GetByteSize(),
       m_reg_kind, initial_value_ptr, object_address_ptr, result, error_ptr);
 }
 
 bool DWARFExpression::Evaluate(
     ExecutionContext *exe_ctx, RegisterContext *reg_ctx,
     lldb::ModuleSP module_sp, const DataExtractor &opcodes,
-    DWARFCompileUnit *dwarf_cu, const lldb::offset_t opcodes_offset,
+    DWARFUnit *dwarf_cu, const lldb::offset_t opcodes_offset,
     const lldb::offset_t opcodes_length, const lldb::RegisterKind reg_kind,
     const Value *initial_value_ptr, const Value *object_address_ptr,
     Value &result, Status *error_ptr) {
 
   if (opcodes_length == 0) {
     if (error_ptr)
       error_ptr->SetErrorString(
           "no location, value may have been optimized out");
if (log && log->GetVerbose()) {
         log->Printf("  %s", new_value.GetData());
       }
     }
     result = stack.back();
   }
   return true; // Return true on success
 }
 
-size_t DWARFExpression::LocationListSize(const DWARFCompileUnit *dwarf_cu,
+size_t DWARFExpression::LocationListSize(const DWARFUnit *dwarf_cu,
                                          const DataExtractor &debug_loc_data,
                                          lldb::offset_t offset) {
   const lldb::offset_t debug_loc_offset = offset;
   while (debug_loc_data.ValidOffset(offset)) {
     lldb::addr_t start_addr = LLDB_INVALID_ADDRESS;
     lldb::addr_t end_addr = LLDB_INVALID_ADDRESS;
     if (!AddressRangeForLocationListEntry(dwarf_cu, debug_loc_data, &offset,
                                           start_addr, end_addr))
       break;
 
     if (start_addr == 0 && end_addr == 0)
       break;
 
     uint16_t loc_length = debug_loc_data.GetU16(&offset);
     offset += loc_length;
   }
 
   if (offset > debug_loc_offset)
     return offset - debug_loc_offset;
   return 0;
 }
 
 bool DWARFExpression::AddressRangeForLocationListEntry(
-    const DWARFCompileUnit *dwarf_cu, const DataExtractor &debug_loc_data,
+    const DWARFUnit *dwarf_cu, const DataExtractor &debug_loc_data,
     lldb::offset_t *offset_ptr, lldb::addr_t &low_pc, lldb::addr_t &high_pc) {
   if (!debug_loc_data.ValidOffset(*offset_ptr))
     return false;
 
   switch (dwarf_cu->GetSymbolFileDWARF()->GetLocationListFormat()) {
   case NonLocationList:
     return false;
   case RegularLocationList:
if (!print_dwarf_exp_op(s, data, &offset, address_size, dwarf_ref_size))
       return false;
     op_count++;
   }
 
   return true;
 }
 
 void DWARFExpression::PrintDWARFLocationList(
-    Stream &s, const DWARFCompileUnit *cu, const DataExtractor &debug_loc_data,
+    Stream &s, const DWARFUnit *cu, const DataExtractor &debug_loc_data,
     lldb::offset_t offset) {
   uint64_t start_addr, end_addr;
-  uint32_t addr_size = DWARFCompileUnit::GetAddressByteSize(cu);
-  s.SetAddressByteSize(DWARFCompileUnit::GetAddressByteSize(cu));
+  uint32_t addr_size = DWARFUnit::GetAddressByteSize(cu);
+  s.SetAddressByteSize(DWARFUnit::GetAddressByteSize(cu));
   dw_addr_t base_addr = cu ? cu->GetBaseAddress() : 0;
   while (debug_loc_data.ValidOffset(offset)) {
     start_addr = debug_loc_data.GetMaxU64(&offset, addr_size);
     end_addr = debug_loc_data.GetMaxU64(&offset, addr_size);
 
     if (start_addr == 0 && end_addr == 0)
       break;
 

lldb/trunk/source/Plugins/SymbolFile/DWARF/DIERef.cpp

 //===-- DIERef.cpp ----------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "DIERef.h"
-#include "DWARFCompileUnit.h"
+#include "DWARFUnit.h"
 #include "DWARFDebugInfo.h"
 #include "DWARFFormValue.h"
 #include "SymbolFileDWARF.h"
 #include "SymbolFileDWARFDebugMap.h"
 
 DIERef::DIERef()
     : cu_offset(DW_INVALID_OFFSET), die_offset(DW_INVALID_OFFSET) {}
 
 DIERef::DIERef(dw_offset_t c, dw_offset_t d) : cu_offset(c), die_offset(d) {}
 
 DIERef::DIERef(lldb::user_id_t uid, SymbolFileDWARF *dwarf)
     : cu_offset(DW_INVALID_OFFSET), die_offset(uid & 0xffffffff) {
   SymbolFileDWARFDebugMap *debug_map = dwarf->GetDebugMapSymfile();
   if (debug_map) {
     const uint32_t oso_idx = debug_map->GetOSOIndexFromUserID(uid);
     SymbolFileDWARF *actual_dwarf = debug_map->GetSymbolFileByOSOIndex(oso_idx);
     if (actual_dwarf) {
       DWARFDebugInfo *debug_info = actual_dwarf->DebugInfo();
       if (debug_info) {
-        DWARFCompileUnit *dwarf_cu =
+        DWARFUnit *dwarf_cu =
             debug_info->GetCompileUnitContainingDIEOffset(die_offset);
         if (dwarf_cu) {
           cu_offset = dwarf_cu->GetOffset();
           return;
         }
       }
     }
     die_offset = DW_INVALID_OFFSET;
   } else {
     cu_offset = uid >> 32;
   }
 }
 
 DIERef::DIERef(const DWARFFormValue &form_value)
     : cu_offset(DW_INVALID_OFFSET), die_offset(DW_INVALID_OFFSET) {
   if (form_value.IsValid()) {
-    const DWARFCompileUnit *dwarf_cu = form_value.GetCompileUnit();
+    const DWARFUnit *dwarf_cu = form_value.GetCompileUnit();
     if (dwarf_cu) {
       if (dwarf_cu->GetBaseObjOffset() != DW_INVALID_OFFSET)
         cu_offset = dwarf_cu->GetBaseObjOffset();
       else
         cu_offset = dwarf_cu->GetOffset();
     }
     die_offset = form_value.Reference();
   }

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParserJava.cpp

 //===-- DWARFASTParserJava.cpp ----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "DWARFASTParserJava.h"
 #include "DWARFAttribute.h"
-#include "DWARFCompileUnit.h"
+#include "DWARFUnit.h"
 #include "DWARFDebugInfoEntry.h"
 #include "DWARFDebugInfoEntry.h"
 #include "DWARFDeclContext.h"
 #include "SymbolFileDWARF.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/SymbolContextScope.h"
default:
     assert(false && "Not a forward java type declaration!");
     break;
   }
   return false;
 }
 
 void DWARFASTParserJava::ParseChildMembers(const DWARFDIE &parent_die,
                                            CompilerType &compiler_type) {
-  DWARFCompileUnit *dwarf_cu = parent_die.GetCU();
+  DWARFUnit *dwarf_cu = parent_die.GetCU();
   for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid();
        die = die.GetSibling()) {
     switch (die.Tag()) {
     case DW_TAG_member: {
       const char *name = nullptr;
       DWARFFormValue encoding_uid;
       uint32_t member_byte_offset = UINT32_MAX;
       DWARFExpression member_location_expression(dwarf_cu);

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFAttribute.h

 //===-- DWARFAttribute.h ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SymbolFileDWARF_DWARFAttribute_h_
 #define SymbolFileDWARF_DWARFAttribute_h_
 
 #include "DWARFDefines.h"
 #include "llvm/ADT/SmallVector.h"
 #include <vector>
 
-class DWARFCompileUnit;
+class DWARFUnit;
 class DWARFFormValue;
 
 class DWARFAttribute {
 public:
   DWARFAttribute(dw_attr_t attr, dw_form_t form) : m_attr(attr), m_form(form) {}
 
   void set(dw_attr_t attr, dw_form_t form) {
     m_attr = attr;
protected:
   dw_form_t m_form;
 };
 
 class DWARFAttributes {
 public:
   DWARFAttributes();
   ~DWARFAttributes();
 
-  void Append(const DWARFCompileUnit *cu, dw_offset_t attr_die_offset,
+  void Append(const DWARFUnit *cu, dw_offset_t attr_die_offset,
               dw_attr_t attr, dw_form_t form);
-  const DWARFCompileUnit *CompileUnitAtIndex(uint32_t i) const {
+  const DWARFUnit *CompileUnitAtIndex(uint32_t i) const {
     return m_infos[i].cu;
   }
   dw_offset_t DIEOffsetAtIndex(uint32_t i) const {
     return m_infos[i].die_offset;
   }
   dw_attr_t AttributeAtIndex(uint32_t i) const {
     return m_infos[i].attr.get_attr();
   }
   dw_attr_t FormAtIndex(uint32_t i) const { return m_infos[i].attr.get_form(); }
   bool ExtractFormValueAtIndex(uint32_t i, DWARFFormValue &form_value) const;
   uint64_t FormValueAsUnsignedAtIndex(uint32_t i, uint64_t fail_value) const;
   uint64_t FormValueAsUnsigned(dw_attr_t attr, uint64_t fail_value) const;
   uint32_t FindAttributeIndex(dw_attr_t attr) const;
   bool ContainsAttribute(dw_attr_t attr) const;
   bool RemoveAttribute(dw_attr_t attr);
   void Clear() { m_infos.clear(); }
   size_t Size() const { return m_infos.size(); }
 
 protected:
   struct AttributeValue {
-    const DWARFCompileUnit *cu; // Keep the compile unit with each attribute in
+    const DWARFUnit *cu;        // Keep the compile unit with each attribute in
                                 // case we have DW_FORM_ref_addr values
     dw_offset_t die_offset;
     DWARFAttribute attr;
   };
   typedef llvm::SmallVector<AttributeValue, 8> collection;
   collection m_infos;
 };
 
 #endif // SymbolFileDWARF_DWARFAttribute_h_

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFAttribute.cpp

 //===-- DWARFAttribute.cpp --------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "DWARFAttribute.h"
-#include "DWARFCompileUnit.h"
+#include "DWARFUnit.h"
 #include "DWARFDebugInfo.h"
 
 DWARFAttributes::DWARFAttributes() : m_infos() {}
 
 DWARFAttributes::~DWARFAttributes() {}
 
 uint32_t DWARFAttributes::FindAttributeIndex(dw_attr_t attr) const {
   collection::const_iterator end = m_infos.end();
   collection::const_iterator beg = m_infos.begin();
   collection::const_iterator pos;
   for (pos = beg; pos != end; ++pos) {
     if (pos->attr.get_attr() == attr)
       return std::distance(beg, pos);
   }
   return UINT32_MAX;
 }
 
-void DWARFAttributes::Append(const DWARFCompileUnit *cu,
+void DWARFAttributes::Append(const DWARFUnit *cu,
                              dw_offset_t attr_die_offset, dw_attr_t attr,
                              dw_form_t form) {
   AttributeValue attr_value = {cu, attr_die_offset, {attr, form}};
   m_infos.push_back(attr_value);
 }
 
 bool DWARFAttributes::ContainsAttribute(dw_attr_t attr) const {
   return FindAttributeIndex(attr) != UINT32_MAX;
 }
 
 bool DWARFAttributes::RemoveAttribute(dw_attr_t attr) {
   uint32_t attr_index = FindAttributeIndex(attr);
   if (attr_index != UINT32_MAX) {
     m_infos.erase(m_infos.begin() + attr_index);
     return true;
   }
   return false;
 }
 
 bool DWARFAttributes::ExtractFormValueAtIndex(
     uint32_t i, DWARFFormValue &form_value) const {
-  const DWARFCompileUnit *cu = CompileUnitAtIndex(i);
+  const DWARFUnit *cu = CompileUnitAtIndex(i);
   form_value.SetCompileUnit(cu);
   form_value.SetForm(FormAtIndex(i));
   lldb::offset_t offset = DIEOffsetAtIndex(i);
   return form_value.ExtractValue(
       cu->GetSymbolFileDWARF()->get_debug_info_data(), &offset);
 }
 
 uint64_t DWARFAttributes::FormValueAsUnsigned(dw_attr_t attr,

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.h

 //===-- DWARFCompileUnit.h --------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SymbolFileDWARF_DWARFCompileUnit_h_
 #define SymbolFileDWARF_DWARFCompileUnit_h_
 
 #include "DWARFUnit.h"
 
-typedef std::shared_ptr<DWARFCompileUnit> DWARFCompileUnitSP;
-
 class DWARFCompileUnit : public DWARFUnit {
   friend class DWARFUnit;
 
 public:
-  static DWARFCompileUnitSP Extract(SymbolFileDWARF *dwarf2Data,
+  static DWARFUnitSP Extract(SymbolFileDWARF *dwarf2Data,
       lldb::offset_t *offset_ptr);
 
   size_t ExtractDIEsIfNeeded(bool cu_die_only);
   DWARFDIE LookupAddress(const dw_addr_t address);
   size_t AppendDIEsWithTag(const dw_tag_t tag,
                            DWARFDIECollection &matching_dies,
                            uint32_t depth = UINT32_MAX) const;
   bool Verify(lldb_private::Stream *s) const;

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp

 using namespace lldb_private;
 using namespace std;
 
 extern int g_verbose;
 
 DWARFCompileUnit::DWARFCompileUnit(SymbolFileDWARF *dwarf2Data)
     : m_dwarf2Data(dwarf2Data) {}
 
-DWARFCompileUnitSP DWARFCompileUnit::Extract(SymbolFileDWARF *dwarf2Data,
+DWARFUnitSP DWARFCompileUnit::Extract(SymbolFileDWARF *dwarf2Data,
     lldb::offset_t *offset_ptr) {
-  DWARFCompileUnitSP cu_sp(new DWARFCompileUnit(dwarf2Data));
+  // std::make_shared would require the ctor to be public.
+  std::shared_ptr<DWARFCompileUnit> cu_sp(new DWARFCompileUnit(dwarf2Data));
   // Out of memory?
   if (cu_sp.get() == NULL)
     return nullptr;
 
   const DWARFDataExtractor &debug_info = dwarf2Data->get_debug_info_data();
 
   cu_sp->m_offset = *offset_ptr;
 
if (log && log->GetVerbose()) {
     else
       m_die_array[0].Dump(m_dwarf2Data, this, strm, UINT32_MAX);
     log->PutString(strm.GetString());
   }
 
   if (!m_dwo_symbol_file)
     return m_die_array.size();
 
-  DWARFCompileUnit *dwo_cu = m_dwo_symbol_file->GetCompileUnit();
+  DWARFUnit *dwo_cu = m_dwo_symbol_file->GetCompileUnit();
   size_t dwo_die_count = dwo_cu->ExtractDIEsIfNeeded(cu_die_only);
   return m_die_array.size() + dwo_die_count -
          1; // We have 2 CU die, but we want to count it only as one
 }
 
 void DWARFCompileUnit::AddCompileUnitDIE(DWARFDebugInfoEntry &die) {
   assert(m_die_array.empty() && "Compile unit DIE already added");
   AddDIE(die);
 
   const DWARFDebugInfoEntry &cu_die = m_die_array.front();
   std::unique_ptr<SymbolFileDWARFDwo> dwo_symbol_file =
       m_dwarf2Data->GetDwoSymbolFileForCompileUnit(*this, cu_die);
   if (!dwo_symbol_file)
     return;
 
-  DWARFCompileUnit *dwo_cu = dwo_symbol_file->GetCompileUnit();
+  DWARFUnit *dwo_cu = dwo_symbol_file->GetCompileUnit();
   if (!dwo_cu)
     return; // Can't fetch the compile unit from the dwo file.
 
   DWARFDIE dwo_cu_die = dwo_cu->GetCompileUnitDIEOnly();
   if (!dwo_cu_die.IsValid())
     return; // Can't fetch the compile unit DIE from the dwo file.
 
   uint64_t main_dwo_id = cu_die.GetAttributeValueAsUnsigned(
if (log) {
           GetOffset());
     }
     const DWARFDebugInfoEntry *die = DIEPtr();
     if (die)
       die->BuildFunctionAddressRangeTable(m_dwarf2Data, this,
                                           m_func_aranges_ap.get());
 
     if (m_dwo_symbol_file) {
-      DWARFCompileUnit *dwo_cu = m_dwo_symbol_file->GetCompileUnit();
+      DWARFUnit *dwo_cu = m_dwo_symbol_file->GetCompileUnit();
       const DWARFDebugInfoEntry *dwo_die = dwo_cu->DIEPtr();
       if (dwo_die)
         dwo_die->BuildFunctionAddressRangeTable(m_dwo_symbol_file.get(), dwo_cu,
                                                 m_func_aranges_ap.get());
     }
 
     const bool minimize = false;
     m_func_aranges_ap->Sort(minimize);

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFDIE.h

 #define SymbolFileDWARF_DWARFDIE_h_
 
 #include "lldb/Core/dwarf.h"
 #include "lldb/lldb-types.h"
 
 struct DIERef;
 class DWARFASTParser;
 class DWARFAttributes;
-class DWARFCompileUnit;
+class DWARFUnit;
 class DWARFDebugInfoEntry;
 class DWARFDeclContext;
 class DWARFDIECollection;
 class SymbolFileDWARF;
 
 class DWARFDIE {
 public:
   DWARFDIE() : m_cu(nullptr), m_die(nullptr) {}
 
-  DWARFDIE(DWARFCompileUnit *cu, DWARFDebugInfoEntry *die)
+  DWARFDIE(DWARFUnit *cu, DWARFDebugInfoEntry *die)
       : m_cu(cu), m_die(die) {}
 
-  DWARFDIE(const DWARFCompileUnit *cu, DWARFDebugInfoEntry *die)
-      : m_cu(const_cast<DWARFCompileUnit *>(cu)), m_die(die) {}
+  DWARFDIE(const DWARFUnit *cu, DWARFDebugInfoEntry *die)
+      : m_cu(const_cast<DWARFUnit *>(cu)), m_die(die) {}
 
-  DWARFDIE(DWARFCompileUnit *cu, const DWARFDebugInfoEntry *die)
+  DWARFDIE(DWARFUnit *cu, const DWARFDebugInfoEntry *die)
       : m_cu(cu), m_die(const_cast<DWARFDebugInfoEntry *>(die)) {}
 
-  DWARFDIE(const DWARFCompileUnit *cu, const DWARFDebugInfoEntry *die)
-      : m_cu(const_cast<DWARFCompileUnit *>(cu)),
+  DWARFDIE(const DWARFUnit *cu, const DWARFDebugInfoEntry *die)
+      : m_cu(const_cast<DWARFUnit *>(cu)),
         m_die(const_cast<DWARFDebugInfoEntry *>(die)) {}
 
   //----------------------------------------------------------------------
   // Tests
   //----------------------------------------------------------------------
   explicit operator bool() const { return IsValid(); }
 
   bool IsValid() const { return m_cu && m_die; }
 
   bool IsStructOrClass() const;
 
   bool HasChildren() const;
 
   bool Supports_DW_AT_APPLE_objc_complete_type() const;
 
   //----------------------------------------------------------------------
   // Accessors
   //----------------------------------------------------------------------
   SymbolFileDWARF *GetDWARF() const;
 
-  DWARFCompileUnit *GetCU() const { return m_cu; }
+  DWARFUnit *GetCU() const { return m_cu; }
 
   DWARFDebugInfoEntry *GetDIE() const { return m_die; }
 
   DIERef GetDIERef() const;
 
   lldb_private::TypeSystem *GetTypeSystem() const;
 
   DWARFASTParser *GetDWARFParser() const;
 
-  void Set(DWARFCompileUnit *cu, DWARFDebugInfoEntry *die) {
+  void Set(DWARFUnit *cu, DWARFDebugInfoEntry *die) {
     if (cu && die) {
       m_cu = cu;
       m_die = die;
     } else {
       Clear();
     }
   }
 
public:
 
   lldb_private::CompilerDecl GetDecl() const;
 
   lldb_private::CompilerDeclContext GetDeclContext() const;
 
   lldb_private::CompilerDeclContext GetContainingDeclContext() const;
 
 protected:
-  DWARFCompileUnit *m_cu;
+  DWARFUnit *m_cu;
   DWARFDebugInfoEntry *m_die;
 };
 
 bool operator==(const DWARFDIE &lhs, const DWARFDIE &rhs);
 bool operator!=(const DWARFDIE &lhs, const DWARFDIE &rhs);
 
 #endif // SymbolFileDWARF_DWARFDIE_h_

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFDIE.cpp

 //===-- DWARFDIE.cpp --------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "DWARFDIE.h"
 
 #include "DWARFASTParser.h"
-#include "DWARFCompileUnit.h"
+#include "DWARFUnit.h"
 #include "DWARFDIECollection.h"
 #include "DWARFDebugAbbrev.h"
 #include "DWARFDebugAranges.h"
 #include "DWARFDebugInfo.h"
 #include "DWARFDebugInfoEntry.h"
 #include "DWARFDebugRanges.h"
 #include "DWARFDeclContext.h"
 #include "DWARFFormValue.h"
return m_die->GetAttributeValueAsSigned(GetDWARF(), GetCU(), attr,
                                             fail_value);
   else
     return fail_value;
 }
 
 DWARFDIE
 DWARFDIE::GetAttributeValueAsReferenceDIE(const dw_attr_t attr) const {
   if (IsValid()) {
-    DWARFCompileUnit *cu = GetCU();
+    DWARFUnit *cu = GetCU();
     SymbolFileDWARF *dwarf = cu->GetSymbolFileDWARF();
     const bool check_specification_or_abstract_origin = true;
     DWARFFormValue form_value;
     if (m_die->GetAttributeValue(dwarf, cu, attr, form_value, nullptr,
                                  check_specification_or_abstract_origin))
       return dwarf->GetDIE(DIERef(form_value));
   }
   return DWARFDIE();
uint64_t DWARFDIE::GetAttributeValueAsAddress(const dw_attr_t attr,
   else
     return fail_value;
 }
 
 DWARFDIE
 DWARFDIE::LookupDeepestBlock(lldb::addr_t file_addr) const {
   if (IsValid()) {
     SymbolFileDWARF *dwarf = GetDWARF();
-    DWARFCompileUnit *cu = GetCU();
+    DWARFUnit *cu = GetCU();
     DWARFDebugInfoEntry *function_die = nullptr;
     DWARFDebugInfoEntry *block_die = nullptr;
     if (m_die->LookupAddress(file_addr, dwarf, cu, &function_die, &block_die)) {
       if (block_die && block_die != function_die) {
         if (cu->ContainsDIEOffset(block_die->GetOffset()))
           return DWARFDIE(cu, block_die);
         else
           return DWARFDIE(dwarf->DebugInfo()->GetCompileUnit(

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFDebugAranges.cpp

 #include <stdio.h>
 
 #include <algorithm>
 
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/Timer.h"
 
-#include "DWARFCompileUnit.h"
+#include "DWARFUnit.h"
 #include "DWARFDebugInfo.h"
 #include "LogChannelDWARF.h"
 #include "SymbolFileDWARF.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 //----------------------------------------------------------------------

 //----------------------------------------------------------------------
 bool DWARFDebugAranges::Generate(SymbolFileDWARF *dwarf2Data) {
   Clear();
   DWARFDebugInfo *debug_info = dwarf2Data->DebugInfo();
   if (debug_info) {
     uint32_t cu_idx = 0;
     const uint32_t num_compile_units = dwarf2Data->GetNumCompileUnits();
     for (cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) {
-      DWARFCompileUnit *cu = debug_info->GetCompileUnitAtIndex(cu_idx);
+      DWARFUnit *cu = debug_info->GetCompileUnitAtIndex(cu_idx);
       if (cu)
         cu->BuildAddressRangeTable(dwarf2Data, this);
     }
   }
   return !IsEmpty();
 }
 
 void DWARFDebugAranges::Dump(Log *log) const {

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.h

 //===-- DWARFDebugInfo.h ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SymbolFileDWARF_DWARFDebugInfo_h_
 #define SymbolFileDWARF_DWARFDebugInfo_h_
 
 #include <map>
 #include <vector>
 
-#include "DWARFCompileUnit.h"
+#include "DWARFUnit.h"
 #include "DWARFDIE.h"
 #include "SymbolFileDWARF.h"
 #include "lldb/Core/STLUtils.h"
 #include "lldb/lldb-private.h"
 
 typedef std::multimap<const char *, dw_offset_t, CStringCompareFunctionObject>
     CStringToDIEMap;
 typedef CStringToDIEMap::iterator CStringToDIEMapIter;
 typedef CStringToDIEMap::const_iterator CStringToDIEMapConstIter;
 
 class DWARFDebugInfo {
 public:
   typedef dw_offset_t (*Callback)(SymbolFileDWARF *dwarf2Data,
-                                  DWARFCompileUnit *cu,
+                                  DWARFUnit *cu,
                                   DWARFDebugInfoEntry *die,
                                   const dw_offset_t next_offset,
                                   const uint32_t depth, void *userData);
 
   DWARFDebugInfo();
   void SetDwarfData(SymbolFileDWARF *dwarf2Data);
 
   size_t GetNumCompileUnits();
-  bool ContainsCompileUnit(const DWARFCompileUnit *cu) const;
-  DWARFCompileUnit *GetCompileUnitAtIndex(uint32_t idx);
-  DWARFCompileUnit *GetCompileUnit(dw_offset_t cu_offset,
-                                   uint32_t *idx_ptr = NULL);
-  DWARFCompileUnit *GetCompileUnitContainingDIEOffset(dw_offset_t die_offset);
-  DWARFCompileUnit *GetCompileUnit(const DIERef &die_ref);
+  bool ContainsCompileUnit(const DWARFUnit *cu) const;
+  DWARFUnit *GetCompileUnitAtIndex(uint32_t idx);
+  DWARFUnit *GetCompileUnit(dw_offset_t cu_offset, uint32_t *idx_ptr = NULL);
+  DWARFUnit *GetCompileUnitContainingDIEOffset(dw_offset_t die_offset);
+  DWARFUnit *GetCompileUnit(const DIERef &die_ref);
   DWARFDIE GetDIEForDIEOffset(dw_offset_t die_offset);
   DWARFDIE GetDIE(const DIERef &die_ref);
 
   void Dump(lldb_private::Stream *s, const uint32_t die_offset,
             const uint32_t recurse_depth);
   static void Parse(SymbolFileDWARF *parser, Callback callback, void *userData);
   static void Verify(lldb_private::Stream *s, SymbolFileDWARF *dwarf2Data);
   static void Dump(lldb_private::Stream *s, SymbolFileDWARF *dwarf2Data,
                    const uint32_t die_offset, const uint32_t recurse_depth);
 
   enum {
     eDumpFlag_Verbose = (1 << 0),  // Verbose dumping
     eDumpFlag_ShowForm = (1 << 1), // Show the DW_form type
     eDumpFlag_ShowAncestors =
         (1 << 2) // Show all parent DIEs when dumping single DIEs
   };
 
   DWARFDebugAranges &GetCompileUnitAranges();
 
 protected:
   static bool OffsetLessThanCompileUnitOffset(dw_offset_t offset,
-                                              const DWARFCompileUnitSP &cu_sp);
+                                              const DWARFUnitSP &cu_sp);
 
-  typedef std::vector<DWARFCompileUnitSP> CompileUnitColl;
+  typedef std::vector<DWARFUnitSP> CompileUnitColl;
 
   //----------------------------------------------------------------------
   // Member variables
   //----------------------------------------------------------------------
   SymbolFileDWARF *m_dwarf2Data;
   CompileUnitColl m_compile_units;
   std::unique_ptr<DWARFDebugAranges>
       m_cu_aranges_ap; // A quick address to compile unit table

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.cpp

for (size_t n = 0; n < m_cu_aranges_ap.get()->GetNumRanges(); n++) {
         cus_with_data.insert(offset);
     }
 
     // Manually build arange data for everything that wasn't in the
     // .debug_aranges table.
     bool printed = false;
     const size_t num_compile_units = GetNumCompileUnits();
     for (size_t idx = 0; idx < num_compile_units; ++idx) {
-      DWARFCompileUnit *cu = GetCompileUnitAtIndex(idx);
+      DWARFUnit *cu = GetCompileUnitAtIndex(idx);
 
       dw_offset_t offset = cu->GetOffset();
       if (cus_with_data.find(offset) == cus_with_data.end()) {
         if (log) {
           if (!printed)
             log->Printf(
                 "DWARFDebugInfo::GetCompileUnitAranges() for \"%s\" by parsing",
                 m_dwarf2Data->GetObjectFile()->GetFileSpec().GetPath().c_str());
           printed = true;
         }
         cu->BuildAddressRangeTable(m_dwarf2Data, m_cu_aranges_ap.get());
       }
     }
 
     const bool minimize = true;
     m_cu_aranges_ap->Sort(minimize);
   }
   return *m_cu_aranges_ap.get();
 }
 
 void DWARFDebugInfo::ParseCompileUnitHeadersIfNeeded() {
   if (m_compile_units.empty()) {
     if (m_dwarf2Data != NULL) {
       lldb::offset_t offset = 0;
-      DWARFCompileUnitSP cu_sp;
+      DWARFUnitSP cu_sp;
       while ((cu_sp = DWARFCompileUnit::Extract(m_dwarf2Data, &offset))) {
         m_compile_units.push_back(cu_sp);
 
         offset = cu_sp->GetNextCompileUnitOffset();
       }
     }
   }
 }
 
 size_t DWARFDebugInfo::GetNumCompileUnits() {
   ParseCompileUnitHeadersIfNeeded();
   return m_compile_units.size();
 }
 
-DWARFCompileUnit *DWARFDebugInfo::GetCompileUnitAtIndex(uint32_t idx) {
-  DWARFCompileUnit *cu = NULL;
+DWARFUnit *DWARFDebugInfo::GetCompileUnitAtIndex(uint32_t idx) {
+  DWARFUnit *cu = NULL;
   if (idx < GetNumCompileUnits())
     cu = m_compile_units[idx].get();
   return cu;
 }
 
-bool DWARFDebugInfo::ContainsCompileUnit(const DWARFCompileUnit *cu) const {
+bool DWARFDebugInfo::ContainsCompileUnit(const DWARFUnit *cu) const {
   // Not a verify efficient function, but it is handy for use in assertions
   // to make sure that a compile unit comes from a debug information file.
   CompileUnitColl::const_iterator end_pos = m_compile_units.end();
   CompileUnitColl::const_iterator pos;
 
   for (pos = m_compile_units.begin(); pos != end_pos; ++pos) {
     if (pos->get() == cu)
       return true;
   }
   return false;
 }
 
 bool DWARFDebugInfo::OffsetLessThanCompileUnitOffset(
-    dw_offset_t offset, const DWARFCompileUnitSP &cu_sp) {
+    dw_offset_t offset, const DWARFUnitSP &cu_sp) {
   return offset < cu_sp->GetOffset();
 }
 
-DWARFCompileUnit *DWARFDebugInfo::GetCompileUnit(dw_offset_t cu_offset,
+DWARFUnit *DWARFDebugInfo::GetCompileUnit(dw_offset_t cu_offset,
                                                  uint32_t *idx_ptr) {
-  DWARFCompileUnitSP cu_sp;
+  DWARFUnitSP cu_sp;
   uint32_t cu_idx = DW_INVALID_INDEX;
   if (cu_offset != DW_INVALID_OFFSET) {
     ParseCompileUnitHeadersIfNeeded();
 
     // Watch out for single compile unit executable as they are pretty common
     const size_t num_cus = m_compile_units.size();
     if (num_cus == 1) {
       if (m_compile_units[0]->GetOffset() == cu_offset) {
if (num_cus == 1) {
       }
     }
   }
   if (idx_ptr)
     *idx_ptr = cu_idx;
   return cu_sp.get();
 }
 
-DWARFCompileUnit *DWARFDebugInfo::GetCompileUnit(const DIERef &die_ref) {
+DWARFUnit *DWARFDebugInfo::GetCompileUnit(const DIERef &die_ref) {
   if (die_ref.cu_offset == DW_INVALID_OFFSET)
     return GetCompileUnitContainingDIEOffset(die_ref.die_offset);
   else
     return GetCompileUnit(die_ref.cu_offset);
 }
 
-DWARFCompileUnit *
+DWARFUnit *
 DWARFDebugInfo::GetCompileUnitContainingDIEOffset(dw_offset_t die_offset) {
   ParseCompileUnitHeadersIfNeeded();
 
-  DWARFCompileUnitSP cu_sp;
+  DWARFUnitSP cu_sp;
 
   // Watch out for single compile unit executable as they are pretty common
   const size_t num_cus = m_compile_units.size();
   if (num_cus == 1) {
     if (m_compile_units[0]->ContainsDIEOffset(die_offset))
       return m_compile_units[0].get();
   } else if (num_cus) {
     CompileUnitColl::const_iterator end_pos = m_compile_units.end();
     CompileUnitColl::const_iterator begin_pos = m_compile_units.begin();
     CompileUnitColl::const_iterator pos = std::upper_bound(
         begin_pos, end_pos, die_offset, OffsetLessThanCompileUnitOffset);
     if (pos != begin_pos) {
       --pos;
       if ((*pos)->ContainsDIEOffset(die_offset))
         return (*pos).get();
     }
   }
 
   return nullptr;
 }
 
 DWARFDIE
 DWARFDebugInfo::GetDIEForDIEOffset(dw_offset_t die_offset) {
-  DWARFCompileUnit *cu = GetCompileUnitContainingDIEOffset(die_offset);
+  DWARFUnit *cu = GetCompileUnitContainingDIEOffset(die_offset);
   if (cu)
     return cu->GetDIE(die_offset);
   return DWARFDIE();
 }
 
 //----------------------------------------------------------------------
 // GetDIE()
 //
 // Get the DIE (Debug Information Entry) with the specified offset.
 //----------------------------------------------------------------------
 DWARFDIE
 DWARFDebugInfo::GetDIE(const DIERef &die_ref) {
-  DWARFCompileUnit *cu = GetCompileUnit(die_ref);
+  DWARFUnit *cu = GetCompileUnit(die_ref);
   if (cu)
     return cu->GetDIE(die_ref.die_offset);
   return DWARFDIE(); // Not found
 }
 
 //----------------------------------------------------------------------
 // Parse
 //
 // Parses the .debug_info section and uses the .debug_abbrev section
 // and various other sections in the SymbolFileDWARF class and calls the
 // supplied callback function each time a compile unit header, or debug
 // information entry is successfully parsed. This function can be used
 // for different tasks such as parsing the file contents into a
 // structured data, dumping, verifying and much more.
 //----------------------------------------------------------------------
 void DWARFDebugInfo::Parse(SymbolFileDWARF *dwarf2Data, Callback callback,
                            void *userData) {
   if (dwarf2Data) {
     lldb::offset_t offset = 0;
     uint32_t depth = 0;
     DWARFDebugInfoEntry die;
 
-    DWARFCompileUnitSP cu;
+    DWARFUnitSP cu;
     while ((cu = DWARFCompileUnit::Extract(dwarf2Data, &offset))) {
       const dw_offset_t next_cu_offset = cu->GetNextCompileUnitOffset();
 
       depth = 0;
       // Call the callback function with no DIE pointer for the compile unit
       // and get the offset that we are to continue to parse from
       offset = callback(dwarf2Data, cu.get(), NULL, offset, depth, userData);
 

 // A callback function for the static DWARFDebugInfo::Parse() function
 // that gets called each time a compile unit header or debug information
 // entry is successfully parsed.
 //
 // This function dump DWARF information and obey recurse depth and
 // whether a single DIE is to be dumped (or all of the data).
 //----------------------------------------------------------------------
 static dw_offset_t DumpCallback(SymbolFileDWARF *dwarf2Data,
-                                DWARFCompileUnit *cu, DWARFDebugInfoEntry *die,
+                                DWARFUnit *cu, DWARFDebugInfoEntry *die,
                                 const dw_offset_t next_offset,
                                 const uint32_t curr_depth, void *userData) {
   DumpInfo *dumpInfo = (DumpInfo *)userData;
   Stream *s = dumpInfo->strm;
   bool show_parents =
       s->GetFlags().Test(DWARFDebugInfo::eDumpFlag_ShowAncestors);
 
   if (die) {
void DWARFDebugInfo::Dump(Stream *s, const uint32_t die_offset,
   DumpInfo dumpInfo(s, die_offset, recurse_depth);
 
   s->PutCString("Dumping .debug_info section from internal representation\n");
 
   CompileUnitColl::const_iterator pos;
   uint32_t curr_depth = 0;
   ParseCompileUnitHeadersIfNeeded();
   for (pos = m_compile_units.begin(); pos != m_compile_units.end(); ++pos) {
-    DWARFCompileUnit *cu = pos->get();
+    DWARFUnit *cu = pos->get();
     DumpCallback(m_dwarf2Data, cu, NULL, 0, curr_depth, &dumpInfo);
 
     const DWARFDIE die = cu->DIE();
     if (die)
       die.Dump(s, recurse_depth);
   }
 }

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.h

public:
   typedef offset_collection::const_iterator offset_collection_const_iterator;
 
   DWARFDebugInfoEntry()
       : m_offset(DW_INVALID_OFFSET), m_parent_idx(0), m_sibling_idx(0),
         m_empty_children(false), m_abbr_idx(0), m_has_children(false),
         m_tag(0) {}
 
   void BuildAddressRangeTable(SymbolFileDWARF *dwarf2Data,
-                              const DWARFCompileUnit *cu,
+                              const DWARFUnit *cu,
                               DWARFDebugAranges *debug_aranges) const;
 
   void BuildFunctionAddressRangeTable(SymbolFileDWARF *dwarf2Data,
-                                      const DWARFCompileUnit *cu,
+                                      const DWARFUnit *cu,
                                       DWARFDebugAranges *debug_aranges) const;
 
   bool FastExtract(const lldb_private::DWARFDataExtractor &debug_info_data,
-                   const DWARFCompileUnit *cu,
+                   const DWARFUnit *cu,
                    const DWARFFormValue::FixedFormSizes &fixed_form_sizes,
                    lldb::offset_t *offset_ptr);
 
-  bool Extract(SymbolFileDWARF *dwarf2Data, const DWARFCompileUnit *cu,
+  bool Extract(SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
                lldb::offset_t *offset_ptr);
 
   bool LookupAddress(const dw_addr_t address, SymbolFileDWARF *dwarf2Data,
-                     const DWARFCompileUnit *cu,
+                     const DWARFUnit *cu,
                      DWARFDebugInfoEntry **function_die,
                      DWARFDebugInfoEntry **block_die);
 
-  size_t GetAttributes(const DWARFCompileUnit *cu,
+  size_t GetAttributes(const DWARFUnit *cu,
                        DWARFFormValue::FixedFormSizes fixed_form_sizes,
                        DWARFAttributes &attrs,
                        uint32_t curr_depth = 0)
       const; // "curr_depth" for internal use only, don't set this yourself!!!
 
   dw_offset_t
-  GetAttributeValue(SymbolFileDWARF *dwarf2Data, const DWARFCompileUnit *cu,
+  GetAttributeValue(SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
                     const dw_attr_t attr, DWARFFormValue &formValue,
                     dw_offset_t *end_attr_offset_ptr = nullptr,
                     bool check_specification_or_abstract_origin = false) const;
 
   const char *GetAttributeValueAsString(
-      SymbolFileDWARF *dwarf2Data, const DWARFCompileUnit *cu,
+      SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
       const dw_attr_t attr, const char *fail_value,
       bool check_specification_or_abstract_origin = false) const;
 
   uint64_t GetAttributeValueAsUnsigned(
-      SymbolFileDWARF *dwarf2Data, const DWARFCompileUnit *cu,
+      SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
       const dw_attr_t attr, uint64_t fail_value,
       bool check_specification_or_abstract_origin = false) const;
 
   uint64_t GetAttributeValueAsReference(
-      SymbolFileDWARF *dwarf2Data, const DWARFCompileUnit *cu,
+      SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
       const dw_attr_t attr, uint64_t fail_value,
       bool check_specification_or_abstract_origin = false) const;
 
   int64_t GetAttributeValueAsSigned(
-      SymbolFileDWARF *dwarf2Data, const DWARFCompileUnit *cu,
+      SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
       const dw_attr_t attr, int64_t fail_value,
       bool check_specification_or_abstract_origin = false) const;
 
   uint64_t GetAttributeValueAsAddress(
-      SymbolFileDWARF *dwarf2Data, const DWARFCompileUnit *cu,
+      SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
       const dw_attr_t attr, uint64_t fail_value,
       bool check_specification_or_abstract_origin = false) const;
 
   dw_addr_t
-  GetAttributeHighPC(SymbolFileDWARF *dwarf2Data, const DWARFCompileUnit *cu,
+  GetAttributeHighPC(SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
                      dw_addr_t lo_pc, uint64_t fail_value,
                      bool check_specification_or_abstract_origin = false) const;
 
   bool GetAttributeAddressRange(
-      SymbolFileDWARF *dwarf2Data, const DWARFCompileUnit *cu, dw_addr_t &lo_pc,
+      SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu, dw_addr_t &lo_pc,
       dw_addr_t &hi_pc, uint64_t fail_value,
       bool check_specification_or_abstract_origin = false) const;
 
   size_t GetAttributeAddressRanges(
-      SymbolFileDWARF *dwarf2Data, const DWARFCompileUnit *cu,
+      SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
       DWARFRangeList &ranges, bool check_hi_lo_pc,
       bool check_specification_or_abstract_origin = false) const;
 
   const char *GetName(SymbolFileDWARF *dwarf2Data,
-                      const DWARFCompileUnit *cu) const;
+                      const DWARFUnit *cu) const;
 
   const char *GetMangledName(SymbolFileDWARF *dwarf2Data,
-                             const DWARFCompileUnit *cu,
+                             const DWARFUnit *cu,
                              bool substitute_name_allowed = true) const;
 
   const char *GetPubname(SymbolFileDWARF *dwarf2Data,
-                         const DWARFCompileUnit *cu) const;
+                         const DWARFUnit *cu) const;
 
-  static bool GetName(SymbolFileDWARF *dwarf2Data, const DWARFCompileUnit *cu,
+  static bool GetName(SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
                       const dw_offset_t die_offset, lldb_private::Stream &s);
 
   static bool AppendTypeName(SymbolFileDWARF *dwarf2Data,
-                             const DWARFCompileUnit *cu,
+                             const DWARFUnit *cu,
                              const dw_offset_t die_offset,
                              lldb_private::Stream &s);
 
   const char *GetQualifiedName(SymbolFileDWARF *dwarf2Data,
-                               DWARFCompileUnit *cu,
+                               DWARFUnit *cu,
                                std::string &storage) const;
 
   const char *GetQualifiedName(SymbolFileDWARF *dwarf2Data,
-                               DWARFCompileUnit *cu,
+                               DWARFUnit *cu,
                                const DWARFAttributes &attributes,
                                std::string &storage) const;
 
   static bool OffsetLessThan(const DWARFDebugInfoEntry &a,
                              const DWARFDebugInfoEntry &b);
 
-  void Dump(SymbolFileDWARF *dwarf2Data, const DWARFCompileUnit *cu,
+  void Dump(SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
             lldb_private::Stream &s, uint32_t recurse_depth) const;
 
-  void DumpAncestry(SymbolFileDWARF *dwarf2Data, const DWARFCompileUnit *cu,
+  void DumpAncestry(SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
                     const DWARFDebugInfoEntry *oldest, lldb_private::Stream &s,
                     uint32_t recurse_depth) const;
 
   static void
-  DumpAttribute(SymbolFileDWARF *dwarf2Data, const DWARFCompileUnit *cu,
+  DumpAttribute(SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
                 const lldb_private::DWARFDataExtractor &debug_info_data,
                 lldb::offset_t *offset_ptr, lldb_private::Stream &s,
                 dw_attr_t attr, dw_form_t form);
   // This one dumps the comp unit name, objfile name and die offset for this die
   // so the stream S.
-  void DumpLocation(SymbolFileDWARF *dwarf2Data, DWARFCompileUnit *cu,
+  void DumpLocation(SymbolFileDWARF *dwarf2Data, DWARFUnit *cu,
                     lldb_private::Stream &s) const;
 
   bool
-  GetDIENamesAndRanges(SymbolFileDWARF *dwarf2Data, const DWARFCompileUnit *cu,
+  GetDIENamesAndRanges(SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
                        const char *&name, const char *&mangled,
                        DWARFRangeList &rangeList, int &decl_file,
                        int &decl_line, int &decl_column, int &call_file,
                        int &call_line, int &call_column,
                        lldb_private::DWARFExpression *frame_base = NULL) const;
 
   const DWARFAbbreviationDeclaration *
   GetAbbreviationDeclarationPtr(SymbolFileDWARF *dwarf2Data,
-                                const DWARFCompileUnit *cu,
+                                const DWARFUnit *cu,
                                 lldb::offset_t &offset) const;
 
   dw_tag_t Tag() const { return m_tag; }
 
   bool IsNULL() const { return m_abbr_idx == 0; }
 
   dw_offset_t GetOffset() const { return m_offset; }
 
public:
   // be the next entry in the list...
   DWARFDebugInfoEntry *GetFirstChild() {
     return (HasChildren() && !m_empty_children) ? this + 1 : NULL;
   }
   const DWARFDebugInfoEntry *GetFirstChild() const {
     return (HasChildren() && !m_empty_children) ? this + 1 : NULL;
   }
 
-  void GetDeclContextDIEs(DWARFCompileUnit *cu,
+  void GetDeclContextDIEs(DWARFUnit *cu,
                           DWARFDIECollection &decl_context_dies) const;
 
-  void GetDWARFDeclContext(SymbolFileDWARF *dwarf2Data, DWARFCompileUnit *cu,
+  void GetDWARFDeclContext(SymbolFileDWARF *dwarf2Data, DWARFUnit *cu,
                            DWARFDeclContext &dwarf_decl_ctx) const;
 
   bool MatchesDWARFDeclContext(SymbolFileDWARF *dwarf2Data,
-                               DWARFCompileUnit *cu,
+                               DWARFUnit *cu,
                                const DWARFDeclContext &dwarf_decl_ctx) const;
 
   DWARFDIE GetParentDeclContextDIE(SymbolFileDWARF *dwarf2Data,
-                                   DWARFCompileUnit *cu) const;
+                                   DWARFUnit *cu) const;
   DWARFDIE GetParentDeclContextDIE(SymbolFileDWARF *dwarf2Data,
-                                   DWARFCompileUnit *cu,
+                                   DWARFUnit *cu,
                                    const DWARFAttributes &attributes) const;
 
   void SetParent(DWARFDebugInfoEntry *parent) {
     if (parent) {
       // We know we are kept in a vector of contiguous entries, so we know
       // our parent will be some index behind "this".
       m_parent_idx = this - parent;
     } else

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

 
 #include <algorithm>
 
 #include "lldb/Core/Module.h"
 #include "lldb/Expression/DWARFExpression.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/Stream.h"
 
-#include "DWARFCompileUnit.h"
+#include "DWARFUnit.h"
 #include "DWARFDIECollection.h"
 #include "DWARFDebugAbbrev.h"
 #include "DWARFDebugAranges.h"
 #include "DWARFDebugInfo.h"
 #include "DWARFDebugRanges.h"
 #include "DWARFDeclContext.h"
 #include "DWARFFormValue.h"
 #include "SymbolFileDWARF.h"
 #include "SymbolFileDWARFDwo.h"
 
 using namespace lldb_private;
 using namespace std;
 extern int g_verbose;
 
 bool DWARFDebugInfoEntry::FastExtract(
-    const DWARFDataExtractor &debug_info_data, const DWARFCompileUnit *cu,
+    const DWARFDataExtractor &debug_info_data, const DWARFUnit *cu,
     const DWARFFormValue::FixedFormSizes &fixed_form_sizes,
     lldb::offset_t *offset_ptr) {
   m_offset = *offset_ptr;
   m_parent_idx = 0;
   m_sibling_idx = 0;
   m_empty_children = false;
   const uint64_t abbr_idx = debug_info_data.GetULEB128(offset_ptr);
   assert(abbr_idx < (1 << DIE_ABBR_IDX_BITSIZE));

 //----------------------------------------------------------------------
 // Extract
 //
 // Extract a debug info entry for a given compile unit from the
 // .debug_info and .debug_abbrev data within the SymbolFileDWARF class
 // starting at the given offset
 //----------------------------------------------------------------------
 bool DWARFDebugInfoEntry::Extract(SymbolFileDWARF *dwarf2Data,
-                                  const DWARFCompileUnit *cu,
+                                  const DWARFUnit *cu,
                                   lldb::offset_t *offset_ptr) {
   const DWARFDataExtractor &debug_info_data = dwarf2Data->get_debug_info_data();
   //    const DWARFDataExtractor& debug_str_data =
   //    dwarf2Data->get_debug_str_data();
   const uint32_t cu_end_offset = cu->GetNextCompileUnitOffset();
   lldb::offset_t offset = *offset_ptr;
   //  if (offset >= cu_end_offset)
   //      Log::Status("DIE at offset 0x%8.8x is beyond the end of the current
if (abbr_idx) {
           cu->GetAbbreviations()->GetAbbreviationDeclaration(abbr_idx);
 
       if (abbrevDecl) {
         m_tag = abbrevDecl->Tag();
         m_has_children = abbrevDecl->HasChildren();
 
         bool isCompileUnitTag = m_tag == DW_TAG_compile_unit;
         if (cu && isCompileUnitTag)
-          const_cast<DWARFCompileUnit *>(cu)->SetBaseAddress(0);
+          const_cast<DWARFUnit *>(cu)->SetBaseAddress(0);
 
         // Skip all data in the .debug_info for the attributes
         const uint32_t numAttributes = abbrevDecl->NumAttributes();
         uint32_t i;
         dw_attr_t attr;
         dw_form_t form;
         for (i = 0; i < numAttributes; ++i) {
           abbrevDecl->GetAttrAndFormByIndexUnchecked(i, attr, form);
 
           if (isCompileUnitTag &&
               ((attr == DW_AT_entry_pc) || (attr == DW_AT_low_pc))) {
             DWARFFormValue form_value(cu, form);
             if (form_value.ExtractValue(debug_info_data, &offset)) {
               if (attr == DW_AT_low_pc || attr == DW_AT_entry_pc)
-                const_cast<DWARFCompileUnit *>(cu)->SetBaseAddress(
+                const_cast<DWARFUnit *>(cu)->SetBaseAddress(
                     form_value.Address());
             }
           } else {
             bool form_is_indirect = false;
             do {
               form_is_indirect = false;
               uint32_t form_size = 0;
               switch (form) {

 
 //----------------------------------------------------------------------
 // DumpAncestry
 //
 // Dumps all of a debug information entries parents up until oldest and
 // all of it's attributes to the specified stream.
 //----------------------------------------------------------------------
 void DWARFDebugInfoEntry::DumpAncestry(SymbolFileDWARF *dwarf2Data,
-                                       const DWARFCompileUnit *cu,
+                                       const DWARFUnit *cu,
                                        const DWARFDebugInfoEntry *oldest,
                                        Stream &s,
                                        uint32_t recurse_depth) const {
   const DWARFDebugInfoEntry *parent = GetParent();
   if (parent && parent != oldest)
     parent->DumpAncestry(dwarf2Data, cu, oldest, s, 0);
   Dump(dwarf2Data, cu, s, recurse_depth);
 }
 
 //----------------------------------------------------------------------
 // GetDIENamesAndRanges
 //
 // Gets the valid address ranges for a given DIE by looking for a
 // DW_AT_low_pc/DW_AT_high_pc pair, DW_AT_entry_pc, or DW_AT_ranges
 // attributes.
 //----------------------------------------------------------------------
 bool DWARFDebugInfoEntry::GetDIENamesAndRanges(
-    SymbolFileDWARF *dwarf2Data, const DWARFCompileUnit *cu, const char *&name,
+    SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu, const char *&name,
     const char *&mangled, DWARFRangeList &ranges, int &decl_file,
     int &decl_line, int &decl_column, int &call_file, int &call_line,
     int &call_column, DWARFExpression *frame_base) const {
   if (dwarf2Data == nullptr)
     return false;
 
   SymbolFileDWARFDwo *dwo_symbol_file = cu->GetDwoSymbolFile();
   if (dwo_symbol_file)

 
 //----------------------------------------------------------------------
 // Dump
 //
 // Dumps a debug information entry and all of it's attributes to the
 // specified stream.
 //----------------------------------------------------------------------
 void DWARFDebugInfoEntry::Dump(SymbolFileDWARF *dwarf2Data,
-                               const DWARFCompileUnit *cu, Stream &s,
+                               const DWARFUnit *cu, Stream &s,
                                uint32_t recurse_depth) const {
   const DWARFDataExtractor &debug_info_data = dwarf2Data->get_debug_info_data();
   lldb::offset_t offset = m_offset;
 
   if (debug_info_data.ValidOffset(offset)) {
     dw_uleb128_t abbrCode = debug_info_data.GetULEB128(&offset);
 
     s.Printf("\n0x%8.8x: ", m_offset);
if (abbrCode != m_abbr_idx) {
                  abbrCode);
     } else {
       s.Printf("NULL\n");
     }
   }
 }
 
 void DWARFDebugInfoEntry::DumpLocation(SymbolFileDWARF *dwarf2Data,
-                                       DWARFCompileUnit *cu, Stream &s) const {
+                                       DWARFUnit *cu, Stream &s) const {
   const DWARFDIE cu_die = cu->GetCompileUnitDIEOnly();
   const char *cu_name = NULL;
   if (cu_die)
     cu_name = cu_die.GetName();
   const char *obj_file_name = NULL;
   ObjectFile *obj_file = dwarf2Data->GetObjectFile();
   if (obj_file)
     obj_file_name =
         obj_file->GetFileSpec().GetFilename().AsCString("<Unknown>");
   const char *die_name = GetName(dwarf2Data, cu);
   s.Printf("0x%8.8x/0x%8.8x: %-30s (from %s in %s)", cu->GetOffset(),
            GetOffset(), die_name ? die_name : "", cu_name ? cu_name : "<NULL>",
            obj_file_name ? obj_file_name : "<NULL>");
 }
 
 //----------------------------------------------------------------------
 // DumpAttribute
 //
 // Dumps a debug information entry attribute along with it's form. Any
 // special display of attributes is done (disassemble location lists,
 // show enumeration values for attributes, etc).
 //----------------------------------------------------------------------
 void DWARFDebugInfoEntry::DumpAttribute(
-    SymbolFileDWARF *dwarf2Data, const DWARFCompileUnit *cu,
+    SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
     const DWARFDataExtractor &debug_info_data, lldb::offset_t *offset_ptr,
     Stream &s, dw_attr_t attr, dw_form_t form) {
   bool show_form = s.GetFlags().Test(DWARFDebugInfo::eDumpFlag_ShowForm);
 
   s.Printf("            ");
   s.Indent(DW_AT_value_to_name(attr));
 
   if (show_form) {
void DWARFDebugInfoEntry::DumpAttribute(
   case DW_AT_data_member_location: {
     const uint8_t *blockData = form_value.BlockData();
     if (blockData) {
       // Location description is inlined in data in the form value
       DWARFDataExtractor locationData(debug_info_data,
                                       (*offset_ptr) - form_value.Unsigned(),
                                       form_value.Unsigned());
       DWARFExpression::PrintDWARFExpression(
-          s, locationData, DWARFCompileUnit::GetAddressByteSize(cu), 4, false);
+          s, locationData, DWARFUnit::GetAddressByteSize(cu), 4, false);
     } else {
       // We have a location list offset as the value that is
       // the offset into the .debug_loc section that describes
       // the value over it's lifetime
       uint64_t debug_loc_offset = form_value.Unsigned();
       if (dwarf2Data) {
         DWARFExpression::PrintDWARFLocationList(
             s, cu, dwarf2Data->get_debug_loc_data(), debug_loc_offset);

 
 //----------------------------------------------------------------------
 // Get all attribute values for a given DIE, including following any
 // specification or abstract origin attributes and including those in
 // the results. Any duplicate attributes will have the first instance
 // take precedence (this can happen for declaration attributes).
 //----------------------------------------------------------------------
 size_t DWARFDebugInfoEntry::GetAttributes(
-    const DWARFCompileUnit *cu, DWARFFormValue::FixedFormSizes fixed_form_sizes,
+    const DWARFUnit *cu, DWARFFormValue::FixedFormSizes fixed_form_sizes,
     DWARFAttributes &attributes, uint32_t curr_depth) const {
   SymbolFileDWARF *dwarf2Data = nullptr;
   const DWARFAbbreviationDeclaration *abbrevDecl = nullptr;
   lldb::offset_t offset = 0;
   if (cu) {
     if (m_tag != DW_TAG_compile_unit) {
       SymbolFileDWARFDwo *dwo_symbol_file = cu->GetDwoSymbolFile();
       if (dwo_symbol_file)
for (i = 0; i < num_attributes; ++i) {
         break;
       }
 
       if ((attr == DW_AT_specification) || (attr == DW_AT_abstract_origin)) {
         DWARFFormValue form_value(cu, form);
         if (form_value.ExtractValue(debug_info_data, &offset)) {
           dw_offset_t die_offset = form_value.Reference();
           DWARFDIE spec_die =
-              const_cast<DWARFCompileUnit *>(cu)->GetDIE(die_offset);
+              const_cast<DWARFUnit *>(cu)->GetDIE(die_offset);
           if (spec_die)
             spec_die.GetAttributes(attributes, curr_depth + 1);
         }
       } else {
         const uint8_t fixed_skip_size = fixed_form_sizes.GetSize(form);
         if (fixed_skip_size)
           offset += fixed_skip_size;
         else

 // GetAttributeValue
 //
 // Get the value of an attribute and return the .debug_info offset of the
 // attribute if it was properly extracted into form_value, or zero
 // if we fail since an offset of zero is invalid for an attribute (it
 // would be a compile unit header).
 //----------------------------------------------------------------------
 dw_offset_t DWARFDebugInfoEntry::GetAttributeValue(
-    SymbolFileDWARF *dwarf2Data, const DWARFCompileUnit *cu,
+    SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
     const dw_attr_t attr, DWARFFormValue &form_value,
     dw_offset_t *end_attr_offset_ptr,
     bool check_specification_or_abstract_origin) const {
   SymbolFileDWARFDwo *dwo_symbol_file = cu->GetDwoSymbolFile();
   if (dwo_symbol_file && m_tag != DW_TAG_compile_unit)
     return GetAttributeValue(dwo_symbol_file, dwo_symbol_file->GetCompileUnit(),
                              attr, form_value, end_attr_offset_ptr,
                              check_specification_or_abstract_origin);
if (attr_idx != DW_INVALID_INDEX) {
         return attr_offset;
       }
     }
   }
 
   if (check_specification_or_abstract_origin) {
     if (GetAttributeValue(dwarf2Data, cu, DW_AT_specification, form_value)) {
       DWARFDIE die =
-          const_cast<DWARFCompileUnit *>(cu)->GetDIE(form_value.Reference());
+          const_cast<DWARFUnit *>(cu)->GetDIE(form_value.Reference());
       if (die) {
         dw_offset_t die_offset = die.GetDIE()->GetAttributeValue(
             die.GetDWARF(), die.GetCU(), attr, form_value, end_attr_offset_ptr,
             false);
         if (die_offset)
           return die_offset;
       }
     }
 
     if (GetAttributeValue(dwarf2Data, cu, DW_AT_abstract_origin, form_value)) {
       DWARFDIE die =
-          const_cast<DWARFCompileUnit *>(cu)->GetDIE(form_value.Reference());
+          const_cast<DWARFUnit *>(cu)->GetDIE(form_value.Reference());
       if (die) {
         dw_offset_t die_offset = die.GetDIE()->GetAttributeValue(
             die.GetDWARF(), die.GetCU(), attr, form_value, end_attr_offset_ptr,
             false);
         if (die_offset)
           return die_offset;
       }
     }
   }
 
   if (!dwo_symbol_file)
     return 0;
 
-  DWARFCompileUnit *dwo_cu = dwo_symbol_file->GetCompileUnit();
+  DWARFUnit *dwo_cu = dwo_symbol_file->GetCompileUnit();
   if (!dwo_cu)
     return 0;
 
   DWARFDIE dwo_cu_die = dwo_cu->GetCompileUnitDIEOnly();
   if (!dwo_cu_die.IsValid())
     return 0;
 
   return dwo_cu_die.GetDIE()->GetAttributeValue(
       dwo_symbol_file, dwo_cu, attr, form_value, end_attr_offset_ptr,
       check_specification_or_abstract_origin);
 }
 
 //----------------------------------------------------------------------
 // GetAttributeValueAsString
 //
 // Get the value of an attribute as a string return it. The resulting
 // pointer to the string data exists within the supplied SymbolFileDWARF
 // and will only be available as long as the SymbolFileDWARF is still around
 // and it's content doesn't change.
 //----------------------------------------------------------------------
 const char *DWARFDebugInfoEntry::GetAttributeValueAsString(
-    SymbolFileDWARF *dwarf2Data, const DWARFCompileUnit *cu,
+    SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
     const dw_attr_t attr, const char *fail_value,
     bool check_specification_or_abstract_origin) const {
   DWARFFormValue form_value;
   if (GetAttributeValue(dwarf2Data, cu, attr, form_value, nullptr,
                         check_specification_or_abstract_origin))
     return form_value.AsCString();
   return fail_value;
 }
 
 //----------------------------------------------------------------------
 // GetAttributeValueAsUnsigned
 //
 // Get the value of an attribute as unsigned and return it.
 //----------------------------------------------------------------------
 uint64_t DWARFDebugInfoEntry::GetAttributeValueAsUnsigned(
-    SymbolFileDWARF *dwarf2Data, const DWARFCompileUnit *cu,
+    SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
     const dw_attr_t attr, uint64_t fail_value,
     bool check_specification_or_abstract_origin) const {
   DWARFFormValue form_value;
   if (GetAttributeValue(dwarf2Data, cu, attr, form_value, nullptr,
                         check_specification_or_abstract_origin))
     return form_value.Unsigned();
   return fail_value;
 }
 
 //----------------------------------------------------------------------
 // GetAttributeValueAsSigned
 //
 // Get the value of an attribute a signed value and return it.
 //----------------------------------------------------------------------
 int64_t DWARFDebugInfoEntry::GetAttributeValueAsSigned(
-    SymbolFileDWARF *dwarf2Data, const DWARFCompileUnit *cu,
+    SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
     const dw_attr_t attr, int64_t fail_value,
     bool check_specification_or_abstract_origin) const {
   DWARFFormValue form_value;
   if (GetAttributeValue(dwarf2Data, cu, attr, form_value, nullptr,
                         check_specification_or_abstract_origin))
     return form_value.Signed();
   return fail_value;
 }
 
 //----------------------------------------------------------------------
 // GetAttributeValueAsReference
 //
 // Get the value of an attribute as reference and fix up and compile
 // unit relative offsets as needed.
 //----------------------------------------------------------------------
 uint64_t DWARFDebugInfoEntry::GetAttributeValueAsReference(
-    SymbolFileDWARF *dwarf2Data, const DWARFCompileUnit *cu,
+    SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
     const dw_attr_t attr, uint64_t fail_value,
     bool check_specification_or_abstract_origin) const {
   DWARFFormValue form_value;
   if (GetAttributeValue(dwarf2Data, cu, attr, form_value, nullptr,
                         check_specification_or_abstract_origin))
     return form_value.Reference();
   return fail_value;
 }
 
 uint64_t DWARFDebugInfoEntry::GetAttributeValueAsAddress(
-    SymbolFileDWARF *dwarf2Data, const DWARFCompileUnit *cu,
+    SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
     const dw_attr_t attr, uint64_t fail_value,
     bool check_specification_or_abstract_origin) const {
   DWARFFormValue form_value;
   if (GetAttributeValue(dwarf2Data, cu, attr, form_value, nullptr,
                         check_specification_or_abstract_origin))
     return form_value.Address();
   return fail_value;
 }
 
 //----------------------------------------------------------------------
 // GetAttributeHighPC
 //
 // Get the hi_pc, adding hi_pc to lo_pc when specified
 // as an <offset-from-low-pc>.
 //
 // Returns the hi_pc or fail_value.
 //----------------------------------------------------------------------
 dw_addr_t DWARFDebugInfoEntry::GetAttributeHighPC(
-    SymbolFileDWARF *dwarf2Data, const DWARFCompileUnit *cu, dw_addr_t lo_pc,
+    SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu, dw_addr_t lo_pc,
     uint64_t fail_value, bool check_specification_or_abstract_origin) const {
   DWARFFormValue form_value;
   if (GetAttributeValue(dwarf2Data, cu, DW_AT_high_pc, form_value, nullptr,
                         check_specification_or_abstract_origin)) {
     dw_form_t form = form_value.Form();
     if (form == DW_FORM_addr || form == DW_FORM_GNU_addr_index)
       return form_value.Address();
 
     // DWARF4 can specify the hi_pc as an <offset-from-lowpc>
     return lo_pc + form_value.Unsigned();
   }
   return fail_value;
 }
 
 //----------------------------------------------------------------------
 // GetAttributeAddressRange
 //
 // Get the lo_pc and hi_pc, adding hi_pc to lo_pc when specified
 // as an <offset-from-low-pc>.
 //
 // Returns true or sets lo_pc and hi_pc to fail_value.
 //----------------------------------------------------------------------
 bool DWARFDebugInfoEntry::GetAttributeAddressRange(
-    SymbolFileDWARF *dwarf2Data, const DWARFCompileUnit *cu, dw_addr_t &lo_pc,
+    SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu, dw_addr_t &lo_pc,
     dw_addr_t &hi_pc, uint64_t fail_value,
     bool check_specification_or_abstract_origin) const {
   lo_pc = GetAttributeValueAsAddress(dwarf2Data, cu, DW_AT_low_pc, fail_value,
                                      check_specification_or_abstract_origin);
   if (lo_pc != fail_value) {
     hi_pc = GetAttributeHighPC(dwarf2Data, cu, lo_pc, fail_value,
                                check_specification_or_abstract_origin);
     if (hi_pc != fail_value)
       return true;
   }
   lo_pc = fail_value;
   hi_pc = fail_value;
   return false;
 }
 
 size_t DWARFDebugInfoEntry::GetAttributeAddressRanges(
-    SymbolFileDWARF *dwarf2Data, const DWARFCompileUnit *cu,
+    SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
     DWARFRangeList &ranges, bool check_hi_lo_pc,
     bool check_specification_or_abstract_origin) const {
   ranges.Clear();
 
   dw_offset_t debug_ranges_offset = GetAttributeValueAsUnsigned(
       dwarf2Data, cu, DW_AT_ranges, DW_INVALID_OFFSET,
       check_specification_or_abstract_origin);
   if (debug_ranges_offset != DW_INVALID_OFFSET) {

 
 //----------------------------------------------------------------------
 // GetName
 //
 // Get value of the DW_AT_name attribute and return it if one exists,
 // else return NULL.
 //----------------------------------------------------------------------
 const char *DWARFDebugInfoEntry::GetName(SymbolFileDWARF *dwarf2Data,
-                                         const DWARFCompileUnit *cu) const {
+                                         const DWARFUnit *cu) const {
   return GetAttributeValueAsString(dwarf2Data, cu, DW_AT_name, nullptr, true);
 }
 
 //----------------------------------------------------------------------
 // GetMangledName
 //
 // Get value of the DW_AT_MIPS_linkage_name attribute and return it if
 // one exists, else return the value of the DW_AT_name attribute
 //----------------------------------------------------------------------
 const char *
 DWARFDebugInfoEntry::GetMangledName(SymbolFileDWARF *dwarf2Data,
-                                    const DWARFCompileUnit *cu,
+                                    const DWARFUnit *cu,
                                     bool substitute_name_allowed) const {
   const char *name = nullptr;
 
   name = GetAttributeValueAsString(dwarf2Data, cu, DW_AT_MIPS_linkage_name,
                                    nullptr, true);
   if (name)
     return name;
 

 
 //----------------------------------------------------------------------
 // GetPubname
 //
 // Get value the name for a DIE as it should appear for a
 // .debug_pubnames or .debug_pubtypes section.
 //----------------------------------------------------------------------
 const char *DWARFDebugInfoEntry::GetPubname(SymbolFileDWARF *dwarf2Data,
-                                            const DWARFCompileUnit *cu) const {
+                                            const DWARFUnit *cu) const {
   const char *name = nullptr;
   if (!dwarf2Data)
     return name;
 
   name = GetAttributeValueAsString(dwarf2Data, cu, DW_AT_MIPS_linkage_name,
                                    nullptr, true);
   if (name)
     return name;

 //
 // Get value of the DW_AT_name attribute for a debug information entry
 // that exists at offset "die_offset" and place that value into the
 // supplied stream object. If the DIE is a NULL object "NULL" is placed
 // into the stream, and if no DW_AT_name attribute exists for the DIE
 // then nothing is printed.
 //----------------------------------------------------------------------
 bool DWARFDebugInfoEntry::GetName(SymbolFileDWARF *dwarf2Data,
-                                  const DWARFCompileUnit *cu,
+                                  const DWARFUnit *cu,
                                   const dw_offset_t die_offset, Stream &s) {
   if (dwarf2Data == NULL) {
     s.PutCString("NULL");
     return false;
   }
 
   DWARFDebugInfoEntry die;
   lldb::offset_t offset = die_offset;

 // AppendTypeName
 //
 // Follows the type name definition down through all needed tags to
 // end up with a fully qualified type name and dump the results to
 // the supplied stream. This is used to show the name of types given
 // a type identifier.
 //----------------------------------------------------------------------
 bool DWARFDebugInfoEntry::AppendTypeName(SymbolFileDWARF *dwarf2Data,
-                                         const DWARFCompileUnit *cu,
+                                         const DWARFUnit *cu,
                                          const dw_offset_t die_offset,
                                          Stream &s) {
   if (dwarf2Data == NULL) {
     s.PutCString("NULL");
     return false;
   }
 
   DWARFDebugInfoEntry die;
bool DWARFDebugInfoEntry::AppendTypeName(SymbolFileDWARF *dwarf2Data,
   }
   return false;
 }
 
 //----------------------------------------------------------------------
 // BuildAddressRangeTable
 //----------------------------------------------------------------------
 void DWARFDebugInfoEntry::BuildAddressRangeTable(
-    SymbolFileDWARF *dwarf2Data, const DWARFCompileUnit *cu,
+    SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
     DWARFDebugAranges *debug_aranges) const {
   if (m_tag) {
     if (m_tag == DW_TAG_subprogram) {
       dw_addr_t lo_pc = LLDB_INVALID_ADDRESS;
       dw_addr_t hi_pc = LLDB_INVALID_ADDRESS;
       if (GetAttributeAddressRange(dwarf2Data, cu, lo_pc, hi_pc,
                                    LLDB_INVALID_ADDRESS)) {
         /// printf("BuildAddressRangeTable() 0x%8.8x: %30s: [0x%8.8x -

 // BuildFunctionAddressRangeTable
 //
 // This function is very similar to the BuildAddressRangeTable function
 // except that the actual DIE offset for the function is placed in the
 // table instead of the compile unit offset (which is the way the
 // standard .debug_aranges section does it).
 //----------------------------------------------------------------------
 void DWARFDebugInfoEntry::BuildFunctionAddressRangeTable(
-    SymbolFileDWARF *dwarf2Data, const DWARFCompileUnit *cu,
+    SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
     DWARFDebugAranges *debug_aranges) const {
   if (m_tag) {
     if (m_tag == DW_TAG_subprogram) {
       dw_addr_t lo_pc = LLDB_INVALID_ADDRESS;
       dw_addr_t hi_pc = LLDB_INVALID_ADDRESS;
       if (GetAttributeAddressRange(dwarf2Data, cu, lo_pc, hi_pc,
                                    LLDB_INVALID_ADDRESS)) {
         //  printf("BuildAddressRangeTable() 0x%8.8x: [0x%16.16" PRIx64 " -
         //  0x%16.16" PRIx64 ")\n", m_offset, lo_pc, hi_pc); // DEBUG ONLY
         debug_aranges->AppendRange(GetOffset(), lo_pc, hi_pc);
       }
     }
 
     const DWARFDebugInfoEntry *child = GetFirstChild();
     while (child) {
       child->BuildFunctionAddressRangeTable(dwarf2Data, cu, debug_aranges);
       child = child->GetSibling();
     }
   }
 }
 
 void DWARFDebugInfoEntry::GetDeclContextDIEs(
-    DWARFCompileUnit *cu, DWARFDIECollection &decl_context_dies) const {
+    DWARFUnit *cu, DWARFDIECollection &decl_context_dies) const {
 
   DWARFDIE die(cu, const_cast<DWARFDebugInfoEntry *>(this));
   die.GetDeclContextDIEs(decl_context_dies);
 }
 
 void DWARFDebugInfoEntry::GetDWARFDeclContext(
-    SymbolFileDWARF *dwarf2Data, DWARFCompileUnit *cu,
+    SymbolFileDWARF *dwarf2Data, DWARFUnit *cu,
     DWARFDeclContext &dwarf_decl_ctx) const {
   const dw_tag_t tag = Tag();
   if (tag != DW_TAG_compile_unit) {
     dwarf_decl_ctx.AppendDeclContext(tag, GetName(dwarf2Data, cu));
     DWARFDIE parent_decl_ctx_die = GetParentDeclContextDIE(dwarf2Data, cu);
     if (parent_decl_ctx_die && parent_decl_ctx_die.GetDIE() != this) {
       if (parent_decl_ctx_die.Tag() != DW_TAG_compile_unit)
         parent_decl_ctx_die.GetDIE()->GetDWARFDeclContext(
             parent_decl_ctx_die.GetDWARF(), parent_decl_ctx_die.GetCU(),
             dwarf_decl_ctx);
     }
   }
 }
 
 bool DWARFDebugInfoEntry::MatchesDWARFDeclContext(
-    SymbolFileDWARF *dwarf2Data, DWARFCompileUnit *cu,
+    SymbolFileDWARF *dwarf2Data, DWARFUnit *cu,
     const DWARFDeclContext &dwarf_decl_ctx) const {
 
   DWARFDeclContext this_dwarf_decl_ctx;
   GetDWARFDeclContext(dwarf2Data, cu, this_dwarf_decl_ctx);
   return this_dwarf_decl_ctx == dwarf_decl_ctx;
 }
 
 DWARFDIE
 DWARFDebugInfoEntry::GetParentDeclContextDIE(SymbolFileDWARF *dwarf2Data,
-                                             DWARFCompileUnit *cu) const {
+                                             DWARFUnit *cu) const {
   DWARFAttributes attributes;
   GetAttributes(cu, DWARFFormValue::FixedFormSizes(), attributes);
   return GetParentDeclContextDIE(dwarf2Data, cu, attributes);
 }
 
 DWARFDIE
 DWARFDebugInfoEntry::GetParentDeclContextDIE(
-    SymbolFileDWARF *dwarf2Data, DWARFCompileUnit *cu,
+    SymbolFileDWARF *dwarf2Data, DWARFUnit *cu,
     const DWARFAttributes &attributes) const {
   DWARFDIE die(cu, const_cast<DWARFDebugInfoEntry *>(this));
 
   while (die) {
     // If this is the original DIE that we are searching for a declaration
     // for, then don't look in the cache as we don't want our own decl
     // context to be our decl context...
     if (die.GetDIE() != this) {
while (die) {
     }
 
     die = die.GetParent();
   }
   return DWARFDIE();
 }
 
 const char *DWARFDebugInfoEntry::GetQualifiedName(SymbolFileDWARF *dwarf2Data,
-                                                  DWARFCompileUnit *cu,
+                                                  DWARFUnit *cu,
                                                   std::string &storage) const {
   DWARFAttributes attributes;
   GetAttributes(cu, DWARFFormValue::FixedFormSizes(), attributes);
   return GetQualifiedName(dwarf2Data, cu, attributes, storage);
 }
 
 const char *DWARFDebugInfoEntry::GetQualifiedName(
-    SymbolFileDWARF *dwarf2Data, DWARFCompileUnit *cu,
+    SymbolFileDWARF *dwarf2Data, DWARFUnit *cu,
     const DWARFAttributes &attributes, std::string &storage) const {
 
   const char *name = GetName(dwarf2Data, cu);
 
   if (name) {
     DWARFDIE parent_decl_ctx_die = GetParentDeclContextDIE(dwarf2Data, cu);
     storage.clear();
     // TODO: change this to get the correct decl context parent....
const char *DWARFDebugInfoEntry::GetQualifiedName(
   return storage.c_str();
 }
 
 //----------------------------------------------------------------------
 // LookupAddress
 //----------------------------------------------------------------------
 bool DWARFDebugInfoEntry::LookupAddress(const dw_addr_t address,
                                         SymbolFileDWARF *dwarf2Data,
-                                        const DWARFCompileUnit *cu,
+                                        const DWARFUnit *cu,
                                         DWARFDebugInfoEntry **function_die,
                                         DWARFDebugInfoEntry **block_die) {
   bool found_address = false;
   if (m_tag) {
     bool check_children = false;
     bool match_addr_range = false;
     //  printf("0x%8.8x: %30s: address = 0x%8.8x - ", m_offset,
     //  DW_TAG_value_to_name(tag), address);
if (check_children) {
       }
     }
   }
   return found_address;
 }
 
 const DWARFAbbreviationDeclaration *
 DWARFDebugInfoEntry::GetAbbreviationDeclarationPtr(
-    SymbolFileDWARF *dwarf2Data, const DWARFCompileUnit *cu,
+    SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
     lldb::offset_t &offset) const {
   if (dwarf2Data) {
     offset = GetOffset();
 
     const DWARFAbbreviationDeclarationSet *abbrev_set = cu->GetAbbreviations();
     if (abbrev_set) {
       const DWARFAbbreviationDeclaration *abbrev_decl =
           abbrev_set->GetAbbreviationDeclaration(m_abbr_idx);

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFFormValue.h

 //===-- DWARFFormValue.h ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SymbolFileDWARF_DWARFFormValue_h_
 #define SymbolFileDWARF_DWARFFormValue_h_
 
 #include "DWARFDataExtractor.h"
 #include <stddef.h> // for NULL
 
-class DWARFCompileUnit;
+class DWARFUnit;
 
 class DWARFFormValue {
 public:
   typedef struct ValueTypeTag {
     ValueTypeTag() : value(), data(NULL) { value.uval = 0; }
 
     union {
       uint64_t uval;
enum {
     eValueTypeInvalid = 0,
     eValueTypeUnsigned,
     eValueTypeSigned,
     eValueTypeCStr,
     eValueTypeBlock
   };
 
   DWARFFormValue();
-  DWARFFormValue(const DWARFCompileUnit *cu, dw_form_t form);
-  const DWARFCompileUnit *GetCompileUnit() const { return m_cu; }
-  void SetCompileUnit(const DWARFCompileUnit *cu) { m_cu = cu; }
+  DWARFFormValue(const DWARFUnit *cu, dw_form_t form);
+  const DWARFUnit *GetCompileUnit() const { return m_cu; }
+  void SetCompileUnit(const DWARFUnit *cu) { m_cu = cu; }
   dw_form_t Form() const { return m_form; }
   void SetForm(dw_form_t form) { m_form = form; }
   const ValueType &Value() const { return m_value; }
   void Dump(lldb_private::Stream &s) const;
   bool ExtractValue(const lldb_private::DWARFDataExtractor &data,
                     lldb::offset_t *offset_ptr);
   const uint8_t *BlockData() const;
   uint64_t Reference() const;
   uint64_t Reference(dw_offset_t offset) const;
   bool Boolean() const { return m_value.value.uval != 0; }
   uint64_t Unsigned() const { return m_value.value.uval; }
   void SetUnsigned(uint64_t uval) { m_value.value.uval = uval; }
   int64_t Signed() const { return m_value.value.sval; }
   void SetSigned(int64_t sval) { m_value.value.sval = sval; }
   const char *AsCString() const;
   dw_addr_t Address() const;
   bool IsValid() const { return m_form != 0; }
   bool SkipValue(const lldb_private::DWARFDataExtractor &debug_info_data,
                  lldb::offset_t *offset_ptr) const;
   static bool SkipValue(const dw_form_t form,
                         const lldb_private::DWARFDataExtractor &debug_info_data,
-                        lldb::offset_t *offset_ptr, const DWARFCompileUnit *cu);
+                        lldb::offset_t *offset_ptr, const DWARFUnit *cu);
   static bool IsBlockForm(const dw_form_t form);
   static bool IsDataForm(const dw_form_t form);
   static FixedFormSizes GetFixedFormSizesForAddressSize(uint8_t addr_size,
                                                         bool is_dwarf64);
   static int Compare(const DWARFFormValue &a, const DWARFFormValue &b);
   void Clear();
   static bool FormIsSupported(dw_form_t form);
 
 protected:
-  const DWARFCompileUnit *m_cu; // Compile unit for this form
+  const DWARFUnit *m_cu;        // Compile unit for this form
   dw_form_t m_form;             // Form for this value
   ValueType m_value;            // Contains all data for the form
 };
 
 #endif // SymbolFileDWARF_DWARFFormValue_h_

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp

 //===-- DWARFFormValue.cpp --------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include <assert.h>
 
 #include "lldb/Core/dwarf.h"
 #include "lldb/Utility/Stream.h"
 
-#include "DWARFCompileUnit.h"
+#include "DWARFUnit.h"
 #include "DWARFFormValue.h"
 
-class DWARFCompileUnit;
+class DWARFUnit;
 
 using namespace lldb_private;
 
 static uint8_t g_form_sizes_addr4[] = {
     0, // 0x00 unused
     4, // 0x01 DW_FORM_addr
     0, // 0x02 unused
     0, // 0x03 DW_FORM_block2
if (addr_size == 8)
                             sizeof(g_form_sizes_addr8_dwarf64));
     // is_dwarf64 && addr_size == 4 : no provider does this.
   }
   return FixedFormSizes();
 }
 
 DWARFFormValue::DWARFFormValue() : m_cu(NULL), m_form(0), m_value() {}
 
-DWARFFormValue::DWARFFormValue(const DWARFCompileUnit *cu, dw_form_t form)
+DWARFFormValue::DWARFFormValue(const DWARFUnit *cu, dw_form_t form)
     : m_cu(cu), m_form(form), m_value() {}
 
 void DWARFFormValue::Clear() {
   m_cu = nullptr;
   m_form = 0;
   memset(&m_value, 0, sizeof(m_value));
 }
 
 bool DWARFFormValue::ExtractValue(const DWARFDataExtractor &data,
                                   lldb::offset_t *offset_ptr) {
   bool indirect = false;
   bool is_block = false;
   m_value.data = NULL;
   uint8_t ref_addr_size;
   // Read the value for the form into value and follow and DW_FORM_indirect
   // instances we run into
   do {
     indirect = false;
     switch (m_form) {
     case DW_FORM_addr:
       assert(m_cu);
       m_value.value.uval = data.GetMaxU64(
-          offset_ptr, DWARFCompileUnit::GetAddressByteSize(m_cu));
+          offset_ptr, DWARFUnit::GetAddressByteSize(m_cu));
       break;
     case DW_FORM_block2:
       m_value.value.uval = data.GetU16(offset_ptr);
       is_block = true;
       break;
     case DW_FORM_block4:
       m_value.value.uval = data.GetU32(offset_ptr);
       is_block = true;
case DW_FORM_flag:
       m_value.value.uval = data.GetU8(offset_ptr);
       break;
     case DW_FORM_sdata:
       m_value.value.sval = data.GetSLEB128(offset_ptr);
       break;
     case DW_FORM_strp:
       assert(m_cu);
       m_value.value.uval =
-          data.GetMaxU64(offset_ptr, DWARFCompileUnit::IsDWARF64(m_cu) ? 8 : 4);
+          data.GetMaxU64(offset_ptr, DWARFUnit::IsDWARF64(m_cu) ? 8 : 4);
       break;
     //  case DW_FORM_APPLE_db_str:
     case DW_FORM_udata:
       m_value.value.uval = data.GetULEB128(offset_ptr);
       break;
     case DW_FORM_ref_addr:
       assert(m_cu);
       ref_addr_size = 4;
do {
     case DW_FORM_indirect:
       m_form = data.GetULEB128(offset_ptr);
       indirect = true;
       break;
 
     case DW_FORM_sec_offset:
       assert(m_cu);
       m_value.value.uval =
-          data.GetMaxU64(offset_ptr, DWARFCompileUnit::IsDWARF64(m_cu) ? 8 : 4);
+          data.GetMaxU64(offset_ptr, DWARFUnit::IsDWARF64(m_cu) ? 8 : 4);
       break;
     case DW_FORM_flag_present:
       m_value.value.uval = 1;
       break;
     case DW_FORM_ref_sig8:
       m_value.value.uval = data.GetU64(offset_ptr);
       break;
     case DW_FORM_GNU_str_index:

 bool DWARFFormValue::SkipValue(const DWARFDataExtractor &debug_info_data,
                                lldb::offset_t *offset_ptr) const {
   return DWARFFormValue::SkipValue(m_form, debug_info_data, offset_ptr, m_cu);
 }
 
 bool DWARFFormValue::SkipValue(dw_form_t form,
                                const DWARFDataExtractor &debug_info_data,
                                lldb::offset_t *offset_ptr,
-                               const DWARFCompileUnit *cu) {
+                               const DWARFUnit *cu) {
   uint8_t ref_addr_size;
   switch (form) {
   // Blocks if inlined data that have a length field and the data bytes
   // inlined in the .debug_info
   case DW_FORM_exprloc:
   case DW_FORM_block: {
     dw_uleb128_t size = debug_info_data.GetULEB128(offset_ptr);
     *offset_ptr += size;
bool DWARFFormValue::SkipValue(dw_form_t form,
 
   // Inlined NULL terminated C-strings
   case DW_FORM_string:
     debug_info_data.GetCStr(offset_ptr);
     return true;
 
   // Compile unit address sized values
   case DW_FORM_addr:
-    *offset_ptr += DWARFCompileUnit::GetAddressByteSize(cu);
+    *offset_ptr += DWARFUnit::GetAddressByteSize(cu);
     return true;
 
   case DW_FORM_ref_addr:
     ref_addr_size = 4;
     assert(cu); // CU must be valid for DW_FORM_ref_addr objects or we will get
                 // this wrong
     if (cu->GetVersion() <= 2)
       ref_addr_size = cu->GetAddressByteSize();

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFUnit.h

enum DWARFProducer {
   eProducerInvalid = 0,
   eProducerClang,
   eProducerGCC,
   eProducerLLVMGCC,
   eProcucerOther
 };
 
 class DWARFUnit {
+  friend class DWARFCompileUnit;
+
 public:
   virtual ~DWARFUnit();
 
   size_t ExtractDIEsIfNeeded(bool cu_die_only);
   DWARFDIE LookupAddress(const dw_addr_t address);
   size_t AppendDIEsWithTag(const dw_tag_t tag,
                            DWARFDIECollection &matching_dies,
                            uint32_t depth = UINT32_MAX) const;

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

if (die_offset != DW_INVALID_OFFSET) {
 
     if (ContainsDIEOffset(die_offset)) {
       ExtractDIEsIfNeeded(false);
       DWARFDebugInfoEntry::iterator end = Data().m_die_array.end();
       DWARFDebugInfoEntry::iterator pos = lower_bound(
           Data().m_die_array.begin(), end, die_offset, CompareDIEOffset);
       if (pos != end) {
         if (die_offset == (*pos).GetOffset())
-          return DWARFDIE(&Data(), &(*pos));
+          return DWARFDIE(this, &(*pos));
       }
     } else {
       // Don't specify the compile unit offset as we don't know it because the
       // DIE belongs to
       // a different compile unit in the same symbol file.
       return Data().m_dwarf2Data->DebugInfo()->GetDIEForDIEOffset(die_offset);
     }
   }
for (pos = begin; pos != end; ++pos) {
     bool is_declaration = false;
     // bool is_artificial = false;
     bool has_address = false;
     bool has_location_or_const_value = false;
     bool is_global_or_static_variable = false;
 
     DWARFFormValue specification_die_form;
     const size_t num_attributes =
-        die.GetAttributes(&dwarf_cu->Data(), fixed_form_sizes, attributes);
+        die.GetAttributes(dwarf_cu, fixed_form_sizes, attributes);
     if (num_attributes > 0) {
       for (uint32_t i = 0; i < num_attributes; ++i) {
         dw_attr_t attr = attributes.AttributeAtIndex(i);
         DWARFFormValue form_value;
         switch (attr) {
         case DW_AT_name:
           if (attributes.ExtractFormValueAtIndex(i, form_value))
             name = form_value.AsCString();

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

public:
 
   DWARFDIE
   GetDeclContextDIEContainingDIE(const DWARFDIE &die);
 
   bool
   HasForwardDeclForClangType(const lldb_private::CompilerType &compiler_type);
 
   lldb_private::CompileUnit *
-  GetCompUnitForDWARFCompUnit(DWARFCompileUnit *dwarf_cu,
+  GetCompUnitForDWARFCompUnit(DWARFUnit *dwarf_cu,
                               uint32_t cu_idx = UINT32_MAX);
 
   virtual size_t GetObjCMethodDIEOffsets(lldb_private::ConstString class_name,
                                          DIEArray &method_die_offsets);
 
-  bool Supports_DW_AT_APPLE_objc_complete_type(DWARFCompileUnit *cu);
+  bool Supports_DW_AT_APPLE_objc_complete_type(DWARFUnit *cu);
 
   lldb_private::DebugMacrosSP ParseDebugMacros(lldb::offset_t *offset);
 
   static DWARFDIE GetParentSymbolContextDIE(const DWARFDIE &die);
 
-  virtual lldb::CompUnitSP ParseCompileUnit(DWARFCompileUnit *dwarf_cu,
+  virtual lldb::CompUnitSP ParseCompileUnit(DWARFUnit *dwarf_cu,
                                             uint32_t cu_idx);
 
   virtual lldb_private::DWARFExpression::LocationListFormat
   GetLocationListFormat() const;
 
   lldb::ModuleSP GetDWOModule(lldb_private::ConstString name);
 
   typedef std::map<lldb_private::ConstString, lldb::ModuleSP>
       ExternalTypeModuleMap;
 
   /// Return the list of Clang modules imported by this SymbolFile.
   const ExternalTypeModuleMap& getExternalTypeModules() const {
       return m_external_type_modules;
   }
 
   virtual DWARFDIE GetDIE(const DIERef &die_ref);
 
   virtual std::unique_ptr<SymbolFileDWARFDwo>
-  GetDwoSymbolFileForCompileUnit(DWARFCompileUnit &dwarf_cu,
+  GetDwoSymbolFileForCompileUnit(DWARFUnit &dwarf_cu,
                                  const DWARFDebugInfoEntry &cu_die);
 
   // For regular SymbolFileDWARF instances the method returns nullptr,
   // for the instances of the subclass SymbolFileDWARFDwo
   // the method returns a pointer to the base compile unit.
-  virtual DWARFCompileUnit *GetBaseCompileUnit();
+  virtual DWARFUnit *GetBaseCompileUnit();
 
 protected:
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb_private::Type *>
       DIEToTypePtr;
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb::VariableSP>
       DIEToVariableSP;
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *,
                          lldb::opaque_compiler_type_t>
protected:
 
   bool DeclContextMatchesThisSymbolFile(
       const lldb_private::CompilerDeclContext *decl_ctx);
 
   bool
   DIEInDeclContext(const lldb_private::CompilerDeclContext *parent_decl_ctx,
                    const DWARFDIE &die);
 
-  virtual DWARFCompileUnit *
+  virtual DWARFUnit *
   GetDWARFCompileUnit(lldb_private::CompileUnit *comp_unit);
 
-  DWARFCompileUnit *GetNextUnparsedDWARFCompileUnit(DWARFCompileUnit *prev_cu);
+  DWARFUnit *GetNextUnparsedDWARFCompileUnit(DWARFUnit *prev_cu);
 
   bool GetFunction(const DWARFDIE &die, lldb_private::SymbolContext &sc);
 
   lldb_private::Function *
   ParseCompileUnitFunction(const lldb_private::SymbolContext &sc,
                            const DWARFDIE &die);
 
   size_t ParseFunctionBlocks(const lldb_private::SymbolContext &sc,

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

 #include "Plugins/Language/ObjC/ObjCLanguage.h"
 
 #include "lldb/Target/Language.h"
 
 #include "lldb/Host/TaskPool.h"
 
 #include "DWARFASTParser.h"
 #include "DWARFASTParserClang.h"
-#include "DWARFCompileUnit.h"
+#include "DWARFUnit.h"
 #include "DWARFDIECollection.h"
 #include "DWARFDebugAbbrev.h"
 #include "DWARFDebugAranges.h"
 #include "DWARFDebugInfo.h"
 #include "DWARFDebugLine.h"
 #include "DWARFDebugMacro.h"
 #include "DWARFDebugRanges.h"
 #include "DWARFDeclContext.h"
static const char *resolveCompDir(const char *path_from_dwarf) {
   const auto error =
       FileSystem::Readlink(local_path_spec, resolved_local_path_spec);
   if (error.Success())
     return resolved_local_path_spec.GetCString();
 
   return nullptr;
 }
 
-DWARFCompileUnit *SymbolFileDWARF::GetBaseCompileUnit() {
+DWARFUnit *SymbolFileDWARF::GetBaseCompileUnit() {
   return nullptr;
 }
 
 void SymbolFileDWARF::Initialize() {
   LogChannelDWARF::Initialize();
   PluginManager::RegisterPlugin(GetPluginNameStatic(),
                                 GetPluginDescriptionStatic(), CreateInstance,
                                 DebuggerInitialize);

 
 size_t SymbolFileDWARF::GetTypes(SymbolContextScope *sc_scope,
                                  uint32_t type_mask, TypeList &type_list)
 
 {
   TypeSet type_set;
 
   CompileUnit *comp_unit = NULL;
-  DWARFCompileUnit *dwarf_cu = NULL;
+  DWARFUnit *dwarf_cu = NULL;
   if (sc_scope)
     comp_unit = sc_scope->CalculateSymbolContextCompileUnit();
 
   if (comp_unit) {
     dwarf_cu = GetDWARFCompileUnit(comp_unit);
     if (dwarf_cu == 0)
       return 0;
     GetTypes(dwarf_cu->DIE(), dwarf_cu->GetOffset(),
DWARFDebugInfo *SymbolFileDWARF::DebugInfo() {
   }
   return m_info.get();
 }
 
 const DWARFDebugInfo *SymbolFileDWARF::DebugInfo() const {
   return m_info.get();
 }
 
-DWARFCompileUnit *
+DWARFUnit *
 SymbolFileDWARF::GetDWARFCompileUnit(lldb_private::CompileUnit *comp_unit) {
   if (!comp_unit)
     return nullptr;
 
   DWARFDebugInfo *info = DebugInfo();
   if (info) {
     // Just a normal DWARF file whose user ID for the compile unit is
     // the DWARF offset itself
 
-    DWARFCompileUnit *dwarf_cu =
+    DWARFUnit *dwarf_cu =
         info->GetCompileUnit((dw_offset_t)comp_unit->GetID());
     if (dwarf_cu && dwarf_cu->GetUserData() == NULL)
       dwarf_cu->SetUserData(comp_unit);
     return dwarf_cu;
   }
   return NULL;
 }
 
DWARFDebugRanges *SymbolFileDWARF::DebugRanges() {
   }
   return m_ranges.get();
 }
 
 const DWARFDebugRanges *SymbolFileDWARF::DebugRanges() const {
   return m_ranges.get();
 }
 
-lldb::CompUnitSP SymbolFileDWARF::ParseCompileUnit(DWARFCompileUnit *dwarf_cu,
+lldb::CompUnitSP SymbolFileDWARF::ParseCompileUnit(DWARFUnit *dwarf_cu,
                                                    uint32_t cu_idx) {
   CompUnitSP cu_sp;
   if (dwarf_cu) {
     CompileUnit *comp_unit = (CompileUnit *)dwarf_cu->GetUserData();
     if (comp_unit) {
       // We already parsed this compile unit, had out a shared pointer to it
       cu_sp = comp_unit->shared_from_this();
     } else {
if (comp_unit) {
               }
 
               std::string remapped_file;
               if (module_sp->RemapSourceFile(cu_file_spec.GetPath(),
                                              remapped_file))
                 cu_file_spec.SetFile(remapped_file, false);
             }
 
-            LanguageType cu_language = DWARFCompileUnit::LanguageTypeFromDWARF(
+            LanguageType cu_language = DWARFUnit::LanguageTypeFromDWARF(
                 cu_die.GetAttributeValueAsUnsigned(DW_AT_language, 0));
 
             bool is_optimized = dwarf_cu->GetIsOptimized();
             cu_sp.reset(new CompileUnit(
                 module_sp, dwarf_cu, cu_file_spec, dwarf_cu->GetID(),
                 cu_language, is_optimized ? eLazyBoolYes : eLazyBoolNo));
             if (cu_sp) {
               // If we just created a compile unit with an invalid file spec,
if (info)
     return info->GetNumCompileUnits();
   return 0;
 }
 
 CompUnitSP SymbolFileDWARF::ParseCompileUnitAtIndex(uint32_t cu_idx) {
   CompUnitSP cu_sp;
   DWARFDebugInfo *info = DebugInfo();
   if (info) {
-    DWARFCompileUnit *dwarf_cu = info->GetCompileUnitAtIndex(cu_idx);
+    DWARFUnit *dwarf_cu = info->GetCompileUnitAtIndex(cu_idx);
     if (dwarf_cu)
       cu_sp = ParseCompileUnit(dwarf_cu, cu_idx);
   }
   return cu_sp;
 }
 
 Function *SymbolFileDWARF::ParseCompileUnitFunction(const SymbolContext &sc,
                                                     const DWARFDIE &die) {
if (debug_map_symfile) {
     return debug_map_symfile->LinkOSOAddress(addr);
   }
   // This is a normal DWARF file, no address fixups need to happen
   return true;
 }
 lldb::LanguageType
 SymbolFileDWARF::ParseCompileUnitLanguage(const SymbolContext &sc) {
   assert(sc.comp_unit);
-  DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
+  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
   if (dwarf_cu)
     return dwarf_cu->GetLanguageType();
   else
     return eLanguageTypeUnknown;
 }
 
 size_t SymbolFileDWARF::ParseCompileUnitFunctions(const SymbolContext &sc) {
   assert(sc.comp_unit);
   size_t functions_added = 0;
-  DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
+  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
   if (dwarf_cu) {
     DWARFDIECollection function_dies;
     const size_t num_functions =
         dwarf_cu->AppendDIEsWithTag(DW_TAG_subprogram, function_dies);
     size_t func_idx;
     for (func_idx = 0; func_idx < num_functions; ++func_idx) {
       DWARFDIE die = function_dies.GetDIEAtIndex(func_idx);
       if (sc.comp_unit->FindFunctionByUID(die.GetID()).get() == NULL) {
         if (ParseCompileUnitFunction(sc, die))
           ++functions_added;
       }
     }
     // FixupTypes();
   }
   return functions_added;
 }
 
 bool SymbolFileDWARF::ParseCompileUnitSupportFiles(
     const SymbolContext &sc, FileSpecList &support_files) {
   assert(sc.comp_unit);
-  DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
+  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
   if (dwarf_cu) {
     const DWARFDIE cu_die = dwarf_cu->GetCompileUnitDIEOnly();
 
     if (cu_die) {
       const char *cu_comp_dir = resolveCompDir(
           cu_die.GetAttributeValueAsString(DW_AT_comp_dir, nullptr));
       const dw_offset_t stmt_list = cu_die.GetAttributeValueAsUnsigned(
           DW_AT_stmt_list, DW_INVALID_OFFSET);
       if (stmt_list != DW_INVALID_OFFSET) {
         // All file indexes in DWARF are one based and a file of index zero is
         // supposed to be the compile unit itself.
         support_files.Append(*sc.comp_unit);
         return DWARFDebugLine::ParseSupportFiles(
             sc.comp_unit->GetModule(), get_debug_line_data(), cu_comp_dir,
             stmt_list, support_files);
       }
     }
   }
   return false;
 }
 
 bool SymbolFileDWARF::ParseCompileUnitIsOptimized(
     const lldb_private::SymbolContext &sc) {
-  DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
+  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
   if (dwarf_cu)
     return dwarf_cu->GetIsOptimized();
   return false;
 }
 
 bool SymbolFileDWARF::ParseImportedModules(
     const lldb_private::SymbolContext &sc,
     std::vector<lldb_private::ConstString> &imported_modules) {
   assert(sc.comp_unit);
-  DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
+  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
   if (dwarf_cu) {
     if (ClangModulesDeclVendor::LanguageSupportsClangModules(
             sc.comp_unit->GetLanguage())) {
       UpdateExternalModuleListIfNeeded();
 
       if (sc.comp_unit) {
         const DWARFDIE die = dwarf_cu->GetCompileUnitDIEOnly();
 
static void ParseDWARFLineTableCallback(dw_offset_t offset,
   }
 }
 
 bool SymbolFileDWARF::ParseCompileUnitLineTable(const SymbolContext &sc) {
   assert(sc.comp_unit);
   if (sc.comp_unit->GetLineTable() != NULL)
     return true;
 
-  DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
+  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
   if (dwarf_cu) {
     const DWARFDIE dwarf_cu_die = dwarf_cu->GetCompileUnitDIEOnly();
     if (dwarf_cu_die) {
       const dw_offset_t cu_line_offset =
           dwarf_cu_die.GetAttributeValueAsUnsigned(DW_AT_stmt_list,
                                                    DW_INVALID_OFFSET);
       if (cu_line_offset != DW_INVALID_OFFSET) {
         std::unique_ptr<LineTable> line_table_ap(new LineTable(sc.comp_unit));
DWARFDebugMacroEntry::ReadMacroEntries(debug_macro_data, get_debug_str_data(),
                                          debug_macros_sp);
 
   return debug_macros_sp;
 }
 
 bool SymbolFileDWARF::ParseCompileUnitDebugMacros(const SymbolContext &sc) {
   assert(sc.comp_unit);
 
-  DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
+  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
   if (dwarf_cu == nullptr)
     return false;
 
   const DWARFDIE dwarf_cu_die = dwarf_cu->GetCompileUnitDIEOnly();
   if (!dwarf_cu_die)
     return false;
 
   lldb::offset_t sect_offset =
if (die) {
 
     } else
       return type;
   }
   return nullptr;
 }
 
 CompileUnit *
-SymbolFileDWARF::GetCompUnitForDWARFCompUnit(DWARFCompileUnit *dwarf_cu,
+SymbolFileDWARF::GetCompUnitForDWARFCompUnit(DWARFUnit *dwarf_cu,
                                              uint32_t cu_idx) {
   // Check if the symbol vendor already knows about this compile unit?
   if (dwarf_cu->GetUserData() == NULL) {
     // The symbol vendor doesn't know about this compile unit, we
     // need to parse and add it to the symbol vendor object.
     return ParseCompileUnit(dwarf_cu, cu_idx).get();
   }
   return (CompileUnit *)dwarf_cu->GetUserData();
SymbolFileDWARF::GetDIE(const DIERef &die_ref) {
   if (debug_info)
     return debug_info->GetDIE(die_ref);
   else
     return DWARFDIE();
 }
 
 std::unique_ptr<SymbolFileDWARFDwo>
 SymbolFileDWARF::GetDwoSymbolFileForCompileUnit(
-    DWARFCompileUnit &dwarf_cu, const DWARFDebugInfoEntry &cu_die) {
+    DWARFUnit &dwarf_cu, const DWARFDebugInfoEntry &cu_die) {
   // If we are using a dSYM file, we never want the standard DWO files since
   // the -gmodules support uses the same DWO machanism to specify full debug
   // info files for modules.
   if (GetDebugMapSymfile())
     return nullptr;
 
   const char *dwo_name = cu_die.GetAttributeValueAsString(
       this, &dwarf_cu, DW_AT_GNU_dwo_name, nullptr);
void SymbolFileDWARF::UpdateExternalModuleListIfNeeded() {
   if (m_fetched_external_modules)
     return;
   m_fetched_external_modules = true;
 
   DWARFDebugInfo *debug_info = DebugInfo();
 
   const uint32_t num_compile_units = GetNumCompileUnits();
   for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) {
-    DWARFCompileUnit *dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx);
+    DWARFUnit *dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx);
 
     const DWARFDIE die = dwarf_cu->GetCompileUnitDIEOnly();
     if (die && die.HasChildren() == false) {
       const char *name = die.GetAttributeValueAsString(DW_AT_name, nullptr);
 
       if (name) {
         ConstString const_name(name);
         if (m_external_type_modules.find(const_name) ==
if (debug_info) {
               scc->CalculateSymbolContext(&sc);
               sc.variable = variable;
             }
             return sc.GetResolvedMask();
           }
         }
       } else {
         uint32_t cu_idx = DW_INVALID_INDEX;
-        DWARFCompileUnit *dwarf_cu =
+        DWARFUnit *dwarf_cu =
             debug_info->GetCompileUnit(cu_offset, &cu_idx);
         if (dwarf_cu) {
           sc.comp_unit = GetCompUnitForDWARFCompUnit(dwarf_cu, cu_idx);
           if (sc.comp_unit) {
             resolved |= eSymbolContextCompUnit;
 
             bool force_check_line_table = false;
             if (resolve_scope &
uint32_t SymbolFileDWARF::ResolveSymbolContext(const FileSpec &file_spec,
                                                bool check_inlines,
                                                uint32_t resolve_scope,
                                                SymbolContextList &sc_list) {
   const uint32_t prev_size = sc_list.GetSize();
   if (resolve_scope & eSymbolContextCompUnit) {
     DWARFDebugInfo *debug_info = DebugInfo();
     if (debug_info) {
       uint32_t cu_idx;
-      DWARFCompileUnit *dwarf_cu = NULL;
+      DWARFUnit *dwarf_cu = NULL;
 
       for (cu_idx = 0;
            (dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx)) != NULL;
            ++cu_idx) {
         CompileUnit *dc_cu = GetCompUnitForDWARFCompUnit(dwarf_cu, cu_idx);
         const bool full_match = (bool)file_spec.GetDirectory();
         bool file_spec_matches_cu_file_spec =
             dc_cu != NULL && FileSpec::Equal(file_spec, *dc_cu, full_match);
if (debug_info) {
     // std::vector<bool> might be implemented using bit test-and-set, so use
     // uint8_t instead.
     std::vector<uint8_t> clear_cu_dies(num_compile_units, false);
     auto parser_fn = [debug_info, &function_basename_index,
                       &function_fullname_index, &function_method_index,
                       &function_selector_index, &objc_class_selectors_index,
                       &global_index, &type_index,
                       &namespace_index](size_t cu_idx) {
-      DWARFCompileUnit *dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx);
+      DWARFUnit *dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx);
       if (dwarf_cu) {
         dwarf_cu->Index(
             function_basename_index[cu_idx], function_fullname_index[cu_idx],
             function_method_index[cu_idx], function_selector_index[cu_idx],
             objc_class_selectors_index[cu_idx], global_index[cu_idx],
             type_index[cu_idx], namespace_index[cu_idx]);
       }
     };
 
     auto extract_fn = [debug_info, &clear_cu_dies](size_t cu_idx) {
-      DWARFCompileUnit *dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx);
+      DWARFUnit *dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx);
       if (dwarf_cu) {
         // dwarf_cu->ExtractDIEsIfNeeded(false) will return zero if the
         // DIEs for a compile unit have already been parsed.
         if (dwarf_cu->ExtractDIEsIfNeeded(false) > 1)
           clear_cu_dies[cu_idx] = true;
       }
     };
 
void SymbolFileDWARF::GetMangledNamesForFunction(
     const std::string &scope_qualified_name,
     std::vector<ConstString> &mangled_names) {
   DWARFDebugInfo *info = DebugInfo();
   uint32_t num_comp_units = 0;
   if (info)
     num_comp_units = info->GetNumCompileUnits();
 
   for (uint32_t i = 0; i < num_comp_units; i++) {
-    DWARFCompileUnit *cu = info->GetCompileUnitAtIndex(i);
+    DWARFUnit *cu = info->GetCompileUnitAtIndex(i);
     if (cu == nullptr)
       continue;
 
     SymbolFileDWARFDwo *dwo = cu->GetDwoSymbolFile();
     if (dwo)
       dwo->GetMangledNamesForFunction(scope_qualified_name, mangled_names);
   }
 

 // then we can end up looking through all class types for a complete type and
 // never find
 // the full definition. We need to know if this attribute is supported, so we
 // determine
 // this here and cache th result. We also need to worry about the debug map
 // DWARF file
 // if we are doing darwin DWARF in .o file debugging.
 bool SymbolFileDWARF::Supports_DW_AT_APPLE_objc_complete_type(
-    DWARFCompileUnit *cu) {
+    DWARFUnit *cu) {
   if (m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolCalculate) {
     m_supports_DW_AT_APPLE_objc_complete_type = eLazyBoolNo;
     if (cu && cu->Supports_DW_AT_APPLE_objc_complete_type())
       m_supports_DW_AT_APPLE_objc_complete_type = eLazyBoolYes;
     else {
       DWARFDebugInfo *debug_info = DebugInfo();
       const uint32_t num_compile_units = GetNumCompileUnits();
       for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) {
-        DWARFCompileUnit *dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx);
+        DWARFUnit *dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx);
         if (dwarf_cu != cu &&
             dwarf_cu->Supports_DW_AT_APPLE_objc_complete_type()) {
           m_supports_DW_AT_APPLE_objc_complete_type = eLazyBoolYes;
           break;
         }
       }
     }
     if (m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolNo &&
else
       die.Clear();
   }
   return types_added;
 }
 
 size_t SymbolFileDWARF::ParseFunctionBlocks(const SymbolContext &sc) {
   assert(sc.comp_unit && sc.function);
   size_t functions_added = 0;
-  DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
+  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
   if (dwarf_cu) {
     const dw_offset_t function_die_offset = sc.function->GetID();
     DWARFDIE function_die = dwarf_cu->GetDIE(function_die_offset);
     if (function_die) {
       ParseFunctionBlocks(sc, &sc.function->GetBlock(false), function_die,
                           LLDB_INVALID_ADDRESS, 0);
     }
   }
 
   return functions_added;
 }
 
 size_t SymbolFileDWARF::ParseTypes(const SymbolContext &sc) {
   // At least a compile unit must be valid
   assert(sc.comp_unit);
   size_t types_added = 0;
-  DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
+  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
   if (dwarf_cu) {
     if (sc.function) {
       dw_offset_t function_die_offset = sc.function->GetID();
       DWARFDIE func_die = dwarf_cu->GetDIE(function_die_offset);
       if (func_die && func_die.HasChildren()) {
         types_added = ParseTypes(sc, func_die.GetFirstChild(), true, true);
       }
     } else {
if (sc.function) {
         const size_t num_variables = ParseVariables(
             sc, function_die.GetFirstChild(), func_lo_pc, true, true);
 
         // Let all blocks know they have parse all their variables
         sc.function->GetBlock(false).SetDidParseVariables(true, true);
         return num_variables;
       }
     } else if (sc.comp_unit) {
-      DWARFCompileUnit *dwarf_cu = info->GetCompileUnit(sc.comp_unit->GetID());
+      DWARFUnit *dwarf_cu = info->GetCompileUnit(sc.comp_unit->GetID());
 
       if (dwarf_cu == NULL)
         return 0;
 
       uint32_t vars_added = 0;
       VariableListSP variables(sc.comp_unit->GetVariableList(false));
 
       if (variables.get() == NULL) {

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.h

 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "SymbolFileDWARF.h"
 
 class SymbolFileDWARFDwo : public SymbolFileDWARF {
 public:
-  SymbolFileDWARFDwo(lldb::ObjectFileSP objfile, DWARFCompileUnit *dwarf_cu);
+  SymbolFileDWARFDwo(lldb::ObjectFileSP objfile, DWARFUnit *dwarf_cu);
 
   ~SymbolFileDWARFDwo() override = default;
 
-  lldb::CompUnitSP ParseCompileUnit(DWARFCompileUnit *dwarf_cu,
+  lldb::CompUnitSP ParseCompileUnit(DWARFUnit *dwarf_cu,
                                     uint32_t cu_idx) override;
 
-  DWARFCompileUnit *GetCompileUnit();
+  DWARFUnit *GetCompileUnit();
 
-  DWARFCompileUnit *
+  DWARFUnit *
   GetDWARFCompileUnit(lldb_private::CompileUnit *comp_unit) override;
 
   lldb_private::DWARFExpression::LocationListFormat
   GetLocationListFormat() const override;
 
   size_t GetObjCMethodDIEOffsets(lldb_private::ConstString class_name,
                                  DIEArray &method_die_offsets) override;
 
   lldb_private::TypeSystem *
   GetTypeSystemForLanguage(lldb::LanguageType language) override;
 
   DWARFDIE
   GetDIE(const DIERef &die_ref) override;
 
   std::unique_ptr<SymbolFileDWARFDwo>
-  GetDwoSymbolFileForCompileUnit(DWARFCompileUnit &dwarf_cu,
+  GetDwoSymbolFileForCompileUnit(DWARFUnit &dwarf_cu,
                                  const DWARFDebugInfoEntry &cu_die) override {
     return nullptr;
   }
 
-  DWARFCompileUnit *GetBaseCompileUnit() override;
+  DWARFUnit *GetBaseCompileUnit() override;
 
 protected:
   void LoadSectionData(lldb::SectionType sect_type,
                        lldb_private::DWARFDataExtractor &data) override;
 
   DIEToTypePtr &GetDIEToType() override;
 
   DIEToVariableSP &GetDIEToVariable() override;
protected:
 
   lldb::TypeSP FindCompleteObjCDefinitionTypeForDIE(
       const DWARFDIE &die, const lldb_private::ConstString &type_name,
       bool must_be_implementation) override;
 
   SymbolFileDWARF *GetBaseSymbolFile();
 
   lldb::ObjectFileSP m_obj_file_sp;
-  DWARFCompileUnit *m_base_dwarf_cu;
+  DWARFUnit *m_base_dwarf_cu;
 };
 
 #endif // SymbolFileDWARFDwo_SymbolFileDWARFDwo_h_

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.cpp

 //===-- SymbolFileDWARFDwo.cpp ----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "SymbolFileDWARFDwo.h"
 
 #include "lldb/Core/Section.h"
 #include "lldb/Expression/DWARFExpression.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/LLDBAssert.h"
 
-#include "DWARFCompileUnit.h"
+#include "DWARFUnit.h"
 #include "DWARFDebugInfo.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SymbolFileDWARFDwo::SymbolFileDWARFDwo(ObjectFileSP objfile,
-                                       DWARFCompileUnit *dwarf_cu)
+                                       DWARFUnit *dwarf_cu)
     : SymbolFileDWARF(objfile.get()), m_obj_file_sp(objfile),
       m_base_dwarf_cu(dwarf_cu) {
   SetID(((lldb::user_id_t)dwarf_cu->GetOffset()) << 32);
 }
 
 void SymbolFileDWARFDwo::LoadSectionData(lldb::SectionType sect_type,
                                          DWARFDataExtractor &data) {
   const SectionList *section_list =
if (section_sp) {
       data.Clear();
     }
   }
 
   SymbolFileDWARF::LoadSectionData(sect_type, data);
 }
 
 lldb::CompUnitSP
-SymbolFileDWARFDwo::ParseCompileUnit(DWARFCompileUnit *dwarf_cu,
+SymbolFileDWARFDwo::ParseCompileUnit(DWARFUnit *dwarf_cu,
                                      uint32_t cu_idx) {
   assert(GetCompileUnit() == dwarf_cu && "SymbolFileDWARFDwo::ParseCompileUnit "
                                          "called with incompatible compile "
                                          "unit");
   return GetBaseSymbolFile()->ParseCompileUnit(m_base_dwarf_cu, UINT32_MAX);
 }
 
-DWARFCompileUnit *SymbolFileDWARFDwo::GetCompileUnit() {
+DWARFUnit *SymbolFileDWARFDwo::GetCompileUnit() {
   // A clang module is found via a skeleton CU, but is not a proper DWO.
   // Clang modules have a .debug_info section instead of the *_dwo variant.
   if (auto *section_list = m_obj_file->GetSectionList(false))
     if (auto section_sp =
             section_list->FindSectionByType(eSectionTypeDWARFDebugInfo, true))
       if (!section_sp->GetName().GetStringRef().endswith("dwo"))
         return nullptr;
 
   // Only dwo files with 1 compile unit is supported
   if (GetNumCompileUnits() == 1)
     return DebugInfo()->GetCompileUnitAtIndex(0);
   else
     return nullptr;
 }
 
-DWARFCompileUnit *
+DWARFUnit *
 SymbolFileDWARFDwo::GetDWARFCompileUnit(lldb_private::CompileUnit *comp_unit) {
   return GetCompileUnit();
 }
 
 SymbolFileDWARF::DIEToTypePtr &SymbolFileDWARFDwo::GetDIEToType() {
   return GetBaseSymbolFile()->GetDIEToType();
 }
 

 
 lldb::TypeSP SymbolFileDWARFDwo::FindCompleteObjCDefinitionTypeForDIE(
     const DWARFDIE &die, const lldb_private::ConstString &type_name,
     bool must_be_implementation) {
   return GetBaseSymbolFile()->FindCompleteObjCDefinitionTypeForDIE(
       die, type_name, must_be_implementation);
 }
 
-DWARFCompileUnit *SymbolFileDWARFDwo::GetBaseCompileUnit() {
+DWARFUnit *SymbolFileDWARFDwo::GetBaseCompileUnit() {
   return m_base_dwarf_cu;
 }
 
 SymbolFileDWARF *SymbolFileDWARFDwo::GetBaseSymbolFile() {
   return m_base_dwarf_cu->GetSymbolFileDWARF();
 }
 
 DWARFExpression::LocationListFormat

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwoDwp.h

 // Other libraries and framework includes
 // Project includes
 #include "SymbolFileDWARFDwo.h"
 #include "SymbolFileDWARFDwp.h"
 
 class SymbolFileDWARFDwoDwp : public SymbolFileDWARFDwo {
 public:
   SymbolFileDWARFDwoDwp(SymbolFileDWARFDwp *dwp_symfile,
-                        lldb::ObjectFileSP objfile, DWARFCompileUnit *dwarf_cu,
+                        lldb::ObjectFileSP objfile, DWARFUnit *dwarf_cu,
                         uint64_t dwo_id);
 
 protected:
   void LoadSectionData(lldb::SectionType sect_type,
                        lldb_private::DWARFDataExtractor &data) override;
 
   SymbolFileDWARFDwp *m_dwp_symfile;
   uint64_t m_dwo_id;
 };
 
 #endif // SymbolFileDWARFDwoDwp_SymbolFileDWARFDwoDwp_h_

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwoDwp.cpp

 //===-- SymbolFileDWARFDwoDwp.cpp -------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "SymbolFileDWARFDwoDwp.h"
 
 #include "lldb/Core/Section.h"
 #include "lldb/Expression/DWARFExpression.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/LLDBAssert.h"
 
-#include "DWARFCompileUnit.h"
+#include "DWARFUnit.h"
 #include "DWARFDebugInfo.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SymbolFileDWARFDwoDwp::SymbolFileDWARFDwoDwp(SymbolFileDWARFDwp *dwp_symfile,
                                              ObjectFileSP objfile,
-                                             DWARFCompileUnit *dwarf_cu,
+                                             DWARFUnit *dwarf_cu,
                                              uint64_t dwo_id)
     : SymbolFileDWARFDwo(objfile, dwarf_cu), m_dwp_symfile(dwp_symfile),
       m_dwo_id(dwo_id) {}
 
 void SymbolFileDWARFDwoDwp::LoadSectionData(lldb::SectionType sect_type,
                                             DWARFDataExtractor &data) {
   if (m_dwp_symfile->LoadSectionData(m_dwo_id, sect_type, data))
     return;
 
   SymbolFileDWARF::LoadSectionData(sect_type, data);
 }

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwp.h

 #include "SymbolFileDWARFDwo.h"
 
 class SymbolFileDWARFDwp {
 public:
   static std::unique_ptr<SymbolFileDWARFDwp>
   Create(lldb::ModuleSP module_sp, const lldb_private::FileSpec &file_spec);
 
   std::unique_ptr<SymbolFileDWARFDwo>
-  GetSymbolFileForDwoId(DWARFCompileUnit *dwarf_cu, uint64_t dwo_id);
+  GetSymbolFileForDwoId(DWARFUnit *dwarf_cu, uint64_t dwo_id);
 
   bool LoadSectionData(uint64_t dwo_id, lldb::SectionType sect_type,
                        lldb_private::DWARFDataExtractor &data);
 
 private:
   explicit SymbolFileDWARFDwp(lldb::ModuleSP module_sp,
                               lldb::ObjectFileSP obj_file);
 

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwp.cpp

 }
 
 SymbolFileDWARFDwp::SymbolFileDWARFDwp(lldb::ModuleSP module_sp,
                                        lldb::ObjectFileSP obj_file)
     : m_obj_file(std::move(obj_file)), m_debug_cu_index(llvm::DW_SECT_INFO) 
 {}
 
 std::unique_ptr<SymbolFileDWARFDwo>
-SymbolFileDWARFDwp::GetSymbolFileForDwoId(DWARFCompileUnit *dwarf_cu,
+SymbolFileDWARFDwp::GetSymbolFileForDwoId(DWARFUnit *dwarf_cu,
                                           uint64_t dwo_id) {
   return std::unique_ptr<SymbolFileDWARFDwo>(
       new SymbolFileDWARFDwoDwp(this, m_obj_file, dwarf_cu, dwo_id));
 }
 
 bool SymbolFileDWARFDwp::LoadSectionData(
     uint64_t dwo_id, lldb::SectionType sect_type,
     lldb_private::DWARFDataExtractor &data) {