(self, cfg_job, current_func_addr)
return entries
Generate a list of successors (generating them each as entries) to IRSB.
        Updates previous CFG nodes with edges.

        :param CFGJob cfg_job: The CFGJob instance.
        :param int current_func_addr: Address of the current function
        :return: a list of successors
        :rtype: list
Generate a list of successors (generating them each as entries) to IRSB.
        Updates previous CFG nodes with edges.
Generate a list of successors ( generating them each as entries ) to IRSB . Updates previous CFG nodes with edges .
def _scan_soot_block(self, cfg_job, current_func_addr):
        """
        Generate a list of successors (generating them each as entries) to IRSB.
        Updates previous CFG nodes with edges.

        :param CFGJob cfg_job: The CFGJob instance.
        :param int current_func_addr: Address of the current function
        :return: a list of successors
        :rtype: list
        """

        addr, function_addr, cfg_node, soot_block = self._generate_cfgnode(cfg_job, current_func_addr)

        # Add edges going to this node in function graphs
        cfg_job.apply_function_edges(self, clear=True)

        # function_addr and current_function_addr can be different. e.g. when tracing an optimized tail-call that jumps
        # into another function that has been identified before.

        if cfg_node is None:
            # exceptions occurred, or we cannot get a CFGNode for other reasons
            return [ ]

        self._graph_add_edge(cfg_node, cfg_job.src_node, cfg_job.jumpkind, cfg_job.src_ins_addr,
                             cfg_job.src_stmt_idx
                             )
        self._function_add_node(cfg_node, function_addr)

        # If we have traced it before, don't trace it anymore
        if addr in self._traced_addresses:
            # the address has been traced before
            return [ ]
        else:
            # Mark the address as traced
            self._traced_addresses.add(addr)

        # soot_block is only used once per CFGNode. We should be able to clean up the CFGNode here in order to save memory
        cfg_node.soot_block = None

        successors = self._soot_get_successors(addr, current_func_addr, soot_block, cfg_node)

        entries = [ ]

        for suc in successors:
            stmt_idx, stmt_addr, target, jumpkind = suc

            entries += self._create_jobs(target, jumpkind, function_addr, soot_block, addr, cfg_node, stmt_addr,
                                         stmt_idx
                                         )

        return entries
def _scan_soot_block ( self , cfg_job , current_func_addr ) : addr , function_addr , cfg_node , soot_block = self . _generate_cfgnode ( cfg_job , current_func_addr ) # Add edges going to this node in function graphs cfg_job . apply_function_edges ( self , clear = True ) # function_addr and current_function_addr can be different. e.g. when tracing an optimized tail-call that jumps # into another function that has been identified before. if cfg_node is None : # exceptions occurred, or we cannot get a CFGNode for other reasons return [ ] self . _graph_add_edge ( cfg_node , cfg_job . src_node , cfg_job . jumpkind , cfg_job . src_ins_addr , cfg_job . src_stmt_idx ) self . _function_add_node ( cfg_node , function_addr ) # If we have traced it before, don't trace it anymore if addr in self . _traced_addresses : # the address has been traced before return [ ] else : # Mark the address as traced self . _traced_addresses . add ( addr ) # soot_block is only used once per CFGNode. We should be able to clean up the CFGNode here in order to save memory cfg_node . soot_block = None successors = self . _soot_get_successors ( addr , current_func_addr , soot_block , cfg_node ) entries = [ ] for suc in successors : stmt_idx , stmt_addr , target , jumpkind = suc entries += self . _create_jobs ( target , jumpkind , function_addr , soot_block , addr , cfg_node , stmt_addr , stmt_idx ) return entries