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

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

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

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.

1286

This should be a method on DWARFFormValue::FixedFormSizes.

source/Plugins/SymbolFile/DWARF/DWARFDebugPubnames.cpp

91

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

source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp

23–24

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

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

Ditto above comment.

136–151

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

4056

No auto

4058

use DWARFFormValue::FixedFormSizes form accessor function.

4080

no auto

4082

use DWARFFormValue::FixedFormSizes form accessor function.

source/Symbol/ClangASTContext.cpp

8944

no auto

9464

no auto

9823

no auto

10405

no auto

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);
+    auto 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& objc_class_selectors,
                          NameToDIE& globals,
                          NameToDIE& types,
                          NameToDIE& namespaces)
 {
     const DWARFDataExtractor* debug_str = &m_dwarf2Data->get_debug_str_data();
     const DWARFDataExtractor* debug_str_offsets = &m_dwarf2Data->get_debug_str_offsets_data();
 
-    const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (GetAddressByteSize(), m_is_dwarf64);
+    auto 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,
+                    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,
+    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 = form < fixed_form_sizes->size() ? fixed_form_sizes->at(form) : 0;
             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)
+        if (fixed_form_sizes == nullptr)
             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)
         {
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 = form < fixed_form_sizes->size() ? fixed_form_sizes->at(form) : 0;
                 if (fixed_skip_size)
                     offset += fixed_skip_size;
                 else
                     DWARFFormValue::SkipValue(form, debug_info_data, &offset, cu);
             }
         }
     }
     else

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());
+            auto 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;
     
+    typedef const std::vector<uint8_t> FixedFormSizes;
+
     enum
     {
         eValueTypeInvalid = 0,
         eValueTypeUnsigned,
         eValueTypeSigned,
         eValueTypeCStr,
         eValueTypeBlock
     };
public:
     void                SetSigned(int64_t sval) { m_value.value.sval = sval; }
     const char*         AsCString(const lldb_private::DWARFDataExtractor* debug_str_data_ptr,
                                   const lldb_private::DWARFDataExtractor* debug_str_offsets_data_ptr) const;
     dw_addr_t           Address(const lldb_private::DWARFDataExtractor* debug_addr_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,
                                  const lldb_private::DWARFDataExtractor* debug_str_offsets_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 "DWARFFormValue.h"
 #include "DWARFCompileUnit.h"
 
 class DWARFCompileUnit;
 
 using namespace lldb_private;
 
 
-static uint8_t g_form_sizes_addr4[] = 
-{
+static DWARFFormValue::FixedFormSizes
+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
g_form_sizes_addr4 {
     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[] = 
-{
+static DWARFFormValue::FixedFormSizes
+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
g_form_sizes_addr8 {
     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[] =
-{
+static DWARFFormValue::FixedFormSizes
+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
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 &g_form_sizes_addr4;
+        case 8: return &g_form_sizes_addr8;
         }
     } else {
         if (addr_size == 8)
-            return g_form_sizes_addr8_dwarf64;
+            return &g_form_sizes_addr8_dwarf64;
         // is_dwarf64 && addr_size == 4 : no provider does this.
     }
-    return NULL;
+    return nullptr;
 }
 
 DWARFFormValue::DWARFFormValue() :
     m_cu (NULL),
     m_form(0),
     m_value()
 {
 }
 

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

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());
+                                auto 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 = form_value.Form() < fixed_form_sizes->size() ? fixed_form_sizes->at(form_value.Form()) : 0;
                                 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());
+                                    auto 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 = form_value.Form() < fixed_form_sizes->size() ? fixed_form_sizes->at(form_value.Form()) : 0;
                                     location.CopyOpcodeData(module, debug_info_data, data_offset, data_length);
                                 }
                                 else
                                 {
                                     const char *str = form_value.AsCString(&get_debug_str_data(),
                                                                            &get_debug_str_offsets_data());
                                     uint32_t string_offset = str - (const char *)debug_info_data.GetDataStart();
                                     uint32_t string_length = strlen(str) + 1;

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