angr 9.2.116__py3-none-manylinux2014_aarch64.whl → 9.2.118__py3-none-manylinux2014_aarch64.whl

angr/analyses/propagator/engine_vex.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from typing import TYPE_CHECKING
 import logging
 
@@ -25,7 +26,7 @@ class SimEnginePropagatorVEX(
     SimEngineLightVEXMixin,
     SimEnginePropagatorBase,
 ):
-    state: "PropagatorVEXState"
+    state: PropagatorVEXState
 
     #
     # Private methods
@@ -33,13 +34,12 @@ class SimEnginePropagatorVEX(
 
     def _process_block_end(self):
         super()._process_block_end()
-        if self.block.vex.jumpkind == "Ijk_Call":
-            if self.arch.call_pushes_ret:
-                # pop ret from the stack
-                sp_offset = self.arch.sp_offset
-                sp_value = self.state.load_register(sp_offset, self.arch.bytes)
-                if sp_value is not None:
-                    self.state.store_register(sp_offset, self.arch.bytes, sp_value + self.arch.bytes)
+        if self.block.vex.jumpkind == "Ijk_Call" and self.arch.call_pushes_ret:
+            # pop ret from the stack
+            sp_offset = self.arch.sp_offset
+            sp_value = self.state.load_register(sp_offset, self.arch.bytes)
+            if sp_value is not None:
+                self.state.store_register(sp_offset, self.arch.bytes, sp_value + self.arch.bytes)
 
         if self.block.vex.jumpkind == "Ijk_Call" or self.block.vex.jumpkind.startswith("Ijk_Sys"):
             self._handle_return_from_call()
@@ -54,16 +54,21 @@ class SimEnginePropagatorVEX(
     def _expr(self, expr):
         v = super()._expr(expr)
 
-        if v is not None and type(v) not in {Bottom, Top} and v is not expr:
+        if (
+            v is not None
+            and type(v) not in {Bottom, Top}
+            and v is not expr
+            and type(expr) is pyvex.IRExpr.Get
+            and expr.offset
+            not in (
+                self.arch.sp_offset,
+                self.arch.ip_offset,
+            )
+        ):
             # Record the replacement
-            if type(expr) is pyvex.IRExpr.Get:
-                if expr.offset not in (
-                    self.arch.sp_offset,
-                    self.arch.ip_offset,
-                ):
-                    self.state.add_replacement(
-                        self._codeloc(block_only=False), VEXReg(expr.offset, expr.result_size(self.tyenv) // 8), v
-                    )
+            self.state.add_replacement(
+                self._codeloc(block_only=False), VEXReg(expr.offset, expr.result_size(self.tyenv) // 8), v
+            )
         return v
 
     def _load_data(self, addr, size, endness):
@@ -71,9 +76,8 @@ class SimEnginePropagatorVEX(
             sp_offset = self.extract_offset_to_sp(addr)
             if sp_offset is not None:
                 # Local variable
-                v = self.state.load_local_variable(sp_offset, size, endness)
-                return v
-            elif addr.op == "BVV":
+                return self.state.load_local_variable(sp_offset, size, endness)
+            if addr.op == "BVV":
                 addr = addr.args[0]
                 # Try loading from the state
                 if self._allow_loading(addr, size):
@@ -95,21 +99,20 @@ class SimEnginePropagatorVEX(
     #
 
     def _handle_function(self, addr):
-        if self.arch.name == "X86":
-            if isinstance(addr, claripy.ast.Base) and addr.op == "BVV":
-                try:
-                    b = self._project.loader.memory.load(addr.args[0], 4)
-                except KeyError:
-                    return
-                except TypeError:
-                    return
-
-                if b == b"\x8b\x1c\x24\xc3":
-                    # getpc:
-                    #   mov ebx, [esp]
-                    #   ret
-                    ebx_offset = self.arch.registers["ebx"][0]
-                    self.state.store_register(ebx_offset, 4, claripy.BVV(self.block.addr + self.block.size, 32))
+        if self.arch.name == "X86" and isinstance(addr, claripy.ast.Base) and addr.op == "BVV":
+            try:
+                b = self._project.loader.memory.load(addr.args[0], 4)
+            except KeyError:
+                return
+            except TypeError:
+                return
+
+            if b == b"\x8b\x1c\x24\xc3":
+                # getpc:
+                #   mov ebx, [esp]
+                #   ret
+                ebx_offset = self.arch.registers["ebx"][0]
+                self.state.store_register(ebx_offset, 4, claripy.BVV(self.block.addr + self.block.size, 32))
 
     def _handle_return_from_call(self):
         # FIXME: Handle the specific function calling convention when known
@@ -207,7 +210,7 @@ class SimEnginePropagatorVEX(
             self.tmps[stmt.dst] = None
 
         # add replacement
-        if stmt.dst in self.tmps and self.tmps[stmt.dst]:
+        if self.tmps.get(stmt.dst):
             self.state.add_replacement(self._codeloc(block_only=True), VEXTmp(stmt.dst), self.tmps[stmt.dst])
 
     def _handle_StoreG(self, stmt):
@@ -280,16 +283,14 @@ class SimEnginePropagatorVEX(
         if not self.state.do_binops:
             return self.state.top(expr.result_size(self.tyenv))
 
-        r = super()._handle_Binop(expr)
+        return super()._handle_Binop(expr)
         # print(expr.op, r)
-        return r
 
     def _handle_Triop(self, expr: pyvex.IRExpr.Triop):
         if not self.state.do_binops:
             return self.state.top(expr.result_size(self.tyenv))
 
-        r = super()._handle_Triop(expr)
-        return r
+        return super()._handle_Triop(expr)
 
     def _handle_Conversion(self, expr):
         expr_ = self._expr(expr.args[0])
@@ -303,11 +304,10 @@ class SimEnginePropagatorVEX(
             if expr_.size() > to_size:
                 # truncation
                 return expr_[to_size - 1 : 0]
-            elif expr_.size() < to_size:
+            if expr_.size() < to_size:
                 # extension
                 return claripy.ZeroExt(to_size - expr_.size(), expr_)
-            else:
-                return expr_
+            return expr_
 
         return self._top(to_size)
 
@@ -317,11 +317,10 @@ class SimEnginePropagatorVEX(
             dst = self._expr(stmt.dst)
             if dst is not None and dst.concrete:
                 anno = guard.annotations[0]
-                if isinstance(anno, RegisterComparisonAnnotation):
-                    if anno.cmp_op == "eq":
-                        v = (anno.offset, anno.size, anno.value)
-                        if v not in self.state.block_initial_reg_values[self.block.addr, dst.concrete_value]:
-                            self.state.block_initial_reg_values[self.block.addr, dst.concrete_value].append(v)
+                if isinstance(anno, RegisterComparisonAnnotation) and anno.cmp_op == "eq":
+                    v = (anno.offset, anno.size, anno.value)
+                    if v not in self.state.block_initial_reg_values[self.block.addr, dst.concrete_value]:
+                        self.state.block_initial_reg_values[self.block.addr, dst.concrete_value].append(v)
 
         super()._handle_Exit(stmt)
 

angr/analyses/propagator/outdated_definition_walker.py

@@ -1,4 +1,5 @@
 # pylint:disable=consider-using-in
+from __future__ import annotations
 from typing import TYPE_CHECKING
 from collections.abc import Callable
 
@@ -24,11 +25,11 @@ class OutdatedDefinitionWalker(AILBlockWalker):
         expr,
         expr_defat: CodeLocation,
         current_loc: CodeLocation,
-        state: "PropagatorAILState",
-        arch: "Arch",
+        state: PropagatorAILState,
+        arch: Arch,
         avoid: Expr.Expression | None = None,
-        extract_offset_to_sp: Callable = None,
-        rda: "ReachingDefinitionsModel" = None,
+        extract_offset_to_sp: Callable | None = None,
+        rda: ReachingDefinitionsModel = None,
     ):
         super().__init__()
         self.expr = expr
@@ -117,26 +118,22 @@ class OutdatedDefinitionWalker(AILBlockWalker):
             # the address is not concrete - we check the address first
             super()._handle_Load(expr_idx, expr, stmt_idx, stmt, block)
             # then if the address expression is up-to-date, we check the global store
-            if not self.out_dated:
-                if (
-                    self.state.global_stores
-                    and not all(
-                        self._check_store_precedes_load(CodeLocation(store_block_addr, store_stmt_idx), self.expr_defat)
-                        for store_block_addr, store_stmt_idx, addr, store in self.state.global_stores
-                    )
-                    or self.state.last_stack_store is not None
-                    and not self._check_store_precedes_load(
-                        CodeLocation(*self.state.last_stack_store[:2]), self.expr_defat
-                    )
-                ):
-                    self.out_dated = True
+            if not self.out_dated and (
+                self.state.global_stores
+                and not all(
+                    self._check_store_precedes_load(CodeLocation(store_block_addr, store_stmt_idx), self.expr_defat)
+                    for store_block_addr, store_stmt_idx, addr, store in self.state.global_stores
+                )
+                or self.state.last_stack_store is not None
+                and not self._check_store_precedes_load(CodeLocation(*self.state.last_stack_store[:2]), self.expr_defat)
+            ):
+                self.out_dated = True
 
     def _handle_VEXCCallExpression(
         self, expr_idx: int, expr: Expr.VEXCCallExpression, stmt_idx: int, stmt: Stmt.Statement, block: Block | None
     ):
-        if self.avoid is not None:
-            if any(op == self.avoid for op in expr.operands):
-                self.has_avoid = True
+        if self.avoid is not None and any(op == self.avoid for op in expr.operands):
+            self.has_avoid = True
 
         super()._handle_VEXCCallExpression(expr_idx, expr, stmt_idx, stmt, block)
 
@@ -144,9 +141,7 @@ class OutdatedDefinitionWalker(AILBlockWalker):
     def _reg_overlap(reg0: Expr.Register, reg1: Expr.Register) -> bool:
         if reg0.reg_offset <= reg1.reg_offset < reg0.reg_offset + reg0.size:
             return True
-        if reg1.reg_offset <= reg0.reg_offset < reg1.reg_offset + reg1.size:
-            return True
-        return False
+        return reg1.reg_offset <= reg0.reg_offset < reg1.reg_offset + reg1.size
 
     @staticmethod
     def _check_store_precedes_load(store_defat: CodeLocation | None, load_defat: CodeLocation | None) -> bool:

angr/analyses/propagator/propagator.py

@@ -1,5 +1,6 @@
 # pylint:disable=isinstance-second-argument-not-valid-type
-from typing import Optional, Any, TYPE_CHECKING
+from __future__ import annotations
+from typing import Any, TYPE_CHECKING
 import logging
 import time
 
@@ -17,6 +18,7 @@ from .. import register_analysis
 from ..analysis import Analysis
 from .engine_vex import SimEnginePropagatorVEX
 from .engine_ail import SimEnginePropagatorAIL
+import contextlib
 
 if TYPE_CHECKING:
     from angr.analyses.reaching_definitions.reaching_definitions import ReachingDefinitionsModel
@@ -65,7 +67,7 @@ class PropagatorAnalysis(ForwardAnalysis, Analysis):  # pylint:disable=abstract-
         gp: int | None = None,
         cache_results: bool = False,
         key_prefix: str | None = None,
-        reaching_definitions: Optional["ReachingDefinitionsModel"] = None,
+        reaching_definitions: ReachingDefinitionsModel | None = None,
         immediate_stmt_removal: bool = False,
         profiling: bool = False,
     ):
@@ -79,10 +81,7 @@ class PropagatorAnalysis(ForwardAnalysis, Analysis):  # pylint:disable=abstract-
         else:
             raise ValueError("Unsupported analysis target.")
 
-        if profiling:
-            start = time.perf_counter_ns() / 1000000
-        else:
-            start = 0
+        start = time.perf_counter_ns() / 1000000 if profiling else 0
 
         self._base_state = base_state
         self._function = func
@@ -161,10 +160,8 @@ class PropagatorAnalysis(ForwardAnalysis, Analysis):  # pylint:disable=abstract-
             the_func = self._function
         else:
             if self._func_addr is not None:
-                try:
+                with contextlib.suppress(KeyError):
                     the_func = self.kb.functions.get_by_addr(self._func_addr)
-                except KeyError:
-                    pass
         if the_func is not None:
             bp_as_gpr = the_func.info.get("bp_as_gpr", False)
 
@@ -231,7 +228,7 @@ class PropagatorAnalysis(ForwardAnalysis, Analysis):  # pylint:disable=abstract-
     def _node_key(self, node: ailment.Block | pyvex.IRSB) -> Any:
         if type(node) is ailment.Block:
             return node.addr, node.idx
-        elif type(node) is pyvex.IRSB:
+        if type(node) is pyvex.IRSB:
             return node.addr
         # fallback
         return node
@@ -324,8 +321,7 @@ class PropagatorAnalysis(ForwardAnalysis, Analysis):  # pylint:disable=abstract-
 
         if self.model.node_iterations[block_key] < self._max_iterations:
             return None, state
-        else:
-            return False, state
+        return False, state
 
     def _process_input_state_for_successor(self, node, successor, input_state: PropagatorAILState | PropagatorVEXState):
         if self._only_consts:

angr/analyses/propagator/tmpvar_finder.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from ailment.expression import Expression, Tmp
 from ailment import AILBlockWalkerBase
 

angr/analyses/propagator/top_checker_mixin.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import claripy
 
 from ...engines.light.engine import SimEngineLightMixin
@@ -5,10 +6,7 @@ from ...engines.light.engine import SimEngineLightMixin
 
 class TopCheckerMixin(SimEngineLightMixin):
     def _is_top(self, expr) -> bool:
-        if isinstance(expr, claripy.ast.Base):
-            if "TOP" in expr.variables:
-                return True
-        return False
+        return bool(isinstance(expr, claripy.ast.Base) and "TOP" in expr.variables)
 
     def _top(self, size: int):
         return self.state.top(size)

angr/analyses/propagator/values.py

@@ -1,4 +1,5 @@
 # pylint: disable=unused-argument
+from __future__ import annotations
 
 
 class Top:

angr/analyses/propagator/vex_vars.py

@@ -1,14 +1,15 @@
 # VEX Variables
+from __future__ import annotations
 
 
 class VEXVariable:
     __slots__ = ()
 
     def __hash__(self):
-        raise NotImplementedError()
+        raise NotImplementedError
 
     def __eq__(self, other):
-        raise NotImplementedError()
+        raise NotImplementedError
 
 
 class VEXMemVar:

angr/analyses/proximity_graph.py

@@ -1,4 +1,5 @@
-from typing import Optional, TYPE_CHECKING
+from __future__ import annotations
+from typing import TYPE_CHECKING
 import logging
 
 import networkx
@@ -163,10 +164,10 @@ class ProximityGraphAnalysis(Analysis):
 
     def __init__(
         self,
-        func: "Function",
-        cfg_model: "CFGModel",
-        xrefs: "XRefManager",
-        decompilation: Optional["Decompiler"] = None,
+        func: Function,
+        cfg_model: CFGModel,
+        xrefs: XRefManager,
+        decompilation: Decompiler | None = None,
         expand_funcs: set[int] | None = None,
     ):
         self._function = func
@@ -240,7 +241,7 @@ class ProximityGraphAnalysis(Analysis):
         # condense blank nodes after the graph has been constructed
         self._condense_blank_nodes(self.graph)
 
-    def _endnode_connector(self, func: "Function", subgraph: networkx.DiGraph):
+    def _endnode_connector(self, func: Function, subgraph: networkx.DiGraph):
         """
         Properly connect expanded function call's to proximity graph.
         """
@@ -268,7 +269,7 @@ class ProximityGraphAnalysis(Analysis):
                     subgraph.add_edge(end_node, succ)
 
     def _process_function(
-        self, func: "Function", graph: networkx.DiGraph, func_proxi_node: FunctionProxiNode | None = None
+        self, func: Function, graph: networkx.DiGraph, func_proxi_node: FunctionProxiNode | None = None
     ) -> list[FunctionProxiNode]:
         to_expand: list[FunctionProxiNode] = []
         found_blocks: dict[BlockNode:BaseProxiNode] = {}
@@ -289,10 +290,7 @@ class ProximityGraphAnalysis(Analysis):
                         found_blocks[block] = node
 
         # subgraph check - do before in case of recursion
-        if self.graph == graph:
-            subgraph = False
-        else:
-            subgraph = True
+        subgraph = self.graph != graph
 
         for edge in func.graph.edges:
             nodes = ()
@@ -346,7 +344,7 @@ class ProximityGraphAnalysis(Analysis):
             args.append(UnknownProxiNode("_"))
 
     def _process_decompilation(
-        self, graph: networkx.DiGraph, decompilation: "Decompiler", func_proxi_node: FunctionProxiNode | None = None
+        self, graph: networkx.DiGraph, decompilation: Decompiler, func_proxi_node: FunctionProxiNode | None = None
     ) -> list[FunctionProxiNode]:
         to_expand: list[FunctionProxiNode] = []
 
@@ -391,10 +389,7 @@ class ProximityGraphAnalysis(Analysis):
             _handle_Call(stmt_idx, expr, block)
 
         # subgraph check - do before in case of recursion
-        if self.graph == graph:
-            subgraph = False
-        else:
-            subgraph = True
+        subgraph = self.graph != graph
 
         # Keep all default handlers, but overwrite necessary ones:
         bw = AILBlockWalker()
@@ -418,10 +413,7 @@ class ProximityGraphAnalysis(Analysis):
                             graph.add_edge(self.handled_stmts[idx - 1], current)
                     # If first block in edge, LAST handled node -> next node
                     # Else (second block in edge), prev node -> FIRST handled node
-                    if block == ail_edge[0]:
-                        proxi_node = self.handled_stmts[-1]
-                    else:
-                        proxi_node = self.handled_stmts[0]
+                    proxi_node = self.handled_stmts[-1] if block == ail_edge[0] else self.handled_stmts[0]
 
                     # Clear the handled stmts for next block
                     self.handled_stmts = []

angr/analyses/reaching_definitions/__init__.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from typing import Set, Optional, Union, TYPE_CHECKING
 
 from ...knowledge_plugins.key_definitions import LiveDefinitions
@@ -42,15 +43,15 @@ __all__ = (
 )
 
 
-def get_all_definitions(region: "MultiValuedMemory") -> set["Definition"]:
-    all_defs: set["Definition"] = set()
+def get_all_definitions(region: MultiValuedMemory) -> set[Definition]:
+    all_defs: set[Definition] = set()
 
     # MultiValuedMemory only uses ListPage internally
     for page in region._pages.values():
-        page: "MVListPage"
+        page: MVListPage
 
         for idx in page.stored_offset:
-            cnt_set: Union["SimMemoryObject", set["SimMemoryObject"]] | None = page.content[idx]
+            cnt_set: SimMemoryObject | set[SimMemoryObject] | None = page.content[idx]
             if cnt_set is None:
                 continue
             if type(cnt_set) is not set:

angr/analyses/reaching_definitions/call_trace.py

@@ -1,3 +1,6 @@
+from __future__ import annotations
+
+
 class CallSite:
     """
     Describes a call site on a CFG.
@@ -17,7 +20,7 @@ class CallSite:
     def __repr__(self):
         result = f"<CallSite in function {self.caller_func_addr:#x}, calling {self.callee_func_addr:#x}"
         if self.block_addr is not None:
-            result += "at block %#x" % self.block_addr
+            result += f"at block {self.block_addr:#x}"
         result += ">"
         return result
 
@@ -52,7 +55,7 @@ class CallTrace:
             return self.target
         return self.callsites[-1].caller_func_addr
 
-    def step_back(self, caller_func_addr: int, block_addr: int | None, callee_func_addr) -> "CallTrace":
+    def step_back(self, caller_func_addr: int, block_addr: int | None, callee_func_addr) -> CallTrace:
         # create a new CallSite object
         site = CallSite(caller_func_addr, block_addr, callee_func_addr)
         t = self.copy()
@@ -62,11 +65,9 @@ class CallTrace:
     def includes_function(self, func_addr: int) -> bool:
         if self.target == func_addr:
             return True
-        if any(cs.caller_func_addr == func_addr for cs in self.callsites):
-            return True
-        return False
+        return bool(any(cs.caller_func_addr == func_addr for cs in self.callsites))
 
-    def copy(self) -> "CallTrace":
+    def copy(self) -> CallTrace:
         t = CallTrace(self.target)
         t.callsites = self.callsites[::]
         return t

angr/analyses/reaching_definitions/dep_graph.py

@@ -1,5 +1,5 @@
+from __future__ import annotations
 from typing import (
-    Optional,
     TYPE_CHECKING,
     overload,
     Literal,
@@ -52,7 +52,7 @@ class DepGraph:
     Mostly a wrapper around a <networkx.DiGraph>.
     """
 
-    def __init__(self, graph: Optional["networkx.DiGraph[Definition]"] = None):
+    def __init__(self, graph: networkx.DiGraph[Definition] | None = None):
         """
         :param graph: A graph where nodes are definitions, and edges represent uses.
         """
@@ -60,12 +60,12 @@ class DepGraph:
         self._transitive_closures: dict = {}
 
         if graph and not all(map(_is_definition, graph.nodes)):
-            raise TypeError("In a DepGraph, nodes need to be <%s>s." % Definition.__name__)
+            raise TypeError(f"In a DepGraph, nodes need to be <{Definition.__name__}>s.")
 
-        self._graph: "networkx.DiGraph[Definition]" = graph if graph is not None else networkx.DiGraph()
+        self._graph: networkx.DiGraph[Definition] = graph if graph is not None else networkx.DiGraph()
 
     @property
-    def graph(self) -> "networkx.DiGraph[Definition]":
+    def graph(self) -> networkx.DiGraph[Definition]:
         return self._graph
 
     def add_node(self, node: Definition) -> None:
@@ -84,7 +84,7 @@ class DepGraph:
         """
         self._graph.add_edge(source, destination, **labels)
 
-    def nodes(self) -> "networkx.classes.reportviews.NodeView[Definition]":
+    def nodes(self) -> networkx.classes.reportviews.NodeView[Definition]:
         return self._graph.nodes()
 
     def predecessors(self, node: Definition) -> Iterator[Definition]:
@@ -93,7 +93,7 @@ class DepGraph:
         """
         return self._graph.predecessors(node)
 
-    def transitive_closure(self, definition: Definition[Atom]) -> "networkx.DiGraph[Definition[Atom]]":
+    def transitive_closure(self, definition: Definition[Atom]) -> networkx.DiGraph[Definition[Atom]]:
         """
         Compute the "transitive closure" of a given definition.
         Obtained by transitively aggregating the ancestors of this definition in the graph.
@@ -106,8 +106,8 @@ class DepGraph:
 
         def _transitive_closure(
             def_: Definition[Atom],
-            graph: "networkx.DiGraph[Definition[Atom]]",
-            result: "networkx.DiGraph[Definition[Atom]]",
+            graph: networkx.DiGraph[Definition[Atom]],
+            result: networkx.DiGraph[Definition[Atom]],
             visited: set[Definition[Atom]] | None = None,
         ):
             """
@@ -147,7 +147,7 @@ class DepGraph:
         return _transitive_closure(definition, self._graph, networkx.DiGraph())
 
     def contains_atom(self, atom: Atom) -> bool:
-        return any(map(lambda definition: definition.atom == atom, self.nodes()))
+        return any(definition.atom == atom for definition in self.nodes())
 
     def add_dependencies_for_concrete_pointers_of(
         self, values: Iterable[claripy.ast.Base | int], definition: Definition, cfg: CFGModel, loader: Loader
@@ -163,13 +163,10 @@ class DepGraph:
         """
         assert definition in self.nodes(), "The given Definition must be present in the given graph."
 
-        known_predecessor_addresses: list[int | claripy.ast.Base] = list(
-            # Needs https://github.com/python/mypy/issues/6847
-            map(
-                lambda definition: definition.atom.addr,  # type: ignore
-                filter(lambda p: isinstance(p.atom, MemoryLocation), self.predecessors(definition)),
-            )
-        )
+        known_predecessor_addresses: list[int | claripy.ast.Base] = [
+            definition.atom.addr
+            for definition in filter(lambda p: isinstance(p.atom, MemoryLocation), self.predecessors(definition))
+        ]
 
         # concretize addresses where possible
         concrete_known_pred_addresses = []
@@ -184,9 +181,8 @@ class DepGraph:
         for v in values:
             if isinstance(v, claripy.ast.Base) and v.concrete:
                 v = v.concrete_value
-            if isinstance(v, int):
-                if v not in concrete_known_pred_addresses:
-                    unknown_concrete_addresses.add(v)
+            if isinstance(v, int) and v not in concrete_known_pred_addresses:
+                unknown_concrete_addresses.add(v)
 
         for address in unknown_concrete_addresses:
             data_at_address = cfg.memory_data.get(address, None) if cfg is not None else None
@@ -201,8 +197,7 @@ class DepGraph:
             def _string_and_length_from(data_at_address):
                 if data_at_address.content is None:
                     return UNDEFINED, data_at_address.size
-                else:
-                    return data_at_address.content.decode("utf-8"), data_at_address.size + 1
+                return data_at_address.content.decode("utf-8"), data_at_address.size + 1
 
             _, string_length = _string_and_length_from(data_at_address)
 
@@ -438,7 +433,7 @@ class DepGraph:
         while queue:
             path = queue.pop()
             for succ in self.graph.succ[path[-1]]:
-                newpath = path + (succ,)
+                newpath = (*path, succ)
                 if succ in ends:
                     yield newpath
                 elif succ in seen: