angr/exploration_techniques/director.py
def _categorize_states(self, simgr):
        """
        Categorize all states into two different groups: reaching the destination within the peek depth, and not
        reaching the destination within the peek depth.

        :param SimulationManager simgr:    The simulation manager that contains states. All active states (state belonging to "active" stash)
                                are subjected to categorization.
        :return:                The categorized simulation manager.
        :rtype:                 angr.SimulationManager
        """

        past_active_states = len(simgr.active)
        # past_deprioritized_states = len(simgr.deprioritized)

        for goal in self._goals:
            for p in simgr.active:
                if self._check_goals(goal, p):
                    if self._goal_satisfied_callback is not None:
                        self._goal_satisfied_callback(goal, p, simgr)

        simgr.stash(
            filter_func=lambda p: all(not goal.check(self._cfg, p, peek_blocks=self._peek_blocks) for goal in
                                      self._goals
                                      ),
            from_stash='active',
            to_stash='deprioritized',
        )

        if simgr.active:
            # TODO: pick some states from depriorized stash to active stash to avoid overfitting
            pass

        active_states = len(simgr.active)
        # deprioritized_states = len(simgr.deprioritized)

        l.debug('%d/%d active states are deprioritized.', past_active_states - active_states, past_active_states)

        return simgr

        Categorize all states into two different groups: reaching the destination within the peek depth, and not
        reaching the destination within the peek depth.

        :param SimulationManager simgr:    The simulation manager that contains states. All active states (state belonging to "active" stash)
                                are subjected to categorization.
        :return:                The categorized simulation manager.
        :rtype:                 angr.SimulationManager
        
Categorize all states into two different groups: reaching the destination within the peek depth, and not
reaching the destination within the peek depth.
Categorize all states into two different groups : reaching the destination within the peek depth and not reaching the destination within the peek depth .
def _categorize_states(self, simgr):
        past_active_states = len(simgr.active)
        for goal in self._goals:
            for p in simgr.active:
                if self._check_goals(goal, p):
                    if self._goal_satisfied_callback is not None:
                        self._goal_satisfied_callback(goal, p, simgr)
        simgr.stash(
            filter_func=lambda p: all(not goal.check(self._cfg, p, peek_blocks=self._peek_blocks) for goal in
                                      self._goals
                                      ),
            from_stash='active',
            to_stash='deprioritized',
        )
        if simgr.active:
            pass
        active_states = len(simgr.active)
        l.debug('%d/%d active states are deprioritized.', past_active_states - active_states, past_active_states)
        return simgr
def _categorize_states ( self , simgr ) : past_active_states = len ( simgr . active ) for goal in self . _goals : for p in simgr . active : if self . _check_goals ( goal , p ) : if self . _goal_satisfied_callback is not None : self . _goal_satisfied_callback ( goal , p , simgr ) simgr . stash ( filter_func = lambda p : all ( not goal . check ( self . _cfg , p , peek_blocks = self . _peek_blocks ) for goal in self . _goals ) , from_stash = 'active' , to_stash = 'deprioritized' , ) if simgr . active : pass active_states = len ( simgr . active ) l . debug ( '%d/%d active states are deprioritized.' , past_active_states - active_states , past_active_states ) return simgr
Categorize all states into two different groups: reaching the destination within the peek depth, and not
reaching the destination within the peek depth.
Categorize all states into two different groups : reaching the destination within the peek depth and not reaching the destination within the peek depth .
"""
        Categorize all states into two different groups: reaching the destination within the peek depth, and not
        reaching the destination within the peek depth.

        :param SimulationManager simgr:    The simulation manager that contains states. All active states (state belonging to "active" stash)
                                are subjected to categorization.
        :return:                The categorized simulation manager.
        :rtype:                 angr.SimulationManager
        """ # past_deprioritized_states = len(simgr.deprioritized) # TODO: pick some states from depriorized stash to active stash to avoid overfitting # deprioritized_states = len(simgr.deprioritized)
The categorized simulation manager.
The categorized simulation manager .
angr.SimulationManager
self
simgr
The simulation manager that contains states. All active states (state belonging to "active" stash)
are subjected to categorization.
The simulation manager that contains states . All active states ( state belonging to " active " stash ) are subjected to categorization .