| /* TODO: |
| 1. check the ARM EABI version--this works for versions 1 and 2. |
| 2. use a more-intelligent approach to finding the symbol table, |
| symbol-string table, and the .dynamic section. |
| 3. fix the determination of the host and ELF-file endianness |
| 4. write the help screen |
| */ |
| |
| #include <stdio.h> |
| #include <common.h> |
| #include <debug.h> |
| #include <libelf.h> |
| #include <elf.h> |
| #include <gelf.h> |
| #include <cmdline.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 <apriori.h> |
| #include <prelinkmap.h> |
| |
| /* Flag set by --verbose. This variable is global as it is accessed by the |
| macro INFO() in multiple compilation unites. */ |
| int verbose_flag = 0; |
| /* Flag set by --quiet. This variable is global as it is accessed by the |
| macro PRINT() in multiple compilation unites. */ |
| int quiet_flag = 0; |
| static void print_dynamic_symbols(Elf *elf, const char *symtab_name); |
| |
| static unsigned s_next_link_addr; |
| static off_t s_addr_increment; |
| |
| static void report_library_size_in_memory(const char *name, off_t fsize) |
| { |
| ASSERT(s_next_link_addr != -1UL); |
| INFO("Setting next link address (current is at 0x%08x):\n", |
| s_next_link_addr); |
| if (s_addr_increment) { |
| FAILIF(s_addr_increment < fsize, |
| "Command-line-specified address increment of 0x%08llx (%lld) " |
| "less than file [%s]'s size of %lld bytes!\n", |
| s_addr_increment, s_addr_increment, name, fsize); |
| FAILIF(s_next_link_addr % 4096, |
| "User-provided address increment 0x%08lx " |
| "is not page-aligned!\n", |
| s_addr_increment); |
| INFO("\tignoring file size, adjusting by address increment.\n"); |
| s_next_link_addr += s_addr_increment; |
| } |
| else { |
| INFO("\tuser address increment is zero, adjusting by file size.\n"); |
| s_next_link_addr += fsize; |
| s_next_link_addr &= ~(4096 - 1); |
| } |
| INFO("\t[%s] file size 0x%08lx\n", |
| name, |
| fsize); |
| INFO("\tnext prelink address: 0x%08x\n", s_next_link_addr); |
| ASSERT(!(s_next_link_addr % 4096)); /* New address must be page-aligned */ |
| } |
| |
| static unsigned get_next_link_address(const char *name) { |
| return s_next_link_addr; |
| } |
| |
| int main(int argc, char **argv) { |
| /* Do not issue INFO() statements before you call get_options() to set |
| the verbose flag as necessary. |
| */ |
| |
| char **lookup_dirs, **default_libs; |
| char *mapfile, *output, *prelinkmap; |
| int start_addr, inc_addr, locals_only, num_lookup_dirs, |
| num_default_libs, dry_run; |
| int first = get_options(argc, argv, |
| &start_addr, &inc_addr, &locals_only, |
| &quiet_flag, |
| &dry_run, |
| &lookup_dirs, &num_lookup_dirs, |
| &default_libs, &num_default_libs, |
| &verbose_flag, |
| &mapfile, |
| &output, |
| &prelinkmap); |
| |
| /* Perform some command-line-parameter checks. */ |
| int cmdline_err = 0; |
| if (first == argc) { |
| ERROR("You must specify at least one input ELF file!\n"); |
| cmdline_err++; |
| } |
| /* We complain when the user does not specify a start address for |
| prelinking when the user does not pass the locals_only switch. The |
| reason is that we will have a collection of executables, which we always |
| prelink to zero, and shared libraries, which we prelink at the specified |
| prelink address. When the user passes the locals_only switch, we do not |
| fail if the user does not specify start_addr, because the file to |
| prelink may be an executable, and not a shared library. At this moment, |
| we do not know what the case is. We find that out when we call function |
| init_source(). |
| */ |
| if (!locals_only && start_addr == -1) { |
| ERROR("You must specify --start-addr!\n"); |
| cmdline_err++; |
| } |
| if (start_addr == -1 && inc_addr != -1) { |
| ERROR("You must provide a start address if you provide an " |
| "address increment!\n"); |
| cmdline_err++; |
| } |
| if (prelinkmap != NULL && start_addr != -1) { |
| ERROR("You may not provide a prelink-map file (-p) and use -s/-i " |
| "at the same time!\n"); |
| cmdline_err++; |
| } |
| if (inc_addr == 0) { |
| ERROR("You may not specify a link-address increment of zero!\n"); |
| cmdline_err++; |
| } |
| if (locals_only) { |
| if (argc - first == 1) { |
| if (inc_addr != -1) { |
| ERROR("You are prelinking a single file; there is no point in " |
| "specifying a prelink-address increment!\n"); |
| /* This is nonfatal error, but paranoia is healthy. */ |
| cmdline_err++; |
| } |
| } |
| if (lookup_dirs != NULL || default_libs != NULL) { |
| ERROR("You are prelinking local relocations only; there is " |
| "no point in specifying lookup directories!\n"); |
| /* This is nonfatal error, but paranoia is healthy. */ |
| cmdline_err++; |
| } |
| } |
| |
| /* If there is an output option, then that must specify a file, if there is |
| a single input file, or a directory, if there are multiple input |
| files. */ |
| if (output != NULL) { |
| struct stat output_st; |
| FAILIF(stat(output, &output_st) < 0 && errno != ENOENT, |
| "stat(%s): %s (%d)\n", |
| output, |
| strerror(errno), |
| errno); |
| |
| if (argc - first == 1) { |
| FAILIF(!errno && !S_ISREG(output_st.st_mode), |
| "you have a single input file: -o must specify a " |
| "file name!\n"); |
| } |
| else { |
| FAILIF(errno == ENOENT, |
| "you have multiple input files: -o must specify a " |
| "directory name, but %s does not exist!\n", |
| output); |
| FAILIF(!S_ISDIR(output_st.st_mode), |
| "you have multiple input files: -o must specify a " |
| "directory name, but %s is not a directory!\n", |
| output); |
| } |
| } |
| |
| if (cmdline_err) { |
| print_help(argv[0]); |
| FAILIF(1, "There are command-line-option errors.\n"); |
| } |
| |
| /* Check to see whether the ELF library is current. */ |
| FAILIF (elf_version(EV_CURRENT) == EV_NONE, "libelf is out of date!\n"); |
| |
| if (inc_addr < 0) { |
| if (!locals_only) |
| PRINT("User has not provided an increment address, " |
| "will use library size to calculate successive " |
| "prelink addresses.\n"); |
| inc_addr = 0; |
| } |
| |
| void (*func_report_library_size_in_memory)(const char *name, off_t fsize); |
| unsigned (*func_get_next_link_address)(const char *name); |
| |
| if (prelinkmap != NULL) { |
| INFO("Reading prelink addresses from prelink-map file [%s].\n", |
| prelinkmap); |
| pm_init(prelinkmap); |
| func_report_library_size_in_memory = pm_report_library_size_in_memory; |
| func_get_next_link_address = pm_get_next_link_address; |
| } |
| else { |
| INFO("Start address: 0x%x\n", start_addr); |
| INFO("Increment address: 0x%x\n", inc_addr); |
| s_next_link_addr = start_addr; |
| s_addr_increment = inc_addr; |
| func_report_library_size_in_memory = report_library_size_in_memory; |
| func_get_next_link_address = get_next_link_address; |
| } |
| |
| /* Prelink... */ |
| apriori(&argv[first], argc - first, output, |
| func_report_library_size_in_memory, func_get_next_link_address, |
| locals_only, |
| dry_run, |
| lookup_dirs, num_lookup_dirs, |
| default_libs, num_default_libs, |
| mapfile); |
| |
| FREEIF(mapfile); |
| FREEIF(output); |
| if (lookup_dirs) { |
| ASSERT(num_lookup_dirs); |
| while (num_lookup_dirs--) |
| FREE(lookup_dirs[num_lookup_dirs]); |
| FREE(lookup_dirs); |
| } |
| if (default_libs) { |
| ASSERT(num_default_libs); |
| while (num_default_libs--) |
| FREE(default_libs[num_default_libs]); |
| FREE(default_libs); |
| } |
| |
| return 0; |
| } |
