':return: True if new data entries are found, False otherwise.
:rtype: bool'

def _tidy_data_references(self):

    keys = sorted(self._memory_data.iterkeys())
    for (i, data_addr) in enumerate(keys):
        data = self._memory_data[data_addr]
        if self._addr_in_exec_memory_regions(data.address):
            pass
        else:
            if ((i + 1) != len(keys)):
                next_data_addr = keys[(i + 1)]
            else:
                next_data_addr = None
            obj = self.project.loader.find_object_containing(data_addr)
            sec = self._addr_belongs_to_section(data_addr)
            next_sec_addr = None
            if (sec is not None):
                last_addr = (sec.vaddr + sec.memsize)
            else:
                next_sec = self._addr_next_section(data_addr)
                if (next_sec is not None):
                    next_sec_addr = next_sec.vaddr
                seg = self._addr_belongs_to_segment(data_addr)
                if (seg is not None):
                    last_addr = (seg.vaddr + seg.memsize)
                else:
                    l.warning('_tidy_data_references()    sees    an    address    %#08x    that    does    not    belong    to    any    section    or    segment.', data_addr)
                    last_addr = None
            if (next_data_addr is None):
                boundary = last_addr
            elif (last_addr is None):
                boundary = next_data_addr
            else:
                boundary = min(last_addr, next_data_addr)
            if (next_sec_addr is not None):
                boundary = min(boundary, next_sec_addr)
            if (boundary is not None):
                data.max_size = (boundary - data_addr)
    keys = sorted(self._memory_data.iterkeys())
    new_data_found = False
    i = 0
    while (i < len(keys)):
        data_addr = keys[i]
        i += 1
        memory_data = self._memory_data[data_addr]
        if (memory_data.sort in ('segment-boundary',)):
            continue
        content_holder = []
        if ((memory_data.sort in ('unknown', None)) or ((memory_data.sort == 'integer') and (memory_data.size == (self.project.arch.bits / 8)))):
            (data_type, data_size) = self._guess_data_type(memory_data.irsb, memory_data.irsb_addr, memory_data.stmt_idx, data_addr, memory_data.max_size, content_holder=content_holder)
        else:
            (data_type, data_size) = (memory_data.sort, memory_data.size)
        if (data_type is not None):
            memory_data.size = data_size
            memory_data.sort = data_type
            if (len(content_holder) == 1):
                memory_data.content = content_holder[0]
            if ((memory_data.size > 0) and (memory_data.size < memory_data.max_size)):
                new_addr = (data_addr + memory_data.size)
                new_md = MemoryData(new_addr, None, None, None, None, None, None, max_size=(memory_data.max_size - memory_data.size))
                self._memory_data[new_addr] = new_md
                keys.insert(i, new_addr)
            if (data_type == 'pointer-array'):
                pointer_size = (self.project.arch.bits / 8)
                buf = self._fast_memory_load(data_addr)
                if (self.project.arch.memory_endness == 'Iend_LE'):
                    fmt = '<'
                else:
                    fmt = '>'
                if (pointer_size == 8):
                    fmt += 'Q'
                elif (pointer_size == 4):
                    fmt += 'I'
                else:
                    raise AngrCFGError('Pointer    size    of    %d    is    not    supported', pointer_size)
                for j in xrange(0, data_size, pointer_size):
                    ptr_str = self._ffi.unpack(self._ffi.cast('char*', (buf + j)), pointer_size)
                    ptr = struct.unpack(fmt, ptr_str)[0]
                    obj = self.project.loader.find_object_containing(ptr)
                    if (obj is not self.project.loader.main_object):
                        continue
                    if self._seg_list.is_occupied(ptr):
                        sort = self._seg_list.occupied_by_sort(ptr)
                        if (sort == 'code'):
                            continue
                        elif (sort == 'pointer-array'):
                            continue
                    if (ptr not in self._memory_data):
                        self._memory_data[ptr] = MemoryData(ptr, 0, 'unknown', None, None, None, None, pointer_addr=(data_addr + j))
                        new_data_found = True
        else:
            memory_data.size = memory_data.max_size
        self._seg_list.occupy(data_addr, memory_data.size, memory_data.sort)
    return new_data_found
