Remove Support for DWARF64

[zturner]

Summary

LLVM doesn't produce DWARF64, and neither does GCC. LLDB's support for DWARF64 is only partial, and if enabled appears to also not work. It also appears to have no test coverage. Removing this makes merging LLVM and LLDB's DWARF parsing implementations simpler.

[aprantl]

LGTM, perhaps let's give this a day for others to chime in in case they missed the thread on lldb-dev.

[clayborg]

What part of parsing DWARF64 wasn't working? I think the SPARC compiler was the only one producing DWARF64. Be a shame to lose the support. What is the plan here after this patch?

[zturner]

In D59235#1425417, @clayborg wrote:

What part of parsing DWARF64 wasn't working? I think the SPARC compiler was the only one producing DWARF64.

This patch originated from a thread on lldb-dev where I asked if anyone knows the status. The first response was from @jankratochvil at Red Hat who gave this example:

IMO there isn't as for example:
lldb/source/Plugins/SymbolFile/DWARF/DIERef.cpp
is using bits 32..63 for additional info (DWO file offset/index for example)
while only bits 0..31 are used for DIE offset inside .debug_info section.

However, presumably this was identified from Jan simply looking at the code. There could be other such examples.

Be a shame to lose the support. What is the plan here after this patch?

Currently I'm doing some very preliminary investigation into merging LLVM and LLDB's DWARF parsers. Initially, I started by updating LLVM's DataExtractor class to accept size_t offsets instead of uint32_t, however that quickly grew into a very large patch.

To answer your question: I think the plan would be to first standardize on a single DWARF parser, and then if / when we decide to support DWARF64, do it in one place (and importantly, make sure it has some corresponding test coverage).

[clayborg]

My main concern with the LLVM DWARF parser is all of the asserts in the code. If you attempt to use a DWARFDIE without first checking it for validity, it will crash on you instead of returning a good error or default value. That makes me really nervous as we shouldn't just crash the debugger. The switching over won't be too hard, just the fallout from the LLDB versions of the class that do error checking and return good error/default values and LLVM being very strict.

[zturner]

In D59235#1425436, @clayborg wrote:

My main concern with the LLVM DWARF parser is all of the asserts in the code. If you attempt to use a DWARFDIE without first checking it for validity, it will crash on you instead of returning a good error or default value. That makes me really nervous as we shouldn't just crash the debugger. The switching over won't be too hard, just the fallout from the LLDB versions of the class that do error checking and return good error/default values and LLVM being very strict.

Sure, I'm prepared to deal all that appropriately. I don't plan to regress LLDB's stability in the process.

That's why for now I'm just doing very small preliminary steps to get the two interfaces to be closer to each other and simplify the problem space. We can worry about the asserts and all of that when we actually start moving pieces of LLDB to use LLVM's classes (which isn't in this patch).

[clayborg]

In D59235#1425443, @zturner wrote:

In D59235#1425436, @clayborg wrote:

My main concern with the LLVM DWARF parser is all of the asserts in the code. If you attempt to use a DWARFDIE without first checking it for validity, it will crash on you instead of returning a good error or default value. That makes me really nervous as we shouldn't just crash the debugger. The switching over won't be too hard, just the fallout from the LLDB versions of the class that do error checking and return good error/default values and LLVM being very strict.

Sure, I'm prepared to deal all that appropriately. I don't plan to regress LLDB's stability in the process.

Sounds good.

That's why for now I'm just doing very small preliminary steps to get the two interfaces to be closer to each other and simplify the problem space. We can worry about the asserts and all of that when we actually start moving pieces of LLDB to use LLVM's classes (which isn't in this patch).

I look forward to seeing this transition. I was planning on working on that right before I left Apple, but I left and didn't have the time after starting a new job. I will be happy to help review any changes as I did a lot of cleanup in the LLVM DWARF parser in preparation for the transition, so we should be in good shape.

[probinson]

In D59235#1425443, @zturner wrote:

In D59235#1425436, @clayborg wrote:

My main concern with the LLVM DWARF parser is all of the asserts in the code. If you attempt to use a DWARFDIE without first checking it for validity, it will crash on you instead of returning a good error or default value. That makes me really nervous as we shouldn't just crash the debugger. The switching over won't be too hard, just the fallout from the LLDB versions of the class that do error checking and return good error/default values and LLVM being very strict.

Sure, I'm prepared to deal all that appropriately. I don't plan to regress LLDB's stability in the process.

That's why for now I'm just doing very small preliminary steps to get the two interfaces to be closer to each other and simplify the problem space. We can worry about the asserts and all of that when we actually start moving pieces of LLDB to use LLVM's classes (which isn't in this patch).

A long term plan of moving LLVM's parser away from asserts and toward error reporting on bad input would also make the binutils that try to read DWARF more robust and useful for trying to diagnose bad object files. I'm all for it.

[jankratochvil]

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

263 ↗

(On Diff #190173)

Here should be an error that DWARF64 is not supported.

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

170 ↗

(On Diff #190173)

Delete the assert?

327 ↗

(On Diff #190173)

Delete the assert?

[zturner]

It seems like we're mostly in agreement on the direction of the patch, so if there's no outstanding comments I'll submit at the end of the day.

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

263 ↗

(On Diff #190173)

How do we report that error? This function doesn't return an error code, and neither does the function that calls it (I didn't look higher than that), and we don't build with exceptions. We can assert, but we try to avoid asserts (although admittedly, we're going to crash anyway). I can try to do more work to propagate errors up the stack, but at this point this whole file (and even most of the folder that the file is in) is in theory going to be going away soon as we converge on LLVM's DWARF parser, so it may make sense to just deal with the problem at that level.

[zturner]

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

170 ↗

(On Diff #190173)

Good catch. I'll do this (and the other one) before submitting.

[aprantl]

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

89 ↗

(On Diff #190173)

Not your code, but this application of llvm_unreachable seems suspicious unless we can guarantee that we already checked for a supported format before entering here.

[jankratochvil]

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

263 ↗

(On Diff #190173)

Just that there should be something, at least a FIXME comment.
There is dwarf2Data->GetObjectFile()->GetModule()->ReportError() but it will currently lock up since implementation of multithreaded DWARF reading. But there are AFAIK already many such errors which do not happen in realworld but they would lock up if they did. I agree returning an error value is the proper solution, I have no idea when it is the right time to implement that.

[JDevlieghere]

In D59235#1426169, @probinson wrote:

In D59235#1425443, @zturner wrote:

In D59235#1425436, @clayborg wrote:

My main concern with the LLVM DWARF parser is all of the asserts in the code. If you attempt to use a DWARFDIE without first checking it for validity, it will crash on you instead of returning a good error or default value. That makes me really nervous as we shouldn't just crash the debugger. The switching over won't be too hard, just the fallout from the LLDB versions of the class that do error checking and return good error/default values and LLVM being very strict.

Sure, I'm prepared to deal all that appropriately. I don't plan to regress LLDB's stability in the process.

That's why for now I'm just doing very small preliminary steps to get the two interfaces to be closer to each other and simplify the problem space. We can worry about the asserts and all of that when we actually start moving pieces of LLDB to use LLVM's classes (which isn't in this patch).

A long term plan of moving LLVM's parser away from asserts and toward error reporting on bad input would also make the binutils that try to read DWARF more robust and useful for trying to diagnose bad object files. I'm all for it.

Agreed, and we've been doing this for new patches for a while now. However, I very strongly prefer having asserts over "returning a default value", which only hides real bugs.

[aprantl]

In D59235#1426716, @JDevlieghere wrote:

Agreed, and we've been doing this for new patches for a while now. However, I very strongly prefer having asserts over "returning a default value", which only hides real bugs.

I think everyone is on the same page here, but it doesn't hurt to explicitly repeat this :-)

• Assertions should be used liberally to assert internal consistency and to enforce contracts in the API. Basically when you write an assertion, you should be already convinced that it will always hold.
• Assertions may never be used to handle invalid external input in a parser. Invalid external input must use error handling, expected, optional, ...

include/lldb/Core/dwarf.h

 typedef int32_t dw_sleb128_t;
 typedef uint16_t dw_attr_t;
 typedef uint16_t dw_form_t;
 typedef uint16_t dw_tag_t;
 typedef uint64_t dw_addr_t; // Dwarf address define that must be big enough for
                             // any addresses in the compile units that get
                             // parsed
 
-#ifdef DWARFUTILS_DWARF64
-#define DWARF_REF_ADDR_SIZE 8
-typedef uint64_t dw_offset_t; // Dwarf Debug Information Entry offset for any
-                              // offset into the file
-#else
-#define DWARF_REF_ADDR_SIZE 4
 typedef uint32_t dw_offset_t; // Dwarf Debug Information Entry offset for any
                               // offset into the file
-#endif
 
 /* Constants */
 #define DW_INVALID_OFFSET (~(dw_offset_t)0)
 #define DW_INVALID_INDEX 0xFFFFFFFFul
 
 // #define DW_ADDR_none 0x0
 
 #define DW_EH_PE_MASK_ENCODING 0x0F

source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp

DWARFUnitSP DWARFCompileUnit::Extract(SymbolFileDWARF *dwarf2Data,
   std::shared_ptr<DWARFCompileUnit> cu_sp(new DWARFCompileUnit(dwarf2Data));
 
   cu_sp->m_offset = *offset_ptr;
 
   if (debug_info.ValidOffset(*offset_ptr)) {
     dw_offset_t abbr_offset;
     const DWARFDebugAbbrev *abbr = dwarf2Data->DebugAbbrev();
     cu_sp->m_length = debug_info.GetDWARFInitialLength(offset_ptr);
-    cu_sp->m_is_dwarf64 = debug_info.IsDWARF64();
     cu_sp->m_version = debug_info.GetU16(offset_ptr);
 
     if (cu_sp->m_version == 5) {
       cu_sp->m_unit_type = debug_info.GetU8(offset_ptr);
       cu_sp->m_addr_size = debug_info.GetU8(offset_ptr);
       abbr_offset = debug_info.GetDWARFOffset(offset_ptr);
 
       if (cu_sp->m_unit_type == llvm::dwarf::DW_UT_skeleton)
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());
 }
 
 uint32_t DWARFCompileUnit::GetHeaderByteSize() const {
   if (m_version < 5)
-    return m_is_dwarf64 ? 23 : 11;
+    return 11;
 
   switch (m_unit_type) {
   case llvm::dwarf::DW_UT_compile:
   case llvm::dwarf::DW_UT_partial:
     return 12;
   case llvm::dwarf::DW_UT_skeleton:
   case llvm::dwarf::DW_UT_split_compile:
     return 20;

source/Plugins/SymbolFile/DWARF/DWARFDataExtractor.h

 
 #include "lldb/Core/dwarf.h"
 #include "lldb/Utility/DataExtractor.h"
 
 namespace lldb_private {
 
 class DWARFDataExtractor : public DataExtractor {
 public:
-  DWARFDataExtractor() : DataExtractor(), m_is_dwarf64(false) {}
+  DWARFDataExtractor() = default;
 
   DWARFDataExtractor(const DWARFDataExtractor &data, lldb::offset_t offset,
                      lldb::offset_t length)
-      : DataExtractor(data, offset, length), m_is_dwarf64(false) {}
+      : DataExtractor(data, offset, length) {}
 
   uint64_t GetDWARFInitialLength(lldb::offset_t *offset_ptr) const;
 
   dw_offset_t GetDWARFOffset(lldb::offset_t *offset_ptr) const;
 
-  size_t GetDWARFSizeofInitialLength() const { return m_is_dwarf64 ? 12 : 4; }
-  size_t GetDWARFSizeOfOffset() const { return m_is_dwarf64 ? 8 : 4; }
-  bool IsDWARF64() const { return m_is_dwarf64; }
-
-protected:
-  mutable bool m_is_dwarf64;
+  size_t GetDWARFSizeofInitialLength() const { return 4; }
+  size_t GetDWARFSizeOfOffset() const { return 4; }
 };
 }
 
 #endif // liblldb_DWARFDataExtractor_h_

source/Plugins/SymbolFile/DWARF/DWARFDataExtractor.cpp

 //===-- DWARFDataExtractor.cpp ----------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "DWARFDataExtractor.h"
 
 namespace lldb_private {
 
 uint64_t
 DWARFDataExtractor::GetDWARFInitialLength(lldb::offset_t *offset_ptr) const {
-  uint64_t length = GetU32(offset_ptr);
-  m_is_dwarf64 = (length == UINT32_MAX);
-  if (m_is_dwarf64)
-    length = GetU64(offset_ptr);
-  return length;
+  return GetU32(offset_ptr);
 }
 
 dw_offset_t
 DWARFDataExtractor::GetDWARFOffset(lldb::offset_t *offset_ptr) const {
   return GetMaxU64(offset_ptr, GetDWARFSizeOfOffset());
 }
 }

source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

for (i = 0; i < numAttributes; ++i) {
           // Compile unit address sized values
           case DW_FORM_addr:
             form_size = cu->GetAddressByteSize();
             break;
           case DW_FORM_ref_addr:
             if (cu->GetVersion() <= 2)
               form_size = cu->GetAddressByteSize();
             else
-              form_size = cu->IsDWARF64() ? 8 : 4;
+              form_size = 4;
             break;
 
           // 0 sized form
           case DW_FORM_flag_present:
             form_size = 0;
             break;
 
           // 1 byte values
for (i = 0; i < numAttributes; ++i) {
 
           case DW_FORM_indirect:
             form_is_indirect = true;
             form = debug_info_data.GetULEB128(&offset);
             break;
 
           case DW_FORM_strp:
           case DW_FORM_sec_offset:
-            if (cu->IsDWARF64())
-              debug_info_data.GetU64(&offset);
-            else
-              debug_info_data.GetU32(&offset);
             break;
 
           case DW_FORM_implicit_const:
             form_size = 0;
             break;
 
           default:
             *offset_ptr = m_offset;
if (abbr_idx) {
               // Compile unit address sized values
               case DW_FORM_addr:
                 form_size = cu->GetAddressByteSize();
                 break;
               case DW_FORM_ref_addr:
                 if (cu->GetVersion() <= 2)
                   form_size = cu->GetAddressByteSize();
                 else
-                  form_size = cu->IsDWARF64() ? 8 : 4;
+                  form_size = 4;
                 break;
 
               // 0 sized form
               case DW_FORM_flag_present:
               case DW_FORM_implicit_const:
                 form_size = 0;
                 break;
 
if (abbr_idx) {
 
               case DW_FORM_indirect:
                 form = debug_info_data.GetULEB128(&offset);
                 form_is_indirect = true;
                 break;
 
               case DW_FORM_strp:
               case DW_FORM_sec_offset:
-                if (cu->IsDWARF64())
-                  debug_info_data.GetU64(&offset);
-                else
-                  debug_info_data.GetU32(&offset);
                 break;
 
               default:
                 *offset_ptr = offset;
                 return false;
               }
 
               offset += form_size;
if (cu) {
     abbrevDecl = GetAbbreviationDeclarationPtr(dwarf2Data, cu, offset);
   }
 
   if (abbrevDecl) {
     const DWARFDataExtractor &debug_info_data = cu->GetData();
 
     if (fixed_form_sizes.Empty())
       fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize(
-          cu->GetAddressByteSize(), cu->IsDWARF64());
+          cu->GetAddressByteSize());
 
     const uint32_t num_attributes = abbrevDecl->NumAttributes();
     for (uint32_t i = 0; i < num_attributes; ++i) {
       DWARFFormValue form_value(cu);
       dw_attr_t attr;
       abbrevDecl->GetAttrAndFormValueByIndex(i, attr, form_value);
       const dw_form_t form = form_value.Form();
 

source/Plugins/SymbolFile/DWARF/DWARFDebugRanges.cpp

bool DWARFDebugRngLists::FindRanges(const DWARFUnit *cu,
   return false;
 }
 
 void DWARFDebugRngLists::Extract(SymbolFileDWARF *dwarf2Data) {
   const DWARFDataExtractor &data = dwarf2Data->get_debug_rnglists_data();
   lldb::offset_t offset = 0;
 
   uint64_t length = data.GetU32(&offset);
-  bool isDwarf64 = (length == 0xffffffff);
-  if (isDwarf64)
-    length = data.GetU64(&offset);
+  // FIXME: Handle DWARF64.
   lldb::offset_t end = offset + length;
 
   // Check version.
   if (data.GetU16(&offset) < 5)
     return;
 
   uint8_t addrSize = data.GetU8(&offset);
 
   // We do not support non-zero segment selector size.
   if (data.GetU8(&offset) != 0) {
     lldbassert(0 && "not implemented");
     return;
   }
 
   uint32_t offsetsAmount = data.GetU32(&offset);
   for (uint32_t i = 0; i < offsetsAmount; ++i)
-    Offsets.push_back(data.GetMaxU64(&offset, isDwarf64 ? 8 : 4));
+    Offsets.push_back(data.GetMaxU64(&offset, 4));
 
   lldb::offset_t listOffset = offset;
   std::vector<RngListEntry> rangeList;
   while (offset < end && ExtractRangeList(data, addrSize, &offset, rangeList)) {
     m_range_map[listOffset] = rangeList;
     listOffset = offset;
   }
 }
 
 uint64_t DWARFDebugRngLists::GetOffset(size_t Index) const {
   return Offsets[Index];
 }

source/Plugins/SymbolFile/DWARF/DWARFFormValue.h

public:
   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 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 FixedFormSizes GetFixedFormSizesForAddressSize(uint8_t addr_size);
   static int Compare(const DWARFFormValue &a, const DWARFFormValue &b);
   void Clear();
   static bool FormIsSupported(dw_form_t form);
 
 protected:
   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_

source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp

static uint8_t g_form_sizes_addr8[] = {
     0, // 0x1b
     0, // 0x1c
     0, // 0x1d
     0, // 0x1e
     0, // 0x1f
     8, // 0x20 DW_FORM_ref_sig8
 };
 
-// Difference with g_form_sizes_addr8:
-// DW_FORM_strp and DW_FORM_sec_offset are 8 instead of 4
-static uint8_t g_form_sizes_addr8_dwarf64[] = {
-    0, // 0x00 unused
-    8, // 0x01 DW_FORM_addr
-    0, // 0x02 unused
-    0, // 0x03 DW_FORM_block2
-    0, // 0x04 DW_FORM_block4
-    2, // 0x05 DW_FORM_data2
-    4, // 0x06 DW_FORM_data4
-    8, // 0x07 DW_FORM_data8
-    0, // 0x08 DW_FORM_string
-    0, // 0x09 DW_FORM_block
-    0, // 0x0a DW_FORM_block1
-    1, // 0x0b DW_FORM_data1
-    1, // 0x0c DW_FORM_flag
-    0, // 0x0d DW_FORM_sdata
-    8, // 0x0e DW_FORM_strp
-    0, // 0x0f DW_FORM_udata
-    0, // 0x10 DW_FORM_ref_addr (addr size for DWARF2 and earlier, 4 bytes for
-       // DWARF32, 8 bytes for DWARF32 in DWARF 3 and later
-    1, // 0x11 DW_FORM_ref1
-    2, // 0x12 DW_FORM_ref2
-    4, // 0x13 DW_FORM_ref4
-    8, // 0x14 DW_FORM_ref8
-    0, // 0x15 DW_FORM_ref_udata
-    0, // 0x16 DW_FORM_indirect
-    8, // 0x17 DW_FORM_sec_offset
-    0, // 0x18 DW_FORM_exprloc
-    0, // 0x19 DW_FORM_flag_present
-    0, // 0x1a
-    0, // 0x1b
-    0, // 0x1c
-    0, // 0x1d
-    0, // 0x1e
-    0, // 0x1f
-    8, // 0x20 DW_FORM_ref_sig8
-};
-
 DWARFFormValue::FixedFormSizes
-DWARFFormValue::GetFixedFormSizesForAddressSize(uint8_t addr_size,
-                                                bool is_dwarf64) {
-  if (!is_dwarf64) {
-    switch (addr_size) {
-    case 4:
-      return FixedFormSizes(g_form_sizes_addr4, sizeof(g_form_sizes_addr4));
-    case 8:
-      return FixedFormSizes(g_form_sizes_addr8, sizeof(g_form_sizes_addr8));
-    }
-  } else {
-    if (addr_size == 8)
-      return FixedFormSizes(g_form_sizes_addr8_dwarf64,
-                            sizeof(g_form_sizes_addr8_dwarf64));
-    // is_dwarf64 && addr_size == 4 : no provider does this.
-  }
+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() {}
 
case DW_FORM_string:
       m_value.value.cstr = data.GetCStr(offset_ptr);
       break;
     case DW_FORM_sdata:
       m_value.value.sval = data.GetSLEB128(offset_ptr);
       break;
     case DW_FORM_strp:
     case DW_FORM_line_strp:
     case DW_FORM_sec_offset:
-      assert(m_cu);
-      m_value.value.uval =
-          data.GetMaxU64(offset_ptr, DWARFUnit::IsDWARF64(m_cu) ? 8 : 4);
+      m_value.value.uval = data.GetMaxU64(offset_ptr, 4);
       break;
     case DW_FORM_addrx1:
     case DW_FORM_strx1:
     case DW_FORM_ref1:
     case DW_FORM_data1:
     case DW_FORM_flag:
       m_value.value.uval = data.GetU8(offset_ptr);
       break;
do {
     case DW_FORM_GNU_addr_index:
       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();
       else
-        ref_addr_size = m_cu->IsDWARF64() ? 8 : 4;
+        ref_addr_size = 4;
       m_value.value.uval = data.GetMaxU64(offset_ptr, ref_addr_size);
       break;
     case DW_FORM_indirect:
       m_form = data.GetULEB128(offset_ptr);
       indirect = true;
       break;
     case DW_FORM_flag_present:
       m_value.value.uval = 1;
bool DWARFFormValue::SkipValue(dw_form_t form,
 
   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();
     else
-      ref_addr_size = cu->IsDWARF64() ? 8 : 4;
+      ref_addr_size = 4;
     *offset_ptr += ref_addr_size;
     return true;
 
   // 0 bytes values (implied from DW_FORM)
   case DW_FORM_flag_present:
   case DW_FORM_implicit_const:
     return true;
 
case DW_FORM_implicit_const:
     case DW_FORM_addrx3:
     case DW_FORM_strx3:
       *offset_ptr += 3;
       return true;
 
     // 32 bit for DWARF 32, 64 for DWARF 64
     case DW_FORM_sec_offset:
     case DW_FORM_strp:
-      assert(cu);
-      *offset_ptr += (cu->IsDWARF64() ? 8 : 4);
+      *offset_ptr += 4;
       return true;
 
     // 4 byte values
     case DW_FORM_addrx4:
     case DW_FORM_data4:
     case DW_FORM_ref4:
     case DW_FORM_strx4:
       *offset_ptr += 4;
if (m_form == DW_FORM_string) {
     if (!symbol_file)
       return nullptr;
 
     return symbol_file->get_debug_str_data().PeekCStr(m_value.value.uval);
   } else if (m_form == DW_FORM_GNU_str_index) {
     if (!symbol_file)
       return nullptr;
 
-    uint32_t index_size = m_cu->IsDWARF64() ? 8 : 4;
+    uint32_t index_size = 4;
     lldb::offset_t offset = m_value.value.uval * index_size;
     dw_offset_t str_offset =
         symbol_file->get_debug_str_offsets_data().GetMaxU64(&offset,
                                                             index_size);
     return symbol_file->get_debug_str_data().PeekCStr(str_offset);
   }
 
   if (m_form == DW_FORM_strx || m_form == DW_FORM_strx1 ||
       m_form == DW_FORM_strx2 || m_form == DW_FORM_strx3 ||
       m_form == DW_FORM_strx4) {
 
     // The same code as above.
     if (!symbol_file)
       return nullptr;
 
-    uint32_t indexSize = m_cu->IsDWARF64() ? 8 : 4;
+    uint32_t indexSize = 4;
     lldb::offset_t offset =
         m_cu->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);
   }
 
   if (m_form == DW_FORM_line_strp)

source/Plugins/SymbolFile/DWARF/DWARFUnit.h

public:
   //------------------------------------------------------------------
   virtual uint32_t GetHeaderByteSize() const = 0;
   // Offset of the initial length field.
   dw_offset_t GetOffset() const { return m_offset; }
   lldb::user_id_t GetID() const;
   //------------------------------------------------------------------
   /// Get the size in bytes of the length field in the header.
   ///
-  /// In DWARF32 this is just 4 bytes, and DWARF64 it is 12 where 4
-  /// are 0xFFFFFFFF followed by the actual 64 bit length.
+  /// In DWARF32 this is just 4 bytes
   ///
   /// \return
   ///     Byte size of the compile unit header length field
   //------------------------------------------------------------------
-  size_t GetLengthByteSize() const { return IsDWARF64() ? 12 : 4; }
-  
+  size_t GetLengthByteSize() const { return 4; }
   bool ContainsDIEOffset(dw_offset_t die_offset) const {
     return die_offset >= GetFirstDIEOffset() &&
            die_offset < GetNextCompileUnitOffset();
   }
   dw_offset_t GetFirstDIEOffset() const {
     return m_offset + GetHeaderByteSize();
   }
   dw_offset_t GetNextCompileUnitOffset() const;
public:
   DWARFBaseDIE GetUnitDIEOnly() { return DWARFDIE(this, GetUnitDIEPtrOnly()); }
 
   DWARFDIE DIE() { return DWARFDIE(this, DIEPtr()); }
 
   DWARFDIE GetDIE(dw_offset_t die_offset);
 
   static uint8_t GetAddressByteSize(const DWARFUnit *cu);
 
-  static bool IsDWARF64(const DWARFUnit *cu);
-
   static uint8_t GetDefaultAddressSize();
 
   void *GetUserData() const;
 
   void SetUserData(void *d);
 
   bool Supports_DW_AT_APPLE_objc_complete_type();
 
public:
   uint32_t GetProducerVersionMinor();
 
   uint32_t GetProducerVersionUpdate();
 
   static lldb::LanguageType LanguageTypeFromDWARF(uint64_t val);
 
   lldb::LanguageType GetLanguageType();
 
-  bool IsDWARF64() const { return m_is_dwarf64; }
-
   bool GetIsOptimized();
 
   const lldb_private::FileSpec &GetCompilationDirectory();
   lldb_private::FileSpec::Style GetPathStyle();
 
   SymbolFileDWARFDwo *GetDwoSymbolFile() const;
 
   dw_offset_t GetBaseObjOffset() const;
protected:
   uint8_t m_addr_size = 0;
   uint8_t m_unit_type = 0;
   uint64_t m_dwo_id = 0;
   DWARFProducer m_producer = eProducerInvalid;
   uint32_t m_producer_version_major = 0;
   uint32_t m_producer_version_minor = 0;
   uint32_t m_producer_version_update = 0;
   lldb::LanguageType m_language_type = lldb::eLanguageTypeUnknown;
-  bool m_is_dwarf64 = false;
   lldb_private::LazyBool m_is_optimized = lldb_private::eLazyBoolCalculate;
   llvm::Optional<lldb_private::FileSpec> m_comp_dir;
   dw_addr_t m_addr_base = 0;   // Value of DW_AT_addr_base
   dw_addr_t m_ranges_base = 0; // Value of DW_AT_ranges_base
   // If this is a dwo compile unit this is the offset of the base compile unit
   // in the main object file
   dw_offset_t m_base_obj_offset = DW_INVALID_OFFSET;
   dw_offset_t m_str_offsets_base = 0; // Value of DW_AT_str_offsets_base.

source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

void DWARFUnit::ExtractUnitDIEIfNeeded() {
   // Set the offset to that of the first DIE and calculate the start of the
   // 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(),
-                                                      IsDWARF64());
+      DWARFFormValue::GetFixedFormSizesForAddressSize(GetAddressByteSize());
   if (offset < GetNextCompileUnitOffset() &&
       m_first_die.FastExtract(data, this, fixed_form_sizes, &offset)) {
     AddUnitDIE(m_first_die);
     return;
   }
 
   ExtractDIEsEndCheck(offset);
 }
void DWARFUnit::ExtractDIEsRWLocked() {
   // 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;
   die_index_stack.reserve(32);
   die_index_stack.push_back(0);
   bool prev_die_had_children = false;
   DWARFFormValue::FixedFormSizes fixed_form_sizes =
-      DWARFFormValue::GetFixedFormSizesForAddressSize(GetAddressByteSize(),
-                                                      IsDWARF64());
+      DWARFFormValue::GetFixedFormSizesForAddressSize(GetAddressByteSize());
   while (offset < next_cu_offset &&
          die.FastExtract(data, this, fixed_form_sizes, &offset)) {
     const bool null_die = die.IsNULL();
     if (depth == 0) {
       assert(m_die_array.empty() && "Compile unit DIE already added");
 
       // The average bytes per DIE entry has been seen to be around 14-20 so
       // lets pre-reserve half of that since we are now stripping the NULL

 TypeSystem *DWARFUnit::GetTypeSystem() {
   if (m_dwarf)
     return m_dwarf->GetTypeSystemForLanguage(GetLanguageType());
   else
     return nullptr;
 }
 
 DWARFFormValue::FixedFormSizes DWARFUnit::GetFixedFormSizes() {
-  return DWARFFormValue::GetFixedFormSizesForAddressSize(GetAddressByteSize(),
-                                                         IsDWARF64());
+  return DWARFFormValue::GetFixedFormSizesForAddressSize(GetAddressByteSize());
 }
 
 void DWARFUnit::SetBaseAddress(dw_addr_t base_addr) { m_base_addr = base_addr; }
 
 //----------------------------------------------------------------------
 // Compare function DWARFDebugAranges::Range structures
 //----------------------------------------------------------------------
 static bool CompareDIEOffset(const DWARFDebugInfoEntry &die,

 }
 
 uint8_t DWARFUnit::GetAddressByteSize(const DWARFUnit *cu) {
   if (cu)
     return cu->GetAddressByteSize();
   return DWARFUnit::GetDefaultAddressSize();
 }
 
-bool DWARFUnit::IsDWARF64(const DWARFUnit *cu) {
-  if (cu)
-    return cu->IsDWARF64();
-  return false;
-}
-
 uint8_t DWARFUnit::GetDefaultAddressSize() { return 4; }
 
 void *DWARFUnit::GetUserData() const { return m_user_data; }
 
 void DWARFUnit::SetUserData(void *d) {
   m_user_data = d;
   if (m_dwo_symbol_file)
     m_dwo_symbol_file->GetCompileUnit()->SetUserData(d);

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

if (num_attributes > 0) {
                     form_value.BlockData() - debug_info_data.GetDataStart();
                 uint32_t block_length = form_value.Unsigned();
                 location.CopyOpcodeData(module, debug_info_data, block_offset,
                                         block_length);
               } else if (DWARFFormValue::IsDataForm(form_value.Form())) {
                 // Retrieve the value as a data expression.
                 DWARFFormValue::FixedFormSizes fixed_form_sizes =
                     DWARFFormValue::GetFixedFormSizesForAddressSize(
-                        attributes.CompileUnitAtIndex(i)->GetAddressByteSize(),
-                        attributes.CompileUnitAtIndex(i)->IsDWARF64());
+                        attributes.CompileUnitAtIndex(i)->GetAddressByteSize());
                 uint32_t data_offset = attributes.DIEOffsetAtIndex(i);
                 uint32_t data_length =
                     fixed_form_sizes.GetSize(form_value.Form());
                 if (data_length == 0) {
                   const uint8_t *data_pointer = form_value.BlockData();
                   if (data_pointer) {
                     form_value.Unsigned();
                   } else if (DWARFFormValue::IsDataForm(form_value.Form())) {
                     // we need to get the byte size of the type later after we
                     // create the variable
                     const_value = form_value;
                   }
                 } else
                   location.CopyOpcodeData(module, debug_info_data, data_offset,
                                           data_length);
               } else {
                 // Retrieve the value as a string expression.
                 if (form_value.Form() == DW_FORM_strp) {
                   DWARFFormValue::FixedFormSizes fixed_form_sizes =
                       DWARFFormValue::GetFixedFormSizesForAddressSize(
                           attributes.CompileUnitAtIndex(i)
-                              ->GetAddressByteSize(),
-                          attributes.CompileUnitAtIndex(i)->IsDWARF64());
+                              ->GetAddressByteSize());
                   uint32_t data_offset = attributes.DIEOffsetAtIndex(i);
                   uint32_t data_length =
                       fixed_form_sizes.GetSize(form_value.Form());
                   location.CopyOpcodeData(module, debug_info_data, data_offset,
                                           data_length);
                 } else {
                   const char *str = form_value.AsCString();
                   uint32_t string_offset =