DWARF64 Fixes

[endlessroad]

Summary

1. DW_FORM_strp and DW_FORM_sec_offset are 64bits for DWARF64 / 32bits for DWARF32

They are different from DW_FORM_addr, whose size is specified in .debug_info

2. Bump DWARF version support form [2,3] to [2,4] in DWARFDebugLine.cpp

3. Fix DWARFDebugLine to support DWARF64

[jasonmolenda]

Greg has done most of the DWARF parser work, he should comment.

In DWARFDebugInfoEntry.cpp DW_FORM_ref_addr you use cu->GetAddressByteSize() for the size (or cu_addr_size, used in a different part of the file) -- but if this is a 64-bit binary using DWARF32, that would be wrong - this is a reference to another part of the DWARF. Or a 32-bit binary using DWARF64. Don't you want to do cu->IsDWARF64() (like you do for DW_FORM_strp / DW_FORM_sec_offset)?

(or more accurately, for DWARF2, the DW_FORM_ref_addr is apparently the word size of the program; with DWARF3+, it's 4 for DWARF32, 8 for DWARF64)

I see what you're doing in DWARFFormValue::GetFixedFormSizesForAddressSize -- you assume that 32-bit-program + DWARF64 is not a possible combination. That's fine, I don't really think any producer would generate it.

Greg might not want to see this change to DWARFAbbreviationDeclaration::Dump() ;) but I don't have an opinion on that.

Otherwise it looks fine to me.

[endlessroad]

Address Jason's comments

[tfiala]

svn commit
Sending source/Plugins/SymbolFile/DWARF/DWARFAbbreviationDeclaration.cpp
Sending source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp
Sending source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.h
Sending source/Plugins/SymbolFile/DWARF/DWARFDataExtractor.h
Sending source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp
Sending source/Plugins/SymbolFile/DWARF/DWARFDebugLine.cpp
Sending source/Plugins/SymbolFile/DWARF/DWARFDebugPubnames.cpp
Sending source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp
Sending source/Plugins/SymbolFile/DWARF/DWARFFormValue.h
Sending source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp
Transmitting file data ..........
Committed revision 217607.

[endlessroad]

Thanks Todd!

[tfiala]

:-)

source/Plugins/SymbolFile/DWARF/DWARFAbbreviationDeclaration.cpp

 void
 DWARFAbbreviationDeclaration::Dump(Stream *s)  const
 {
-//  *ostrm_ptr << std::setfill(' ') << std::dec << '[' << std::setw(3) << std::right << m_code << ']' << ' ' << std::setw(30) << std::left << DW_TAG_value_to_name(m_tag) << DW_CHILDREN_value_to_name(m_has_children) << std::endl;
-//
-//  DWARFAttribute::const_iterator pos;
-//
-//  for (pos = m_attributes.begin(); pos != m_attributes.end(); ++pos)
-//      *ostrm_ptr << "      " << std::setw(29) << std::left << DW_AT_value_to_name(pos->attr()) << ' ' << DW_FORM_value_to_name(pos->form()) << std::endl;
-//
-//  *ostrm_ptr << std::endl;
+    s->Printf("Debug Abbreviation Declaration: code = 0x%4.4x, tag = %s, has_children = %s\n", m_code, DW_TAG_value_to_name(m_tag), DW_CHILDREN_value_to_name(m_has_children));
+
+    DWARFAttribute::const_iterator pos;
+
+    for (pos = m_attributes.begin(); pos != m_attributes.end(); ++pos)
+        s->Printf("        attr = %s, form = %s\n", DW_AT_value_to_name(pos->get_attr()), DW_FORM_value_to_name(pos->get_form()));
+
+    s->Printf("\n");
 }
 
 

source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.h

     bool        Verify(lldb_private::Stream *s) const;
     void        Dump(lldb_private::Stream *s) const;
     dw_offset_t GetOffset() const { return m_offset; }
-    uint32_t    Size() const { return 11; /* Size in bytes of the compile unit header */ }
+    uint32_t    Size() const { return m_is_dwarf64 ? 23 : 11; /* Size in bytes of the compile unit header */ }
     bool        ContainsDIEOffset(dw_offset_t die_offset) const { return die_offset >= GetFirstDIEOffset() && die_offset < GetNextCompileUnitOffset(); }
     dw_offset_t GetFirstDIEOffset() const { return m_offset + Size(); }
-    dw_offset_t GetNextCompileUnitOffset() const { return m_offset + m_length + 4; }
-    size_t      GetDebugInfoSize() const { return m_length + 4 - Size(); /* Size in bytes of the .debug_info data associated with this compile unit. */ }
+    dw_offset_t GetNextCompileUnitOffset() const { return m_offset + m_length + (m_is_dwarf64 ? 12 : 4); }
+    size_t      GetDebugInfoSize() const { return m_length + (m_is_dwarf64 ? 12 : 4) - Size(); /* Size in bytes of the .debug_info data associated with this compile unit. */ }
     uint32_t    GetLength() const { return m_length; }
     uint16_t    GetVersion() const { return m_version; }
     const DWARFAbbreviationDeclarationSet*  GetAbbreviations() const { return m_abbrevs; }

     static uint8_t
     GetAddressByteSize(const DWARFCompileUnit* cu);
 
+    static bool
+    IsDWARF64(const DWARFCompileUnit* cu);
+
     static uint8_t
     GetDefaultAddressSize();
 

     uint32_t
     GetProducerVersionUpdate();
 
+    bool
+    IsDWARF64() const;
+
 protected:
     SymbolFileDWARF*    m_dwarf2Data;
     const DWARFAbbreviationDeclarationSet *m_abbrevs;

     std::unique_ptr<DWARFDebugAranges> m_func_aranges_ap;   // A table similar to the .debug_aranges table, but this one points to the exact DW_TAG_subprogram DIEs
     dw_addr_t           m_base_addr;
     dw_offset_t         m_offset;
-    uint32_t            m_length;
+    dw_offset_t         m_length;
     uint16_t            m_version;
     uint8_t             m_addr_size;
     Producer            m_producer;
     uint32_t            m_producer_version_major;
     uint32_t            m_producer_version_minor;
     uint32_t            m_producer_version_update;
+    bool                m_is_dwarf64;
     
     void
     ParseProducerInfo ();

source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp

     m_producer      (eProducerInvalid),
     m_producer_version_major (0),
     m_producer_version_minor (0),
-    m_producer_version_update (0)
+    m_producer_version_update (0),
+    m_is_dwarf64    (false)
 {
 }
 

     m_func_aranges_ap.reset();
     m_user_data     = NULL;
     m_producer      = eProducerInvalid;
+    m_is_dwarf64    = false;
 }
 
 bool

     {
         dw_offset_t abbr_offset;
         const DWARFDebugAbbrev *abbr = m_dwarf2Data->DebugAbbrev();
-        m_length        = debug_info.GetU32(offset_ptr);
+        m_length        = debug_info.GetDWARFInitialLength(offset_ptr);
+        m_is_dwarf64    = debug_info.IsDWARF64();
         m_version       = debug_info.GetU16(offset_ptr);
-        abbr_offset     = debug_info.GetU32(offset_ptr);
+        abbr_offset     = debug_info.GetDWARFOffset(offset_ptr);
         m_addr_size     = debug_info.GetU8 (offset_ptr);
 
         bool length_OK = debug_info.ValidOffset(GetNextCompileUnitOffset()-1);

     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());
+    const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (GetAddressByteSize(), m_is_dwarf64);
     while (offset < next_cu_offset &&
            die.FastExtract (debug_info_data, this, fixed_form_sizes, &offset))
     {

     return DWARFCompileUnit::GetDefaultAddressSize();
 }
 
+bool
+DWARFCompileUnit::IsDWARF64(const DWARFCompileUnit* cu)
+{
+    if (cu)
+        return cu->IsDWARF64();
+    return false;
+}
+
 uint8_t
 DWARFCompileUnit::GetDefaultAddressSize()
 {

 {
     const DWARFDataExtractor* debug_str = &m_dwarf2Data->get_debug_str_data();
 
-    const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (GetAddressByteSize());
+    const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (GetAddressByteSize(), m_is_dwarf64);
 
     Log *log (LogChannelDWARF::GetLogIfAll (DWARF_LOG_LOOKUPS));
     

     return m_producer_version_update;
 }
 
+bool
+DWARFCompileUnit::IsDWARF64() const
+{
+    return m_is_dwarf64;
+}
+

source/Plugins/SymbolFile/DWARF/DWARFDataExtractor.h

     size_t
     GetDWARFSizeofInitialLength() const { return m_is_dwarf64 ? 12 : 4; }
 
+    bool
+    IsDWARF64() const { return m_is_dwarf64; }
+
 protected:
     mutable bool m_is_dwarf64;
 };

source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

                         if (cu->GetVersion() <= 2)
                             form_size = cu->GetAddressByteSize();
                         else
-                            form_size = 4; // 4 bytes for DWARF 32, 8 bytes for DWARF 64, but we don't support DWARF64 yet
+                            form_size = cu->IsDWARF64() ? 8 : 4;
                         break;
 
                     // 0 sized form

                         break;
 
                     // 4 byte values
-                    case DW_FORM_strp        :
                     case DW_FORM_data4       :
                     case DW_FORM_ref4        :
                         form_size = 4;

                         form = debug_info_data.GetULEB128 (&offset);
                         break;
 
+                    case DW_FORM_strp        :
                     case DW_FORM_sec_offset  :
-                        if (cu->GetAddressByteSize () == 4)
-                            debug_info_data.GetU32 (offset_ptr);
-                        else
+                        if (cu->IsDWARF64 ())
                             debug_info_data.GetU64 (offset_ptr);
+                        else
+                            debug_info_data.GetU32 (offset_ptr);
                         break;
 
                     default:

     const DWARFDataExtractor& debug_info_data = dwarf2Data->get_debug_info_data();
 //    const DWARFDataExtractor& debug_str_data = dwarf2Data->get_debug_str_data();
     const uint32_t cu_end_offset = cu->GetNextCompileUnitOffset();
-    const uint8_t cu_addr_size = cu->GetAddressByteSize();
     lldb::offset_t offset = *offset_ptr;
 //  if (offset >= cu_end_offset)
 //      Log::Error("DIE at offset 0x%8.8x is beyond the end of the current compile unit (0x%8.8x)", m_offset, cu_end_offset);

 
                             // Compile unit address sized values
                             case DW_FORM_addr        :
-                                form_size = cu_addr_size;
+                                form_size = cu->GetAddressByteSize();
                                 break;
                             case DW_FORM_ref_addr    :
                                 if (cu->GetVersion() <= 2)
-                                    form_size = cu_addr_size;
+                                    form_size = cu->GetAddressByteSize();
                                 else
-                                    form_size = 4; // 4 bytes for DWARF 32, 8 bytes for DWARF 64, but we don't support DWARF64 yet
+                                    form_size = cu->IsDWARF64() ? 8 : 4;
                                 break;
 
                             // 0 sized form

                                 break;
 
                             // 4 byte values
-                            case DW_FORM_strp        :
-                                form_size = 4;
-                                break;
-
                             case DW_FORM_data4       :
                             case DW_FORM_ref4        :
                                 form_size = 4;

                                 form_is_indirect = true;
                                 break;
 
+                            case DW_FORM_strp        :
                             case DW_FORM_sec_offset  :
-                                if (cu->GetAddressByteSize () == 4)
-                                    debug_info_data.GetU32 (offset_ptr);
-                                else
+                                if (cu->IsDWARF64 ())
                                     debug_info_data.GetU64 (offset_ptr);
+                                else
+                                    debug_info_data.GetU32 (offset_ptr);
                                 break;
 
                             default:

         const DWARFDataExtractor& debug_info_data = dwarf2Data->get_debug_info_data();
 
         if (fixed_form_sizes == NULL)
-            fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize(cu->GetAddressByteSize());
+            fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize(cu->GetAddressByteSize(), cu->IsDWARF64());
 
         const uint32_t num_attributes = abbrevDecl->NumAttributes();
         uint32_t i;

source/Plugins/SymbolFile/DWARF/DWARFDebugLine.cpp

     const char * s;
     prologue->total_length      = debug_line_data.GetDWARFInitialLength(offset_ptr);
     prologue->version           = debug_line_data.GetU16(offset_ptr);
-    if (prologue->version < 2 || prologue->version > 3)
+    if (prologue->version < 2 || prologue->version > 4)
       return false;
 
     prologue->prologue_length   = debug_line_data.GetDWARFOffset(offset_ptr);

     (void)debug_line_data.GetDWARFInitialLength(&offset);
     const char * s;
     uint32_t version = debug_line_data.GetU16(&offset);
-    if (version < 2 || version > 3)
+    if (version < 2 || version > 4)
       return false;
 
     const dw_offset_t end_prologue_offset = debug_line_data.GetDWARFOffset(&offset) + offset;

                 // relocatable address. All of the other statement program opcodes
                 // that affect the address register add a delta to it. This instruction
                 // stores a relocatable value into it instead.
-                state.address = debug_line_data.GetAddress(offset_ptr);
+                if (arg_size == 4)
+                    state.address = debug_line_data.GetU32(offset_ptr);
+                else // arg_size == 8
+                    state.address = debug_line_data.GetU64(offset_ptr);
                 break;
 
             case DW_LNE_define_file:

source/Plugins/SymbolFile/DWARF/DWARFDebugPubnames.cpp

 
             DWARFCompileUnit* cu = debug_info->GetCompileUnitAtIndex(cu_idx);
 
-            const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (cu->GetAddressByteSize());
+            const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (cu->GetAddressByteSize(), cu->IsDWARF64());
 
             bool clear_dies = cu->ExtractDIEsIfNeeded (false) > 1;
 

source/Plugins/SymbolFile/DWARF/DWARFFormValue.h

 //  static bool         PutUnsigned(dw_form_t form, dw_offset_t offset, uint64_t value, BinaryStreamBuf& out_buff, const DWARFCompileUnit* cu, bool fixup_cu_relative_refs);
     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);
+    static const uint8_t * GetFixedFormSizesForAddressSize (uint8_t addr_size, bool is_dwarf64);
     static int          Compare (const DWARFFormValue& a, const DWARFFormValue& b, const DWARFCompileUnit* a_cu, const DWARFCompileUnit* b_cu, const lldb_private::DWARFDataExtractor* debug_str_data_ptr);
 protected:
     dw_form_t   m_form;     // Form for this value

source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp

     8, // 0x20 DW_FORM_ref_sig8
 };
 
+// Difference with g_form_sizes_addr8:
+// DW_FORM_strp and DW_FORM_sec_offset are 8 instead of 4
+static uint8_t
+g_form_sizes_addr8_dwarf64[] =
+{
+    0, // 0x00 unused
+    8, // 0x01 DW_FORM_addr
+    0, // 0x02 unused
+    0, // 0x03 DW_FORM_block2
+    0, // 0x04 DW_FORM_block4
+    2, // 0x05 DW_FORM_data2
+    4, // 0x06 DW_FORM_data4
+    8, // 0x07 DW_FORM_data8
+    0, // 0x08 DW_FORM_string
+    0, // 0x09 DW_FORM_block
+    0, // 0x0a DW_FORM_block1
+    1, // 0x0b DW_FORM_data1
+    1, // 0x0c DW_FORM_flag
+    0, // 0x0d DW_FORM_sdata
+    8, // 0x0e DW_FORM_strp
+    0, // 0x0f DW_FORM_udata
+    0, // 0x10 DW_FORM_ref_addr (addr size for DWARF2 and earlier, 4 bytes for DWARF32, 8 bytes for DWARF32 in DWARF 3 and later
+    1, // 0x11 DW_FORM_ref1
+    2, // 0x12 DW_FORM_ref2
+    4, // 0x13 DW_FORM_ref4
+    8, // 0x14 DW_FORM_ref8
+    0, // 0x15 DW_FORM_ref_udata
+    0, // 0x16 DW_FORM_indirect
+    8, // 0x17 DW_FORM_sec_offset
+    0, // 0x18 DW_FORM_exprloc
+    0, // 0x19 DW_FORM_flag_present
+    0, // 0x1a
+    0, // 0x1b
+    0, // 0x1c
+    0, // 0x1d
+    0, // 0x1e
+    0, // 0x1f
+    8, // 0x20 DW_FORM_ref_sig8
+};
+
 const uint8_t * 
-DWARFFormValue::GetFixedFormSizesForAddressSize (uint8_t addr_size)
+DWARFFormValue::GetFixedFormSizesForAddressSize (uint8_t addr_size, bool is_dwarf64)
 {
-    switch (addr_size)
-    {
-    case 4: return g_form_sizes_addr4;
-    case 8: return g_form_sizes_addr8;
+    if (!is_dwarf64) {
+        switch (addr_size)
+        {
+        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;
+        // is_dwarf64 && addr_size == 4 : no provider does this.
     }
     return NULL;
 }

     bool indirect = false;
     bool is_block = false;
     m_value.data = NULL;
+    uint8_t ref_addr_size;
     // Read the value for the form into value and follow and DW_FORM_indirect instances we run into
     do
     {

         case DW_FORM_data1:     m_value.value.uval = data.GetU8(offset_ptr);                            break;
         case DW_FORM_flag:      m_value.value.uval = data.GetU8(offset_ptr);                            break;
         case DW_FORM_sdata:     m_value.value.sval = data.GetSLEB128(offset_ptr);                       break;
-        case DW_FORM_strp:      m_value.value.uval = data.GetU32(offset_ptr);                           break;
+        case DW_FORM_strp:      m_value.value.uval = data.GetMaxU64(offset_ptr, DWARFCompileUnit::IsDWARF64(cu) ? 8 : 4);  break;
     //  case DW_FORM_APPLE_db_str:
         case DW_FORM_udata:     m_value.value.uval = data.GetULEB128(offset_ptr);                       break;
-        case DW_FORM_ref_addr:
-            if (cu->GetVersion() <= 2)
-                m_value.value.uval = data.GetMaxU64(offset_ptr, DWARFCompileUnit::GetAddressByteSize(cu));
-            else
-                m_value.value.uval = data.GetU32(offset_ptr); // 4 for DWARF32, 8 for DWARF64, but we don't support DWARF64 yet
-            break;
+        case DW_FORM_ref_addr:  ref_addr_size = 4;
+                                if (cu) {
+                                    if (cu->GetVersion() <= 2)
+                                        ref_addr_size = cu->GetAddressByteSize();
+                                    else
+                                        ref_addr_size = cu->IsDWARF64() ? 8 : 4;
+                                }
+                                m_value.value.uval = data.GetMaxU64(offset_ptr, ref_addr_size);         break;
         case DW_FORM_ref1:      m_value.value.uval = data.GetU8(offset_ptr);                            break;
         case DW_FORM_ref2:      m_value.value.uval = data.GetU16(offset_ptr);                           break;
         case DW_FORM_ref4:      m_value.value.uval = data.GetU32(offset_ptr);                           break;

             indirect = true;
             break;
 
-        case DW_FORM_sec_offset:    m_value.value.uval = data.GetU32(offset_ptr);                       break;
+        case DW_FORM_sec_offset:    m_value.value.uval = data.GetMaxU64(offset_ptr, DWARFCompileUnit::IsDWARF64(cu) ? 8 : 4);  break;
         case DW_FORM_flag_present:  m_value.value.uval = 1;                                             break;
         case DW_FORM_ref_sig8:      m_value.value.uval = data.GetU64(offset_ptr);                       break;
         default:

 bool
 DWARFFormValue::SkipValue(dw_form_t form, const DWARFDataExtractor& debug_info_data, lldb::offset_t *offset_ptr, const DWARFCompileUnit* cu)
 {
+    uint8_t ref_addr_size;
     switch (form)
     {
     // Blocks if inlined data that have a length field and the data bytes

         return true;
 
     case DW_FORM_ref_addr:
-        if (cu->GetVersion() <= 2)
-            *offset_ptr += DWARFCompileUnit::GetAddressByteSize(cu);
-        else
-            *offset_ptr += 4;// 4 for DWARF32, 8 for DWARF64, but we don't support DWARF64 yet
+        ref_addr_size = 4;
+        if (cu) {
+            if (cu->GetVersion() <= 2)
+                ref_addr_size = cu->GetAddressByteSize();
+            else
+                ref_addr_size = cu->IsDWARF64() ? 8 : 4;
+        }
+        *offset_ptr += ref_addr_size;
         return true;
 
     // 0 bytes values (implied from DW_FORM)

 
     // 32 bit for DWARF 32, 64 for DWARF 64
     case DW_FORM_sec_offset:
-        *offset_ptr += 4;
+    case DW_FORM_strp:
+        *offset_ptr += (cu->IsDWARF64() ? 8 : 4);
         return true;
 
     // 4 byte values
-    case DW_FORM_strp:
     case DW_FORM_data4:
     case DW_FORM_ref4:
         *offset_ptr += 4;

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

     case DW_TAG_template_type_parameter:
     case DW_TAG_template_value_parameter:
         {
-            const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (dwarf_cu->GetAddressByteSize());
+            const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (dwarf_cu->GetAddressByteSize(), dwarf_cu->IsDWARF64());
 
             DWARFDebugInfoEntry::Attributes attributes;
             const size_t num_attributes = die->GetAttributes (this, 

 
     size_t count = 0;
     const DWARFDebugInfoEntry *die;
-    const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (dwarf_cu->GetAddressByteSize());
+    const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (dwarf_cu->GetAddressByteSize(), dwarf_cu->IsDWARF64());
     uint32_t member_idx = 0;
     BitfieldInfo last_field_info;
     ModuleSP module = GetObjectFile()->GetModule();

     if (parent_die == NULL)
         return 0;
 
-    const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (dwarf_cu->GetAddressByteSize());
+    const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (dwarf_cu->GetAddressByteSize(), dwarf_cu->IsDWARF64());
 
     size_t arg_idx = 0;
     const DWARFDebugInfoEntry *die;

 
     size_t enumerators_added = 0;
     const DWARFDebugInfoEntry *die;
-    const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (dwarf_cu->GetAddressByteSize());
+    const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (dwarf_cu->GetAddressByteSize(), dwarf_cu->IsDWARF64());
 
     for (die = parent_die->GetFirstChild(); die != NULL; die = die->GetSibling())
     {

         return;
 
     const DWARFDebugInfoEntry *die;
-    const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (dwarf_cu->GetAddressByteSize());
+    const uint8_t *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();

                             else if (DWARFFormValue::IsDataForm(form_value.Form()))
                             {
                                 // Retrieve the value as a data expression.
-                                const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (dwarf_cu->GetAddressByteSize());
+                                const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (dwarf_cu->GetAddressByteSize(), dwarf_cu->IsDWARF64());
                                 uint32_t data_offset = attributes.DIEOffsetAtIndex(i);
                                 uint32_t data_length = fixed_form_sizes[form_value.Form()];
                                 if (data_length == 0)

                                 // Retrieve the value as a string expression.
                                 if (form_value.Form() == DW_FORM_strp)
                                 {
-                                    const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (dwarf_cu->GetAddressByteSize());
+                                    const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (dwarf_cu->GetAddressByteSize(), dwarf_cu->IsDWARF64());
                                     uint32_t data_offset = attributes.DIEOffsetAtIndex(i);
                                     uint32_t data_length = fixed_form_sizes[form_value.Form()];
                                     location.CopyOpcodeData(module, debug_info_data, data_offset, data_length);