DW_FORM_ref_sig8 support (#595)

* DW_FORM_ref_sig8 support

* Nitpicks addressed

* Minor fixes

* More minor fixes

Author: sevaa

elftools/dwarf/datatype_cpp.py

@@ -229,6 +229,8 @@ def DIE_is_ptr_to_member_struct(type_die):
 
 def _strip_type_tag(die):
     """Given a DIE with DW_TAG_foo_type, returns foo"""
+    if isinstance(die.tag, int): # User-defined tag 
+        return ""
     return die.tag[7:-5]
 
 def _array_subtype_size(sub):

elftools/dwarf/die.py

@@ -118,8 +118,7 @@ def get_DIE_from_attribute(self, name):
         elif attr.form in ('DW_FORM_ref_addr'):
             return self.cu.dwarfinfo.get_DIE_from_refaddr(attr.raw_value)
         elif attr.form in ('DW_FORM_ref_sig8'):
-            # Implement search type units for matching signature
-            raise NotImplementedError('%s (type unit by signature)' % attr.form)
+            return self.cu.dwarfinfo.get_DIE_by_sig8(attr.raw_value)
         elif attr.form in ('DW_FORM_ref_sup4', 'DW_FORM_ref_sup8', 'DW_FORM_GNU_ref_alt'):
             if self.dwarfinfo.supplementary_dwarfinfo:
                 return self.dwarfinfo.supplementary_dwarfinfo.get_DIE_from_refaddr(attr.raw_value)

elftools/dwarf/dwarfinfo.py

@@ -139,7 +139,7 @@ def __init__(self,
         self._cu_cache = []
         self._cu_offsets_map = []
 
-        # DWARF v4 type units by sig8 - OrderedDict created on Reference
+        # DWARF v4 type units by sig8 - OrderedDict created when needed
         self._type_units_by_sig = None
 
     @property
@@ -179,6 +179,32 @@ def get_DIE_from_refaddr(self, refaddr, cu=None):
         if cu is None:
             cu = self.get_CU_containing(refaddr)
         return cu.get_DIE_from_refaddr(refaddr)
+    
+    def get_DIE_by_sig8(self, sig8):
+        """ Find and return a DIE referenced by its type signature.
+            sig8:
+                The 8 byte signature (as a 64-bit unsigned integer)
+            Returns the DIE with the given type signature by searching
+            for the Type Unit with the matching signature then finding
+            the DIE at the offset given by the type_die field in the
+            Type Unit header.
+                Signatures are an 64-bit unsigned integers computed by the
+                DWARF producer as specified in the DWARF standard. Each
+                Type Unit contains one signature and the offset to the
+                corresponding DW_AT_type DIE in its unit header.
+                Describing a type can generate several DIEs. By moving
+                a DIE and its related DIEs to a Type Unit and generating
+                a hash of the DIEs and attributes in a flattened form
+                multiple Compile Units in a linked object can reference
+                the same DIE in the overall DWARF structure.
+            In DWARF v4 type units are identified by their appearance in the
+            .debug_types section.
+        """
+        self._parse_debug_types()
+        tu = self._type_units_by_sig.get(sig8)
+        if tu is None:
+            raise KeyError("Signature %016x not found in .debug_types" % sig8)
+        return tu._get_cached_DIE(tu.tu_offset + tu['type_offset'])    
 
     def get_CU_containing(self, refaddr):
         """ Find the CU that includes the given reference address in the
@@ -478,8 +504,8 @@ def _parse_TUs_iter(self, offset=0):
 
     def _parse_debug_types(self):
         """ Check if the .debug_types section is previously parsed. If not,
-        parse all TUs and store them in an OrderedDict using their unique
-        64-bit signature as the key.
+            parse all TUs and store them in an OrderedDict using their unique
+            64-bit signature as the key.
 
             See .get_TU_by_sig8().
         """
@@ -490,9 +516,16 @@ def _parse_debug_types(self):
         if self.debug_types_sec is None:
             return
 
-        # Collect all Type Units in the .debug_types section for access using
-        # their 8-byte unique signature
-        for tu in self._parse_TUs_iter():
+        # Parse all the Type Units in the types section for access by sig8
+        offset = 0
+        while offset < self.debug_types_sec.size:
+            tu = self._parse_TU_at_offset(offset)
+            # Compute the offset of the next TU in the section. The unit_length
+            # field of the TU header contains its size not including the length
+            # field itself.
+            offset = (offset +
+                      tu['unit_length'] +
+                      tu.structs.initial_length_field_size())
             self._type_units_by_sig[tu['signature']] = tu
 
     def _cached_CU_at_offset(self, offset):
@@ -583,7 +616,8 @@ def _parse_TU_at_offset(self, offset):
         dwarf_format = 64 if initial_length == 0xFFFFFFFF else 32
 
         # Temporary structs for parsing the header
-        # The structs for the rest of the TUs depend on the header data.
+        # The structs for the rest of the TU depend on the header data.
+        #
         tu_structs = DWARFStructs(
             little_endian=self.config.little_endian,
             dwarf_format=dwarf_format,

elftools/dwarf/enums.py

@@ -90,7 +90,8 @@
     DW_TAG_skeleton_unit               = 0x4a,
     DW_TAG_immutable_type              = 0x4b,
 
-
+    # Tags between 0x4080 and 0xffff are user-defined.
+    # different implementations may overlap?
 
     DW_TAG_lo_user                     = 0x4080,
     DW_TAG_GNU_template_template_param = 0x4106,
@@ -272,6 +273,8 @@
     DW_AT_MIPS_assumed_shape_dopetype   = 0x2010,
     DW_AT_MIPS_assumed_size             = 0x2011,
 
+    DW_AT_HP_opt_level                  = 0x2014,
+
     DW_AT_sf_names                      = 0x2101,
     DW_AT_src_info                      = 0x2102,
     DW_AT_mac_info                      = 0x2103,

elftools/dwarf/typeunit.py

@@ -185,6 +185,22 @@ def iter_DIE_children(self, die):
 
                 cur_offset = child._terminator.offset + child._terminator.size
 
+    def get_DIE_from_refaddr(self, refaddr):
+        """ Obtain a DIE contained in this CU from a reference.
+            refaddr:
+                The offset into the .debug_info section, which must be
+                contained in this CU or a DWARFError will be raised.
+            When using a reference class attribute with a form that is
+            relative to the compile unit, add unit add the compile unit's
+            .cu_addr before calling this function.
+        """
+        # All DIEs are after the cu header and within the unit
+        dwarf_assert(
+            self.cu_die_offset <= refaddr < self.cu_offset + self.size,
+            'refaddr %s not in DIE range of CU %s' % (refaddr, self.cu_offset))
+
+        return self._get_cached_DIE(refaddr)
+
     #------ PRIVATE ------#
 
     def __getitem__(self, name):

scripts/dwarfdump.py

@@ -84,8 +84,12 @@ def _safe_DIE_linkage_name(die, default=None):
 def _desc_ref(attr, die, extra=''):
     if extra:
         extra = " \"%s\"" % extra
+    if attr.form == 'DW_FORM_ref_addr':
+        return "0x%016x%s" % (attr.value, extra)
+    if attr.form == 'DW_FORM_ref_sig8':
+        return "0x%016x" % attr.value
     # TODO: leading zeros on the addend to CU - sometimes present, sometimes not.
-    # Check by the LLVM sources.
+    # Check by the LLVM sources.    
     return "cu + 0x%04x => {0x%08x}%s" % (
         attr.raw_value,
         die.cu.cu_offset + attr.raw_value,
@@ -225,7 +229,8 @@ def _arch(cu):
     return cu.dwarfinfo.config.machine_arch
 
 def _desc_reg(reg_no, cu):
-    return describe_reg_name(reg_no, _arch(cu), True).upper()
+    reg_name = describe_reg_name(reg_no, _arch(cu), False)
+    return reg_name.upper() if reg_name else ""
 
 def _desc_operation(op, op_name, args, cu):
     # Not sure about regx(regno) and bregx(regno, offset)
@@ -346,7 +351,7 @@ def __init__(self, filename, file, output):
         self.elffile = ELFFile(file)
         self.output = output
         self._dwarfinfo = self.elffile.get_dwarf_info()
-        arches = {"EM_386": "i386", "EM_X86_64": "x86-64", "EM_ARM": "littlearm", "EM_AARCH64": "littleaarch64", "EM_LOONGARCH": "loongarch", "EM_RISCV": "littleriscv", "EM_MIPS": "mips"}
+        arches = {"EM_386": "i386", "EM_X86_64": "x86-64", "EM_ARM": "littlearm", "EM_AARCH64": "littleaarch64", "EM_LOONGARCH": "loongarch", "EM_RISCV": "littleriscv", "EM_MIPS": "mips", "EM_TI_C2000": "unknown"}
         arch = arches[self.elffile['e_machine']]
         bits = self.elffile.elfclass
         self._emitline("%s:	file format elf%d-%s" % (filename, bits, arch))
@@ -387,7 +392,7 @@ def dump_info(self):
                 if not die.is_null(): 
                     self._emitline("0x%08x: %s [%d] %s %s" % (
                         die.offset,
-                        die.tag,
+                        die.tag if isinstance(die.tag, str) else "DW_TAG_unknown_%x" % die.tag,
                         die.abbrev_code,
                         '*' if die.has_children else '',
                         '(0x%08x)' % die.get_parent().offset if die.get_parent() is not None else ''))
@@ -540,6 +545,7 @@ def main(stream=None):
     del ENUM_DW_TAG["DW_TAG_template_value_param"]
     ENUM_DW_TAG['DW_TAG_template_type_parameter'] = 0x2f
     ENUM_DW_TAG['DW_TAG_template_value_parameter'] = 0x30
+    del ENUM_DW_TAG['DW_TAG_lo_user'] # dwarfdump dumps it as unknown
 
     with open(args.file, 'rb') as file:
         try:

test/run_readelf_tests.py

@@ -78,6 +78,10 @@ def run_test_on_file(filename, verbose=False, opt=None):
         #  https://sourceware.org/bugzilla/show_bug.cgi?id=31973
         options.remove('--debug-dump=frames')
         options.remove('--debug-dump=frames-interp')
+        # TODO: Stream parsing errors out with the .debug_aranges section
+        #  generated by IAR EWARM 9.20.4.
+        # https://github.com/STMicroelectronics/STM32CubeWB/issues/109
+        options.remove('--debug-dump=aranges')
 
     for option in options:
         if verbose: testlog.info("..option='%s'" % option)