def _get_successors(self, entry, _locals):
        """

        :param entry:
        :param _locals:
        :return:
        """

        simrun = _locals['simrun']
        addr = _locals['addr']
        cfg_node = _locals['cfg_node']
        func_addr = _locals['func_addr']
        current_function = _locals['current_function']
        error_occurred = _locals['error_occurred']
        simrun_key = _locals['simrun_key']
        current_stack_pointer = _locals['current_stack_pointer']
        accessed_registers_in_function = _locals['accessed_registers_in_function']

        # Get all successors of this SimRun
        successors = (simrun.flat_successors + simrun.unsat_successors) if addr not in self._avoid_runs else []

        # Post-process successors
        successors, extra_info = self._post_process_successors(simrun, successors)

        _locals['extra_info'] = extra_info

        if self._keep_state:
            cfg_node.final_states = successors[::]

        # Try to resolve indirect jumps
        successors = self._resolve_indirect_jumps(simrun, cfg_node, func_addr, successors, error_occurred,
                                                  self._simrun_info_collection
                                                  )

        # Ad additional edges supplied by the user
        successors = self._add_additional_edges(simrun, cfg_node, successors)

        if len(successors) == 0:
            # There is no way out :-(
            # Log it first
            self._push_unresolvable_run(addr)

            if isinstance(simrun,
                          simuvex.procedures.SimProcedures["stubs"]["PathTerminator"]):
                # If there is no valid exit in this branch and it's not
                # intentional (e.g. caused by a SimProcedure that does not
                # do_return) , we should make it return to its call-site. However,
                # we don't want to use its state anymore as it might be corrupted.
                # Just create an edge in the graph.
                retn_target = entry.call_stack.current_return_target
                if retn_target is not None:
                    new_call_stack = entry.call_stack_copy()
                    exit_target_tpl = self._generate_simrun_key(
                        new_call_stack.stack_suffix(self.context_sensitivity_level),
                        retn_target,
                        False
                    )  # You can never return to a syscall
                    self._graph_add_edge(simrun_key, exit_target_tpl, jumpkind='Ijk_Ret', exit_stmt_id='default')

            else:
                # Well, there is just no successors. What can you expect?
                pass

        #
        # Enough foreplay. Time to do real job!
        #

        # First, handle all actions
        if successors:
            self._handle_actions(successors[0], simrun, current_function, current_stack_pointer,
                                 accessed_registers_in_function)

        return successors
dataset/ETHPy150Open angr/angr/angr/analyses/cfg_accurate.py/CFGAccurate._get_successors/original