[thirdparty/binutils-gdb.git] / binutils / size.c

/* size.c -- report size of various sections of an executable file.
   Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
   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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
\f
/* 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 "bfd.h"
#include "getopt.h"
#include "bucomm.h"
#include "libiberty.h"

#ifndef BSD_DEFAULT
#define BSD_DEFAULT 1
#endif

/* Program options.  */

enum
  {
    decimal, octal, hex
  } radix = decimal;
int berkeley_format = BSD_DEFAULT;	/* 0 means use AT&T-style output.  */
int show_version = 0;
int show_help = 0;

/* Program exit status.  */
int return_code = 0;

static char *target = NULL;

/* Static declarations */

static void usage PARAMS ((FILE *, int));
static void display_file PARAMS ((char *filename));
static void display_bfd PARAMS ((bfd *));
static void display_archive PARAMS ((bfd *));
static int size_number PARAMS ((bfd_size_type));
#if 0
static void lprint_number PARAMS ((int, bfd_size_type));
#endif
static void rprint_number PARAMS ((int, bfd_size_type));
static void print_berkeley_format PARAMS ((bfd *));
static void sysv_internal_sizer PARAMS ((bfd *, asection *, PTR));
static void sysv_internal_printer PARAMS ((bfd *, asection *, PTR));
static void print_sysv_format PARAMS ((bfd *));
static void print_sizes PARAMS ((bfd * file));
static void berkeley_sum PARAMS ((bfd *, sec_ptr, PTR));
\f
static void
usage (stream, status)
     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|-h  --radix={8|10|16}         Display numbers in octal, decimal or hex\n\
            --target=<bfdname>        Set the binary file format\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 (status == 0)
    fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
  exit (status);
}

struct option long_options[] =
{
  {"format", required_argument, 0, 200},
  {"radix", required_argument, 0, 201},
  {"target", required_argument, 0, 202},
  {"version", no_argument, &show_version, 1},
  {"help", no_argument, &show_help, 1},
  {0, no_argument, 0, 0}
};

int main PARAMS ((int, char **));

int
main (argc, argv)
     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);

  bfd_init ();
  set_default_bfd_target ();

  while ((c = getopt_long (argc, argv, "ABHhVvdfox", long_options,
			   (int *) 0)) != EOF)
    switch (c)
      {
      case 200:		/* --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 202:		/* --target */
	target = optarg;
	break;

      case 201:		/* --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 '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++]);

  return return_code;
}
\f
/* Display stats on file or archive member ABFD.  */

static void
display_bfd (abfd)
     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 (file)
     bfd *file;
{
  bfd *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);
      /* Don't close the archive elements; we need them for next_archive */
    }
}

static void
display_file (filename)
     char *filename;
{
  bfd *file = bfd_openr (filename, target);
  if (file == NULL)
    {
      bfd_nonfatal (filename);
      return_code = 1;
      return;
    }

  if (bfd_check_format (file, bfd_archive) == true)
    display_archive (file);
  else
    display_bfd (file);

  if (bfd_close (file) == false)
    {
      bfd_nonfatal (filename);
      return_code = 1;
      return;
    }
}
\f
/* This is what lexical functions are for.  */

static int
size_number (num)
     bfd_size_type num;
{
  char buffer[40];
  sprintf (buffer,
	   (radix == decimal ? "%lu" :
	   ((radix == octal) ? "0%lo" : "0x%lx")),
	   (unsigned long) num);

  return strlen (buffer);
}

#if 0

/* This is not used.  */

static void
lprint_number (width, num)
     int width;
     bfd_size_type num;
{
  char buffer[40];
  sprintf (buffer,
	   (radix == decimal ? "%lu" :
	   ((radix == octal) ? "0%lo" : "0x%lx")),
	   (unsigned long) num);

  printf ("%-*s", width, buffer);
}

#endif

static void
rprint_number (width, num)
     int width;
     bfd_size_type num;
{
  char buffer[40];
  sprintf (buffer,
	   (radix == decimal ? "%lu" :
	   ((radix == octal) ? "0%lo" : "0x%lx")),
	   (unsigned long) num);

  printf ("%*s", width, buffer);
}

static bfd_size_type bsssize;
static bfd_size_type datasize;
static bfd_size_type textsize;

static void
berkeley_sum (abfd, sec, ignore)
     bfd *abfd ATTRIBUTE_UNUSED;
     sec_ptr sec;
     PTR 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_before_reloc (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 (abfd)
     bfd *abfd;
{
  static int files_seen = 0;
  bfd_size_type total;

  bsssize = 0;
  datasize = 0;
  textsize = 0;

  bfd_map_over_sections (abfd, berkeley_sum, (PTR) NULL);

  if (files_seen++ == 0)
#if 0
    /* Intel doesn't like bss/stk because they don't have core files.  */
    puts ((radix == octal) ? "   text\t   data\tbss/stk\t    oct\t    hex\tfilename" :
	  "   text\t   data\tbss/stk\t    dec\t    hex\tfilename");
#else
    puts ((radix == octal) ? "   text\t   data\t    bss\t    oct\t    hex\tfilename" :
	  "   text\t   data\t    bss\t    dec\t    hex\tfilename");
#endif

  total = textsize + datasize + 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 (file, sec, ignore)
     bfd *file ATTRIBUTE_UNUSED;
     sec_ptr sec;
     PTR 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_internal_printer (file, sec, ignore)
     bfd *file ATTRIBUTE_UNUSED;
     sec_ptr sec;
     PTR 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;

      printf ("%-*s   ", svi_namelen, bfd_section_name (file, sec));
      rprint_number (svi_sizelen, size);
      printf ("   ");
      rprint_number (svi_vmalen, bfd_section_vma (file, sec));
      printf ("\n");
    }
}

static void
print_sysv_format (file)
     bfd *file;
{
  /* size all of the columns */
  svi_total = 0;
  svi_maxvma = 0;
  svi_namelen = 0;
  bfd_map_over_sections (file, sysv_internal_sizer, (PTR) NULL);
  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, (PTR) NULL);

  printf ("%-*s   ", svi_namelen, "Total");
  rprint_number (svi_sizelen, svi_total);
  printf ("\n\n");
}

static void
print_sizes (file)
     bfd *file;
{
  if (berkeley_format)
    print_berkeley_format (file);
  else
    print_sysv_format (file);
}
Commit	Line	Data
252b5132	1	/* size.c -- report size of various sections of an executable file.
8b53311e	2	Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
252b5132 RH	3	Free Software Foundation, Inc.
	4
	5	This file is part of GNU Binutils.
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 2 of the License, or
	10	(at your option) any later version.
	11
	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this program; if not, write to the Free Software
	19	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
	20	\f
	21	/* Extensions/incompatibilities:
	22	o - BSD output has filenames at the end.
	23	o - BSD output can appear in different radicies.
	24	o - SysV output has less redundant whitespace. Filename comes at end.
	25	o - SysV output doesn't show VMA which is always the same as the PMA.
	26	o - We also handle core files.
	27	o - We also handle archives.
	28	If you write shell scripts which manipulate this info then you may be
	29	out of luck; there's no --compatibility or --pedantic option.
	30	*/
	31
	32	#include "bfd.h"
	33	#include "getopt.h"
	34	#include "bucomm.h"
	35	#include "libiberty.h"
	36
	37	#ifndef BSD_DEFAULT
	38	#define BSD_DEFAULT 1
	39	#endif
	40
	41	/* Program options. */
	42
	43	enum
	44	{
	45	decimal, octal, hex
	46	} radix = decimal;
	47	int berkeley_format = BSD_DEFAULT; /* 0 means use AT&T-style output. */
	48	int show_version = 0;
	49	int show_help = 0;
	50
	51	/* Program exit status. */
	52	int return_code = 0;
	53
	54	static char *target = NULL;
	55
	56	/* Static declarations */
	57
	58	static void usage PARAMS ((FILE *, int));
	59	static void display_file PARAMS ((char *filename));
	60	static void display_bfd PARAMS ((bfd *));
	61	static void display_archive PARAMS ((bfd *));
	62	static int size_number PARAMS ((bfd_size_type));
	63	#if 0
	64	static void lprint_number PARAMS ((int, bfd_size_type));
	65	#endif
	66	static void rprint_number PARAMS ((int, bfd_size_type));
67	static void print_berkeley_format PARAMS ((bfd *));
68	static void sysv_internal_sizer PARAMS ((bfd , asection , PTR));
69	static void sysv_internal_printer PARAMS ((bfd , asection , PTR));
70	static void print_sysv_format PARAMS ((bfd *));
71	static void print_sizes PARAMS ((bfd * file));
72	static void berkeley_sum PARAMS ((bfd *, sec_ptr, PTR));
73	\f
74	static void
75	usage (stream, status)
76	FILE *stream;
77	int status;
78	{
8b53311e NC	79	fprintf (stream, _("Usage: %s [option(s)] [file(s)]\n"), program_name);
	80	fprintf (stream, _(" Displays the sizes of sections inside binary files\n"));
	81	fprintf (stream, _(" If no input file(s) are specified, a.out is assumed\n"));
	82	fprintf (stream, _(" The options are:\n\
	83	-A\|-B --format={sysv\|berkeley} Select output style (default is %s)\n\
	84	-o\|-d\|-h --radix={8\|10\|16} Display numbers in octal, decimal or hex\n\
	85	--target=<bfdname> Set the binary file format\n\
	86	-h --help Display this information\n\
	87	-v --version Display the program's version\n\
	88	\n"),
252b5132	89	#if BSD_DEFAULT
8b53311e	90	"berkeley"
252b5132	91	#else
8b53311e	92	"sysv"
252b5132	93	#endif
8b53311e	94	);
252b5132 RH	95	list_supported_targets (program_name, stream);
252b5132 RH	96	if (status == 0)
8ad3436c	97	fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 RH	98	exit (status);
	99	}
	100
	101	struct option long_options[] =
	102	{
	103	{"format", required_argument, 0, 200},
	104	{"radix", required_argument, 0, 201},
	105	{"target", required_argument, 0, 202},
	106	{"version", no_argument, &show_version, 1},
	107	{"help", no_argument, &show_help, 1},
	108	{0, no_argument, 0, 0}
	109	};
	110
65de42c0 TS	111	int main PARAMS ((int, char **));
65de42c0 TS	112
252b5132 RH	113	int
	114	main (argc, argv)
	115	int argc;
	116	char **argv;
	117	{
	118	int temp;
	119	int c;
	120
	121	#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
	122	setlocale (LC_MESSAGES, "");
3882b010 L	123	#endif
	124	#if defined (HAVE_SETLOCALE)
	125	setlocale (LC_CTYPE, "");
252b5132 RH	126	#endif
	127	bindtextdomain (PACKAGE, LOCALEDIR);
	128	textdomain (PACKAGE);
	129
	130	program_name = *argv;
	131	xmalloc_set_program_name (program_name);
	132
	133	bfd_init ();
	134	set_default_bfd_target ();
	135
8b53311e	136	while ((c = getopt_long (argc, argv, "ABHhVvdfox", long_options,
252b5132 RH	137	(int *) 0)) != EOF)
	138	switch (c)
	139	{
	140	case 200: /* --format */
	141	switch (*optarg)
	142	{
	143	case 'B':
	144	case 'b':
	145	berkeley_format = 1;
	146	break;
	147	case 'S':
	148	case 's':
	149	berkeley_format = 0;
	150	break;
	151	default:
37cc8ec1	152	non_fatal (_("invalid argument to --format: %s"), optarg);
252b5132 RH	153	usage (stderr, 1);
	154	}
	155	break;
	156
	157	case 202: /* --target */
	158	target = optarg;
	159	break;
	160
	161	case 201: /* --radix */
	162	#ifdef ANSI_LIBRARIES
	163	temp = strtol (optarg, NULL, 10);
	164	#else
	165	temp = atol (optarg);
	166	#endif
	167	switch (temp)
	168	{
	169	case 10:
	170	radix = decimal;
	171	break;
	172	case 8:
	173	radix = octal;
	174	break;
	175	case 16:
	176	radix = hex;
	177	break;
	178	default:
37cc8ec1	179	non_fatal (_("Invalid radix: %s\n"), optarg);
252b5132 RH	180	usage (stderr, 1);
	181	}
	182	break;
	183
	184	case 'A':
	185	berkeley_format = 0;
	186	break;
	187	case 'B':
	188	berkeley_format = 1;
	189	break;
8b53311e	190	case 'v':
252b5132 RH	191	case 'V':
	192	show_version = 1;
	193	break;
	194	case 'd':
	195	radix = decimal;
	196	break;
	197	case 'x':
	198	radix = hex;
	199	break;
	200	case 'o':
	201	radix = octal;
	202	break;
e3a69612 AM	203	case 'f': /* FIXME : For sysv68, `-f' means `full format', i.e.
	204	`[fname:] M(.text) + N(.data) + O(.bss) + P(.comment) = Q'
	205	where `fname: ' appears only if there are >= 2 input files,
	206	and M, N, O, P, Q are expressed in decimal by default,
	207	hexa or octal if requested by `-x' or `-o'.
	208	Just to make things interesting, Solaris also accepts -f,
	209	which prints out the size of each allocatable section, the
	210	name of the section, and the total of the section sizes. */
	211	/* For the moment, accept `-f' silently, and ignore it. */
	212	break;
252b5132 RH	213	case 0:
252b5132 RH	214	break;
8b53311e NC	215	case 'h':
8b53311e NC	216	case 'H':
252b5132 RH	217	case '?':
	218	usage (stderr, 1);
	219	}
	220
	221	if (show_version)
	222	print_version ("size");
	223	if (show_help)
	224	usage (stdout, 0);
	225
	226	if (optind == argc)
	227	display_file ("a.out");
	228	else
	229	for (; optind < argc;)
	230	display_file (argv[optind++]);
	231
	232	return return_code;
	233	}
	234	\f
	235	/* Display stats on file or archive member ABFD. */
	236
	237	static void
	238	display_bfd (abfd)
	239	bfd *abfd;
	240	{
	241	char **matching;
	242
	243	if (bfd_check_format (abfd, bfd_archive))
	244	/* An archive within an archive. */
	245	return;
	246
	247	if (bfd_check_format_matches (abfd, bfd_object, &matching))
	248	{
	249	print_sizes (abfd);
	250	printf ("\n");
	251	return;
	252	}
	253
	254	if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
	255	{
	256	bfd_nonfatal (bfd_get_filename (abfd));
	257	list_matching_formats (matching);
	258	free (matching);
	259	return_code = 3;
	260	return;
	261	}
	262
	263	if (bfd_check_format_matches (abfd, bfd_core, &matching))
	264	{
	265	CONST char *core_cmd;
	266
	267	print_sizes (abfd);
	268	fputs (" (core file", stdout);
	269
	270	core_cmd = bfd_core_file_failing_command (abfd);
	271	if (core_cmd)
	272	printf (" invoked as %s", core_cmd);
	273
	274	puts (")\n");
	275	return;
	276	}
	277
	278	bfd_nonfatal (bfd_get_filename (abfd));
	279
	280	if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
281	{
282	list_matching_formats (matching);
283	free (matching);
284	}
285
286	return_code = 3;
287	}
288
289	static void
290	display_archive (file)
291	bfd *file;
292	{
293	bfd arfile = (bfd ) NULL;
294
295	for (;;)
296	{
297	bfd_set_error (bfd_error_no_error);
298
299	arfile = bfd_openr_next_archived_file (file, arfile);
300	if (arfile == NULL)
301	{
302	if (bfd_get_error () != bfd_error_no_more_archived_files)
303	{
304	bfd_nonfatal (bfd_get_filename (file));
305	return_code = 2;
306	}
307	break;
308	}
309
310	display_bfd (arfile);
311	/* Don't close the archive elements; we need them for next_archive */
312	}
313	}
314
315	static void
316	display_file (filename)
317	char *filename;
318	{
319	bfd *file = bfd_openr (filename, target);
320	if (file == NULL)
321	{
322	bfd_nonfatal (filename);
323	return_code = 1;
324	return;
325	}
326
327	if (bfd_check_format (file, bfd_archive) == true)
328	display_archive (file);
329	else
330	display_bfd (file);
331
332	if (bfd_close (file) == false)
333	{
334	bfd_nonfatal (filename);
335	return_code = 1;
336	return;
337	}
338	}
339	\f
340	/* This is what lexical functions are for. */
341
342	static int
343	size_number (num)
344	bfd_size_type num;
345	{
346	char buffer[40];
347	sprintf (buffer,
348	(radix == decimal ? "%lu" :
349	((radix == octal) ? "0%lo" : "0x%lx")),
350	(unsigned long) num);
351
352	return strlen (buffer);
353	}
354
355	#if 0
356
357	/* This is not used. */
358
359	static void
360	lprint_number (width, num)
361	int width;
362	bfd_size_type num;
363	{
364	char buffer[40];
365	sprintf (buffer,
366	(radix == decimal ? "%lu" :
367	((radix == octal) ? "0%lo" : "0x%lx")),
368	(unsigned long) num);
369
370	printf ("%-*s", width, buffer);
371	}
372
373	#endif
374
375	static void
376	rprint_number (width, num)
377	int width;
378	bfd_size_type num;
379	{
380	char buffer[40];
381	sprintf (buffer,
382	(radix == decimal ? "%lu" :
383	((radix == octal) ? "0%lo" : "0x%lx")),
384	(unsigned long) num);
385
386	printf ("%*s", width, buffer);
387	}
388
389	static bfd_size_type bsssize;
390	static bfd_size_type datasize;
391	static bfd_size_type textsize;
392
393	static void
394	berkeley_sum (abfd, sec, ignore)
b4c96d0d	395	bfd *abfd ATTRIBUTE_UNUSED;
252b5132	396	sec_ptr sec;
b4c96d0d	397	PTR ignore ATTRIBUTE_UNUSED;
252b5132 RH	398	{
	399	flagword flags;
	400	bfd_size_type size;
	401
	402	flags = bfd_get_section_flags (abfd, sec);
	403	if ((flags & SEC_ALLOC) == 0)
	404	return;
	405
	406	size = bfd_get_section_size_before_reloc (sec);
	407	if ((flags & SEC_CODE) != 0 \|\| (flags & SEC_READONLY) != 0)
	408	textsize += size;
	409	else if ((flags & SEC_HAS_CONTENTS) != 0)
	410	datasize += size;
	411	else
	412	bsssize += size;
	413	}
	414
	415	static void
	416	print_berkeley_format (abfd)
	417	bfd *abfd;
	418	{
	419	static int files_seen = 0;
	420	bfd_size_type total;
	421
	422	bsssize = 0;
	423	datasize = 0;
	424	textsize = 0;
	425
	426	bfd_map_over_sections (abfd, berkeley_sum, (PTR) NULL);
	427
	428	if (files_seen++ == 0)
	429	#if 0
	430	/* Intel doesn't like bss/stk because they don't have core files. */
	431	puts ((radix == octal) ? " text\t data\tbss/stk\t oct\t hex\tfilename" :
	432	" text\t data\tbss/stk\t dec\t hex\tfilename");
	433	#else
	434	puts ((radix == octal) ? " text\t data\t bss\t oct\t hex\tfilename" :
	435	" text\t data\t bss\t dec\t hex\tfilename");
	436	#endif
	437
	438	total = textsize + datasize + bsssize;
	439
	440	rprint_number (7, textsize);
	441	putchar ('\t');
	442	rprint_number (7, datasize);
	443	putchar ('\t');
	444	rprint_number (7, bsssize);
	445	printf (((radix == octal) ? "\t%7lo\t%7lx\t" : "\t%7lu\t%7lx\t"),
	446	(unsigned long) total, (unsigned long) total);
	447
	448	fputs (bfd_get_filename (abfd), stdout);
	449	if (bfd_my_archive (abfd))
	450	printf (" (ex %s)", bfd_get_filename (bfd_my_archive (abfd)));
	451	}
	452
	453	/* I REALLY miss lexical functions! */
	454	bfd_size_type svi_total = 0;
	455	bfd_vma svi_maxvma = 0;
	456	int svi_namelen = 0;
	457	int svi_vmalen = 0;
	458	int svi_sizelen = 0;
	459
	460	static void
	461	sysv_internal_sizer (file, sec, ignore)
b4c96d0d	462	bfd *file ATTRIBUTE_UNUSED;
252b5132	463	sec_ptr sec;
b4c96d0d	464	PTR ignore ATTRIBUTE_UNUSED;
252b5132 RH	465	{
	466	bfd_size_type size = bfd_section_size (file, sec);
	467	if (!bfd_is_abs_section (sec)
	468	&& !bfd_is_com_section (sec)
	469	&& !bfd_is_und_section (sec))
	470	{
	471	int namelen = strlen (bfd_section_name (file, sec));
	472	if (namelen > svi_namelen)
	473	svi_namelen = namelen;
	474
	475	svi_total += size;
	476	if (bfd_section_vma (file, sec) > svi_maxvma)
	477	svi_maxvma = bfd_section_vma (file, sec);
	478	}
	479	}
	480
	481	static void
	482	sysv_internal_printer (file, sec, ignore)
b4c96d0d	483	bfd *file ATTRIBUTE_UNUSED;
252b5132	484	sec_ptr sec;
b4c96d0d	485	PTR ignore ATTRIBUTE_UNUSED;
252b5132 RH	486	{
	487	bfd_size_type size = bfd_section_size (file, sec);
	488	if (!bfd_is_abs_section (sec)
	489	&& !bfd_is_com_section (sec)
	490	&& !bfd_is_und_section (sec))
	491	{
	492	svi_total += size;
	493
	494	printf ("%-*s ", svi_namelen, bfd_section_name (file, sec));
	495	rprint_number (svi_sizelen, size);
	496	printf (" ");
	497	rprint_number (svi_vmalen, bfd_section_vma (file, sec));
	498	printf ("\n");
	499	}
	500	}
	501
	502	static void
	503	print_sysv_format (file)
	504	bfd *file;
	505	{
	506	/* size all of the columns */
	507	svi_total = 0;
	508	svi_maxvma = 0;
	509	svi_namelen = 0;
	510	bfd_map_over_sections (file, sysv_internal_sizer, (PTR) NULL);
	511	svi_vmalen = size_number ((bfd_size_type)svi_maxvma);
	512	if ((size_t) svi_vmalen < sizeof ("addr") - 1)
	513	svi_vmalen = sizeof ("addr")-1;
	514
	515	svi_sizelen = size_number (svi_total);
	516	if ((size_t) svi_sizelen < sizeof ("size") - 1)
	517	svi_sizelen = sizeof ("size")-1;
	518
	519	svi_total = 0;
	520	printf ("%s ", bfd_get_filename (file));
	521	if (bfd_my_archive (file))
	522	printf (" (ex %s)", bfd_get_filename (bfd_my_archive (file)));
	523
	524	printf (":\n%-s %s %*s\n", svi_namelen, "section",
	525	svi_sizelen, "size", svi_vmalen, "addr");
	526	bfd_map_over_sections (file, sysv_internal_printer, (PTR) NULL);
	527
	528	printf ("%-*s ", svi_namelen, "Total");
	529	rprint_number (svi_sizelen, svi_total);
	530	printf ("\n\n");
	531	}
	532
	533	static void
	534	print_sizes (file)
	535	bfd *file;
	536	{
	537	if (berkeley_format)
	538	print_berkeley_format (file);
	539	else
	540	print_sysv_format (file);
	541	}