'Create a backward slice from a specific statement based on provided control flow graph (CFG), control
dependence graph (CDG), and data dependence graph (DDG).
The data dependence graph can be either CFG-based, or Value-set analysis based. A CFG-based DDG is much faster
to generate, but it only reflects those states while generating the CFG, and it is neither sound nor accurate.
The VSA based DDG (called VSA_DDG) is based on static analysis, which gives you a much better result.
:param cfg:                 The control flow graph.
:param cdg:                 The control dependence graph.
:param ddg:                 The data dependence graph.
:param targets:             A list of "target" that specify targets of the backward slices. Each target can be a
tuple in form of (cfg_node, stmt_idx), or a CodeLocation instance.
:param cfg_node:            Deprecated. The target CFGNode to reach. It should exist in the CFG.
:param stmt_id:             Deprecated. The target statement to reach.
:param control_flow_slice:  True/False, indicates whether we should slice only based on CFG. Sometimes when
acquiring DDG is difficult or impossible, you can just create a slice on your CFG.
Well, if you don\'t even have a CFG, then...
:param no_construct:        Only used for testing and debugging to easily create a BackwardSlice object.'

def __init__(self, cfg, cdg, ddg, targets=None, cfg_node=None, stmt_id=None, control_flow_slice=False, same_function=False, no_construct=False):

    self._cfg = cfg
    self._cdg = cdg
    self._ddg = ddg
    self._same_function = same_function
    self._targets = []
    if ((cfg_node is not None) or (stmt_id is not None)):
        l.warning('"cfg_node"    and    "stmt_id"    are    deprecated.    Please    use    "targets"    to    pass    in    one    or    more    targets.')
        self._targets = [(cfg_node, stmt_id)]
    if (targets is not None):
        for t in targets:
            if isinstance(t, CodeLocation):
                node = self._cfg.get_any_node(t.block_addr)
                self._targets.append((node, t.stmt_idx))
            elif (type(t) is tuple):
                self._targets.append(t)
            else:
                raise AngrBackwardSlicingError(('Unsupported    type    of    target    %s' % t))
    self.initial_taints_per_run = None
    self.runs_in_slice = None
    self.cfg_nodes_in_slice = None
    self.chosen_statements = defaultdict(set)
    self.chosen_exits = defaultdict(list)
    if (not no_construct):
        self._construct(self._targets, control_flow_slice=control_flow_slice)
