1 files changed, 36 insertions, 44 deletions

diff --git a/lldb/source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp b/lldb/source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp
index e809daa65f8..6d13a593c6d 100644
--- a/lldb/source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp
+++ b/lldb/source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp
@@ -104,16 +104,8 @@ DWARFFormValue::GetFixedFormSizesForAddressSize(uint8_t addr_size) {
   return FixedFormSizes();
 }
 
-DWARFFormValue::DWARFFormValue() : m_cu(NULL), m_form(0), m_value() {}
-
-DWARFFormValue::DWARFFormValue(const DWARFUnit *cu)
-    : m_cu(cu), m_form(0), m_value() {}
-
-DWARFFormValue::DWARFFormValue(const DWARFUnit *cu, dw_form_t form)
-    : m_cu(cu), m_form(form), m_value() {}
-
 void DWARFFormValue::Clear() {
-  m_cu = nullptr;
+  m_unit = nullptr;
   m_form = 0;
   m_value = ValueTypeTag();
 }
@@ -133,9 +125,9 @@ bool DWARFFormValue::ExtractValue(const DWARFDataExtractor &data,
     indirect = false;
     switch (m_form) {
     case DW_FORM_addr:
-      assert(m_cu);
+      assert(m_unit);
       m_value.value.uval =
-          data.GetMaxU64(offset_ptr, DWARFUnit::GetAddressByteSize(m_cu));
+          data.GetMaxU64(offset_ptr, DWARFUnit::GetAddressByteSize(m_unit));
       break;
     case DW_FORM_block1:
       m_value.value.uval = data.GetU8(offset_ptr);
@@ -207,9 +199,9 @@ bool DWARFFormValue::ExtractValue(const DWARFDataExtractor &data,
       m_value.value.uval = data.GetULEB128(offset_ptr);
       break;
     case DW_FORM_ref_addr:
-      assert(m_cu);
-      if (m_cu->GetVersion() <= 2)
-        ref_addr_size = m_cu->GetAddressByteSize();
+      assert(m_unit);
+      if (m_unit->GetVersion() <= 2)
+        ref_addr_size = m_unit->GetAddressByteSize();
       else
         ref_addr_size = 4;
       m_value.value.uval = data.GetMaxU64(offset_ptr, ref_addr_size);
@@ -238,13 +230,13 @@ bool DWARFFormValue::ExtractValue(const DWARFDataExtractor &data,
 
 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);
+  return DWARFFormValue::SkipValue(m_form, debug_info_data, offset_ptr, m_unit);
 }
 
 bool DWARFFormValue::SkipValue(dw_form_t form,
                                const DWARFDataExtractor &debug_info_data,
                                lldb::offset_t *offset_ptr,
-                               const DWARFUnit *cu) {
+                               const DWARFUnit *unit) {
   uint8_t ref_addr_size;
   switch (form) {
   // Blocks if inlined data that have a length field and the data bytes inlined
@@ -278,15 +270,15 @@ bool DWARFFormValue::SkipValue(dw_form_t form,
 
   // Compile unit address sized values
   case DW_FORM_addr:
-    *offset_ptr += DWARFUnit::GetAddressByteSize(cu);
+    *offset_ptr += DWARFUnit::GetAddressByteSize(unit);
     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();
+    assert(unit); // Unit must be valid for DW_FORM_ref_addr objects or we will
+                  // get this wrong
+    if (unit->GetVersion() <= 2)
+      ref_addr_size = unit->GetAddressByteSize();
     else
       ref_addr_size = 4;
     *offset_ptr += ref_addr_size;
@@ -356,7 +348,7 @@ bool DWARFFormValue::SkipValue(dw_form_t form,
   case DW_FORM_indirect: {
     dw_form_t indirect_form = debug_info_data.GetULEB128(offset_ptr);
     return DWARFFormValue::SkipValue(indirect_form, debug_info_data, offset_ptr,
-                                     cu);
+                                     unit);
   }
 
   default:
@@ -367,7 +359,7 @@ bool DWARFFormValue::SkipValue(dw_form_t form,
 
 void DWARFFormValue::Dump(Stream &s) const {
   uint64_t uvalue = Unsigned();
-  bool cu_relative_offset = false;
+  bool unit_relative_offset = false;
 
   switch (m_form) {
   case DW_FORM_addr:
@@ -444,9 +436,9 @@ void DWARFFormValue::Dump(Stream &s) const {
   } break;
 
   case DW_FORM_ref_addr: {
-    assert(m_cu); // CU must be valid for DW_FORM_ref_addr objects or we will
-                  // get this wrong
-    if (m_cu->GetVersion() <= 2)
+    assert(m_unit); // Unit must be valid for DW_FORM_ref_addr objects or we
+                    // will get this wrong
+    if (m_unit->GetVersion() <= 2)
       s.Address(uvalue, sizeof(uint64_t) * 2);
     else
       s.Address(uvalue, 4 * 2); // 4 for DWARF32, 8 for DWARF64, but we don't
@@ -454,19 +446,19 @@ void DWARFFormValue::Dump(Stream &s) const {
     break;
   }
   case DW_FORM_ref1:
-    cu_relative_offset = true;
+    unit_relative_offset = true;
     break;
   case DW_FORM_ref2:
-    cu_relative_offset = true;
+    unit_relative_offset = true;
     break;
   case DW_FORM_ref4:
-    cu_relative_offset = true;
+    unit_relative_offset = true;
     break;
   case DW_FORM_ref8:
-    cu_relative_offset = true;
+    unit_relative_offset = true;
     break;
   case DW_FORM_ref_udata:
-    cu_relative_offset = true;
+    unit_relative_offset = true;
     break;
 
   // All DW_FORM_indirect attributes should be resolved prior to calling this
@@ -481,15 +473,15 @@ void DWARFFormValue::Dump(Stream &s) const {
     break;
   }
 
-  if (cu_relative_offset) {
-    assert(m_cu); // CU must be valid for DW_FORM_ref forms that are compile
-                  // unit relative or we will get this wrong
-    s.Printf("{0x%8.8" PRIx64 "}", uvalue + m_cu->GetOffset());
+  if (unit_relative_offset) {
+    assert(m_unit); // Unit must be valid for DW_FORM_ref forms that are compile
+                    // unit relative or we will get this wrong
+    s.Printf("{0x%8.8" PRIx64 "}", uvalue + m_unit->GetOffset());
   }
 }
 
 const char *DWARFFormValue::AsCString() const {
-  SymbolFileDWARF *symbol_file = m_cu->GetSymbolFileDWARF();
+  SymbolFileDWARF *symbol_file = m_unit->GetSymbolFileDWARF();
 
   if (m_form == DW_FORM_string) {
     return m_value.value.cstr;
@@ -520,7 +512,7 @@ const char *DWARFFormValue::AsCString() const {
 
     uint32_t indexSize = 4;
     lldb::offset_t offset =
-        m_cu->GetStrOffsetsBase() + m_value.value.uval * indexSize;
+        m_unit->GetStrOffsetsBase() + m_value.value.uval * indexSize;
     dw_offset_t strOffset =
         symbol_file->get_debug_str_offsets_data().GetMaxU64(&offset, indexSize);
     return symbol_file->get_debug_str_data().PeekCStr(strOffset);
@@ -533,12 +525,12 @@ const char *DWARFFormValue::AsCString() const {
 }
 
 dw_addr_t DWARFFormValue::Address() const {
-  SymbolFileDWARF *symbol_file = m_cu->GetSymbolFileDWARF();
+  SymbolFileDWARF *symbol_file = m_unit->GetSymbolFileDWARF();
 
   if (m_form == DW_FORM_addr)
     return Unsigned();
 
-  assert(m_cu);
+  assert(m_unit);
   assert(m_form == DW_FORM_GNU_addr_index || m_form == DW_FORM_addrx ||
          m_form == DW_FORM_addrx1 || m_form == DW_FORM_addrx2 ||
          m_form == DW_FORM_addrx3 || m_form == DW_FORM_addrx4);
@@ -546,8 +538,8 @@ dw_addr_t DWARFFormValue::Address() const {
   if (!symbol_file)
     return 0;
 
-  uint32_t index_size = m_cu->GetAddressByteSize();
-  dw_offset_t addr_base = m_cu->GetAddrBase();
+  uint32_t index_size = m_unit->GetAddressByteSize();
+  dw_offset_t addr_base = m_unit->GetAddrBase();
   lldb::offset_t offset = addr_base + m_value.value.uval * index_size;
   return symbol_file->get_debug_addr_data().GetMaxU64(&offset, index_size);
 }
@@ -560,9 +552,9 @@ uint64_t DWARFFormValue::Reference() const {
   case DW_FORM_ref4:
   case DW_FORM_ref8:
   case DW_FORM_ref_udata:
-    assert(m_cu); // CU must be valid for DW_FORM_ref forms that are compile
-                  // unit relative or we will get this wrong
-    return value + m_cu->GetOffset();
+    assert(m_unit); // Unit must be valid for DW_FORM_ref forms that are compile
+                    // unit relative or we will get this wrong
+    return value + m_unit->GetOffset();
 
   case DW_FORM_ref_addr:
   case DW_FORM_ref_sig8: