angr 9.2.138__py3-none-manylinux2014_x86_64.whl → 9.2.140__py3-none-manylinux2014_x86_64.whl

angr/block.py

@@ -130,19 +130,23 @@ class Block(Serializable):
     BLOCK_MAX_SIZE = 4096
 
     __slots__ = [
+        "_backup_state",
         "_bytes",
         "_capstone",
         "_collect_data_refs",
         "_const_prop",
         "_cross_insn_opt",
         "_disassembly",
+        "_extra_stop_points",
         "_initial_regs",
         "_instruction_addrs",
         "_instructions",
         "_load_from_ro_regions",
+        "_max_size",
         "_opt_level",
         "_project",
         "_strict_block_end",
+        "_traceflags",
         "_vex",
         "_vex_nostmt",
         "addr",
@@ -155,11 +159,10 @@ class Block(Serializable):
         self,
         addr,
         project=None,
-        arch: Arch = None,
+        arch: Arch | None = None,
         size=None,
         max_size=None,
         byte_string=None,
-        vex=None,
         thumb=False,
         backup_state=None,
         extra_stop_points=None,
@@ -174,14 +177,11 @@ class Block(Serializable):
         initial_regs=None,
         skip_stmts=False,
     ):
-        # set up arch
-        self.arch: Arch
-        if project is not None:
+        if arch is not None:
+            self.arch = arch
+        elif project is not None:
             self.arch = project.arch
         else:
-            self.arch = arch
-
-        if self.arch is None:
             raise ValueError('Either "project" or "arch" has to be specified.')
 
         if project is not None and backup_state is None and project.kb.patches.values():
@@ -195,63 +195,23 @@ class Block(Serializable):
         else:
             thumb = False
 
-        self._project: Project | None = project
-        self.thumb = thumb
+        self._project = project
         self.addr = addr
+        self._backup_state = backup_state
+        self.thumb = thumb
         self._opt_level = opt_level
-        self._initial_regs: list[tuple[int, int, int]] | None = (
-            initial_regs if (collect_data_refs or const_prop) else None
-        )
+        self._initial_regs = initial_regs if (collect_data_refs or const_prop) else None
+        self._traceflags = traceflags
+        self._extra_stop_points = extra_stop_points
+        self._max_size = max_size if max_size is not None else self.BLOCK_MAX_SIZE
 
         if self._project is None and byte_string is None:
             raise ValueError('"byte_string" has to be specified if "project" is not provided.')
 
-        if size is None:
-            if byte_string is not None:
-                size = len(byte_string)
-            elif vex is not None:
-                size = vex.size
-            else:
-                if self._initial_regs:
-                    self.set_initial_regs()
-                clemory = None
-                if project is not None:
-                    clemory = (
-                        project.loader.memory_ro_view
-                        if project.loader.memory_ro_view is not None
-                        else project.loader.memory
-                    )
-                vex = self._vex_engine.lift_vex(
-                    clemory=clemory,
-                    state=backup_state,
-                    insn_bytes=byte_string,
-                    addr=addr,
-                    size=max_size,
-                    thumb=thumb,
-                    extra_stop_points=extra_stop_points,
-                    opt_level=opt_level,
-                    num_inst=num_inst,
-                    traceflags=traceflags,
-                    strict_block_end=strict_block_end,
-                    collect_data_refs=collect_data_refs,
-                    load_from_ro_regions=load_from_ro_regions,
-                    const_prop=const_prop,
-                    cross_insn_opt=cross_insn_opt,
-                    skip_stmts=skip_stmts,
-                )
-                if self._initial_regs:
-                    self.reset_initial_regs()
-                size = vex.size
-
-        if skip_stmts:
-            self._vex = None
-            self._vex_nostmt = vex
-        else:
-            self._vex = vex
-            self._vex_nostmt = None
+        self._vex = None
+        self._vex_nostmt = None
         self._disassembly = None
         self._capstone = None
-        self.size = size
         self._collect_data_refs = collect_data_refs
         self._strict_block_end = strict_block_end
         self._cross_insn_opt = cross_insn_opt
@@ -261,6 +221,23 @@ class Block(Serializable):
         self._instructions: int | None = num_inst
         self._instruction_addrs: list[int] = []
 
+        self._bytes = byte_string
+        self.size = size
+
+        if size is None:
+            if byte_string is not None:
+                size = len(byte_string)
+            else:
+                vex = self._lift_nocache(skip_stmts)
+                size = vex.size
+
+                if skip_stmts:
+                    self._vex_nostmt = vex
+                else:
+                    self._vex = vex
+
+        self.size = size
+
         if skip_stmts:
             self._parse_vex_info(self._vex_nostmt)
         else:
@@ -343,50 +320,7 @@ class Block(Serializable):
             raise ValueError("Project is not set")
         return self._project.factory.default_engine  # type:ignore
 
-    @property
-    def vex(self) -> IRSB | PcodeIRSB:
-        if not self._vex:
-            if self._initial_regs:
-                self.set_initial_regs()
-            clemory = None
-            if self._project is not None:
-                clemory = (
-                    self._project.loader.memory_ro_view
-                    if self._project.loader.memory_ro_view is not None
-                    else self._project.loader.memory
-                )
-            self._vex = self._vex_engine.lift_vex(
-                clemory=clemory,
-                insn_bytes=self._bytes,
-                addr=self.addr,
-                thumb=self.thumb,
-                size=self.size,
-                num_inst=self._instructions,
-                opt_level=self._opt_level,
-                arch=self.arch,
-                collect_data_refs=self._collect_data_refs,
-                strict_block_end=self._strict_block_end,
-                cross_insn_opt=self._cross_insn_opt,
-                load_from_ro_regions=self._load_from_ro_regions,
-                const_prop=self._const_prop,
-            )
-            if self._initial_regs:
-                self.reset_initial_regs()
-            self._parse_vex_info(self._vex)
-
-        assert self._vex is not None
-        return self._vex
-
-    @property
-    def vex_nostmt(self):
-        if self._vex_nostmt:
-            return self._vex_nostmt
-
-        if self._vex:
-            return self._vex
-
-        if self._initial_regs:
-            self.set_initial_regs()
+    def _lift_nocache(self, skip_stmts: bool) -> IRSB | PcodeIRSB:
         clemory = None
         if self._project is not None:
             clemory = (
@@ -394,25 +328,53 @@ class Block(Serializable):
                 if self._project.loader.memory_ro_view is not None
                 else self._project.loader.memory
             )
-        self._vex_nostmt = self._vex_engine.lift_vex(
+
+        if self._initial_regs:
+            self.set_initial_regs()
+
+        vex = self._vex_engine.lift_vex(
+            addr=self.addr,
+            state=self._backup_state,
             clemory=clemory,
             insn_bytes=self._bytes,
-            addr=self.addr,
-            thumb=self.thumb,
+            arch=self.arch,
             size=self.size,
             num_inst=self._instructions,
+            traceflags=self._traceflags,
+            thumb=self.thumb,
+            extra_stop_points=self._extra_stop_points,
             opt_level=self._opt_level,
-            arch=self.arch,
-            skip_stmts=True,
-            collect_data_refs=self._collect_data_refs,
             strict_block_end=self._strict_block_end,
+            skip_stmts=skip_stmts,
+            collect_data_refs=self._collect_data_refs,
             cross_insn_opt=self._cross_insn_opt,
             load_from_ro_regions=self._load_from_ro_regions,
             const_prop=self._const_prop,
         )
+
         if self._initial_regs:
             self.reset_initial_regs()
+
+        return vex
+
+    @property
+    def vex(self) -> IRSB | PcodeIRSB:
+        if not self._vex:
+            self._vex = self._lift_nocache(False)
+            self._parse_vex_info(self._vex)
+
+        return self._vex
+
+    @property
+    def vex_nostmt(self):
+        if self._vex_nostmt:
+            return self._vex_nostmt
+        if self._vex:
+            return self._vex
+
+        self._vex_nostmt = self._lift_nocache(True)
         self._parse_vex_info(self._vex_nostmt)
+
         return self._vex_nostmt
 
     @property

angr/callable.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 import pycparser
 
+from .sim_manager import SimulationManager
 from .errors import AngrCallableError, AngrCallableMultistateError
 from .calling_conventions import default_cc, SimCC
 
@@ -28,6 +29,7 @@ class Callable:
         cc=None,
         add_options=None,
         remove_options=None,
+        step_limit: int | None = None,
     ):
         """
         :param project:         The project to operate on
@@ -60,6 +62,7 @@ class Callable:
         self._func_ty = prototype
         self._add_options = add_options if add_options else set()
         self._remove_options = remove_options if remove_options else set()
+        self._step_limit = step_limit
 
         self.result_path_group = None
         self.result_state = None
@@ -95,16 +98,12 @@ class Callable:
             remove_options=self._remove_options,
         )
 
-        def step_func(pg):
-            pg2 = pg.prune()
-            if len(pg2.active) > 1:
-                raise AngrCallableMultistateError("Execution split on symbolic condition!")
-            return pg2
-
         caller = self._project.factory.simulation_manager(state)
-        caller.run(step_func=step_func if self._concrete_only else None).unstash(from_stash="deadended")
+        caller.run(step_func=self._step_func).unstash(from_stash="deadended")
         caller.prune(filter_func=lambda pt: pt.addr == self._deadend_addr)
 
+        if "step_limited" in caller.stashes:
+            caller.stash(from_stash="step_limited", to_stash="active")
         if len(caller.active) == 0:
             raise AngrCallableError("No paths returned from function")
 
@@ -159,3 +158,11 @@ class Callable:
                 raise AngrCallableError(f"Unsupported expression type {type(expr)}.")
 
         return self.__call__(*args)
+
+    def _step_func(self, pg: SimulationManager):
+        pg2 = pg.prune()
+        if self._concrete_only and len(pg2.active) > 1:
+            raise AngrCallableMultistateError("Execution split on symbolic condition!")
+        if self._step_limit:
+            pg2.stash(filter_func=lambda p: p.history.depth >= self._step_limit, to_stash="step_limited")
+        return pg2

angr/calling_conventions.py

@@ -11,6 +11,7 @@ import archinfo
 from archinfo import RegisterName
 from unique_log_filter import UniqueLogFilter
 
+import angr
 from .errors import AngrTypeError
 from .sim_type import (
     SimType,
@@ -33,7 +34,6 @@ from .sim_type import (
     SimTypeReference,
 )
 from .state_plugins.sim_action_object import SimActionObject
-from .engines.soot.engine import SootMixin
 
 l = logging.getLogger(name=__name__)
 l.addFilter(UniqueLogFilter())
@@ -307,7 +307,7 @@ class SimRegArg(SimFunctionArgument):
     def __hash__(self):
         return hash((self.size, self.reg_name, self.reg_offset))
 
-    def check_offset(self, arch):
+    def check_offset(self, arch) -> int:
         return arch.registers[self.reg_name][0] + self.reg_offset
 
     def set_value(self, state, value, **kwargs):  # pylint: disable=unused-argument,arguments-differ
@@ -582,7 +582,12 @@ class SimCC:
     FP_RETURN_VAL: SimFunctionArgument | None = (
         None  # The location where floating-point argument return values are stored
     )
-    ARCH = None  # The archinfo.Arch class that this CC must be used for, if relevant
+    ARCH: type[archinfo.Arch] | None = (
+        None  # The archinfo.Arch class for which this CC is most likely relevant, if related
+    )
+    # archinfo.Arch classes for which this CC is relevant, in addition to self.ARCH.
+    # you should access cls.arches() to get a list of all arches for which this CC is relevant
+    EXTRA_ARCHES: tuple[type[archinfo.Arch], ...] = ()
     CALLEE_CLEANUP = False  # Whether the callee has to deallocate the stack space for the arguments
 
     STACK_ALIGNMENT = 1  # the alignment requirement of the stack pointer at function start BEFORE call
@@ -682,7 +687,7 @@ class SimCC:
             ty = ty.with_arch(self.arch)
         if isinstance(ty, (SimStruct, SimUnion, SimTypeFixedSizeArray)):
             raise AngrTypeError(
-                f"{self} doesn't know how to return aggregate types. Consider overriding return_val to "
+                f"{self} doesn't know how to return aggregate types ({type(ty)}). Consider overriding return_val to "
                 "implement its ABI logic"
             )
         if self.return_in_implicit_outparam(ty):
@@ -1082,8 +1087,8 @@ class SimCC:
 
     @classmethod
     def _match(cls, arch, args: list, sp_delta):
-        if cls.ARCH is not None and not isinstance(
-            arch, cls.ARCH
+        if (
+            cls.arches() is not None and ":" not in arch.name and not isinstance(arch, cls.arches())
         ):  # pylint:disable=isinstance-second-argument-not-valid-type
             return False
         if sp_delta != cls.STACKARG_SP_DIFF:
@@ -1149,6 +1154,12 @@ class SimCC:
                 return cc_cls(arch)
         return None
 
+    @classmethod
+    def arches(cls) -> tuple[type[archinfo.Arch], ...]:
+        if cls.ARCH is not None:
+            return (cls.ARCH, *cls.EXTRA_ARCHES)
+        return cls.EXTRA_ARCHES
+
     def get_arg_info(self, state, prototype):
         """
         This is just a simple wrapper that collects the information from various locations
@@ -1323,6 +1334,20 @@ class SimCCMicrosoftAMD64(SimCC):
     def return_val(self, ty, perspective_returned=False):
         if ty._arch is None:
             ty = ty.with_arch(self.arch)
+
+        # Unions are allocated according to the layout of the largest member
+        if isinstance(ty, SimUnion):
+            chosen = None
+            size = None
+            for subty in ty.members.values():
+                if subty.size is not None and (size is None or size < subty.size):
+                    chosen = subty
+                    size = subty.size
+            if chosen is None:
+                # fallback to void*
+                chosen = SimTypePointer(SimTypeBottom())
+            return self.return_val(chosen, perspective_returned=perspective_returned)
+
         if not isinstance(ty, SimStruct):
             return super().return_val(ty, perspective_returned)
 
@@ -1444,7 +1469,7 @@ class SimCCSystemVAMD64(SimCC):
 
     @classmethod
     def _match(cls, arch, args, sp_delta):
-        if cls.ARCH is not None and not isinstance(arch, cls.ARCH):
+        if cls.ARCH is not None and ":" not in arch.name and not isinstance(arch, cls.ARCH):
             return False
         # if sp_delta != cls.STACKARG_SP_DIFF:
         #    return False
@@ -1789,8 +1814,54 @@ class SimCCARMHF(SimCCARM):
     FP_RETURN_VAL = SimRegArg("s0", 32)
     CALLER_SAVED_REGS = []
     RETURN_ADDR = SimRegArg("lr", 4)
-    RETURN_VAL = SimRegArg("r0", 4)  # TODO Return val can also include reg r1
+    RETURN_VAL = SimRegArg("r0", 4)
+    OVERFLOW_RETURN_VAL = SimRegArg("r1", 4)
     ARCH = archinfo.ArchARMHF
+    EXTRA_ARCHES = (archinfo.ArchARMCortexM,)
+
+    def next_arg(self, session, arg_type):
+        if isinstance(arg_type, (SimTypeArray, SimTypeFixedSizeArray)):  # hack
+            arg_type = SimTypePointer(arg_type.elem_type).with_arch(self.arch)
+        state = session.getstate()
+        classification = self._classify(arg_type)
+        try:
+            mapped_classes = []
+            for cls in classification:
+                if cls == "DOUBLEP":
+                    if session.getstate()[1] % 2 == 1:  # doubles must start on an even register
+                        next(session.int_iter)
+
+                    if session.getstate()[1] == len(self.ARG_REGS) - 2:
+                        mapped_classes.append(next(session.int_iter))
+                        mapped_classes.append(next(session.both_iter))
+                    else:
+                        try:
+                            mapped_classes.append(next(session.int_iter))
+                            mapped_classes.append(next(session.int_iter))
+                        except StopIteration:
+                            mapped_classes.append(next(session.both_iter))
+                            mapped_classes.append(next(session.both_iter))
+                elif cls == "NO_CLASS":
+                    raise NotImplementedError("Bug. Report to @rhelmot")
+                elif cls == "MEMORY":
+                    mapped_classes.append(next(session.both_iter))
+                elif cls == "INTEGER":
+                    try:
+                        mapped_classes.append(next(session.int_iter))
+                    except StopIteration:
+                        mapped_classes.append(next(session.both_iter))
+                elif cls == "SINGLEP":
+                    try:
+                        mapped_classes.append(next(session.fp_iter))
+                    except StopIteration:
+                        mapped_classes.append(next(session.both_iter))
+                else:
+                    raise NotImplementedError("Bug. Report to @rhelmot")
+        except StopIteration:
+            session.setstate(state)
+            mapped_classes = [next(session.both_iter) for _ in classification]
+
+        return refine_locs_with_struct_type(self.arch, mapped_classes, arg_type)
 
 
 class SimCCARMLinuxSyscall(SimCCSyscall):
@@ -2122,7 +2193,7 @@ class SimCCSoot(SimCC):
     ARG_REGS = []
 
     def setup_callsite(self, state, ret_addr, args, prototype, stack_base=None, alloc_base=None, grow_like_stack=True):
-        SootMixin.setup_callsite(state, args, ret_addr)
+        angr.engines.SootMixin.setup_callsite(state, args, ret_addr)
 
     @staticmethod
     def guess_prototype(args, prototype=None):
@@ -2226,7 +2297,7 @@ DEFAULT_CC: dict[str, dict[str, type[SimCC]]] = {
     "X86": {"Linux": SimCCCdecl, "CGC": SimCCCdecl, "Win32": SimCCMicrosoftCdecl},
     "ARMEL": {"Linux": SimCCARM},
     "ARMHF": {"Linux": SimCCARMHF},
-    "ARMCortexM": {"Linux": SimCCARM},
+    "ARMCortexM": {"Linux": SimCCARMHF},
     "MIPS32": {"Linux": SimCCO32},
     "MIPS64": {"Linux": SimCCN64},
     "PPC32": {"Linux": SimCCPowerPC},

angr/distributed/__init__.py

@@ -1,4 +1,4 @@
-""" angr.distributed provides a simple implementation for conducting
+"""angr.distributed provides a simple implementation for conducting
 long-running symbolic-execution-based tasks.
 """
 

angr/engines/__init__.py

@@ -1,15 +1,14 @@
 from __future__ import annotations
 
-from .successors import SimSuccessors
-from .engine import SimEngine, SuccessorsMixin
-
-from .vex import HeavyVEXMixin, TrackActionsMixin, SimInspectMixin, HeavyResilienceMixin, SuperFastpathMixin
-from .procedure import ProcedureMixin, ProcedureEngine
-from .unicorn import SimEngineUnicorn
+from .engine import SimEngine
 from .failure import SimEngineFailure
-from .syscall import SimEngineSyscall
 from .hook import HooksMixin
+from .procedure import ProcedureEngine, ProcedureMixin
 from .soot import SootMixin
+from .successors import SimSuccessors, SuccessorsEngine
+from .syscall import SimEngineSyscall
+from .unicorn import SimEngineUnicorn
+from .vex import HeavyResilienceMixin, HeavyVEXMixin, SimInspectMixin, SuperFastpathMixin, TrackActionsMixin
 
 
 class UberEngine(
@@ -47,7 +46,7 @@ __all__ = [
     "SimInspectMixin",
     "SimSuccessors",
     "SootMixin",
-    "SuccessorsMixin",
+    "SuccessorsEngine",
     "SuperFastpathMixin",
     "TrackActionsMixin",
     "UberEngine",

angr/engines/engine.py

@@ -1,33 +1,19 @@
 from __future__ import annotations
 
-from typing import Generic, TypeVar
 import abc
-import logging
+from typing import Generic, TypeVar
 
-import claripy
-from archinfo.arch_soot import SootAddressDescriptor
 
 import angr
-from angr.sim_state import SimState
-from angr import sim_options as o
-from angr.errors import SimException
-from angr.state_plugins.inspect import BP_AFTER, BP_BEFORE
-from .successors import SimSuccessors
-
-
-l = logging.getLogger(name=__name__)
-
 
 StateType = TypeVar("StateType")
 ResultType = TypeVar("ResultType")
 DataType_co = TypeVar("DataType_co", covariant=True)
-HeavyState = SimState[int | SootAddressDescriptor, claripy.ast.BV | SootAddressDescriptor]
 
 
-class SimEngineBase(Generic[StateType]):
+class SimEngine(Generic[StateType, ResultType], metaclass=abc.ABCMeta):
     """
-    Even more basey of a base class for SimEngine. Used as a base by mixins which want access to the project but for
-    which having method `process` (contained in `SimEngine`) doesn't make sense
+    A SimEngine is a type which understands how to perform execution on a state.
     """
 
     state: StateType
@@ -41,124 +27,3 @@ class SimEngineBase(Generic[StateType]):
 
     def __setstate__(self, state):
         self.project = state[0]
-
-
-class SimEngine(Generic[StateType, ResultType], SimEngineBase[StateType], metaclass=abc.ABCMeta):
-    """
-    A SimEngine is a class which understands how to perform execution on a state. This is a base class.
-    """
-
-    @abc.abstractmethod
-    def process(self, state: StateType, **kwargs) -> ResultType:
-        """
-        The main entry point for an engine. Should take a state and return a result.
-
-        :param state:   The state to proceed from
-        :return:        The result. Whatever you want ;)
-        """
-
-
-class SuccessorsMixin(SimEngine[HeavyState, SimSuccessors]):
-    """
-    A mixin for SimEngine which implements ``process`` to perform common operations related to symbolic execution
-    and dispatches to a ``process_successors`` method to fill a SimSuccessors object with the results.
-    """
-
-    def __init__(self, project: angr.Project):
-        super().__init__(project)
-
-        self.successors: SimSuccessors | None = None
-
-    def process(self, state: HeavyState, **kwargs) -> SimSuccessors:  # pylint:disable=unused-argument
-        """
-        Perform execution with a state.
-
-        You should only override this method in a subclass in order to provide the correct method signature and
-        docstring. You should override the ``_process`` method to do your actual execution.
-
-        :param state:       The state with which to execute. This state will be copied before
-                            modification.
-        :param inline:      This is an inline execution. Do not bother copying the state.
-        :param force_addr:  Force execution to pretend that we're working at this concrete address
-        :returns:           A SimSuccessors object categorizing the execution's successor states
-        """
-        inline = kwargs.pop("inline", False)
-        force_addr = kwargs.pop("force_addr", None)
-
-        ip = state._ip
-        addr = (
-            (ip if isinstance(ip, SootAddressDescriptor) else state.solver.eval(ip))
-            if force_addr is None
-            else force_addr
-        )
-
-        # make a copy of the initial state for actual processing, if needed
-        new_state = state.copy() if not inline and o.COPY_STATES in state.options else state
-        # enforce this distinction
-        old_state = state
-        del state
-        self.state = new_state
-
-        # we have now officially begun the stepping process! now is where we "cycle" a state's
-        # data - move the "present" into the "past" by pushing an entry on the history stack.
-        # nuance: make sure to copy from the PREVIOUS state to the CURRENT one
-        # to avoid creating a dead link in the history, messing up the statehierarchy
-        new_state.register_plugin("history", old_state.history.make_child())
-        new_state.history.recent_bbl_addrs.append(addr)
-        if new_state.arch.unicorn_support:
-            assert isinstance(addr, int)
-            new_state.scratch.executed_pages_set = {addr & ~0xFFF}
-
-        self.successors = SimSuccessors(addr, old_state)
-
-        new_state._inspect(
-            "engine_process", when=BP_BEFORE, sim_engine=self, sim_successors=self.successors, address=addr
-        )
-        self.successors = new_state._inspect_getattr("sim_successors", self.successors)
-        try:
-            self.process_successors(self.successors, **kwargs)
-        except SimException as e:
-            if o.EXCEPTION_HANDLING not in old_state.options:
-                raise
-            assert old_state.project is not None
-            old_state.project.simos.handle_exception(self.successors, self, e)
-
-        new_state._inspect("engine_process", when=BP_AFTER, sim_successors=self.successors, address=addr)
-        self.successors = new_state._inspect_getattr("sim_successors", self.successors)
-        assert self.successors is not None
-
-        # downsizing
-        if new_state.supports_inspect:
-            new_state.inspect.downsize()
-        # if not TRACK, clear actions on OLD state
-        # if o.TRACK_ACTION_HISTORY not in old_state.options:
-        #    old_state.history.recent_events = []
-
-        # fix up the descriptions...
-        description = str(self.successors)
-        l.info("Ticked state: %s", description)
-        for succ in self.successors.all_successors:
-            succ.history.recent_description = description
-        for succ in self.successors.flat_successors:
-            succ.history.recent_description = description
-
-        return self.successors
-
-    def process_successors(self, successors, **kwargs):  # pylint:disable=unused-argument,no-self-use
-        """
-        Implement this function to fill out the SimSuccessors object with the results of stepping state.
-
-        In order to implement a model where multiple mixins can potentially handle a request, a mixin may implement
-        this method and then perform a super() call if it wants to pass on handling to the next mixin.
-
-        Keep in mind python's method resolution order when composing multiple classes implementing this method.
-        In short: left-to-right, depth-first, but deferring any base classes which are shared by multiple subclasses
-        (the merge point of a diamond pattern in the inheritance graph) until the last point where they would be
-        encountered in this depth-first search. For example, if you have classes A, B(A), C(B), D(A), E(C, D), then the
-        method resolution order will be E, C, B, D, A.
-
-        :param state:           The state to manipulate
-        :param successors:      The successors object to fill out
-        :param kwargs:          Any extra arguments. Do not fail if you are passed unexpected arguments.
-        """
-        successors.processed = False  # mark failure