[SymbolFileDWARF] Replace FixedFormSizes with llvm::dwarf::getFixedFormByteSize

[labath]

Summary

The llvm function is practically a drop-in replacement. There may be
slight differences in performance as the llvm version uses a switch
whereas our version used a lookup table, but I can't say which way that
will go. (In practice, the compiler will also turn the switch into a jump
table.)

The thing we definitely gain by this is support for new forms that
haven't been added to our tables (e.g. DW_FORM_data16) and the ability
to represent forms of size 0 like DW_FORM_implicit_const (which we
couldn't represent because we used 0 to mean "size unknown"). The thing
we definitely lose is 150 lines of code.

[clayborg]

Looks fine. It would be nice to verify that there are no performance regressions due to this before making this change. Can you do some timings to make sure? Do anything that indexes a large C++ DWARF codebase, like clang, and make sure we don't regress by a significant amount.

source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

765–766

formatting?

[labath]

Hmm... how much is a "significant"? I tried time optimized/lldb --file debug/clang -o "br set -n dump" as a benchmark and I saw a 2-3% slowdown (the variance between individual samples is ~1%, so this is statistically significant).

I tried playing around with this, and I was able to get about 1% speedup (borderline significant) by changing the llvm's implementation to a lookup table (presumably, the speedup comes from the fact that the llvm version handles more forms, most likely the ones whose size is dwarf-version-dependent). However, this required making some non-llvm-y changes like ditching llvm::Optional as a return type, as that saved a couple of instructions (I should probably double check that with a top-of-tree compiler, to see if it can optimize it better).

[clayborg]

I would like to not lose any performance if possible.

[labath]

I'm not sure my benchmark strategy is correct here. I'm getting different (but consistent) results even after making changes that should not impact performance at all (e.g. because I change the code which is not executed). I'll abandon this until I find some time to benchmark this properly.

source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp

size_t DWARFCompileUnit::ExtractDIEsIfNeeded(bool cu_die_only) {
   // We are in our compile unit, parse starting at the offset
   // we were told to parse
   const DWARFDataExtractor &debug_info_data =
       m_dwarf2Data->get_debug_info_data();
   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(),
-                                                      m_is_dwarf64);
+  llvm::dwarf::FormParams form_params = GetFormParams();
   while (offset < next_cu_offset &&
-         die.FastExtract(debug_info_data, this, fixed_form_sizes, &offset)) {
+         die.FastExtract(debug_info_data, this, form_params, &offset)) {
     //        if (log)
     //            log->Printf("0x%8.8x: %*.*s%s%s",
     //                        die.GetOffset(),
     //                        depth * 2, depth * 2, "",
     //                        DW_TAG_value_to_name (die.Tag()),
     //                        die.HasChildren() ? " *" : "");
 
     const bool null_die = die.IsNULL();

source/Plugins/SymbolFile/DWARF/DWARFDIE.cpp

 }
 
 bool DWARFDIE::Supports_DW_AT_APPLE_objc_complete_type() const {
   return IsValid() && GetDWARF()->Supports_DW_AT_APPLE_objc_complete_type(m_cu);
 }
 
 size_t DWARFDIE::GetAttributes(DWARFAttributes &attributes,
                                uint32_t depth) const {
-  if (IsValid()) {
-    return m_die->GetAttributes(m_cu, m_cu->GetFixedFormSizes(), attributes,
-                                depth);
-  }
+  if (IsValid())
+    return m_die->GetAttributes(m_cu, m_cu->GetFormParams(), attributes, depth);
   if (depth == 0)
     attributes.Clear();
   return 0;
 }
 
 bool DWARFDIE::GetDIENamesAndRanges(
     const char *&name, const char *&mangled, DWARFRangeList &ranges,
     int &decl_file, int &decl_line, int &decl_column, int &call_file,

source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.h

void BuildAddressRangeTable(SymbolFileDWARF *dwarf2Data,
                               DWARFDebugAranges *debug_aranges) const;
 
   void BuildFunctionAddressRangeTable(SymbolFileDWARF *dwarf2Data,
                                       const DWARFUnit *cu,
                                       DWARFDebugAranges *debug_aranges) const;
 
   bool FastExtract(const lldb_private::DWARFDataExtractor &debug_info_data,
                    const DWARFUnit *cu,
-                   const DWARFFormValue::FixedFormSizes &fixed_form_sizes,
+                   llvm::dwarf::FormParams form_params,
                    lldb::offset_t *offset_ptr);
 
   bool Extract(SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
                lldb::offset_t *offset_ptr);
 
   bool LookupAddress(const dw_addr_t address, SymbolFileDWARF *dwarf2Data,
                      const DWARFUnit *cu,
                      DWARFDebugInfoEntry **function_die,
                      DWARFDebugInfoEntry **block_die);
 
   size_t GetAttributes(const DWARFUnit *cu,
-                       DWARFFormValue::FixedFormSizes fixed_form_sizes,
+                       llvm::dwarf::FormParams form_params,
                        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 DWARFUnit *cu,
                     const dw_attr_t attr, DWARFFormValue &formValue,
                     dw_offset_t *end_attr_offset_ptr = nullptr,

source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

 #include "SymbolFileDWARFDwo.h"
 
 using namespace lldb_private;
 using namespace std;
 extern int g_verbose;
 
 bool DWARFDebugInfoEntry::FastExtract(
     const DWARFDataExtractor &debug_info_data, const DWARFUnit *cu,
-    const DWARFFormValue::FixedFormSizes &fixed_form_sizes,
+                                      llvm::dwarf::FormParams form_params,
     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));
   m_abbr_idx = abbr_idx;
 
-  // assert (fixed_form_sizes);  // For best performance this should be
-  // specified!
-
   if (m_abbr_idx) {
     lldb::offset_t offset = *offset_ptr;
 
     const DWARFAbbreviationDeclaration *abbrevDecl =
         cu->GetAbbreviations()->GetAbbreviationDeclaration(m_abbr_idx);
 
     if (abbrevDecl == NULL) {
       cu->GetSymbolFileDWARF()->GetObjectFile()->GetModule()->ReportError(
           "{0x%8.8x}: invalid abbreviation code %u, please file a bug and "
           "attach the file at the start of this error message",
           m_offset, (unsigned)abbr_idx);
       // WE can't parse anymore if the DWARF is borked...
       *offset_ptr = UINT32_MAX;
       return false;
     }
     m_tag = abbrevDecl->Tag();
     m_has_children = abbrevDecl->HasChildren();
     // Skip all data in the .debug_info for the attributes
     const uint32_t numAttributes = abbrevDecl->NumAttributes();
     uint32_t i;
     dw_form_t form;
     for (i = 0; i < numAttributes; ++i) {
       form = abbrevDecl->GetFormByIndexUnchecked(i);
 
-      const uint8_t fixed_skip_size = fixed_form_sizes.GetSize(form);
-      if (fixed_skip_size)
-        offset += fixed_skip_size;
+      if (llvm::Optional<uint8_t> fixed_skip_size =
+              llvm::dwarf::getFixedFormByteSize(llvm::dwarf::Form(form),
+                                                form_params))
+        offset += *fixed_skip_size;
       else {
         bool form_is_indirect = false;
         do {
           form_is_indirect = false;
           uint32_t form_size = 0;
           switch (form) {
           // Blocks if inlined data that have a length field and the data bytes
           // inlined in the .debug_info

 
 //----------------------------------------------------------------------
 // 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 DWARFUnit *cu, DWARFFormValue::FixedFormSizes fixed_form_sizes,
+    const DWARFUnit *cu,
+                                          llvm::dwarf::FormParams form_params,
     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)
-        return GetAttributes(dwo_symbol_file->GetCompileUnit(),
-                             fixed_form_sizes, attributes, curr_depth);
+        return GetAttributes(dwo_symbol_file->GetCompileUnit(), form_params,
+                             attributes, curr_depth);
     }
 
     dwarf2Data = cu->GetSymbolFileDWARF();
     abbrevDecl = GetAbbreviationDeclarationPtr(dwarf2Data, cu, offset);
   }
 
   if (abbrevDecl) {
     const DWARFDataExtractor &debug_info_data =
         dwarf2Data->get_debug_info_data();
 
-    if (fixed_form_sizes.Empty())
-      fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize(
-          cu->GetAddressByteSize(), cu->IsDWARF64());
+    if (!form_params)
+      form_params = cu->GetFormParams();
 
     const uint32_t num_attributes = abbrevDecl->NumAttributes();
     uint32_t i;
     dw_attr_t attr;
     dw_form_t form;
     for (i = 0; i < num_attributes; ++i) {
       abbrevDecl->GetAttrAndFormByIndexUnchecked(i, attr, form);
 
for (i = 0; i < num_attributes; ++i) {
         if (form_value.ExtractValue(debug_info_data, &offset)) {
           dw_offset_t die_offset = form_value.Reference();
           DWARFDIE spec_die =
               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;
+        if (llvm::Optional<uint8_t> fixed_skip_size =
+                llvm::dwarf::getFixedFormByteSize(llvm::dwarf::Form(form),
+                                                  form_params))
+          offset += *fixed_skip_size;
         else
           DWARFFormValue::SkipValue(form, debug_info_data, &offset, cu);
       }
     }
   } else {
     attributes.Clear();
   }
   return attributes.Size();
bool DWARFDebugInfoEntry::MatchesDWARFDeclContext(
   GetDWARFDeclContext(dwarf2Data, cu, this_dwarf_decl_ctx);
   return this_dwarf_decl_ctx == dwarf_decl_ctx;
 }
 
 DWARFDIE
 DWARFDebugInfoEntry::GetParentDeclContextDIE(SymbolFileDWARF *dwarf2Data,
                                              DWARFUnit *cu) const {
   DWARFAttributes attributes;
-  GetAttributes(cu, DWARFFormValue::FixedFormSizes(), attributes);
+  GetAttributes(cu, llvm::dwarf::FormParams{0, 0, llvm::dwarf::DWARF32},
+                attributes);
   return GetParentDeclContextDIE(dwarf2Data, cu, attributes);
 }
 
 DWARFDIE
 DWARFDebugInfoEntry::GetParentDeclContextDIE(
     SymbolFileDWARF *dwarf2Data, DWARFUnit *cu,
     const DWARFAttributes &attributes) const {
   DWARFDIE die(cu, const_cast<DWARFDebugInfoEntry *>(this));
DWARFDebugInfoEntry::GetParentDeclContextDIE(
   }
   return DWARFDIE();
 }
 
 const char *DWARFDebugInfoEntry::GetQualifiedName(SymbolFileDWARF *dwarf2Data,
                                                   DWARFUnit *cu,
                                                   std::string &storage) const {
   DWARFAttributes attributes;
-  GetAttributes(cu, DWARFFormValue::FixedFormSizes(), attributes);
+  GetAttributes(cu, llvm::dwarf::FormParams{0, 0, llvm::dwarf::DWARF32},
+                attributes);
   return GetQualifiedName(dwarf2Data, cu, attributes, storage);
 }
 
 const char *DWARFDebugInfoEntry::GetQualifiedName(
     SymbolFileDWARF *dwarf2Data, DWARFUnit *cu,
     const DWARFAttributes &attributes, std::string &storage) const {
 
   const char *name = GetName(dwarf2Data, cu);

source/Plugins/SymbolFile/DWARF/DWARFFormValue.h

typedef struct ValueTypeTag {
     union {
       uint64_t uval;
       int64_t sval;
       const char *cstr;
     } value;
     const uint8_t *data;
   } ValueType;
 
-  class FixedFormSizes {
-  public:
-    FixedFormSizes() : m_fix_sizes(nullptr), m_size(0) {}
-
-    FixedFormSizes(const uint8_t *fix_sizes, size_t size)
-        : m_fix_sizes(fix_sizes), m_size(size) {}
-
-    uint8_t GetSize(uint32_t index) const {
-      return index < m_size ? m_fix_sizes[index] : 0;
-    }
-
-    bool Empty() const { return m_size == 0; }
-
-  private:
-    const uint8_t *m_fix_sizes;
-    size_t m_size;
-  };
-
   enum {
     eValueTypeInvalid = 0,
     eValueTypeUnsigned,
     eValueTypeSigned,
     eValueTypeCStr,
     eValueTypeBlock
   };
 
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 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

 #include <assert.h>
 
 #include "lldb/Core/dwarf.h"
 #include "lldb/Utility/Stream.h"
 
 #include "DWARFUnit.h"
 #include "DWARFFormValue.h"
 
-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
-    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
-    4, // 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
-    4, // 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
-
-};
-
-static uint8_t g_form_sizes_addr8[] = {
-    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
-    4, // 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
-    4, // 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
-};
-
-// 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.
-  }
-  return FixedFormSizes();
-}
-
 DWARFFormValue::DWARFFormValue() : m_cu(NULL), 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_form = 0;

source/Plugins/SymbolFile/DWARF/DWARFUnit.h

public:
   void ClearDIEs(bool keep_compile_unit_die);
   void BuildAddressRangeTable(SymbolFileDWARF *dwarf2Data,
                               DWARFDebugAranges *debug_aranges);
 
   lldb::ByteOrder GetByteOrder() const;
 
   lldb_private::TypeSystem *GetTypeSystem();
 
-  DWARFFormValue::FixedFormSizes GetFixedFormSizes();
+  llvm::dwarf::FormParams GetFormParams() const;
 
   void SetBaseAddress(dw_addr_t base_addr);
 
   DWARFDIE
   GetCompileUnitDIEOnly();
 
   DWARFDIE
   DIE();
public:
   dw_offset_t GetBaseObjOffset() const;
 
 protected:
   virtual DWARFCompileUnit &Data() = 0;
   virtual const DWARFCompileUnit &Data() const = 0;
 
   DWARFUnit();
 
-  static void
-  IndexPrivate(DWARFUnit *dwarf_cu, const lldb::LanguageType cu_language,
-               const DWARFFormValue::FixedFormSizes &fixed_form_sizes,
-               const dw_offset_t cu_offset, NameToDIE &func_basenames,
-               NameToDIE &func_fullnames, NameToDIE &func_methods,
-               NameToDIE &func_selectors, NameToDIE &objc_class_selectors,
-               NameToDIE &globals, NameToDIE &types, NameToDIE &namespaces);
+  static void IndexPrivate(DWARFUnit *dwarf_cu,
+                           const lldb::LanguageType cu_language,
+                           llvm::dwarf::FormParams form_params,
+                           const dw_offset_t cu_offset,
+                           NameToDIE &func_basenames, NameToDIE &func_fullnames,
+                           NameToDIE &func_methods, NameToDIE &func_selectors,
+                           NameToDIE &objc_class_selectors, NameToDIE &globals,
+                           NameToDIE &types, NameToDIE &namespaces);
 
   // Offset of the initial length field.
   dw_offset_t m_offset;
 
 private:
   const DWARFDebugInfoEntry *GetCompileUnitDIEPtrOnly();
 
   const DWARFDebugInfoEntry *DIEPtr();
 
   DISALLOW_COPY_AND_ASSIGN(DWARFUnit);
 };
 
 #endif // SymbolFileDWARF_DWARFUnit_h_

source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

 lldb::ByteOrder DWARFUnit::GetByteOrder() const {
   return Data().m_dwarf2Data->GetObjectFile()->GetByteOrder();
 }
 
 TypeSystem *DWARFUnit::GetTypeSystem() {
   return Data().GetTypeSystem();
 }
 
-DWARFFormValue::FixedFormSizes DWARFUnit::GetFixedFormSizes() {
-  return DWARFFormValue::GetFixedFormSizesForAddressSize(GetAddressByteSize(),
-                                                         IsDWARF64());
+llvm::dwarf::FormParams DWARFUnit::GetFormParams() const {
+  return llvm::dwarf::FormParams{GetVersion(), GetAddressByteSize(),
+                                 IsDWARF64() ? llvm::dwarf::DWARF64
+                                             : llvm::dwarf::DWARF32};
 }
 
 void DWARFUnit::SetBaseAddress(dw_addr_t base_addr) {
   Data().m_base_addr = base_addr;
 }
 
 DWARFDIE DWARFUnit::GetCompileUnitDIEOnly() {
   return Data().GetCompileUnitDIEOnly();
void DWARFUnit::Index(NameToDIE &func_basenames,
   if (log) {
     Data().m_dwarf2Data->GetObjectFile()->GetModule()->LogMessage(
         log,
         "DWARFUnit::Index() for compile unit at .debug_info[0x%8.8x]",
         GetOffset());
   }
 
   const LanguageType cu_language = GetLanguageType();
-  DWARFFormValue::FixedFormSizes fixed_form_sizes =
-      DWARFFormValue::GetFixedFormSizesForAddressSize(GetAddressByteSize(),
-                                                      IsDWARF64());
-
-  IndexPrivate(this, cu_language, fixed_form_sizes, GetOffset(), func_basenames,
+  IndexPrivate(this, cu_language, GetFormParams(), GetOffset(), func_basenames,
                func_fullnames, func_methods, func_selectors,
                objc_class_selectors, globals, types, namespaces);
 
   SymbolFileDWARFDwo *dwo_symbol_file = GetDwoSymbolFile();
   if (dwo_symbol_file) {
     IndexPrivate(
-        dwo_symbol_file->GetCompileUnit(), cu_language, fixed_form_sizes,
+        dwo_symbol_file->GetCompileUnit(), cu_language, GetFormParams(),
         GetOffset(), func_basenames, func_fullnames, func_methods,
         func_selectors, objc_class_selectors, globals, types, namespaces);
   }
 }
 
 void DWARFUnit::IndexPrivate(
     DWARFUnit *dwarf_cu, const LanguageType cu_language,
-    const DWARFFormValue::FixedFormSizes &fixed_form_sizes,
-    const dw_offset_t cu_offset, NameToDIE &func_basenames,
-    NameToDIE &func_fullnames, NameToDIE &func_methods,
-    NameToDIE &func_selectors, NameToDIE &objc_class_selectors,
-    NameToDIE &globals, NameToDIE &types, NameToDIE &namespaces) {
+    llvm::dwarf::FormParams form_params, const dw_offset_t cu_offset,
+    NameToDIE &func_basenames, NameToDIE &func_fullnames,
+    NameToDIE &func_methods, NameToDIE &func_selectors,
+    NameToDIE &objc_class_selectors, NameToDIE &globals, NameToDIE &types,
+    NameToDIE &namespaces) {
   DWARFDebugInfoEntry::const_iterator pos;
   DWARFDebugInfoEntry::const_iterator begin =
       dwarf_cu->Data().m_die_array.begin();
   DWARFDebugInfoEntry::const_iterator end = dwarf_cu->Data().m_die_array.end();
   for (pos = begin; pos != end; ++pos) {
     const DWARFDebugInfoEntry &die = *pos;
 
     const dw_tag_t tag = die.Tag();
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, fixed_form_sizes, attributes);
+        die.GetAttributes(dwarf_cu, form_params, 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();

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

if (num_attributes > 0) {
                 // Retrieve the value as a block expression.
                 uint32_t block_offset =
                     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());
+                llvm::dwarf::FormParams form_params =
+                    attributes.CompileUnitAtIndex(i)->GetFormParams();
                 uint32_t data_offset = attributes.DIEOffsetAtIndex(i);
-                uint32_t data_length =
-                    fixed_form_sizes.GetSize(form_value.Form());
-                if (data_length == 0) {
+                if (llvm::Optional<uint8_t> data_length =
+                        llvm::dwarf::getFixedFormByteSize(
+                            llvm::dwarf::Form(form_value.Form()), form_params))
+                  location.CopyOpcodeData(module, debug_info_data, data_offset,
+                                          *data_length);
+                else {
                   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());
+                  llvm::dwarf::FormParams form_params =
+                      attributes.CompileUnitAtIndex(i)->GetFormParams();
                   uint32_t data_offset = attributes.DIEOffsetAtIndex(i);
-                  uint32_t data_length =
-                      fixed_form_sizes.GetSize(form_value.Form());
+                  uint32_t data_length = *llvm::dwarf::getFixedFormByteSize(
+                      DW_FORM_strp, form_params);
                   location.CopyOpcodeData(module, debug_info_data, data_offset,
                                           data_length);
                 } else {
                   const char *str = form_value.AsCString();
                   uint32_t string_offset =
                       str - (const char *)debug_info_data.GetDataStart();
                   uint32_t string_length = strlen(str) + 1;
                   location.CopyOpcodeData(module, debug_info_data,