/* Auxiliary function for try_map_near_symbol(): a very inneficient way of
 * searching for a page before the one we want that contains `symbol` with
 * size `want_size` (which will be rounded to the page size). */
static void *find_free_page_near_symbol(void *symbol, size_t want_size)
{
    /* This is quite inneficient, but it's fine for my toy JIT. */
    FILE *maps;
    char buffer[512];
    char *ptr;
    uintptr_t max_want_addr = 0;
    uintptr_t symbol_addr = (uintptr_t)symbol;
    long page_size = sysconf(_SC_PAGE_SIZE);

    maps = fopen("/proc/self/maps", "re");
    if (!maps)
        return NULL;

    want_size = (want_size + (page_size - 1)) & ~(page_size - 1);

    while ((ptr = fgets(buffer, 512, maps))) {
        uintptr_t start, end;

        if (sscanf(ptr, "%lx-%lx", &start, &end) != 2)
            continue;

        if (symbol_addr >= start && symbol_addr <= end) {
           max_want_addr = start - want_size;
           rewind(maps);
           break;
        }
    }

    if (max_want_addr) {
        while ((ptr = fgets(buffer, 512, maps))) {
            uintptr_t start, end;

            if (sscanf(ptr, "%lx-%lx", &start, &end) != 2)
                continue;

            if (start >= max_want_addr && end <= max_want_addr + want_size) {
                max_want_addr -= page_size;
                rewind(maps);
            }
        }
    }

    fclose(maps);

    return (void *)max_want_addr;
}

/* This tries creating a private anonymous map with ``prot`` and size
 * ``want_size``, at a location that is close enough to ``symbol``
 * that a direct call instruction with a 32-bit offset can be emitted
 * in JITted code.
 * NOTE: This function does not ensure that the actual offset is indeed
 *       a 32-bit offset in the end!  A lot of things may go wrong here,
 *       including find_free_page_near_symbol() going too far backwards
 *       that it wraps.  This has been written for a toy, thus error
 *       handling is minimal. */
static void *try_map_near_symbol(void *symbol, size_t want_size, int prot)
{
    int flags = MAP_ANONYMOUS | MAP_FIXED_NOREPLACE | MAP_PRIVATE;
    void *addr = symbol;

    for (int try = 0; try < 32; try ++) {
        addr = find_free_page_near_symbol(addr, want_size);
        if (!addr)
            break;

        void *ptr = mmap(addr, want_size, prot, flags, -1, 0);
        if (ptr == addr)
            return ptr;

        if (ptr != MAP_FAILED) {
            munmap(ptr, want_size);
        } else {
            if (errno == EEXIST && (flags & MAP_FIXED_NOREPLACE)) {
                /* If we get EEXIST here, then we know that this kernel
                 * has NOREPLACE support -- we just got unlucky with a
                 * race condition and lost.  Try finding another address
                 * again. */
                continue;
            }

            /* Any other error condition means we might want to try
             * just passing a hint to mmap() and seeing if the address
             * it returns us is the same that we want. */
        }

        /* This kernel probably has no NOREPLACE support, so disable it
         * for the next tries. */
        flags &= ~MAP_FIXED_NOREPLACE;
        /* We don't set MAP_FIXED here because that might replace some
         * already existing mapping -- so let's give the kernel some
         * opportunity to map memory at the address we want, because
         * it prefers regions that are currently unmapped otherwise. */
    }

    return NULL;
}