diff options
Diffstat (limited to 'tools/lsd/lsd.c')
| -rw-r--r-- | tools/lsd/lsd.c | 777 |
1 files changed, 0 insertions, 777 deletions
diff --git a/tools/lsd/lsd.c b/tools/lsd/lsd.c deleted file mode 100644 index 03c235b..0000000 --- a/tools/lsd/lsd.c +++ /dev/null @@ -1,777 +0,0 @@ -#include <stdio.h> -#include <common.h> -#include <debug.h> -#include <libelf.h> -#include <libebl.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> -#include <hash.h> -#include <lsd.h> - -extern int verbose_flag; - -typedef struct source_t source_t; - -typedef struct { - Elf_Scn *scn; - GElf_Shdr shdr; - Elf_Data *data; -} section_info_t; - -typedef struct next_export_t { - source_t *source; - int next_idx; -} next_export_t; - -struct source_t { - source_t *next; - int visited; - - char *name; /* full path name of this executable file */ - /* ELF-related information: */ - Elf *elf; - int elf_fd; - GElf_Ehdr elf_hdr; - size_t shstrndx; - int shnum; /* number of sections */ - - section_info_t symtab; - section_info_t strtab; - section_info_t dynamic; - section_info_t hash; - - section_info_t *relocations; - int num_relocations; /* number of relocs (<= relocations_size) */ - int relocations_size; /* sice of array -- NOT number of relocs! */ - - /* satisfied_execs: array containing pointers to the libraries or - executables that this executable satisfies symbol references for. */ - source_t **satisfied_execs; - int num_satisfied_execs; - int satisfied_execs_size; - - /* satisfied: array is parallel to symbol table; for each undefined symbol - in that array, we maintain a flag stating whether that symbol has been - satisfied, and if so, by which library. This applies both to executable - files and libraries. - */ - source_t **satisfied; - - /* exports: array is parallel to symbol table; for each global symbol - in that array, we maintain a flag stating whether that symbol satisfies - a dependency in some other file. num_syms is the length of the exports - array, as well as the satisfied array. This applied to libraries only. - - next_exports: this is a bit tricky. We use this field to maintain a - linked list of source_t for each global symbol of a shared library. - For a shared library's global symbol at index N has the property that - exports[N] is the head of a linked list (threaded through next_export) - of all source_t that this symbol resolves a reference to. For example, - if symbol printf has index 1000 in libc.so, and an executable A and - library L use printf, then the source_t entry corresponding to libc.so - will have exports[1000] be a linked list that contains the nodes for - application A and library L. - */ - - next_export_t *exports; - /* num_exported is the number of symbols in this file actually used by - somebody else; it's not the size of the exports array. */ - int num_exported; - next_export_t *next_export; - int num_next_export; - int next_export_size; - - int num_syms; /* number of symbols in symbol table. This is the length of - both exports[] and satisfied[] arrays. */ - - /* This is an array that contains one element for each library dependency - listed in the executable or shared library. */ - source_t **lib_deps; /* list of library dependencies */ - int num_lib_deps; /* actual number of library dependencies */ - int lib_deps_size; /* size of lib_deps array--NOT actual number of deps! */ - -}; - -static source_t *sources = NULL; - -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) { - source_t *trav = sources; - char *full = find_file(name, lib_lookup_dirs, num_lib_lookup_dirs); - FAILIF(full == NULL, "Cannot construct full path for file [%s]!\n", name); - while (trav) { - if (!strcmp(trav->name, full)) - break; - trav = trav->next; - } - free(full); - return trav; -} - -static inline void add_to_sources(source_t *src) { - src->next = sources; - sources = src; -} - -static source_t* init_source(char *full_path) { - source_t *source = (source_t *)CALLOC(1, sizeof(source_t)); - - ASSERT(full_path); - source->name = full_path; - source->elf_fd = -1; - - INFO("Opening %s...\n", full_path); - source->elf_fd = open(full_path, O_RDONLY); - FAILIF(source->elf_fd < 0, "open(%s): %s (%d)\n", - full_path, - strerror(errno), - errno); - INFO("Calling elf_begin(%s)...\n", full_path); - source->elf = elf_begin(source->elf_fd, ELF_C_READ, NULL); - FAILIF_LIBELF(source->elf == NULL, elf_begin); - - /* libelf can recognize COFF and A.OUT formats, but we handle only ELF. */ - if (elf_kind(source->elf) != 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->elf, &source->elf_hdr), gelf_getehdr); - FAILIF(source->elf_hdr.e_type != ET_DYN && - source->elf_hdr.e_type != ET_EXEC, - "%s must be a shared library (elf type is %d, expecting %d).\n", - full_path, - source->elf_hdr.e_type, - ET_DYN); - } - - /* Get the index of the section-header-strings-table section. */ - FAILIF_LIBELF(elf_getshstrndx (source->elf, &source->shstrndx) < 0, - elf_getshstrndx); - - FAILIF_LIBELF(elf_getshnum (source->elf, &source->shnum) < 0, elf_getshnum); - - /* Find various sections. */ - size_t scnidx; - Elf_Scn *scn; - GElf_Shdr *shdr, shdr_mem; - INFO("Locating %d sections in %s...\n", source->shnum, full_path); - for (scnidx = 1; scnidx < source->shnum; scnidx++) { - scn = elf_getscn(source->elf, scnidx); - FAILIF_LIBELF(NULL == scn, elf_getscn); - shdr = gelf_getshdr(scn, &shdr_mem); - FAILIF_LIBELF(NULL == shdr, gelf_getshdr); - INFO("\tfound section [%s]...\n", elf_strptr(source->elf, source->shstrndx, shdr->sh_name)); - 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)); - - /* 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(scn, &source->strtab.shdr), - gelf_getshdr); - source->strtab.data = elf_getdata(source->strtab.scn, NULL); - FAILIF_LIBELF(NULL == source->strtab.data, elf_getdata); - } - else if (shdr->sh_type == SHT_DYNAMIC) { - source->dynamic.scn = scn; - source->dynamic.data = elf_getdata(scn, NULL); - FAILIF_LIBELF(NULL == source->symtab.data, elf_getdata); - memcpy(&source->dynamic.shdr, shdr, sizeof(GElf_Shdr)); - } - 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)); - } - else if (shdr->sh_type == SHT_REL || shdr->sh_type == SHT_RELA) { - if (source->num_relocations == source->relocations_size) { - source->relocations_size += 5; - source->relocations = - (section_info_t *)REALLOC(source->relocations, - source->relocations_size * - sizeof(section_info_t)); - } - section_info_t *reloc = - source->relocations + source->num_relocations; - reloc->scn = scn; - reloc->data = elf_getdata(scn, NULL); - FAILIF_LIBELF(NULL == reloc->data, elf_getdata); - memcpy(&reloc->shdr, shdr, sizeof(GElf_Shdr)); - source->num_relocations++; - } - } - - if (source->dynamic.scn == NULL) { - INFO("File [%s] does not have a dynamic section!\n", full_path); - return 0; - } - - FAILIF(source->symtab.scn == NULL, - "File [%s] does not have a dynamic symbol table!\n", - full_path); - - FAILIF(source->hash.scn == NULL, - "File [%s] does not have a hash table!\n", - full_path); - 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(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->satisfied = (source_t **)CALLOC(source->num_syms, - sizeof(source_t *)); - source->exports = (source_t **)CALLOC(source->num_syms, - sizeof(next_export_t)); - - source->num_exported = 0; - source->satisfied_execs = NULL; - source->num_satisfied_execs = 0; - source->satisfied_execs_size = 0; - - add_to_sources(source); - return source; -} - -static void destroy_source(source_t *source) { - FREE(source->satisfied_execs); - FREE(source->satisfied); - FREE(source->exports); - FREE(source->next_export); - FREE(source->lib_deps); /* list of library dependencies */ - 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); - FREE(source->name); - FREE(source); -} - -static void print_needed_libs(source_t *source) -{ - size_t idx; - for (idx = 0; idx < source->num_lib_deps; idx++) { - PRINT("%s:%s\n", - source->name, - source->lib_deps[idx]->name); - } -} - -static int is_symbol_imported(source_t *source, - GElf_Sym *sym, - size_t symidx) -{ - const char *symname = elf_strptr(source->elf, - elf_ndxscn(source->strtab.scn), - sym->st_name); - - /* A symbol is imported by an executable or a library if it is undefined - and is either global or weak. There is an additional case for - executables that we will check below. */ - if (sym->st_shndx == SHN_UNDEF && - (GELF_ST_BIND(sym->st_info) == STB_GLOBAL || - GELF_ST_BIND(sym->st_info) == STB_WEAK)) { - INFO("*** symbol [%s:%s] is imported (UNDEFIEND).\n", - source->name, - symname); - return 1; - } - -#ifdef ARM_SPECIFIC_HACKS - /* A symbol is imported by an executable if is marked as an undefined - symbol--this is standard to all ELF formats. Alternatively, according - to the ARM specifications, a symbol in a BSS section that is also marked - by an R_ARM_COPY relocation is also imported. */ - - if (source->elf_hdr.e_type != ET_EXEC) { - INFO("is_symbol_imported(): [%s] is a library, " - "no further checks.\n", source->name); - return 0; - } - - /* Is the symbol in the BSS section, and is there a COPY relocation on - that symbol? */ - INFO("*** [%s:%s] checking further to see if symbol is imported.\n", - source->name, symname); - if (sym->st_shndx < source->shnum) { - /* Is it the .bss section? */ - Elf_Scn *scn = elf_getscn(source->elf, sym->st_shndx); - FAILIF_LIBELF(NULL == scn, elf_getscn); - GElf_Shdr *shdr, shdr_mem; - shdr = gelf_getshdr(scn, &shdr_mem); - FAILIF_LIBELF(NULL == shdr, gelf_getshdr); - if (!strcmp(".bss", elf_strptr(source->elf, - source->shstrndx, - shdr->sh_name))) - { - /* Is there an R_ARM_COPY relocation on this symbol? Iterate - over the list of relocation sections and scan each section for - an entry that matches the symbol. */ - size_t idx; - for (idx = 0; idx < source->num_relocations; idx++) { - section_info_t *reloc = source->relocations + idx; - /* Does the relocation section refer to the symbol table in - which this symbol resides, and does it relocate the .bss - section? */ - if (reloc->shdr.sh_link == elf_ndxscn(source->symtab.scn) && - reloc->shdr.sh_info == sym->st_shndx) - { - /* Go over the relocations and see if any of them matches - our symbol. */ - size_t nrels = reloc->shdr.sh_size / reloc->shdr.sh_entsize; - size_t relidx, newidx; - if (reloc->shdr.sh_type == SHT_REL) { - for (newidx = relidx = 0; relidx < nrels; ++relidx) { - GElf_Rel rel_mem; - FAILIF_LIBELF(gelf_getrel (reloc->data, - relidx, - &rel_mem) == NULL, - gelf_getrel); - if (GELF_R_TYPE(rel_mem.r_info) == R_ARM_COPY && - GELF_R_SYM (rel_mem.r_info) == symidx) - { - INFO("*** symbol [%s:%s] is imported " - "(DEFINED, REL-COPY-RELOCATED).\n", - source->name, - symname); - return 1; - } - } /* for each rel entry... */ - } else { - for (newidx = relidx = 0; relidx < nrels; ++relidx) { - GElf_Rela rel_mem; - FAILIF_LIBELF(gelf_getrela (reloc->data, - relidx, - &rel_mem) == NULL, - gelf_getrela); - if (GELF_R_TYPE(rel_mem.r_info) == R_ARM_COPY && - GELF_R_SYM (rel_mem.r_info) == symidx) - { - INFO("*** symbol [%s:%s] is imported " - "(DEFINED, RELA-COPY-RELOCATED).\n", - source->name, - symname); - return 1; - } - } /* for each rela entry... */ - } /* if rel else rela */ - } - } - } - } -#endif/*ARM_SPECIFIC_HACKS*/ - - return 0; -} - -static void resolve(source_t *source) { - /* Iterate the symbol table. For each undefined symbol, scan the - list of dependencies till we find a global symbol in one of them that - satisfies the undefined reference. At this point, we update both the - satisfied[] array of the sources entry, as well as the exports array of - the dependency where we found the match. - */ - - GElf_Sym *sym, sym_mem; - size_t symidx; - for (symidx = 0; symidx < source->num_syms; symidx++) { - sym = gelf_getsymshndx(source->symtab.data, - NULL, - symidx, - &sym_mem, - NULL); - FAILIF_LIBELF(NULL == sym, gelf_getsymshndx); - if (is_symbol_imported(source, sym, symidx)) - { - /* 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; - const char *symname = elf_strptr(source->elf, - elf_ndxscn(source->strtab.scn), - sym->st_name); - for (libidx = 0; libidx < source->num_lib_deps; libidx++) { - source_t *lib = source->lib_deps[libidx]; - int lib_symidx = hash_lookup(lib->elf, - lib->hash.data, - lib->symtab.data, - lib->strtab.data, - symname); - if (STN_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, lib_sym_mem; - lib_sym = gelf_getsymshndx(lib->symtab.data, - NULL, - lib_symidx, - &lib_sym_mem, - NULL); - FAILIF_LIBELF(NULL == lib_sym, gelf_getsymshndx); - - if(lib_sym->st_shndx != STN_UNDEF && - (GELF_ST_BIND(lib_sym->st_info) == STB_GLOBAL || - GELF_ST_BIND(lib_sym->st_info) == STB_WEAK)) - { - /* We found the symbol! Update the satisfied array at this - index location. */ - source->satisfied[symidx] = lib; - /* Now, link this structure into the linked list - corresponding to the found symbol in the library's - global array. */ - if (source->num_next_export == source->next_export_size) { - source->next_export_size += 30; - source->next_export = - (source_t **)REALLOC(source->next_export, - source->next_export_size * - sizeof(struct next_export_t)); - } - source->next_export[source->num_next_export] = lib->exports[lib_symidx]; - lib->exports[lib_symidx].source = source; - lib->exports[lib_symidx].next_idx = source->num_next_export; - - source->num_next_export++; - lib->num_exported++; - - INFO("[%s:%s (index %d)] satisfied by [%s] (index %d)\n", - source->name, - symname, - symidx, - lib->name, - lib_symidx); - 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(found == 0) { - ERROR("ERROR: could not find match for %s:%s.\n", - source->name, - symname); - } - } /* if we found the symbol... */ - } /* for each symbol... */ -} /* resolve() */ - -static void print_used_symbols(source_t *source) { - - int name_len = strlen(source->name); - static const char ext[] = ".syms"; - char *filter = (char *)MALLOC(name_len + sizeof(ext)); - strcpy(filter, source->name); - strcpy(filter + name_len, ext); - - FILE *fp = fopen(filter, "w+"); - FAILIF(NULL == fp, - "Can't open %s: %s (%d)\n", - filter, - strerror(errno), errno); - - /* Is anybody using the symbols defined in source? */ - - if (source->num_exported > 0) { - INFO("[%s] exports %d symbols to %d libraries and executables.\n", - source->name, - source->num_exported, - source->num_satisfied_execs); - size_t symidx; - for (symidx = 0; symidx < source->num_syms; symidx++) { - if (source->exports[symidx].source != NULL) { - GElf_Sym *sym, sym_mem; - sym = gelf_getsymshndx(source->symtab.data, - NULL, - symidx, - &sym_mem, - NULL); - FAILIF_LIBELF(NULL == sym, gelf_getsymshndx); - fprintf(fp, "%s\n", elf_strptr(source->elf, - elf_ndxscn(source->strtab.scn), - sym->st_name)); - } - } - } - else if (source->num_satisfied_execs > 0) { - - /* Is the source listed as a depenency on anyone? If so, then the source exports no symbols - to anyone, but someone lists it as a dependency, which is unnecessary, so we print a warning. - */ - - ERROR("WARNING: [%s] is listed as a dependency in: ", source->name); - int i; - for (i = 0; i < source->num_satisfied_execs; i++) { - ERROR(" [%s],", source->satisfied_execs[i]->name); - } - ERROR(" but none of its symbols are used!.\n"); - } -#if 0 /* This is not really an error--a library's symbols may not be used anyone as specified in the ELF file, - but someone may still open a library via dlopen(). - */ - else { - ERROR("WARNING: None of [%s]'s symbols are used by any library or executable!\n", source->name); - } -#endif - - fclose(fp); - FREE(filter); -} - -static void print_symbol_references(source_t *source) { - - int name_len = strlen(source->name); - static const char ext[] = ".info"; - char *filter = (char *)MALLOC(name_len + sizeof(ext)); - strcpy(filter, source->name); - strcpy(filter + name_len, ext); - - FILE *fp = fopen(filter, "w+"); - FAILIF(NULL == fp, - "Can't open %s: %s (%d)\n", - filter, - strerror(errno), errno); - - if (source->num_exported > 0) { - size_t symidx; - for (symidx = 0; symidx < source->num_syms; symidx++) { - if (source->exports[symidx].source != NULL) { - const char *symname; - GElf_Sym *sym, sym_mem; - sym = gelf_getsymshndx(source->symtab.data, - NULL, - symidx, - &sym_mem, - NULL); - FAILIF_LIBELF(NULL == sym, gelf_getsymshndx); - symname = elf_strptr(source->elf, - elf_ndxscn(source->strtab.scn), - sym->st_name); - fprintf(fp, "%s\n", symname); - next_export_t *export = &source->exports[symidx]; - while (export->source != NULL) { - //fprintf(stderr, "%s:%s\n", symname, export->source->name); - fprintf(fp, "\t%s\n", export->source->name); - export = &export->source->next_export[export->next_idx]; - } - } - } - } - - fclose(fp); - FREE(filter); -} - -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 source_t* process_library(const char *libname, - char **lib_lookup_dirs, - int num_lib_lookup_dirs) { - source_t *source = find_source(libname, lib_lookup_dirs, num_lib_lookup_dirs); - if (NULL == source) { - INFO("Processing [%s].\n", libname); - char *full = find_file(libname, 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", libname); - source = init_source(full); - if (source) { - GElf_Dyn *dyn, dyn_mem; - size_t dynidx; - size_t numdyn = - source->dynamic.shdr.sh_size / - source->dynamic.shdr.sh_entsize; - - for (dynidx = 0; dynidx < numdyn; dynidx++) { - dyn = gelf_getdyn (source->dynamic.data, - dynidx, - &dyn_mem); - FAILIF_LIBELF(NULL == dyn, gelf_getdyn); - if (dyn->d_tag == DT_NEEDED) { - /* Process the needed library recursively. */ - const char *dep_lib = - elf_strptr (source->elf, - source->dynamic.shdr.sh_link, - dyn->d_un.d_val); - INFO("[%s] depends on [%s].\n", libname, dep_lib); - source_t *dep = process_library(dep_lib, - lib_lookup_dirs, - num_lib_lookup_dirs); - - /* Tell dep that source depends on it. */ - if (dep->num_satisfied_execs == dep->satisfied_execs_size) { - dep->satisfied_execs_size += 10; - dep->satisfied_execs = - REALLOC(dep->satisfied_execs, - dep->satisfied_execs_size * - sizeof(source_t *)); - } - dep->satisfied_execs[dep->num_satisfied_execs++] = source; - - /* 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; - } - } /* for each dynamic entry... */ - } - } else INFO("[%s] has been processed already.\n", libname); - - return source; -} - -void lsd(char **execs, int num_execs, - int list_needed_libs, - int print_info, - char **lib_lookup_dirs, int num_lib_lookup_dirs) { - - source_t *source; /* for general usage */ - int input_idx; - - for (input_idx = 0; input_idx < num_execs; input_idx++) { - INFO("executable: [%s]\n", execs[input_idx]); - /* Here process library is actually processing the top-level executable - files. */ - process_library(execs[input_idx], lib_lookup_dirs, num_lib_lookup_dirs); - /* if source is NULL, then the respective executable is static */ - /* Mark the source as an executable */ - } /* for each input executable... */ - - if (list_needed_libs) { - source = sources; - while (source) { - print_needed_libs(source); - source = source->next; - } - } - - /* Now, for each entry in the sources array, iterate its symbol table. For - each undefined symbol, scan the list of dependencies till we find a - global symbol in one of them that satisfies the undefined reference. - At this point, we update both the satisfied[] array of the sources entry, - as well as the exports array of the dependency where we found the match. - */ - - source = sources; - while (source) { - resolve(source); - source = source->next; - } - - /* 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. */ - - source = sources; - while (source) { - /* If it's a library, print the results. */ - if (source->elf_hdr.e_type == ET_DYN) { - print_used_symbols(source); - if (print_info) - print_symbol_references(source); - } - source = source->next; - } - - /* 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); - } -} - |