diff options
Diffstat (limited to 'ldso')
| -rw-r--r-- | ldso/ldso/bfin/dl-inlines.h | 258 | ||||
| -rw-r--r-- | ldso/ldso/fdpic/dl-inlines.h | 744 |
2 files changed, 495 insertions, 507 deletions
diff --git a/ldso/ldso/bfin/dl-inlines.h b/ldso/ldso/bfin/dl-inlines.h index 67f9ff6a3..66aa95ac8 100644 --- a/ldso/ldso/bfin/dl-inlines.h +++ b/ldso/ldso/bfin/dl-inlines.h @@ -11,142 +11,142 @@ #include "../fdpic/dl-inlines.h" -void -__dl_loadaddr_unmap (struct elf32_fdpic_loadaddr loadaddr, - struct funcdesc_ht *funcdesc_ht) +static __always_inline void +__dl_loadaddr_unmap(struct elf32_fdpic_loadaddr loadaddr, + struct funcdesc_ht *funcdesc_ht) { - int i; - - for (i = 0; i < loadaddr.map->nsegs; i++) - { - struct elf32_fdpic_loadseg *segdata; - ssize_t offs; - segdata = loadaddr.map->segs + i; - - /* FIXME: - A more cleaner way is to add type for struct elf32_fdpic_loadseg, - and release the memory according to the type. - Currently, we hardcode the memory address of L1 SRAM. */ - if ((segdata->addr & 0xff800000) == 0xff800000) - { - _dl_sram_free ((void *)segdata->addr); - continue; - } - - offs = (segdata->p_vaddr & ADDR_ALIGN); - _dl_munmap ((void*)segdata->addr - offs, - segdata->p_memsz + offs); - } - /* _dl_unmap is only called for dlopen()ed libraries, for which - calling free() is safe, or before we've completed the initial - relocation, in which case calling free() is probably pointless, - but still safe. */ - _dl_free (loadaddr.map); - if (funcdesc_ht) - htab_delete (funcdesc_ht); + int i; + + for (i = 0; i < loadaddr.map->nsegs; i++) { + struct elf32_fdpic_loadseg *segdata; + ssize_t offs; + segdata = loadaddr.map->segs + i; + + /* FIXME: + * A more cleaner way is to add type for struct elf32_fdpic_loadseg, + * and release the memory according to the type. + * Currently, we hardcode the memory address of L1 SRAM. + */ + if ((segdata->addr & 0xff800000) == 0xff800000) { + _dl_sram_free((void *)segdata->addr); + continue; + } + + offs = (segdata->p_vaddr & ADDR_ALIGN); + _dl_munmap((void*)segdata->addr - offs, + segdata->p_memsz + offs); + } + + /* + * _dl_unmap is only called for dlopen()ed libraries, for which + * calling free() is safe, or before we've completed the initial + * relocation, in which case calling free() is probably pointless, + * but still safe. + */ + _dl_free(loadaddr.map); + if (funcdesc_ht) + htab_delete(funcdesc_ht); } static __always_inline int -__dl_is_special_segment (Elf32_Ehdr *epnt, - Elf32_Phdr *ppnt) +__dl_is_special_segment(Elf32_Ehdr *epnt, Elf32_Phdr *ppnt) { - if (ppnt->p_type != PT_LOAD) - return 0; - - if ((epnt->e_flags & EF_BFIN_CODE_IN_L1) - && !(ppnt->p_flags & PF_W) - && (ppnt->p_flags & PF_X)) - return 1; - - if ((epnt->e_flags & EF_BFIN_DATA_IN_L1) - && (ppnt->p_flags & PF_W) - && !(ppnt->p_flags & PF_X)) - return 1; - - /* 0xfeb00000, 0xfec00000, 0xff700000, 0xff800000, 0xff900000, - and 0xffa00000 are also used in GNU ld and linux kernel. - They need to be kept synchronized. */ - if (ppnt->p_vaddr == 0xff700000 - || ppnt->p_vaddr == 0xff800000 - || ppnt->p_vaddr == 0xff900000 - || ppnt->p_vaddr == 0xffa00000 - || ppnt->p_vaddr == 0xfeb00000 - || ppnt->p_vaddr == 0xfec00000) - return 1; - - return 0; + if (ppnt->p_type != PT_LOAD) + return 0; + + /* Allow read-only executable segments to be loaded into L1 inst */ + if ((epnt->e_flags & EF_BFIN_CODE_IN_L1) && + !(ppnt->p_flags & PF_W) && (ppnt->p_flags & PF_X)) + return 1; + + /* Allow writable non-executable segments to be loaded into L1 data */ + if ((epnt->e_flags & EF_BFIN_DATA_IN_L1) && + (ppnt->p_flags & PF_W) && !(ppnt->p_flags & PF_X)) + return 1; + + /* + * These L1 memory addresses are also used in GNU ld and linux kernel. + * They need to be kept synchronized. + */ + switch (ppnt->p_vaddr) { + case 0xff700000: + case 0xff800000: + case 0xff900000: + case 0xffa00000: + case 0xfeb00000: + case 0xfec00000: + return 1; + default: + return 0; + } } static __always_inline char * -__dl_map_segment (Elf32_Ehdr *epnt, - Elf32_Phdr *ppnt, - int infile, - int flags) +__dl_map_segment(Elf32_Ehdr *epnt, Elf32_Phdr *ppnt, int infile, int flags) { - char *status, *tryaddr, *addr; - size_t size; - - if (((epnt->e_flags & EF_BFIN_CODE_IN_L1) || ppnt->p_vaddr == 0xffa00000) - && !(ppnt->p_flags & PF_W) - && (ppnt->p_flags & PF_X)) { - status = (char *) _dl_mmap - (tryaddr = 0, - size = (ppnt->p_vaddr & ADDR_ALIGN) + ppnt->p_filesz, - LXFLAGS(ppnt->p_flags), - flags | MAP_EXECUTABLE | MAP_DENYWRITE, - infile, ppnt->p_offset & OFFS_ALIGN); - if (_dl_mmap_check_error(status) - || (tryaddr && tryaddr != status)) - return NULL; - addr = (char *) _dl_sram_alloc (ppnt->p_filesz, L1_INST_SRAM); - if (addr != NULL) - _dl_dma_memcpy (addr, status + (ppnt->p_vaddr & ADDR_ALIGN), ppnt->p_filesz); - _dl_munmap (status, size); - if (addr == NULL) - _dl_dprintf(2, "%s:%i: L1 allocation failed\n", _dl_progname, __LINE__); - return addr; - } - - if (((epnt->e_flags & EF_BFIN_DATA_IN_L1) - || ppnt->p_vaddr == 0xff700000 - || ppnt->p_vaddr == 0xff800000 - || ppnt->p_vaddr == 0xff900000) - && (ppnt->p_flags & PF_W) - && !(ppnt->p_flags & PF_X)) { - if (ppnt->p_vaddr == 0xff800000) - addr = (char *) _dl_sram_alloc (ppnt->p_memsz, L1_DATA_A_SRAM); - else if (ppnt->p_vaddr == 0xff900000) - addr = (char *) _dl_sram_alloc (ppnt->p_memsz, L1_DATA_B_SRAM); - else - addr = (char *) _dl_sram_alloc (ppnt->p_memsz, L1_DATA_SRAM); - if (addr == NULL) { - _dl_dprintf(2, "%s:%i: L1 allocation failed\n", _dl_progname, __LINE__); - } else { - if (_DL_PREAD (infile, addr, ppnt->p_filesz, ppnt->p_offset) != ppnt->p_filesz) { - _dl_sram_free (addr); - return NULL; - } - if (ppnt->p_filesz < ppnt->p_memsz) - _dl_memset (addr + ppnt->p_filesz, 0, ppnt->p_memsz - ppnt->p_filesz); - } - return addr; - } - - if (ppnt->p_vaddr == 0xfeb00000 - || ppnt->p_vaddr == 0xfec00000) { - addr = (char *) _dl_sram_alloc (ppnt->p_memsz, L2_SRAM); - if (addr == NULL) { - _dl_dprintf(2, "%s:%i: L2 allocation failed\n", _dl_progname, __LINE__); - } else { - if (_DL_PREAD (infile, addr, ppnt->p_filesz, ppnt->p_offset) != ppnt->p_filesz) { - _dl_sram_free (addr); - return NULL; - } - if (ppnt->p_filesz < ppnt->p_memsz) - _dl_memset (addr + ppnt->p_filesz, 0, ppnt->p_memsz - ppnt->p_filesz); - } - return addr; - } - - return 0; + void *addr; + + /* Handle L1 inst mappings */ + if (((epnt->e_flags & EF_BFIN_CODE_IN_L1) || ppnt->p_vaddr == 0xffa00000) && + !(ppnt->p_flags & PF_W) && (ppnt->p_flags & PF_X)) + { + size_t size = (ppnt->p_vaddr & ADDR_ALIGN) + ppnt->p_filesz; + void *status = _dl_mmap(NULL, size, LXFLAGS(ppnt->p_flags), + flags | MAP_EXECUTABLE | MAP_DENYWRITE, + infile, ppnt->p_offset & OFFS_ALIGN); + if (_dl_mmap_check_error(status)) + return NULL; + + addr = _dl_sram_alloc(ppnt->p_filesz, L1_INST_SRAM); + if (addr) + _dl_dma_memcpy(addr, status + (ppnt->p_vaddr & ADDR_ALIGN), ppnt->p_filesz); + else + _dl_dprintf(2, "%s:%i: L1 allocation failed\n", _dl_progname, __LINE__); + + _dl_munmap(status, size); + return addr; + } + + /* Handle L1 data mappings */ + if (((epnt->e_flags & EF_BFIN_DATA_IN_L1) || + ppnt->p_vaddr == 0xff700000 || + ppnt->p_vaddr == 0xff800000 || + ppnt->p_vaddr == 0xff900000) && + (ppnt->p_flags & PF_W) && !(ppnt->p_flags & PF_X)) + { + if (ppnt->p_vaddr == 0xff800000) + addr = _dl_sram_alloc(ppnt->p_memsz, L1_DATA_A_SRAM); + else if (ppnt->p_vaddr == 0xff900000) + addr = _dl_sram_alloc(ppnt->p_memsz, L1_DATA_B_SRAM); + else + addr = _dl_sram_alloc (ppnt->p_memsz, L1_DATA_SRAM); + + if (addr) { + if (_DL_PREAD(infile, addr, ppnt->p_filesz, ppnt->p_offset) != ppnt->p_filesz) { + _dl_sram_free(addr); + return NULL; + } + if (ppnt->p_filesz < ppnt->p_memsz) + _dl_memset(addr + ppnt->p_filesz, 0, ppnt->p_memsz - ppnt->p_filesz); + } else + _dl_dprintf(2, "%s:%i: L1 allocation failed\n", _dl_progname, __LINE__); + return addr; + } + + /* Handle L2 mappings */ + if (ppnt->p_vaddr == 0xfeb00000 || ppnt->p_vaddr == 0xfec00000) { + addr = _dl_sram_alloc(ppnt->p_memsz, L2_SRAM); + if (addr) { + if (_DL_PREAD(infile, addr, ppnt->p_filesz, ppnt->p_offset) != ppnt->p_filesz) { + _dl_sram_free(addr); + return NULL; + } + if (ppnt->p_filesz < ppnt->p_memsz) + _dl_memset(addr + ppnt->p_filesz, 0, ppnt->p_memsz - ppnt->p_filesz); + } else + _dl_dprintf(2, "%s:%i: L2 allocation failed\n", _dl_progname, __LINE__); + return addr; + } + + return 0; } diff --git a/ldso/ldso/fdpic/dl-inlines.h b/ldso/ldso/fdpic/dl-inlines.h index 42ad23b81..14a491689 100644 --- a/ldso/ldso/fdpic/dl-inlines.h +++ b/ldso/ldso/fdpic/dl-inlines.h @@ -5,480 +5,468 @@ * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. */ -#ifndef _dl_assert -# define _dl_assert(expr) -#endif - -/* Initialize a DL_LOADADDR_TYPE given a got pointer and a complete - load map. */ +/* Initialize a DL_LOADADDR_TYPE given a got pointer and a complete load map. */ static __always_inline void -__dl_init_loadaddr_map (struct elf32_fdpic_loadaddr *loadaddr, Elf32_Addr dl_boot_got_pointer, - struct elf32_fdpic_loadmap *map) +__dl_init_loadaddr_map(struct elf32_fdpic_loadaddr *loadaddr, Elf32_Addr dl_boot_got_pointer, + struct elf32_fdpic_loadmap *map) { - if (map->version != 0) - { - SEND_EARLY_STDERR ("Invalid loadmap version number\n"); - _dl_exit(-1); - } - if (map->nsegs == 0) - { - SEND_EARLY_STDERR ("Invalid segment count in loadmap\n"); - _dl_exit(-1); - } - loadaddr->got_value = (void *)dl_boot_got_pointer; - loadaddr->map = map; + if (map->version != 0) { + SEND_EARLY_STDERR("Invalid loadmap version number\n"); + _dl_exit(-1); + } + if (map->nsegs == 0) { + SEND_EARLY_STDERR("Invalid segment count in loadmap\n"); + _dl_exit(-1); + } + loadaddr->got_value = (void *)dl_boot_got_pointer; + loadaddr->map = map; } -/* Figure out how many LOAD segments there are in the given headers, - and allocate a block for the load map big enough for them. - got_value will be properly initialized later on, with INIT_GOT. */ +/* + * Figure out how many LOAD segments there are in the given headers, + * and allocate a block for the load map big enough for them. + * got_value will be properly initialized later on, with INIT_GOT. + */ static __always_inline int -__dl_init_loadaddr (struct elf32_fdpic_loadaddr *loadaddr, Elf32_Phdr *ppnt, - int pcnt) +__dl_init_loadaddr(struct elf32_fdpic_loadaddr *loadaddr, Elf32_Phdr *ppnt, + int pcnt) { - int count = 0, i; - size_t size; + int count = 0, i; + size_t size; - for (i = 0; i < pcnt; i++) - if (ppnt[i].p_type == PT_LOAD) - count++; + for (i = 0; i < pcnt; i++) + if (ppnt[i].p_type == PT_LOAD) + count++; - loadaddr->got_value = 0; + loadaddr->got_value = 0; - size = sizeof (struct elf32_fdpic_loadmap) - + sizeof (struct elf32_fdpic_loadseg) * count; - loadaddr->map = _dl_malloc (size); - if (! loadaddr->map) - _dl_exit (-1); + size = sizeof(struct elf32_fdpic_loadmap) + + (sizeof(struct elf32_fdpic_loadseg) * count); + loadaddr->map = _dl_malloc(size); + if (!loadaddr->map) + _dl_exit(-1); - loadaddr->map->version = 0; - loadaddr->map->nsegs = 0; + loadaddr->map->version = 0; + loadaddr->map->nsegs = 0; - return count; + return count; } -/* Incrementally initialize a load map. */ +/* Incrementally initialize a load map. */ static __always_inline void -__dl_init_loadaddr_hdr (struct elf32_fdpic_loadaddr loadaddr, void *addr, - Elf32_Phdr *phdr, int maxsegs) +__dl_init_loadaddr_hdr(struct elf32_fdpic_loadaddr loadaddr, void *addr, + Elf32_Phdr *phdr, int maxsegs) { - struct elf32_fdpic_loadseg *segdata; + struct elf32_fdpic_loadseg *segdata; - if (loadaddr.map->nsegs == maxsegs) - _dl_exit (-1); + if (loadaddr.map->nsegs == maxsegs) + _dl_exit(-1); - segdata = &loadaddr.map->segs[loadaddr.map->nsegs++]; - segdata->addr = (Elf32_Addr) addr; - segdata->p_vaddr = phdr->p_vaddr; - segdata->p_memsz = phdr->p_memsz; + segdata = &loadaddr.map->segs[loadaddr.map->nsegs++]; + segdata->addr = (Elf32_Addr)addr; + segdata->p_vaddr = phdr->p_vaddr; + segdata->p_memsz = phdr->p_memsz; -#if defined (__SUPPORT_LD_DEBUG__) - if (_dl_debug) - _dl_dprintf(_dl_debug_file, "%i: mapped %x at %x, size %x\n", - loadaddr.map->nsegs-1, - segdata->p_vaddr, segdata->addr, segdata->p_memsz); +#if defined(__SUPPORT_LD_DEBUG__) + if (_dl_debug) + _dl_dprintf(_dl_debug_file, "%i: mapped %x at %x, size %x\n", + loadaddr.map->nsegs - 1, + segdata->p_vaddr, segdata->addr, segdata->p_memsz); #endif } -/* Replace an existing entry in the load map. */ +/* Replace an existing entry in the load map. */ static __always_inline void -__dl_update_loadaddr_hdr (struct elf32_fdpic_loadaddr loadaddr, void *addr, - Elf32_Phdr *phdr) +__dl_update_loadaddr_hdr(struct elf32_fdpic_loadaddr loadaddr, void *addr, + Elf32_Phdr *phdr) { - struct elf32_fdpic_loadseg *segdata; - void *oldaddr; - int i; - - for (i = 0; i < loadaddr.map->nsegs; i++) - if (loadaddr.map->segs[i].p_vaddr == phdr->p_vaddr - && loadaddr.map->segs[i].p_memsz == phdr->p_memsz) - break; - if (i == loadaddr.map->nsegs) - _dl_exit (-1); - - segdata = loadaddr.map->segs + i; - oldaddr = (void *)segdata->addr; - _dl_munmap (oldaddr, segdata->p_memsz); - segdata->addr = (Elf32_Addr) addr; + struct elf32_fdpic_loadseg *segdata; + void *oldaddr; + int i; + + for (i = 0; i < loadaddr.map->nsegs; i++) + if (loadaddr.map->segs[i].p_vaddr == phdr->p_vaddr && + loadaddr.map->segs[i].p_memsz == phdr->p_memsz) + break; + if (i == loadaddr.map->nsegs) + _dl_exit(-1); + + segdata = loadaddr.map->segs + i; + oldaddr = (void *)segdata->addr; + _dl_munmap(oldaddr, segdata->p_memsz); + segdata->addr = (Elf32_Addr)addr; #if defined (__SUPPORT_LD_DEBUG__) - if (_dl_debug) - _dl_dprintf(_dl_debug_file, "%i: changed mapping %x at %x (old %x), size %x\n", - loadaddr.map->nsegs-1, - segdata->p_vaddr, segdata->addr, oldaddr, segdata->p_memsz); + if (_dl_debug) + _dl_dprintf(_dl_debug_file, "%i: changed mapping %x at %x (old %x), size %x\n", + loadaddr.map->nsegs - 1, + segdata->p_vaddr, segdata->addr, oldaddr, segdata->p_memsz); #endif } -static __always_inline void __dl_loadaddr_unmap -(struct elf32_fdpic_loadaddr loadaddr, struct funcdesc_ht *funcdesc_ht); -/* Figure out whether the given address is in one of the mapped - segments. */ -static __always_inline int -__dl_addr_in_loadaddr (void *p, struct elf32_fdpic_loadaddr loadaddr) +#ifndef __dl_loadaddr_unmap +static __always_inline void +__dl_loadaddr_unmap(struct elf32_fdpic_loadaddr loadaddr, + struct funcdesc_ht *funcdesc_ht) { - struct elf32_fdpic_loadmap *map = loadaddr.map; - int c; - - for (c = 0; c < map->nsegs; c++) - if ((void*)map->segs[c].addr <= p - && (char*)p < (char*)map->segs[c].addr + map->segs[c].p_memsz) - return 1; - - return 0; + int i; + + for (i = 0; i < loadaddr.map->nsegs; i++) + _dl_munmap((void *)loadaddr.map->segs[i].addr, + loadaddr.map->segs[i].p_memsz); + + /* + * _dl_unmap is only called for dlopen()ed libraries, for which + * calling free() is safe, or before we've completed the initial + * relocation, in which case calling free() is probably pointless, + * but still safe. + */ + _dl_free(loadaddr.map); + if (funcdesc_ht) + htab_delete(funcdesc_ht); } +#endif -static __always_inline void * _dl_funcdesc_for (void *entry_point, void *got_value); +/* Figure out whether the given address is in one of the mapped segments. */ +static __always_inline int +__dl_addr_in_loadaddr(void *p, struct elf32_fdpic_loadaddr loadaddr) +{ + struct elf32_fdpic_loadmap *map = loadaddr.map; + int c; -/* The hashcode handling code below is heavily inspired in libiberty's - hashtab code, but with most adaptation points and support for - deleting elements removed. + for (c = 0; c < map->nsegs; c++) + if ((void *)map->segs[c].addr <= p && + (char *)p < (char *)map->segs[c].addr + map->segs[c].p_memsz) + return 1; - Copyright (C) 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc. - Contributed by Vladimir Makarov (vmakarov@cygnus.com). */ + return 0; +} +/* + * The hashcode handling code below is heavily inspired in libiberty's + * hashtab code, but with most adaptation points and support for + * deleting elements removed. + * + * Copyright (C) 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc. + * Contributed by Vladimir Makarov (vmakarov@cygnus.com). + */ static __always_inline unsigned long -higher_prime_number (unsigned long n) +higher_prime_number(unsigned long n) { - /* These are primes that are near, but slightly smaller than, a - power of two. */ - static const unsigned long primes[] = { - (unsigned long) 7, - (unsigned long) 13, - (unsigned long) 31, - (unsigned long) 61, - (unsigned long) 127, - (unsigned long) 251, - (unsigned long) 509, - (unsigned long) 1021, - (unsigned long) 2039, - (unsigned long) 4093, - (unsigned long) 8191, - (unsigned long) 16381, - (unsigned long) 32749, - (unsigned long) 65521, - (unsigned long) 131071, - (unsigned long) 262139, - (unsigned long) 524287, - (unsigned long) 1048573, - (unsigned long) 2097143, - (unsigned long) 4194301, - (unsigned long) 8388593, - (unsigned long) 16777213, - (unsigned long) 33554393, - (unsigned long) 67108859, - (unsigned long) 134217689, - (unsigned long) 268435399, - (unsigned long) 536870909, - (unsigned long) 1073741789, - (unsigned long) 2147483647, - /* 4294967291L */ - ((unsigned long) 2147483647) + ((unsigned long) 2147483644), - }; - - const unsigned long *low = &primes[0]; - const unsigned long *high = &primes[sizeof(primes) / sizeof(primes[0])]; - - while (low != high) - { - const unsigned long *mid = low + (high - low) / 2; - if (n > *mid) - low = mid + 1; - else - high = mid; - } + /* These are primes that are near, but slightly smaller than, a power of two. */ + static const unsigned long primes[] = { + 7, + 13, + 31, + 61, + 127, + 251, + 509, + 1021, + 2039, + 4093, + 8191, + 16381, + 32749, + 65521, + 131071, + 262139, + 524287, + 1048573, + 2097143, + 4194301, + 8388593, + 16777213, + 33554393, + 67108859, + 134217689, + 268435399, + 536870909, + 1073741789, + /* 4294967291 */ + ((unsigned long) 2147483647) + ((unsigned long) 2147483644), + }; + const unsigned long *low = &primes[0]; + const unsigned long *high = &primes[ARRAY_SIZE(primes)]; + + while (low != high) { + const unsigned long *mid = low + (high - low) / 2; + if (n > *mid) + low = mid + 1; + else + high = mid; + } #if 0 - /* If we've run out of primes, abort. */ - if (n > *low) - { - fprintf (stderr, "Cannot find prime bigger than %lu\n", n); - abort (); - } + /* If we've run out of primes, abort. */ + if (n > *low) { + fprintf(stderr, "Cannot find prime bigger than %lu\n", n); + abort(); + } #endif - return *low; + return *low; } struct funcdesc_ht { - /* Table itself. */ - struct funcdesc_value **entries; + /* Table itself */ + struct funcdesc_value **entries; - /* Current size (in entries) of the hash table */ - size_t size; + /* Current size (in entries) of the hash table */ + size_t size; - /* Current number of elements. */ - size_t n_elements; + /* Current number of elements */ + size_t n_elements; }; static __always_inline int -hash_pointer (const void *p) +hash_pointer(const void *p) { - return (int) ((long)p >> 3); + return (int) ((long)p >> 3); } static __always_inline struct funcdesc_ht * -htab_create (void) +htab_create(void) { - struct funcdesc_ht *ht = _dl_malloc (sizeof (struct funcdesc_ht)); - - if (! ht) - return NULL; - ht->size = 3; - ht->entries = _dl_malloc (sizeof (struct funcdesc_ht_value *) * ht->size); - if (! ht->entries) - return NULL; + struct funcdesc_ht *ht = _dl_malloc(sizeof(*ht)); + size_t ent_size; - ht->n_elements = 0; + if (!ht) + return NULL; + ht->size = 3; + ent_size = sizeof(struct funcdesc_ht_value *) * ht->size; + ht->entries = _dl_malloc(ent_size); + if (!ht->entries) + return NULL; - _dl_memset (ht->entries, 0, sizeof (struct funcdesc_ht_value *) * ht->size); + ht->n_elements = 0; + _dl_memset(ht->entries, 0, ent_size); - return ht; + return ht; } -/* This is only called from _dl_loadaddr_unmap, so it's safe to call - _dl_free(). See the discussion below. */ +/* + * This is only called from _dl_loadaddr_unmap, so it's safe to call + * _dl_free(). See the discussion below. + */ static __always_inline void -htab_delete (struct funcdesc_ht *htab) +htab_delete(struct funcdesc_ht *htab) { - int i; + size_t i; - for (i = htab->size - 1; i >= 0; i--) - if (htab->entries[i]) - _dl_free (htab->entries[i]); + for (i = htab->size - 1; i >= 0; i--) + if (htab->entries[i]) + _dl_free(htab->entries[i]); - _dl_free (htab->entries); - _dl_free (htab); + _dl_free(htab->entries); + _dl_free(htab); } -/* Similar to htab_find_slot, but without several unwanted side effects: - - Does not call htab->eq_f when it finds an existing entry. - - Does not change the count of elements/searches/collisions in the - hash table. - This function also assumes there are no deleted entries in the table. - HASH is the hash value for the element to be inserted. */ - +/* + * Similar to htab_find_slot, but without several unwanted side effects: + * - Does not call htab->eq_f when it finds an existing entry. + * - Does not change the count of elements/searches/collisions in the + * hash table. + * This function also assumes there are no deleted entries in the table. + * HASH is the hash value for the element to be inserted. + */ static __always_inline struct funcdesc_value ** -find_empty_slot_for_expand (struct funcdesc_ht *htab, int hash) +find_empty_slot_for_expand(struct funcdesc_ht *htab, int hash) { - size_t size = htab->size; - unsigned int index = hash % size; - struct funcdesc_value **slot = htab->entries + index; - int hash2; - - if (! *slot) - return slot; - - hash2 = 1 + hash % (size - 2); - for (;;) - { - index += hash2; - if (index >= size) - index -= size; - - slot = htab->entries + index; - if (! *slot) - return slot; - } + size_t size = htab->size; + unsigned int index = hash % size; + struct funcdesc_value **slot = htab->entries + index; + int hash2; + + if (!*slot) + return slot; + + hash2 = 1 + hash % (size - 2); + for (;;) { + index += hash2; + if (index >= size) + index -= size; + + slot = htab->entries + index; + if (!*slot) + return slot; + } } -/* The following function changes size of memory allocated for the - entries and repeatedly inserts the table elements. The occupancy - of the table after the call will be about 50%. Naturally the hash - table must already exist. Remember also that the place of the - table entries is changed. If memory allocation failures are allowed, - this function will return zero, indicating that the table could not be - expanded. If all goes well, it will return a non-zero value. */ - +/* + * The following function changes size of memory allocated for the + * entries and repeatedly inserts the table elements. The occupancy + * of the table after the call will be about 50%. Naturally the hash + * table must already exist. Remember also that the place of the + * table entries is changed. If memory allocation failures are allowed, + * this function will return zero, indicating that the table could not be + * expanded. If all goes well, it will return a non-zero value. + */ static __always_inline int -htab_expand (struct funcdesc_ht *htab) +htab_expand(struct funcdesc_ht *htab) { - struct funcdesc_value **oentries; - struct funcdesc_value **olimit; - struct funcdesc_value **p; - struct funcdesc_value **nentries; - size_t nsize; - - oentries = htab->entries; - olimit = oentries + htab->size; - - /* Resize only when table after removal of unused elements is either - too full or too empty. */ - if (htab->n_elements * 2 > htab->size) - nsize = higher_prime_number (htab->n_elements * 2); - else - nsize = htab->size; - - nentries = _dl_malloc (sizeof (struct funcdesc_value *) * nsize); - _dl_memset (nentries, 0, sizeof (struct funcdesc_value *) * nsize); - if (nentries == NULL) - return 0; - htab->entries = nentries; - htab->size = nsize; - - p = oentries; - do - { - if (*p) - *find_empty_slot_for_expand (htab, hash_pointer ((*p)->entry_point)) - = *p; - - p++; - } - while (p < olimit); - -#if 0 /* We can't tell whether this was allocated by the _dl_malloc() - built into ld.so or malloc() in the main executable or libc, - and calling free() for something that wasn't malloc()ed could - do Very Bad Things (TM). Take the conservative approach - here, potentially wasting as much memory as actually used by - the hash table, even if multiple growths occur. That's not - so bad as to require some overengineered solution that would - enable us to keep track of how it was allocated. */ - _dl_free (oentries); + struct funcdesc_value **oentries; + struct funcdesc_value **olimit; + struct funcdesc_value **p; + struct funcdesc_value **nentries; + size_t nsize; + + oentries = htab->entries; + olimit = oentries + htab->size; + + /* + * Resize only when table after removal of unused elements is either + * too full or too empty. + */ + if (htab->n_elements * 2 > htab->size) + nsize = higher_prime_number(htab->n_elements * 2); + else + nsize = htab->size; + + nentries = _dl_malloc(sizeof(*nentries) * nsize); + _dl_memset(nentries, 0, sizeof(*nentries) * nsize); + if (nentries == NULL) + return 0; + htab->entries = nentries; + htab->size = nsize; + + p = oentries; + do { + if (*p) + *find_empty_slot_for_expand(htab, hash_pointer((*p)->entry_point)) = *p; + p++; + } while (p < olimit); + +#if 0 + /* + * We can't tell whether this was allocated by the _dl_malloc() + * built into ld.so or malloc() in the main executable or libc, + * and calling free() for something that wasn't malloc()ed could + * do Very Bad Things (TM). Take the conservative approach + * here, potentially wasting as much memory as actually used by + * the hash table, even if multiple growths occur. That's not + * so bad as to require some overengineered solution that would + * enable us to keep track of how it was allocated. + */ + _dl_free(oentries); #endif - return 1; + return 1; } -/* This function searches for a hash table slot containing an entry - equal to the given element. To delete an entry, call this with - INSERT = 0, then call htab_clear_slot on the slot returned (possibly - after doing some checks). To insert an entry, call this with - INSERT = 1, then write the value you want into the returned slot. - When inserting an entry, NULL may be returned if memory allocation - fails. */ - +/* + * This function searches for a hash table slot containing an entry + * equal to the given element. To delete an entry, call this with + * INSERT = 0, then call htab_clear_slot on the slot returned (possibly + * after doing some checks). To insert an entry, call this with + * INSERT = 1, then write the value you want into the returned slot. + * When inserting an entry, NULL may be returned if memory allocation + * fails. + */ static __always_inline struct funcdesc_value ** -htab_find_slot (struct funcdesc_ht *htab, void *ptr, int insert) +htab_find_slot(struct funcdesc_ht *htab, void *ptr, int insert) { - unsigned int index; - int hash, hash2; - size_t size; - struct funcdesc_value **entry; - - if (htab->size * 3 <= htab->n_elements * 4 - && htab_expand (htab) == 0) - return NULL; - - hash = hash_pointer (ptr); - - size = htab->size; - index = hash % size; - - entry = &htab->entries[index]; - if (!*entry) - goto empty_entry; - else if ((*entry)->entry_point == ptr) - return entry; - - hash2 = 1 + hash % (size - 2); - for (;;) - { - index += hash2; - if (index >= size) - index -= size; - - entry = &htab->entries[index]; - if (!*entry) - goto empty_entry; - else if ((*entry)->entry_point == ptr) - return entry; - } + unsigned int index; + int hash, hash2; + size_t size; + struct funcdesc_value **entry; + + if (htab->size * 3 <= htab->n_elements * 4 && + htab_expand(htab) == 0) + return NULL; + + hash = hash_pointer(ptr); + + size = htab->size; + index = hash % size; + + entry = &htab->entries[index]; + if (!*entry) + goto empty_entry; + else if ((*entry)->entry_point == ptr) + return entry; + + hash2 = 1 + hash % (size - 2); + for (;;) { + index += hash2; + if (index >= size) + index -= size; + + entry = &htab->entries[index]; + if (!*entry) + goto empty_entry; + else if ((*entry)->entry_point == ptr) + return entry; + } empty_entry: - if (!insert) - return NULL; + if (!insert) + return NULL; - htab->n_elements++; - return entry; + htab->n_elements++; + return entry; } void * _dl_funcdesc_for (void *entry_point, void *got_value) { - struct elf_resolve *tpnt = ((void**)got_value)[2]; - struct funcdesc_ht *ht = tpnt->funcdesc_ht; - struct funcdesc_value **entry; - - _dl_assert (got_value == tpnt->loadaddr.got_value); - - if (! ht) - { - ht = htab_create (); - if (! ht) - return (void*)-1; - tpnt->funcdesc_ht = ht; - } - - entry = htab_find_slot (ht, entry_point, 1); - if (*entry) - { - _dl_assert ((*entry)->entry_point == entry_point); - return _dl_stabilize_funcdesc (*entry); - } - - *entry = _dl_malloc (sizeof (struct funcdesc_value)); - (*entry)->entry_point = entry_point; - (*entry)->got_value = got_value; - - return _dl_stabilize_funcdesc (*entry); + struct elf_resolve *tpnt = ((void**)got_value)[2]; + struct funcdesc_ht *ht = tpnt->funcdesc_ht; + struct funcdesc_value **entry; + + _dl_assert(got_value == tpnt->loadaddr.got_value); + + if (!ht) { + ht = htab_create(); + if (!ht) + return (void*)-1; + tpnt->funcdesc_ht = ht; + } + + entry = htab_find_slot(ht, entry_point, 1); + if (*entry) { + _dl_assert((*entry)->entry_point == entry_point); + return _dl_stabilize_funcdesc(*entry); + } + + *entry = _dl_malloc(sizeof(**entry)); + (*entry)->entry_point = entry_point; + (*entry)->got_value = got_value; + + return _dl_stabilize_funcdesc(*entry); } static __always_inline void const * -_dl_lookup_address (void const *address) +_dl_lookup_address(void const *address) { - struct elf_resolve *rpnt; - struct funcdesc_value const *fd; + struct elf_resolve *rpnt; + struct funcdesc_value const *fd; - /* Make sure we don't make assumptions about its alignment. */ - __asm__ ("" : "+r" (address)); + /* Make sure we don't make assumptions about its alignment. */ + __asm__ ("" : "+r" (address)); - if ((Elf32_Addr)address & 7) - /* It's not a function descriptor. */ - return address; + if ((Elf32_Addr)address & 7) + /* It's not a function descriptor. */ + return address; - fd = (struct funcdesc_value const *)address; + fd = address; - for (rpnt = _dl_loaded_modules; rpnt; rpnt = rpnt->next) - { - if (! rpnt->funcdesc_ht) - continue; + for (rpnt = _dl_loaded_modules; rpnt; rpnt = rpnt->next) { + if (!rpnt->funcdesc_ht) + continue; - if (fd->got_value != rpnt->loadaddr.got_value) - continue; + if (fd->got_value != rpnt->loadaddr.got_value) + continue; - address = htab_find_slot (rpnt->funcdesc_ht, (void*)fd->entry_point, 0); + address = htab_find_slot(rpnt->funcdesc_ht, (void *)fd->entry_point, 0); - if (address && *(struct funcdesc_value *const*)address == fd) - { - address = (*(struct funcdesc_value *const*)address)->entry_point; - break; + if (address && *(struct funcdesc_value *const*)address == fd) { + address = (*(struct funcdesc_value *const*)address)->entry_point; + break; + } else + address = fd; } - else - address = fd; - } - return address; + return address; } - -#ifndef __dl_loadaddr_unmap -void -__dl_loadaddr_unmap (struct elf32_fdpic_loadaddr loadaddr, - struct funcdesc_ht *funcdesc_ht) -{ - int i; - - for (i = 0; i < loadaddr.map->nsegs; i++) - _dl_munmap ((void*)loadaddr.map->segs[i].addr, - loadaddr.map->segs[i].p_memsz); - - /* _dl_unmap is only called for dlopen()ed libraries, for which - calling free() is safe, or before we've completed the initial - relocation, in which case calling free() is probably pointless, - but still safe. */ - _dl_free (loadaddr.map); - if (funcdesc_ht) - htab_delete (funcdesc_ht); -} -#endif |