angr 9.2.118__py3-none-win_amd64.whl → 9.2.120__py3-none-win_amd64.whl

angr/analyses/data_dep/__init__.py

@@ -1,3 +1,16 @@
 from __future__ import annotations
+
 from .data_dependency_analysis import DataDependencyGraphAnalysis
 from .dep_nodes import DepNodeTypes, BaseDepNode, VarDepNode, MemDepNode, ConstantDepNode, TmpDepNode, RegDepNode
+
+
+__all__ = (
+    "DataDependencyGraphAnalysis",
+    "DepNodeTypes",
+    "BaseDepNode",
+    "VarDepNode",
+    "MemDepNode",
+    "ConstantDepNode",
+    "TmpDepNode",
+    "RegDepNode",
+)

angr/analyses/data_dep/data_dependency_analysis.py

@@ -12,11 +12,11 @@ import claripy
 from claripy.ast.bv import BV
 from .dep_nodes import DepNodeTypes, ConstantDepNode, MemDepNode, VarDepNode, RegDepNode, TmpDepNode
 from .sim_act_location import SimActLocation, DEFAULT_LOCATION, ParsedInstruction
-from .. import Analysis
-from ...analyses import AnalysesHub
-from ...errors import AngrDDGError, AngrAnalysisError, SimValueError
-from ...state_plugins import SimActionData
-from ...storage import DefaultMemory
+from angr.analyses import Analysis
+from angr.analyses import AnalysesHub
+from angr.errors import AngrDDGError, AngrAnalysisError, SimValueError
+from angr.state_plugins import SimActionData
+from angr.storage import DefaultMemory
 
 if TYPE_CHECKING:
     from .dep_nodes import BaseDepNode

angr/analyses/datagraph_meta.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 import logging
 
-from ..sim_procedure import SimProcedure
+from angr.sim_procedure import SimProcedure
 
 l = logging.getLogger(name=__name__)
 

angr/analyses/ddg.py

@@ -6,9 +6,9 @@ import networkx
 import pyvex
 from . import Analysis
 
-from ..code_location import CodeLocation
-from ..errors import SimSolverModeError, SimUnsatError, AngrDDGError
-from ..sim_variable import (
+from angr.code_location import CodeLocation
+from angr.errors import SimSolverModeError, SimUnsatError, AngrDDGError
+from angr.sim_variable import (
     SimRegisterVariable,
     SimMemoryVariable,
     SimTemporaryVariable,

angr/analyses/decompiler/__init__.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 from .region_identifier import RegionIdentifier
 from .structured_codegen import CStructuredCodeGenerator, ImportSourceCode
 from .clinic import Clinic
@@ -10,7 +11,31 @@ from .callsite_maker import CallSiteMaker
 from .ail_simplifier import AILSimplifier
 from .ssailification import Ssailification
 from .dephication import GraphDephication, SeqNodeDephication
+from .presets import DECOMPILATION_PRESETS
 from . import structuring
 from . import optimization_passes
 
+
 StructuredCodeGenerator = CStructuredCodeGenerator
+
+
+__all__ = (
+    "RegionIdentifier",
+    "CStructuredCodeGenerator",
+    "ImportSourceCode",
+    "Clinic",
+    "RegionSimplifier",
+    "Decompiler",
+    "options",
+    "options_by_category",
+    "BlockSimplifier",
+    "CallSiteMaker",
+    "AILSimplifier",
+    "Ssailification",
+    "GraphDephication",
+    "SeqNodeDephication",
+    "DECOMPILATION_PRESETS",
+    "structuring",
+    "optimization_passes",
+    "StructuredCodeGenerator",
+)

angr/analyses/decompiler/ail_simplifier.py

@@ -27,14 +27,14 @@ from ailment.expression import (
 
 from angr.analyses.s_reaching_definitions import SRDAModel
 from angr.utils.ail import is_phi_assignment, HasExprWalker
-from ...code_location import CodeLocation, ExternalCodeLocation
-from ...sim_variable import SimStackVariable, SimMemoryVariable, SimVariable
-from ...knowledge_plugins.propagations.states import Equivalence
-from ...knowledge_plugins.key_definitions import atoms
-from ...knowledge_plugins.key_definitions.definition import Definition
-from ...knowledge_plugins.key_definitions.constants import OP_BEFORE
-from ...errors import AngrRuntimeError
-from .. import Analysis, AnalysesHub
+from angr.code_location import CodeLocation, ExternalCodeLocation
+from angr.sim_variable import SimStackVariable, SimMemoryVariable, SimVariable
+from angr.knowledge_plugins.propagations.states import Equivalence
+from angr.knowledge_plugins.key_definitions import atoms
+from angr.knowledge_plugins.key_definitions.definition import Definition
+from angr.knowledge_plugins.key_definitions.constants import OP_BEFORE
+from angr.errors import AngrRuntimeError
+from angr.analyses import Analysis, AnalysesHub
 from .ailgraph_walker import AILGraphWalker
 from .expression_narrower import ExpressionNarrowingWalker
 from .block_simplifier import BlockSimplifier
@@ -475,7 +475,7 @@ class AILSimplifier(Analysis):
                     assert is_phi_assignment(stmt)
 
                     for _, vvar in stmt.src.src_and_vvars:
-                        if vvar.varid == def_.atom.varid:
+                        if vvar is not None and vvar.varid == def_.atom.varid:
                             use_exprs.append((vvar, loc, ("phi-src-expr", (vvar,))))
 
             # replace all uses if necessary

angr/analyses/decompiler/block_simplifier.py

@@ -10,9 +10,9 @@ from ailment import AILBlockWalkerBase
 
 from angr.code_location import ExternalCodeLocation, CodeLocation
 
-from ...analyses.s_propagator import SPropagatorAnalysis
-from ...analyses.s_reaching_definitions import SReachingDefinitionsAnalysis, SRDAModel
-from .. import Analysis, register_analysis
+from angr.analyses.s_propagator import SPropagatorAnalysis
+from angr.analyses.s_reaching_definitions import SReachingDefinitionsAnalysis, SRDAModel
+from angr.analyses import Analysis, register_analysis
 from .peephole_optimizations import (
     MULTI_STMT_OPTS,
     STMT_OPTS,

angr/analyses/decompiler/callsite_maker.py

@@ -11,7 +11,7 @@ from angr.sim_type import SimTypeBottom, SimTypePointer, SimTypeChar, SimTypeInt
 from angr.calling_conventions import SimRegArg, SimStackArg, SimCC, SimStructArg
 from angr.knowledge_plugins.key_definitions.constants import OP_BEFORE
 from angr.analyses import Analysis, register_analysis
-from angr.analyses.s_reaching_definitions.s_rda import SRDAView
+from angr.analyses.s_reaching_definitions import SRDAView
 from angr import SIM_LIBRARIES, SIM_TYPE_COLLECTIONS
 
 if TYPE_CHECKING:
@@ -284,7 +284,9 @@ class CallSiteMaker(Analysis):
 
             if vvar is not None:
                 vvar_value = view.get_vvar_value(vvar)
-                return vvar_value, vvar
+                if not isinstance(vvar_value, Expr.Phi):
+                    return vvar_value, vvar
+                return None, vvar
 
         return None
 
@@ -311,7 +313,7 @@ class CallSiteMaker(Analysis):
                 )
                 if vvar is not None:
                     value = view.get_vvar_value(vvar)
-                    if value is not None:
+                    if value is not None and not isinstance(value, Expr.Phi):
                         return None, value
                     return None, Expr.VirtualVariable(
                         self._atom_idx(),

angr/analyses/decompiler/clinic.py

@@ -12,13 +12,14 @@ import capstone
 
 import ailment
 
-from ...knowledge_base import KnowledgeBase
-from ...knowledge_plugins.functions import Function
-from ...knowledge_plugins.cfg.memory_data import MemoryDataSort
-from ...codenode import BlockNode
-from ...utils import timethis
-from ...calling_conventions import SimRegArg, SimStackArg, SimFunctionArgument
-from ...sim_type import (
+from angr.errors import AngrDecompilationError
+from angr.knowledge_base import KnowledgeBase
+from angr.knowledge_plugins.functions import Function
+from angr.knowledge_plugins.cfg.memory_data import MemoryDataSort
+from angr.codenode import BlockNode
+from angr.utils import timethis
+from angr.calling_conventions import SimRegArg, SimStackArg, SimFunctionArgument
+from angr.sim_type import (
     SimTypeChar,
     SimTypeInt,
     SimTypeLongLong,
@@ -28,17 +29,16 @@ from ...sim_type import (
     SimTypeFloat,
     SimTypePointer,
 )
-from ..stack_pointer_tracker import Register, OffsetVal
-from ...sim_variable import SimVariable, SimStackVariable, SimRegisterVariable, SimMemoryVariable
-from ...procedures.stubs.UnresolvableCallTarget import UnresolvableCallTarget
-from ...procedures.stubs.UnresolvableJumpTarget import UnresolvableJumpTarget
-from .. import Analysis, register_analysis
-from ..cfg.cfg_base import CFGBase
-from ..reaching_definitions import ReachingDefinitionsAnalysis
+from angr.analyses.stack_pointer_tracker import Register, OffsetVal
+from angr.sim_variable import SimVariable, SimStackVariable, SimRegisterVariable, SimMemoryVariable
+from angr.procedures.stubs.UnresolvableCallTarget import UnresolvableCallTarget
+from angr.procedures.stubs.UnresolvableJumpTarget import UnresolvableJumpTarget
+from angr.analyses import Analysis, register_analysis
+from angr.analyses.cfg.cfg_base import CFGBase
+from angr.analyses.reaching_definitions import ReachingDefinitionsAnalysis
 from .return_maker import ReturnMaker
 from .ailgraph_walker import AILGraphWalker, RemoveNodeNotice
 from .optimization_passes import (
-    get_default_optimization_passes,
     OptimizationPassStage,
     RegisterSaveAreaSimplifier,
     StackCanarySimplifier,
@@ -128,7 +128,7 @@ class Clinic(Analysis):
         self._func_graph: networkx.DiGraph | None = None
         self._ail_manager = None
         self._blocks_by_addr_and_size = {}
-        self._entry_node_addr: tuple[int, int | None] = self.function.addr, None
+        self.entry_node_addr: tuple[int, int | None] = self.function.addr, None
 
         self._fold_callexprs_into_conditions = fold_callexprs_into_conditions
         self._insert_labels = insert_labels
@@ -164,8 +164,7 @@ class Clinic(Analysis):
         if optimization_passes is not None:
             self._optimization_passes = optimization_passes
         else:
-            self._optimization_passes = get_default_optimization_passes(self.project.arch, self.project.simos.name)
-            l.debug("Get %d optimization passes for the current binary.", len(self._optimization_passes))
+            self._optimization_passes = []
 
         if self._mode == ClinicMode.DECOMPILE:
             self._analyze_for_decompiling()
@@ -712,11 +711,11 @@ class Clinic(Analysis):
             if self._func_graph.in_degree(node) == 0 and CFGBase._is_noop_block(
                 self.project.arch, self.project.factory.block(node.addr, node.size)
             ):
-                if (node.addr, None) == self._entry_node_addr:
+                if (node.addr, None) == self.entry_node_addr:
                     # this is the entry node. after removing this node, the new entry node will be its successor
                     if self._func_graph.out_degree[node] == 1:
                         succ = next(iter(self._func_graph.successors(node)))
-                        self._entry_node_addr = succ.addr, None
+                        self.entry_node_addr = succ.addr, None
                     else:
                         # we just don't remove this node...
                         continue
@@ -1210,6 +1209,7 @@ class Clinic(Analysis):
                 # of the graph is applied
                 self.unoptimized_graph = self._copy_graph(ail_graph)
 
+            pass_ = timethis(pass_)
             a = pass_(
                 self.function,
                 blocks_by_addr=addr_to_blocks,
@@ -1217,6 +1217,7 @@ class Clinic(Analysis):
                 graph=ail_graph,
                 variable_kb=variable_kb,
                 vvar_id_start=self.vvar_id_start,
+                entry_node_addr=self.entry_node_addr,
                 **kwargs,
             )
             if a.out_graph:
@@ -1238,7 +1239,7 @@ class Clinic(Analysis):
         ail_graph: networkx.DiGraph,
         arg_vvars: dict[int, tuple[ailment.Expr.VirtualVariable, SimVariable]],
     ) -> networkx.DiGraph:
-        entrypoint = next(iter(bb for bb in ail_graph if (bb.addr, bb.idx) == self._entry_node_addr))
+        entrypoint = next(iter(bb for bb in ail_graph if (bb.addr, bb.idx) == self.entry_node_addr))
         new_stmts = []
         for arg in arg_list:
             if not isinstance(arg, SimRegisterVariable):
@@ -1296,7 +1297,7 @@ class Clinic(Analysis):
         ssailification = self.project.analyses.Ssailification(
             self.function,
             ail_graph,
-            entry=next(iter(bb for bb in ail_graph if (bb.addr, bb.idx) == self._entry_node_addr)),
+            entry=next(iter(bb for bb in ail_graph if (bb.addr, bb.idx) == self.entry_node_addr)),
             ail_manager=self._ail_manager,
             ssa_stackvars=False,
             vvar_id_start=self.vvar_id_start,
@@ -1309,7 +1310,7 @@ class Clinic(Analysis):
         ssailification = self.project.analyses.Ssailification(
             self.function,
             ail_graph,
-            entry=next(iter(bb for bb in ail_graph if (bb.addr, bb.idx) == self._entry_node_addr)),
+            entry=next(iter(bb for bb in ail_graph if (bb.addr, bb.idx) == self.entry_node_addr)),
             ail_manager=self._ail_manager,
             ssa_stackvars=True,
             vvar_id_start=self.vvar_id_start,
@@ -1322,7 +1323,7 @@ class Clinic(Analysis):
         dephication = self.project.analyses.GraphDephicationVVarMapping(
             self.function,
             ail_graph,
-            entry=next(iter(bb for bb in ail_graph if (bb.addr, bb.idx) == self._entry_node_addr)),
+            entry=next(iter(bb for bb in ail_graph if (bb.addr, bb.idx) == self.entry_node_addr)),
             vvar_id_start=self.vvar_id_start,
         )
         self.vvar_id_start = dephication.vvar_id_start + 1
@@ -1794,21 +1795,30 @@ class Clinic(Analysis):
         if blocks_by_addr_and_size is None:
             blocks_by_addr_and_size = self._blocks_by_addr_and_size
 
-        node_to_block_mapping = {}
         graph = networkx.DiGraph()
 
-        for node in func_graph.nodes():
-            ail_block = blocks_by_addr_and_size.get((node.addr, node.size), node)
-            node_to_block_mapping[node] = ail_block
-
-            if ail_block is not None:
-                graph.add_node(ail_block)
-
-        for src_node, dst_node, data in func_graph.edges(data=True):
-            src = node_to_block_mapping[src_node]
-            dst = node_to_block_mapping[dst_node]
+        entry_node = next(iter(node for node in func_graph if node.addr == self.entry_node_addr[0]), None)
+        if entry_node is None:
+            raise AngrDecompilationError(
+                f"Entry node with address {self.entry_node_addr[0]:#x} not found in the function graph"
+            )
 
-            if dst is not None:
+        # add the entry node into the graph
+        ail_block = blocks_by_addr_and_size.get((entry_node.addr, entry_node.size))
+        if ail_block is None:
+            raise AngrDecompilationError(f"AIL block at address {entry_node.addr:#x} not found")
+        graph.add_node(ail_block)
+
+        # get all descendants and only include them in the AIL graph.
+        # this way all unreachable blocks will be excluded from the AIL graph.
+        descendants = networkx.descendants(func_graph, entry_node) | {entry_node}
+        for src_node, dst_node, data in networkx.subgraph_view(
+            func_graph, filter_node=lambda n: n in descendants
+        ).edges(data=True):
+            src = blocks_by_addr_and_size.get((src_node.addr, src_node.size))
+            dst = blocks_by_addr_and_size.get((dst_node.addr, dst_node.size))
+
+            if src is not None and dst is not None:
                 graph.add_edge(src, dst, **data)
 
         return graph

angr/analyses/decompiler/condition_processor.py

@@ -12,11 +12,11 @@ from unique_log_filter import UniqueLogFilter
 
 
 from angr.utils.graph import GraphUtils
-from ...utils.lazy_import import lazy_import
-from ...utils import is_pyinstaller
-from ...utils.graph import dominates, inverted_idoms
-from ...block import Block, BlockNode
-from ...errors import AngrRuntimeError
+from angr.utils.lazy_import import lazy_import
+from angr.utils import is_pyinstaller
+from angr.utils.graph import dominates, inverted_idoms
+from angr.block import Block, BlockNode
+from angr.errors import AngrRuntimeError
 from .peephole_optimizations import InvertNegatedLogicalConjunctionsAndDisjunctions
 from .structuring.structurer_nodes import (
     MultiNode,
@@ -56,6 +56,25 @@ _UNIFIABLE_COMPARISONS = {
     "SGE",
 }
 
+
+_INVERSE_OPERATIONS = {
+    "__eq__": "__ne__",
+    "__ne__": "__eq__",
+    "__gt__": "__le__",
+    "__lt__": "__ge__",
+    "__ge__": "__lt__",
+    "__le__": "__gt__",
+    "ULT": "UGE",
+    "UGE": "ULT",
+    "UGT": "ULE",
+    "ULE": "UGT",
+    "SLT": "SGE",
+    "SGE": "SLT",
+    "SLE": "SGT",
+    "SGT": "SLE",
+}
+
+
 #
 # Util methods and mapping used during AIL AST to claripy AST conversion
 #
@@ -138,6 +157,9 @@ _ail2claripy_op_mapping = {
     "SBorrow": lambda expr, _, m: _dummy_bvs(expr, m),
     "ExpCmpNE": lambda expr, _, m: _dummy_bools(expr, m),
     "CmpORD": lambda expr, _, m: _dummy_bvs(expr, m),  # in case CmpORDRewriter fails
+    "GetMSBs": lambda expr, _, m: _dummy_bvs(expr, m),
+    "InterleaveLOV": lambda expr, _, m: _dummy_bvs(expr, m),
+    "InterleaveHIV": lambda expr, _, m: _dummy_bvs(expr, m),
 }
 
 #
@@ -178,7 +200,7 @@ class ConditionProcessor:
             predicate = self._extract_predicate(src, dst, edge_type)
         except EmptyBlockNotice:
             # catch empty block notice - although this should not really happen
-            predicate = claripy.true
+            predicate = claripy.true()
         return predicate
 
     def recover_edge_conditions(self, region, graph=None) -> dict:
@@ -254,15 +276,15 @@ class ConditionProcessor:
 
             if node is head:
                 # the head is always reachable
-                reaching_condition = claripy.true
+                reaching_condition = claripy.true()
             elif idoms is not None and _strictly_postdominates(idoms, node, head):
                 # the node that post dominates the head is always reachable
-                reaching_conditions[node] = claripy.true
+                reaching_conditions[node] = claripy.true()
             else:
                 for pred in preds:
                     edge = (pred, node)
-                    pred_condition = reaching_conditions.get(pred, claripy.true)
-                    edge_condition = edge_conditions.get(edge, claripy.true)
+                    pred_condition = reaching_conditions.get(pred, claripy.true())
+                    edge_condition = edge_conditions.get(edge, claripy.true())
 
                     if reaching_condition is None:
                         reaching_condition = claripy.And(pred_condition, edge_condition)
@@ -596,7 +618,7 @@ class ConditionProcessor:
             return claripy.Not(bool_var)
 
         if type(src_block) is GraphRegion:
-            return claripy.true
+            return claripy.true()
 
         # sometimes the last statement is the conditional jump. sometimes it's the first statement of the block
         if (
@@ -609,10 +631,10 @@ class ConditionProcessor:
             last_stmt = self.get_last_statement(src_block)
 
         if last_stmt is None:
-            return claripy.true
+            return claripy.true()
         if type(last_stmt) is ailment.Stmt.Jump:
             if isinstance(last_stmt.target, ailment.Expr.Const):
-                return claripy.true
+                return claripy.true()
             # indirect jump
             target_ast = self.claripy_ast_from_ail_condition(last_stmt.target)
             return target_ast == dst_block.addr
@@ -622,7 +644,7 @@ class ConditionProcessor:
                 return bool_var
             return claripy.Not(bool_var)
 
-        return claripy.true
+        return claripy.true()
 
     #
     # Expression conversion
@@ -727,6 +749,7 @@ class ConditionProcessor:
             "ZeroExt": lambda cond_, tags: _binary_op_reduce(
                 "Concat", [claripy.BVV(0, cond_.args[0]), cond_.args[1]], tags
             ),
+            "Concat": lambda cond_, tags: _binary_op_reduce("Concat", cond_.args, tags),
         }
 
         if cond.op in _mapping:
@@ -780,8 +803,8 @@ class ConditionProcessor:
                 var = claripy.BoolV(condition.value)
             else:
                 var = claripy.BVV(condition.value, condition.bits)
-            if isinstance(var, claripy.Bits) and var.size() == 1:
-                var = claripy.true if var.concrete_value == 1 else claripy.false
+            if isinstance(var, claripy.ast.Bits) and var.size() == 1:
+                var = claripy.true() if var.concrete_value == 1 else claripy.false()
             return var
         if isinstance(condition, ailment.Expr.Tmp):
             l.warning("Left-over ailment.Tmp variable %s.", condition)
@@ -839,7 +862,7 @@ class ConditionProcessor:
 
         if ast.op in _UNIFIABLE_COMPARISONS:
             # unify comparisons to enable more simplification opportunities without going "deep" in sympy
-            inverse_op = getattr(ast.args[0], claripy.operations.inverse_operations[ast.op])
+            inverse_op = getattr(ast.args[0], _INVERSE_OPERATIONS[ast.op])
             return sympy.Not(ConditionProcessor.claripy_ast_to_sympy_expr(inverse_op(ast.args[1]), memo=memo))
 
         if memo is not None and ast in memo:
@@ -860,9 +883,9 @@ class ConditionProcessor:
         if isinstance(expr, sympy.Not):
             return claripy.Not(ConditionProcessor.sympy_expr_to_claripy_ast(expr.args[0], memo))
         if isinstance(expr, sympy.logic.boolalg.BooleanTrue):
-            return claripy.true
+            return claripy.true()
         if isinstance(expr, sympy.logic.boolalg.BooleanFalse):
-            return claripy.false
+            return claripy.false()
         raise AngrRuntimeError("Unreachable reached")
 
     @staticmethod
@@ -1092,7 +1115,9 @@ class ConditionProcessor:
         for term in all_terms_without_negs:
             neg = negations.get(term)
 
-            replaced_with_true = ConditionProcessor._replace_term_in_ast(cond, term, claripy.true, neg, claripy.false)
+            replaced_with_true = ConditionProcessor._replace_term_in_ast(
+                cond, term, claripy.true(), neg, claripy.false()
+            )
             sat0 = solver.satisfiable(
                 extra_constraints=(
                     cond,
@@ -1108,7 +1133,9 @@ class ConditionProcessor:
             if sat0 or sat1:
                 continue
 
-            replaced_with_false = ConditionProcessor._replace_term_in_ast(cond, term, claripy.false, neg, claripy.true)
+            replaced_with_false = ConditionProcessor._replace_term_in_ast(
+                cond, term, claripy.false(), neg, claripy.true()
+            )
             sat0 = solver.satisfiable(
                 extra_constraints=(
                     cond,

angr/analyses/decompiler/counters/__init__.py

@@ -1,5 +1,16 @@
 from __future__ import annotations
+
 from .boolean_counter import BooleanCounter
 from .call_counter import AILBlockCallCounter
 from .seq_cf_structure_counter import ControlFlowStructureCounter
 from .expression_counters import SingleExpressionCounter, RegisterExpressionCounter, OperatorCounter
+
+
+__all__ = (
+    "BooleanCounter",
+    "AILBlockCallCounter",
+    "ControlFlowStructureCounter",
+    "SingleExpressionCounter",
+    "RegisterExpressionCounter",
+    "OperatorCounter",
+)

angr/analyses/decompiler/decompiler.py

@@ -10,15 +10,14 @@ from cle import SymbolType
 import ailment
 
 from angr.analyses.cfg import CFGFast
-from ...knowledge_plugins.functions.function import Function
-from ...knowledge_base import KnowledgeBase
-from ...sim_variable import SimMemoryVariable, SimRegisterVariable, SimStackVariable
-from ...utils import timethis
-from .. import Analysis, AnalysesHub
+from angr.knowledge_plugins.functions.function import Function
+from angr.knowledge_base import KnowledgeBase
+from angr.sim_variable import SimMemoryVariable, SimRegisterVariable, SimStackVariable
+from angr.utils import timethis
+from angr.analyses import Analysis, AnalysesHub
 from .structuring import RecursiveStructurer, PhoenixStructurer, DEFAULT_STRUCTURER
 from .region_identifier import RegionIdentifier
 from .optimization_passes.optimization_pass import OptimizationPassStage
-from .optimization_passes import get_default_optimization_passes
 from .ailgraph_walker import AILGraphWalker
 from .condition_processor import ConditionProcessor
 from .decompilation_options import DecompilationOption
@@ -26,6 +25,7 @@ from .decompilation_cache import DecompilationCache
 from .utils import remove_labels
 from .sequence_walker import SequenceWalker
 from .structuring.structurer_nodes import SequenceNode
+from .presets import DECOMPILATION_PRESETS, DecompilationPreset
 
 if TYPE_CHECKING:
     from angr.knowledge_plugins.cfg.cfg_model import CFGModel
@@ -52,6 +52,7 @@ class Decompiler(Analysis):
         func: Function | str | int,
         cfg: CFGFast | CFGModel | None = None,
         options=None,
+        preset: str | DecompilationPreset | None = None,
         optimization_passes=None,
         sp_tracker_track_memory=True,
         variable_kb=None,
@@ -73,11 +74,21 @@ class Decompiler(Analysis):
         self.func: Function = func
         self._cfg = cfg.model if isinstance(cfg, CFGFast) else cfg
         self._options = options
-        if optimization_passes is None:
-            self._optimization_passes = get_default_optimization_passes(self.project.arch, self.project.simos.name)
-            l.debug("Get %d optimization passes for the current binary.", len(self._optimization_passes))
-        else:
+
+        if preset is None and optimization_passes:
             self._optimization_passes = optimization_passes
+        else:
+            # we use the preset
+            if isinstance(preset, str):
+                if preset not in DECOMPILATION_PRESETS:
+                    raise KeyError(f"Decompilation preset {preset} is not found")
+                preset = DECOMPILATION_PRESETS[preset]
+            elif preset is None:
+                preset = DECOMPILATION_PRESETS["default"]
+            if not isinstance(preset, DecompilationPreset):
+                raise TypeError('"preset" must be a DecompilationPreset instance')
+            self._optimization_passes = preset.get_optimization_passes(self.project.arch, self.project.simos.name)
+        l.debug("Get %d optimization passes for the current binary.", len(self._optimization_passes))
         self._sp_tracker_track_memory = sp_tracker_track_memory
         self._peephole_optimizations = peephole_optimizations
         self._vars_must_struct = vars_must_struct
@@ -299,6 +310,7 @@ class Decompiler(Analysis):
             update_graph=update_graph,
             force_loop_single_exit=self._force_loop_single_exit,
             complete_successors=self._complete_successors,
+            entry_node_addr=self.clinic.entry_node_addr,
             **self.options_to_params(self.options_by_class["region_identifier"]),
         )
 
@@ -334,6 +346,7 @@ class Decompiler(Analysis):
                 )
                 continue
 
+            pass_ = timethis(pass_)
             a = pass_(
                 self.func,
                 blocks_by_addr=addr_to_blocks,
@@ -341,6 +354,7 @@ class Decompiler(Analysis):
                 graph=ail_graph,
                 variable_kb=self._variable_kb,
                 reaching_definitions=reaching_definitions,
+                entry_node_addr=self.clinic.entry_node_addr,
                 **kwargs,
             )
 
@@ -389,6 +403,7 @@ class Decompiler(Analysis):
                 )
                 continue
 
+            pass_ = timethis(pass_)
             a = pass_(
                 self.func,
                 blocks_by_addr=addr_to_blocks,
@@ -398,6 +413,7 @@ class Decompiler(Analysis):
                 region_identifier=ri,
                 reaching_definitions=reaching_definitions,
                 vvar_id_start=self.vvar_id_start,
+                entry_node_addr=self.clinic.entry_node_addr,
                 **kwargs,
             )
 
@@ -425,6 +441,7 @@ class Decompiler(Analysis):
             if pass_.STAGE != OptimizationPassStage.AFTER_STRUCTURING:
                 continue
 
+            pass_ = timethis(pass_)
             a = pass_(self.func, seq=seq_node, **kwargs)
             if a.out_seq:
                 seq_node = a.out_seq