02/06: Finish renaming CompileUnit->Unit

[jankratochvil]

Summary

D42892 changed a lot of code to use superclass DWARFUnit instead of its subclass DWARFCompileUnit.

Finish this change more thoroughly for any *CompileUnit*->*Unit* names. Later patch will introduce DWARFTypeUnit which needs to be sometimes different from DWARFCompileUnit and it would be confusing without this renaming.

The whole patchset available for testing as: git clone -b debugtypes git://git.jankratochvil.net/lldb

[labath]

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

1767

did you clang-format the patch? It looks like this could fit on a single line now..

[JDevlieghere]

LGTM with Pavel's comment addressed.

[jankratochvil]

Thanks for the review, I have pushed it ahead of the rest of the series as it was a bit annoying to keep it updating off-trunk. And then the renaming is a correct cleanup anyway.

lldb/source/Plugins/SymbolFile/DWARF/AppleDWARFIndex.cpp

 
 void AppleDWARFIndex::GetGlobalVariables(const DWARFUnit &cu,
                                          DIEArray &offsets) {
   if (!m_apple_names_up)
     return;
 
   DWARFMappedHash::DIEInfoArray hash_data;
   if (m_apple_names_up->AppendAllDIEsInRange(
-          cu.GetOffset(), cu.GetNextCompileUnitOffset(), hash_data))
+          cu.GetOffset(), cu.GetNextUnitOffset(), hash_data))
     DWARFMappedHash::ExtractDIEArray(hash_data, offsets);
 }
 
 void AppleDWARFIndex::GetObjCMethods(ConstString class_name,
                                      DIEArray &offsets) {
   if (m_apple_objc_up)
     m_apple_objc_up->FindByName(class_name.GetStringRef(), offsets);
 }

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

DIERef::DIERef(lldb::user_id_t uid, SymbolFileDWARF *dwarf)
   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) {
         DWARFUnit *dwarf_cu =
-            debug_info->GetCompileUnitContainingDIEOffset(die_offset);
+            debug_info->GetUnitContainingDIEOffset(die_offset);
         if (dwarf_cu) {
           cu_offset = dwarf_cu->GetOffset();
           return;
         }
       }
     }
     die_offset = DW_INVALID_OFFSET;
   } else {

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

if (cu_sp->m_version == 5) {
 
     if (cu_sp->m_unit_type == llvm::dwarf::DW_UT_skeleton)
       cu_sp->m_dwo_id = debug_info.GetU64(offset_ptr);
   } else {
     abbr_offset = debug_info.GetDWARFOffset(offset_ptr);
     cu_sp->m_addr_size = debug_info.GetU8(offset_ptr);
   }
 
-  bool length_OK =
-      debug_info.ValidOffset(cu_sp->GetNextCompileUnitOffset() - 1);
+  bool length_OK = debug_info.ValidOffset(cu_sp->GetNextUnitOffset() - 1);
   bool version_OK = SymbolFileDWARF::SupportedVersion(cu_sp->m_version);
   bool abbr_offset_OK =
       dwarf2Data->get_debug_abbrev_data().ValidOffset(abbr_offset);
   bool addr_size_OK = (cu_sp->m_addr_size == 4) || (cu_sp->m_addr_size == 8);
 
   if (!length_OK)
     return llvm::make_error<llvm::object::GenericBinaryError>(
         "Invalid compile unit length");
DWARFCompileUnit::extract(SymbolFileDWARF *dwarf2Data,
   return cu_sp;
 }
 
 void DWARFCompileUnit::Dump(Stream *s) const {
   s->Printf("0x%8.8x: Compile Unit: length = 0x%8.8x, version = 0x%4.4x, "
             "abbr_offset = 0x%8.8x, addr_size = 0x%2.2x (next CU at "
             "{0x%8.8x})\n",
             m_offset, m_length, m_version, GetAbbrevOffset(), m_addr_size,
-            GetNextCompileUnitOffset());
+            GetNextUnitOffset());
 }
 
 uint32_t DWARFCompileUnit::GetHeaderByteSize() const {
   if (m_version < 5)
     return 11;
 
   switch (m_unit_type) {
   case llvm::dwarf::DW_UT_compile:

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

if (IsValid()) {
     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(
+          return DWARFDIE(dwarf->DebugInfo()->GetUnit(
                               DIERef(cu->GetOffset(), block_die->GetOffset())),
                           block_die);
       }
     }
   }
   return DWARFDIE();
 }
 

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

if (num_descriptors > 0) {
       for (uint32_t i = 0; i < num_descriptors; ++i) {
         const DWARFDebugArangeSet::Descriptor &descriptor =
             set.GetDescriptorRef(i);
         m_aranges.Append(RangeToDIE::Entry(descriptor.address,
                                            descriptor.length, cu_offset));
       }
     }
     set.Clear();
-    }
-    return llvm::ErrorSuccess();
 }
 
 void DWARFDebugAranges::Dump(Log *log) const {
   if (log == NULL)
     return;
 
   const size_t num_entries = m_aranges.GetSize();
   for (size_t i = 0; i < num_entries; ++i) {

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

typedef dw_offset_t (*Callback)(SymbolFileDWARF *dwarf2Data,
                                   DWARFUnit *cu,
                                   DWARFDebugInfoEntry *die,
                                   const dw_offset_t next_offset,
                                   const uint32_t depth, void *userData);
 
   explicit DWARFDebugInfo(lldb_private::DWARFContext &context);
   void SetDwarfData(SymbolFileDWARF *dwarf2Data);
 
-  size_t GetNumCompileUnits();
-  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);
+  size_t GetNumUnits();
+  DWARFUnit *GetUnitAtIndex(uint32_t idx);
+  DWARFUnit *GetUnit(dw_offset_t cu_offset, uint32_t *idx_ptr = NULL);
+  DWARFUnit *GetUnitContainingDIEOffset(dw_offset_t die_offset);
+  DWARFUnit *GetUnit(const DIERef &die_ref);
   DWARFDIE GetDIEForDIEOffset(dw_offset_t die_offset);
   DWARFDIE GetDIE(const DIERef &die_ref);
 
   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
   };
 
   llvm::Expected<DWARFDebugAranges &> GetCompileUnitAranges();
 
 protected:
-  static bool OffsetLessThanCompileUnitOffset(dw_offset_t offset,
-                                              const DWARFUnitSP &cu_sp);
+  static bool OffsetLessThanUnitOffset(dw_offset_t offset,
 
-  typedef std::vector<DWARFUnitSP> CompileUnitColl;
+  typedef std::vector<DWARFUnitSP> UnitColl;
 
   // Member variables
   SymbolFileDWARF *m_dwarf2Data;
   lldb_private::DWARFContext &m_context;
-  CompileUnitColl m_compile_units;
+  UnitColl m_units;
   std::unique_ptr<DWARFDebugAranges>
       m_cu_aranges_up; // A quick address to compile unit table
 
 private:
   // All parsing needs to be done partially any managed by this class as
   // accessors are called.
-  void ParseCompileUnitHeadersIfNeeded();
+  void ParseUnitHeadersIfNeeded();
 
   template<class Contains>
-  DWARFUnit *GetCompileUnitTmpl(
+  DWARFUnit *GetUnitTmpl(
       Contains contains, dw_offset_t offset, uint32_t *idx_ptr = NULL);
 
   DISALLOW_COPY_AND_ASSIGN(DWARFDebugInfo);
 };
 
 template<class Contains>
-DWARFUnit *DWARFDebugInfo::GetCompileUnitTmpl(
+DWARFUnit *DWARFDebugInfo::GetUnitTmpl(
     Contains contains, dw_offset_t offset, uint32_t *idx_ptr) {
-  ParseCompileUnitHeadersIfNeeded();
+  ParseUnitHeadersIfNeeded();
 
   DWARFUnitSP cu_sp;
 
-  // Watch out for single compile unit executable as they are pretty common
-  const size_t num_cus = m_compile_units.size();
+  // Watch out for single unit executable as they are pretty common
+  const size_t num_cus = m_units.size();
   if (num_cus == 1) {
-    if (contains(*m_compile_units[0], offset)) {
+    if (contains(*m_units[0], offset)) {
       if (idx_ptr)
         *idx_ptr = 0;
-      return m_compile_units[0].get();
+      return m_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, offset, OffsetLessThanCompileUnitOffset);
+    UnitColl::const_iterator end_pos = m_units.end();
+    UnitColl::const_iterator begin_pos = m_units.begin();
+    UnitColl::const_iterator pos = std::upper_bound(
+        begin_pos, end_pos, offset, OffsetLessThanUnitOffset);
     if (pos != begin_pos) {
       --pos;
       if (contains(**pos, offset)) {
         if (idx_ptr)
           *idx_ptr = pos - begin_pos;
         return (*pos).get();
       }
     }
   }
 
   if (idx_ptr)
     *idx_ptr = DW_INVALID_INDEX;
   return nullptr;
 }
 
 #endif // SymbolFileDWARF_DWARFDebugInfo_h_

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

 #include "DWARFFormValue.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace std;
 
 // Constructor
 DWARFDebugInfo::DWARFDebugInfo(lldb_private::DWARFContext &context)
-    : m_dwarf2Data(NULL), m_context(context), m_compile_units(),
-      m_cu_aranges_up() {}
+    : m_dwarf2Data(NULL), m_context(context), m_units(), m_cu_aranges_up() {}
 
 // SetDwarfData
 void DWARFDebugInfo::SetDwarfData(SymbolFileDWARF *dwarf2Data) {
   m_dwarf2Data = dwarf2Data;
-  m_compile_units.clear();
+  m_units.clear();
 }
 
 llvm::Expected<DWARFDebugAranges &> DWARFDebugInfo::GetCompileUnitAranges() {
   if (m_cu_aranges_up)
     return *m_cu_aranges_up;
 
   assert(m_dwarf2Data);
 
llvm::Expected<DWARFDebugAranges &> DWARFDebugInfo::GetCompileUnitAranges() {
   for (size_t n = 0; n < m_cu_aranges_up->GetNumRanges(); n++) {
     dw_offset_t offset = m_cu_aranges_up->OffsetAtIndex(n);
     if (offset != DW_INVALID_OFFSET)
       cus_with_data.insert(offset);
   }
 
   // Manually build arange data for everything that wasn't in the
   // .debug_aranges table.
-  const size_t num_compile_units = GetNumCompileUnits();
-  for (size_t idx = 0; idx < num_compile_units; ++idx) {
-    DWARFUnit *cu = GetCompileUnitAtIndex(idx);
+  const size_t num_units = GetNumUnits();
+  for (size_t idx = 0; idx < num_units; ++idx) {
+    DWARFUnit *cu = GetUnitAtIndex(idx);
 
     dw_offset_t offset = cu->GetOffset();
     if (cus_with_data.find(offset) == cus_with_data.end())
       cu->BuildAddressRangeTable(m_dwarf2Data, m_cu_aranges_up.get());
   }
 
   const bool minimize = true;
   m_cu_aranges_up->Sort(minimize);
   return *m_cu_aranges_up;
 }
 
-void DWARFDebugInfo::ParseCompileUnitHeadersIfNeeded() {
-  if (!m_compile_units.empty())
+void DWARFDebugInfo::ParseUnitHeadersIfNeeded() {
+  if (!m_units.empty())
     return;
   if (!m_dwarf2Data)
     return;
 
   lldb::offset_t offset = 0;
   const auto &debug_info_data = m_dwarf2Data->get_debug_info_data();
 
   while (debug_info_data.ValidOffset(offset)) {
     llvm::Expected<DWARFUnitSP> cu_sp =
         DWARFCompileUnit::extract(m_dwarf2Data, debug_info_data, &offset);
 
     if (!cu_sp) {
       // FIXME: Propagate this error up.
       llvm::consumeError(cu_sp.takeError());
       return;
     }
 
-    // If it didn't return an error, then it should be returning a valid
-    // CompileUnit.
+    // If it didn't return an error, then it should be returning a valid Unit.
     assert(*cu_sp);
 
-    m_compile_units.push_back(*cu_sp);
+    m_units.push_back(*cu_sp);
 
-    offset = (*cu_sp)->GetNextCompileUnitOffset();
+    offset = (*cu_sp)->GetNextUnitOffset();
   }
 }
 
-size_t DWARFDebugInfo::GetNumCompileUnits() {
-  ParseCompileUnitHeadersIfNeeded();
-  return m_compile_units.size();
+size_t DWARFDebugInfo::GetNumUnits() {
+  ParseUnitHeadersIfNeeded();
+  return m_units.size();
 }
 
-DWARFUnit *DWARFDebugInfo::GetCompileUnitAtIndex(uint32_t idx) {
+DWARFUnit *DWARFDebugInfo::GetUnitAtIndex(uint32_t idx) {
   DWARFUnit *cu = NULL;
-  if (idx < GetNumCompileUnits())
-    cu = m_compile_units[idx].get();
+  if (idx < GetNumUnits())
+    cu = m_units[idx].get();
   return cu;
 }
 
-bool DWARFDebugInfo::OffsetLessThanCompileUnitOffset(
+bool DWARFDebugInfo::OffsetLessThanUnitOffset(
     dw_offset_t offset, const DWARFUnitSP &cu_sp) {
   return offset < cu_sp->GetOffset();
 }
 
-DWARFUnit *DWARFDebugInfo::GetCompileUnit(dw_offset_t cu_offset,
-                                                 uint32_t *idx_ptr) {
-  return GetCompileUnitTmpl(
+DWARFUnit *DWARFDebugInfo::GetUnit(dw_offset_t cu_offset, uint32_t *idx_ptr) {
+  return GetUnitTmpl(
       [](const DWARFUnit &unit, dw_offset_t cu_offset) {
         return unit.GetOffset() == cu_offset;
       }, cu_offset, idx_ptr);
 }
 
-DWARFUnit *DWARFDebugInfo::GetCompileUnit(const DIERef &die_ref) {
+DWARFUnit *DWARFDebugInfo::GetUnit(const DIERef &die_ref) {
   if (die_ref.cu_offset == DW_INVALID_OFFSET)
-    return GetCompileUnitContainingDIEOffset(die_ref.die_offset);
+    return GetUnitContainingDIEOffset(die_ref.die_offset);
   else
-    return GetCompileUnit(die_ref.cu_offset);
+    return GetUnit(die_ref.cu_offset);
 }
 
 DWARFUnit *
-DWARFDebugInfo::GetCompileUnitContainingDIEOffset(dw_offset_t die_offset) {
-  return GetCompileUnitTmpl(
+DWARFDebugInfo::GetUnitContainingDIEOffset(dw_offset_t die_offset) {
+  return GetUnitTmpl(
       [](const DWARFUnit &unit, dw_offset_t die_offset) {
         return unit.ContainsDIEOffset(die_offset);
       }, die_offset);
 }
 
 DWARFDIE
 DWARFDebugInfo::GetDIEForDIEOffset(dw_offset_t die_offset) {
-  DWARFUnit *cu = GetCompileUnitContainingDIEOffset(die_offset);
+  DWARFUnit *cu = GetUnitContainingDIEOffset(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) {
-  DWARFUnit *cu = GetCompileUnit(die_ref);
+  DWARFUnit *cu = GetUnit(die_ref);
   if (cu)
     return cu->GetDIE(die_ref.die_offset);
   return DWARFDIE(); // Not found
 }
 

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

 // 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(const DWARFUnit *cu,
                                   lldb::offset_t *offset_ptr) {
   const DWARFDataExtractor &debug_info_data = cu->GetData();
   //    const DWARFDataExtractor& debug_str_data =
   //    dwarf2Data->get_debug_str_data();
-  const uint32_t cu_end_offset = cu->GetNextCompileUnitOffset();
+  const uint32_t cu_end_offset = cu->GetNextUnitOffset();
   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
   //      compile unit (0x%8.8x)", m_offset, cu_end_offset);
   if ((offset < cu_end_offset) && debug_info_data.ValidOffset(offset)) {
     m_offset = offset;
 
     const uint64_t abbr_idx = debug_info_data.GetULEB128(&offset);

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

public:
   /// In DWARF32 this is just 4 bytes
   ///
   /// \return
   ///     Byte size of the compile unit header length field
   size_t GetLengthByteSize() const { return 4; }
 
   bool ContainsDIEOffset(dw_offset_t die_offset) const {
     return die_offset >= GetFirstDIEOffset() &&
-           die_offset < GetNextCompileUnitOffset();
+           die_offset < GetNextUnitOffset();
   }
   dw_offset_t GetFirstDIEOffset() const {
     return m_offset + GetHeaderByteSize();
   }
-  dw_offset_t GetNextCompileUnitOffset() const;
+  dw_offset_t GetNextUnitOffset() const;
   // Size of the CU data (without initial length and without header).
   size_t GetDebugInfoSize() const;
   // Size of the CU data incl. header but without initial length.
   uint32_t GetLength() const { return m_length; }
   uint16_t GetVersion() const { return m_version; }
   const DWARFAbbreviationDeclarationSet *GetAbbreviations() const;
   dw_offset_t GetAbbrevOffset() const;
   uint8_t GetAddressByteSize() const { return m_addr_size; }

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

void DWARFUnit::ExtractUnitDIEIfNeeded() {
   // next compilation unit header.
   lldb::offset_t offset = GetFirstDIEOffset();
 
   // We are in our compile unit, parse starting at the offset we were told to
   // parse
   const DWARFDataExtractor &data = GetData();
   DWARFFormValue::FixedFormSizes fixed_form_sizes =
       DWARFFormValue::GetFixedFormSizesForAddressSize(GetAddressByteSize());
-  if (offset < GetNextCompileUnitOffset() &&
+  if (offset < GetNextUnitOffset() &&
       m_first_die.FastExtract(data, this, fixed_form_sizes, &offset)) {
     AddUnitDIE(m_first_die);
     return;
   }
 }
 
 // Parses a compile unit and indexes its DIEs if it hasn't already been done.
 // It will leave this compile unit extracted forever.
void DWARFUnit::ExtractDIEsRWLocked() {
 
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(
       func_cat, "%8.8x: DWARFUnit::ExtractDIEsIfNeeded()", m_offset);
 
   // Set the offset to that of the first DIE and calculate the start of the
   // next compilation unit header.
   lldb::offset_t offset = GetFirstDIEOffset();
-  lldb::offset_t next_cu_offset = GetNextCompileUnitOffset();
+  lldb::offset_t next_cu_offset = GetNextUnitOffset();
 
   DWARFDebugInfoEntry die;
 
   uint32_t depth = 0;
   // We are in our compile unit, parse starting at the offset we were told to
   // parse
   const DWARFDataExtractor &data = GetData();
   std::vector<uint32_t> die_index_stack;
lldb::user_id_t DWARFUnit::GetID() const {
   dw_offset_t local_id =
       m_base_obj_offset != DW_INVALID_OFFSET ? m_base_obj_offset : m_offset;
   if (m_dwarf)
     return DIERef(local_id, local_id).GetUID(m_dwarf);
   else
     return local_id;
 }
 
-dw_offset_t DWARFUnit::GetNextCompileUnitOffset() const {
+dw_offset_t DWARFUnit::GetNextUnitOffset() const {
   return m_offset + GetLengthByteSize() + GetLength();
 }
 
 size_t DWARFUnit::GetDebugInfoSize() const {
   return GetLengthByteSize() + GetLength() - GetHeaderByteSize();
 }
 
 const DWARFAbbreviationDeclarationSet *DWARFUnit::GetAbbreviations() const {

lldb/source/Plugins/SymbolFile/DWARF/DebugNamesDWARFIndex.cpp

DebugNamesDWARFIndex::GetUnits(const DebugNames &debug_names) {
   return result;
 }
 
 DIERef DebugNamesDWARFIndex::ToDIERef(const DebugNames::Entry &entry) {
   llvm::Optional<uint64_t> cu_offset = entry.getCUOffset();
   if (!cu_offset)
     return DIERef();
 
-  DWARFUnit *cu = m_debug_info.GetCompileUnit(*cu_offset);
+  DWARFUnit *cu = m_debug_info.GetUnit(*cu_offset);
   if (!cu)
     return DIERef();
 
   // This initializes the DWO symbol file. It's not possible for
   // GetDwoSymbolFile to call this automatically because of mutual recursion
   // between this and DWARFDebugInfoEntry::GetAttributeValue.
   cu->ExtractUnitDIEIfNeeded();
   uint64_t die_bias = cu->GetDwoSymbolFile() ? 0 : *cu_offset;
for (const DebugNames::Entry &entry :
     if (entry.tag() != DW_TAG_structure_type &&
         entry.tag() != DW_TAG_class_type)
       continue;
 
     DIERef ref = ToDIERef(entry);
     if (!ref)
       continue;
 
-    DWARFUnit *cu = m_debug_info.GetCompileUnit(ref.cu_offset);
+    DWARFUnit *cu = m_debug_info.GetUnit(ref.cu_offset);
     if (!cu || !cu->Supports_DW_AT_APPLE_objc_complete_type()) {
       incomplete_types.push_back(ref);
       continue;
     }
 
     // FIXME: We should return DWARFDIEs so we don't have to resolve it twice.
     DWARFDIE die = m_debug_info.GetDIE(ref);
     if (!die)

lldb/source/Plugins/SymbolFile/DWARF/ManualDWARFIndex.cpp

void ManualDWARFIndex::Index() {
 
   DWARFDebugInfo &debug_info = *m_debug_info;
   m_debug_info = nullptr;
 
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(func_cat, "%p", static_cast<void *>(&debug_info));
 
   std::vector<DWARFUnit *> units_to_index;
-  units_to_index.reserve(debug_info.GetNumCompileUnits());
-  for (size_t U = 0; U < debug_info.GetNumCompileUnits(); ++U) {
-    DWARFUnit *unit = debug_info.GetCompileUnitAtIndex(U);
+  units_to_index.reserve(debug_info.GetNumUnits());
+  for (size_t U = 0; U < debug_info.GetNumUnits(); ++U) {
+    DWARFUnit *unit = debug_info.GetUnitAtIndex(U);
     if (unit && m_units_to_avoid.count(unit->GetOffset()) == 0)
       units_to_index.push_back(unit);
   }
   if (units_to_index.empty())
     return;
 
   std::vector<IndexSet> sets(units_to_index.size());
 
-  // Keep memory down by clearing DIEs for any compile units if indexing
-  // caused us to load the compile unit's DIEs.
+  // Keep memory down by clearing DIEs for any units if indexing
+  // caused us to load the unit's DIEs.
   std::vector<llvm::Optional<DWARFUnit::ScopedExtractDIEs>> clear_cu_dies(
       units_to_index.size());
   auto parser_fn = [&](size_t cu_idx) {
     IndexUnit(*units_to_index[cu_idx], sets[cu_idx]);
   };
 
   auto extract_fn = [&units_to_index, &clear_cu_dies](size_t cu_idx) {
     clear_cu_dies[cu_idx] = units_to_index[cu_idx]->ExtractDIEsScoped();
   };
 
-  // Create a task runner that extracts dies for each DWARF compile unit in a
+  // Create a task runner that extracts dies for each DWARF unit in a
   // separate thread
-  // First figure out which compile units didn't have their DIEs already
+  // First figure out which units didn't have their DIEs already
   // parsed and remember this.  If no DIEs were parsed prior to this index
   // function call, we are going to want to clear the CU dies after we are
   // done indexing to make sure we don't pull in all DWARF dies, but we need
-  // to wait until all compile units have been indexed in case a DIE in one
-  // compile unit refers to another and the indexes accesses those DIEs.
+  // to wait until all units have been indexed in case a DIE in one
+  // unit refers to another and the indexes accesses those DIEs.
   TaskMapOverInt(0, units_to_index.size(), extract_fn);
 
-  // Now create a task runner that can index each DWARF compile unit in a
+  // Now create a task runner that can index each DWARF unit in a
   // separate thread so we can index quickly.
 
   TaskMapOverInt(0, units_to_index.size(), parser_fn);
 
   auto finalize_fn = [this, &sets](NameToDIE(IndexSet::*index)) {
     NameToDIE &result = m_set.*index;
     for (auto &set : sets)
       result.Append(set.*index);

 void ManualDWARFIndex::IndexUnit(DWARFUnit &unit, IndexSet &set) {
   assert(!unit.GetSymbolFileDWARF()->GetBaseCompileUnit() &&
       "DWARFUnit associated with .dwo or .dwp should not be indexed directly");
 
   Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS);
 
   if (log) {
     m_module.LogMessage(
-        log, "ManualDWARFIndex::IndexUnit for compile unit at .debug_info[0x%8.8x]",
+        log, "ManualDWARFIndex::IndexUnit for unit at .debug_info[0x%8.8x]",
         unit.GetOffset());
   }
 
   const LanguageType cu_language = unit.GetLanguageType();
   DWARFFormValue::FixedFormSizes fixed_form_sizes = unit.GetFixedFormSizes();
 
   IndexUnitImpl(unit, cu_language, fixed_form_sizes, unit.GetOffset(), set);
 
if (num_attributes > 0) {
                 // if (attributes.ExtractFormValueAtIndex(dwarf, i,
                 //                                        form_value)) {
                 //   // If we have valid block data, then we have location
                 //   // expression bytesthat are fixed (not a location list).
                 //   const uint8_t *block_data = form_value.BlockData();
                 //   if (block_data) {
                 //     uint32_t block_length = form_value.Unsigned();
                 //     if (block_length == 1 +
-                //     attributes.CompileUnitAtIndex(i)->GetAddressByteSize()) {
+                //     attributes.UnitAtIndex(i)->GetAddressByteSize()) {
                 //       if (block_data[0] == DW_OP_addr)
                 //         add_die = true;
                 //     }
                 //   }
                 // }
                 parent_die = NULL; // Terminate the while loop.
                 break;
 

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

size_t SymbolFileDWARF::GetTypes(SymbolContextScope *sc_scope,
   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(),
-             dwarf_cu->GetNextCompileUnitOffset(), type_mask, type_set);
+             dwarf_cu->GetNextUnitOffset(), type_mask, type_set);
   } else {
     DWARFDebugInfo *info = DebugInfo();
     if (info) {
-      const size_t num_cus = info->GetNumCompileUnits();
+      const size_t num_cus = info->GetNumUnits();
       for (size_t cu_idx = 0; cu_idx < num_cus; ++cu_idx) {
-        dwarf_cu = info->GetCompileUnitAtIndex(cu_idx);
+        dwarf_cu = info->GetUnitAtIndex(cu_idx);
         if (dwarf_cu) {
           GetTypes(dwarf_cu->DIE(), 0, UINT32_MAX, type_mask, type_set);
         }
       }
     }
   }
 
   std::set<CompilerType> compiler_type_set;
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
 
     DWARFUnit *dwarf_cu =
-        info->GetCompileUnit((dw_offset_t)comp_unit->GetID());
+        info->GetUnit((dw_offset_t)comp_unit->GetID());
     if (dwarf_cu && dwarf_cu->GetUserData() == NULL)
       dwarf_cu->SetUserData(comp_unit);
     return dwarf_cu;
   }
   return NULL;
 }
 
 DWARFDebugRangesBase *SymbolFileDWARF::DebugRanges() {
if (comp_unit) {
                   cu_sp->GetSupportFiles().Replace(0, cu_file_spec);
                 }
               }
 
               dwarf_cu->SetUserData(cu_sp.get());
 
               // Figure out the compile unit index if we weren't given one
               if (cu_idx == UINT32_MAX)
-                DebugInfo()->GetCompileUnit(dwarf_cu->GetOffset(), &cu_idx);
+                DebugInfo()->GetUnit(dwarf_cu->GetOffset(), &cu_idx);
 
               m_obj_file->GetModule()->GetSymbolVendor()->SetCompileUnitAtIndex(
                   cu_idx, cu_sp);
             }
           }
         }
       }
     }
   }
   return cu_sp;
 }
 
 uint32_t SymbolFileDWARF::GetNumCompileUnits() {
   DWARFDebugInfo *info = DebugInfo();
   if (info)
-    return info->GetNumCompileUnits();
+    return info->GetNumUnits();
   return 0;
 }
 
 CompUnitSP SymbolFileDWARF::ParseCompileUnitAtIndex(uint32_t cu_idx) {
   ASSERT_MODULE_LOCK(this);
   CompUnitSP cu_sp;
   DWARFDebugInfo *info = DebugInfo();
   if (info) {
-    DWARFUnit *dwarf_cu = info->GetCompileUnitAtIndex(cu_idx);
+    DWARFUnit *dwarf_cu = info->GetUnitAtIndex(cu_idx);
     if (dwarf_cu)
       cu_sp = ParseCompileUnit(dwarf_cu, cu_idx);
   }
   return cu_sp;
 }
 
 Function *SymbolFileDWARF::ParseFunction(CompileUnit &comp_unit,
                                          const DWARFDIE &die) {
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) {
-    DWARFUnit *dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx);
+    DWARFUnit *dwarf_cu = debug_info->GetUnitAtIndex(cu_idx);
 
     const DWARFBaseDIE die = dwarf_cu->GetUnitDIEOnly();
     if (die && !die.HasChildren()) {
       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) {
               sc.variable = variable;
             }
             return sc.GetResolvedMask();
           }
         }
       } else {
         uint32_t cu_idx = DW_INVALID_INDEX;
         DWARFUnit *dwarf_cu =
-            debug_info->GetCompileUnit(cu_offset, &cu_idx);
+            debug_info->GetUnit(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 &
                 (eSymbolContextFunction | eSymbolContextBlock)) {
uint32_t SymbolFileDWARF::ResolveSymbolContext(const FileSpec &file_spec,
   const uint32_t prev_size = sc_list.GetSize();
   if (resolve_scope & eSymbolContextCompUnit) {
     DWARFDebugInfo *debug_info = DebugInfo();
     if (debug_info) {
       uint32_t cu_idx;
       DWARFUnit *dwarf_cu = NULL;
 
       for (cu_idx = 0;
-           (dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx)) != NULL;
+           (dwarf_cu = debug_info->GetUnitAtIndex(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 (check_inlines || file_spec_matches_cu_file_spec) {
           SymbolContext sc(m_obj_file->GetModule());
           sc.comp_unit = GetCompUnitForDWARFCompUnit(dwarf_cu, cu_idx);

 }
 
 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();
+    num_comp_units = info->GetNumUnits();
 
   for (uint32_t i = 0; i < num_comp_units; i++) {
-    DWARFUnit *cu = info->GetCompileUnitAtIndex(i);
+    DWARFUnit *cu = info->GetUnitAtIndex(i);
     if (cu == nullptr)
       continue;
 
     SymbolFileDWARFDwo *dwo = cu->GetDwoSymbolFile();
     if (dwo)
       dwo->GetMangledNamesForFunction(scope_qualified_name, mangled_names);
   }
 
bool SymbolFileDWARF::Supports_DW_AT_APPLE_objc_complete_type(
   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) {
-        DWARFUnit *dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx);
+        DWARFUnit *dwarf_cu = debug_info->GetUnitAtIndex(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 &&
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) {
-      DWARFUnit *dwarf_cu = info->GetCompileUnit(sc.comp_unit->GetID());
+      DWARFUnit *dwarf_cu = info->GetUnit(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/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.cpp

assert(GetCompileUnit() == dwarf_cu && "SymbolFileDWARFDwo::ParseCompileUnit "
                                          "called with incompatible compile "
                                          "unit");
   return GetBaseSymbolFile()->ParseCompileUnit(m_base_dwarf_cu, UINT32_MAX);
 }
 
 DWARFUnit *SymbolFileDWARFDwo::GetCompileUnit() {
   // Only dwo files with 1 compile unit is supported
   if (GetNumCompileUnits() == 1)
-    return DebugInfo()->GetCompileUnitAtIndex(0);
+    return DebugInfo()->GetUnitAtIndex(0);
   else
     return nullptr;
 }
 
 DWARFUnit *
 SymbolFileDWARFDwo::GetDWARFCompileUnit(lldb_private::CompileUnit *comp_unit) {
   return GetCompileUnit();
 }