auto import from //depot/cupcake/@135843
diff --git a/tools/apriori/apriori.c b/tools/apriori/apriori.c
new file mode 100644
index 0000000..d1807b3
--- /dev/null
+++ b/tools/apriori/apriori.c
@@ -0,0 +1,2601 @@
+#include <stdio.h>
+#include <common.h>
+#include <debug.h>
+#include <libelf.h>
+#include <libebl.h>
+#ifdef ARM_SPECIFIC_HACKS
+ #include <libebl_arm.h>
+#endif/*ARM_SPECIFIC_HACKS*/
+#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>
+#include <hash.h>
+#include <apriori.h>
+#include <source.h>
+#include <tweak.h>
+#include <rangesort.h>
+#include <prelink_info.h>
+#include <prelinkmap.h>
+#include <libgen.h>
+
+#ifndef ADJUST_ELF
+#error "ADJUST_ELF must be defined!"
+#endif
+
+/* When this macro is defined, apriori sets to ZERO those relocation values for
+ which it canot find the appropriate referent.
+*/
+#define PERMISSIVE
+#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)
+
+/* When the macro below is defined, apriori does not mark for removal those
+ relocation sections that it fully handles. Instead, apriori just sets their
+ sizes to zero. This is more for debugging than of any actual use.
+
+ This macro is meaningful only when ADJUST_ELF!=0
+*/
+#define REMOVE_HANDLED_SECTIONS
+
+extern int verbose_flag;
+
+static source_t *sources = NULL;
+
+#if defined(DEBUG) && 0
+
+static void print_shdr(source_t *source, Elf_Scn *scn)
+{
+ GElf_Shdr shdr_mem, *shdr;
+ shdr = gelf_getshdr(scn, &shdr_mem);
+ Elf_Data *data = elf_getdata(scn, NULL);
+ INFO("\t%02d: data = %p, hdr = { offset = %8lld, size = %lld }, "
+ "data->d_buf = %p data->d_off = %lld, data->d_size = %d\n",
+ elf_ndxscn(scn),
+ data,
+ shdr->sh_offset, shdr->sh_size,
+ data->d_buf, data->d_off, data->d_size);
+}
+
+static void print_shdr_idx(source_t *source, Elf *elf, int idx)
+{
+ print_shdr(source, elf_getscn(elf, idx));
+}
+
+static void print_shdrs(source_t *source) {
+ Elf_Scn *scn = NULL;
+ INFO("section offset dump for new ELF\n");
+ while ((scn = elf_nextscn (source->elf, scn)) != NULL)
+ print_shdr(source, scn);
+
+ INFO("\nsection offset dump for original ELF\n");
+ while ((scn = elf_nextscn (source->oldelf, scn)) != NULL)
+ print_shdr(source, scn);
+
+#if 0
+ {
+ INFO("section offset dump for new ELF\n");
+ int i = 0;
+ for (i = 0; i < source->shnum; i++) {
+ scn = elf_getscn(source->elf, i);
+ print_shdr(source, scn);
+ }
+ }
+#endif
+}
+
+#endif /* DEBUG */
+
+static char * find_file(const char *libname,
+ char **lib_lookup_dirs,
+ int num_lib_lookup_dirs);
+
+static inline source_t* find_source(const char *name,
+ char **lib_lookup_dirs,
+ int num_lib_lookup_dirs) {
+ char *full = find_file(name, lib_lookup_dirs, num_lib_lookup_dirs);
+ if (full) {
+ source_t *trav = sources;
+ while (trav) {
+ if (!strcmp(trav->name, full))
+ break;
+ trav = trav->next;
+ }
+ free(full);
+ return trav;
+ }
+ return NULL;
+}
+
+static inline void add_to_sources(source_t *src) {
+ src->next = sources;
+ sources = src;
+}
+
+static void handle_range_error(range_error_t err,
+ range_t *left, range_t *right) {
+ switch (err) {
+ case ERROR_CONTAINS:
+ ERROR("ERROR: section (%lld, %lld bytes) contains "
+ "section (%lld, %lld bytes)\n",
+ left->start, left->length,
+ right->start, right->length);
+ break;
+ case ERROR_OVERLAPS:
+ ERROR("ERROR: Section (%lld, %lld bytes) intersects "
+ "section (%lld, %lld bytes)\n",
+ left->start, left->length,
+ right->start, right->length);
+ break;
+ default:
+ ASSERT(!"Unknown range error code!");
+ }
+
+ FAILIF(1, "Range error.\n");
+}
+
+static void create_elf_sections(source_t *source, Elf *elf)
+{
+ INFO("Creating new ELF sections.\n");
+ ASSERT(elf == NULL || source->elf == NULL || source->elf == elf);
+ if (elf == NULL) {
+ ASSERT(source->elf != NULL);
+ elf = source->elf;
+ }
+
+ int cnt = 1;
+ Elf_Scn *oldscn = NULL, *scn;
+ while ((oldscn = elf_nextscn (source->oldelf, oldscn)) != NULL) {
+ GElf_Shdr *oldshdr, oldshdr_mem;
+
+ scn = elf_newscn(elf);
+ FAILIF_LIBELF(NULL == scn, elf_newscn);
+
+ oldshdr = gelf_getshdr(oldscn, &oldshdr_mem);
+ FAILIF_LIBELF(NULL == oldshdr, gelf_getshdr);
+ /* Set the section header of the new section to be the same as the
+ headset of the old section by default. */
+ gelf_update_shdr(scn, oldshdr);
+
+ /* Copy the section data */
+ Elf_Data *olddata = elf_getdata(oldscn, NULL);
+ FAILIF_LIBELF(NULL == olddata, elf_getdata);
+
+ Elf_Data *data = elf_newdata(scn);
+ FAILIF_LIBELF(NULL == data, elf_newdata);
+ *data = *olddata;
+#if COPY_SECTION_DATA_BUFFER
+ if (olddata->d_buf != NULL) {
+ data->d_buf = MALLOC(data->d_size);
+ memcpy(data->d_buf, olddata->d_buf, olddata->d_size);
+ }
+#endif
+
+ INFO("\tsection %02d: [%-30s] created\n",
+ cnt,
+ elf_strptr(source->oldelf,
+ source->shstrndx,
+ oldshdr->sh_name));
+
+ if (ADJUST_ELF) {
+ ASSERT(source->shdr_info != NULL);
+ /* Create a new section. */
+ source->shdr_info[cnt].idx = cnt;
+ source->shdr_info[cnt].newscn = scn;
+ source->shdr_info[cnt].data = data;
+ source->shdr_info[cnt].
+ use_old_shdr_for_relocation_calculations = 1;
+ INFO("\tsection [%s] (old offset %lld, old size %lld) "
+ "will have index %d (was %d).\n",
+ source->shdr_info[cnt].name,
+ source->shdr_info[cnt].old_shdr.sh_offset,
+ source->shdr_info[cnt].old_shdr.sh_size,
+ source->shdr_info[cnt].idx,
+ elf_ndxscn(source->shdr_info[cnt].scn));
+ /* Same as the next assert */
+ ASSERT(elf_ndxscn (source->shdr_info[cnt].newscn) ==
+ source->shdr_info[cnt].idx);
+ }
+
+ ASSERT(elf_ndxscn(scn) == (size_t)cnt);
+ cnt++;
+ }
+}
+
+/* This function sets up the shdr_info[] array of a source_t. We call it only
+ when ADJUST_ELF is non-zero (i.e., support for adjusting an ELF file for
+ changes in sizes and numbers of relocation sections is compiled in. Note
+ that setup_shdr_info() depends only on the information in source->oldelf,
+ not on source->elf.
+*/
+
+static void setup_shdr_info(source_t *source)
+{
+ if (ADJUST_ELF)
+ {
+ /* Allocate the section-header-info buffer. */
+ INFO("Allocating section-header info structure (%d) bytes...\n",
+ source->shnum * sizeof (shdr_info_t));
+
+ source->shdr_info = (shdr_info_t *)CALLOC(source->shnum,
+ sizeof (shdr_info_t));
+
+ /* Mark the SHT_NULL section as handled. */
+ source->shdr_info[0].idx = 2;
+
+ int cnt = 1;
+ Elf_Scn *oldscn = NULL;
+ while ((oldscn = elf_nextscn (source->oldelf, oldscn)) != NULL) {
+ /* Copy the section header */
+ ASSERT(elf_ndxscn(oldscn) == (size_t)cnt);
+
+ /* Initialized the corresponding shdr_info entry */
+ {
+ /* Mark the section with a non-zero index. Later, when we
+ decide to drop a section, we will set its idx to zero, and
+ assign section numbers to the remaining sections.
+ */
+ source->shdr_info[cnt].idx = 1;
+
+ source->shdr_info[cnt].scn = oldscn;
+
+ /* NOTE: Here we pupulate the section-headset struct with the
+ same values as the original section's. After the
+ first run of prelink(), we will update the sh_size
+ fields of those sections that need resizing.
+ */
+ FAILIF_LIBELF(NULL ==
+ gelf_getshdr(oldscn,
+ &source->shdr_info[cnt].shdr),
+ gelf_getshdr);
+
+ /* Get the name of the section. */
+ source->shdr_info[cnt].name =
+ elf_strptr (source->oldelf, source->shstrndx,
+ source->shdr_info[cnt].shdr.sh_name);
+
+ INFO("\tname: %s\n", source->shdr_info[cnt].name);
+ FAILIF(source->shdr_info[cnt].name == NULL,
+ "Malformed file: section %d name is null\n",
+ cnt);
+
+ /* Remember the shdr.sh_link value. We need to remember this
+ value for those sections that refer to other sections. For
+ example, we need to remember it for relocation-entry
+ sections, because if we modify the symbol table that a
+ relocation-entry section is relative to, then we need to
+ patch the relocation section. By the time we get to
+ deciding whether we need to patch the relocation section, we
+ will have overwritten its header's sh_link field with a new
+ value.
+ */
+ source->shdr_info[cnt].old_shdr = source->shdr_info[cnt].shdr;
+ INFO("\t\toriginal sh_link: %08d\n",
+ source->shdr_info[cnt].old_shdr.sh_link);
+ INFO("\t\toriginal sh_addr: %lld\n",
+ source->shdr_info[cnt].old_shdr.sh_addr);
+ INFO("\t\toriginal sh_offset: %lld\n",
+ source->shdr_info[cnt].old_shdr.sh_offset);
+ INFO("\t\toriginal sh_size: %lld\n",
+ source->shdr_info[cnt].old_shdr.sh_size);
+
+ FAILIF(source->shdr_info[cnt].shdr.sh_type == SHT_SYMTAB_SHNDX,
+ "Cannot handle sh_type SHT_SYMTAB_SHNDX!\n");
+ FAILIF(source->shdr_info[cnt].shdr.sh_type == SHT_GROUP,
+ "Cannot handle sh_type SHT_GROUP!\n");
+ FAILIF(source->shdr_info[cnt].shdr.sh_type == SHT_GNU_versym,
+ "Cannot handle sh_type SHT_GNU_versym!\n");
+ }
+
+ cnt++;
+ } /* for each section */
+ } /* if (ADJUST_ELF) */
+}
+
+static Elf * init_elf(source_t *source, bool create_new_sections)
+{
+ Elf *elf;
+ if (source->output != NULL) {
+ if (source->output_is_dir) {
+ source->output_is_dir++;
+ char *dir = source->output;
+ int dirlen = strlen(dir);
+ /* The main() function maintains a pointer to source->output; it
+ frees the buffer after apriori() returns.
+ */
+ source->output = MALLOC(dirlen +
+ 1 + /* slash */
+ strlen(source->name) +
+ 1); /* null terminator */
+ strcpy(source->output, dir);
+ source->output[dirlen] = '/';
+ strcpy(source->output + dirlen + 1,
+ basename(source->name));
+ }
+
+ source->newelf_fd = open(source->output,
+ O_RDWR | O_CREAT,
+ 0666);
+ FAILIF(source->newelf_fd < 0, "open(%s): %s (%d)\n",
+ source->output,
+ strerror(errno),
+ errno);
+ elf = elf_begin(source->newelf_fd, ELF_C_WRITE, NULL);
+ FAILIF_LIBELF(elf == NULL, elf_begin);
+ } else {
+ elf = elf_clone(source->oldelf, ELF_C_EMPTY);
+ FAILIF_LIBELF(elf == NULL, elf_clone);
+ }
+
+ GElf_Ehdr *oldehdr = gelf_getehdr(source->oldelf, &source->old_ehdr_mem);
+ FAILIF_LIBELF(NULL == oldehdr, gelf_getehdr);
+
+ /* Create new ELF and program headers for the elf file */
+ INFO("Creating empty ELF and program headers...\n");
+ FAILIF_LIBELF(gelf_newehdr (elf, gelf_getclass (source->oldelf)) == 0,
+ gelf_newehdr);
+ FAILIF_LIBELF(oldehdr->e_type != ET_REL
+ && gelf_newphdr (elf,
+ oldehdr->e_phnum) == 0,
+ gelf_newphdr);
+
+ /* Copy the elf header */
+ INFO("Copying ELF header...\n");
+ GElf_Ehdr *ehdr = gelf_getehdr(elf, &source->ehdr_mem);
+ FAILIF_LIBELF(NULL == ehdr, gelf_getehdr);
+ memcpy(ehdr, oldehdr, sizeof(GElf_Ehdr));
+ FAILIF_LIBELF(!gelf_update_ehdr(elf, ehdr), gelf_update_ehdr);
+
+ /* Copy out the old program header: notice that if the ELF file does not
+ have a program header, this loop won't execute.
+ */
+ INFO("Copying ELF program header...\n");
+ {
+ int cnt;
+ source->phdr_info = (GElf_Phdr *)CALLOC(ehdr->e_phnum,
+ sizeof(GElf_Phdr));
+ for (cnt = 0; cnt < ehdr->e_phnum; ++cnt) {
+ INFO("\tRetrieving entry %d\n", cnt);
+ FAILIF_LIBELF(NULL ==
+ gelf_getphdr(source->oldelf, cnt,
+ source->phdr_info + cnt),
+ gelf_getphdr);
+ FAILIF_LIBELF(gelf_update_phdr (elf, cnt,
+ source->phdr_info + cnt) == 0,
+ gelf_update_phdr);
+ }
+ }
+
+ /* Copy the sections and the section headers. */
+ if (create_new_sections)
+ {
+ create_elf_sections(source, elf);
+ }
+
+ /* The ELF library better follows our layout when this is not a
+ relocatable object file. */
+ elf_flagelf (elf, ELF_C_SET, (ehdr->e_type != ET_REL ? ELF_F_LAYOUT : 0));
+
+ return elf;
+}
+
+static shdr_info_t *lookup_shdr_info_by_new_section(
+ source_t *source,
+ const char *sname,
+ Elf_Scn *newscn)
+{
+ if (source->shdr_info == NULL) return NULL;
+ int cnt;
+ for (cnt = 0; cnt < source->shnum; cnt++) {
+ if (source->shdr_info[cnt].newscn == newscn) {
+ INFO("\t\tnew section at %p matches shdr_info[%d], "
+ "section [%s]!\n",
+ newscn,
+ cnt,
+ source->shdr_info[cnt].name);
+ FAILIF(strcmp(sname, source->shdr_info[cnt].name),
+ "Matched section's name [%s] does not match "
+ "looked-up section's name [%s]!\n",
+ source->shdr_info[cnt].name,
+ sname);
+ return source->shdr_info + cnt;
+ }
+ }
+ return NULL;
+}
+
+static bool do_init_source(source_t *source, unsigned base)
+{
+ /* Find various sections. */
+ size_t scnidx;
+ Elf_Scn *scn;
+ GElf_Shdr *shdr, shdr_mem;
+ source->sorted_sections = init_range_list();
+ INFO("Processing [%s]'s sections...\n", source->name);
+ for (scnidx = 1; scnidx < (size_t)source->shnum; scnidx++) {
+ INFO("\tGetting section index %d...\n", scnidx);
+ scn = elf_getscn(source->elf, scnidx);
+ if (NULL == scn) {
+ /* If we get an error from elf_getscn(), it means that a section
+ at the requested index does not exist. This may happen when
+ we remove sections. Since we do not update source->shnum
+ (we can't, since we need to know the original number of sections
+ to know source->shdr_info[]'s length), we will attempt to
+ retrieve a section for an index that no longer exists in the
+ new ELF file. */
+ INFO("\tThere is no section at index %d anymore, continuing.\n",
+ scnidx);
+ continue;
+ }
+ shdr = gelf_getshdr(scn, &shdr_mem);
+ FAILIF_LIBELF(NULL == shdr, gelf_getshdr);
+
+ /* We haven't modified the shstrtab section, and so shdr->sh_name
+ has the same value as before. Thus we look up the name based
+ on the old ELF handle. We cannot use shstrndx on the new ELF
+ handle because the index of the shstrtab section may have
+ changed (and calling elf_getshstrndx() returns the same section
+ index, so libelf can't handle thise ither).
+ */
+ const char *sname =
+ elf_strptr(source->oldelf, source->shstrndx, shdr->sh_name);
+ ASSERT(sname);
+
+ INFO("\tAdding [%s] (%lld, %lld)...\n",
+ sname,
+ shdr->sh_addr,
+ shdr->sh_addr + shdr->sh_size);
+ if ((shdr->sh_flags & SHF_ALLOC) == SHF_ALLOC) {
+ add_unique_range_nosort(source->sorted_sections,
+ shdr->sh_addr,
+ shdr->sh_size,
+ scn,
+ handle_range_error,
+ NULL); /* no user-data destructor */
+ }
+
+ if (shdr->sh_type == SHT_DYNSYM) {
+ source->symtab.scn = scn;
+ source->symtab.data = elf_getdata(scn, NULL);
+ FAILIF_LIBELF(NULL == source->symtab.data, elf_getdata);
+ memcpy(&source->symtab.shdr, shdr, sizeof(GElf_Shdr));
+ source->symtab.info = lookup_shdr_info_by_new_section(
+ source, sname, scn);
+ ASSERT(source->shdr_info == NULL || source->symtab.info != NULL);
+
+ /* The sh_link field of the section header of the symbol table
+ contains the index of the associated strings table. */
+ source->strtab.scn = elf_getscn(source->elf,
+ source->symtab.shdr.sh_link);
+ FAILIF_LIBELF(NULL == source->strtab.scn, elf_getscn);
+ FAILIF_LIBELF(NULL == gelf_getshdr(source->strtab.scn,
+ &source->strtab.shdr),
+ gelf_getshdr);
+ source->strtab.data = elf_getdata(source->strtab.scn, NULL);
+ FAILIF_LIBELF(NULL == source->strtab.data, elf_getdata);
+ source->strtab.info = lookup_shdr_info_by_new_section(
+ source,
+ elf_strptr(source->oldelf, source->shstrndx,
+ source->strtab.shdr.sh_name),
+ source->strtab.scn);
+ ASSERT(source->shdr_info == NULL || source->strtab.info != NULL);
+ } else if (shdr->sh_type == SHT_DYNAMIC) {
+ source->dynamic.scn = scn;
+ source->dynamic.data = elf_getdata(scn, NULL);
+ FAILIF_LIBELF(NULL == source->dynamic.data, elf_getdata);
+ memcpy(&source->dynamic.shdr, shdr, sizeof(GElf_Shdr));
+ source->dynamic.info = lookup_shdr_info_by_new_section(
+ source, sname, scn);
+ ASSERT(source->shdr_info == NULL || source->dynamic.info != NULL);
+ } else if (shdr->sh_type == SHT_HASH) {
+ source->hash.scn = scn;
+ source->hash.data = elf_getdata(scn, NULL);
+ FAILIF_LIBELF(NULL == source->hash.data, elf_getdata);
+ memcpy(&source->hash.shdr, shdr, sizeof(GElf_Shdr));
+ source->hash.info = lookup_shdr_info_by_new_section(
+ source, sname, scn);
+ ASSERT(source->shdr_info == NULL || source->hash.info != NULL);
+ } else if (shdr->sh_type == SHT_REL || shdr->sh_type == SHT_RELA) {
+ if (source->num_relocation_sections ==
+ source->relocation_sections_size) {
+ source->relocation_sections_size += 5;
+ source->relocation_sections =
+ (section_info_t *)REALLOC(source->relocation_sections,
+ source->relocation_sections_size *
+ sizeof(section_info_t));
+ }
+ section_info_t *reloc =
+ source->relocation_sections + source->num_relocation_sections;
+ reloc->scn = scn;
+ reloc->info = lookup_shdr_info_by_new_section(source, sname, scn);
+ ASSERT(source->shdr_info == NULL || reloc->info != NULL);
+ reloc->data = elf_getdata(scn, NULL);
+ FAILIF_LIBELF(NULL == reloc->data, elf_getdata);
+ memcpy(&reloc->shdr, shdr, sizeof(GElf_Shdr));
+ source->num_relocation_sections++;
+ } else if (!strcmp(sname, ".bss")) {
+ source->bss.scn = scn;
+ source->bss.data = elf_getdata(scn, NULL);
+ source->bss.info = lookup_shdr_info_by_new_section(
+ source, sname, scn);
+ ASSERT(source->shdr_info == NULL || source->bss.info != NULL);
+ /* The BSS section occupies no space in the ELF file. */
+ FAILIF_LIBELF(NULL == source->bss.data, elf_getdata)
+ FAILIF(NULL != source->bss.data->d_buf,
+ "Enexpected: section [%s] has data!",
+ sname);
+ memcpy(&source->bss.shdr, shdr, sizeof(GElf_Shdr));
+ }
+ }
+ sort_ranges(source->sorted_sections);
+
+ source->unfinished =
+ (unfinished_relocation_t *)CALLOC(source->num_relocation_sections,
+ sizeof(unfinished_relocation_t));
+
+ if (source->dynamic.scn == NULL) {
+ INFO("File [%s] does not have a dynamic section!\n", source->name);
+ /* If this is a static executable, we won't update anything. */
+ source->dry_run = 1;
+ return false;
+ }
+
+ FAILIF(source->symtab.scn == NULL,
+ "File [%s] does not have a dynamic symbol table!\n",
+ source->name);
+ FAILIF(source->hash.scn == NULL,
+ "File [%s] does not have a hash table!\n",
+ source->name);
+ FAILIF(source->hash.shdr.sh_link != elf_ndxscn(source->symtab.scn),
+ "Hash points to section %d, not to %d as expected!\n",
+ source->hash.shdr.sh_link,
+ elf_ndxscn(source->symtab.scn));
+
+ /* Now, find out how many symbols we have and allocate the array of
+ satisfied symbols.
+
+ NOTE: We don't count the number of undefined symbols here; we will
+ iterate over the symbol table later, and count them then, when it is
+ more convenient.
+ */
+ size_t symsize = gelf_fsize (source->elf,
+ ELF_T_SYM,
+ 1, source->elf_hdr.e_version);
+ ASSERT(symsize);
+
+ source->num_syms = source->symtab.data->d_size / symsize;
+ source->base = (source->oldelf_hdr.e_type == ET_DYN) ? base : 0;
+ INFO("Relink base for [%s]: 0x%lx\n", source->name, source->base);
+ FAILIF(source->base == -1,
+ "Can't prelink [%s]: it's a shared library and you did not "
+ "provide a prelink address!\n",
+ source->name);
+#ifdef SUPPORT_ANDROID_PRELINK_TAGS
+ FAILIF(source->prelinked && source->base != source->prelink_base,
+ "ERROR: file [%s] has already been prelinked for 0x%08lx. "
+ "Cannot change to 0x%08lx!\n",
+ source->name,
+ source->prelink_base,
+ source->base);
+#endif/*SUPPORT_ANDROID_PRELINK_TAGS*/
+
+ return true;
+}
+
+static source_t* init_source(const char *full_path,
+ const char *output, int is_file,
+ int base, int dry_run)
+{
+ source_t *source = (source_t *)CALLOC(1, sizeof(source_t));
+
+ ASSERT(full_path);
+ source->name = full_path;
+ source->output = output;
+ source->output_is_dir = !is_file;
+
+ source->newelf_fd = -1;
+ source->elf_fd = -1;
+ INFO("Opening %s...\n", full_path);
+ source->elf_fd =
+ open(full_path, ((dry_run || output != NULL) ? O_RDONLY : O_RDWR));
+ FAILIF(source->elf_fd < 0, "open(%s): %s (%d)\n",
+ full_path,
+ strerror(errno),
+ errno);
+
+ FAILIF(fstat(source->elf_fd, &source->elf_file_info) < 0,
+ "fstat(%s(fd %d)): %s (%d)\n",
+ source->name,
+ source->elf_fd,
+ strerror(errno),
+ errno);
+ INFO("File [%s]'s size is %lld bytes!\n",
+ source->name,
+ source->elf_file_info.st_size);
+
+ INFO("Calling elf_begin(%s)...\n", full_path);
+
+ source->oldelf =
+ elf_begin(source->elf_fd,
+ (dry_run || output != NULL) ? ELF_C_READ : ELF_C_RDWR,
+ NULL);
+ FAILIF_LIBELF(source->oldelf == NULL, elf_begin);
+
+ /* libelf can recognize COFF and A.OUT formats, but we handle only ELF. */
+ if(elf_kind(source->oldelf) != ELF_K_ELF) {
+ ERROR("Input file %s is not in ELF format!\n", full_path);
+ return NULL;
+ }
+
+ /* Make sure this is a shared library or an executable. */
+ {
+ INFO("Making sure %s is a shared library or an executable...\n",
+ full_path);
+ FAILIF_LIBELF(0 == gelf_getehdr(source->oldelf, &source->oldelf_hdr),
+ gelf_getehdr);
+ FAILIF(source->oldelf_hdr.e_type != ET_DYN &&
+ source->oldelf_hdr.e_type != ET_EXEC,
+ "%s must be a shared library (elf type is %d, expecting %d).\n",
+ full_path,
+ source->oldelf_hdr.e_type,
+ ET_DYN);
+ }
+
+#ifdef SUPPORT_ANDROID_PRELINK_TAGS
+ /* First, check to see if the file has been prelinked. */
+ source->prelinked =
+ check_prelinked(source->name,
+ source->oldelf_hdr.e_ident[EI_DATA] == ELFDATA2LSB,
+ &source->prelink_base);
+ /* Note that in the INFO() below we need to use oldelf_hdr because we
+ haven't cloned the ELF file yet, and source->elf_hdr is not defined. */
+ if (source->prelinked) {
+ PRINT("%s [%s] is already prelinked at 0x%08lx!\n",
+ (source->oldelf_hdr.e_type == ET_EXEC ?
+ "Executable" : "Shared library"),
+ source->name,
+ source->prelink_base);
+ /* Force a dry run when the file has already been prelinked */
+ source->dry_run = dry_run = 1;
+ }
+ else {
+ INFO("%s [%s] is not prelinked!\n",
+ (source->oldelf_hdr.e_type == ET_EXEC ?
+ "Executable" : "Shared library"),
+ source->name);
+ source->dry_run = dry_run;
+ }
+#endif/*SUPPORT_ANDROID_PRELINK_TAGS*/
+
+ /* Get the index of the section-header-strings-table section. */
+ FAILIF_LIBELF(elf_getshstrndx (source->oldelf, &source->shstrndx) < 0,
+ elf_getshstrndx);
+
+ FAILIF_LIBELF(elf_getshnum (source->oldelf, (size_t *)&source->shnum) < 0,
+ elf_getshnum);
+
+ /* When we have a dry run, or when ADJUST_ELF is enabled, we use
+ source->oldelf for source->elf, because the former is mmapped privately,
+ so changes to it have no effect. With ADJUST_ELF, the first run of
+ prelink() is a dry run. We will reopen the elf file for write access
+ after that dry run, before we call adjust_elf. */
+
+ source->elf = (ADJUST_ELF || source->dry_run) ?
+ source->oldelf : init_elf(source, ADJUST_ELF == 0);
+
+ FAILIF_LIBELF(0 == gelf_getehdr(source->elf, &source->elf_hdr),
+ gelf_getehdr);
+#ifdef DEBUG
+ ASSERT(!memcmp(&source->oldelf_hdr,
+ &source->elf_hdr,
+ sizeof(source->elf_hdr)));
+#endif
+
+ /* Get the EBL handling. The -g option is currently the only reason
+ we need EBL so dont open the backend unless necessary. */
+ source->ebl = ebl_openbackend (source->elf);
+ FAILIF_LIBELF(NULL == source->ebl, ebl_openbackend);
+#ifdef ARM_SPECIFIC_HACKS
+ FAILIF_LIBELF(0 != arm_init(source->elf, source->elf_hdr.e_machine,
+ source->ebl, sizeof(Ebl)),
+ arm_init);
+#endif/*ARM_SPECIFIC_HACKS*/
+
+ add_to_sources(source);
+ if (do_init_source(source, base) == false) return NULL;
+ return source;
+}
+
+/* complements do_init_source() */
+static void do_destroy_source(source_t *source)
+{
+ int cnt;
+ destroy_range_list(source->sorted_sections);
+ source->sorted_sections = NULL;
+ for (cnt = 0; cnt < source->num_relocation_sections; cnt++) {
+ FREEIF(source->unfinished[cnt].rels);
+ source->unfinished[cnt].rels = NULL;
+ source->unfinished[cnt].num_rels = 0;
+ source->unfinished[cnt].rels_size = 0;
+ }
+ if (source->jmprel.sections != NULL) {
+ destroy_range_list(source->jmprel.sections);
+ source->jmprel.sections = NULL;
+ }
+ if (source->rel.sections != NULL) {
+ destroy_range_list(source->rel.sections);
+ source->rel.sections = NULL;
+ }
+ FREE(source->unfinished); /* do_init_source() */
+ source->unfinished = NULL;
+ FREE(source->relocation_sections); /* do_init_source() */
+ source->relocation_sections = NULL;
+ source->num_relocation_sections = source->relocation_sections_size = 0;
+}
+
+static void destroy_source(source_t *source)
+{
+ /* Is this a little-endian ELF file? */
+ if (source->oldelf != source->elf) {
+ /* If it's a dynamic executable, this must not be a dry run. */
+ if (!source->dry_run && source->dynamic.scn != NULL)
+ {
+ FAILIF_LIBELF(elf_update(source->elf, ELF_C_WRITE) == -1,
+ elf_update);
+ }
+ FAILIF_LIBELF(elf_end(source->oldelf), elf_end);
+ }
+ ebl_closebackend(source->ebl);
+ FAILIF_LIBELF(elf_end(source->elf), elf_end);
+ FAILIF(close(source->elf_fd) < 0, "Could not close file %s: %s (%d)!\n",
+ source->name, strerror(errno), errno);
+ FAILIF((source->newelf_fd >= 0) && (close(source->newelf_fd) < 0),
+ "Could not close output file: %s (%d)!\n", strerror(errno), errno);
+
+#ifdef SUPPORT_ANDROID_PRELINK_TAGS
+ if (!source->dry_run) {
+ if (source->dynamic.scn != NULL &&
+ source->elf_hdr.e_type != ET_EXEC)
+ {
+ /* For some reason, trying to write directly to source->elf_fd
+ causes a "bad file descriptor" error because of something libelf
+ does. We just close the file descriptor and open a new one in
+ function setup_prelink_info() below. */
+ INFO("%s: setting up prelink tag at end of file.\n",
+ source->output ? source->output : source->name);
+ setup_prelink_info(source->output ? source->output : source->name,
+ source->elf_hdr.e_ident[EI_DATA] == ELFDATA2LSB,
+ source->base);
+ }
+ else INFO("%s: executable, NOT setting up prelink tag.\n",
+ source->name);
+ }
+#endif/*SUPPORT_ANDROID_PRELINK_TAGS*/
+
+ do_destroy_source(source);
+
+ if (source->shstrtab_data != NULL)
+ FREEIF(source->shstrtab_data->d_buf); /* adjust_elf */
+
+ FREE(source->lib_deps); /* list of library dependencies (process_file()) */
+ FREEIF(source->shdr_info); /* setup_shdr_info() */
+ FREEIF(source->phdr_info); /* init_elf() */
+ FREE(source->name); /* assigned to by init_source() */
+ /* If the output is a directory, in init_elf() we allocate a buffer where
+ we copy the directory, a slash, and the file name. Here we free that
+ buffer.
+ */
+ if (source->output_is_dir > 1) {
+ FREE(source->output);
+ }
+ FREE(source); /* init_source() */
+}
+
+static void reinit_source(source_t *source)
+{
+ do_destroy_source(source);
+ do_init_source(source, source->base);
+
+ {
+ /* We've gathered all the DT_DYNAMIC entries; now we need to figure
+ out which relocation sections fit in which range as described by
+ the entries. Before we do so, however, we will populate the
+ jmprel and rel members of source, as well as their sizes.
+ */
+
+ size_t dynidx, numdyn;
+ GElf_Dyn *dyn, dyn_mem;
+
+ numdyn = source->dynamic.shdr.sh_size /
+ source->dynamic.shdr.sh_entsize;
+
+ source->rel.idx = source->rel.sz_idx = -1;
+ source->jmprel.idx = source->jmprel.sz_idx = -1;
+ for (dynidx = 0; dynidx < numdyn; dynidx++) {
+ dyn = gelf_getdyn (source->dynamic.data,
+ dynidx,
+ &dyn_mem);
+ FAILIF_LIBELF(NULL == dyn, gelf_getdyn);
+ switch (dyn->d_tag)
+ {
+ case DT_NEEDED:
+ break;
+ case DT_JMPREL:
+ INFO("reinit_source: DT_JMPREL is at index %d, 0x%08llx.\n",
+ dynidx, dyn->d_un.d_ptr);
+ source->jmprel.idx = dynidx;
+ source->jmprel.addr = dyn->d_un.d_ptr;
+ break;
+ case DT_PLTRELSZ:
+ INFO("reinit_source: DT_PLTRELSZ is at index %d, 0x%08llx.\n",
+ dynidx, dyn->d_un.d_val);
+ source->jmprel.sz_idx = dynidx;
+ source->jmprel.size = dyn->d_un.d_val;
+ break;
+ case DT_REL:
+ INFO("reinit_source: DT_REL is at index %d, 0x%08llx.\n",
+ dynidx, dyn->d_un.d_ptr);
+ source->rel.idx = dynidx;
+ source->rel.addr = dyn->d_un.d_ptr;
+ break;
+ case DT_RELSZ:
+ INFO("reinit_source: DT_RELSZ is at index %d, 0x%08llx.\n",
+ dynidx, dyn->d_un.d_val);
+ source->rel.sz_idx = dynidx;
+ source->rel.size = dyn->d_un.d_val;
+ break;
+ case DT_RELA:
+ case DT_RELASZ:
+ FAILIF(1, "Can't handle DT_RELA and DT_RELASZ entries!\n");
+ break;
+ } /* switch */
+ } /* for each dynamic entry... */
+ }
+}
+
+static GElf_Sym *hash_lookup_global_or_weak_symbol(source_t *lib,
+ const char *symname,
+ GElf_Sym *lib_sym_mem)
+{
+ int lib_symidx = hash_lookup(lib->elf,
+ lib->hash.data,
+ lib->symtab.data,
+ lib->strtab.data,
+ symname);
+
+ GElf_Sym sym_mem;
+ if (SHN_UNDEF != lib_symidx) {
+ /* We found the symbol--now check to see if it is global
+ or weak. If this is the case, then the symbol satisfies
+ the dependency. */
+ GElf_Sym *lib_sym = gelf_getsymshndx(lib->symtab.data,
+ NULL,
+ lib_symidx,
+ &sym_mem,
+ NULL);
+ FAILIF_LIBELF(NULL == lib_sym, gelf_getsymshndx);
+#if ELF_STRPTR_IS_BROKEN
+ ASSERT(!strcmp(
+ symname,
+ ((char *)elf_getdata(elf_getscn(lib->elf,
+ lib->symtab.shdr.sh_link),
+ NULL)->d_buf) +
+ lib_sym->st_name));
+#else
+ ASSERT(!strcmp(
+ symname,
+ elf_strptr(lib->elf, lib->symtab.shdr.sh_link,
+ lib_sym->st_name)));
+#endif
+ if (lib_sym->st_shndx != SHN_UNDEF &&
+ (GELF_ST_BIND(lib_sym->st_info) == STB_GLOBAL ||
+ GELF_ST_BIND(lib_sym->st_info) == STB_WEAK)) {
+ memcpy(lib_sym_mem, &sym_mem, sizeof(GElf_Sym));
+ return lib_sym;
+ }
+ }
+
+ return NULL;
+}
+
+static source_t *lookup_symbol_in_dependencies(source_t *source,
+ const char *symname,
+ GElf_Sym *found_sym)
+{
+ source_t *sym_source = NULL; /* return value */
+
+ /* This is an undefined symbol. Go over the list of libraries
+ and look it up. */
+ size_t libidx;
+ int found = 0;
+ source_t *last_found = NULL;
+ for (libidx = 0; libidx < (size_t)source->num_lib_deps; libidx++) {
+ source_t *lib = source->lib_deps[libidx];
+ if (hash_lookup_global_or_weak_symbol(lib, symname, found_sym) != NULL)
+ {
+ sym_source = lib;
+ if (found) {
+ if (found == 1) {
+ found++;
+ ERROR("ERROR: multiple definitions found for [%s:%s]!\n",
+ source->name, symname);
+ ERROR("\tthis definition [%s]\n", lib->name);
+ }
+ ERROR("\tprevious definition [%s]\n", last_found->name);
+ }
+ last_found = lib;
+ if (!found) found = 1;
+ }
+ }
+
+#if ELF_STRPTR_IS_BROKEN
+ ASSERT(!sym_source ||
+ !strcmp(symname,
+ (char *)(elf_getdata(elf_getscn(
+ sym_source->elf,
+ sym_source->symtab.shdr.sh_link),
+ NULL)->d_buf) +
+ found_sym->st_name));
+#else
+ ASSERT(!sym_source ||
+ !strcmp(symname,
+ elf_strptr(sym_source->elf,
+ sym_source->symtab.shdr.sh_link,
+ found_sym->st_name)));
+#endif
+
+ return sym_source;
+}
+
+static int do_prelink(source_t *source,
+ Elf_Data *reloc_scn_data,
+ int reloc_scn_entry_size,
+ unfinished_relocation_t *unfinished,
+ int locals_only,
+ bool dry_run,
+ char **lib_lookup_dirs, int num_lib_lookup_dirs,
+ char **default_libs, int num_default_libs,
+ int *num_unfinished_relocs)
+{
+ int num_relocations = 0;
+
+ size_t num_rels;
+ num_rels = reloc_scn_data->d_size / reloc_scn_entry_size;
+
+ INFO("\tThere are %d relocations.\n", num_rels);
+
+ int rel_idx;
+ for (rel_idx = 0; rel_idx < (size_t)num_rels; rel_idx++) {
+ GElf_Rel *rel, rel_mem;
+
+ //INFO("\tHandling relocation %d/%d\n", rel_idx, num_rels);
+
+ rel = gelf_getrel(reloc_scn_data, rel_idx, &rel_mem);
+ FAILIF_LIBELF(rel == NULL, gelf_getrel);
+ GElf_Sym *sym = NULL, sym_mem;
+ unsigned sym_idx = GELF_R_SYM(rel->r_info);
+ source_t *sym_source = NULL;
+ /* found_sym points to found_sym_mem, when sym_source != NULL, and
+ to sym, when the sybmol is locally defined. If the symbol is
+ not locally defined and sym_source == NULL, then sym is not
+ defined either. */
+ GElf_Sym *found_sym = NULL, found_sym_mem;
+ const char *symname = NULL;
+ int sym_is_local = 1;
+ if (sym_idx) {
+ sym = gelf_getsymshndx(source->symtab.data,
+ NULL,
+ sym_idx,
+ &sym_mem,
+ NULL);
+ FAILIF_LIBELF(NULL == sym, gelf_getsymshndx);
+#if ELF_STRPTR_IS_BROKEN
+ symname =
+ ((char *)source->strtab.data->d_buf) +
+ sym->st_name;
+#else
+ symname = elf_strptr(source->elf,
+ elf_ndxscn(source->strtab.scn),
+ sym->st_name);
+#endif
+
+ /* If the symbol is defined and is either not in the BSS
+ section, or if it is in the BSS then the relocation is
+ not a copy relocation, then the symbol's source is this
+ library (i.e., it is locally-defined). Otherwise, the
+ symbol is imported.
+ */
+
+ sym_is_local = 0;
+ if (sym->st_shndx != SHN_UNDEF &&
+ (source->bss.scn == NULL ||
+ sym->st_shndx != elf_ndxscn(source->bss.scn) ||
+#ifdef ARM_SPECIFIC_HACKS
+ GELF_R_TYPE(rel->r_info) != R_ARM_COPY
+#else
+ 1
+#endif
+ ))
+ {
+ sym_is_local = 1;
+ }
+
+ if (sym_is_local) {
+ INFO("\t\tSymbol [%s:%s] is defined locally.\n",
+ source->name,
+ symname);
+ sym_source = source;
+ found_sym = sym;
+ }
+ else if (!locals_only) {
+ sym_source = lookup_symbol_in_dependencies(source,
+ symname,
+ &found_sym_mem);
+
+ /* The symbol was not in the list of dependencies, which by
+ itself is an error: it means either that the symbol does
+ not exist anywhere, or that the library which has the symbol
+ has not been listed as a dependency in this library or
+ executable. It could also mean (for a library) that the
+ symbol is defined in the executable that links agsinst it,
+ which is obviously not a good thing. These are bad things,
+ but they do happen, which is why we have the ability to
+ provide a list of default dependencies, including
+ executables. Here we check to see if the symbol has been
+ defined in any of them.
+ */
+ if (NULL == sym_source) {
+ INFO("\t\tChecking default dependencies...\n");
+ int i;
+ source_t *lib, *old_sym_source = NULL;
+ int printed_initial_error = 0;
+ for (i = 0; i < num_default_libs; i++) {
+ INFO("\tChecking in [%s].\n", default_libs[i]);
+ lib = find_source(default_libs[i],
+ lib_lookup_dirs,
+ num_lib_lookup_dirs);
+ FAILIF(NULL == lib,
+ "Can't find default library [%s]!\n",
+ default_libs[i]);
+ if (hash_lookup_global_or_weak_symbol(lib,
+ symname,
+ &found_sym_mem)) {
+ found_sym = &found_sym_mem;
+ sym_source = lib;
+#if ELF_STRPTR_IS_BROKEN
+ ASSERT(!strcmp(symname,
+ (char *)(elf_getdata(
+ elf_getscn(
+ sym_source->elf,
+ sym_source->symtab.
+ shdr.sh_link),
+ NULL)->d_buf) +
+ found_sym->st_name));
+#else
+ ASSERT(!strcmp(symname,
+ elf_strptr(sym_source->elf,
+ sym_source->symtab.shdr.sh_link,
+ found_sym->st_name)));
+
+#endif
+ INFO("\tFound symbol [%s] in [%s]!\n",
+ symname, lib->name);
+ if (old_sym_source) {
+ if (printed_initial_error == 0) {
+ printed_initial_error = 1;
+ ERROR("Multiple definition of [%s]:\n"
+ "\t[%s]\n",
+ symname,
+ old_sym_source->name);
+ }
+ ERROR("\t[%s]\n", sym_source->name);
+ }
+ old_sym_source = sym_source;
+ } else {
+ INFO("\tCould not find symbol [%s] in default "
+ "lib [%s]!\n", symname, lib->name);
+ }
+ }
+ if (sym_source) {
+ ERROR("ERROR: Could not find [%s:%s] in dependent "
+ "libraries (but found in default [%s])!\n",
+ source->name,
+ symname,
+ sym_source->name);
+ }
+ } else {
+ found_sym = &found_sym_mem;
+ /* We found the symbol in a dependency library. */
+ INFO("\t\tSymbol [%s:%s, value %lld] is imported from [%s]\n",
+ source->name,
+ symname,
+ found_sym->st_value,
+ sym_source->name);
+ }
+ } /* if symbol is defined in this library... */
+
+ if (!locals_only) {
+ /* If a symbol is weak and we haven't found it, then report
+ an error. We really need to find a way to set its value
+ to zero. The problem is that it needs to refer to some
+ section. */
+
+ FAILIF(NULL == sym_source &&
+ GELF_ST_BIND(sym->st_info) == STB_WEAK,
+ "Cannot handle weak symbols yet (%s:%s <- %s).\n",
+ source->name,
+ symname,
+ sym_source->name);
+#ifdef PERMISSIVE
+ if (GELF_ST_BIND(sym->st_info) != STB_WEAK &&
+ NULL == sym_source) {
+ ERROR("ERROR: Can't find symbol [%s:%s] in dependent or "
+ "default libraries!\n", source->name, symname);
+ }
+#else
+ FAILIF(GELF_ST_BIND(sym->st_info) != STB_WEAK &&
+ NULL == sym_source,
+ "Can't find symbol [%s:%s] in dependent or default "
+ "libraries!\n",
+ source->name,
+ symname);
+#endif
+ } /* if (!locals_only) */
+ }
+#if 0 // too chatty
+ else
+ INFO("\t\tno symbol is associated with this relocation\n");
+#endif
+
+
+ // We prelink only local symbols when locals_only == 1.
+
+ bool can_relocate = true;
+ if (!sym_is_local &&
+ (symname[0] == 'd' && symname[1] == 'l' && symname[2] != '\0' &&
+ (!strcmp(symname + 2, "open") ||
+ !strcmp(symname + 2, "close") ||
+ !strcmp(symname + 2, "sym") ||
+ !strcmp(symname + 2, "error")))) {
+ INFO("********* NOT RELOCATING LIBDL SYMBOL [%s]\n", symname);
+ can_relocate = false;
+ }
+
+ if (can_relocate && (sym_is_local || !locals_only))
+ {
+ GElf_Shdr shdr_mem; Elf_Scn *scn; Elf_Data *data;
+ find_section(source, rel->r_offset, &scn, &shdr_mem, &data);
+ unsigned *dest =
+ (unsigned*)(((char *)data->d_buf) +
+ (rel->r_offset - shdr_mem.sh_addr));
+ unsigned rel_type = GELF_R_TYPE(rel->r_info);
+ char buf[64];
+ INFO("\t\t%-15s ",
+ ebl_reloc_type_name(source->ebl,
+ GELF_R_TYPE(rel->r_info),
+ buf,
+ sizeof(buf)));
+
+ /* Section-name offsets do not change, so we use oldelf to get the
+ strings. This makes a difference in the second pass of the
+ perlinker, after the call to adjust_elf, because
+ source->shstrndx no longer contains the index of the
+ section-header-strings table.
+ */
+ const char *sname = elf_strptr(
+ source->oldelf, source->shstrndx, shdr_mem.sh_name);
+
+ switch (rel_type) {
+ case R_ARM_JUMP_SLOT:
+ case R_ARM_GLOB_DAT:
+ case R_ARM_ABS32:
+ ASSERT(data->d_buf != NULL);
+ ASSERT(data->d_size >= rel->r_offset - shdr_mem.sh_addr);
+#ifdef PERMISSIVE
+ if (sym_source == NULL) {
+ ERROR("ERROR: Permissive relocation "
+ "[%-15s] [%s:%s]: [0x%llx] = ZERO\n",
+ ebl_reloc_type_name(source->ebl,
+ GELF_R_TYPE(rel->r_info),
+ buf,
+ sizeof(buf)),
+ sname,
+ symname,
+ rel->r_offset);
+ if (!dry_run)
+ *dest = 0;
+ } else
+#endif
+ {
+ ASSERT(sym_source);
+ INFO("[%s:%s]: [0x%llx] = 0x%llx + 0x%lx\n",
+ sname,
+ symname,
+ rel->r_offset,
+ found_sym->st_value,
+ sym_source->base);
+ if (!dry_run)
+ *dest = found_sym->st_value + sym_source->base;
+ }
+ num_relocations++;
+ break;
+ case R_ARM_RELATIVE:
+ ASSERT(data->d_buf != NULL);
+ ASSERT(data->d_size >= rel->r_offset - shdr_mem.sh_addr);
+ FAILIF(sym != NULL,
+ "Unsupported RELATIVE form (symbol != 0)...\n");
+ INFO("[%s:%s]: [0x%llx] = 0x%x + 0x%lx\n",
+ sname,
+ symname ?: "(symbol has no name)",
+ rel->r_offset, *dest, source->base);
+ if (!dry_run)
+ *dest += source->base;
+ num_relocations++;
+ break;
+ case R_ARM_COPY:
+#ifdef PERMISSIVE
+ if (sym_source == NULL) {
+ ERROR("ERROR: Permissive relocation "
+ "[%-15s] [%s:%s]: NOT PERFORMING\n",
+ ebl_reloc_type_name(source->ebl,
+ GELF_R_TYPE(rel->r_info),
+ buf,
+ sizeof(buf)),
+ sname,
+ symname);
+ } else
+#endif
+ {
+ ASSERT(sym);
+ ASSERT(sym_source);
+ GElf_Shdr src_shdr_mem;
+ Elf_Scn *src_scn;
+ Elf_Data *src_data;
+ find_section(sym_source, found_sym->st_value,
+ &src_scn,
+ &src_shdr_mem,
+ &src_data);
+ INFO("Found [%s:%s (%lld)] in section [%s] .\n",
+ sym_source->name,
+ symname,
+ found_sym->st_value,
+#if ELF_STRPTR_IS_BROKEN
+ (((char *)elf_getdata(
+ elf_getscn(sym_source->elf,
+ sym_source->shstrndx),
+ NULL)->d_buf) + src_shdr_mem.sh_name)
+#else
+ elf_strptr(sym_source->elf,
+ sym_source->shstrndx,
+ src_shdr_mem.sh_name)
+#endif
+ );
+
+ unsigned *src = NULL;
+ if (src_data->d_buf == NULL)
+ {
+#ifdef PERMISSIVE
+ if (sym_source->bss.scn == NULL ||
+ elf_ndxscn(src_scn) !=
+ elf_ndxscn(sym_source->bss.scn)) {
+ ERROR("ERROR: Permissive relocation (NULL source "
+ "not from .bss) [%-15s] [%s:%s]: "
+ "NOT PERFORMING\n",
+ ebl_reloc_type_name(source->ebl,
+ GELF_R_TYPE(rel->r_info),
+ buf,
+ sizeof(buf)),
+ sname,
+ symname);
+ }
+#endif
+ }
+ else {
+ ASSERT(src_data->d_size >=
+ found_sym->st_value - src_shdr_mem.sh_addr);
+ src = (unsigned*)(((char *)src_data->d_buf) +
+ (found_sym->st_value -
+ src_shdr_mem.sh_addr));
+ }
+ ASSERT(symname);
+ INFO("[%s:%s]: [0x%llx] <- [0x%llx] size %lld\n",
+ sname,
+ symname, rel->r_offset,
+ found_sym->st_value,
+ found_sym->st_size);
+
+#ifdef PERMISSIVE
+ if (src_data->d_buf != NULL ||
+ (sym_source->bss.scn != NULL &&
+ elf_ndxscn(src_scn) ==
+ elf_ndxscn(sym_source->bss.scn)))
+#endif/*PERMISSIVE*/
+ {
+ if (data->d_buf == NULL) {
+ INFO("Incomplete relocation [%-15s] of [%s:%s].\n",
+ ebl_reloc_type_name(source->ebl,
+ GELF_R_TYPE(rel->r_info),
+ buf,
+ sizeof(buf)),
+ sname,
+ symname);
+ FAILIF(unfinished == NULL,
+ "You passed unfinished as NULL expecting "
+ "to handle all relocations, "
+ "but at least one cannot be handled!\n");
+ if (unfinished->num_rels == unfinished->rels_size) {
+ unfinished->rels_size += 10;
+ unfinished->rels = (GElf_Rel *)REALLOC(
+ unfinished->rels,
+ unfinished->rels_size *
+ sizeof(GElf_Rel));
+ }
+ unfinished->rels[unfinished->num_rels++] = *rel;
+ num_relocations--;
+ (*num_unfinished_relocs)++;
+ }
+ else {
+ if (src_data->d_buf != NULL)
+ {
+ ASSERT(data->d_buf != NULL);
+ ASSERT(data->d_size >= rel->r_offset -
+ shdr_mem.sh_addr);
+ if (!dry_run)
+ memcpy(dest, src, found_sym->st_size);
+ }
+ else {
+ ASSERT(src == NULL);
+ ASSERT(elf_ndxscn(src_scn) ==
+ elf_ndxscn(sym_source->bss.scn));
+ if (!dry_run)
+ memset(dest, 0, found_sym->st_size);
+ }
+ }
+ }
+ num_relocations++;
+ }
+ break;
+ default:
+ FAILIF(1, "Unknown relocation type %d!\n", rel_type);
+ } // switch
+ } // relocate
+ else {
+ INFO("\t\tNot relocating symbol [%s]%s\n",
+ symname,
+ (can_relocate ? ", relocating only locals" :
+ ", which is a libdl symbol"));
+ FAILIF(unfinished == NULL,
+ "You passed unfinished as NULL expecting to handle all "
+ "relocations, but at least one cannot be handled!\n");
+ if (unfinished->num_rels == unfinished->rels_size) {
+ unfinished->rels_size += 10;
+ unfinished->rels = (GElf_Rel *)REALLOC(
+ unfinished->rels,
+ unfinished->rels_size *
+ sizeof(GElf_Rel));
+ }
+ unfinished->rels[unfinished->num_rels++] = *rel;
+ (*num_unfinished_relocs)++;
+ }
+ } // for each relocation entry
+
+ return num_relocations;
+}
+
+static int prelink(source_t *source,
+ int locals_only,
+ bool dry_run,
+ char **lib_lookup_dirs, int num_lib_lookup_dirs,
+ char **default_libs, int num_default_libs,
+ int *num_unfinished_relocs)
+{
+ INFO("Prelinking [%s] (number of relocation sections: %d)%s...\n",
+ source->name, source->num_relocation_sections,
+ (dry_run ? " (dry run)" : ""));
+ int num_relocations = 0;
+ int rel_scn_idx;
+ for (rel_scn_idx = 0; rel_scn_idx < source->num_relocation_sections;
+ rel_scn_idx++)
+ {
+ section_info_t *reloc_scn = source->relocation_sections + rel_scn_idx;
+ unfinished_relocation_t *unfinished = source->unfinished + rel_scn_idx;
+
+ /* We haven't modified the shstrtab section, and so shdr->sh_name has
+ the same value as before. Thus we look up the name based on the old
+ ELF handle. We cannot use shstrndx on the new ELF handle because
+ the index of the shstrtab section may have changed (and calling
+ elf_getshstrndx() returns the same section index, so libelf can't
+ handle thise ither).
+
+ If reloc_scn->info is available, we can assert that the
+ section-name has not changed. If this assertion fails,
+ then we cannot use the elf_strptr() trick below to get
+ the section name. One solution would be to save it in
+ the section_info_t structure.
+ */
+ ASSERT(reloc_scn->info == NULL ||
+ reloc_scn->shdr.sh_name == reloc_scn->info->old_shdr.sh_name);
+ const char *sname =
+ elf_strptr(source->oldelf,
+ source->shstrndx,
+ reloc_scn->shdr.sh_name);
+ ASSERT(sname != NULL);
+
+ INFO("\n\tIterating relocation section [%s]...\n", sname);
+
+ /* In general, the new size of the section differs from the original
+ size of the section, because we can handle some of the relocations.
+ This was communicated to adjust_elf, which modified the ELF file
+ according to the new section sizes. Now, when prelink() does the
+ actual work of prelinking, it needs to know the original size of the
+ relocation section so that it can see all of the original relocation
+ entries!
+ */
+ size_t d_size = reloc_scn->data->d_size;
+ if (reloc_scn->info != NULL &&
+ reloc_scn->data->d_size != reloc_scn->info->old_shdr.sh_size)
+ {
+ INFO("Setting size of section [%s] to from new size %d to old "
+ "size %lld temporarily (so prelinker can see all "
+ "relocations).\n",
+ reloc_scn->info->name,
+ d_size,
+ reloc_scn->info->old_shdr.sh_size);
+ reloc_scn->data->d_size = reloc_scn->info->old_shdr.sh_size;
+ }
+
+ num_relocations +=
+ do_prelink(source,
+ reloc_scn->data, reloc_scn->shdr.sh_entsize,
+ unfinished,
+ locals_only, dry_run,
+ lib_lookup_dirs, num_lib_lookup_dirs,
+ default_libs, num_default_libs,
+ num_unfinished_relocs);
+
+ if (reloc_scn->data->d_size != d_size)
+ {
+ ASSERT(reloc_scn->info != NULL);
+ INFO("Resetting size of section [%s] to %d\n",
+ reloc_scn->info->name,
+ d_size);
+ reloc_scn->data->d_size = d_size;
+ }
+ }
+
+ /* Now prelink those relocation sections which were fully handled, and
+ therefore removed. They are not a part of the
+ source->relocation_sections[] array anymore, but we can find them by
+ scanning source->shdr_info[] and looking for sections with idx == 0.
+ */
+
+ if (ADJUST_ELF && source->shdr_info != NULL) {
+ /* Walk over the shdr_info[] array to see if we've removed any
+ relocation sections. prelink() those sections as well.
+ */
+ int i;
+ for (i = 0; i < source->shnum; i++) {
+ shdr_info_t *info = source->shdr_info + i;
+ if (info->idx == 0 &&
+ (info->shdr.sh_type == SHT_REL ||
+ info->shdr.sh_type == SHT_RELA)) {
+
+ Elf_Data *data = elf_getdata(info->scn, NULL);
+ ASSERT(data->d_size == 0);
+ data->d_size = info->old_shdr.sh_size;
+
+ INFO("\n\tIterating relocation section [%s], which was "
+ "discarded (size %d, entry size %lld).\n",
+ info->name,
+ data->d_size,
+ info->old_shdr.sh_entsize);
+
+ num_relocations +=
+ do_prelink(source,
+ data, info->old_shdr.sh_entsize,
+ NULL, /* the section was fully handled */
+ locals_only, dry_run,
+ lib_lookup_dirs, num_lib_lookup_dirs,
+ default_libs, num_default_libs,
+ num_unfinished_relocs);
+
+ data->d_size = 0;
+ }
+ }
+ }
+ return num_relocations;
+}
+
+static char * find_file(const char *libname,
+ char **lib_lookup_dirs,
+ int num_lib_lookup_dirs) {
+ if (libname[0] == '/') {
+ /* This is an absolute path name--just return it. */
+ /* INFO("ABSOLUTE PATH: [%s].\n", libname); */
+ return strdup(libname);
+ } else {
+ /* First try the working directory. */
+ int fd;
+ if ((fd = open(libname, O_RDONLY)) > 0) {
+ close(fd);
+ /* INFO("FOUND IN CURRENT DIR: [%s].\n", libname); */
+ return strdup(libname);
+ } else {
+ /* Iterate over all library paths. For each path, append the file
+ name and see if there is a file at that place. If that fails,
+ bail out. */
+
+ char *name;
+ while (num_lib_lookup_dirs--) {
+ size_t lib_len = strlen(*lib_lookup_dirs);
+ /* one extra character for the slash, and another for the
+ terminating NULL. */
+ name = (char *)MALLOC(lib_len + strlen(libname) + 2);
+ strcpy(name, *lib_lookup_dirs);
+ name[lib_len] = '/';
+ strcpy(name + lib_len + 1, libname);
+ if ((fd = open(name, O_RDONLY)) > 0) {
+ close(fd);
+ /* INFO("FOUND: [%s] in [%s].\n", libname, name); */
+ return name;
+ }
+ INFO("NOT FOUND: [%s] in [%s].\n", libname, name);
+ free(name);
+ }
+ }
+ }
+ return NULL;
+}
+
+static void adjust_dynamic_segment_entry_size(source_t *source,
+ dt_rel_info_t *dyn)
+{
+ /* Update the size entry in the DT_DYNAMIC segment. */
+ GElf_Dyn *dyn_entry, dyn_entry_mem;
+ dyn_entry = gelf_getdyn(source->dynamic.data,
+ dyn->sz_idx,
+ &dyn_entry_mem);
+ FAILIF_LIBELF(NULL == dyn_entry, gelf_getdyn);
+ /* If we are calling this function to adjust the size of the dynamic entry,
+ then there should be some unfinished relocations remaining. If there
+ are none, then we should remove the entry from the dynamic section
+ altogether.
+ */
+ ASSERT(dyn->num_unfinished_relocs);
+
+ size_t relsize = gelf_fsize(source->elf,
+ ELF_T_REL,
+ 1,
+ source->elf_hdr.e_version);
+
+ if (unlikely(verbose_flag)) {
+ char buf[64];
+ INFO("Updating entry %d: [%-10s], %08llx --> %08x\n",
+ dyn->sz_idx,
+ ebl_dynamic_tag_name (source->ebl, dyn_entry->d_tag,
+ buf, sizeof (buf)),
+ dyn_entry->d_un.d_val,
+ dyn->num_unfinished_relocs * relsize);
+ }
+
+ dyn_entry->d_un.d_val = dyn->num_unfinished_relocs * relsize;
+
+ FAILIF_LIBELF(!gelf_update_dyn(source->dynamic.data,
+ dyn->sz_idx,
+ dyn_entry),
+ gelf_update_dyn);
+}
+
+static void adjust_dynamic_segment_entries(source_t *source)
+{
+ /* This function many remove entries from the dynamic segment, but it won't
+ resize the relevant section. It'll just fill the remainted with empty
+ DT entries.
+
+ FIXME: This is not guaranteed right now. If a dynamic segment does not
+ end with null DT entries, I think this will break.
+ */
+ FAILIF(source->rel.processed,
+ "More than one section matches DT_REL entry in dynamic segment!\n");
+ FAILIF(source->jmprel.processed,
+ "More than one section matches DT_JMPREL entry in "
+ "dynamic segment!\n");
+ source->rel.processed =
+ source->jmprel.processed = 1;
+
+ if (source->rel.num_unfinished_relocs > 0)
+ adjust_dynamic_segment_entry_size(source, &source->rel);
+
+ if (source->jmprel.num_unfinished_relocs > 0)
+ adjust_dynamic_segment_entry_size(source, &source->jmprel);
+
+ /* If at least one of the entries is empty, then we need to remove it. We
+ have already adjusted the size of the other.
+ */
+ if (source->rel.num_unfinished_relocs == 0 ||
+ source->jmprel.num_unfinished_relocs == 0)
+ {
+ /* We need to delete the DT_REL/DT_RELSZ and DT_PLTREL/DT_PLTRELSZ
+ entries from the dynamic segment. */
+
+ GElf_Dyn *dyn_entry, dyn_entry_mem;
+ size_t dynidx, updateidx;
+
+ size_t numdyn =
+ source->dynamic.shdr.sh_size /
+ source->dynamic.shdr.sh_entsize;
+
+ for (updateidx = dynidx = 0; dynidx < numdyn; dynidx++)
+ {
+ dyn_entry = gelf_getdyn(source->dynamic.data,
+ dynidx,
+ &dyn_entry_mem);
+ FAILIF_LIBELF(NULL == dyn_entry, gelf_getdyn);
+ if ((source->rel.num_unfinished_relocs == 0 &&
+ (dynidx == source->rel.idx ||
+ dynidx == source->rel.sz_idx)) ||
+ (source->jmprel.num_unfinished_relocs == 0 &&
+ (dynidx == source->jmprel.idx ||
+ dynidx == source->jmprel.sz_idx)))
+ {
+ if (unlikely(verbose_flag)) {
+ char buf[64];
+ INFO("\t(!)\tRemoving entry %02d: [%-10s], %08llx\n",
+ dynidx,
+ ebl_dynamic_tag_name (source->ebl, dyn_entry->d_tag,
+ buf, sizeof (buf)),
+ dyn_entry->d_un.d_val);
+ }
+ continue;
+ }
+
+ if (unlikely(verbose_flag)) {
+ char buf[64];
+ INFO("\t\tKeeping entry %02d: [%-10s], %08llx\n",
+ dynidx,
+ ebl_dynamic_tag_name (source->ebl, dyn_entry->d_tag,
+ buf, sizeof (buf)),
+ dyn_entry->d_un.d_val);
+ }
+
+ gelf_update_dyn(source->dynamic.data,
+ updateidx,
+ &dyn_entry_mem);
+ updateidx++;
+ }
+ }
+} /* adjust_dynamic_segment_entries */
+
+static bool adjust_dynamic_segment_for(source_t *source,
+ dt_rel_info_t *dyn,
+ bool adjust_section_size_only)
+{
+ bool dropped_sections = false;
+
+ /* Go over the sections that belong to this dynamic range. */
+ dyn->num_unfinished_relocs = 0;
+ if (dyn->sections) {
+ int num_scns, idx;
+ range_t *scns = get_sorted_ranges(dyn->sections, &num_scns);
+
+ INFO("\tdynamic range %s:[%lld, %lld) contains %d sections.\n",
+ source->name,
+ dyn->addr,
+ dyn->addr + dyn->size,
+ num_scns);
+
+ ASSERT(scns);
+ int next_idx = 0, next_rel_off = 0;
+ /* The total number of unfinished relocations for this dynamic
+ * entry. */
+ section_info_t *next = (section_info_t *)scns[next_idx].user;
+ section_info_t *first = next;
+ ASSERT(first);
+ for (idx = 0; idx < num_scns; idx++) {
+ section_info_t *reloc_scn = (section_info_t *)scns[idx].user;
+ size_t rel_scn_idx = reloc_scn - source->relocation_sections;
+ ASSERT(rel_scn_idx < (size_t)source->num_relocation_sections);
+ unfinished_relocation_t *unfinished =
+ &source->unfinished[rel_scn_idx];
+ int unf_idx;
+
+ ASSERT(reloc_scn->info == NULL ||
+ reloc_scn->shdr.sh_name ==
+ reloc_scn->info->old_shdr.sh_name);
+ const char *sname =
+ elf_strptr(source->oldelf,
+ source->shstrndx,
+ reloc_scn->shdr.sh_name);
+
+ INFO("\tsection [%s] contains %d unfinished relocs.\n",
+ sname,
+ unfinished->num_rels);
+
+ for (unf_idx = 0; unf_idx < unfinished->num_rels; unf_idx++)
+ {
+ /* There are unfinished relocations. Copy them forward to the
+ lowest section we can. */
+
+ while (next_rel_off ==
+ (int)(next->shdr.sh_size/next->shdr.sh_entsize))
+ {
+ INFO("\tsection [%s] has filled up with %d unfinished "
+ "relocs.\n",
+ sname,
+ next_rel_off);
+
+ next_idx++;
+ ASSERT(next_idx <= idx);
+ next = (section_info_t *)scns[next_idx].user;
+ next_rel_off = 0;
+ }
+
+ if (!adjust_section_size_only) {
+ INFO("\t\tmoving unfinished relocation %2d to [%s:%d]\n",
+ unf_idx,
+ sname,
+ next_rel_off);
+ FAILIF_LIBELF(0 ==
+ gelf_update_rel(next->data,
+ next_rel_off,
+ &unfinished->rels[unf_idx]),
+ gelf_update_rel);
+ }
+
+ next_rel_off++;
+ dyn->num_unfinished_relocs++;
+ }
+ } /* for */
+
+ /* Set the size of the last section, and mark all subsequent
+ sections for removal. At this point, next is the section
+ to which we last wrote data, next_rel_off is the offset before
+ which we wrote the last relocation, and so next_rel_off *
+ relsize is the new size of the section.
+ */
+
+ bool adjust_file = ADJUST_ELF && source->elf_hdr.e_type != ET_EXEC;
+ if (adjust_file && !source->dry_run)
+ {
+ size_t relsize = gelf_fsize(source->elf,
+ ELF_T_REL,
+ 1,
+ source->elf_hdr.e_version);
+
+ ASSERT(next->info == NULL ||
+ next->shdr.sh_name == next->info->old_shdr.sh_name);
+ const char *sname =
+ elf_strptr(source->oldelf,
+ source->shstrndx,
+ next->shdr.sh_name);
+
+ INFO("\tsection [%s] (index %d) has %d unfinished relocs, "
+ "changing its size to %ld bytes (from %ld bytes).\n",
+ sname,
+ elf_ndxscn(next->scn),
+ next_rel_off,
+ (long)(next_rel_off * relsize),
+ (long)(next->shdr.sh_size));
+
+ /* source->shdr_info[] must be allocated prior to calling this
+ function. This is in fact done in process_file(), by calling
+ setup_shdr_info() just before we call adjust_dynamic_segment().
+ */
+ ASSERT(source->shdr_info != NULL);
+
+ /* We do not update the data field of shdr_info[], because it does
+ not exist yet (with ADJUST_ELF != 0). We create the new section
+ and section data after the first call to prelink(). For now, we
+ save the results of our analysis by modifying the sh_size field
+ of the section header. When we create the new sections' data,
+ we set the size of the data from the sh_size fields of the
+ section headers.
+
+ NOTE: The assertion applies only to the first call of
+ adjust_dynamic_segment (which calls this function). By
+ the second call, we've already created the data for the
+ new sections. The only sections for which we haven't
+ created data are the relocation sections we are removing.
+ */
+#ifdef DEBUG
+ ASSERT((!adjust_section_size_only &&
+ (source->shdr_info[elf_ndxscn(next->scn)].idx > 0)) ||
+ source->shdr_info[elf_ndxscn(next->scn)].data == NULL);
+#endif
+
+ //FIXME: what else do we need to do here? Do we need to update
+ // another copy of the shdr so that it's picked up when we
+ // commit the file?
+ next->shdr.sh_size = next_rel_off * relsize;
+ source->shdr_info[elf_ndxscn(next->scn)].shdr.sh_size =
+ next->shdr.sh_size;
+ if (next_rel_off * relsize == 0) {
+#ifdef REMOVE_HANDLED_SECTIONS
+ INFO("\tsection [%s] (index %d) is now empty, marking for "
+ "removal.\n",
+ sname,
+ elf_ndxscn(next->scn));
+ source->shdr_info[elf_ndxscn(next->scn)].idx = 0;
+ dropped_sections = true;
+#endif
+ }
+
+ while (++next_idx < num_scns) {
+ next = (section_info_t *)scns[next_idx].user;
+#ifdef REMOVE_HANDLED_SECTIONS
+ ASSERT(next->info == NULL ||
+ next->shdr.sh_name == next->info->old_shdr.sh_name);
+ const char *sname =
+ elf_strptr(source->oldelf,
+ source->shstrndx,
+ next->shdr.sh_name);
+ INFO("\tsection [%s] (index %d) is now empty, marking for "
+ "removal.\n",
+ sname,
+ elf_ndxscn(next->scn));
+ /* mark for removal */
+ source->shdr_info[elf_ndxscn(next->scn)].idx = 0;
+ dropped_sections = true;
+#endif
+ }
+ }
+
+ } /* if (dyn->sections) */
+ else {
+ /* The dynamic entry won't have any sections when it itself doesn't
+ exist. This could happen when we remove all relocation sections
+ from a dynamic entry because we have managed to handle all
+ relocations in them.
+ */
+ INFO("\tNo section for dynamic entry!\n");
+ }
+
+ return dropped_sections;
+}
+
+static bool adjust_dynamic_segment(source_t *source,
+ bool adjust_section_size_only)
+{
+ bool dropped_section;
+ INFO("Adjusting dynamic segment%s.\n",
+ (adjust_section_size_only ? " (section sizes only)" : ""));
+ INFO("\tadjusting dynamic segment REL.\n");
+ dropped_section =
+ adjust_dynamic_segment_for(source, &source->rel,
+ adjust_section_size_only);
+ INFO("\tadjusting dynamic segment JMPREL.\n");
+ dropped_section =
+ adjust_dynamic_segment_for(source, &source->jmprel,
+ adjust_section_size_only) ||
+ dropped_section;
+ if (!adjust_section_size_only)
+ adjust_dynamic_segment_entries(source);
+ return dropped_section;
+}
+
+static void match_relocation_sections_to_dynamic_ranges(source_t *source)
+{
+ /* We've gathered all the DT_DYNAMIC entries; now we need to figure out
+ which relocation sections fit in which range as described by the
+ entries.
+ */
+
+ int relidx;
+ for (relidx = 0; relidx < source->num_relocation_sections; relidx++) {
+ section_info_t *reloc_scn = &source->relocation_sections[relidx];
+
+ int index = elf_ndxscn(reloc_scn->scn);
+
+ ASSERT(reloc_scn->info == NULL ||
+ reloc_scn->shdr.sh_name == reloc_scn->info->old_shdr.sh_name);
+ const char *sname =
+ elf_strptr(source->oldelf,
+ source->shstrndx,
+ reloc_scn->shdr.sh_name);
+
+ INFO("Checking section [%s], index %d, for match to dynamic ranges\n",
+ sname, index);
+ if (source->shdr_info == NULL || reloc_scn->info->idx > 0) {
+ if (source->rel.addr &&
+ source->rel.addr <= reloc_scn->shdr.sh_addr &&
+ reloc_scn->shdr.sh_addr < source->rel.addr + source->rel.size)
+ {
+ /* The entire section must fit in the dynamic range. */
+ if((reloc_scn->shdr.sh_addr + reloc_scn->shdr.sh_size) >
+ (source->rel.addr + source->rel.size))
+ {
+ PRINT("WARNING: In [%s], section %s:[%lld,%lld) "
+ "is not fully contained in dynamic range "
+ "[%lld,%lld)!\n",
+ source->name,
+ sname,
+ reloc_scn->shdr.sh_addr,
+ reloc_scn->shdr.sh_addr +
+ reloc_scn->shdr.sh_size,
+ source->rel.addr,
+ source->rel.addr + source->rel.size);
+ }
+
+ if (NULL == source->rel.sections) {
+ source->rel.sections = init_range_list();
+ ASSERT(source->rel.sections);
+ }
+ add_unique_range_nosort(source->rel.sections,
+ reloc_scn->shdr.sh_addr,
+ reloc_scn->shdr.sh_size,
+ reloc_scn,
+ NULL,
+ NULL);
+ INFO("\tSection [%s] matches dynamic range REL.\n",
+ sname);
+ }
+ else if (source->jmprel.addr &&
+ source->jmprel.addr <= reloc_scn->shdr.sh_addr &&
+ reloc_scn->shdr.sh_addr <= source->jmprel.addr +
+ source->jmprel.size)
+ {
+ if((reloc_scn->shdr.sh_addr + reloc_scn->shdr.sh_size) >
+ (source->jmprel.addr + source->jmprel.size))
+ {
+ PRINT("WARNING: In [%s], section %s:[%lld,%lld) "
+ "is not fully "
+ "contained in dynamic range [%lld,%lld)!\n",
+ source->name,
+ sname,
+ reloc_scn->shdr.sh_addr,
+ reloc_scn->shdr.sh_addr +
+ reloc_scn->shdr.sh_size,
+ source->jmprel.addr,
+ source->jmprel.addr + source->jmprel.size);
+ }
+
+ if (NULL == source->jmprel.sections) {
+ source->jmprel.sections = init_range_list();
+ ASSERT(source->jmprel.sections);
+ }
+ add_unique_range_nosort(source->jmprel.sections,
+ reloc_scn->shdr.sh_addr,
+ reloc_scn->shdr.sh_size,
+ reloc_scn,
+ NULL,
+ NULL);
+ INFO("\tSection [%s] matches dynamic range JMPREL.\n",
+ sname);
+ }
+ else
+ PRINT("WARNING: Relocation section [%s:%s] does not match "
+ "any DT_ entry.\n",
+ source->name,
+ sname);
+ }
+ else {
+ INFO("Section [%s] was removed, not matching it to dynamic "
+ "ranges.\n",
+ sname);
+ }
+ } /* for ... */
+
+ if (source->rel.sections) sort_ranges(source->rel.sections);
+ if (source->jmprel.sections) sort_ranges(source->jmprel.sections);
+}
+
+static void drop_sections(source_t *source)
+{
+ INFO("We are dropping some sections from [%s]--creating section entries "
+ "only for remaining sections.\n",
+ source->name);
+ /* Renumber the sections. The numbers for the sections after those we are
+ dropping will be shifted back by the number of dropped sections. */
+ int cnt, idx;
+ for (cnt = idx = 1; cnt < source->shnum; ++cnt) {
+ if (source->shdr_info[cnt].idx > 0) {
+ source->shdr_info[cnt].idx = idx++;
+
+ /* Create a new section. */
+ FAILIF_LIBELF((source->shdr_info[cnt].newscn =
+ elf_newscn(source->elf)) == NULL, elf_newscn);
+ ASSERT(elf_ndxscn (source->shdr_info[cnt].newscn) ==
+ source->shdr_info[cnt].idx);
+
+ /* Copy the section data */
+ Elf_Data *olddata =
+ elf_getdata(source->shdr_info[cnt].scn, // old section
+ NULL);
+ FAILIF_LIBELF(NULL == olddata, elf_getdata);
+ Elf_Data *data =
+ elf_newdata(source->shdr_info[cnt].newscn);
+ FAILIF_LIBELF(NULL == data, elf_newdata);
+ *data = *olddata;
+#if COPY_SECTION_DATA_BUFFER
+ if (olddata->d_buf != NULL) {
+ data->d_buf = MALLOC(data->d_size);
+ memcpy(data->d_buf, olddata->d_buf, olddata->d_size);
+ }
+#endif
+ source->shdr_info[cnt].data = data;
+
+ if (data->d_size !=
+ source->shdr_info[cnt].shdr.sh_size) {
+ INFO("Trimming new-section data from %d to %lld bytes "
+ "(as calculated by adjust_dynamic_segment()).\n",
+ data->d_size,
+ source->shdr_info[cnt].shdr.sh_size);
+ data->d_size =
+ source->shdr_info[cnt].shdr.sh_size;
+ }
+
+ INFO("\tsection [%s] (old offset %lld, old size %lld) "
+ "will have index %d (was %d), new size %d\n",
+ source->shdr_info[cnt].name,
+ source->shdr_info[cnt].old_shdr.sh_offset,
+ source->shdr_info[cnt].old_shdr.sh_size,
+ source->shdr_info[cnt].idx,
+ elf_ndxscn(source->shdr_info[cnt].scn),
+ data->d_size);
+ } else {
+ INFO("\tIgnoring section [%s] (offset %lld, size %lld, index %d), "
+ "it will be discarded.\n",
+ source->shdr_info[cnt].name,
+ source->shdr_info[cnt].shdr.sh_offset,
+ source->shdr_info[cnt].shdr.sh_size,
+ elf_ndxscn(source->shdr_info[cnt].scn));
+ }
+
+ /* NOTE: We mark use_old_shdr_for_relocation_calculations even for the
+ sections we are removing. adjust_elf has an assertion that makes
+ sure that if the values for the size of a section according to its
+ header and its data structure differ, then we are using explicitly
+ the old section header for calculations, and that the section in
+ question is a relocation section.
+ */
+ source->shdr_info[cnt].use_old_shdr_for_relocation_calculations = true;
+ } /* for */
+}
+
+static source_t* process_file(const char *filename,
+ const char *output, int is_file,
+ void (*report_library_size_in_memory)(
+ const char *name, off_t fsize),
+ unsigned (*get_next_link_address)(
+ const char *name),
+ int locals_only,
+ char **lib_lookup_dirs,
+ int num_lib_lookup_dirs,
+ char **default_libs,
+ int num_default_libs,
+ int dry_run,
+ int *total_num_handled_relocs,
+ int *total_num_unhandled_relocs)
+{
+ /* Look up the file in the list of already-handles files, which are
+ represented by source_t structs. If we do not find the file, then we
+ haven't prelinked it yet. If we find it, then we have, so we do
+ nothing. Keep in mind that apriori operates on an entire collection
+ of files, and if application A used library L, and so does application
+ B, if we process A first, then by the time we get to B we will have
+ prelinked L already; that's why we check first to see if a library has
+ been prelinked.
+ */
+ source_t *source =
+ find_source(filename, lib_lookup_dirs, num_lib_lookup_dirs);
+ if (NULL == source) {
+ /* If we could not find the source, then it hasn't been processed yet,
+ so we go ahead and process it! */
+ INFO("Processing [%s].\n", filename);
+ char *full = find_file(filename, lib_lookup_dirs, num_lib_lookup_dirs);
+ FAILIF(NULL == full,
+ "Could not find [%s] in the current directory or in any of "
+ "the search paths!\n", filename);
+
+ unsigned base = get_next_link_address(full);
+
+ source = init_source(full, output, is_file, base, dry_run);
+
+ if (source == NULL) {
+ INFO("File [%s] is a static executable.\n", filename);
+ return NULL;
+ }
+ ASSERT(source->dynamic.scn != NULL);
+
+ /* We need to increment the next prelink address only when the file we
+ are currently handing is a shared library. Executables do not need
+ to be prelinked at a different address, they are always at address
+ zero.
+
+ Also, if we are prelinking locals only, then we are handling a
+ single file per invokation of apriori, so there is no need to
+ increment the prelink address unless there is a global prelink map,
+ in which case we do need to check to see if the library isn't
+ running into its neighbouts in the prelink map.
+ */
+ if (source->oldelf_hdr.e_type != ET_EXEC &&
+ (!locals_only ||
+ report_library_size_in_memory ==
+ pm_report_library_size_in_memory)) {
+ /* This sets the next link address only if an increment was not
+ specified by the user. If an address increment was specified,
+ then we just check to make sure that the file size is less than
+ the increment.
+
+ NOTE: The file size is the absolute highest number of bytes that
+ the file may occupy in memory, if the entire file is loaded, but
+ this is almost next the case. A file will often have sections
+ which are not loaded, which could add a lot of size. That's why
+ we start off with the file size and then subtract the size of
+ the biggest sections that will not get loaded, which are the
+ varios DWARF sections, all of which of which are named starting
+ with ".debug_".
+
+ We could do better than this (by caculating exactly how many
+ bytes from that file will be loaded), but that's an overkill.
+ Unless the prelink-address increment becomes too small, the file
+ size after subtracting the sizes of the DWARF section will be a
+ good-enough upper bound.
+ */
+
+ unsigned long fsize = source->elf_file_info.st_size;
+ INFO("Calculating loadable file size for next link address. "
+ "Starting with %ld.\n", fsize);
+ if (true) {
+ Elf_Scn *scn = NULL;
+ GElf_Shdr shdr_mem, *shdr;
+ const char *scn_name;
+ while ((scn = elf_nextscn (source->oldelf, scn)) != NULL) {
+ shdr = gelf_getshdr(scn, &shdr_mem);
+ FAILIF_LIBELF(NULL == shdr, gelf_getshdr);
+ scn_name = elf_strptr (source->oldelf,
+ source->shstrndx, shdr->sh_name);
+ ASSERT(scn_name != NULL);
+
+ if (!(shdr->sh_flags & SHF_ALLOC)) {
+ INFO("\tDecrementing by %lld on account of section "
+ "[%s].\n",
+ shdr->sh_size,
+ scn_name);
+ fsize -= shdr->sh_size;
+ }
+ }
+ }
+ INFO("Done calculating loadable file size for next link address: "
+ "Final value is %ld.\n", fsize);
+ report_library_size_in_memory(source->name, fsize);
+ }
+
+ /* Identify the dynamic segment and process it. Specifically, we find
+ out what dependencies, if any, this file has. Whenever we encounter
+ such a dependency, we process it recursively; we find out where the
+ various relocation information sections are stored. */
+
+ size_t dynidx;
+ GElf_Dyn *dyn, dyn_mem;
+ size_t numdyn =
+ source->dynamic.shdr.sh_size /
+ source->dynamic.shdr.sh_entsize;
+ ASSERT(source->dynamic.shdr.sh_size == source->dynamic.data->d_size);
+
+ source->rel.idx = source->rel.sz_idx = -1;
+ source->jmprel.idx = source->jmprel.sz_idx = -1;
+
+ for (dynidx = 0; dynidx < numdyn; dynidx++) {
+ dyn = gelf_getdyn (source->dynamic.data,
+ dynidx,
+ &dyn_mem);
+ FAILIF_LIBELF(NULL == dyn, gelf_getdyn);
+ /* When we are processing only the local relocations in a file,
+ we don't need to handle any of the dependencies. It won't
+ hurt if we do, but we will be doing unnecessary work.
+ */
+ switch (dyn->d_tag)
+ {
+ case DT_NEEDED:
+ if (!locals_only) {
+ /* Process the needed library recursively.
+ */
+ const char *dep_lib =
+#if ELF_STRPTR_IS_BROKEN
+ (((char *)elf_getdata(
+ elf_getscn(source->elf,
+ source->dynamic.shdr.sh_link),
+ NULL)->d_buf) + dyn->d_un.d_val);
+#else
+ elf_strptr (source->elf,
+ source->dynamic.shdr.sh_link,
+ dyn->d_un.d_val);
+#endif
+ ASSERT(dep_lib != NULL);
+ INFO("[%s] depends on [%s].\n", filename, dep_lib);
+ ASSERT(output == NULL || is_file == 0);
+ source_t *dep = process_file(dep_lib,
+ output, is_file,
+ report_library_size_in_memory,
+ get_next_link_address,
+ locals_only,
+ lib_lookup_dirs,
+ num_lib_lookup_dirs,
+ default_libs,
+ num_default_libs,
+ dry_run,
+ total_num_handled_relocs,
+ total_num_unhandled_relocs);
+
+ /* Add the library to the dependency list. */
+ if (source->num_lib_deps == source->lib_deps_size) {
+ source->lib_deps_size += 10;
+ source->lib_deps = REALLOC(source->lib_deps,
+ source->lib_deps_size *
+ sizeof(source_t *));
+ }
+ source->lib_deps[source->num_lib_deps++] = dep;
+ }
+ break;
+ case DT_JMPREL:
+ source->jmprel.idx = dynidx;
+ source->jmprel.addr = dyn->d_un.d_ptr;
+ break;
+ case DT_PLTRELSZ:
+ source->jmprel.sz_idx = dynidx;
+ source->jmprel.size = dyn->d_un.d_val;
+ break;
+ case DT_REL:
+ source->rel.idx = dynidx;
+ source->rel.addr = dyn->d_un.d_ptr;
+ break;
+ case DT_RELSZ:
+ source->rel.sz_idx = dynidx;
+ source->rel.size = dyn->d_un.d_val;
+ break;
+ case DT_RELA:
+ case DT_RELASZ:
+ FAILIF(1, "Can't handle DT_RELA and DT_RELASZ entries!\n");
+ break;
+ } /* switch */
+ } /* for each dynamic entry... */
+
+ INFO("Handling [%s].\n", filename);
+
+#ifdef SUPPORT_ANDROID_PRELINK_TAGS
+ if (!source->prelinked)
+#endif
+ {
+ /* When ADJUST_ELF is defined, this call to prelink is a dry run
+ intended to calculate the number of relocations that could not
+ be handled. This, in turn, allows us to calculate the amount by
+ which we can shrink the various relocation sections before we
+ call adjust_elf. After we've adjusted the sections, we will
+ call prelink() one more time to do the actual work.
+
+ NOTE: Even when ADJUST_ELF != 0, we cannot adjust an ELF file
+ that is an executabe, because an executable is not PIC.
+ */
+
+ int num_unfinished_relocs = 0;
+ bool adjust_file = ADJUST_ELF && source->elf_hdr.e_type != ET_EXEC;
+ INFO("\n\n\tPRELINKING %s\n\n",
+ adjust_file ?
+ "(CALCULATE NUMBER OF HANDLED RELOCATIONS)" :
+ "(ACTUAL)");
+ int num_relocs = prelink(source, locals_only,
+ adjust_file || dry_run,
+ lib_lookup_dirs, num_lib_lookup_dirs,
+ default_libs, num_default_libs,
+ &num_unfinished_relocs);
+ INFO("[%s]: (calculate changes) handled %d, could not handle %d "
+ "relocations.\n",
+ source->name,
+ num_relocs,
+ num_unfinished_relocs);
+
+ if (adjust_file && !dry_run)
+ {
+ /* Find out the new section sizes of the relocation sections,
+ but do not move any relocations around, because adjust_elf
+ needs to know about all relocations in order to adjust the
+ file correctly.
+ */
+ match_relocation_sections_to_dynamic_ranges(source);
+
+ /* We haven't set up source->shdr_info[] yet, so we do it now.
+
+ NOTE: setup_shdr_info() depends only on source->oldelf, not
+ on source->elf! source->elf is not even defined yet. We
+ initialize source->shdr_info[] based on the section
+ information of the unmodified ELF file, and then make our
+ modifications in the call to adjust_dynamic_segment() based
+ on this information. adjust_dynamic_segment() will
+ rearrange the unhandled relocations in the beginning of
+ their relocation sections, and adjust the size of those
+ relocation sections. In the case when a relocation section
+ is completely handled, adjust_dynamic_segment() will mark it
+ for removal by function adjust_elf.
+ */
+
+ ASSERT(source->elf == source->oldelf);
+ ASSERT(source->shdr_info == NULL);
+ setup_shdr_info(source);
+ ASSERT(source->shdr_info != NULL);
+
+ INFO("\n\n\tADJUSTING DYNAMIC SEGMENT "
+ "(CALCULATE CHANGES)\n\n");
+ bool drop_some_sections = adjust_dynamic_segment(source, true);
+
+ /* Reopen the elf file! Note that we are not doing a dry run
+ (the if statement above makes sure of that.)
+
+ NOTE: We call init_elf() after we called
+ adjust_dynamic_segment() in order to have
+ adjust_dynamic_segment() refer to source->oldelf when
+ it refers to source->elf. Since
+ adjust_dynamic_segment doesn't actually write to the
+ ELF file, this is OK. adjust_dynamic_segment()
+ updates the sh_size fields of saved section headers
+ and optionally marks sections for removal.
+
+ Having adjust_dynamic_segment() refer to
+ source->oldelf means that we'll have access to
+ section-name strings so we can print them out in our
+ logging and debug output.
+ */
+ source->elf = init_elf(source, false);
+
+ /* This is the same code as in init_source() after the call to
+ * init_elf(). */
+ ASSERT(source->elf != source->oldelf);
+ ebl_closebackend(source->ebl);
+ source->ebl = ebl_openbackend (source->elf);
+ FAILIF_LIBELF(NULL == source->ebl, ebl_openbackend);
+#ifdef ARM_SPECIFIC_HACKS
+ FAILIF_LIBELF(0 != arm_init(source->elf,
+ source->elf_hdr.e_machine,
+ source->ebl, sizeof(Ebl)),
+ arm_init);
+#endif/*ARM_SPECIFIC_HACKS*/
+
+ if (drop_some_sections)
+ drop_sections(source);
+ else {
+ INFO("All sections remain in [%s]--we are changing at "
+ "most section sizes.\n", source->name);
+ create_elf_sections(source, NULL);
+ int cnt, idx;
+ for (cnt = idx = 1; cnt < source->shnum; ++cnt) {
+ Elf_Data *data = elf_getdata(
+ source->shdr_info[cnt].newscn, // new section
+ NULL);
+ if (data->d_size !=
+ source->shdr_info[cnt].shdr.sh_size) {
+ INFO("Trimming new-section data from %d to %lld "
+ "bytes (as calculated by "
+ "adjust_dynamic_segment()).\n",
+ data->d_size,
+ source->shdr_info[cnt].shdr.sh_size);
+ data->d_size = source->shdr_info[cnt].shdr.sh_size;
+ }
+ }
+ }
+
+ /* Shrink it! */
+ INFO("\n\n\tADJUSTING ELF\n\n");
+ adjust_elf(
+ source->oldelf, source->name,
+ source->elf, source->name,
+ source->ebl,
+ &source->old_ehdr_mem,
+ NULL, 0, // no symbol filter
+ source->shdr_info, // information on how to adjust the ELF
+ source->shnum, // length of source->shdr_info[]
+ source->phdr_info, // program-header info
+ source->shnum, // irrelevant--we're not rebuilding shstrtab
+ source->shnum, // number of sections in file
+ source->shstrndx, // index of shstrtab (both in
+ // shdr_info[] and as a section index)
+ NULL, // irrelevant, since we are not rebuilding shstrtab
+ drop_some_sections, // some sections are being dropped
+ elf_ndxscn(source->dynamic.scn), // index of .dynamic
+ elf_ndxscn(source->symtab.scn), // index of .dynsym
+ 1, // allow shady business
+ &source->shstrtab_data,
+ true,
+ false); // do not rebuild shstrtab
+
+ INFO("\n\n\tREINITIALIZING STRUCTURES "
+ "(TO CONTAIN ADJUSTMENTS)\n\n");
+ reinit_source(source);
+
+ INFO("\n\n\tPRELINKING (ACTUAL)\n\n");
+#ifdef DEBUG
+ int old_num_unfinished_relocs = num_unfinished_relocs;
+#endif
+ num_unfinished_relocs = 0;
+#ifdef DEBUG
+ int num_relocs_take_two =
+#endif
+ prelink(source, locals_only,
+ false, /* not a dry run */
+ lib_lookup_dirs, num_lib_lookup_dirs,
+ default_libs, num_default_libs,
+ &num_unfinished_relocs);
+
+ /* The numbers for the total number of relocations and the
+ number of unhandled relocations between the first and second
+ invokationof prelink() must be the same! The first time we
+ ran prelink() just to calculate the numbers so that we could
+ calculate the adjustments to pass to adjust_elf, and the
+ second time we actually carry out the prelinking; the
+ numbers must stay the same!
+ */
+ ASSERT(num_relocs == num_relocs_take_two);
+ ASSERT(old_num_unfinished_relocs == num_unfinished_relocs);
+
+ INFO("[%s]: (actual prelink) handled %d, could not "
+ "handle %d relocations.\n",
+ source->name,
+ num_relocs,
+ num_unfinished_relocs);
+ } /* if (adjust_elf && !dry_run) */
+
+ *total_num_handled_relocs += num_relocs;
+ *total_num_unhandled_relocs += num_unfinished_relocs;
+
+ if(num_unfinished_relocs != 0 &&
+ source->elf_hdr.e_type != ET_EXEC &&
+ !locals_only)
+ {
+ /* One reason you could have unfinished relocations in an
+ executable file is if this file used dlopen() and friends.
+ We do not adjust relocation entries to those symbols,
+ because libdl is a dummy only--the real functions are
+ provided for by the dynamic linker itsef.
+
+ NOTE FIXME HACK: This is specific to the Android dynamic
+ linker, and may not be true in other cases.
+ */
+ PRINT("WARNING: Expecting to have unhandled relocations only "
+ "for executables (%s is not an executable)!\n",
+ source->name);
+ }
+
+ match_relocation_sections_to_dynamic_ranges(source);
+
+ /* Now, for each relocation section, check to see if its address
+ matches one of the DT_DYNAMIC relocation pointers. If so, then
+ if the section has no unhandled relocations, simply set the
+ associated DT_DYNAMIC entry's size to zero. If the section does
+ have unhandled entries, then lump them all together at the front
+ of the respective section and update the size of the respective
+ DT_DYNAMIC entry to the new size of the section. A better
+ approach would be do delete a relocation section if it has been
+ fully relocated and to remove its entry from the DT_DYNAMIC
+ array, and for relocation entries that still have some
+ relocations in them, we should shrink the section if that won't
+ violate relative offsets. This is more work, however, and for
+ the speed improvement we expect from a prelinker, just patching
+ up DT_DYNAMIC will suffice.
+
+ Note: adjust_dynamic_segment() will modify source->shdr_info[]
+ to denote any change in a relocation section's size. This
+ will be picked up by adjust_elf, which will rearrange the
+ file to eliminate the gap created by the decrease in size
+ of the relocation section. We do not need to do this, but
+ the relocation section could be large, and reduced
+ drastically by the prelinking process, so it pays to
+ adjust the file.
+ */
+
+ INFO("\n\n\tADJUSTING DYNAMIC SEGMENT (ACTUAL)\n\n");
+ adjust_dynamic_segment(source, false);
+ }
+#ifdef SUPPORT_ANDROID_PRELINK_TAGS
+ else INFO("[%s] is already prelinked at 0x%08lx.\n",
+ filename,
+ source->prelink_base);
+#endif
+ } else INFO("[%s] has been processed already.\n", filename);
+
+ return source;
+}
+
+void apriori(char **execs, int num_execs,
+ char *output,
+ void (*report_library_size_in_memory)(
+ const char *name, off_t fsize),
+ int (*get_next_link_address)(const char *name),
+ int locals_only,
+ int dry_run,
+ char **lib_lookup_dirs, int num_lib_lookup_dirs,
+ char **default_libs, int num_default_libs,
+ char *mapfile)
+{
+ source_t *source; /* for general usage */
+ int input_idx;
+
+ ASSERT(report_library_size_in_memory != NULL);
+ ASSERT(get_next_link_address != NULL);
+
+ /* Process and prelink each executable and object file. Function
+ process_file() is called for each executable in the loop below.
+ It calls itself recursively for each library. We prelink each library
+ after prelinking its dependencies. */
+ int total_num_handled_relocs = 0, total_num_unhandled_relocs = 0;
+ for (input_idx = 0; input_idx < num_execs; input_idx++) {
+ INFO("executable: [%s]\n", execs[input_idx]);
+ /* Here process_file() is actually processing the top-level
+ executable files. */
+ process_file(execs[input_idx], output, num_execs == 1,
+ report_library_size_in_memory,
+ get_next_link_address, /* executables get a link address
+ of zero, regardless of this
+ value */
+ locals_only,
+ lib_lookup_dirs, num_lib_lookup_dirs,
+ default_libs, num_default_libs,
+ dry_run,
+ &total_num_handled_relocs,
+ &total_num_unhandled_relocs);
+ /* if source is NULL, then the respective executable is static */
+ /* Mark the source as an executable */
+ } /* for each input executable... */
+
+ PRINT("Handled %d relocations.\n", total_num_handled_relocs);
+ PRINT("Could not handle %d relocations.\n", total_num_unhandled_relocs);
+
+ /* We are done! Since the end result of our calculations is a set of
+ symbols for each library that other libraries or executables link
+ against, we iterate over the set of libraries one last time, and for
+ each symbol that is marked as satisfying some dependence, we emit
+ a line with the symbol's name to a text file derived from the library's
+ name by appending the suffix .syms to it. */
+
+ if (mapfile != NULL) {
+ const char *mapfile_name = mapfile;
+ FILE *fp;
+ if (*mapfile == '+') {
+ mapfile_name = mapfile + 1;
+ INFO("Opening map file %s for append/write.\n",
+ mapfile_name);
+ fp = fopen(mapfile_name, "a");
+ }
+ else fp = fopen(mapfile_name, "w");
+
+ FAILIF(fp == NULL, "Cannot open file [%s]: %s (%d)!\n",
+ mapfile_name,
+ strerror(errno),
+ errno);
+ source = sources;
+ while (source) {
+ /* If it's a library, print the results. */
+ if (source->elf_hdr.e_type == ET_DYN) {
+ /* Add to the memory map file. */
+ fprintf(fp, "%s 0x%08lx %lld\n",
+ basename(source->name),
+ source->base,
+ source->elf_file_info.st_size);
+ }
+ source = source->next;
+ }
+ fclose(fp);
+ }
+
+ /* Free the resources--you can't do it in the loop above because function
+ print_symbol_references() accesses nodes other than the one being
+ iterated over.
+ */
+ source = sources;
+ while (source) {
+ source_t *old = source;
+ source = source->next;
+ /* Destroy the evidence. */
+ destroy_source(old);
+ }
+}