do
{
- if (__builtin_expect (*name, 'a') == '$')
+ if (__builtin_expect (*name == '$', 0))
{
const char *repl = NULL;
size_t len = 1;
char *cp;
struct r_search_path_elem **result;
size_t nelems;
+ /* Initialize to please the compiler. */
+ const char *errstring = NULL;
/* First see whether we must forget the RUNPATH and RPATH from this
object. */
result = (struct r_search_path_elem **)
malloc (sizeof (*result));
if (result == NULL)
- _dl_signal_error (ENOMEM, NULL, NULL,
- N_("cannot create cache for search path"));
+ {
+ signal_error_cache:
+ errstring = N_("cannot create cache for search path");
+ signal_error:
+ _dl_signal_error (ENOMEM, NULL, NULL, errstring);
+ }
+
result[0] = NULL;
sps->dirs = result;
string tokens. */
copy = expand_dynamic_string_token (l, rpath);
if (copy == NULL)
- _dl_signal_error (ENOMEM, NULL, NULL,
- N_("cannot create RUNPATH/RPATH copy"));
+ {
+ errstring = N_("cannot create RUNPATH/RPATH copy");
+ goto signal_error;
+ }
/* Count the number of necessary elements in the result array. */
nelems = 0;
result = (struct r_search_path_elem **) malloc ((nelems + 1 + 1)
* sizeof (*result));
if (result == NULL)
- _dl_signal_error (ENOMEM, NULL, NULL,
- N_("cannot create cache for search path"));
+ goto signal_error_cache;
fillin_rpath (copy, result, ":", 0, what, where);
#ifdef SHARED
struct link_map *l;
#endif
+ /* Initialize to please the compiler. */
+ const char *errstring = NULL;
/* Fill in the information about the application's RPATH and the
directories addressed by the LD_LIBRARY_PATH environment variable. */
aelem = rtld_search_dirs.dirs = (struct r_search_path_elem **)
malloc ((nsystem_dirs_len + 1) * sizeof (struct r_search_path_elem *));
if (rtld_search_dirs.dirs == NULL)
- _dl_signal_error (ENOMEM, NULL, NULL,
- N_("cannot create search path array"));
+ {
+ errstring = N_("cannot create search path array");
+ signal_error:
+ _dl_signal_error (ENOMEM, NULL, NULL, errstring);
+ }
round_size = ((2 * sizeof (struct r_search_path_elem) - 1
+ ncapstr * sizeof (enum r_dir_status))
malloc ((sizeof (system_dirs) / sizeof (system_dirs[0]))
* round_size * sizeof (struct r_search_path_elem));
if (rtld_search_dirs.dirs[0] == NULL)
- _dl_signal_error (ENOMEM, NULL, NULL,
- N_("cannot create cache for search path"));
+ {
+ errstring = N_("cannot create cache for search path");
+ goto signal_error;
+ }
rtld_search_dirs.malloced = 0;
pelem = _dl_all_dirs = rtld_search_dirs.dirs[0];
env_path_list.dirs = (struct r_search_path_elem **)
malloc ((nllp + 1) * sizeof (struct r_search_path_elem *));
if (env_path_list.dirs == NULL)
- _dl_signal_error (ENOMEM, NULL, NULL,
- N_("cannot create cache for search path"));
+ {
+ errstring = N_("cannot create cache for search path");
+ goto signal_error;
+ }
(void) fillin_rpath (llp_tmp, env_path_list.dirs, ":;",
__libc_enable_secure, "LD_LIBRARY_PATH", NULL);
performance does not count. The function used to be "inlinable" and
the compiled did so all the time. This increased the code size for
absolutely no good reason. */
-#define LOSE(code, s) lose (code, fd, name, realname, l, s)
static void
__attribute__ ((noreturn))
lose (int code, int fd, const char *name, char *realname, struct link_map *l,
int mode)
{
struct link_map *l = NULL;
-
- auto inline caddr_t map_segment (ElfW(Addr) mapstart, size_t len,
- int prot, int fixed, off_t offset);
-
- inline caddr_t map_segment (ElfW(Addr) mapstart, size_t len,
- int prot, int fixed, off_t offset)
- {
- caddr_t mapat = __mmap ((caddr_t) mapstart, len, prot,
- fixed|MAP_COPY|MAP_FILE,
- fd, offset);
- if (mapat == MAP_FAILED)
- LOSE (errno, N_("failed to map segment from shared object"));
- return mapat;
- }
-
const ElfW(Ehdr) *header;
const ElfW(Phdr) *phdr;
const ElfW(Phdr) *ph;
size_t maplength;
int type;
struct stat64 st;
+ /* Initialize to keep the compiler happy. */
+ const char *errstring = NULL;
+ int errval = 0;
/* Get file information. */
- if (__fxstat64 (_STAT_VER, fd, &st) < 0)
- LOSE (errno, N_("cannot stat shared object"));
+ if (__builtin_expect (__fxstat64 (_STAT_VER, fd, &st) < 0, 0))
+ {
+ errstring = N_("cannot stat shared object");
+ call_lose_errno:
+ errval = errno;
+ call_lose:
+ lose (errval, fd, name, realname, l, errstring);
+ }
/* Look again to see if the real name matched another already loaded. */
for (l = _dl_loaded; l; l = l->l_next)
/* Enter the new object in the list of loaded objects. */
l = _dl_new_object (realname, name, l_type, loader);
if (__builtin_expect (! l, 0))
- LOSE (ENOMEM, N_("cannot create shared object descriptor"));
+ {
+ errstring = N_("cannot create shared object descriptor");
+ goto call_lose_errno;
+ }
/* Extract the remaining details we need from the ELF header
and then read in the program header table. */
phdr = alloca (maplength);
__lseek (fd, SEEK_SET, header->e_phoff);
if (__libc_read (fd, (void *) phdr, maplength) != maplength)
- LOSE (errno, N_("cannot read file data"));
+ {
+ errstring = N_("cannot read file data");
+ goto call_lose_errno;
+ }
}
{
l->l_ld = (void *) ph->p_vaddr;
l->l_ldnum = ph->p_memsz / sizeof (ElfW(Dyn));
break;
+
case PT_PHDR:
l->l_phdr = (void *) ph->p_vaddr;
break;
case PT_LOAD:
/* A load command tells us to map in part of the file.
We record the load commands and process them all later. */
- if (ph->p_align % _dl_pagesize != 0)
- LOSE (0, N_("ELF load command alignment not page-aligned"));
- if ((ph->p_vaddr - ph->p_offset) % ph->p_align)
- LOSE (0,
- N_("ELF load command address/offset not properly aligned"));
+ if ((ph->p_align & (_dl_pagesize - 1)) != 0)
+ {
+ errstring = N_("ELF load command alignment not page-aligned");
+ goto call_lose;
+ }
+ if (((ph->p_vaddr - ph->p_offset) & (ph->p_align - 1)) != 0)
+ {
+ errstring
+ = N_("ELF load command address/offset not properly aligned");
+ goto call_lose;
+ }
+
{
struct loadcmd *c = &loadcmds[nloadcmds++];
c->mapstart = ph->p_vaddr & ~(ph->p_align - 1);
- MAP_BASE_ADDR (l));
/* Remember which part of the address space this object uses. */
- l->l_map_start = (ElfW(Addr)) map_segment (mappref, maplength, c->prot,
- 0, c->mapoff);
+ l->l_map_start = (ElfW(Addr)) __mmap ((void *) mappref, maplength,
+ c->prot, MAP_COPY | MAP_FILE,
+ fd, c->mapoff);
+ if ((void *) l->l_map_start == MAP_FAILED)
+ {
+ map_error:
+ errstring = N_("failed to map segment from shared object");
+ goto call_lose_errno;
+ }
+
l->l_map_end = l->l_map_start + maplength;
l->l_addr = l->l_map_start - c->mapstart;
happen for objects loaded with dlopen(). */
if (__builtin_expect (mode & __RTLD_DLOPEN, 0))
{
- LOSE (0, N_("cannot dynamically load executable"));
+ errstring = N_("cannot dynamically load executable");
+ goto call_lose;
}
/* Notify ELF_PREFERRED_ADDRESS that we have to load this one
while (c < &loadcmds[nloadcmds])
{
- if (c->mapend > c->mapstart)
- /* Map the segment contents from the file. */
- map_segment (l->l_addr + c->mapstart, c->mapend - c->mapstart,
- c->prot, MAP_FIXED, c->mapoff);
+ if (c->mapend > c->mapstart
+ /* Map the segment contents from the file. */
+ && (__mmap ((void *) (l->l_addr + c->mapstart),
+ c->mapend - c->mapstart, c->prot,
+ MAP_FIXED | MAP_COPY | MAP_FILE, fd, c->mapoff)
+ == MAP_FAILED))
+ goto map_error;
postmap:
if (l->l_phdr == 0
/* Dag nab it. */
if (__mprotect ((caddr_t) (zero & ~(_dl_pagesize - 1)),
_dl_pagesize, c->prot|PROT_WRITE) < 0)
- LOSE (errno, N_("cannot change memory protections"));
+ {
+ errstring = N_("cannot change memory protections");
+ goto call_lose_errno;
+ }
}
memset ((void *) zero, '\0', zeropage - zero);
if ((c->prot & PROT_WRITE) == 0)
c->prot, MAP_ANON|MAP_PRIVATE|MAP_FIXED,
ANONFD, 0);
if (mapat == MAP_FAILED)
- LOSE (errno, N_("cannot map zero-fill pages"));
+ {
+ errstring = N_("cannot map zero-fill pages");
+ goto call_lose_errno;
+ }
}
}
ElfW(Phdr) *newp = (ElfW(Phdr) *) malloc (header->e_phnum
* sizeof (ElfW(Phdr)));
if (newp == NULL)
- LOSE (ENOMEM, N_("cannot allocate memory for program header"));
+ {
+ errstring = N_("cannot allocate memory for program header");
+ goto call_lose_errno;
+ }
l->l_phdr = memcpy (newp, phdr,
(header->e_phnum * sizeof (ElfW(Phdr))));
if (l->l_ld == 0)
{
if (type == ET_DYN)
- LOSE (0, N_("object file has no dynamic section"));
+ {
+ errstring = N_("object file has no dynamic section");
+ goto call_lose;
+ }
}
else
(ElfW(Addr)) l->l_ld += l->l_addr;
(struct link_map **) malloc (sizeof (struct link_map *));
if (l->l_symbolic_searchlist.r_list == NULL)
- LOSE (ENOMEM, N_("cannot create searchlist"));
+ {
+ errstring = N_("cannot create searchlist");
+ goto call_lose_errno;
+ }
l->l_symbolic_searchlist.r_list[0] = l;
l->l_symbolic_searchlist.r_nlist = 1;
}
/* Remember whether this object must be initialized first. */
- if (__builtin_expect (l->l_flags_1 & DF_1_INITFIRST, 0))
+ if (l->l_flags_1 & DF_1_INITFIRST)
_dl_initfirst = l;
/* Finally the file information. */
[EI_OSABI] = ELFOSABI_SYSV,
[EI_ABIVERSION] = 0
};
- static const struct {
- ElfW(Word) vendorlen, datalen, type;
+ static const struct
+ {
+ ElfW(Word) vendorlen;
+ ElfW(Word) datalen;
+ ElfW(Word) type;
char vendor[4];
} expected_note = { 4, 16, 1, "GNU" };
int fd;
+ /* Initialize it to make the compiler happy. */
+ const char *errstring = NULL;
+ int errval = 0;
/* Open the file. We always open files read-only. */
fd = __open (name, O_RDONLY);
/* Now run the tests. */
if (__builtin_expect (fbp->len < (ssize_t) sizeof (ElfW(Ehdr)), 0))
- lose (errno, fd, name, NULL, NULL,
- errno == 0 ? N_("file too short") : N_("cannot read file data"));
+ {
+ errval = errno;
+ errstring = (errval == 0
+ ? N_("file too short") : N_("cannot read file data"));
+ call_lose:
+ lose (errval, fd, name, NULL, NULL, errstring);
+ }
/* See whether the ELF header is what we expect. */
if (__builtin_expect (! VALID_ELF_HEADER (ehdr->e_ident, expected,
(ELFMAG3 << (EI_MAG0 * 8)))
#endif
)
- lose (0, fd, name, NULL, NULL, N_("invalid ELF header"));
-
- if (ehdr->e_ident[EI_CLASS] != ELFW(CLASS))
+ errstring = N_("invalid ELF header");
+ else if (ehdr->e_ident[EI_CLASS] != ELFW(CLASS))
/* This is not a fatal error. On architectures where
32-bit and 64-bit binaries can be run this might
happen. */
goto close_and_out;
-
- if (ehdr->e_ident[EI_DATA] != byteorder)
+ else if (ehdr->e_ident[EI_DATA] != byteorder)
{
if (BYTE_ORDER == BIG_ENDIAN)
- lose (0, fd, name, NULL, NULL,
- "ELF file data encoding not big-endian");
+ errstring = N_("ELF file data encoding not big-endian");
else
- lose (0, fd, name, NULL, NULL,
- "ELF file data encoding not little-endian");
+ errstring = N_("ELF file data encoding not little-endian");
}
- if (ehdr->e_ident[EI_VERSION] != EV_CURRENT)
- lose (0, fd, name, NULL, NULL,
- N_("ELF file version ident does not match current one"));
+ else if (ehdr->e_ident[EI_VERSION] != EV_CURRENT)
+ errstring
+ = N_("ELF file version ident does not match current one");
/* XXX We should be able so set system specific versions which are
allowed here. */
- if (!VALID_ELF_OSABI (ehdr->e_ident[EI_OSABI]))
- lose (0, fd, name, NULL, NULL, N_("ELF file OS ABI invalid"));
- if (!VALID_ELF_ABIVERSION (ehdr->e_ident[EI_ABIVERSION]))
- lose (0, fd, name, NULL, NULL,
- N_("ELF file ABI version invalid"));
- lose (0, fd, name, NULL, NULL, N_("internal error"));
+ else if (!VALID_ELF_OSABI (ehdr->e_ident[EI_OSABI]))
+ errstring = N_("ELF file OS ABI invalid");
+ else if (!VALID_ELF_ABIVERSION (ehdr->e_ident[EI_ABIVERSION]))
+ errstring = N_("ELF file ABI version invalid");
+ else
+ /* Otherwise we don't know what went wrong. */
+ errstring = N_("internal error");
+
+ goto call_lose;
}
if (__builtin_expect (ehdr->e_version, EV_CURRENT) != EV_CURRENT)
- lose (0, fd, name, NULL, NULL,
- N_("ELF file version does not match current one"));
+ {
+ errstring = N_("ELF file version does not match current one");
+ goto call_lose;
+ }
if (! __builtin_expect (elf_machine_matches_host (ehdr), 1))
goto close_and_out;
else if (__builtin_expect (ehdr->e_phentsize, sizeof (ElfW(Phdr)))
!= sizeof (ElfW(Phdr)))
- lose (0, fd, name, NULL, NULL,
- N_("ELF file's phentsize not the expected size"));
+ {
+ errstring = N_("ELF file's phentsize not the expected size");
+ goto call_lose;
+ }
else if (__builtin_expect (ehdr->e_type, ET_DYN) != ET_DYN
&& __builtin_expect (ehdr->e_type, ET_EXEC) != ET_EXEC)
- lose (0, fd, name, NULL, NULL,
- N_("only ET_DYN and ET_EXEC can be loaded"));
+ {
+ errstring = N_("only ET_DYN and ET_EXEC can be loaded");
+ goto call_lose;
+ }
maplength = ehdr->e_phnum * sizeof (ElfW(Phdr));
if (ehdr->e_phoff + maplength <= fbp->len)
phdr = alloca (maplength);
__lseek (fd, SEEK_SET, ehdr->e_phoff);
if (__libc_read (fd, (void *) phdr, maplength) != maplength)
- lose (errno, fd, name, NULL, NULL, N_("cannot read file data"));
+ {
+ read_error:
+ errval = errno;
+ errstring = N_("cannot read file data");
+ goto call_lose;
+ }
}
/* Check .note.ABI-tag if present. */
{
__lseek (fd, SEEK_SET, ph->p_offset);
if (__libc_read (fd, (void *) abi_note_buf, 32) != 32)
- lose (errno, fd, name, NULL, NULL,
- N_("cannot read file data"));
+ goto read_error;
+
abi_note = abi_note_buf;
}
projects / thirdparty / glibc.git / commitdiff
