Add support for more types of DWARF data

cle/backends/elf/elf.py

@@ -39,7 +39,7 @@
 from .subprogram import LexicalBlock, Subprogram
 from .symbol import ELFSymbol, Symbol, SymbolType
 from .variable import Variable
-from .variable_type import VariableType
+from .variable_type import VariableType, SubprogramType
 
 try:
     import pypcode
@@ -761,7 +761,7 @@ def _load_dies(self, dwarf: DWARFInfo):
                     if VariableType.supported_die(die):
                         var_type = VariableType.read_from_die(die, self)
                         if var_type is not None:
-                            type_list[die.offset] = var_type
+                            type_list[cu.cu_offset + die.offset] = var_type
             except KeyError:
                 # pyelftools is not very resilient - we need to catch KeyErrors here
                 continue
@@ -863,16 +863,20 @@ def _load_die_lex_block(
                 return None
 
         if subprogram is None:
-            subprogram = block = Subprogram(name, low_pc, high_pc, ranges)
+            subprogram = block = Subprogram.from_die(die, self, name, low_pc, high_pc, ranges)
         else:
             block = LexicalBlock(low_pc, high_pc, ranges)
 
         for sub_die in cu.iter_DIE_children(die):
-            if sub_die.tag in ["DW_TAG_variable", "DW_TAG_formal_parameter"]:
+            is_variable = sub_die.tag == "DW_TAG_variable"
+            is_formal_parameter = sub_die.tag == "DW_TAG_formal_parameter"
+            if is_variable or is_formal_parameter:
                 # load local variable
                 var = Variable.from_die(sub_die, expr_parser, self, block)
                 var.decl_file = file_path
                 subprogram.local_variables.append(var)
+                if is_formal_parameter:
+                    subprogram.parameters.append(var)
             elif sub_die.tag == "DW_TAG_lexical_block":
                 sub_block = self._load_die_lex_block(
                     sub_die, dwarf, aranges, expr_parser, type_list, cu, file_path, subprogram, namespace

cle/backends/elf/subprogram.py

@@ -1,9 +1,17 @@
 from __future__ import annotations
 
+from typing import TYPE_CHECKING
+
+from elftools.dwarf.die import DIE
+
 from cle.backends.inlined_function import InlinedFunction
 
 from .variable import Variable
 
+from .variable_type import VariableType
+
+if TYPE_CHECKING:
+    from .elf import ELF
 
 class LexicalBlock:
     """
@@ -41,6 +49,7 @@ class Subprogram(LexicalBlock):
     DW_TAG_subprogram for DWARF. The behavior is mostly inherited from
     LexicalBlock to avoid redundancy.
 
+    :param elf_object: The ELF object containing the subprogram
     :param name:     The name of the function/program
     :param low_pc:   The relative start address of the subprogram
     :param high_pc:  The relative end address of the subprogram
@@ -52,11 +61,35 @@ class Subprogram(LexicalBlock):
     """
 
     def __init__(
-        self, name: str | None, low_pc: int | None, high_pc: int | None, ranges: list[tuple[int, int]] | None = None
+        self, elf_object: ELF, name: str | None, linkage_name: str | None, low_pc: int | None, high_pc: int | None,
+        ranges: list[tuple[int, int]] | None = None,
     ) -> None:
+        self._elf_object = elf_object
         # pass self as the super_block of this subprogram
         self.subprogram = self
         super().__init__(low_pc, high_pc, ranges)
         self.name = name
+        self.linkage_name = linkage_name
+        self.parameters: list[Variable] = []
         self.local_variables: list[Variable] = []
         self.inlined_functions: list[InlinedFunction] = []
+        self._return_type_offset = None
+
+    @staticmethod
+    def from_die(die: DIE, elf_object: ELF, name: str | None, low_pc: int | None, high_pc: int | None, ranges: list[tuple[int, int]] | None = None):
+        linkage_name_attr = die.attributes.get("DW_AT_linkage_name", None)
+        linkage_name = None if linkage_name_attr is None else linkage_name_attr.value.decode()
+
+        sub_prg = Subprogram(elf_object, name, linkage_name, low_pc, high_pc, ranges=ranges)
+        if "DW_AT_type" in die.attributes:
+            sub_prg._return_type_offset = die.attributes["DW_AT_type"].value + die.cu.cu_offset
+        return sub_prg
+
+    @property
+    def return_type(self) -> VariableType | None:
+        # Note that in DWARF an omitted return type typically means a void return type
+        try:
+            return self._elf_object.type_list[self._return_type_offset]
+        except KeyError:
+            return None
+