/* size.c -- report size of various sections of an executable file. Copyright (C) 1991-2015 Free Software Foundation, Inc. This file is part of GNU Binutils. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ /* Extensions/incompatibilities: o - BSD output has filenames at the end. o - BSD output can appear in different radicies. o - SysV output has less redundant whitespace. Filename comes at end. o - SysV output doesn't show VMA which is always the same as the PMA. o - We also handle core files. o - We also handle archives. If you write shell scripts which manipulate this info then you may be out of luck; there's no --compatibility or --pedantic option. */ #include "sysdep.h" #include "bfd.h" #include "libiberty.h" #include "getopt.h" #include "bucomm.h" #ifndef BSD_DEFAULT #define BSD_DEFAULT 1 #endif /* Program options. */ static enum { decimal, octal, hex } radix = decimal; /* 0 means use AT&T-style output. */ static int berkeley_format = BSD_DEFAULT; static int show_version = 0; static int show_help = 0; static int show_totals = 0; static int show_common = 0; static bfd_size_type common_size; static bfd_size_type total_bsssize; static bfd_size_type total_datasize; static bfd_size_type total_textsize; /* Program exit status. */ static int return_code = 0; static char *target = NULL; /* Forward declarations. */ static void display_file (char *); static void rprint_number (int, bfd_size_type); static void print_sizes (bfd * file); static void usage (FILE *stream, int status) { fprintf (stream, _("Usage: %s [option(s)] [file(s)]\n"), program_name); fprintf (stream, _(" Displays the sizes of sections inside binary files\n")); fprintf (stream, _(" If no input file(s) are specified, a.out is assumed\n")); fprintf (stream, _(" The options are:\n\ -A|-B --format={sysv|berkeley} Select output style (default is %s)\n\ -o|-d|-x --radix={8|10|16} Display numbers in octal, decimal or hex\n\ -t --totals Display the total sizes (Berkeley only)\n\ --common Display total size for *COM* syms\n\ --target= Set the binary file format\n\ @ Read options from \n\ -h --help Display this information\n\ -v --version Display the program's version\n\ \n"), #if BSD_DEFAULT "berkeley" #else "sysv" #endif ); list_supported_targets (program_name, stream); if (REPORT_BUGS_TO[0] && status == 0) fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO); exit (status); } #define OPTION_FORMAT (200) #define OPTION_RADIX (OPTION_FORMAT + 1) #define OPTION_TARGET (OPTION_RADIX + 1) static struct option long_options[] = { {"common", no_argument, &show_common, 1}, {"format", required_argument, 0, OPTION_FORMAT}, {"radix", required_argument, 0, OPTION_RADIX}, {"target", required_argument, 0, OPTION_TARGET}, {"totals", no_argument, &show_totals, 1}, {"version", no_argument, &show_version, 1}, {"help", no_argument, &show_help, 1}, {0, no_argument, 0, 0} }; int main (int, char **); int main (int argc, char **argv) { int temp; int c; #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES) setlocale (LC_MESSAGES, ""); #endif #if defined (HAVE_SETLOCALE) setlocale (LC_CTYPE, ""); #endif bindtextdomain (PACKAGE, LOCALEDIR); textdomain (PACKAGE); program_name = *argv; xmalloc_set_program_name (program_name); expandargv (&argc, &argv); bfd_init (); set_default_bfd_target (); while ((c = getopt_long (argc, argv, "ABHhVvdfotx", long_options, (int *) 0)) != EOF) switch (c) { case OPTION_FORMAT: switch (*optarg) { case 'B': case 'b': berkeley_format = 1; break; case 'S': case 's': berkeley_format = 0; break; default: non_fatal (_("invalid argument to --format: %s"), optarg); usage (stderr, 1); } break; case OPTION_TARGET: target = optarg; break; case OPTION_RADIX: #ifdef ANSI_LIBRARIES temp = strtol (optarg, NULL, 10); #else temp = atol (optarg); #endif switch (temp) { case 10: radix = decimal; break; case 8: radix = octal; break; case 16: radix = hex; break; default: non_fatal (_("Invalid radix: %s\n"), optarg); usage (stderr, 1); } break; case 'A': berkeley_format = 0; break; case 'B': berkeley_format = 1; break; case 'v': case 'V': show_version = 1; break; case 'd': radix = decimal; break; case 'x': radix = hex; break; case 'o': radix = octal; break; case 't': show_totals = 1; break; case 'f': /* FIXME : For sysv68, `-f' means `full format', i.e. `[fname:] M(.text) + N(.data) + O(.bss) + P(.comment) = Q' where `fname: ' appears only if there are >= 2 input files, and M, N, O, P, Q are expressed in decimal by default, hexa or octal if requested by `-x' or `-o'. Just to make things interesting, Solaris also accepts -f, which prints out the size of each allocatable section, the name of the section, and the total of the section sizes. */ /* For the moment, accept `-f' silently, and ignore it. */ break; case 0: break; case 'h': case 'H': case '?': usage (stderr, 1); } if (show_version) print_version ("size"); if (show_help) usage (stdout, 0); if (optind == argc) display_file ("a.out"); else for (; optind < argc;) display_file (argv[optind++]); if (show_totals && berkeley_format) { bfd_size_type total = total_textsize + total_datasize + total_bsssize; rprint_number (7, total_textsize); putchar('\t'); rprint_number (7, total_datasize); putchar('\t'); rprint_number (7, total_bsssize); printf (((radix == octal) ? "\t%7lo\t%7lx\t" : "\t%7lu\t%7lx\t"), (unsigned long) total, (unsigned long) total); fputs ("(TOTALS)\n", stdout); } return return_code; } /* Total size required for common symbols in ABFD. */ static void calculate_common_size (bfd *abfd) { asymbol **syms = NULL; long storage, symcount; common_size = 0; if ((bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC | HAS_SYMS)) != HAS_SYMS) return; storage = bfd_get_symtab_upper_bound (abfd); if (storage < 0) bfd_fatal (bfd_get_filename (abfd)); if (storage) syms = (asymbol **) xmalloc (storage); symcount = bfd_canonicalize_symtab (abfd, syms); if (symcount < 0) bfd_fatal (bfd_get_filename (abfd)); while (--symcount >= 0) { asymbol *sym = syms[symcount]; if (bfd_is_com_section (sym->section) && (sym->flags & BSF_SECTION_SYM) == 0) common_size += sym->value; } free (syms); } /* Display stats on file or archive member ABFD. */ static void display_bfd (bfd *abfd) { char **matching; if (bfd_check_format (abfd, bfd_archive)) /* An archive within an archive. */ return; if (bfd_check_format_matches (abfd, bfd_object, &matching)) { print_sizes (abfd); printf ("\n"); return; } if (bfd_get_error () == bfd_error_file_ambiguously_recognized) { bfd_nonfatal (bfd_get_filename (abfd)); list_matching_formats (matching); free (matching); return_code = 3; return; } if (bfd_check_format_matches (abfd, bfd_core, &matching)) { const char *core_cmd; print_sizes (abfd); fputs (" (core file", stdout); core_cmd = bfd_core_file_failing_command (abfd); if (core_cmd) printf (" invoked as %s", core_cmd); puts (")\n"); return; } bfd_nonfatal (bfd_get_filename (abfd)); if (bfd_get_error () == bfd_error_file_ambiguously_recognized) { list_matching_formats (matching); free (matching); } return_code = 3; } static void display_archive (bfd *file) { bfd *arfile = (bfd *) NULL; bfd *last_arfile = (bfd *) NULL; for (;;) { bfd_set_error (bfd_error_no_error); arfile = bfd_openr_next_archived_file (file, arfile); if (arfile == NULL) { if (bfd_get_error () != bfd_error_no_more_archived_files) { bfd_nonfatal (bfd_get_filename (file)); return_code = 2; } break; } display_bfd (arfile); if (last_arfile != NULL) { bfd_close (last_arfile); /* PR 17512: file: a244edbc. */ if (last_arfile == arfile) return; } last_arfile = arfile; } if (last_arfile != NULL) bfd_close (last_arfile); } static void display_file (char *filename) { bfd *file; if (get_file_size (filename) < 1) { return_code = 1; return; } file = bfd_openr (filename, target); if (file == NULL) { bfd_nonfatal (filename); return_code = 1; return; } if (bfd_check_format (file, bfd_archive)) display_archive (file); else display_bfd (file); if (!bfd_close (file)) { bfd_nonfatal (filename); return_code = 1; return; } } static int size_number (bfd_size_type num) { char buffer[40]; sprintf (buffer, (radix == decimal ? "%" BFD_VMA_FMT "u" : ((radix == octal) ? "0%" BFD_VMA_FMT "o" : "0x%" BFD_VMA_FMT "x")), num); return strlen (buffer); } static void rprint_number (int width, bfd_size_type num) { char buffer[40]; sprintf (buffer, (radix == decimal ? "%" BFD_VMA_FMT "u" : ((radix == octal) ? "0%" BFD_VMA_FMT "o" : "0x%" BFD_VMA_FMT "x")), num); printf ("%*s", width, buffer); } static bfd_size_type bsssize; static bfd_size_type datasize; static bfd_size_type textsize; static void berkeley_sum (bfd *abfd ATTRIBUTE_UNUSED, sec_ptr sec, void *ignore ATTRIBUTE_UNUSED) { flagword flags; bfd_size_type size; flags = bfd_get_section_flags (abfd, sec); if ((flags & SEC_ALLOC) == 0) return; size = bfd_get_section_size (sec); if ((flags & SEC_CODE) != 0 || (flags & SEC_READONLY) != 0) textsize += size; else if ((flags & SEC_HAS_CONTENTS) != 0) datasize += size; else bsssize += size; } static void print_berkeley_format (bfd *abfd) { static int files_seen = 0; bfd_size_type total; bsssize = 0; datasize = 0; textsize = 0; bfd_map_over_sections (abfd, berkeley_sum, NULL); bsssize += common_size; if (files_seen++ == 0) puts ((radix == octal) ? " text\t data\t bss\t oct\t hex\tfilename" : " text\t data\t bss\t dec\t hex\tfilename"); total = textsize + datasize + bsssize; if (show_totals) { total_textsize += textsize; total_datasize += datasize; total_bsssize += bsssize; } rprint_number (7, textsize); putchar ('\t'); rprint_number (7, datasize); putchar ('\t'); rprint_number (7, bsssize); printf (((radix == octal) ? "\t%7lo\t%7lx\t" : "\t%7lu\t%7lx\t"), (unsigned long) total, (unsigned long) total); fputs (bfd_get_filename (abfd), stdout); if (bfd_my_archive (abfd)) printf (" (ex %s)", bfd_get_filename (bfd_my_archive (abfd))); } /* I REALLY miss lexical functions! */ bfd_size_type svi_total = 0; bfd_vma svi_maxvma = 0; int svi_namelen = 0; int svi_vmalen = 0; int svi_sizelen = 0; static void sysv_internal_sizer (bfd *file ATTRIBUTE_UNUSED, sec_ptr sec, void *ignore ATTRIBUTE_UNUSED) { bfd_size_type size = bfd_section_size (file, sec); if ( ! bfd_is_abs_section (sec) && ! bfd_is_com_section (sec) && ! bfd_is_und_section (sec)) { int namelen = strlen (bfd_section_name (file, sec)); if (namelen > svi_namelen) svi_namelen = namelen; svi_total += size; if (bfd_section_vma (file, sec) > svi_maxvma) svi_maxvma = bfd_section_vma (file, sec); } } static void sysv_one_line (const char *name, bfd_size_type size, bfd_vma vma) { printf ("%-*s ", svi_namelen, name); rprint_number (svi_sizelen, size); printf (" "); rprint_number (svi_vmalen, vma); printf ("\n"); } static void sysv_internal_printer (bfd *file ATTRIBUTE_UNUSED, sec_ptr sec, void *ignore ATTRIBUTE_UNUSED) { bfd_size_type size = bfd_section_size (file, sec); if ( ! bfd_is_abs_section (sec) && ! bfd_is_com_section (sec) && ! bfd_is_und_section (sec)) { svi_total += size; sysv_one_line (bfd_section_name (file, sec), size, bfd_section_vma (file, sec)); } } static void print_sysv_format (bfd *file) { /* Size all of the columns. */ svi_total = 0; svi_maxvma = 0; svi_namelen = 0; bfd_map_over_sections (file, sysv_internal_sizer, NULL); if (show_common) { if (svi_namelen < (int) sizeof ("*COM*") - 1) svi_namelen = sizeof ("*COM*") - 1; svi_total += common_size; } svi_vmalen = size_number ((bfd_size_type)svi_maxvma); if ((size_t) svi_vmalen < sizeof ("addr") - 1) svi_vmalen = sizeof ("addr")-1; svi_sizelen = size_number (svi_total); if ((size_t) svi_sizelen < sizeof ("size") - 1) svi_sizelen = sizeof ("size")-1; svi_total = 0; printf ("%s ", bfd_get_filename (file)); if (bfd_my_archive (file)) printf (" (ex %s)", bfd_get_filename (bfd_my_archive (file))); printf (":\n%-*s %*s %*s\n", svi_namelen, "section", svi_sizelen, "size", svi_vmalen, "addr"); bfd_map_over_sections (file, sysv_internal_printer, NULL); if (show_common) { svi_total += common_size; sysv_one_line ("*COM*", common_size, 0); } printf ("%-*s ", svi_namelen, "Total"); rprint_number (svi_sizelen, svi_total); printf ("\n\n"); } static void print_sizes (bfd *file) { if (show_common) calculate_common_size (file); if (berkeley_format) print_berkeley_format (file); else print_sysv_format (file); }