def _compute_dead_maps(self, live_map, var_def_map):
        """
        Compute the end-of-live information for variables.
        `live_map` contains a mapping of block offset to all the living
        variables at the ENTRY of the block.
        """
        # The following three dictionaries will be
        # { block offset -> set of variables to delete }
        # all vars that should be deleted at the start of the successors
        escaping_dead_map = collections.defaultdict(set)
        # all vars that should be deleted within this block
        internal_dead_map = collections.defaultdict(set)
        # all vars that should be delted after the function exit
        exit_dead_map = collections.defaultdict(set)

        for offset, ir_block in self.blocks.items():
            # live vars WITHIN the block will include all the locally
            # defined variables
            cur_live_set = live_map[offset] | var_def_map[offset]
            # vars alive alive in the outgoing blocks
            outgoing_live_map = dict((out_blk, live_map[out_blk])
                                     for out_blk, _data
                                     in self.cfa.graph.successors(offset))
            # vars to keep alive for the terminator
            terminator_liveset = set(v.name
                                     for v in ir_block.terminator.list_vars())
            # vars to keep alive in the successors
            combined_liveset = reduce(operator.or_, outgoing_live_map.values(),
                                      set())
            # include variables used in terminator
            combined_liveset |= terminator_liveset
            # vars that are dead within the block beacuse they are not
            # propagated to any outgoing blocks
            internal_set = cur_live_set - combined_liveset
            internal_dead_map[offset] = internal_set
            # vars that escape this block
            escaping_live_set = cur_live_set - internal_set
            for out_blk, new_live_set in outgoing_live_map.items():
                # successor should delete the unused escaped vars
                new_live_set = new_live_set | var_def_map[out_blk]
                escaping_dead_map[out_blk] |= escaping_live_set - new_live_set

            # if no outgoing blocks
            if not outgoing_live_map:
                # insert var used by terminator
                exit_dead_map[offset] = terminator_liveset

        # Verify that the dead maps cover all live variables
        all_vars = reduce(operator.or_, live_map.values(), set())
        internal_dead_vars = reduce(operator.or_, internal_dead_map.values(),
                                    set())
        escaping_dead_vars = reduce(operator.or_, escaping_dead_map.values(),
                                    set())
        exit_dead_vars = reduce(operator.or_, exit_dead_map.values(), set())
        dead_vars = (internal_dead_vars | escaping_dead_vars | exit_dead_vars)
        missing_vars = all_vars - dead_vars
        if missing_vars:
            # There are no exit points
            if not self.cfa.graph.exit_points():
                # We won't be able to verify this
                pass
            else:
                msg = 'liveness info missing for vars: {0}'.format(missing_vars)
                raise RuntimeError(msg)

        return internal_dead_map, escaping_dead_map
dataset/ETHPy150Open numba/numba/numba/interpreter.py/Interpreter._compute_dead_maps/original