#include <stdio.h>
#include <common.h>
#include <debug.h>
#include <hash.h>
#include <libelf.h>
#include <libebl.h>
#include <libebl_arm.h>
#include <elf.h>
#include <gelf.h>
#include <string.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#ifdef DEBUG
#include <rangesort.h>
#endif
/* static void print_shdr_array(shdr_info_t *, int); */
#include <elfcopy.h>
#define COPY_SECTION_DATA_BUFFER (0)
/* When this macro is set to a nonzero value, we replace calls to elf_strptr()
on the target ELF handle with code that extracts the strings directly from
the data buffers of that ELF handle. In this case, elf_strptr() does not
work as expected, as it tries to read the data buffer of the associated
string section directly from the file, and that buffer does not exist yet
in the file, since we haven't committed our changes yet.
*/
#define ELF_STRPTR_IS_BROKEN (1)
static void update_relocations_section_symbol_references(Elf *newelf, Elf *elf,
shdr_info_t *info, int info_len,
shdr_info_t *relsect_info,
Elf32_Word *newsymidx);
static void update_relocations_section_offsets(Elf *newelf, Elf *elf, Ebl *ebl,
shdr_info_t *info,
int info_len,
shdr_info_t *relsect_info,
Elf_Data *data,
range_list_t *old_section_ranges);
static void update_hash_table(Elf *newelf, Elf *elf,
Elf32_Word hash_scn_idx,
shdr_info_t *symtab_info);
static inline
Elf_Data *create_section_data(shdr_info_t *, Elf_Scn *);
static Elf64_Off section_to_header_mapping(Elf *elf,
int phdr_idx,
shdr_info_t *shdr_info,
int num_shdr_info,
Elf64_Off *file_end,
Elf64_Off *mem_end);
static void build_dynamic_segment_strings(Elf *elf, Ebl *oldebl,
int dynidx, /* index of .dynamic section */
int symtabidx, /* index of symbol table section */
shdr_info_t *shdr_info,
int shdr_info_len);
#ifdef DEBUG
static void print_dynamic_segment_strings(Elf *elf, Ebl *oldebl,
int dynidx, /* index of .dynamic section */
int symtabidx, /* index of symbol table section */
shdr_info_t *shdr_info,
int shdr_info_len);
#endif
static void adjust_dynamic_segment_offsets(Elf *elf, Ebl *oldebl,
Elf *newelf,
int idx, /* index of .dynamic section */
shdr_info_t *shdr_info,
int shdr_info_len);
static void update_symbol_values(Elf *elf, GElf_Ehdr *ehdr,
Elf *newelf,
shdr_info_t *shdr_info,
int num_shdr_info,
int shady,
int dynamic_idx);
static bool section_belongs_to_header(GElf_Shdr *shdr, GElf_Phdr *phdr);
static range_list_t *
update_section_offsets(Elf *elf,
Elf *newelf,
GElf_Phdr *phdr_info,
shdr_info_t *shdr_info,
int num_shdr_info,
range_list_t *section_ranges,
bool adjust_alloc_section_offsets);
void handle_range_error(range_error_t err, range_t *left, range_t *right);
#ifdef DEBUG
static void
verify_elf(GElf_Ehdr *ehdr, struct shdr_info_t *shdr_info, int shdr_info_len,
GElf_Phdr *phdr_info);
#endif
void adjust_elf(Elf *elf, const char *elf_name,
Elf *newelf, const char *newelf_name __attribute__((unused)),
Ebl *ebl,
GElf_Ehdr *ehdr, /* store ELF header of original library */
bool *sym_filter, int num_symbols,
struct shdr_info_t *shdr_info, int shdr_info_len,
GElf_Phdr *phdr_info,
size_t highest_scn_num,
size_t shnum,
size_t shstrndx,
struct Ebl_Strtab *shst,
bool sections_dropped_or_rearranged,
int dynamic_idx, /* index in shdr_info[] of .dynamic section */
int dynsym_idx, /* index in shdr_info[] of dynamic symbol table */
int shady,
Elf_Data **shstrtab_data,
bool adjust_alloc_section_offsets,
bool rebuild_shstrtab)
{
int cnt; /* general-purpose counter */
Elf_Scn *scn; /* general-purpose section */
*shstrtab_data = NULL;
/* When this flag is true, we have dropped some symbols, which caused
a change in the order of symbols in the symbol table (all symbols after
the removed symbol have shifted forward), and a change in its size as
well. When the symbol table changes this way, we need to modify the
relocation entries that relocate symbols in this symbol table, and we
also need to rebuild the hash table (the hash is outdated).
Note that it is possible to change the symbols in the symbol table
without changing their position (that is, without cutting any symbols
out). If a section that a symbol refers to changes (i.e., moves), we
need to update that section's index in the symbol entry in the symbol
table. Therefore, there are symbol-table changes that can be made and
still have symtab_size_changed == false!
*/
bool symtab_size_changed = false;
/* We allow adjusting of offsets only for files that are shared libraries.
We cannot mess with the relative positions of sections for executable
files, because we do not have enough information to adjust them. The
text section is already linked to fixed addresses.
*/
ASSERT(!adjust_alloc_section_offsets || ehdr->e_type == ET_DYN);
if (!sections_dropped_or_rearranged)
INFO("Note: we aren't dropping or rearranging any sections.\n");
/* Index of the section header table in the shdr_info array. This is
an important variable because it denotes the last section of the old
file, as well as the location of the section-strings section of the
new one.
Note: we use this variable only when we are re-creating the section-
header-strings table. Otherwise, we keep it as zero.
*/
size_t shdridx = shstrndx;
if (rebuild_shstrtab) {
INFO("Creating new section-strings section...\n");
shdridx = shnum;
/* Create the new section-name-strings section */
{
INFO("\tNew index will be %d (was %d).\n", highest_scn_num, shstrndx);
/* Add the section header string table section name. */
shdr_info[shdridx] = shdr_info[shstrndx];
ASSERT(!strcmp(shdr_info[shdridx].name, ".shstrtab"));
shdr_info[shdridx].se = ebl_strtabadd (shst, ".shstrtab", 10);
ASSERT(shdr_info[shdridx].se != NULL);
shdr_info[shdridx].idx = highest_scn_num;
/* Create the section header. */
shdr_info[shdridx].shdr.sh_type = SHT_STRTAB;
shdr_info[shdridx].shdr.sh_flags = 0;
shdr_info[shdridx].shdr.sh_addr = 0;
shdr_info[shdridx].shdr.sh_link = SHN_UNDEF;
shdr_info[shdridx].shdr.sh_info = SHN_UNDEF;
shdr_info[shdridx].shdr.sh_entsize = 0;
shdr_info[shdridx].shdr.sh_offset = shdr_info[shdridx].old_shdr.sh_offset;
shdr_info[shdridx].shdr.sh_addralign = 1;
/* Create the section. */
FAILIF_LIBELF((shdr_info[shdridx].newscn = elf_newscn(newelf)) == NULL,
elf_newscn);
ASSERT(elf_ndxscn (shdr_info[shdridx].newscn) == highest_scn_num);
{
/* Finalize the string table and fill in the correct indices in
the section headers. */
FAILIF_LIBELF((*shstrtab_data =
elf_newdata (shdr_info[shdridx].newscn)) == NULL,
elf_newdata);
ebl_strtabfinalize (shst, *shstrtab_data);
/* We have to set the section size. */
INFO("\tNew size will be %d.\n", (*shstrtab_data)->d_size);
shdr_info[shdridx].shdr.sh_size = (*shstrtab_data)->d_size;
/* Setting the data pointer tells the update loop below not to
copy the information from the original section. */
shdr_info[shdridx].data = *shstrtab_data;
#if COPY_SECTION_DATA_BUFFER
shdr_info[shdridx].data->d_buf = MALLOC(shdr_info[shdridx].data->d_size);
ASSERT((*shstrtab_data)->d_buf);
memcpy(shdr_info[shdridx].data->d_buf, (*shstrtab_data)->d_buf, (*shstrtab_data)->d_size);
#endif
}
}
} /* if (rebuild_shstrtab) */
else {
/* When we are not rebuilding shstrtab, we expect the input parameter
shstrndx to be the index of .shstrtab BOTH in shdr_info[] and in
as a section index in the ELF file.
*/
ASSERT(!strcmp(shdr_info[shdridx].name, ".shstrtab"));
}
INFO("Updating section information...\n");
/* Update the section information. */
#ifdef DEBUG
/* We use this flag to ASSERT that the symbol tables comes
before the .dynamic section in the file. See comments
further below.
*/
bool visited_dynsym = false;
#endif
for (cnt = 1; cnt < shdr_info_len; ++cnt) {
if (shdr_info[cnt].idx > 0) {
Elf_Data *newdata;
INFO("\t%03d: Updating section %s (index %d, address %lld offset %lld, size %lld, alignment %d)...\n",
cnt,
(shdr_info[cnt].name ?: "(no name)"),
shdr_info[cnt].idx,
shdr_info[cnt].shdr.sh_addr,
shdr_info[cnt].shdr.sh_offset,
shdr_info[cnt].shdr.sh_size,
shdr_info[cnt].shdr.sh_addralign);
scn = shdr_info[cnt].newscn;
ASSERT(scn != NULL);
ASSERT(scn == elf_getscn(newelf, shdr_info[cnt].idx));
/* Update the name. */
if (rebuild_shstrtab) {
Elf64_Word new_sh_name = ebl_strtaboffset(shdr_info[cnt].se);
INFO("\t\tname offset %d (was %d).\n",
new_sh_name,
shdr_info[cnt].shdr.sh_name);
shdr_info[cnt].shdr.sh_name = new_sh_name;
}
/* Update the section header from the input file. Some fields
might be section indices which now have to be adjusted. */
if (shdr_info[cnt].shdr.sh_link != 0) {
INFO("\t\tsh_link %d (was %d).\n",
shdr_info[shdr_info[cnt].shdr.sh_link].idx,
shdr_info[cnt].shdr.sh_link);
shdr_info[cnt].shdr.sh_link =
shdr_info[shdr_info[cnt].shdr.sh_link].idx;
}
/* Handle the SHT_REL, SHT_RELA, and SHF_INFO_LINK flag. */
if (SH_INFO_LINK_P (&shdr_info[cnt].shdr)) {
INFO("\t\tsh_info %d (was %d).\n",
shdr_info[shdr_info[cnt].shdr.sh_info].idx,
shdr_info[cnt].shdr.sh_info);
shdr_info[cnt].shdr.sh_info =
shdr_info[shdr_info[cnt].shdr.sh_info].idx;
}
/* Get the data from the old file if necessary. We already
created the data for the section header string table, which
has a section number equal to shnum--hence the ASSERT().
*/
ASSERT(!rebuild_shstrtab || shdr_info[cnt].data || cnt < shnum);
newdata = create_section_data(shdr_info + cnt, scn);
/* We know the size. */
shdr_info[cnt].shdr.sh_size = shdr_info[cnt].data->d_size;
/* We have to adjust symbol tables. Each symbol contains
a reference to the section it belongs to. Since we have
renumbered the sections (and dropped some), we need to adjust
the symbols' section indices as well. Also, if we do not want
to keep a symbol, we drop it from the symbol table in this loop.
When we drop symbols from the dynamic-symbol table, we need to
remove the names of the sybmols from the dynamic-symbol-strings
table. Changing the dynamic-symbol-strings table means that we
also have to rebuild the strings that go into the .dynamic
section (such as the DT_NEEDED strings, which lists the libraries
that the file depends on), since those strings are kept in the
same dynamic-symbol-strings table. That latter statement
is an assumption (which we ASSERT against, read on below).
Note: we process the symbol-table sections only when the user
specifies a symbol filter AND that leads to a change in the
symbol table, or when section indices change.
*/
/* The .dynamic section's strings need not be contained in the
same section as the strings of the dynamic symbol table,
but we assume that they are (I haven't seen it be otherwise).
We assert the validity of our assumption here.
If this assertion fails, then we *may* need to reorganize
this code as follows: we will need to call function
build_dynamic_segment_strings() even when sections numbers
don't change and there is no filter. Also, if string section
containing the .dynamic section strings changes, then we'd
need to update the sh_link of the .dynamic section to point
to the new section.
*/
ASSERT(shdr_info[dynamic_idx].shdr.sh_link ==
shdr_info[dynsym_idx].shdr.sh_link);
if (sections_dropped_or_rearranged || (sym_filter != NULL))
{
if(shdr_info[cnt].shdr.sh_type == SHT_DYNSYM)
{
INFO("\t\tupdating a symbol table.\n");
/* Calculate the size of the external representation of a
symbol. */
size_t elsize = gelf_fsize (elf, ELF_T_SYM, 1, ehdr->e_version);
/* Check the length of the dynamic-symbol filter. (This is the
second of two identical checks, the first one being in
the loop that checks for exceptions.)
NOTE: We narrow this assertion down to the dynamic-symbol
table only. Since we expect the symbol filter to
be parallel to .dynsym, and .dynsym in general
contains fewer symbols than .strtab, we cannot
make this assertion for .strtab.
*/
FAILIF(sym_filter != NULL &&
num_symbols != shdr_info[cnt].data->d_size / elsize,
"Length of dynsym filter (%d) must equal the number"
" of dynamic symbols (%d) in section [%s]!\n",
num_symbols,
shdr_info[cnt].data->d_size / elsize,
shdr_info[cnt].name);
shdr_info[cnt].symse =
(struct Ebl_Strent **)MALLOC(
(shdr_info[cnt].data->d_size/elsize) *
sizeof(struct Ebl_Strent *));
shdr_info[cnt].dynsymst = ebl_strtabinit(1);
FAILIF_LIBELF(NULL == shdr_info[cnt].dynsymst, ebl_strtabinit);
/* Allocate an array of Elf32_Word, one for each symbol. This
array will hold the new symbol indices.
*/
shdr_info[cnt].newsymidx =
(Elf32_Word *)CALLOC(shdr_info[cnt].data->d_size / elsize,
sizeof (Elf32_Word));
bool last_was_local = true;
size_t destidx, // index of the symbol in the new symbol table
inner, // index of the symbol in the old table
last_local_idx = 0;
int num_kept_undefined_and_special = 0;
int num_kept_global_or_weak = 0;
int num_thrown_away = 0;
unsigned long num_symbols = shdr_info[cnt].data->d_size / elsize;
INFO("\t\tsymbol table has %ld symbols.\n", num_symbols);
/* In the loop below, determine whether to remove or not each
symbol.
*/
for (destidx = inner = 1; inner < num_symbols; ++inner)
{
Elf32_Word sec; /* index of section a symbol refers to */
Elf32_Word xshndx; /* extended-section index of symbol */
/* Retrieve symbol information and separate section index
from the symbol table at the given index. */
GElf_Sym sym_mem; /* holds the symbol */
/* Retrieve symbol information and separate section index
from the symbol table at the given index. */
GElf_Sym *sym = gelf_getsymshndx (shdr_info[cnt].data,
NULL, inner,
&sym_mem, &xshndx);
ASSERT(sym != NULL);
FAILIF(sym->st_shndx == SHN_XINDEX,
"Can't handle symbol's st_shndx == SHN_XINDEX!\n");
/* Do not automatically strip the symbol if:
-- the symbol filter is NULL or
-- the symbol is marked to keep or
-- the symbol is neither of:
-- imported or refers to a nonstandard section
-- global
-- weak
We do not want to strip imported symbols, because then
we won't be able to link against them. We do not want
to strip global or weak symbols, because then someone
else will fail to link against them. Finally, we do
not want to strip nonstandard symbols, because we're
not sure what they are doing there.
*/
char *symname = elf_strptr(elf,
shdr_info[cnt].old_shdr.sh_link,
sym->st_name);
if (NULL == sym_filter || /* no symfilter */
sym_filter[inner] || /* keep the symbol! */
/* don't keep the symbol, but the symbol is undefined
or refers to a specific section */
sym->st_shndx == SHN_UNDEF || sym->st_shndx >= shnum ||
/* don't keep the symbol, which defined and refers to
a normal section, but the symbol is neither global
nor weak. */
(ELF32_ST_BIND(sym->st_info) != STB_GLOBAL &&
ELF32_ST_BIND(sym->st_info) != STB_WEAK))
{
/* Do not remove the symbol. */
if (sym->st_shndx == SHN_UNDEF ||
sym->st_shndx >= shnum)
{
/* This symbol has no section index (it is
absolute). Leave the symbol alone unless it is
moved. */
FAILIF_LIBELF(!(destidx == inner ||
gelf_update_symshndx(
shdr_info[cnt].data,
NULL,
destidx,
sym,
xshndx)),
gelf_update_symshndx);
shdr_info[cnt].newsymidx[inner] = destidx;
INFO("\t\t\tkeeping %s symbol %d (new index %d), name [%s]\n",
(sym->st_shndx == SHN_UNDEF ? "undefined" : "special"),
inner,
destidx,
symname);
/* mark the symbol as kept */
if (sym_filter) sym_filter[inner] = 1;
shdr_info[cnt].symse[destidx] =
ebl_strtabadd (shdr_info[cnt].dynsymst,
symname, 0);
ASSERT(shdr_info[cnt].symse[destidx] != NULL);
num_kept_undefined_and_special++;
if (GELF_ST_BIND(sym->st_info) == STB_LOCAL)
last_local_idx = destidx;
destidx++;
} else {
/* Get the full section index. */
sec = shdr_info[sym->st_shndx].idx;
if (sec) {
Elf32_Word nxshndx;
ASSERT (sec < SHN_LORESERVE);
nxshndx = 0;
/* Update the symbol only if something changed,
that is, if either the symbol's position in
the symbol table changed (because we deleted
some symbols), or because its section moved!
NOTE: We don't update the symbol's section
index, sym->st_shndx here, but in function
update_symbol_values() instead. The reason
is that if we update the symbol-section index,
now, it won't refer anymore to the shdr_info[]
entry, which we will need in
update_symbol_values().
*/
if (inner != destidx)
{
FAILIF_LIBELF(0 ==
gelf_update_symshndx(
shdr_info[cnt].data,
NULL,
destidx, sym,
nxshndx),
gelf_update_symshndx);
}
shdr_info[cnt].newsymidx[inner] = destidx;
/* If we are not filtering out some symbols,
there's no point to printing this message
for every single symbol. */
if (sym_filter) {
INFO("\t\t\tkeeping symbol %d (new index %d), name (index %d) [%s]\n",
inner,
destidx,
sym->st_name,
symname);
/* mark the symbol as kept */
sym_filter[inner] = 1;
}
shdr_info[cnt].symse[destidx] =
ebl_strtabadd(shdr_info[cnt].dynsymst,
symname, 0);
ASSERT(shdr_info[cnt].symse[destidx] != NULL);
num_kept_global_or_weak++;
if (GELF_ST_BIND(sym->st_info) == STB_LOCAL)
last_local_idx = destidx;
destidx++;
} else {
/* I am not sure, there might be other types of
symbols that do not refer to any section, but
I will handle them case by case when this
assertion fails--I want to know if each of them
is safe to remove!
*/
ASSERT(GELF_ST_TYPE (sym->st_info) == STT_SECTION ||
GELF_ST_TYPE (sym->st_info) == STT_NOTYPE);
INFO("\t\t\tignoring %s symbol [%s]"
" at index %d refering to section %d\n",
(GELF_ST_TYPE(sym->st_info) == STT_SECTION
? "STT_SECTION" : "STT_NOTYPE"),
symname,
inner,
sym->st_shndx);
num_thrown_away++;
/* mark the symbol as thrown away */
if (sym_filter) sym_filter[inner] = 0;
}
}
} /* to strip or not to strip? */
else {
INFO("\t\t\tremoving symbol [%s]\n", symname);
shdr_info[cnt].newsymidx[inner] = (Elf32_Word)-1;
num_thrown_away++;
/* mark the symbol as thrown away */
if (sym_filter) sym_filter[inner] = 0;
}
/* For symbol-table sections, sh_info is one greater than the
symbol table index of the last local symbol. This is why,
when we find the last local symbol, we update the sh_info
field.
*/
if (last_was_local) {
if (GELF_ST_BIND (sym->st_info) != STB_LOCAL) {
last_was_local = false;
if (last_local_idx) {
INFO("\t\t\tMARKING ONE PAST LAST LOCAL INDEX %d\n",
last_local_idx + 1);
shdr_info[cnt].shdr.sh_info =
last_local_idx + 1;
}
else shdr_info[cnt].shdr.sh_info = 0;
}
} else FAILIF(0 && GELF_ST_BIND (sym->st_info) == STB_LOCAL,
"Internal error in ELF file: symbol table has"
" local symbols after first global"
" symbol!\n");
} /* for each symbol */
INFO("\t\t%d undefined or special symbols were kept.\n",
num_kept_undefined_and_special);
INFO("\t\t%d global or weak symbols were kept.\n",
num_kept_global_or_weak);
INFO("\t\t%d symbols were thrown away.\n",
num_thrown_away);
if (destidx != inner) {
/* The symbol table changed. */
INFO("\t\t\tthe symbol table has changed.\n");
INFO("\t\t\tdestidx = %d, inner = %d.\n", destidx, inner);
INFO("\t\t\tnew size %d (was %lld).\n",
destidx * elsize,
shdr_info[cnt].shdr.sh_size);
shdr_info[cnt].shdr.sh_size = newdata->d_size = destidx * elsize;
symtab_size_changed = true;
} else {
/* The symbol table didn't really change. */
INFO("\t\t\tthe symbol table did not change.\n");
FREE (shdr_info[cnt].newsymidx);
shdr_info[cnt].newsymidx = NULL;
}
#ifdef DEBUG
visited_dynsym = shdr_info[cnt].shdr.sh_type == SHT_DYNSYM;
#endif
} /* if it's a symbol table... */
else if (shdr_info[cnt].shdr.sh_type == SHT_DYNAMIC) {
/* We get here either when we drop some sections, or
when we are dropping symbols. If we are not dropping
symbols, then the dynamic-symbol-table and its strings
section won't change, so we won't need to rebuild the
symbols for the SHT_DYNAMIC section either.
NOTE: If ever in the future we add the ability in
adjust_elf() to change the strings in the SHT_DYNAMIC
section, then we would need to find a way to rebuild
the dynamic-symbol-table-strings section.
*/
/* symtab_size_changed has a meaningful value only after
we've processed the symbol table. If this assertion
is ever violated, it will be because the .dynamic section
came before the symbol table in the list of section in
a file. If that happens, then we have to break up the
loop into two: one that finds and processes the symbol
tables, and another, after the first one, that finds
and handles the .dynamic sectio.
*/
ASSERT(visited_dynsym == true);
if (sym_filter != NULL && symtab_size_changed) {
/* Walk the old dynamic segment. For each tag that represents
a string, build an entry into the dynamic-symbol-table's
strings table. */
INFO("\t\tbuilding strings for the dynamic section.\n");
ASSERT(cnt == dynamic_idx);
/* NOTE: By passing the the index (in shdr_info[]) of the
dynamic-symbol table to build_dynamic_segment_strings(),
we are making the assumption that those strings will be
kept in that table. While this does not seem to be
mandated by the ELF spec, it seems to be always the case.
Where else would you put these strings? You already have
the dynamic-symbol table and its strings table, and that's
guaranteed to be in the file, so why not put it there?
*/
build_dynamic_segment_strings(elf, ebl,
dynamic_idx,
dynsym_idx,
shdr_info,
shdr_info_len);
}
else {
INFO("\t\tThe dynamic-symbol table is not changing, so no "
"need to rebuild strings for the dynamic section.\n");
#ifdef DEBUG
print_dynamic_segment_strings(elf, ebl,
dynamic_idx,
dynsym_idx,
shdr_info,
shdr_info_len);
#endif
}
}
}
/* Set the section header in the new file. There cannot be any
overflows. */
INFO("\t\tupdating section header (size %lld)\n",
shdr_info[cnt].shdr.sh_size);
FAILIF(!gelf_update_shdr (scn, &shdr_info[cnt].shdr),
"Could not update section header for section %s!\n",
shdr_info[cnt].name);
} /* if (shdr_info[cnt].idx > 0) */
else INFO("\t%03d: not updating section %s, it will be discarded.\n",
cnt,
shdr_info[cnt].name);
} /* for (cnt = 1; cnt < shdr_info_len; ++cnt) */
/* Now, if we removed some symbols and thus modified the symbol table,
we need to update the hash table, the relocation sections that use these
symbols, and the symbol-strings table to cut out the unused symbols.
*/
if (symtab_size_changed) {
for (cnt = 1; cnt < shnum; ++cnt) {
if (shdr_info[cnt].idx == 0) {
/* Ignore sections which are discarded, unless these sections
are relocation sections. This case is for use by the
prelinker. */
if (shdr_info[cnt].shdr.sh_type != SHT_REL &&
shdr_info[cnt].shdr.sh_type != SHT_RELA) {
continue;
}
}
if (shdr_info[cnt].shdr.sh_type == SHT_REL ||
shdr_info[cnt].shdr.sh_type == SHT_RELA) {
/* shdr_info[cnt].old_shdr.sh_link is index of old symbol-table
section that this relocation-table section was relative to.
We can access shdr_info[] at that index to get to the
symbol-table section.
*/
Elf32_Word *newsymidx =
shdr_info[shdr_info[cnt].old_shdr.sh_link].newsymidx;
/* The referred-to-section must be a symbol table! Note that
alrhough shdr_info[cnt].shdr refers to the updated section
header, this assertion is still valid, since when updating
the section header we never modify the sh_type field.
*/
{
Elf64_Word sh_type =
shdr_info[shdr_info[cnt].shdr.sh_link].shdr.sh_type;
FAILIF(sh_type != SHT_DYNSYM,
"Section refered to from relocation section is not"
" a dynamic symbol table (sh_type=%d)!\n",
sh_type);
}
/* If that symbol table hasn't changed, then its newsymidx
field is NULL (see comments to shdr_info_t), so we
don't have to update this relocation-table section
*/
if (newsymidx == NULL) continue;
update_relocations_section_symbol_references(newelf, elf,
shdr_info, shnum,
shdr_info + cnt,
newsymidx);
} else if (shdr_info[cnt].shdr.sh_type == SHT_HASH) {
/* We have to recompute the hash table. A hash table's
sh_link field refers to the symbol table for which the hash
table is generated.
*/
Elf32_Word symtabidx = shdr_info[cnt].old_shdr.sh_link;
/* We do not have to recompute the hash table if the symbol
table was not changed. */
if (shdr_info[symtabidx].newsymidx == NULL)
continue;
FAILIF(shdr_info[cnt].shdr.sh_entsize != sizeof (Elf32_Word),
"Can't handle 64-bit ELF files!\n");
update_hash_table(newelf, /* new ELF */
elf, /* old ELF */
shdr_info[cnt].idx, /* hash table index */
shdr_info + symtabidx);
} /* if SHT_REL else if SHT_HASH ... */
else if (shdr_info[cnt].shdr.sh_type == SHT_DYNSYM)
{
/* The symbol table's sh_link field contains the index of the
strings table for this symbol table. We want to find the
index of the section in the shdr_info[] array. That index
corresponds to the index of the section in the original ELF file,
which is why we look at shdr_info[cnt].old_shdr and not
shdr_info[cnt].shdr.
*/
int symstrndx = shdr_info[cnt].old_shdr.sh_link;
INFO("Updating [%s] (symbol-strings-section data for [%s]).\n",
shdr_info[symstrndx].name,
shdr_info[cnt].name);
ASSERT(shdr_info[symstrndx].newscn);
size_t new_symstrndx = elf_ndxscn(shdr_info[symstrndx].newscn);
Elf_Data *newdata = elf_getdata(shdr_info[symstrndx].newscn, NULL);
ASSERT(NULL != newdata);
INFO("\tbefore update:\n"
"\t\tbuffer: %p\n"
"\t\tsize: %d\n",
newdata->d_buf,
newdata->d_size);
ASSERT(shdr_info[cnt].dynsymst);
ebl_strtabfinalize (shdr_info[cnt].dynsymst, newdata);
INFO("\tafter update:\n"
"\t\tbuffer: %p\n"
"\t\tsize: %d\n",
newdata->d_buf,
newdata->d_size);
FAILIF(new_symstrndx != shdr_info[cnt].shdr.sh_link,
"The index of the symbol-strings table according to elf_ndxscn() is %d, "
"according to shdr_info[] is %d!\n",
new_symstrndx,
shdr_info[cnt].shdr.sh_link);
INFO("%d nonprintable\n",
dump_hex_buffer(stdout, newdata->d_buf, newdata->d_size, 0));
shdr_info[symstrndx].shdr.sh_size = newdata->d_size;
FAILIF(!gelf_update_shdr(shdr_info[symstrndx].newscn,
&shdr_info[symstrndx].shdr),
"Could not update section header for section %s!\n",
shdr_info[symstrndx].name);
/* Now, update the symbol-name offsets. */
{
size_t i;
size_t elsize = gelf_fsize (elf, ELF_T_SYM, 1, ehdr->e_version);
for (i = 1; i < shdr_info[cnt].shdr.sh_size / elsize; ++i) {
Elf32_Word xshndx;
GElf_Sym sym_mem;
/* retrieve the symbol information; */
GElf_Sym *sym = gelf_getsymshndx (shdr_info[cnt].data,
NULL, i,
&sym_mem, &xshndx);
ASSERT(sym != NULL);
ASSERT(NULL != shdr_info[cnt].symse[i]);
/* calculate the new name offset; */
size_t new_st_name =
ebl_strtaboffset(shdr_info[cnt].symse[i]);
#if 1
ASSERT(!strcmp(newdata->d_buf + new_st_name,
elf_strptr(elf, shdr_info[cnt].old_shdr.sh_link,
sym->st_name)));
#endif
if (sym_filter && (sym->st_name != new_st_name)) {
/* FIXME: For some reason, elf_strptr() does not return the updated
string value here. It looks like ebl_strtabfinalize() doesn't
update libelf's internal structures well enough for elf_strptr()
to work on an ELF file that's being compose.
*/
INFO("Symbol [%s]'s name (index %d, old value %llx) changes offset: %d -> %d\n",
#if 0
newdata->d_buf + new_st_name,
#else
elf_strptr(elf, shdr_info[cnt].old_shdr.sh_link,
sym->st_name),
#endif
i,
sym->st_value,
sym->st_name,
new_st_name);
}
sym->st_name = new_st_name;
/* update the symbol info; */
FAILIF_LIBELF(0 ==
gelf_update_symshndx(
shdr_info[cnt].data,
NULL,
i, sym,
xshndx),
gelf_update_symshndx);
} /* for each symbol... */
}
}
FAILIF(shdr_info[cnt].shdr.sh_type == SHT_GNU_versym,
"Can't handle SHT_GNU_versym!\n");
FAILIF(shdr_info[cnt].shdr.sh_type == SHT_GROUP,
"Can't handle section groups!\n");
} /* for (cnt = 1; cnt < shnum; ++cnt) */
} /* if (symtab_size_changed) */
range_list_t *old_section_ranges = init_range_list();
range_list_t *section_ranges = NULL;
/* Analyze gaps in the ranges before we compact the sections. */
INFO("Analyzing gaps in ranges before compacting sections...\n");
{
size_t scnidx;
/* Gather the ranges */
for (scnidx = 1; scnidx < shdr_info_len; scnidx++) {
if (shdr_info[scnidx].idx > 0) {
if (/*shdr_info[scnidx].old_shdr.sh_type != SHT_NOBITS &&*/
shdr_info[scnidx].old_shdr.sh_flags & SHF_ALLOC) {
add_unique_range_nosort(
old_section_ranges,
shdr_info[scnidx].old_shdr.sh_addr,
shdr_info[scnidx].old_shdr.sh_size,
shdr_info + scnidx,
handle_range_error,
NULL);
}
}
}
sort_ranges(old_section_ranges);
#ifdef DEBUG
int num_ranges;
/* Analyze gaps in the ranges before we compact the sections. */
range_t *ranges = get_sorted_ranges(old_section_ranges, &num_ranges);
if (ranges) {
GElf_Off last_end = ranges->start;
int i;
for (i = 0; i < num_ranges; i++) {
shdr_info_t *curr = (shdr_info_t *)ranges[i].user;
ASSERT(ranges[i].start >= last_end);
int col_before, col_after;
INFO("[%016lld, %016lld] %n[%s]%n",
ranges[i].start,
ranges[i].start + ranges[i].length,
&col_before,
curr->name,
&col_after);
if (ranges[i].start > last_end) {
shdr_info_t *prev = (shdr_info_t *)ranges[i-1].user;
ASSERT(prev && curr);
while (col_after++ - col_before < 20) INFO(" ");
INFO(" [GAP: %lld bytes with %s]\n",
(ranges[i].start - last_end),
prev->name);
}
else INFO("\n");
last_end = ranges[i].start + ranges[i].length;
}
}
#endif/*DEBUG*/
}
/* Calculate the final section offsets */
INFO("Calculating new section offsets...\n");
section_ranges = update_section_offsets(elf,
newelf,
phdr_info,
shdr_info,
shdr_info_len,
init_range_list(),
adjust_alloc_section_offsets);
#ifdef DEBUG
{
/* Analyze gaps in the ranges after we've compacted the sections. */
int num_ranges;
range_t *ranges = get_sorted_ranges(section_ranges, &num_ranges);
if (ranges) {
int last_end = ranges->start;
int i;
for (i = 0; i < num_ranges; i++) {
shdr_info_t *curr = (shdr_info_t *)ranges[i].user;
ASSERT(ranges[i].start >= last_end);
int col_before, col_after;
INFO("[%016lld, %016lld] %n[%s]%n",
ranges[i].start,
ranges[i].start + ranges[i].length,
&col_before,
curr->name,
&col_after);
if (ranges[i].start > last_end) {
shdr_info_t *prev = (shdr_info_t *)ranges[i-1].user;
ASSERT(prev && curr);
while (col_after++ - col_before < 20) INFO(" ");
INFO(" [GAP: %lld bytes with %s]\n",
(ranges[i].start - last_end),
prev->name);
}
else INFO("\n");
last_end = ranges[i].start + ranges[i].length;
}
}
}
#endif
{
/* Now that we have modified the section offsets, we need to scan the
symbol tables once again and update their st_value fields. A symbol's
st_value field (in a shared library) contains the virtual address of the
symbol. For each symbol we encounter, we look up the section it was in.
If that section's virtual address has changed, then we calculate the
delta and update the symbol.
*/
#if 0
{
/* for debugging: Print out all sections and their data pointers and
sizes. */
int i = 1;
for (; i < shdr_info_len; i++) {
PRINT("%8d: %-15s: %2lld %8lld %08lx (%08lx:%8d) %08lx (%08lx:%8d)\n",
i,
shdr_info[i].name,
shdr_info[i].shdr.sh_entsize,
shdr_info[i].shdr.sh_addralign,
(long)shdr_info[i].data,
(long)(shdr_info[i].data ? shdr_info[i].data->d_buf : 0),
(shdr_info[i].data ? shdr_info[i].data->d_size : 0),
(long)shdr_info[i].newdata,
(long)(shdr_info[i].newdata ? shdr_info[i].newdata->d_buf : 0),
(shdr_info[i].newdata ? shdr_info[i].newdata->d_size : 0));
if (!strcmp(shdr_info[i].name, ".got") /* ||
!strcmp(shdr_info[i].name, ".plt") */) {
dump_hex_buffer(stdout,
shdr_info[i].newdata->d_buf,
shdr_info[i].newdata->d_size,
shdr_info[i].shdr.sh_entsize);
}
}
}
#endif
INFO("Updating symbol values...\n");
update_symbol_values(elf, ehdr, newelf, shdr_info, shdr_info_len,
shady,
dynamic_idx);
/* If we are not stripping the debug sections, then we need to adjust
* them accordingly, so that the new ELF file is actually debuggable.
* For that glorios reason, we call update_dwarf(). Note that
* update_dwarf() won't do anything if there, in fact, no debug
* sections to speak of.
*/
INFO("Updating DWARF records...\n");
int num_total_dwarf_patches = 0, num_failed_dwarf_patches = 0;
update_dwarf_if_necessary(
elf, ehdr, newelf,
shdr_info, shdr_info_len,
&num_total_dwarf_patches, &num_failed_dwarf_patches);
INFO("DWARF: %-15s: total %8d failed %8d.\n", elf_name, num_total_dwarf_patches, num_failed_dwarf_patches);
/* Adjust the program-header table. Since the file offsets of the various
sections may have changed, the file offsets of their containing segments
must change as well. We update those offsets in the loop below.
*/
{
INFO("Adjusting program-header table...\n");
int pi; /* program-header index */
for (pi = 0; pi < ehdr->e_phnum; ++pi) {
/* Print the segment number. */
INFO("\t%2.2zu\t", pi);
INFO("PT_ header type: %d", phdr_info[pi].p_type);
if (phdr_info[pi].p_type == PT_NULL) {
INFO(" PT_NULL (skip)\n");
}
else if (phdr_info[pi].p_type == PT_PHDR) {
INFO(" PT_PHDR\n");
ASSERT(phdr_info[pi].p_memsz == phdr_info[pi].p_filesz);
/* Although adjust_elf() does not remove program-header entries,
we perform this update here because I've seen object files
whose PHDR table is bigger by one element than it should be.
Here we check and correct the size, if necessary.
*/
if (phdr_info[pi].p_memsz != ehdr->e_phentsize * ehdr->e_phnum) {
ASSERT(phdr_info[pi].p_memsz > ehdr->e_phentsize * ehdr->e_phnum);
INFO("WARNING: PT_PHDR file and memory sizes are incorrect (%ld instead of %ld). Correcting.\n",
(long)phdr_info[pi].p_memsz,
(long)(ehdr->e_phentsize * ehdr->e_phnum));
phdr_info[pi].p_memsz = ehdr->e_phentsize * ehdr->e_phnum;
phdr_info[pi].p_filesz = phdr_info[pi].p_memsz;
}
}
else {
/* Go over the section array and find which section's offset
field matches this program header's, and update the program
header's offset to reflect the new value.
*/
Elf64_Off file_end, mem_end;
Elf64_Off new_phdr_offset =
section_to_header_mapping(elf, pi,
shdr_info, shdr_info_len,
&file_end,
&mem_end);
if (new_phdr_offset == (Elf64_Off)-1) {
INFO("PT_ header type: %d does not contain any sections.\n",
phdr_info[pi].p_type);
/* Move to the next program header. */
continue;
}
/* Alignments of 0 and 1 mean nothing. Higher alignments are
interpreted as powers of 2. */
if (phdr_info[pi].p_align > 1) {
INFO("\t\tapplying alignment of 0x%llx to new offset %lld\n",
phdr_info[pi].p_align,
new_phdr_offset);
new_phdr_offset &= ~(phdr_info[pi].p_align - 1);
}
Elf32_Sxword delta = new_phdr_offset - phdr_info[pi].p_offset;
INFO("\t\tnew offset %lld (was %lld)\n",
new_phdr_offset,
phdr_info[pi].p_offset);
phdr_info[pi].p_offset = new_phdr_offset;
INFO("\t\tnew vaddr 0x%llx (was 0x%llx)\n",
phdr_info[pi].p_vaddr + delta,
phdr_info[pi].p_vaddr);
phdr_info[pi].p_vaddr += delta;
INFO("\t\tnew paddr 0x%llx (was 0x%llx)\n",
phdr_info[pi].p_paddr + delta,
phdr_info[pi].p_paddr);
phdr_info[pi].p_paddr += delta;
INFO("\t\tnew mem size %lld (was %lld)\n",
mem_end - new_phdr_offset,
phdr_info[pi].p_memsz);
//phdr_info[pi].p_memsz = mem_end - new_phdr_offset;
phdr_info[pi].p_memsz = mem_end - phdr_info[pi].p_vaddr;
INFO("\t\tnew file size %lld (was %lld)\n",
file_end - new_phdr_offset,
phdr_info[pi].p_filesz);
//phdr_info[pi].p_filesz = file_end - new_phdr_offset;
phdr_info[pi].p_filesz = file_end - phdr_info[pi].p_offset;
}
FAILIF_LIBELF(gelf_update_phdr (newelf, pi, &phdr_info[pi]) == 0,
gelf_update_phdr);
}
}
if (dynamic_idx >= 0) {
/* NOTE: dynamic_idx is the index of .dynamic section in the shdr_info[] array, NOT the
index of the section in the ELF file!
*/
adjust_dynamic_segment_offsets(elf, ebl,
newelf,
dynamic_idx,
shdr_info,
shdr_info_len);
}
else INFO("There is no dynamic section in this file.\n");
/* Walk the relocation sections (again). This time, update offsets of the
relocation entries. Note that there is an implication here that the
offsets are virual addresses, because we are handling a shared library!
*/
for (cnt = 1; cnt < shdr_info_len; cnt++) {
/* Note here that we process even those relocation sections that are
* marked for removal. Normally, we wouldn't need to do this, but
* in the case where we run adjust_elf() after a dry run of
* prelink() (see apriori), we still want to update the relocation
* offsets because those will be picked up by the second run of
* prelink(). If this all seems too cryptic, go yell at Iliyan
* Malchev.
*/
if (/* shdr_info[cnt].idx > 0 && */
(shdr_info[cnt].shdr.sh_type == SHT_REL ||
shdr_info[cnt].shdr.sh_type == SHT_RELA))
{
int hacked = shdr_info[cnt].idx == 0;
Elf_Data *data;
if (hacked) {
/* This doesn't work! elf_ndxscn(shdr_info[cnt].scn) will return the section number
of the new sectin that has moved into this slot. */
shdr_info[cnt].idx = elf_ndxscn(shdr_info[cnt].scn);
data = elf_getdata (elf_getscn (elf, shdr_info[cnt].idx), NULL);
INFO("PRELINKER HACK: Temporarily restoring index of to-be-removed section [%s] to %d.\n",
shdr_info[cnt].name,
shdr_info[cnt].idx);
}
else
data = elf_getdata (elf_getscn (newelf, shdr_info[cnt].idx), NULL);
update_relocations_section_offsets(newelf, elf, ebl,
shdr_info, shdr_info_len,
shdr_info + cnt,
data,
old_section_ranges);
if (hacked) {
INFO("PRELINKER HACK: Done with hack, marking section [%s] for removal again.\n",
shdr_info[cnt].name);
shdr_info[cnt].idx = 0;
}
}
}
}
/* Finally finish the ELF header. Fill in the fields not handled by
libelf from the old file. */
{
GElf_Ehdr *newehdr, newehdr_mem;
newehdr = gelf_getehdr (newelf, &newehdr_mem);
FAILIF_LIBELF(newehdr == NULL, gelf_getehdr);
INFO("Updating ELF header.\n");
memcpy (newehdr->e_ident, ehdr->e_ident, EI_NIDENT);
newehdr->e_type = ehdr->e_type;
newehdr->e_machine = ehdr->e_machine;
newehdr->e_version = ehdr->e_version;
newehdr->e_entry = ehdr->e_entry;
newehdr->e_flags = ehdr->e_flags;
newehdr->e_phoff = ehdr->e_phoff;
/* We need to position the section header table. */
{
const size_t offsize = gelf_fsize (elf, ELF_T_OFF, 1, EV_CURRENT);
newehdr->e_shoff = get_last_address(section_ranges);
newehdr->e_shoff += offsize - 1;
newehdr->e_shoff &= ~((GElf_Off) (offsize - 1));
newehdr->e_shentsize = gelf_fsize (elf, ELF_T_SHDR, 1, EV_CURRENT);
INFO("\tsetting section-header-table offset to %lld\n",
newehdr->e_shoff);
}
if (rebuild_shstrtab) {
/* If we are rebuilding the section-headers string table, then
the new index must not be zero. This is to guard against
code breakage resulting from rebuild_shstrtab and shdridx
somehow getting out of sync. */
ASSERT(shdridx);
/* The new section header string table index. */
FAILIF(!(shdr_info[shdridx].idx < SHN_HIRESERVE) &&
likely (shdr_info[shdridx].idx != SHN_XINDEX),
"Can't handle extended section indices!\n");
}
INFO("Index of shstrtab is now %d (was %d).\n",
shdr_info[shdridx].idx,
ehdr->e_shstrndx);
newehdr->e_shstrndx = shdr_info[shdridx].idx;
FAILIF_LIBELF(gelf_update_ehdr(newelf, newehdr) == 0, gelf_update_ehdr);
}
if (section_ranges != NULL) destroy_range_list(section_ranges);
destroy_range_list(old_section_ranges);
#ifdef DEBUG
verify_elf (ehdr, shdr_info, shdr_info_len, phdr_info);
#endif
}
static void update_hash_table(Elf *newelf, Elf *elf,
Elf32_Word hash_scn_idx,
shdr_info_t *symtab_info) {
GElf_Shdr shdr_mem, *shdr = NULL;
Elf32_Word *chain;
Elf32_Word nbucket;
/* The hash table section and data in the new file. */
Elf_Scn *hashscn = elf_getscn (newelf, hash_scn_idx);
ASSERT(hashscn != NULL);
Elf_Data *hashd = elf_getdata (hashscn, NULL);
ASSERT (hashd != NULL);
Elf32_Word *bucket = (Elf32_Word *) hashd->d_buf; /* Sane arches first. */
/* The symbol table data. */
Elf_Data *symd = elf_getdata (elf_getscn (newelf, symtab_info->idx), NULL);
ASSERT (symd != NULL);
GElf_Ehdr ehdr_mem;
GElf_Ehdr *ehdr = gelf_getehdr (elf, &ehdr_mem);
FAILIF_LIBELF(NULL == ehdr, gelf_getehdr);
size_t strshndx = symtab_info->old_shdr.sh_link;
size_t elsize = gelf_fsize (elf, ELF_T_SYM, 1,
ehdr->e_version);
/* Convert to the correct byte order. */
FAILIF_LIBELF(gelf_xlatetom (newelf, hashd, hashd,
BYTE_ORDER == LITTLE_ENDIAN
? ELFDATA2LSB : ELFDATA2MSB) == NULL,
gelf_xlatetom);
/* Adjust the nchain value. The symbol table size changed. We keep the
same size for the bucket array. */
INFO("hash table: buckets: %d (no change).\n", bucket[0]);
INFO("hash table: chains: %d (was %d).\n",
symd->d_size / elsize,
bucket[1]);
bucket[1] = symd->d_size / elsize;
nbucket = bucket[0];
bucket += 2;
chain = bucket + nbucket;
/* New size of the section. */
shdr = gelf_getshdr (hashscn, &shdr_mem);
ASSERT(shdr->sh_type == SHT_HASH);
shdr->sh_size = (2 + symd->d_size / elsize + nbucket) * sizeof (Elf32_Word);
INFO("hash table: size %lld (was %d) bytes.\n",
shdr->sh_size,
hashd->d_size);
hashd->d_size = shdr->sh_size;
(void)gelf_update_shdr (hashscn, shdr);
/* Clear the arrays. */
memset (bucket, '\0',
(symd->d_size / elsize + nbucket)
* sizeof (Elf32_Word));
size_t inner;
for (inner = symtab_info->shdr.sh_info;
inner < symd->d_size / elsize;
++inner) {
const char *name;
GElf_Sym sym_mem;
GElf_Sym *sym = gelf_getsym (symd, inner, &sym_mem);
ASSERT (sym != NULL);
name = elf_strptr (elf, strshndx, sym->st_name);
ASSERT (name != NULL);
size_t hidx = elf_hash (name) % nbucket;
if (bucket[hidx] == 0)
bucket[hidx] = inner;
else {
hidx = bucket[hidx];
while (chain[hidx] != 0)
hidx = chain[hidx];
chain[hidx] = inner;
}
}
/* Convert back to the file byte order. */
FAILIF_LIBELF(gelf_xlatetof (newelf, hashd, hashd,
BYTE_ORDER == LITTLE_ENDIAN
? ELFDATA2LSB : ELFDATA2MSB) == NULL,
gelf_xlatetof);
}
/* This function updates the symbol indices of relocation entries. It does not
update the section offsets of those entries.
*/
static void update_relocations_section_symbol_references(
Elf *newelf, Elf *elf __attribute__((unused)),
shdr_info_t *info,
int info_len __attribute__((unused)),
shdr_info_t *relsect_info,
Elf32_Word *newsymidx)
{
/* Get this relocation section's data */
Elf_Data *d = elf_getdata (elf_getscn (newelf, relsect_info->idx), NULL);
ASSERT (d != NULL);
ASSERT (d->d_size == relsect_info->shdr.sh_size);
size_t old_nrels =
relsect_info->old_shdr.sh_size / relsect_info->old_shdr.sh_entsize;
size_t new_nrels =
relsect_info->shdr.sh_size / relsect_info->shdr.sh_entsize;
size_t nrels = new_nrels;
if (relsect_info->use_old_shdr_for_relocation_calculations) {
nrels = old_nrels;
/* Now, we update d->d_size to point to the old size in order to
prevent gelf_update_rel() and gelf_update_rela() from returning
an error. We restore the value at the end of the function.
*/
d->d_size = old_nrels * relsect_info->shdr.sh_entsize;
}
/* Now, walk the relocations one by one. For each relocation,
check to see whether the symbol it refers to has a new
index in the symbol table, and if so--update it. We know
if a symbol's index has changed when we look up that
the newsymidx[] array at the old index. If the value at that
location is different from the array index, then the
symbol's index has changed; otherwise, it remained the same.
*/
INFO("Scanning %d relocation entries in section [%s] (taken from %s section header (old %d, new %d))...\n",
nrels,
relsect_info->name,
(relsect_info->use_old_shdr_for_relocation_calculations ? "old" : "new"),
old_nrels, new_nrels);
size_t relidx, newidx;
if (relsect_info->shdr.sh_type == SHT_REL) {
for (newidx = relidx = 0; relidx < nrels; ++relidx) {
GElf_Rel rel_mem;
FAILIF_LIBELF(gelf_getrel (d, relidx, &rel_mem) == NULL,
gelf_getrel);
size_t symidx = GELF_R_SYM (rel_mem.r_info);
if (newsymidx[symidx] != (Elf32_Word)-1)
{
rel_mem.r_info = GELF_R_INFO (newsymidx[symidx],
GELF_R_TYPE (rel_mem.r_info));
FAILIF_LIBELF(gelf_update_rel (d, newidx, &rel_mem) == 0,
gelf_update_rel);
newidx++;
}
else {
INFO("Discarding REL entry for symbol [%d], section [%d]\n",
symidx,
relsect_info->shdr.sh_info);
}
} /* for each rel entry... */
} else {
for (newidx = relidx = 0; relidx < nrels; ++relidx) {
GElf_Rela rel_mem;
FAILIF_LIBELF(gelf_getrela (d, relidx, &rel_mem) == NULL,
gelf_getrela);
size_t symidx = GELF_R_SYM (rel_mem.r_info);
if (newsymidx[symidx] != (Elf32_Word)-1)
{
rel_mem.r_info
= GELF_R_INFO (newsymidx[symidx],
GELF_R_TYPE (rel_mem.r_info));
FAILIF_LIBELF(gelf_update_rela (d, newidx, &rel_mem) == 0,
gelf_update_rela);
newidx++;
}
else {
INFO("Discarding RELA entry for symbol [%d], section [%d]\n",
symidx,
relsect_info->shdr.sh_info);
}
} /* for each rela entry... */
} /* if rel else rela */
if (newidx != relidx)
{
INFO("Shrinking relocation section from %lld to %lld bytes (%d -> %d "
"entries).\n",
relsect_info->shdr.sh_size,
relsect_info->shdr.sh_entsize * newidx,
relidx,
newidx);
d->d_size = relsect_info->shdr.sh_size =
relsect_info->shdr.sh_entsize * newidx;
} else INFO("Relocation section [%s]'s size (relocates: %s(%d), "
"symab: %s(%d)) does not change.\n",
relsect_info->name,
info[relsect_info->shdr.sh_info].name,
relsect_info->shdr.sh_info,
info[relsect_info->shdr.sh_link].name,
relsect_info->shdr.sh_link);
/* Restore d->d_size if necessary. */
if (relsect_info->use_old_shdr_for_relocation_calculations)
d->d_size = new_nrels * relsect_info->shdr.sh_entsize;
}
static void update_relocations_section_offsets(Elf *newelf __attribute((unused)), Elf *elf,
Ebl *ebl __attribute__((unused)),
shdr_info_t *info,
int info_len __attribute__((unused)),
shdr_info_t *relsect_info,
Elf_Data *d,
range_list_t *old_section_ranges)
{
/* Get this relocation section's data */
ASSERT (d != NULL);
if (d->d_size != relsect_info->shdr.sh_size) {
/* This is not necessarily a fatal error. In the case where we call adjust_elf() from apriori
(the prelinker), we may call this function for a relocation section that is marked for
removal. We still want to process this relocation section because, even though it is marked
for removal, its relocatin entries will be used by the prelinker to know what to prelink.
Once the prelinker is done, it will call adjust_elf() one more time to actually eliminate the
relocation section. */
PRINT("WARNING: section size according to section [%s]'s header is %lld, but according to data buffer is %ld.\n",
relsect_info->name,
relsect_info->shdr.sh_size,
d->d_size);
ASSERT((relsect_info->shdr.sh_type == SHT_REL || relsect_info->shdr.sh_type == SHT_RELA) &&
relsect_info->use_old_shdr_for_relocation_calculations);
}
size_t old_nrels =
relsect_info->old_shdr.sh_size / relsect_info->old_shdr.sh_entsize;
size_t new_nrels =
relsect_info->shdr.sh_size / relsect_info->shdr.sh_entsize;
size_t nrels = new_nrels;
if (relsect_info->use_old_shdr_for_relocation_calculations) {
nrels = old_nrels;
/* Now, we update d->d_size to point to the old size in order to
prevent gelf_update_rel() and gelf_update_rela() from returning
an error. We restore the value at the end of the function.
*/
d->d_size = old_nrels * relsect_info->shdr.sh_entsize;
}
/* Now, walk the relocations one by one. For each relocation,
check to see whether the symbol it refers to has a new
index in the symbol table, and if so--update it. We know
if a symbol's index has changed when we look up that
the newsymidx[] array at the old index. If the value at that
location is different from the array index, then the
symbol's index has changed; otherwise, it remained the same.
*/
INFO("Scanning %d relocation entries in section [%s] (taken from %s section header (old %d, new %d))...\n",
nrels,
relsect_info->name,
(relsect_info->use_old_shdr_for_relocation_calculations ? "old" : "new"),
old_nrels, new_nrels);
if (relsect_info->old_shdr.sh_info == 0) {
PRINT("WARNING: Relocation section [%s] relocates the NULL section.\n",
relsect_info->name);
}
else {
FAILIF(info[relsect_info->old_shdr.sh_info].idx == 0,
"Section [%s] relocates section [%s] (index %d), which is being "
"removed!\n",
relsect_info->name,
info[relsect_info->old_shdr.sh_info].name,
relsect_info->old_shdr.sh_info);
}
size_t relidx;
FAILIF(relsect_info->shdr.sh_type == SHT_RELA,
"Can't handle SHT_RELA relocation entries.\n");
if (relsect_info->shdr.sh_type == SHT_REL) {
for (relidx = 0; relidx < nrels; ++relidx) {
GElf_Rel rel_mem;
FAILIF_LIBELF(gelf_getrel (d, relidx, &rel_mem) == NULL,
gelf_getrel);
if (GELF_R_TYPE(rel_mem.r_info) == R_ARM_NONE)
continue;
range_t *old_range = find_range(old_section_ranges,
rel_mem.r_offset);
#if 1
if (NULL == old_range) {
GElf_Sym *sym, sym_mem;
unsigned sym_idx = GELF_R_SYM(rel_mem.r_info);
/* relsect_info->shdr.sh_link is the index of the associated
symbol table. */
sym = gelf_getsymshndx(info[relsect_info->shdr.sh_link].data,
NULL,
sym_idx,
&sym_mem,
NULL);
/* info[relsect_info->shdr.sh_link].shdr.sh_link is the index
of the string table associated with the symbol table
associated with the relocation section rel_sect. */
const char *symname = elf_strptr(elf,
info[relsect_info->shdr.sh_link].shdr.sh_link,
sym->st_name);
{
int i = 0;
INFO("ABOUT TO FAIL for symbol [%s]: old section ranges:\n", symname);
int num_ranges;
range_t *ranges = get_sorted_ranges(old_section_ranges, &num_ranges);
for (; i < num_ranges; i++) {
shdr_info_t *inf = (shdr_info_t *)ranges[i].user;
INFO("\t[%8lld, %8lld] (%8lld bytes) [%8lld, %8lld] (%8lld bytes) [%-15s]\n",
ranges[i].start,
ranges[i].start + ranges[i].length,
ranges[i].length,
inf->old_shdr.sh_addr,
inf->old_shdr.sh_addr + inf->old_shdr.sh_size,
inf->old_shdr.sh_size,
inf->name);
}
INFO("\n");
}
FAILIF(1,
"No range matches relocation entry value 0x%llx (%d) [%s]!\n",
rel_mem.r_offset,
rel_mem.r_offset,
symname);
}
#else
FAILIF(NULL == old_range,
"No range matches relocation entry value 0x%llx!\n",
rel_mem.r_offset);
#endif
ASSERT(old_range->start <= rel_mem.r_offset &&
rel_mem.r_offset < old_range->start + old_range->length);
ASSERT(old_range->user);
shdr_info_t *old_range_info = (shdr_info_t *)old_range->user;
ASSERT(old_range_info->idx > 0);
if (relsect_info->old_shdr.sh_info &&
old_range_info->idx != relsect_info->old_shdr.sh_info) {
PRINT("Relocation offset 0x%llx does not match section [%s] "
"but section [%s]!\n",
rel_mem.r_offset,
info[relsect_info->old_shdr.sh_info].name,
old_range_info->name);
}
#if 0 /* This is true only for shared libraries, but not for executables */
ASSERT(old_range_info->shdr.sh_addr == old_range_info->shdr.sh_offset);
ASSERT(old_range_info->old_shdr.sh_addr == old_range_info->old_shdr.sh_offset);
#endif
Elf64_Sxword delta =
old_range_info->shdr.sh_addr - old_range_info->old_shdr.sh_addr;
if (delta) {
extern int verbose_flag;
/* Print out some info about the relocation entry we are
modifying. */
if (unlikely(verbose_flag)) {
/* Get associated (new) symbol table. */
Elf64_Word symtab = relsect_info->shdr.sh_link;
/* Get the symbol that is being relocated. */
size_t symidx = GELF_R_SYM (rel_mem.r_info);
GElf_Sym sym_mem, *sym;
/* Since by now we've already updated the symbol index,
we need to retrieve the symbol from the new symbol table.
*/
sym = gelf_getsymshndx (elf_getdata(info[symtab].newscn, NULL),
NULL,
symidx, &sym_mem, NULL);
FAILIF_LIBELF(NULL == sym, gelf_getsymshndx);
char buf[64];
INFO("\t%02d (%-15s) off 0x%llx -> 0x%llx (%lld) (relocates [%s:(%d)%s])\n",
(unsigned)GELF_R_TYPE(rel_mem.r_info),
ebl_reloc_type_name(ebl,
GELF_R_TYPE(rel_mem.r_info),
buf,
sizeof(buf)),
rel_mem.r_offset, rel_mem.r_offset + delta, delta,
old_range_info->name,
symidx,
#if ELF_STRPTR_IS_BROKEN
/* libelf does not keep track of changes very well.
Looks like, if you use elf_strptr() on a file that
has not been updated yet, you get bogus results. */
((char *)info[info[symtab].old_shdr.sh_link].
newdata->d_buf) + sym->st_name
#else
elf_strptr(newelf,
info[symtab].shdr.sh_link,
sym->st_name)
#endif
);
} /* if (verbose_flag) */
rel_mem.r_offset += delta;
FAILIF_LIBELF(gelf_update_rel (d, relidx, &rel_mem) == 0,
gelf_update_rel);
#ifdef ARM_SPECIFIC_HACKS
if (GELF_R_TYPE(rel_mem.r_info) == R_ARM_RELATIVE) {
FAILIF(GELF_R_SYM(rel_mem.r_info) != 0,
"Can't handle relocation!\n");
/* From the ARM documentation: "when the symbol is zero,
the R_ARM_RELATIVE entry resolves to the difference
between the address at which the segment being
relocated was loaded and the address at which it
was linked."
*/
int *ptr =
(int *)(((char *)old_range_info->newdata->d_buf) +
(rel_mem.r_offset -
old_range_info->shdr.sh_addr));
*ptr += (int)delta;
}
#endif
} /* if (delta) */
} /* for each rel entry... */
}
/* Restore d->d_size if necessary. */
if (relsect_info->use_old_shdr_for_relocation_calculations)
d->d_size = new_nrels * relsect_info->shdr.sh_entsize;
}
static inline
Elf_Data *create_section_data(shdr_info_t *info, Elf_Scn *scn)
{
Elf_Data *newdata = NULL;
if (info->data == NULL) {
info->data = elf_getdata (info->scn, NULL);
FAILIF_LIBELF(NULL == info->data, elf_getdata);
INFO("\t\tcopying data from original section (%d bytes).\n",
info->data->d_size);
/* Set the data. This is done by copying from the old file. */
newdata = elf_newdata (scn);
FAILIF_LIBELF(newdata == NULL, elf_newdata);
/* Copy the structure. Note that the data buffer pointer gets
copied, but the buffer itself does not. */
*newdata = *info->data;
#if COPY_SECTION_DATA_BUFFER
if (info->data->d_buf != NULL) {
newdata->d_buf = MALLOC(newdata->d_size);
memcpy(newdata->d_buf, info->data->d_buf, newdata->d_size);
}
#endif
} else {
INFO("\t\tassigning new data to section (%d bytes).\n",
info->data->d_size);
newdata = info->data;
}
info->newdata = newdata;
return newdata;
}
#if 0
static void print_shdr_array(shdr_info_t *info, int num_entries) {
extern int verbose_flag;
if (verbose_flag) {
int i;
for (i = 0; i < num_entries; i++) {
INFO("%03d:"
"\tname [%s]\n"
"\tidx [%d]\n",
i, info[i].name, info[i].idx);
}
} /* if (verbose_flag) */
}
#endif
static size_t do_update_dyn_entry_address(Elf *elf,
GElf_Dyn *dyn,
shdr_info_t *shdr_info,
int shdr_info_len,
int newline)
{
size_t scnidx = 0;
INFO("%#0*llx",
gelf_getclass (elf) == ELFCLASS32 ? 10 : 18,
dyn->d_un.d_val);
for (scnidx = 1; scnidx < shdr_info_len; scnidx++) {
if (shdr_info[scnidx].old_shdr.sh_addr == dyn->d_un.d_ptr) {
if (shdr_info[scnidx].idx > 0) {
INFO(" (updating to 0x%08llx per section %d (shdr_info[] index %d): [%s])",
shdr_info[scnidx].shdr.sh_addr,
shdr_info[scnidx].idx,
scnidx,
shdr_info[scnidx].name);
dyn->d_un.d_ptr = shdr_info[scnidx].shdr.sh_addr;
break;
}
else {
/* FIXME: This should be more intelligent. What if there is more than one section that fits the
dynamic entry, and just the first such is being removed? We should keep on searching here.
*/
INFO(" (Setting to ZERO per section (shdr_info[] index %d) [%s], which is being removed)",
scnidx,
shdr_info[scnidx].name);
dyn->d_un.d_ptr = 0;
break;
}
}
}
if (newline) INFO("\n");
return scnidx == shdr_info_len ? 0 : scnidx;
}
static inline size_t update_dyn_entry_address(Elf *elf,
GElf_Dyn *dyn,
shdr_info_t *shdr_info,
int shdr_info_len)
{
return do_update_dyn_entry_address(elf, dyn, shdr_info, shdr_info_len, 1);
}
static void update_dyn_entry_address_and_size(Elf *elf, Ebl *oldebl,
GElf_Dyn *dyn,
shdr_info_t *shdr_info,
int shdr_info_len,
Elf_Data *dyn_data,
size_t *dyn_size_entries,
int dyn_entry_idx)
{
size_t scnidx = do_update_dyn_entry_address(elf, dyn,
shdr_info, shdr_info_len,
0);
if (scnidx) {
char buf[64];
INFO(" (affects tag %s)",
ebl_dynamic_tag_name(oldebl, dyn_entry_idx,
buf, sizeof (buf)));
if (dyn_size_entries[dyn_entry_idx]) {
/* We previously encountered this size entry, and because
we did not know which section would affect it, we saved its
index in the dyn_size_entries[] array so that we can update
the entry when we do know. Now we know that the field
shdr_info[scnidx].shdr.sh_size contains that new value.
*/
GElf_Dyn *szdyn, szdyn_mem;
szdyn = gelf_getdyn (dyn_data,
dyn_size_entries[dyn_entry_idx],
&szdyn_mem);
FAILIF_LIBELF(NULL == szdyn, gelf_getdyn);
ASSERT(szdyn->d_tag == dyn_entry_idx);
INFO("\n (!)\t%-17s completing deferred update (%lld -> %lld bytes)"
" per section %d [%s]",
ebl_dynamic_tag_name (oldebl, szdyn->d_tag,
buf, sizeof (buf)),
szdyn->d_un.d_val,
shdr_info[scnidx].shdr.sh_size,
shdr_info[scnidx].idx,
shdr_info[scnidx].name);
szdyn->d_un.d_val = shdr_info[scnidx].shdr.sh_size;
FAILIF_LIBELF(0 == gelf_update_dyn(dyn_data,
dyn_size_entries[dyn_entry_idx],
szdyn),
gelf_update_dyn);
#ifdef DEBUG
dyn_size_entries[dyn_entry_idx] = -1;
#endif
}
else dyn_size_entries[dyn_entry_idx] = scnidx;
} /* if (scnidx) */
INFO("\n");
}
static void do_build_dynamic_segment_strings(Elf *elf, Ebl *oldebl,
int dynidx, /* index of .dynamic section */
int symtabidx, /* index of symbol table section */
shdr_info_t *shdr_info,
int shdr_info_len __attribute__((unused)),
bool print_strings_only)
{
Elf_Scn *dynscn = elf_getscn(elf, dynidx);
FAILIF_LIBELF(NULL == dynscn, elf_getscn);
Elf_Data *data = elf_getdata (dynscn, NULL);
ASSERT(data != NULL);
size_t cnt;
if (!print_strings_only) {
/* Allocate an array of string-offset structures. */
shdr_info[dynidx].symse =
(struct Ebl_Strent **)CALLOC(
shdr_info[dynidx].shdr.sh_size/shdr_info[dynidx].shdr.sh_entsize,
sizeof(struct Ebl_Strent *));
}
for (cnt = 0;
cnt < shdr_info[dynidx].shdr.sh_size/shdr_info[dynidx].shdr.sh_entsize;
++cnt)
{
char buf[64];
GElf_Dyn dynmem;
GElf_Dyn *dyn;
dyn = gelf_getdyn (data, cnt, &dynmem);
FAILIF_LIBELF(NULL == dyn, gelf_getdyn);
switch (dyn->d_tag) {
case DT_NEEDED:
case DT_SONAME:
case DT_RPATH:
case DT_RUNPATH:
{
const char *str =
elf_strptr (elf,
shdr_info[dynidx].shdr.sh_link,
dyn->d_un.d_val);
ASSERT(str != NULL);
INFO("\t\t\t%-17s: ",
ebl_dynamic_tag_name (oldebl,
dyn->d_tag,
buf, sizeof (buf)));
INFO("[%s] (offset %ld)\n", str, dyn->d_un.d_val);
if (!print_strings_only) {
/* We append the strings to the string table belonging to the
dynamic-symbol-table section. We keep the dynsymst handle
for the strings section in the shdr_info[] entry for the
dynamic-sybmol table. Confusing, I know.
*/
ASSERT(shdr_info[symtabidx].dynsymst);
/* The string tables for the symbol table and the .dynamic
section must be the same.
*/
ASSERT(shdr_info[symtabidx].shdr.sh_link ==
shdr_info[dynidx].shdr.sh_link);
shdr_info[dynidx].symse[cnt] =
ebl_strtabadd(shdr_info[symtabidx].dynsymst, str?:"", 0);
ASSERT(shdr_info[dynidx].symse[cnt] != NULL);
}
}
break;
default:
break;
}
} /* for (...) */
} /* build_dynamic_segment_strings() */
static void build_dynamic_segment_strings(Elf *elf, Ebl *oldebl,
int dynidx, /* index of .dynamic section */
int symtabidx, /* index of symbol table section */
shdr_info_t *shdr_info,
int shdr_info_len __attribute__((unused)))
{
INFO("\t\tbuilding string offsets for dynamic section [%s], index %d\n",
shdr_info[dynidx].name,
dynidx);
do_build_dynamic_segment_strings(elf, oldebl, dynidx, symtabidx,
shdr_info, shdr_info_len, false);
}
#ifdef DEBUG
static void print_dynamic_segment_strings(Elf *elf, Ebl *oldebl,
int dynidx, /* index of .dynamic section */
int symtabidx, /* index of symbol table section */
shdr_info_t *shdr_info,
int shdr_info_len __attribute__((unused)))
{
INFO("\t\tprinting string offsets for dynamic section [%s], index %d\n",
shdr_info[dynidx].name,
dynidx);
do_build_dynamic_segment_strings(elf, oldebl, dynidx, symtabidx,
shdr_info, shdr_info_len, true);
}
#endif
static void adjust_dynamic_segment_offsets(Elf *elf, Ebl *oldebl,
Elf *newelf __attribute__((unused)),
int dynidx, /* index of .dynamic section in shdr_info[] */
shdr_info_t *shdr_info,
int shdr_info_len)
{
Elf_Scn *scn = shdr_info[dynidx].newscn;
FAILIF_LIBELF(NULL == scn, elf_getscn);
Elf_Data *data = elf_getdata (scn, NULL);
ASSERT(data != NULL);
size_t cnt;
INFO("Updating dynamic section [%s], index %d\n",
shdr_info[dynidx].name,
dynidx);
size_t *dyn_size_entries = (size_t *)CALLOC(DT_NUM, sizeof(size_t));
ASSERT(data->d_type == ELF_T_DYN);
for (cnt = 0; cnt < shdr_info[dynidx].shdr.sh_size / shdr_info[dynidx].shdr.sh_entsize; ++cnt) {
char buf[64];
GElf_Dyn dynmem;
GElf_Dyn *dyn;
dyn = gelf_getdyn (data, cnt, &dynmem);
FAILIF_LIBELF(NULL == dyn, gelf_getdyn);
INFO("\t%-17s ",
ebl_dynamic_tag_name (oldebl, dyn->d_tag, buf, sizeof (buf)));
switch (dyn->d_tag) {
/* Updates to addresses */
/* We assume that the address entries come before the size entries.
*/
case DT_PLTGOT:
case DT_HASH:
case DT_SYMTAB:
(void)update_dyn_entry_address(elf, dyn, shdr_info, shdr_info_len);
break;
case DT_STRTAB:
/* Defer-update DT_STRSZ as well, if not already updated. */
update_dyn_entry_address_and_size(elf, oldebl, dyn,
shdr_info, shdr_info_len,
data,
dyn_size_entries,
DT_STRSZ);
break;
case DT_RELA:
/* Defer-update DT_RELASZ as well, if not already updated. */
update_dyn_entry_address_and_size(elf, oldebl, dyn,
shdr_info, shdr_info_len,
data,
dyn_size_entries,
DT_RELASZ);
break;
case DT_REL:
/* Defer-update DT_RELSZ as well, if not already updated. */
update_dyn_entry_address_and_size(elf, oldebl, dyn,
shdr_info, shdr_info_len,
data,
dyn_size_entries,
DT_RELSZ);
break;
case DT_JMPREL:
/* Defer-update DT_PLTRELSZ as well, if not already updated. */
update_dyn_entry_address_and_size(elf, oldebl, dyn,
shdr_info, shdr_info_len,
data,
dyn_size_entries,
DT_PLTRELSZ);
break;
case DT_INIT_ARRAY:
case DT_FINI_ARRAY:
case DT_PREINIT_ARRAY:
case DT_INIT:
case DT_FINI:
(void)update_dyn_entry_address(elf, dyn, shdr_info, shdr_info_len);
break;
/* Updates to sizes */
case DT_PLTRELSZ: /* DT_JMPREL or DT_PLTGOT */
case DT_STRSZ: /* DT_STRTAB */
case DT_RELSZ: /* DT_REL */
case DT_RELASZ: /* DR_RELA */
if (dyn_size_entries[dyn->d_tag] == 0) {
/* We have not yet found the new size for this entry, so we
save the index of the dynamic entry in the dyn_size_entries[]
array. When we find the section affecting this field (in
code above), we will update the entry.
*/
INFO("(!) (deferring update: new value not known yet)\n");
dyn_size_entries[dyn->d_tag] = cnt;
}
else {
ASSERT(dyn_size_entries[dyn->d_tag] < shdr_info_len);
INFO("%lld (bytes) (updating to %lld bytes "
"per section %d [%s])\n",
dyn->d_un.d_val,
shdr_info[dyn_size_entries[dyn->d_tag]].shdr.sh_size,
shdr_info[dyn_size_entries[dyn->d_tag]].idx,
shdr_info[dyn_size_entries[dyn->d_tag]].name);
dyn->d_un.d_val =
shdr_info[dyn_size_entries[dyn->d_tag]].shdr.sh_size;
#ifdef DEBUG
/* Clear the array so that we know we are done with it. */
dyn_size_entries[dyn->d_tag] = (size_t)-1;
#endif
}
break;
/* End of updates. */
case DT_NULL:
case DT_DEBUG:
case DT_BIND_NOW:
case DT_TEXTREL:
/* No further output. */
INFO("\n");
break;
/* String-entry updates. */
case DT_NEEDED:
case DT_SONAME:
case DT_RPATH:
case DT_RUNPATH:
if (shdr_info[dynidx].symse != NULL)
{
Elf64_Xword new_offset =
ebl_strtaboffset(shdr_info[dynidx].symse[cnt]);
INFO("string [%s] offset changes: %lld -> %lld\n",
elf_strptr (elf,
shdr_info[dynidx].shdr.sh_link,
dyn->d_un.d_val),
dyn->d_un.d_val,
new_offset);
dyn->d_un.d_val = new_offset;
FAILIF_LIBELF(0 == gelf_update_dyn(data, cnt, dyn),
gelf_update_dyn);
}
else
INFO("string [%s] offset has not changed from %lld, not updating\n",
elf_strptr (elf,
shdr_info[dynidx].shdr.sh_link,
dyn->d_un.d_val),
dyn->d_un.d_val);
break;
case DT_RELAENT:
case DT_SYMENT:
case DT_RELENT:
case DT_PLTPADSZ:
case DT_MOVEENT:
case DT_MOVESZ:
case DT_INIT_ARRAYSZ:
case DT_FINI_ARRAYSZ:
case DT_SYMINSZ:
case DT_SYMINENT:
case DT_GNU_CONFLICTSZ:
case DT_GNU_LIBLISTSZ:
INFO("%lld (bytes)\n", dyn->d_un.d_val);
break;
case DT_VERDEFNUM:
case DT_VERNEEDNUM:
case DT_RELACOUNT:
case DT_RELCOUNT:
INFO("%lld\n", dyn->d_un.d_val);
break;
case DT_PLTREL: /* Specifies whether PLTREL (same as JMPREL) has REL or RELA entries */
INFO("%s (%d)\n", ebl_dynamic_tag_name (oldebl, dyn->d_un.d_val, NULL, 0), dyn->d_un.d_val);
break;
default:
INFO("%#0*llx\n",
gelf_getclass (elf) == ELFCLASS32 ? 10 : 18,
dyn->d_un.d_val);
break;
}
FAILIF_LIBELF(0 == gelf_update_dyn(data, cnt, dyn),
gelf_update_dyn);
} /* for (...) */
#ifdef DEBUG
if (1) {
int i;
for (i = 0; i < DT_NUM; i++)
ASSERT((ssize_t)dyn_size_entries[i] <= 0);
}
#endif
FREE(dyn_size_entries);
} /* adjust_dynamic_segment_offsets() */
static bool section_belongs_to_header(GElf_Shdr *shdr, GElf_Phdr *phdr)
{
if (shdr->sh_size) {
/* Compare allocated sections by VMA, unallocated
sections by file offset. */
if(shdr->sh_flags & SHF_ALLOC) {
if(shdr->sh_addr >= phdr->p_vaddr
&& (shdr->sh_addr + shdr->sh_size
<= phdr->p_vaddr + phdr->p_memsz))
{
return true;
}
}
else {
if (shdr->sh_offset >= phdr->p_offset
&& (shdr->sh_offset + shdr->sh_size
<= phdr->p_offset + phdr->p_filesz))
{
return true;
}
}
}
return false;
}
static Elf64_Off section_to_header_mapping(Elf *elf,
int phdr_idx,
shdr_info_t *shdr_info,
int num_shdr_info,
Elf64_Off *file_end,
Elf64_Off *mem_end)
{
Elf64_Off start;
GElf_Phdr phdr_mem;
GElf_Phdr *phdr = gelf_getphdr (elf, phdr_idx, &phdr_mem);
FAILIF_LIBELF(NULL == phdr, gelf_getphdr);
size_t inner;
FAILIF(phdr->p_type == PT_GNU_RELRO,
"Can't handle segments of type PT_GNU_RELRO!\n");
/* Iterate over the sections. */
start = (Elf64_Off)-1;
*file_end = *mem_end = 0;
INFO("\n\t\t");
for (inner = 1; inner < num_shdr_info; ++inner)
{
if (shdr_info[inner].idx > 0) {
/* Check to see the section is in the segment. We use the old
header because that header contains the old offset and length
information about a section.
*/
if (section_belongs_to_header(&shdr_info[inner].old_shdr, phdr))
{
INFO("%-17s", shdr_info[inner].name);
#define SECT_MEM_END(s) ((s).sh_addr + (s).sh_size)
if ((shdr_info[inner].shdr.sh_flags & SHF_ALLOC)) {
if (SECT_MEM_END(shdr_info[inner].shdr) > *mem_end) {
INFO("(mem_end 0x%llx --> 0x%llx) ", *mem_end, SECT_MEM_END(shdr_info[inner].shdr));
*mem_end = SECT_MEM_END(shdr_info[inner].shdr);
}
#undef SECT_MEM_END
#define SECT_FILE_END(s) ((s).sh_offset + (s).sh_size)
if (shdr_info[inner].shdr.sh_type != SHT_NOBITS) {
if (SECT_FILE_END(shdr_info[inner].shdr) > *file_end) {
INFO("(file_end 0x%llx --> 0x%llx) ", *file_end, SECT_FILE_END(shdr_info[inner].shdr));
*file_end = SECT_FILE_END(shdr_info[inner].shdr);
}
}
#undef SECT_FILE_END
if (shdr_info[inner].shdr.sh_offset < start) {
start = shdr_info[inner].shdr.sh_offset;
}
} /* if section takes space */
INFO("\n\t\t");
}
else
INFO("(!) %-17s does not belong\n\t\t", shdr_info[inner].name);
}
else
INFO("(!) %-17s is not considered, it is being removed\n\t\t", shdr_info[inner].name);
}
/* Finish the line. */
INFO("start: %lld\n", start);
INFO("\t\tends: %lld file, %lld mem\n", *file_end, *mem_end);
return start;
}
static void
update_symbol_values(Elf *elf, GElf_Ehdr *ehdr,
Elf *newelf __attribute__((unused)),
shdr_info_t *shdr_info,
int num_shdr_info,
int shady,
int dynamic_idx)
{
/* Scan the sections, looking for the symbol table. */
size_t i;
for (i = 1; i < num_shdr_info; i++) {
if (shdr_info[i].idx > 0 &&
(shdr_info[i].shdr.sh_type == SHT_SYMTAB ||
shdr_info[i].shdr.sh_type == SHT_DYNSYM))
{
size_t inner;
size_t elsize = gelf_fsize (elf, ELF_T_SYM, 1, ehdr->e_version);
Elf_Data *symdata = shdr_info[i].newdata;
/* shdr_info[i].old_shdr.sh_link is the index of the strings table
in the old ELF file. This index still points to the same section
in the shdr_info[] array. The idx field of that entry is that
section's new index. That index must, therefore, be equal to
the new value of sh_link. */
ASSERT(shdr_info[shdr_info[i].old_shdr.sh_link].idx ==
shdr_info[i].shdr.sh_link);
ASSERT(shdr_info[shdr_info[i].old_shdr.sh_link].data);
INFO("\tupdating symbol values for section [%s]...\n",
shdr_info[i].name);
#if 1 /* DEBUG */
{
Elf_Scn *symstrscn = elf_getscn(newelf, shdr_info[i].shdr.sh_link);
ASSERT(symstrscn);
Elf_Data *symstrdata = elf_getdata(symstrscn, NULL);
ASSERT(symstrdata);
INFO("%d nonprintable\n",
dump_hex_buffer(stdout, symstrdata->d_buf, symstrdata->d_size, 0));
}
#endif
INFO("\tnumber of symbols to update: %d (%d bytes)\n",
symdata->d_size / elsize, symdata->d_size);
for (inner = 0; inner < symdata->d_size / elsize; ++inner)
{
GElf_Sym sym_mem;
GElf_Sym *sym;
size_t shnum;
FAILIF_LIBELF(elf_getshnum (elf, &shnum) < 0, elf_getshnum);
sym = gelf_getsymshndx (symdata, NULL,
inner, &sym_mem, NULL);
FAILIF_LIBELF(sym == NULL, gelf_getsymshndx);
#if 0 /* DEBUG */
if (shdr_info[i].shdr.sh_type == SHT_SYMTAB) {
PRINT("%8d: name %d info %02x other %02x shndx %d size %lld value %lld\n",
inner,
sym->st_info,
sym->st_name,
sym->st_other,
sym->st_shndx,
sym->st_size,
sym->st_value);
}
#endif
size_t scnidx = sym->st_shndx;
FAILIF(scnidx == SHN_XINDEX,
"Can't handle SHN_XINDEX!\n");
char *symname = NULL;
{
#if ELF_STRPTR_IS_BROKEN
Elf_Scn *symstrscn = elf_getscn(newelf, shdr_info[i].shdr.sh_link);
ASSERT(symstrscn);
Elf_Data *symstrdata = elf_getdata(symstrscn, NULL);
ASSERT(symstrdata);
symname = symstrdata->d_buf + sym->st_name;
#else
symname = elf_strptr(newelf,
shdr_info[i].shdr.sh_link,
sym->st_name);
#endif
}
extern int verbose_flag;
if (unlikely(verbose_flag))
{
int c, max = 40;
INFO("%-8d [", inner);
for (c=0; c<max-1; c++) {
if (symname[c]) {
INFO("%c", symname[c]);
}
else break;
}
if (c < max-1) {
while (c++ < max) INFO(" ");
}
else INFO("<");
INFO("]");
} /* if (unlikely(verbose_flag)) */
/* Notice that shdr_info[] is an array whose indices correspond
to the section indices in the original ELF file. Of those
sections, some have been discarded, and one is moved to the
end of the file--this is section .shstrtab. Of course, no
symbol refers to this section, so it is safe for us to
address sections by their original indices in the
shdr_info[] array directly.
*/
/* Note that we do not skip over the STT_SECTION symbols. Since
they contain the addresses of sections, we update their
values as well.
*/
if (scnidx == SHN_UNDEF) {
INFO(" undefined\n");
continue;
}
if (scnidx >= shnum ||
(scnidx >= SHN_LORESERVE &&
scnidx <= SHN_HIRESERVE))
{
INFO(" special (scn %d, value 0x%llx, size %lld)\n",
scnidx,
sym->st_value,
sym->st_size);
/* We shouldn't be messing with these symbols, but they are
often absolute symbols that encode the starting address
or the ending address of some section. As a heuristic,
we will check to see if the value of the symbol matches
the start or the end of any section, and if so, we will
update it, but only if --shady is enabled.
*/
if (shady && sym->st_value) {
size_t scnidx;
/* Is it the special symbol _DYNAMIC? */
if (!strcmp(symname, "_DYNAMIC")) {
/* The _DYNAMIC symbol points to the DYNAMIC
segment. It is used by linker to bootstrap
itself. */
ASSERT(dynamic_idx >= 0);
PRINT("*** SHADY *** symbol %s: "
"new st_value = %lld (was %lld), "
"st_size = %lld (was %lld)\n",
symname,
shdr_info[dynamic_idx].shdr.sh_addr,
sym->st_value,
shdr_info[dynamic_idx].shdr.sh_size,
sym->st_size);
sym->st_value =
shdr_info[dynamic_idx].shdr.sh_addr;
sym->st_size =
shdr_info[dynamic_idx].shdr.sh_size;
/* NOTE: We don't update st_shndx, because this is a special
symbol. I am not sure if it's necessary though.
*/
FAILIF_LIBELF(gelf_update_symshndx(symdata,
NULL,
inner,
sym,
0) == 0,
gelf_update_symshndx);
}
else {
for (scnidx = 1; scnidx < num_shdr_info; scnidx++) {
if (sym->st_value ==
shdr_info[scnidx].old_shdr.sh_addr) {
if (shdr_info[scnidx].shdr.sh_addr !=
sym->st_value) {
PRINT("*** SHADY *** symbol %s matches old "
"start %lld of section %s, updating "
"to %lld.\n",
symname,
shdr_info[scnidx].old_shdr.sh_addr,
shdr_info[scnidx].name,
shdr_info[scnidx].shdr.sh_addr);
sym->st_value = shdr_info[scnidx].shdr.sh_addr;
}
break;
}
else {
Elf64_Addr oldaddr =
shdr_info[scnidx].old_shdr.sh_addr +
shdr_info[scnidx].old_shdr.sh_size;
if (sym->st_value == oldaddr) {
Elf64_Addr newaddr =
shdr_info[scnidx].shdr.sh_addr +
shdr_info[scnidx].shdr.sh_size;
if (newaddr != sym->st_value) {
PRINT("*** SHADY *** symbol %s matches old "
"end %lld of section %s, updating "
"to %lld.\n",
symname,
oldaddr,
shdr_info[scnidx].name,
newaddr);
sym->st_value = newaddr;
}
break;
}
}
} /* for each section... */
/* NOTE: We don't update st_shndx, because this is a special
symbol. I am not sure if it's necessary though.
*/
if (scnidx < num_shdr_info) {
FAILIF_LIBELF(gelf_update_symshndx(symdata,
NULL,
inner,
sym,
0) == 0,
gelf_update_symshndx);
}
} /* if symbol is _DYNAMIC else */
}
continue;
} /* handle special-section symbols */
/* The symbol must refer to a section which is not being
removed. */
if(shdr_info[scnidx].idx == 0)
{
FAILIF(GELF_ST_TYPE (sym->st_info) != STT_SECTION,
"Non-STT_SECTION symbol [%s] refers to section [%s],"
" which is being removed.\n",
symname,
shdr_info[scnidx].name);
INFO("STT_SECTION symbol [%s] refers to section [%s], "
"which is being removed. Skipping...\n",
symname,
shdr_info[scnidx].name);
continue;
}
INFO(" %8d %-17s ",
sym->st_shndx,
shdr_info[sym->st_shndx].name);
/* Has the section's offset (hence its virtual address,
because we set that to the same value as the offset) changed?
If so, calculate the delta and update the symbol entry.
*/
Elf64_Sxword delta;
delta =
shdr_info[scnidx].shdr.sh_offset -
shdr_info[scnidx].old_shdr.sh_offset;
Elf64_Sxword vaddr_delta;
vaddr_delta =
shdr_info[scnidx].shdr.sh_addr -
shdr_info[scnidx].old_shdr.sh_addr;
if (vaddr_delta || shdr_info[scnidx].idx != scnidx) {
if (sym->st_value)
INFO("0x%llx -> 0x%llx (delta %lld)",
sym->st_value,
sym->st_value + vaddr_delta,
vaddr_delta);
else {
INFO("(value is zero, not adjusting it)");
/* This might be a bit too paranoid, but symbols with values of
zero for which we are not adjusting the value must be in the
static-symbol section and refer to a section which is
not loaded at run time. If this assertion ever fails, figure
out why and also figure out whether the zero value should have
been adjusted, after all.
*/
ASSERT(!(shdr_info[sym->st_shndx].shdr.sh_flags & SHF_ALLOC));
ASSERT(shdr_info[i].shdr.sh_type == SHT_SYMTAB);
}
/* The section index of the symbol must coincide with
the shdr_info[] index of the section that the
symbol refers to. Since that section may have been
moved, its new setion index, which is stored in
the idx field, may have changed. However the index
of the original section must match.
*/
ASSERT(scnidx == elf_ndxscn(shdr_info[scnidx].scn));
if(unlikely(verbose_flag)) {
if (shdr_info[scnidx].idx != scnidx) {
INFO(" (updating sym->st_shndx = %lld --> %lld)\n",
sym->st_shndx,
shdr_info[scnidx].idx);
}
else INFO("(sym->st_shndx remains %lld)\n", sym->st_shndx);
}
sym->st_shndx = shdr_info[scnidx].idx;
if (sym->st_value)
sym->st_value += vaddr_delta;
FAILIF_LIBELF(gelf_update_symshndx(symdata,
NULL,
inner,
sym,
0) == 0,
gelf_update_symshndx);
}
else {
INFO(" (no change)\n");
}
} /* for each symbol */
} /* if it's a symbol table... */
} /* for each section... */
}
static void adjust_section_offset(Elf *newelf,
shdr_info_t *shdr_info,
Elf64_Sxword delta)
{
Elf_Scn *scn = elf_getscn (newelf, shdr_info->idx);
ASSERT(scn != NULL);
ASSERT(((Elf64_Sxword)shdr_info->shdr.sh_offset) + delta >= 0);
shdr_info->shdr.sh_offset += delta;
ASSERT(shdr_info->shdr.sh_addralign);
#ifdef DEBUG
/* The assumption is that the delta is calculated so that it will preserve
the alignment. Of course, we don't trust ourselves so we verify.
NOTE: The assertion below need not hold about NOBITS sections (such as
the .bss section), for which the offset in the file and the address at
which the section is to be loaded may differ.
*/
if (shdr_info->shdr.sh_type != SHT_NOBITS)
{
Elf64_Off new_offset = shdr_info->shdr.sh_offset;
new_offset += shdr_info->shdr.sh_addralign - 1;
new_offset &= ~((GElf_Off)(shdr_info->shdr.sh_addralign - 1));
ASSERT(shdr_info->shdr.sh_offset == new_offset);
}
#endif
INFO("\t\t\t\tsection offset %lld -> %lld%s\n",
shdr_info->old_shdr.sh_offset,
shdr_info->shdr.sh_offset,
(shdr_info->old_shdr.sh_offset ==
shdr_info->shdr.sh_offset ? " (SAME)" : ""));
/* If there is a delta for an ALLOC section, then the sections address must match the sections's offset in
the file, if that section is not marked SHT_NOBITS. For SHT_NOBITS sections, the two may differ.
Note that we compare against the old_shdr.sh_offset because we just modified shdr.sh_offset!
*/
ASSERT(!delta ||
!(shdr_info->shdr.sh_flags & SHF_ALLOC) ||
shdr_info->shdr.sh_type == SHT_NOBITS ||
shdr_info->shdr.sh_addr == shdr_info->old_shdr.sh_offset);
if ((shdr_info->shdr.sh_flags & SHF_ALLOC) == SHF_ALLOC)
{
ASSERT(shdr_info->shdr.sh_addr);
shdr_info->shdr.sh_addr += delta;
INFO("\t\t\t\tsection address %lld -> %lld%s\n",
shdr_info->old_shdr.sh_addr,
shdr_info->shdr.sh_addr,
(shdr_info->old_shdr.sh_addr ==
shdr_info->shdr.sh_addr ? " (SAME)" : ""));
}
/* Set the section header in the new file. There cannot be any
overflows. */
INFO("\t\t\t\tupdating section header (size %lld)\n",
shdr_info->shdr.sh_size);
FAILIF(!gelf_update_shdr (scn, &shdr_info->shdr),
"Could not update section header for section %s!\n",
shdr_info->name);
}
#ifdef MOVE_SECTIONS_IN_RANGES
static int get_end_of_range(shdr_info_t *shdr_info,
int num_shdr_info,
int start,
Elf64_Xword *alignment,
Elf32_Word *real_align)
{
int end = start;
ASSERT(start < num_shdr_info);
/* Note that in the loop below we do not check to see if a section is
being thrown away. If a section in the middle of a range is thrown
away, that will cause the section to be removed, but it will not cause
the relative offsets of the sections in the block to be modified.
*/
*alignment = real_align[start];
while (end < num_shdr_info &&
((shdr_info[end].shdr.sh_flags & SHF_ALLOC) == SHF_ALLOC) &&
((shdr_info[end].shdr.sh_type == SHT_PROGBITS) ||
(shdr_info[end].shdr.sh_type == SHT_INIT_ARRAY) ||
(shdr_info[end].shdr.sh_type == SHT_FINI_ARRAY) ||
(shdr_info[end].shdr.sh_type == SHT_PREINIT_ARRAY) ||
/* (shdr_info[end].shdr.sh_type == SHT_NOBITS) || */
#ifdef ARM_SPECIFIC_HACKS
/* SHF_ALLOC sections with with names starting with ".ARM." are
part of the ARM EABI extensions to ELF.
*/
!strncmp(shdr_info[end].name, ".ARM.", 5) ||
#endif
(shdr_info[end].shdr.sh_type == SHT_DYNAMIC)))
{
if (real_align[end] > *alignment) {
*alignment = real_align[end];
}
end++;
}
return end == start ? end + 1 : end;
}
#endif/*MOVE_SECTIONS_IN_RANGES*/
static GElf_Off update_last_offset(shdr_info_t *shdr_info,
range_list_t *section_ranges,
GElf_Off offset)
{
GElf_Off filesz = 0;
if (shdr_info->shdr.sh_type != SHT_NOBITS) {
/* This function is used as an assertion: if the range we are
adding conflicts with another range already in the list,
then add_unique_range() will call FAILIF().
*/
add_unique_range_nosort(section_ranges,
shdr_info->shdr.sh_offset,
shdr_info->shdr.sh_size,
shdr_info,
handle_range_error,
NULL);
filesz = shdr_info->shdr.sh_size;
}
/* Remember the last section written so far. */
if (offset < shdr_info->shdr.sh_offset + filesz) {
offset = shdr_info->shdr.sh_offset + filesz;
INFO("\t\t\t\tupdated lastoffset to %lld\n", offset);
}
return offset;
}
static GElf_Off move_sections(Elf *newelf,
shdr_info_t *shdr_info,
int num_shdr_info,
int start,
int end,
GElf_Off offset,
Elf64_Xword alignment,
range_list_t *section_ranges,
bool adjust_alloc_section_offsets)
{
/* The alignment parameter is expected to contain the largest alignment of
all sections in the block. Thus, when we iterate over all sections in
the block and apply the same offset to them, we are guaranteed to
preserve (a) the relative offsets between the sections in the block and
(b) the alignment requirements of each individual section.
*/
ASSERT(start < num_shdr_info);
ASSERT(end <= num_shdr_info);
Elf64_Sxword delta = offset - shdr_info[start].shdr.sh_offset;
delta += (alignment - 1);
delta &= ~(alignment - 1);
while (start < end) {
if (shdr_info[start].idx > 0) {
if (adjust_alloc_section_offsets || (shdr_info[start].shdr.sh_flags & SHF_ALLOC) != SHF_ALLOC) {
INFO("\t\t\t%03d:\tAdjusting offset of section %s "
"(index %d) from 0x%llx (%lld) to 0x%llx (%lld) (DELTA %lld)...\n",
start,
(shdr_info[start].name ?: "(no name)"),
shdr_info[start].idx,
shdr_info[start].old_shdr.sh_offset, shdr_info[start].old_shdr.sh_offset,
offset, offset,
delta);
/* Compute the new offset of the section. */
adjust_section_offset(newelf, shdr_info + start, delta);
}
else {
INFO("\t\t\t%03d: NOT adjusting offset of section %s (index %d)"
": (not moving SHF_ALLOC sections)...\n",
start,
(shdr_info[start].name ?: "(no name)"),
shdr_info[start].idx);
}
offset = update_last_offset(shdr_info + start,
section_ranges,
offset);
} /* if (shdr_info[start].idx > 0) */
else {
INFO("\t\t\t%03d: NOT adjusting offset of section %s (index %d)"
" (ignored)...\n",
start,
(shdr_info[start].name ?: "(no name)"),
shdr_info[start].idx);
}
start++;
}
sort_ranges(section_ranges);
return offset;
}
/* Compute the alignments of sections with consideration of segment
alignments. Returns an array of Elf32_Word containing the alignment
of sections. Callee is responsible to deallocate the array after use. */
Elf32_Word *
get_section_real_align (GElf_Ehdr *ehdr, GElf_Phdr *phdr_info,
struct shdr_info_t *shdr_info, int shdr_info_len)
{
size_t max_align_array_size;
Elf32_Word *max_align;
size_t first_section;
bool propagate_p;
int si, pi;
max_align_array_size = sizeof(Elf32_Word) * shdr_info_len;
max_align = (Elf32_Word*) malloc (max_align_array_size);
FAILIF(!max_align, "malloc(%zu) failed.\n", max_align_array_size);
/* Initialize alignment array. */
max_align[0] = 0;
for (si = 1; si < shdr_info_len; si++)
max_align[si] = shdr_info[si].shdr.sh_addralign;
/* Determine which sections need to be aligned with the alignment of
containing segments. Becasue the first section in a segment may
be deleted, we need to look at all sections and compare their offsets.
*/
for (pi = 0; pi < ehdr->e_phnum; ++pi) {
/* Skip null segment. */
if (phdr_info[pi].p_type == PT_NULL)
continue;
/* Look for the first non-deleted section of a segment in output.
We assume asections are sorted by offsets. Also check to see if
a segment starts with a section. We only want to propagate
alignment if the segment starts with a section. */
propagate_p = false;
first_section = 0;
for (si = 1; si < shdr_info_len && first_section == 0; si++) {
if (shdr_info[si].old_shdr.sh_offset == phdr_info[pi].p_offset)
propagate_p = true;
if (shdr_info[si].idx > 0
&& section_belongs_to_header(&shdr_info[si].old_shdr,
&phdr_info[pi]))
first_section = si;
}
if (!propagate_p || first_section == 0)
continue;
/* Adjust alignment of first section. Note that a section can appear
in multiple segments. We only need the extra alignment if the
section's alignment is smaller than that of the segment. */
if (first_section != 0 &&
max_align[first_section] < phdr_info[pi].p_align) {
max_align[first_section] = phdr_info[pi].p_align;
}
}
return max_align;
}
static range_list_t *
update_section_offsets(Elf *elf,
Elf *newelf,
GElf_Phdr *phdr_info,
shdr_info_t *shdr_info,
int num_shdr_info,
range_list_t *section_ranges,
bool adjust_alloc_section_offsets)
{
Elf32_Word *real_align;
ASSERT(section_ranges);
INFO("Updating section addresses and offsets...\n");
/* The initial value of lastoffset is set to the size of the ELF header
plus the size of the program-header table. libelf seems to always
place the program-header table for a new file immediately after the
ELF header itself... or I could not find any other way to change it
otherwise.
*/
GElf_Ehdr ehdr_mem, *ehdr;
ehdr = gelf_getehdr (elf, &ehdr_mem);
FAILIF_LIBELF(NULL == ehdr, gelf_getehdr);
const size_t ehdr_size = gelf_fsize (elf, ELF_T_EHDR, 1, EV_CURRENT);
FAILIF(ehdr->e_phoff != ehdr_size,
"Expecting the program-header table to follow the ELF header"
" immediately!\n");
GElf_Off lastoffset = 0;
lastoffset += ehdr_size;
lastoffset += ehdr->e_phnum * ehdr->e_phentsize;
INFO("Section offsets will start from %lld.\n", lastoffset);
int start = 1, end = 1;
ASSERT(num_shdr_info > 0);
real_align = get_section_real_align (ehdr, phdr_info, shdr_info,
num_shdr_info);
while (end < num_shdr_info) {
Elf64_Xword alignment;
/* end is the index one past the last section of the block. */
#ifdef MOVE_SECTIONS_IN_RANGES
end = get_end_of_range(shdr_info, num_shdr_info,
start, &alignment, real_align);
#else
end = start + 1;
alignment = real_align[start];
#endif
INFO("\tAdjusting sections [%d - %d) as a group (start offset %lld, alignment %lld)\n",
start, end, lastoffset, alignment);
lastoffset = move_sections(newelf,
shdr_info,
num_shdr_info,
start, end,
lastoffset,
alignment,
section_ranges,
adjust_alloc_section_offsets);
start = end;
}
ASSERT(lastoffset == get_last_address(section_ranges));
free (real_align);
return section_ranges;
}
void handle_range_error(range_error_t err, range_t *left, range_t *right)
{
shdr_info_t *info_l = (shdr_info_t *)left->user;
shdr_info_t *info_r = (shdr_info_t *)right->user;
ASSERT(info_l);
ASSERT(info_r);
switch (err) {
case ERROR_CONTAINS:
ERROR("ERROR: section [%s] (%lld, %lld bytes) contains "
"section [%s] (%lld, %lld bytes)\n",
info_l->name,
left->start, left->length,
info_r->name,
right->start, right->length);
break;
case ERROR_OVERLAPS:
ERROR("ERROR: Section [%s] (%lld, %lld bytes) intersects "
"section [%s] (%lld, %lld bytes)\n",
info_l->name,
left->start, left->length,
info_r->name,
right->start, right->length);
break;
default:
ASSERT(!"Unknown range error code!");
}
FAILIF(1, "Range error.\n");
}
#ifdef DEBUG
/* Functions to ELF file is still sane after adjustment. */
static bool
sections_overlap_p (GElf_Shdr *s1, GElf_Shdr *s2)
{
GElf_Addr a1, a2;
GElf_Off o1, o2;
if ((s1->sh_flags & s2->sh_flags & SHF_ALLOC) != 0) {
a1 = (s1->sh_addr > s2->sh_addr)? s1->sh_addr : s2->sh_addr;
a2 = ((s1->sh_addr + s1->sh_size < s2->sh_addr + s2->sh_size)?
(s1->sh_addr + s1->sh_size) : (s2->sh_addr + s2->sh_size));
if (a1 < a2)
return true;
}
if (s1->sh_type != SHT_NOBITS && s2->sh_type != SHT_NOBITS) {
o1 = (s1->sh_offset > s2->sh_offset)? s1->sh_offset : s2->sh_offset;
o2 = ((s1->sh_offset + s1->sh_size < s2->sh_offset + s2->sh_size)?
(s1->sh_offset + s1->sh_size) : (s2->sh_offset + s2->sh_size));
if (o1 < o2)
return true;
}
return false;
}
/* Return size of the overlapping portion of section S and segment P
in memory. */
static GElf_Word
mem_overlap_size (GElf_Shdr *s, GElf_Phdr *p)
{
GElf_Addr a1, a2;
if (s->sh_flags & SHF_ALLOC) {
a1 = p->p_vaddr > s->sh_addr ? p->p_vaddr : s->sh_addr;
a2 = ((p->p_vaddr + p->p_memsz < s->sh_addr + s->sh_size) ?
(p->p_vaddr + p->p_memsz) : (s->sh_addr + s->sh_size));
if (a1 < a2) {
return a2 - a1;
}
}
return 0;
}
/* Return size of the overlapping portion of section S and segment P
in file. */
static GElf_Word
file_overlap_size (GElf_Shdr *s, GElf_Phdr *p)
{
GElf_Off o1, o2;
if (s->sh_type != SHT_NOBITS) {
o1 = p->p_offset > s->sh_offset ? p->p_offset : s->sh_offset;
o2 = ((p->p_offset + p->p_filesz < s->sh_offset + s->sh_size) ?
(p->p_offset + p->p_filesz) : (s->sh_offset + s->sh_size));
if (o1 < o2) {
return o2 - o1;
}
}
return 0;
}
/* Verify the ELF file is sane. */
static void
verify_elf(GElf_Ehdr *ehdr, struct shdr_info_t *shdr_info, int shdr_info_len,
GElf_Phdr *phdr_info)
{
int si, sj, pi;
GElf_Word addralign;
GElf_Word m_size, f_size;
/* Check all sections */
for (si = 1; si < shdr_info_len; si++) {
if (shdr_info[si].idx <= 0)
continue;
/* Check alignment */
addralign = shdr_info[si].shdr.sh_addralign;
if (addralign != 0) {
if (shdr_info[si].shdr.sh_flags & SHF_ALLOC) {
FAILIF ((addralign - 1) & shdr_info[si].shdr.sh_addr,
"Load address %llx of section %s is not "
"aligned to multiples of %u\n",
(long long unsigned) shdr_info[si].shdr.sh_addr,
shdr_info[si].name,
addralign);
}
if (shdr_info[si].shdr.sh_type != SHT_NOBITS) {
FAILIF ((addralign - 1) & shdr_info[si].shdr.sh_offset,
"Offset %lx of section %s is not "
"aligned to multiples of %u\n",
shdr_info[si].shdr.sh_offset,
shdr_info[si].name,
addralign);
}
}
/* Verify that sections do not overlap. */
for (sj = si + 1; sj < shdr_info_len; sj++) {
if (shdr_info[sj].idx <= 0)
continue;
FAILIF (sections_overlap_p (&shdr_info[si].shdr,
&shdr_info[sj].shdr),
"sections %s and %s overlap.\n", shdr_info[si].name,
shdr_info[sj].name);
}
/* Verify that section is properly contained in segments. */
for (pi = 0; pi < ehdr->e_phnum; pi++) {
if (phdr_info[pi].p_type == PT_NULL)
continue;
f_size = file_overlap_size (&shdr_info[si].shdr, &phdr_info[pi]);
m_size = mem_overlap_size (&shdr_info[si].shdr, &phdr_info[pi]);
if (f_size) {
FAILIF (shdr_info[si].shdr.sh_size > phdr_info[pi].p_filesz,
"Section %s is larger than segment %d\n",
shdr_info[si].name, pi);
FAILIF (f_size != shdr_info[si].shdr.sh_size,
"Section %s partially overlaps segment %d in file.\n",
shdr_info[si].name, pi);
}
if (m_size) {
FAILIF (shdr_info[si].shdr.sh_size > phdr_info[pi].p_memsz,
"Section %s is larger than segment %d\n",
shdr_info[si].name, pi);
FAILIF (m_size != shdr_info[si].shdr.sh_size,
"Section %s partially overlaps segment %d in memory.\n",
shdr_info[si].name, pi);
}
}
}
}
#endif /* DEBUG */