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

25

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

source/Plugins/SymbolFile/DWARF/DWARFFormValue.h

39

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–180

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–666

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

This should be a method on DWARFFormValue::FixedFormSizes.

1281

This should be a method on DWARFFormValue::FixedFormSizes.

source/Plugins/SymbolFile/DWARF/DWARFDebugPubnames.cpp

90–92

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

source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp

24–25

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.

63–64

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.

103–104

Ditto above comment.

139–154

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

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

4045–4048

No auto

4050

use DWARFFormValue::FixedFormSizes form accessor function.

4072–4075

no auto

4077

use DWARFFormValue::FixedFormSizes form accessor function.

source/Symbol/ClangASTContext.cpp

8944–8946

no auto

9465–9467

no auto

9825–9827

no auto

10403–10405

no auto

10581–10583

no auto

[tberghammer]

Address review comments

[tberghammer]

source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.h

165

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.

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());

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,

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

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();

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_

source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp

 #include "DWARFCompileUnit.h"
 
 class DWARFCompileUnit;
 
 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
static uint8_t g_form_sizes_addr4[] =
     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
g_form_sizes_addr8[] =
     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
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()
 {
 }
 

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);

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)