Aksal/nuttx
3
1
Fork 1
mirror of https://github.com/apache/nuttx.git synced 2026-09-30 02:53:49 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 2
nuttx/libs/libc/elf/elf_bind.c
Marco Casaroli 50a735bf86 libs/libc/machine/arm: Relocate FDPIC function descriptors. 
A function pointer under FDPIC is not a code address.  Because each
PT_LOAD segment is placed independently, a pointer has to carry the data
base its callee will need, so it is a two-word descriptor: the entry
point, and the base to install in the PIC register before branching.
R_ARM_FUNCDESC_VALUE says "the thing you are patching is such a
descriptor", and R_ARM_FUNCDESC says "manufacture one and give me its
address".

Both need state a relocation cannot carry.  A descriptor's second word is
the *object's* data base, from DT_PLTGOT, and R_ARM_FUNCDESC carves
descriptors from a pool whose cursor has to survive from one relocation
to the next.  up_relocate() is handed only a relocation, a resolved
symbol and an address to patch.

arch_data is the existing channel for exactly this -- RISC-V already uses
it to remember a HI20 relocation while its LO12 partner is processed --
but nothing has ever put loader state into it: it is declared zeroed and
written only by up_relocate() itself.  So ARCH_ELFDATA_INIT and
ARCH_ELFDATA_FINI are added, seeding the block from the loadinfo before
the relocation loop and reading the cursor back after.  Both default to
nothing, so an architecture that does not define them is unaffected, and
RISC-V's use of arch_data is untouched.  libelf_relocatedyn() walks both
dynamic tables under one arch_data, so the cursor spans the whole object.

The addend handling is the part that is easy to get wrong.  REL format
keeps the addend in place, in the word about to become the entry point,
and a pointer to a static function is referenced through its *section*
symbol -- the value is the section base and the offset, including the
Thumb bit, is entirely in the addend.  Dropping it yields an even address
and the core faults trying to execute it as ARM code.

The GOT written into a descriptor is the loading object's own, even for
an imported function, which is what makes a callback work: when the base
firmware's qsort() calls back into a module's comparison function, the
module needs its own data base in the PIC register.

libelf_relocatedyn()'s imported-symbol path needed a change to suit.  It
stores the resolved address directly and never calls up_relocate(), which
cannot produce a two-word descriptor, so under FDPIC the resolved value
now goes through up_relocate() and the relocation type decides what to
write.

Implemented for armv7-m and armv8-m, the profiles FDPIC targets; the
other ARM variants gain the arch_data block but no new relocations.
Built and booted mps3-an547:picostest and lm3s6965-ek:qemu-nxflat, the
ELF PIC and NXFLAT users of this code, both unchanged.

Assisted-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
Signed-off-by: Marco Casaroli <marco.casaroli@gmail.com>
2026-09-13 16:03:32 -03:00

1254 lines
37 KiB
C
Raw Blame History

/****************************************************************************
* libs/libc/elf/elf_bind.c
*
* SPDX-License-Identifier: Apache-2.0
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <stdint.h>
#include <string.h>
#include <errno.h>
#include <assert.h>
#include <nuttx/debug.h>
#include <nuttx/arch.h>
#include <nuttx/cache.h>
#include <nuttx/elf.h>
#include <nuttx/symtab.h>
#include <nuttx/lib/elf.h>
#include "libc.h"
#include "elf/elf.h"
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#define I_REL 0 /* Index into relxxx[] arrays for relocations */
#define I_PLT 1 /* ... for PLTs */
#define N_RELS 2 /* Number of relxxx[] indexes */
#ifdef ARCH_ELFDATA
# define ARCH_ELFDATA_DEF arch_elfdata_t arch_data; \
memset(&arch_data, 0, sizeof(arch_elfdata_t))
# define ARCH_ELFDATA_PARM &arch_data
#else
# define ARCH_ELFDATA_DEF
# define ARCH_ELFDATA_PARM NULL
#endif
/* Move loader state in and out of the arch_data block, and say which
* relocation table is being walked. Nothing for an architecture whose
* relocations do not need any of it.
*/
#if defined(ARCH_ELFDATA) && defined(ARCH_ELFDATA_SET_PLTREL)
# define ARCH_ELFDATA_PLTREL(v) ARCH_ELFDATA_SET_PLTREL(&arch_data, v)
#else
# define ARCH_ELFDATA_PLTREL(v)
#endif
#if defined(ARCH_ELFDATA) && defined(ARCH_ELFDATA_INIT)
# define ARCH_ELFDATA_SETUP(l) ARCH_ELFDATA_INIT(&arch_data, l)
# define ARCH_ELFDATA_TEARDOWN(l) ARCH_ELFDATA_FINI(&arch_data, l)
#else
# define ARCH_ELFDATA_SETUP(l)
# define ARCH_ELFDATA_TEARDOWN(l)
#endif
/****************************************************************************
* Private Types
****************************************************************************/
/* REVISIT: This naming breaks the NuttX coding standard, but is consistent
* with legacy naming of other ELF types.
*/
typedef struct
{
dq_entry_t entry;
Elf_Sym sym;
int idx;
} Elf_SymCache;
struct
{
int stroff; /* offset to string table */
int symoff; /* offset to symbol table */
int lsymtab; /* size of symbol table */
int relentsz[2]; /* size of relocation entry */
int reloff[2]; /* offset to the relocation section */
int relsz[2]; /* size of relocation table */
int relrela[2]; /* type of relocation type - 0: DT_REL / 1: DT_RELA */
} reldata;
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: libelf_readrels
*
* Description:
* Read the (ELF_Rel structure * buffer count) into memory.
*
****************************************************************************/
static inline int libelf_readrels(FAR struct mod_loadinfo_s *loadinfo,
FAR const Elf_Shdr *relsec,
int index, FAR Elf_Rel *rels,
int count)
{
off_t offset;
int size;
/* Verify that the symbol table index lies within symbol table */
if (index < 0 || index > (relsec->sh_size / sizeof(Elf_Rel)))
{
berr("ERROR: Bad relocation symbol index: %d\n", index);
return -EINVAL;
}
/* Get the file offset to the symbol table entry */
offset = sizeof(Elf_Rel) * index;
size = sizeof(Elf_Rel) * count;
if (offset + size > relsec->sh_size)
{
size = relsec->sh_size - offset;
}
/* And, finally, read the symbol table entry into memory */
return libelf_read(loadinfo, (FAR uint8_t *)rels, size,
relsec->sh_offset + offset);
}
/****************************************************************************
* Name: libelf_readrelas
*
* Description:
* Read the (ELF_Rela structure * buffer count) into memory.
*
****************************************************************************/
static inline int libelf_readrelas(FAR struct mod_loadinfo_s *loadinfo,
FAR const Elf_Shdr *relsec,
int index, FAR Elf_Rela *relas,
int count)
{
off_t offset;
int size;
/* Verify that the symbol table index lies within symbol table */
if (index < 0 || index > (relsec->sh_size / sizeof(Elf_Rela)))
{
berr("ERROR: Bad relocation symbol index: %d\n", index);
return -EINVAL;
}
/* Get the file offset to the symbol table entry */
offset = sizeof(Elf_Rela) * index;
size = sizeof(Elf_Rela) * count;
if (offset + size > relsec->sh_size)
{
size = relsec->sh_size - offset;
}
/* And, finally, read the symbol table entry into memory */
return libelf_read(loadinfo, (FAR uint8_t *)relas, size,
relsec->sh_offset + offset);
}
/****************************************************************************
* Name: libelf_relocate and libelf_relocateadd
*
* Description:
* Perform all relocations associated with a section.
*
* Returned Value:
* 0 (OK) is returned on success and a negated errno is returned on
* failure.
*
****************************************************************************/
static int libelf_relocate(FAR struct module_s *modp,
FAR struct mod_loadinfo_s *loadinfo, int relidx,
FAR const struct symtab_s *exports, int nexports)
{
FAR Elf_Shdr *relsec = &loadinfo->shdr[relidx];
FAR Elf_Shdr *dstsec = &loadinfo->shdr[relsec->sh_info];
FAR Elf_Rel *rels;
FAR Elf_Rel *rel;
FAR Elf_SymCache *cache;
FAR Elf_Sym *sym;
FAR dq_entry_t *e;
dq_queue_t q;
uintptr_t addr;
int symidx;
int ret = OK;
int i;
int j;
/* Define potential architecture specific elf data container */
ARCH_ELFDATA_DEF;
rels = lib_malloc(CONFIG_LIBC_ELF_RELOCATION_BUFFERCOUNT *
sizeof(Elf_Rel));
if (!rels)
{
berr("Failed to allocate memory for elf relocation rels\n");
return -ENOMEM;
}
dq_init(&q);
/* Examine each relocation in the section. 'relsec' is the section
* containing the relations. 'dstsec' is the section containing the data
* to be relocated.
*/
for (i = j = 0; i < relsec->sh_size / sizeof(Elf_Rel); i++)
{
/* Read the relocation entry into memory */
rel = &rels[i % CONFIG_LIBC_ELF_RELOCATION_BUFFERCOUNT];
if (!(i % CONFIG_LIBC_ELF_RELOCATION_BUFFERCOUNT))
{
ret = libelf_readrels(loadinfo, relsec, i, rels,
CONFIG_LIBC_ELF_RELOCATION_BUFFERCOUNT);
if (ret < 0)
{
berr("ERROR: Section %d reloc %d: "
"Failed to read relocation entry: %d\n",
relidx, i, ret);
break;
}
}
/* Get the symbol table index for the relocation. This is contained
* in a bit-field within the r_info element.
*/
symidx = ELF_R_SYM(rel->r_info);
/* First try the cache */
sym = NULL;
for (e = dq_peek(&q); e; e = dq_next(e))
{
cache = (FAR Elf_SymCache *)e;
if (cache->idx == symidx)
{
dq_rem(&cache->entry, &q);
dq_addfirst(&cache->entry, &q);
sym = &cache->sym;
break;
}
}
/* If the symbol was not found in the cache, we will need to read the
* symbol from the file.
*/
if (sym == NULL)
{
if (j < CONFIG_LIBC_ELF_SYMBOL_CACHECOUNT)
{
cache = lib_malloc(sizeof(Elf_SymCache));
if (!cache)
{
berr("Failed to allocate memory for elf symbols\n");
ret = -ENOMEM;
break;
}
j++;
}
else
{
cache = (FAR Elf_SymCache *)dq_remlast(&q);
}
sym = &cache->sym;
/* Read the symbol table entry into memory */
ret = libelf_readsym(loadinfo, symidx, sym,
&loadinfo->shdr[loadinfo->symtabidx]);
if (ret < 0)
{
berr("ERROR: Section %d reloc %d: "
"Failed to read symbol[%d]: %d\n",
relidx, i, symidx, ret);
lib_free(cache);
break;
}
/* Get the value of the symbol (in sym.st_value) */
ret = libelf_symvalue(modp, loadinfo, sym,
loadinfo->shdr[loadinfo->strtabidx].sh_offset,
exports, nexports);
if (ret < 0)
{
/* The special error -ESRCH is returned only in one condition:
* The symbol has no name.
*
* There are a few relocations for a few architectures that do
* no depend upon a named symbol. We don't know if that is the
* case here, but we will use a NULL symbol pointer to indicate
* that case to up_relocate(). That function can then do what
* is best.
*/
if (ret == -ESRCH)
{
berr("ERROR: Section %d reloc %d: "
"Undefined symbol[%d] has no name: %d\n",
relidx, i, symidx, ret);
}
else
{
berr("ERROR: Section %d reloc %d: "
"Failed to get value of symbol[%d]: %d\n",
relidx, i, symidx, ret);
lib_free(cache);
break;
}
}
cache->idx = symidx;
dq_addfirst(&cache->entry, &q);
}
if (sym->st_shndx == SHN_UNDEF && sym->st_name == 0)
{
sym = NULL;
}
/* Calculate the relocation address. */
if (loadinfo->gotsize != 0)
{
if (sym->st_shndx == SHN_UNDEF)
{
/* Symbol type is undefined, we need to set the address
* to the value of the symbol.
*/
FAR uintptr_t *gotaddr = (FAR uintptr_t *)(loadinfo->gotbase +
*((FAR uintptr_t *)(dstsec->sh_addr + rel->r_offset)));
*gotaddr = sym->st_value;
continue;
}
if ((dstsec->sh_flags & SHF_WRITE) == 0)
{
/* Skip relocations for read-only sections */
continue;
}
/* Use the GOT to store the address */
if (rel->r_offset - dstsec->sh_offset >
dstsec->sh_size)
{
berr("ERROR: Section %d reloc %d: "
"Relocation address out of range, "
"offset %" PRIuPTR " size %ju\n",
relidx, i, (uintptr_t)rel->r_offset,
(uintmax_t)dstsec->sh_size);
ret = -EINVAL;
break;
}
addr = dstsec->sh_addr + rel->r_offset - dstsec->sh_offset;
if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
{
/* Symbol type is section, we need clear the address
* and keep the original value.
*/
*(FAR uintptr_t *)addr -=
loadinfo->shdr[sym->st_shndx].sh_offset;
}
else
{
/* Normal symbol, just keep it zero */
*(FAR uintptr_t *)addr = 0;
}
}
else
{
if (rel->r_offset > dstsec->sh_size)
{
berr("ERROR: Section %d reloc %d: "
"Relocation address out of range, "
"offset %" PRIuPTR " size %ju\n",
relidx, i, (uintptr_t)rel->r_offset,
(uintmax_t)dstsec->sh_size);
ret = -EINVAL;
break;
}
addr = dstsec->sh_addr + rel->r_offset;
}
/* Now perform the architecture-specific relocation */
ret = up_relocate(rel, sym, addr, ARCH_ELFDATA_PARM);
if (ret < 0)
{
berr("ERROR: Section %d reloc %d: Relocation failed: %d\n",
relidx, i, ret);
break;
}
}
lib_free(rels);
while ((e = dq_peek(&q)) != NULL)
{
dq_rem(e, &q);
lib_free(e);
}
return ret;
}
static int libelf_relocateadd(FAR struct module_s *modp,
FAR struct mod_loadinfo_s *loadinfo,
int relidx,
FAR const struct symtab_s *exports,
int nexports)
{
FAR Elf_Shdr *relsec = &loadinfo->shdr[relidx];
FAR Elf_Shdr *dstsec = &loadinfo->shdr[relsec->sh_info];
FAR Elf_Rela *relas;
FAR Elf_Rela *rela;
FAR Elf_SymCache *cache;
FAR Elf_Sym *sym;
FAR dq_entry_t *e;
dq_queue_t q;
uintptr_t addr;
int symidx;
int ret = OK;
int i;
int j;
/* Define potential architecture specific elf data container */
ARCH_ELFDATA_DEF;
relas = lib_malloc(CONFIG_LIBC_ELF_RELOCATION_BUFFERCOUNT *
sizeof(Elf_Rela));
if (!relas)
{
berr("Failed to allocate memory for elf relocation relas\n");
return -ENOMEM;
}
dq_init(&q);
/* Examine each relocation in the section. 'relsec' is the section
* containing the relations. 'dstsec' is the section containing the data
* to be relocated.
*/
for (i = j = 0; i < relsec->sh_size / sizeof(Elf_Rela); i++)
{
/* Read the relocation entry into memory */
rela = &relas[i % CONFIG_LIBC_ELF_RELOCATION_BUFFERCOUNT];
if (!(i % CONFIG_LIBC_ELF_RELOCATION_BUFFERCOUNT))
{
ret = libelf_readrelas(loadinfo, relsec, i, relas,
CONFIG_LIBC_ELF_RELOCATION_BUFFERCOUNT);
if (ret < 0)
{
berr("ERROR: Section %d reloc %d: "
"Failed to read relocation entry: %d\n",
relidx, i, ret);
break;
}
}
/* Get the symbol table index for the relocation. This is contained
* in a bit-field within the r_info element.
*/
symidx = ELF_R_SYM(rela->r_info);
/* First try the cache */
sym = NULL;
for (e = dq_peek(&q); e; e = dq_next(e))
{
cache = (FAR Elf_SymCache *)e;
if (cache->idx == symidx)
{
dq_rem(&cache->entry, &q);
dq_addfirst(&cache->entry, &q);
sym = &cache->sym;
break;
}
}
/* If the symbol was not found in the cache, we will need to read the
* symbol from the file.
*/
if (sym == NULL)
{
if (j < CONFIG_LIBC_ELF_SYMBOL_CACHECOUNT)
{
cache = lib_malloc(sizeof(Elf_SymCache));
if (!cache)
{
berr("Failed to allocate memory for elf symbols\n");
ret = -ENOMEM;
break;
}
j++;
}
else
{
cache = (FAR Elf_SymCache *)dq_remlast(&q);
}
sym = &cache->sym;
/* Read the symbol table entry into memory */
ret = libelf_readsym(loadinfo, symidx, sym,
&loadinfo->shdr[loadinfo->symtabidx]);
if (ret < 0)
{
berr("ERROR: Section %d reloc %d: "
"Failed to read symbol[%d]: %d\n",
relidx, i, symidx, ret);
lib_free(cache);
break;
}
/* Get the value of the symbol (in sym.st_value) */
ret = libelf_symvalue(modp, loadinfo, sym,
loadinfo->shdr[loadinfo->strtabidx].sh_offset,
exports, nexports);
if (ret < 0)
{
/* The special error -ESRCH is returned only in one condition:
* The symbol has no name.
*
* There are a few relocations for a few architectures that do
* no depend upon a named symbol. We don't know if that is the
* case here, but we will use a NULL symbol pointer to indicate
* that case to up_relocate(). That function can then do what
* is best.
*/
if (ret == -ESRCH)
{
berr("ERROR: Section %d reloc %d: "
"Undefined symbol[%d] has no name: %d\n",
relidx, i, symidx, ret);
}
else
{
berr("ERROR: Section %d reloc %d: "
"Failed to get value of symbol[%d]: %d\n",
relidx, i, symidx, ret);
lib_free(cache);
break;
}
}
cache->idx = symidx;
dq_addfirst(&cache->entry, &q);
}
if (sym->st_shndx == SHN_UNDEF && sym->st_name == 0)
{
sym = NULL;
}
/* Calculate the relocation address. */
if (rela->r_offset < 0 ||
rela->r_offset > dstsec->sh_size)
{
berr("ERROR: Section %d reloc %d: "
"Relocation address out of range, "
"offset %" PRIuPTR " size %ju\n",
relidx, i, (uintptr_t)rela->r_offset,
(uintmax_t)dstsec->sh_size);
ret = -EINVAL;
break;
}
addr = dstsec->sh_addr + rela->r_offset;
/* Now perform the architecture-specific relocation */
ret = up_relocateadd(rela, sym, addr, ARCH_ELFDATA_PARM);
if (ret < 0)
{
berr("ERROR: Section %d reloc %d: Relocation failed: %d\n",
relidx, i, ret);
break;
}
}
lib_free(relas);
while ((e = dq_peek(&q)) != NULL)
{
dq_rem(e, &q);
lib_free(e);
}
return ret;
}
/****************************************************************************
* Name: libelf_relocatedyn
*
* Description:
* Perform all relocations associated with a dynamic section.
*
* Returned Value:
* 0 (OK) is returned on success and a negated errno is returned on
* failure.
*
****************************************************************************/
static int libelf_relocatedyn(FAR struct module_s *modp,
FAR struct mod_loadinfo_s *loadinfo,
int relidx,
FAR const struct symtab_s *exports,
int nexports)
{
FAR Elf_Shdr *shdr = &loadinfo->shdr[relidx];
FAR Elf_Shdr *symhdr;
FAR Elf_Dyn *dyn = NULL;
FAR Elf_Rel *rels = NULL;
FAR Elf_Rel *rel;
FAR Elf_Rela *relas = NULL;
FAR Elf_Rela *rela;
FAR Elf_Sym *sym = NULL;
uintptr_t addr;
int ret;
int i;
int idx_rel;
int idx_sym;
/* Define potential architecture specific elf data container */
ARCH_ELFDATA_DEF;
dyn = lib_malloc(shdr->sh_size);
if (dyn == NULL)
{
berr("Failed to allocate memory for elf dynamic section\n");
return -ENOMEM;
}
ret = libelf_read(loadinfo, (FAR uint8_t *)dyn, shdr->sh_size,
shdr->sh_offset);
if (ret < 0)
{
berr("Failed to read dynamic section header");
lib_free(dyn);
return ret;
}
/* Assume DT_RELA to get maximum size required */
rels = lib_zalloc(CONFIG_LIBC_ELF_RELOCATION_BUFFERCOUNT *
sizeof(Elf_Rela));
if (!rels)
{
berr("Failed to allocate memory for elf relocation rels\n");
lib_free(dyn);
return -ENOMEM;
}
memset((FAR void *)&reldata, 0, sizeof(reldata));
relas = (FAR Elf_Rela *)rels;
for (i = 0; dyn[i].d_tag != DT_NULL; i++)
{
switch (dyn[i].d_tag)
{
case DT_REL:
reldata.reloff[I_REL] = dyn[i].d_un.d_val;
break;
case DT_RELSZ:
reldata.relsz[I_REL] = dyn[i].d_un.d_val;
break;
case DT_RELENT:
reldata.relentsz[I_REL] = dyn[i].d_un.d_val;
break;
case DT_SYMTAB:
reldata.symoff = dyn[i].d_un.d_val;
break;
case DT_STRTAB:
reldata.stroff = dyn[i].d_un.d_val;
break;
case DT_JMPREL:
reldata.reloff[I_PLT] = dyn[i].d_un.d_val;
break;
case DT_PLTRELSZ:
reldata.relsz[I_PLT] = dyn[i].d_un.d_val;
break;
case DT_PLTGOT:
/* The object's data base. Every function descriptor built
* for it names this base.
*/
loadinfo->gotbase = libelf_addr(loadinfo,
dyn[i].d_un.d_ptr);
break;
/* The constructor and destructor tables. Section headers are
* optional, so the dynamic tags are the authoritative copy.
*/
case DT_INIT_ARRAY:
loadinfo->initarr = libelf_addr(loadinfo, dyn[i].d_un.d_ptr);
break;
case DT_INIT_ARRAYSZ:
loadinfo->ninit = dyn[i].d_un.d_val / sizeof(uintptr_t);
break;
case DT_FINI_ARRAY:
loadinfo->finiarr = libelf_addr(loadinfo, dyn[i].d_un.d_ptr);
break;
case DT_FINI_ARRAYSZ:
loadinfo->nfini = dyn[i].d_un.d_val / sizeof(uintptr_t);
break;
case DT_PREINIT_ARRAY:
loadinfo->preiarr = libelf_addr(loadinfo, dyn[i].d_un.d_ptr);
break;
case DT_PREINIT_ARRAYSZ:
loadinfo->nprei = dyn[i].d_un.d_val / sizeof(uintptr_t);
break;
case DT_PLTREL:
if (dyn[i].d_un.d_val == DT_REL)
{
reldata.relentsz[I_PLT] = sizeof(Elf_Rel);
reldata.relrela[I_PLT] = 0;
}
else if (loadinfo->fdpic)
{
/* The ARM FDPIC ABI is REL throughout. RELA entries are
* longer, so walking them as REL reads the wrong place.
*/
berr("ERROR: FDPIC object claims RELA PLT relocations\n");
lib_free(sym);
lib_free(rels);
lib_free(dyn);
return -ENOEXEC;
}
else
{
reldata.relentsz[I_PLT] = sizeof(Elf_Rela);
reldata.relrela[I_PLT] = 1;
}
break;
}
}
/* After the loop, because DT_PLTGOT is read there. Both relocation
* tables are walked under this one arch_data, so the pool cursor
* survives from one to the next.
*/
ARCH_ELFDATA_SETUP(loadinfo);
symhdr = &loadinfo->shdr[loadinfo->dsymtabidx];
sym = lib_malloc(symhdr->sh_size);
if (!sym)
{
berr("Error obtaining storage for dynamic symbol table");
lib_free(rels);
lib_free(dyn);
return -ENOMEM;
}
ret = libelf_read(loadinfo, (FAR uint8_t *)sym, symhdr->sh_size,
symhdr->sh_offset);
if (ret < 0)
{
berr("Error reading dynamic symbol table - %d", ret);
lib_free(sym);
lib_free(rels);
lib_free(dyn);
return ret;
}
reldata.lsymtab = reldata.stroff - reldata.symoff;
for (idx_rel = 0; idx_rel < N_RELS; idx_rel++)
{
int lrelent;
if ((reldata.relsz[idx_rel] == 0) || (reldata.reloff[idx_rel] == 0))
{
continue;
}
/* Examine each relocation in the .rel.* section. */
ret = OK;
lrelent = reldata.relsz[idx_rel] / reldata.relentsz[idx_rel];
/* Say which table this is, for an architecture that cares. */
ARCH_ELFDATA_PLTREL(idx_rel == I_PLT);
for (i = 0; i < lrelent; i++)
{
/* Process each relocation entry
* - we cheat by using the fact the 1st two fields of Elf_Rel
* and Elf_Rela are identical so can do things based on the
* former until it's important
*/
if (reldata.relrela[idx_rel] == 0)
{
rel = &rels[i % CONFIG_LIBC_ELF_RELOCATION_BUFFERCOUNT];
rela = (Elf_Rela *)rel; /* Just to keep the compiler happy */
}
else
{
rela = &relas[i % CONFIG_LIBC_ELF_RELOCATION_BUFFERCOUNT];
rel = (Elf_Rel *)rela;
}
if (!(i % CONFIG_LIBC_ELF_RELOCATION_BUFFERCOUNT))
{
size_t relsize = (sizeof(Elf_Rela) *
CONFIG_LIBC_ELF_RELOCATION_BUFFERCOUNT);
if (reldata.relsz[idx_rel] < relsize)
{
relsize = reldata.relsz[idx_rel];
}
ret = libelf_read(loadinfo, (FAR uint8_t *)rels,
relsize,
reldata.reloff[idx_rel] +
i * sizeof(Elf_Rel));
if (ret < 0)
{
berr("ERROR: Section %d reloc %d:"
"Failed to read relocation entry: %d\n",
relidx, i, ret);
break;
}
}
/* Now perform the architecture-specific relocation */
if ((idx_sym = ELF_R_SYM(rel->r_info)) != 0)
{
/* We have an external reference */
if (sym[idx_sym].st_shndx == SHN_UNDEF)
{
FAR void *ep;
ep = libelf_findglobal(modp, loadinfo, symhdr,
&sym[idx_sym]);
/* libelf_findglobal() searches only the registered
* symbols. A module from exec() has its own export
* table, and an FDPIC module imports its libc there.
*/
if (ep == NULL && exports != NULL)
{
FAR const struct symtab_s *sm;
sm = symtab_findbyname(exports,
(FAR char *)
loadinfo->iobuffer,
nexports);
if (sm != NULL)
{
ep = (FAR void *)sm->sym_value;
}
}
if ((ep == NULL) && (ELF_ST_BIND(sym[idx_sym].st_info)
!= STB_WEAK))
{
berr("ERROR: Unable to resolve addr of ext ref %s\n",
loadinfo->iobuffer);
ret = -EINVAL;
lib_free(sym);
lib_free(rels);
lib_free(dyn);
return ret;
}
addr = libelf_addr(loadinfo, rel->r_offset);
if (reldata.relrela[idx_rel] == 1)
{
addr += rela->r_addend;
}
/* An import may be a descriptor under FDPIC, which is
* built rather than assigned, so the relocation type
* decides what to write. Everything else stores the
* resolved address, which R_ARM_JUMP_SLOT and
* R_ARM_GLOB_DAT do, so one path serves both.
*/
Elf_Sym extsym =
{
0
};
extsym.st_value = (uintptr_t)ep;
ret = up_relocate(rel, &extsym, addr, ARCH_ELFDATA_PARM);
if (ret < 0)
{
berr("ERROR: Section %d reloc %d: "
"Relocation failed: %d\n", relidx, i, ret);
lib_free(sym);
lib_free(rels);
lib_free(dyn);
return ret;
}
}
else if (loadinfo->fdpic)
{
/* A relocation naming a symbol inside this object. A
* pointer to a static function is emitted against the
* section symbol, so the offset, Thumb bit included, is
* the addend and must not come from the patched word.
*/
Elf_Sym defsym = sym[idx_sym];
defsym.st_value = libelf_addr(loadinfo,
sym[idx_sym].st_value);
addr = libelf_addr(loadinfo, rel->r_offset);
if (reldata.relrela[idx_rel] == 1)
{
addr += rela->r_addend;
}
ret = up_relocate(rel, &defsym, addr, ARCH_ELFDATA_PARM);
if (ret < 0)
{
berr("ERROR: Section %d reloc %d: "
"Relocation failed: %d\n", relidx, i, ret);
lib_free(sym);
lib_free(rels);
lib_free(dyn);
return ret;
}
}
}
else
{
Elf_Sym dynsym =
{
0
};
addr = libelf_addr(loadinfo, rel->r_offset);
if (reldata.relrela[idx_rel] == 1)
{
addr += rela->r_addend;
}
dynsym.st_value = libelf_addr(loadinfo,
*(FAR uint32_t *)addr);
ret = up_relocate(rel, &dynsym, addr, ARCH_ELFDATA_PARM);
}
if (ret < 0)
{
berr("ERROR: Section %d reloc %d: Relocation failed: %d\n",
relidx, i, ret);
lib_free(sym);
lib_free(rels);
lib_free(dyn);
return ret;
}
}
}
/* Hand back what the relocations consumed. The error paths above do
* not bother: the load is being abandoned, so the cursor has no reader.
*/
ARCH_ELFDATA_TEARDOWN(loadinfo);
lib_free(sym);
lib_free(rels);
lib_free(dyn);
return ret;
}
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: libelf_bind
*
* Description:
* Bind the imported symbol names in the loaded module described by
* 'loadinfo' using the exported symbol values provided by
* libelf_setsymtab().
*
* Input Parameters:
* modp - Module state information
* loadinfo - Load state information
* exports - The table of exported symbols
* nexports - The number of symbols in the exports table
*
* Returned Value:
* 0 (OK) is returned on success and a negated errno is returned on
* failure.
*
****************************************************************************/
int libelf_bind(FAR struct module_s *modp,
FAR struct mod_loadinfo_s *loadinfo,
FAR const struct symtab_s *exports, int nexports)
{
int ret;
int i;
#ifdef CONFIG_ARCH_ADDRENV
/* If CONFIG_ARCH_ADDRENV=y, then the loaded ELF lies in a virtual address
* space that may not be in place now. libelf_addrenv_select() will
* temporarily instantiate that address space.
*/
if (loadinfo->addrenv != NULL)
{
ret = libelf_addrenv_select(loadinfo);
if (ret < 0)
{
berr("ERROR: libelf_addrenv_select() failed: %d\n", ret);
return ret;
}
}
#endif
/* Find the symbol and string tables */
ret = libelf_findsymtab(loadinfo);
if (ret < 0)
{
goto errout_with_addrenv;
}
/* Process relocations in every allocated section */
for (i = 1; i < loadinfo->ehdr.e_shnum; i++)
{
/* Get the index to the relocation section */
int infosec = loadinfo->shdr[i].sh_info;
if (infosec >= loadinfo->ehdr.e_shnum)
{
continue;
}
if (loadinfo->ehdr.e_type == ET_DYN)
{
modp->dynamic = 1;
switch (loadinfo->shdr[i].sh_type)
{
case SHT_DYNAMIC:
ret = libelf_relocatedyn(modp, loadinfo, i,
exports, nexports);
break;
case SHT_DYNSYM:
loadinfo->dsymtabidx = i;
break;
case SHT_INIT_ARRAY:
loadinfo->initarr = libelf_addr(loadinfo,
loadinfo->shdr[i].sh_addr);
loadinfo->ninit = loadinfo->shdr[i].sh_size /
sizeof(uintptr_t);
break;
case SHT_FINI_ARRAY:
loadinfo->finiarr = libelf_addr(loadinfo,
loadinfo->shdr[i].sh_addr);
loadinfo->nfini = loadinfo->shdr[i].sh_size /
sizeof(uintptr_t);
break;
case SHT_PREINIT_ARRAY:
loadinfo->preiarr = libelf_addr(loadinfo,
loadinfo->shdr[i].sh_addr);
loadinfo->nprei = loadinfo->shdr[i].sh_size /
sizeof(uintptr_t);
break;
}
if (ret < 0)
{
goto errout_with_addrenv;
}
}
else
{
modp->dynamic = 0;
/* Make sure that the section is allocated. We can't
* relocate sections that were not loaded into memory.
*/
if ((loadinfo->shdr[i].sh_flags & SHF_ALLOC) == 0 &&
(loadinfo->shdr[i].sh_flags & SHF_INFO_LINK) == 0)
{
continue;
}
/* Process the relocations by type */
switch (loadinfo->shdr[i].sh_type)
{
case SHT_REL:
if ((loadinfo->shdr[infosec].sh_flags & SHF_ALLOC) == 0)
{
continue;
}
ret = libelf_relocate(modp, loadinfo, i, exports, nexports);
break;
case SHT_RELA:
if ((loadinfo->shdr[infosec].sh_flags & SHF_ALLOC) == 0)
{
continue;
}
ret = libelf_relocateadd(modp, loadinfo, i, exports,
nexports);
break;
case SHT_INIT_ARRAY:
loadinfo->initarr = loadinfo->shdr[i].sh_addr;
loadinfo->ninit = loadinfo->shdr[i].sh_size /
sizeof(uintptr_t);
break;
case SHT_FINI_ARRAY:
loadinfo->finiarr = loadinfo->shdr[i].sh_addr;
loadinfo->nfini = loadinfo->shdr[i].sh_size /
sizeof(uintptr_t);
break;
}
}
if (ret < 0)
{
goto errout_with_addrenv;
}
}
modp->xipbase = loadinfo->xipbase;
/* Ensure that the I and D caches are coherent before starting the newly
* loaded module by cleaning the D cache (i.e., flushing the D cache
* contents to memory and invalidating the I cache).
*/
if (loadinfo->textsize > 0)
{
up_coherent_dcache(loadinfo->textalloc, loadinfo->textsize);
}
if (loadinfo->datasize > 0)
{
up_coherent_dcache(loadinfo->datastart, loadinfo->datasize);
}
#ifdef CONFIG_ARCH_USE_SEPARATED_SECTION
for (i = 0; loadinfo->ehdr.e_type == ET_REL && i < loadinfo->ehdr.e_shnum;
i++)
{
if (loadinfo->sectalloc[i] == 0)
{
continue;
}
up_coherent_dcache(loadinfo->sectalloc[i], loadinfo->shdr[i].sh_size);
}
#endif
errout_with_addrenv:
#ifdef CONFIG_ARCH_ADDRENV
if (loadinfo->addrenv != NULL)
{
int status = libelf_addrenv_restore(loadinfo);
if (status < 0)
{
berr("ERROR: libelf_addrenv_restore() failed: %d\n", status);
if (ret == OK)
{
ret = status;
}
}
}
#endif
return ret;
}
Reference in a new issue View git blame Copy permalink