Fix buffer overflow for fixed_form_sizes

[tberghammer]

Summary

Fix buffer overflow for fixed_form_sizes

The array is indexed by the value in the DW_FORM filed what can be
bigger then the size of the array. This CL add bound checking to avoid
buffer overflows.

Note: This CL is part of a long series of CLs to add fission support to LLDB

[labath]

source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp

24 ↗

(On Diff #32827)

Will these be linker-initialized? As I understand it, we are trying to avoid static constructors..

source/Plugins/SymbolFile/DWARF/DWARFFormValue.h

39 ↗

(On Diff #32827)

I don't think hiding const in the type name is a good idea. It makes it quite hard to tell you are declaring constant arrays below.

[clayborg]

See inlined comments.

source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp

179 ↗

(On Diff #32827)

Please don't use auto for simple types. For template types yes (for things like "std::vector<int>::iterator", but not for simple types.

665 ↗

(On Diff #32827)

Please don't use auto for simple types. For template types yes (for things like "std::vector<int>::iterator", but not for simple types.

source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

161 ↗

(On Diff #32827)

This should be a method on DWARFFormValue::FixedFormSizes.

1286 ↗

(On Diff #32827)

This should be a method on DWARFFormValue::FixedFormSizes.

source/Plugins/SymbolFile/DWARF/DWARFDebugPubnames.cpp

91 ↗

(On Diff #32827)

"DWARFFormValue::FixedFormSizes *" instead of "auto".

source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp

23–24 ↗

(On Diff #32827)

You could probably leave these as "static uint8_t g_form_sizes_addr4[]" and then have the new DWARFFormValue::FixedFormSizes struct/class that we make get intialized with these const arrays and do the bounds checking. This would avoid static constructors and also provide bounds checking.

60–61 ↗

(On Diff #32827)

You could probably leave these as "static uint8_t g_form_sizes_addr8[]" and then have the new DWARFFormValue::FixedFormSizes struct/class that we make get intialized with these const arrays and do the bounds checking. This would avoid static constructors and also provide bounds checking.

99–100 ↗

(On Diff #32827)

Ditto above comment.

136–151 ↗

(On Diff #32827)

Change this function to use the original static arrays and construct a DWARFFormValue::FixedFormSizes with a pointer and array size to provide bounds checking. No need to use a std::vector for const data.

source/Plugins/SymbolFile/DWARF/DWARFFormValue.h

39 ↗

(On Diff #32827)

Make this a struct and add a method to access the form size by form so we don't have the following code in multiple places:

const uint8_t fixed_skip_size = form < fixed_form_sizes->size() ? fixed_form_sizes->at(form) : 0;

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

4056 ↗

(On Diff #32827)

No auto

4058 ↗

(On Diff #32827)

use DWARFFormValue::FixedFormSizes form accessor function.

4080 ↗

(On Diff #32827)

no auto

4082 ↗

(On Diff #32827)

use DWARFFormValue::FixedFormSizes form accessor function.

source/Symbol/ClangASTContext.cpp

8944 ↗

(On Diff #32827)

no auto

9464 ↗

(On Diff #32827)

no auto

9823 ↗

(On Diff #32827)

no auto

10405 ↗

(On Diff #32827)

no auto

10583 ↗

(On Diff #32827)

no auto

[tberghammer]

Address review comments

[tberghammer]

source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.h

165 ↗

(On Diff #32946)

Note: Get attributes have to make a copy of fixed_form_sizes because it query a new fixed_form_sizes object if an empty object was passed in.

[clayborg]

Looks good.

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

DWARFCompileUnit::ExtractDIEsIfNeeded (bool cu_die_only)
     uint32_t depth = 0;
     // 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;
-    const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (GetAddressByteSize(), m_is_dwarf64);
+    DWARFFormValue::FixedFormSizes fixed_form_sizes =
+        DWARFFormValue::GetFixedFormSizesForAddressSize (GetAddressByteSize(), m_is_dwarf64);
     while (offset < next_cu_offset &&
            die.FastExtract (debug_info_data, this, fixed_form_sizes, &offset))
     {
 //        if (log)
 //            log->Printf("0x%8.8x: %*.*s%s%s",
 //                        die.GetOffset(),
 //                        depth * 2, depth * 2, "",
 //                        DW_TAG_value_to_name (die.Tag()),
DWARFCompileUnit::Index (const uint32_t cu_idx,
                          NameToDIE& func_selectors,
                          NameToDIE& objc_class_selectors,
                          NameToDIE& globals,
                          NameToDIE& types,
                          NameToDIE& namespaces)
 {
     const DWARFDataExtractor* debug_str = &m_dwarf2Data->get_debug_str_data();
 
-    const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (GetAddressByteSize(), m_is_dwarf64);
+    DWARFFormValue::FixedFormSizes fixed_form_sizes =
+        DWARFFormValue::GetFixedFormSizesForAddressSize (GetAddressByteSize(), m_is_dwarf64);
 
     Log *log (LogChannelDWARF::GetLogIfAll (DWARF_LOG_LOOKUPS));
     
     if (log)
     {
         m_dwarf2Data->GetObjectFile()->GetModule()->LogMessage (log, 
                                                                 "DWARFCompileUnit::Index() for compile unit at .debug_info[0x%8.8x]",
                                                                 GetOffset());

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

public:
     void        BuildFunctionAddressRangeTable(
                     SymbolFileDWARF* dwarf2Data,
                     const DWARFCompileUnit* cu,
                     DWARFDebugAranges* debug_aranges) const;
 
     bool        FastExtract(
                     const lldb_private::DWARFDataExtractor& debug_info_data,
                     const DWARFCompileUnit* cu,
-                    const uint8_t *fixed_form_sizes,
+                    const DWARFFormValue::FixedFormSizes& fixed_form_sizes,
                     lldb::offset_t* offset_ptr);
 
     bool        Extract(
                     SymbolFileDWARF* dwarf2Data,
                     const DWARFCompileUnit* cu,
                     lldb::offset_t* offset_ptr);
 
     bool        LookupAddress(
                     const dw_addr_t address,
                     SymbolFileDWARF* dwarf2Data,
                     const DWARFCompileUnit* cu,
                     DWARFDebugInfoEntry** function_die,
                     DWARFDebugInfoEntry** block_die);
 
     size_t      GetAttributes(
                     SymbolFileDWARF* dwarf2Data,
                     const DWARFCompileUnit* cu,
-                    const uint8_t *fixed_form_sizes,
+                    DWARFFormValue::FixedFormSizes fixed_form_sizes,
                     DWARFDebugInfoEntry::Attributes& attrs,
                     uint32_t curr_depth = 0) const; // "curr_depth" for internal use only, don't set this yourself!!!
 
     dw_offset_t GetAttributeValue(
                     SymbolFileDWARF* dwarf2Data,
                     const DWARFCompileUnit* cu,
                     const dw_attr_t attr,
                     DWARFFormValue& formValue,

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

 
 
 
 bool
 DWARFDebugInfoEntry::FastExtract
 (
     const DWARFDataExtractor& debug_info_data,
     const DWARFCompileUnit* cu,
-    const uint8_t *fixed_form_sizes,
+    const DWARFFormValue::FixedFormSizes& fixed_form_sizes,
     lldb::offset_t *offset_ptr
 )
 {
     m_offset = *offset_ptr;
     m_parent_idx = 0;
     m_sibling_idx = 0;
     m_empty_children = false;
     const uint64_t abbr_idx = debug_info_data.GetULEB128 (offset_ptr);
if (m_abbr_idx)
         // 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 [form];
+            const uint8_t fixed_skip_size = fixed_form_sizes.GetSize(form);
             if (fixed_skip_size)
                 offset += fixed_skip_size;
             else
             {
                 bool form_is_indirect = false;
                 do
                 {
                     form_is_indirect = false;

 // the results. Any duplicate attributes will have the first instance
 // take precedence (this can happen for declaration attributes).
 //----------------------------------------------------------------------
 size_t
 DWARFDebugInfoEntry::GetAttributes
 (
     SymbolFileDWARF* dwarf2Data,
     const DWARFCompileUnit* cu,
-    const uint8_t *fixed_form_sizes,
+    DWARFFormValue::FixedFormSizes fixed_form_sizes,
     DWARFDebugInfoEntry::Attributes& attributes,
     uint32_t curr_depth
 ) const
 {
     lldb::offset_t offset;
     const DWARFAbbreviationDeclaration* abbrevDecl = GetAbbreviationDeclarationPtr(dwarf2Data, cu, offset);
 
     if (abbrevDecl)
     {
         const DWARFDataExtractor& debug_info_data = dwarf2Data->get_debug_info_data();
 
-        if (fixed_form_sizes == NULL)
-            fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize(cu->GetAddressByteSize(), cu->IsDWARF64());
+        if (fixed_form_sizes.Empty())
+            fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize(
+                    cu->GetAddressByteSize(), cu->IsDWARF64());
 
         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);
if (abbrevDecl)
                         die = const_cast<SymbolFileDWARF*>(dwarf2Data)->DebugInfo()->GetDIEPtr(die_offset, &cu_sp_ptr);
                         if (die)
                             die->GetAttributes(dwarf2Data, cu_sp_ptr.get(), fixed_form_sizes, attributes, curr_depth + 1);
                     }
                 }
             }
             else
             {
-                const uint8_t fixed_skip_size = fixed_form_sizes [form];
+                const uint8_t fixed_skip_size = fixed_form_sizes.GetSize(form);
                 if (fixed_skip_size)
                     offset += fixed_skip_size;
                 else
                     DWARFFormValue::SkipValue(form, debug_info_data, &offset, cu);
             }
         }
     }
     else
DWARFDebugInfoEntry::MatchesDWARFDeclContext (SymbolFileDWARF* dwarf2Data,
     return this_dwarf_decl_ctx == dwarf_decl_ctx;
 }
 
 const DWARFDebugInfoEntry *
 DWARFDebugInfoEntry::GetParentDeclContextDIE (SymbolFileDWARF* dwarf2Data, 
                         DWARFCompileUnit* cu) const
 {
   DWARFDebugInfoEntry::Attributes attributes;
-  GetAttributes(dwarf2Data, cu, NULL, attributes);
+  GetAttributes(dwarf2Data, cu, DWARFFormValue::FixedFormSizes(), attributes);
   return GetParentDeclContextDIE (dwarf2Data, cu, attributes);
 }
 
 const DWARFDebugInfoEntry *
 DWARFDebugInfoEntry::GetParentDeclContextDIE (SymbolFileDWARF* dwarf2Data, 
                         DWARFCompileUnit* cu,
                         const DWARFDebugInfoEntry::Attributes& attributes) const
 {

 
 
 const char *
 DWARFDebugInfoEntry::GetQualifiedName (SymbolFileDWARF* dwarf2Data, 
                      DWARFCompileUnit* cu,
                      std::string &storage) const
 {
   DWARFDebugInfoEntry::Attributes attributes;
-  GetAttributes(dwarf2Data, cu, NULL, attributes);
+  GetAttributes(dwarf2Data, cu, DWARFFormValue::FixedFormSizes(), attributes);
   return GetQualifiedName (dwarf2Data, cu, attributes, storage);
 }
 
 const char*
 DWARFDebugInfoEntry::GetQualifiedName (SymbolFileDWARF* dwarf2Data, 
                      DWARFCompileUnit* cu,
                      const DWARFDebugInfoEntry::Attributes& attributes,
                      std::string &storage) const

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

if (debug_info)
 
         uint32_t cu_idx = 0;
         const uint32_t num_compile_units = dwarf2Data->GetNumCompileUnits();
         for (cu_idx = 0; cu_idx < num_compile_units; ++cu_idx)
         {
 
             DWARFCompileUnit* cu = debug_info->GetCompileUnitAtIndex(cu_idx);
 
-            const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (cu->GetAddressByteSize(), cu->IsDWARF64());
+            DWARFFormValue::FixedFormSizes fixed_form_sizes =
+                DWARFFormValue::GetFixedFormSizesForAddressSize (cu->GetAddressByteSize(),
+                                                                 cu->IsDWARF64());
 
             bool clear_dies = cu->ExtractDIEsIfNeeded (false) > 1;
 
             DWARFDIECollection dies;
             const size_t die_count = cu->AppendDIEsWithTag (DW_TAG_subprogram, dies) +
                                      cu->AppendDIEsWithTag (DW_TAG_variable, dies);
 
             dw_offset_t cu_offset = cu->GetOffset();

lldb/trunk/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:
     void                SetUnsigned(uint64_t uval) { m_value.value.uval = uval; }
     int64_t             Signed() const { return m_value.value.sval; }
     void                SetSigned(int64_t sval) { m_value.value.sval = sval; }
     const char*         AsCString(const lldb_private::DWARFDataExtractor* debug_str_data_ptr) const;
     bool                SkipValue(const lldb_private::DWARFDataExtractor& debug_info_data, lldb::offset_t *offset_ptr) const;
     static bool         SkipValue(const dw_form_t form, const lldb_private::DWARFDataExtractor& debug_info_data, lldb::offset_t *offset_ptr, const DWARFCompileUnit* cu);
     static bool         IsBlockForm(const dw_form_t form);
     static bool         IsDataForm(const dw_form_t form);
-    static const uint8_t * GetFixedFormSizesForAddressSize (uint8_t addr_size, bool is_dwarf64);
+    static FixedFormSizes GetFixedFormSizesForAddressSize (uint8_t addr_size, bool is_dwarf64);
     static int          Compare (const DWARFFormValue& a, const DWARFFormValue& b, const lldb_private::DWARFDataExtractor* debug_str_data_ptr);
 protected:
     const DWARFCompileUnit* m_cu; // Compile unit for this form
     dw_form_t   m_form;     // Form for this value
     ValueType   m_value;    // Contains all data for the form
 };
 
 
 #endif  // SymbolFileDWARF_DWARFFormValue_h_

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

g_form_sizes_addr8_dwarf64[] =
     0, // 0x1b
     0, // 0x1c
     0, // 0x1d
     0, // 0x1e
     0, // 0x1f
     8, // 0x20 DW_FORM_ref_sig8
 };
 
-const uint8_t * 
+DWARFFormValue::FixedFormSizes
 DWARFFormValue::GetFixedFormSizesForAddressSize (uint8_t addr_size, bool is_dwarf64)
 {
     if (!is_dwarf64) {
         switch (addr_size)
         {
-        case 4: return g_form_sizes_addr4;
-        case 8: return g_form_sizes_addr8;
+        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 g_form_sizes_addr8_dwarf64;
+            return FixedFormSizes(g_form_sizes_addr8_dwarf64, sizeof(g_form_sizes_addr8_dwarf64));
         // is_dwarf64 && addr_size == 4 : no provider does this.
     }
-    return NULL;
+    return FixedFormSizes();
 }
 
 DWARFFormValue::DWARFFormValue() :
     m_cu (NULL),
     m_form(0),
     m_value()
 {
 }

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

SymbolFileDWARF::FunctionDieMatchesPartialName (const DWARFDebugInfoEntry* die,
     if (base_name_start != partial_name || *base_name_end != '\0')
     {
         // First see if the stuff to the left matches the full name.  To do that let's see if
         // we can pull out the mips linkage name attribute:
         
         Mangled best_name;
         DWARFDebugInfoEntry::Attributes attributes;
         DWARFFormValue form_value;
-        die->GetAttributes(this, dwarf_cu, NULL, attributes);
+        die->GetAttributes(this, dwarf_cu, DWARFFormValue::FixedFormSizes(), attributes);
         uint32_t idx = attributes.FindAttributeIndex(DW_AT_MIPS_linkage_name);
         if (idx == UINT32_MAX)
             idx = attributes.FindAttributeIndex(DW_AT_linkage_name);
         if (idx != UINT32_MAX)
         {
             if (attributes.ExtractFormValueAtIndex(this, idx, form_value))
             {
                 const char *mangled_name = form_value.AsCString(&get_debug_str_data());
)
     const dw_tag_t tag = die->Tag();
     ModuleSP module = GetObjectFile()->GetModule();
     
     if ((tag == DW_TAG_variable) ||
         (tag == DW_TAG_constant) ||
         (tag == DW_TAG_formal_parameter && sc.function))
     {
         DWARFDebugInfoEntry::Attributes attributes;
-        const size_t num_attributes = die->GetAttributes(this, dwarf_cu, NULL, attributes);
+        const size_t num_attributes = die->GetAttributes(this,
+                                                         dwarf_cu,
+                                                         DWARFFormValue::FixedFormSizes(),
+                                                         attributes);
         if (num_attributes > 0)
         {
             const char *name = NULL;
             const char *mangled = NULL;
             Declaration decl;
             uint32_t i;
             lldb::user_id_t type_uid = LLDB_INVALID_UID;
             DWARFExpression location;
if ((tag == DW_TAG_variable) ||
                                 // 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.
-                                const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (attributes.CompileUnitAtIndex(i)->GetAddressByteSize(), attributes.CompileUnitAtIndex(i)->IsDWARF64());
+                                DWARFFormValue::FixedFormSizes fixed_form_sizes =
+                                    DWARFFormValue::GetFixedFormSizesForAddressSize (
+                                            attributes.CompileUnitAtIndex(i)->GetAddressByteSize(),
+                                            attributes.CompileUnitAtIndex(i)->IsDWARF64());
                                 uint32_t data_offset = attributes.DIEOffsetAtIndex(i);
-                                uint32_t data_length = fixed_form_sizes[form_value.Form()];
+                                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)
                                 {
-                                    const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (attributes.CompileUnitAtIndex(i)->GetAddressByteSize(), attributes.CompileUnitAtIndex(i)->IsDWARF64());
+                                    DWARFFormValue::FixedFormSizes fixed_form_sizes =
+                                        DWARFFormValue::GetFixedFormSizesForAddressSize (
+                                                attributes.CompileUnitAtIndex(i)->GetAddressByteSize(),
+                                                attributes.CompileUnitAtIndex(i)->IsDWARF64());
                                     uint32_t data_offset = attributes.DIEOffsetAtIndex(i);
-                                    uint32_t data_length = fixed_form_sizes[form_value.Form()];
+                                    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(&debug_info_data);
                                     uint32_t string_offset = str - (const char *)debug_info_data.GetDataStart();
                                     uint32_t string_length = strlen(str) + 1;
                                     location.CopyOpcodeData(module, debug_info_data, string_offset, string_length);

lldb/trunk/source/Symbol/ClangASTContext.cpp

 {
     const dw_tag_t tag = die->Tag();
 
     switch (tag)
     {
         case DW_TAG_template_type_parameter:
         case DW_TAG_template_value_parameter:
         {
-            const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (dwarf_cu->GetAddressByteSize(), dwarf_cu->IsDWARF64());
+            DWARFFormValue::FixedFormSizes fixed_form_sizes =
+                DWARFFormValue::GetFixedFormSizesForAddressSize (dwarf_cu->GetAddressByteSize(),
+                                                                 dwarf_cu->IsDWARF64());
 
             DWARFDebugInfoEntry::Attributes attributes;
             const size_t num_attributes = die->GetAttributes (dwarf,
                                                               dwarf_cu,
                                                               fixed_form_sizes,
                                                               attributes);
             const char *name = NULL;
             Type *lldb_type = NULL;
ClangASTContext::ParseChildEnumerators (const SymbolContext& sc,
                                         DWARFCompileUnit* dwarf_cu,
                                         const DWARFDebugInfoEntry *parent_die)
 {
     if (parent_die == NULL)
         return 0;
 
     size_t enumerators_added = 0;
     const DWARFDebugInfoEntry *die;
-    const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (dwarf_cu->GetAddressByteSize(), dwarf_cu->IsDWARF64());
+    DWARFFormValue::FixedFormSizes fixed_form_sizes =
+        DWARFFormValue::GetFixedFormSizesForAddressSize (dwarf_cu->GetAddressByteSize(),
+                                                         dwarf_cu->IsDWARF64());
 
     for (die = parent_die->GetFirstChild(); die != NULL; die = die->GetSibling())
     {
         const dw_tag_t tag = die->Tag();
         if (tag == DW_TAG_enumerator)
         {
             DWARFDebugInfoEntry::Attributes attributes;
             const size_t num_child_attributes = die->GetAttributes(dwarf, dwarf_cu, fixed_form_sizes, attributes);
ClangASTContext::ParseChildMembers (const SymbolContext& sc,
                                     bool &is_a_class,
                                     LayoutInfo &layout_info)
 {
     if (parent_die == NULL)
         return 0;
 
     size_t count = 0;
     const DWARFDebugInfoEntry *die;
-    const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (dwarf_cu->GetAddressByteSize(), dwarf_cu->IsDWARF64());
+    DWARFFormValue::FixedFormSizes fixed_form_sizes =
+        DWARFFormValue::GetFixedFormSizesForAddressSize (dwarf_cu->GetAddressByteSize(),
+                                                         dwarf_cu->IsDWARF64());
     uint32_t member_idx = 0;
     BitfieldInfo last_field_info;
     ModuleSP module_sp = dwarf->GetObjectFile()->GetModule();
     ClangASTContext* ast = class_clang_type.GetTypeSystem()->AsClangASTContext();
     if (ast == nullptr)
         return 0;
 
     for (die = parent_die->GetFirstChild(); die != NULL; die = die->GetSibling())
ClangASTContext::ParseChildParameters (const SymbolContext& sc,
                                        bool &is_variadic,
                                        std::vector<CompilerType>& function_param_types,
                                        std::vector<clang::ParmVarDecl*>& function_param_decls,
                                        unsigned &type_quals)
 {
     if (parent_die == NULL)
         return 0;
 
-    const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (dwarf_cu->GetAddressByteSize(), dwarf_cu->IsDWARF64());
+    DWARFFormValue::FixedFormSizes fixed_form_sizes =
+        DWARFFormValue::GetFixedFormSizesForAddressSize (dwarf_cu->GetAddressByteSize(),
+                                                         dwarf_cu->IsDWARF64());
 
     size_t arg_idx = 0;
     const DWARFDebugInfoEntry *die;
     for (die = parent_die->GetFirstChild(); die != NULL; die = die->GetSibling())
     {
         dw_tag_t tag = die->Tag();
         switch (tag)
         {
ClangASTContext::ParseChildArrayInfo (const SymbolContext& sc,
                                       std::vector<uint64_t>& element_orders,
                                       uint32_t& byte_stride,
                                       uint32_t& bit_stride)
 {
     if (parent_die == NULL)
         return;
 
     const DWARFDebugInfoEntry *die;
-    const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (dwarf_cu->GetAddressByteSize(), dwarf_cu->IsDWARF64());
+    DWARFFormValue::FixedFormSizes fixed_form_sizes =
+        DWARFFormValue::GetFixedFormSizesForAddressSize (dwarf_cu->GetAddressByteSize(),
+                                                         dwarf_cu->IsDWARF64());
     for (die = parent_die->GetFirstChild(); die != NULL; die = die->GetSibling())
     {
         const dw_tag_t tag = die->Tag();
         switch (tag)
         {
             case DW_TAG_subrange_type:
             {
                 DWARFDebugInfoEntry::Attributes attributes;
#endif
                 case DW_TAG_const_type:
                 case DW_TAG_restrict_type:
                 case DW_TAG_volatile_type:
                 case DW_TAG_unspecified_type:
                 {
                     // Set a bit that lets us know that we are currently parsing this
                     dwarf->m_die_to_type[die] = DIE_IS_BEING_PARSED;
 
-                    const size_t num_attributes = die->GetAttributes(dwarf, dwarf_cu, NULL, attributes);
+                    const size_t num_attributes = die->GetAttributes(dwarf,
+                                                                     dwarf_cu,
+                                                                     DWARFFormValue::FixedFormSizes(),
+                                                                     attributes);
                     uint32_t encoding = 0;
                     lldb::user_id_t encoding_uid = LLDB_INVALID_UID;
 
                     if (num_attributes > 0)
                     {
                         uint32_t i;
                         for (i=0; i<num_attributes; ++i)
                         {
#endif
                 {
                     // Set a bit that lets us know that we are currently parsing this
                     dwarf->m_die_to_type[die] = DIE_IS_BEING_PARSED;
                     bool byte_size_valid = false;
 
                     LanguageType class_language = eLanguageTypeUnknown;
                     bool is_complete_objc_class = false;
                     //bool struct_is_class = false;
-                    const size_t num_attributes = die->GetAttributes(dwarf, dwarf_cu, NULL, attributes);
+                    const size_t num_attributes = die->GetAttributes(dwarf,
+                                                                     dwarf_cu,
+                                                                     DWARFFormValue::FixedFormSizes(),
+                                                                     attributes);
                     if (num_attributes > 0)
                     {
                         uint32_t i;
                         for (i=0; i<num_attributes; ++i)
                         {
                             attr = attributes.AttributeAtIndex(i);
                             if (attributes.ExtractFormValueAtIndex(dwarf, i, form_value))
                             {
#endif
 
                 case DW_TAG_enumeration_type:
                 {
                     // Set a bit that lets us know that we are currently parsing this
                     dwarf->m_die_to_type[die] = DIE_IS_BEING_PARSED;
 
                     lldb::user_id_t encoding_uid = DW_INVALID_OFFSET;
 
-                    const size_t num_attributes = die->GetAttributes(dwarf, dwarf_cu, NULL, attributes);
+                    const size_t num_attributes = die->GetAttributes(dwarf,
+                                                                     dwarf_cu,
+                                                                     DWARFFormValue::FixedFormSizes(),
+                                                                     attributes);
                     if (num_attributes > 0)
                     {
                         uint32_t i;
 
                         for (i=0; i<num_attributes; ++i)
                         {
                             attr = attributes.AttributeAtIndex(i);
                             if (attributes.ExtractFormValueAtIndex(dwarf, i, form_value))
#endif
                     dw_offset_t specification_die_offset = DW_INVALID_OFFSET;
                     dw_offset_t abstract_origin_die_offset = DW_INVALID_OFFSET;
                     dw_offset_t object_pointer_die_offset = DW_INVALID_OFFSET;
 
                     unsigned type_quals = 0;
                     clang::StorageClass storage = clang::SC_None;//, Extern, Static, PrivateExtern
 
 
-                    const size_t num_attributes = die->GetAttributes(dwarf, dwarf_cu, NULL, attributes);
+                    const size_t num_attributes = die->GetAttributes(dwarf,
+                                                                     dwarf_cu,
+                                                                     DWARFFormValue::FixedFormSizes(),
+                                                                     attributes);
                     if (num_attributes > 0)
                     {
                         uint32_t i;
                         for (i=0; i<num_attributes; ++i)
                         {
                             attr = attributes.AttributeAtIndex(i);
                             if (attributes.ExtractFormValueAtIndex(dwarf, i, form_value))
                             {

                     // Set a bit that lets us know that we are currently parsing this
                     dwarf->m_die_to_type[die] = DIE_IS_BEING_PARSED;
 
                     lldb::user_id_t type_die_offset = DW_INVALID_OFFSET;
                     int64_t first_index = 0;
                     uint32_t byte_stride = 0;
                     uint32_t bit_stride = 0;
                     bool is_vector = false;
-                    const size_t num_attributes = die->GetAttributes(dwarf, dwarf_cu, NULL, attributes);
+                    const size_t num_attributes = die->GetAttributes(dwarf,
+                                                                     dwarf_cu,
+                                                                     DWARFFormValue::FixedFormSizes(),
+                                                                     attributes);
 
                     if (num_attributes > 0)
                     {
                         uint32_t i;
                         for (i=0; i<num_attributes; ++i)
                         {
                             attr = attributes.AttributeAtIndex(i);
                             if (attributes.ExtractFormValueAtIndex(dwarf, i, form_value))

                     }
                 }
                     break;
                     
                 case DW_TAG_ptr_to_member_type:
                 {
                     dw_offset_t type_die_offset = DW_INVALID_OFFSET;
                     dw_offset_t containing_type_die_offset = DW_INVALID_OFFSET;
-                    
-                    const size_t num_attributes = die->GetAttributes(dwarf, dwarf_cu, NULL, attributes);
-                    
+                    const size_t num_attributes = die->GetAttributes(dwarf,
+                                                                     dwarf_cu,
+                                                                     DWARFFormValue::FixedFormSizes(),
+                                                                     attributes);
                     if (num_attributes > 0) {
                         uint32_t i;
                         for (i=0; i<num_attributes; ++i)
                         {
                             attr = attributes.AttributeAtIndex(i);
                             if (attributes.ExtractFormValueAtIndex(dwarf, i, form_value))
                             {
                                 switch (attr)