angr/exploration_techniques/director.py
def check(self, cfg, state, peek_blocks):
        """
        Check if the specified function will be reached with certain arguments.

        :param cfg:
        :param state:
        :param peek_blocks:
        :return:
        """

        # Get the current CFGNode
        node = self._get_cfg_node(cfg, state)

        if node is None:
            l.error("Failed to find CFGNode for state %s on the control flow graph.", state)
            return False

        # crawl the graph to see if we can reach the target function within the limited steps
        for src, dst in self._dfs_edges(cfg.graph, node, max_steps=peek_blocks):
            the_node = None
            if src.addr == self.function.addr:
                the_node = src
            elif dst.addr == self.function.addr:
                the_node = dst

            if the_node is not None:
                if self.arguments is None:
                    # we do not care about arguments
                    return True

                else:
                    # check arguments
                    arch = state.arch
                    state = the_node.input_state
                    same_arguments = self._check_arguments(arch, state)

                    if same_arguments:
                        # all arguments are the same!
                        return True

        l.debug("SimState %s will not reach function %s.", state, self.function)
        return False

        Check if the specified function will be reached with certain arguments.

        :param cfg:
        :param state:
        :param peek_blocks:
        :return:
        
Check if the specified function will be reached with certain arguments.
Check if the specified function will be reached with certain arguments .
def check(self, cfg, state, peek_blocks):
        node = self._get_cfg_node(cfg, state)
        if node is None:
            l.error("Failed to find CFGNode for state %s on the control flow graph.", state)
            return False
        for src, dst in self._dfs_edges(cfg.graph, node, max_steps=peek_blocks):
            the_node = None
            if src.addr == self.function.addr:
                the_node = src
            elif dst.addr == self.function.addr:
                the_node = dst
            if the_node is not None:
                if self.arguments is None:
                    return True
                else:
                    arch = state.arch
                    state = the_node.input_state
                    same_arguments = self._check_arguments(arch, state)
                    if same_arguments:
                        return True
        l.debug("SimState %s will not reach function %s.", state, self.function)
        return False
def check ( self , cfg , state , peek_blocks ) : node = self . _get_cfg_node ( cfg , state ) if node is None : l . error ( "Failed to find CFGNode for state %s on the control flow graph." , state ) return False for src , dst in self . _dfs_edges ( cfg . graph , node , max_steps = peek_blocks ) : the_node = None if src . addr == self . function . addr : the_node = src elif dst . addr == self . function . addr : the_node = dst if the_node is not None : if self . arguments is None : return True else : arch = state . arch state = the_node . input_state same_arguments = self . _check_arguments ( arch , state ) if same_arguments : return True l . debug ( "SimState %s will not reach function %s." , state , self . function ) return False
Check if the specified function will be reached with certain arguments.
Check if the specified function will be reached with certain arguments .
"""
        Check if the specified function will be reached with certain arguments.

        :param cfg:
        :param state:
        :param peek_blocks:
        :return:
        """ # Get the current CFGNode # crawl the graph to see if we can reach the target function within the limited steps # we do not care about arguments # check arguments # all arguments are the same!
None
self
cfg
None
state
None
peek_blocks
None