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

/* size.c -- report size of various sections of an executable file.
   Copyright 1991, 1992 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., 675 Mass Ave, Cambridge, MA 02139, 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 --predantic option.
*/

#include "bfd.h"
#include "sysdep.h"
#include "getopt.h"

#ifndef BSD_DEFAULT
#define BSD_DEFAULT 1
#endif

/* Various 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;

int return_code = 0;

/* IMPORTS */
extern char *program_version;
extern char *program_name;
extern char *target;

/* Forward declarations */

static void
display_file PARAMS ((char *filename));

static void
print_sizes PARAMS ((bfd *file));
\f
/** main and like trivia */

void
usage ()
{
  fprintf (stderr, "size %s\n\
Usage: %s [-ABdoxV] [--format=berkeley|sysv] [--radix=8|10|16]\n\
       [--target=bfdname] [--version] [--help] [file...]\n",
	   program_version, program_name);
#if BSD_DEFAULT
  fputs ("       (default is --format=berkeley)\n", stderr);
#else
  fputs ("       (default is --format=sysv)\n", stderr);
#endif
  exit (1);
}

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 (argc, argv)
     int argc;
     char **argv;
{
  int temp;
  int c;			/* sez which option char */
  extern int optind;		/* steps thru options */

  program_name = *argv;

  bfd_init();

  while ((c = getopt_long(argc, argv, "ABVdox", 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: fprintf(stderr, "invalid argument to --format: %s\n", optarg);
	  usage();
	}
	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: printf("Unknown radix: %s\n", optarg);
	  usage();
	}
	break;

    case 'A': berkeley_format = 0; break;
    case 'B': berkeley_format = 1; break;
    case 'V': show_version = 1; break;
    case 'd': radix = decimal; break;
    case 'x': radix = hex; break;
    case 'o': radix = octal; break;
    case '?': usage();
    }

  if (show_version) printf("%s version %s\n", program_name, program_version);
  if (show_help) usage();
	
  if (optind == argc)
    display_file ("a.out");
  else
    for (; optind < argc;)
      display_file (argv[optind++]);

  return return_code;
}
\f
/** Display a file's stats */

void
display_bfd (abfd)
     bfd *abfd;
{
  CONST  char *core_cmd;

  if (bfd_check_format(abfd, bfd_archive)) return;

  if (bfd_check_format(abfd, bfd_object)) {
    print_sizes(abfd);
    goto done;
  }

  if (bfd_check_format(abfd, bfd_core)) {
    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(")");
    goto done;
  }
  
  printf("Unknown file format: %s.", bfd_get_filename(abfd));
  return_code = 3;

 done:


  printf("\n");
  return;
}

static void
display_file(filename)
     char *filename;
{
  bfd *file, *arfile = (bfd *) NULL;

  file = bfd_openr (filename, target);
  if (file == NULL) {
    fprintf (stderr, "%s: ", program_name);
    bfd_perror (filename);
    return_code = 1;
    return;
  }

  if (bfd_check_format(file, bfd_archive) == true) {
    for(;;) {
      
      bfd_error = no_error;

       arfile = bfd_openr_next_archived_file (file, arfile);
      if (arfile == NULL) {
	if (bfd_error != no_more_archived_files) {
	  fprintf (stderr, "%s: ", program_name);
	  bfd_perror (bfd_get_filename (file));
	  return_code = 2;
        }
	return;
      }

      display_bfd (arfile);
      /* Don't close the archive elements; we need them for next_archive */
    }
  }
  else
    display_bfd (file);

  bfd_close (file);
}
\f
/* This is what lexical functions are for */
void
lprint_number (width, num)
     int width;
     bfd_size_type num;
{
  printf ((radix == decimal ? "%-*lu\t" :
	   ((radix == octal) ? "%-*lo\t" : "%-*lx\t")),
	  width, (unsigned long)num);
}

void
rprint_number(width, num)
     int width;
     bfd_size_type num;
{
  printf ((radix == decimal ? "%*lu\t" :
	   ((radix == octal) ? "%*lo\t" : "%*lx\t")),
	  width, (unsigned long)num);
}

static char *bss_section_name = ".bss";
static char *data_section_name = ".data";
static char *stack_section_name = ".stack";
static char *text_section_name = ".text";

void print_berkeley_format(abfd)
bfd *abfd;
{
  static int files_seen = 0;
  sec_ptr bsssection = NULL;
  sec_ptr datasection = NULL;
  sec_ptr textsection = NULL;
  bfd_size_type bsssize = 0;
  bfd_size_type datasize = 0;
  bfd_size_type textsize = 0;
  bfd_size_type total = 0;

  
  if ((textsection = bfd_get_section_by_name (abfd, text_section_name))
      != NULL) {
    textsize = bfd_get_section_size_before_reloc (textsection);
  }

  if ((datasection = bfd_get_section_by_name (abfd, data_section_name))
      != NULL) {
    datasize = bfd_get_section_size_before_reloc ( datasection);
  }
	
  if (bfd_get_format (abfd) == bfd_object) {
    if ((bsssection = bfd_get_section_by_name (abfd, bss_section_name))
	!= NULL) {
      bsssize = bfd_section_size(abfd, bsssection);
    }
  } else {
    if ((bsssection = bfd_get_section_by_name (abfd, stack_section_name))
	!= NULL) {
      bsssize = bfd_section_size(abfd, bsssection);
    }
  }

  if (files_seen++ == 0)
#if 0	/* intel doesn't like bss/stk b/c they don't gave core files */
    puts((radix == octal) ? "text\tdata\tbss/stk\toct\thex\tfilename" :
	 "text\tdata\tbss/stk\tdec\thex\tfilename");
#else
    puts((radix == octal) ? "text\tdata\tbss\toct\thex\tfilename" :
	 "text\tdata\tbss\tdec\thex\tfilename");
#endif
	
  total = textsize + datasize + bsssize;
	
  lprint_number (7, textsize);
  lprint_number (7, datasize);
  lprint_number (7, bsssize);
  printf (((radix == octal) ? "%-7lo\t%-7lx\t" : "%-7lu\t%-7lx\t"),
	  (unsigned long)total, (unsigned long)total);

  fputs(bfd_get_filename(abfd), stdout);
  if (abfd->my_archive) printf (" (ex %s)", abfd->my_archive->filename);
}

/* I REALLY miss lexical functions! */
bfd_size_type svi_total = 0;

void
sysv_internal_printer(file, sec, ignore)
     bfd *file;
     sec_ptr sec;
     PTR ignore;
{
  bfd_size_type size = bfd_section_size (file, sec);
  if (sec!= &bfd_abs_section 
      && ! bfd_is_com_section (sec)
      && sec!=&bfd_und_section) 
  {
  
    svi_total += size;
	
    printf ("%-12s", bfd_section_name(file, sec));
    rprint_number (8, size);
    printf(" ");
    rprint_number (8, bfd_section_vma(file, sec));
    printf ("\n");
  }

}

void
print_sysv_format(file)
     bfd *file;
{
  svi_total = 0;

  printf ("%s  ", bfd_get_filename (file));
  if (file->my_archive) printf (" (ex %s)", file->my_archive->filename);

  puts(":\nsection\t\tsize\t     addr");
  bfd_map_over_sections (file, sysv_internal_printer, (PTR)NULL);

  printf("Total       ");
  rprint_number(8, svi_total);
  printf("\n");  printf("\n");
}

static void
print_sizes(file)
     bfd *file;
{
  if (berkeley_format)
    print_berkeley_format(file);
  else print_sysv_format(file);
}
Commit	Line	Data
770cde30	1	/* size.c -- report size of various sections of an executable file.
e2fe2df4	2	Copyright 1991, 1992 Free Software Foundation, Inc.
770cde30 JG	3
	4	This file is part of GNU Binutils.
	5
	6	This program is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 2 of the License, or
	9	(at your option) any later version.
	10
	11	This program is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with this program; if not, write to the Free Software
	18	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
	19
	20
2fa0b342 DHW	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
d2442698	29	out of luck; there's no --predantic option.
2fa0b342	30	*/
770cde30	31
2fa0b342	32	#include "bfd.h"
770cde30	33	#include "sysdep.h"
2fa0b342 DHW	34	#include "getopt.h"
2fa0b342 DHW	35
2fa0b342 DHW	36	#ifndef BSD_DEFAULT
	37	#define BSD_DEFAULT 1
	38	#endif
	39
2fa0b342 DHW	40	/* Various program options */
	41
	42	enum {decimal, octal, hex} radix = decimal;
	43	int berkeley_format = BSD_DEFAULT; /* 0 means use AT&T-style output */
	44	int show_version = 0;
	45	int show_help = 0;
	46
770cde30 JG	47	int return_code = 0;
770cde30 JG	48
2fa0b342 DHW	49	/* IMPORTS */
	50	extern char *program_version;
	51	extern char *program_name;
	52	extern char *target;
e2fe2df4 PB	53
	54	/* Forward declarations */
	55
	56	static void
	57	display_file PARAMS ((char *filename));
	58
	59	static void
	60	print_sizes PARAMS ((bfd *file));
2fa0b342 DHW	61	\f
	62	/** main and like trivia */
	63
	64	void
	65	usage ()
	66	{
d2442698 DM	67	fprintf (stderr, "size %s\n\
	68	Usage: %s [-ABdoxV] [--format=berkeley\|sysv] [--radix=8\|10\|16]\n\
	69	[--target=bfdname] [--version] [--help] [file...]\n",
	70	program_version, program_name);
2fa0b342	71	#if BSD_DEFAULT
d2442698	72	fputs (" (default is --format=berkeley)\n", stderr);
2fa0b342	73	#else
d2442698	74	fputs (" (default is --format=sysv)\n", stderr);
2fa0b342	75	#endif
d2442698	76	exit (1);
2fa0b342 DHW	77	}
2fa0b342 DHW	78
d2442698 DM	79	struct option long_options[] = {
	80	{"format", required_argument, 0, 200},
	81	{"radix", required_argument, 0, 201},
	82	{"target", required_argument, 0, 202},
	83	{"version", no_argument, &show_version, 1},
	84	{"help", no_argument, &show_help, 1},
	85	{0, no_argument, 0, 0}
	86	};
2fa0b342 DHW	87
	88	int
	89	main (argc, argv)
	90	int argc;
	91	char **argv;
	92	{
	93	int temp;
	94	int c; /* sez which option char */
2fa0b342	95	extern int optind; /* steps thru options */
d2442698	96
2fa0b342 DHW	97	program_name = *argv;
2fa0b342 DHW	98
770cde30 JG	99	bfd_init();
770cde30 JG	100
2fa0b342	101	while ((c = getopt_long(argc, argv, "ABVdox", long_options,
d2442698	102	(int *) 0)) != EOF)
2fa0b342	103	switch(c) {
d2442698	104	case 200: /* --format */
2fa0b342 DHW	105	switch(*optarg) {
	106	case 'B': case 'b': berkeley_format = 1; break;
	107	case 'S': case 's': berkeley_format = 0; break;
d2442698	108	default: fprintf(stderr, "invalid argument to --format: %s\n", optarg);
2fa0b342 DHW	109	usage();
	110	}
	111	break;
2fa0b342	112
d2442698	113	case 202: /* --target */
2fa0b342 DHW	114	target = optarg;
2fa0b342 DHW	115	break;
2fa0b342	116
d2442698	117	case 201: /* --radix */
2fa0b342 DHW	118	#ifdef ANSI_LIBRARIES
	119	temp = strtol(optarg, NULL, 10);
	120	#else
	121	temp = atol(optarg);
	122	#endif
	123	switch(temp) {
	124	case 10: radix = decimal; break;
	125	case 8: radix = octal; break;
	126	case 16: radix = hex; break;
	127	default: printf("Unknown radix: %s\n", optarg);
	128	usage();
	129	}
d2442698 DM	130	break;
d2442698 DM	131
2fa0b342 DHW	132	case 'A': berkeley_format = 0; break;
	133	case 'B': berkeley_format = 1; break;
	134	case 'V': show_version = 1; break;
	135	case 'd': radix = decimal; break;
	136	case 'x': radix = hex; break;
	137	case 'o': radix = octal; break;
	138	case '?': usage();
	139	}
	140
	141	if (show_version) printf("%s version %s\n", program_name, program_version);
	142	if (show_help) usage();
	143
2fa0b342 DHW	144	if (optind == argc)
	145	display_file ("a.out");
	146	else
	147	for (; optind < argc;)
	148	display_file (argv[optind++]);
	149
770cde30	150	return return_code;
2fa0b342 DHW	151	}
	152	\f
	153	/** Display a file's stats */
	154
	155	void
	156	display_bfd (abfd)
	157	bfd *abfd;
	158	{
770cde30	159	CONST char *core_cmd;
2fa0b342 DHW	160
	161	if (bfd_check_format(abfd, bfd_archive)) return;
	162
	163	if (bfd_check_format(abfd, bfd_object)) {
	164	print_sizes(abfd);
	165	goto done;
	166	}
	167
	168	if (bfd_check_format(abfd, bfd_core)) {
	169	print_sizes(abfd);
	170	fputs(" (core file", stdout);
	171
	172	core_cmd = bfd_core_file_failing_command(abfd);
	173	if (core_cmd) printf(" invoked as %s", core_cmd);
	174
	175	puts(")");
	176	goto done;
	177	}
	178
	179	printf("Unknown file format: %s.", bfd_get_filename(abfd));
770cde30	180	return_code = 3;
2fa0b342 DHW	181
	182	done:
	183
	184
	185	printf("\n");
	186	return;
	187	}
	188
e2fe2df4	189	static void
2fa0b342 DHW	190	display_file(filename)
	191	char *filename;
	192	{
	193	bfd file, arfile = (bfd *) NULL;
	194
	195	file = bfd_openr (filename, target);
	196	if (file == NULL) {
d2442698	197	fprintf (stderr, "%s: ", program_name);
2fa0b342	198	bfd_perror (filename);
770cde30	199	return_code = 1;
2fa0b342 DHW	200	return;
	201	}
	202
	203	if (bfd_check_format(file, bfd_archive) == true) {
	204	for(;;) {
	205
	206	bfd_error = no_error;
	207
	208	arfile = bfd_openr_next_archived_file (file, arfile);
	209	if (arfile == NULL) {
770cde30	210	if (bfd_error != no_more_archived_files) {
d2442698	211	fprintf (stderr, "%s: ", program_name);
2fa0b342	212	bfd_perror (bfd_get_filename (file));
770cde30 JG	213	return_code = 2;
770cde30 JG	214	}
2fa0b342 DHW	215	return;
	216	}
	217
	218	display_bfd (arfile);
	219	/* Don't close the archive elements; we need them for next_archive */
	220	}
	221	}
	222	else
	223	display_bfd (file);
	224
	225	bfd_close (file);
	226	}
	227	\f
	228	/* This is what lexical functions are for */
	229	void
	230	lprint_number (width, num)
e2fe2df4 PB	231	int width;
e2fe2df4 PB	232	bfd_size_type num;
2fa0b342	233	{
d2442698 DM	234	printf ((radix == decimal ? "%-*lu\t" :
	235	((radix == octal) ? "%-lo\t" : "%-lx\t")),
	236	width, (unsigned long)num);
2fa0b342 DHW	237	}
	238
	239	void
	240	rprint_number(width, num)
e2fe2df4 PB	241	int width;
e2fe2df4 PB	242	bfd_size_type num;
2fa0b342	243	{
d2442698 DM	244	printf ((radix == decimal ? "%*lu\t" :
	245	((radix == octal) ? "%lo\t" : "%lx\t")),
	246	width, (unsigned long)num);
2fa0b342 DHW	247	}
	248
	249	static char *bss_section_name = ".bss";
	250	static char *data_section_name = ".data";
	251	static char *stack_section_name = ".stack";
	252	static char *text_section_name = ".text";
	253
	254	void print_berkeley_format(abfd)
	255	bfd *abfd;
	256	{
770cde30	257	static int files_seen = 0;
2fa0b342 DHW	258	sec_ptr bsssection = NULL;
	259	sec_ptr datasection = NULL;
	260	sec_ptr textsection = NULL;
e2fe2df4 PB	261	bfd_size_type bsssize = 0;
	262	bfd_size_type datasize = 0;
	263	bfd_size_type textsize = 0;
	264	bfd_size_type total = 0;
2fa0b342 DHW	265
	266
	267	if ((textsection = bfd_get_section_by_name (abfd, text_section_name))
	268	!= NULL) {
770cde30	269	textsize = bfd_get_section_size_before_reloc (textsection);
2fa0b342 DHW	270	}
	271
	272	if ((datasection = bfd_get_section_by_name (abfd, data_section_name))
	273	!= NULL) {
770cde30	274	datasize = bfd_get_section_size_before_reloc ( datasection);
2fa0b342 DHW	275	}
	276
	277	if (bfd_get_format (abfd) == bfd_object) {
	278	if ((bsssection = bfd_get_section_by_name (abfd, bss_section_name))
	279	!= NULL) {
	280	bsssize = bfd_section_size(abfd, bsssection);
	281	}
	282	} else {
	283	if ((bsssection = bfd_get_section_by_name (abfd, stack_section_name))
	284	!= NULL) {
	285	bsssize = bfd_section_size(abfd, bsssection);
	286	}
	287	}
770cde30 JG	288
	289	if (files_seen++ == 0)
	290	#if 0 /* intel doesn't like bss/stk b/c they don't gave core files */
	291	puts((radix == octal) ? "text\tdata\tbss/stk\toct\thex\tfilename" :
	292	"text\tdata\tbss/stk\tdec\thex\tfilename");
	293	#else
	294	puts((radix == octal) ? "text\tdata\tbss\toct\thex\tfilename" :
	295	"text\tdata\tbss\tdec\thex\tfilename");
	296	#endif
2fa0b342 DHW	297
	298	total = textsize + datasize + bsssize;
	299
	300	lprint_number (7, textsize);
	301	lprint_number (7, datasize);
	302	lprint_number (7, bsssize);
d2442698 DM	303	printf (((radix == octal) ? "%-7lo\t%-7lx\t" : "%-7lu\t%-7lx\t"),
d2442698 DM	304	(unsigned long)total, (unsigned long)total);
2fa0b342 DHW	305
	306	fputs(bfd_get_filename(abfd), stdout);
	307	if (abfd->my_archive) printf (" (ex %s)", abfd->my_archive->filename);
	308	}
	309
	310	/* I REALLY miss lexical functions! */
e2fe2df4	311	bfd_size_type svi_total = 0;
2fa0b342 DHW	312
2fa0b342 DHW	313	void
770cde30	314	sysv_internal_printer(file, sec, ignore)
2fa0b342 DHW	315	bfd *file;
2fa0b342 DHW	316	sec_ptr sec;
770cde30	317	PTR ignore;
2fa0b342	318	{
e2fe2df4	319	bfd_size_type size = bfd_section_size (file, sec);
770cde30	320	if (sec!= &bfd_abs_section
d2442698	321	&& ! bfd_is_com_section (sec)
770cde30 JG	322	&& sec!=&bfd_und_section)
	323	{
	324
	325	svi_total += size;
2fa0b342	326
770cde30 JG	327	printf ("%-12s", bfd_section_name(file, sec));
	328	rprint_number (8, size);
	329	printf(" ");
	330	rprint_number (8, bfd_section_vma(file, sec));
	331	printf ("\n");
	332	}
	333
2fa0b342 DHW	334	}
	335
	336	void
	337	print_sysv_format(file)
	338	bfd *file;
	339	{
	340	svi_total = 0;
	341
	342	printf ("%s ", bfd_get_filename (file));
	343	if (file->my_archive) printf (" (ex %s)", file->my_archive->filename);
	344
	345	puts(":\nsection\t\tsize\t addr");
770cde30	346	bfd_map_over_sections (file, sysv_internal_printer, (PTR)NULL);
2fa0b342 DHW	347
	348	printf("Total ");
	349	rprint_number(8, svi_total);
	350	printf("\n"); printf("\n");
	351	}
	352
e2fe2df4	353	static void
2fa0b342 DHW	354	print_sizes(file)
	355	bfd *file;
	356	{
	357	if (berkeley_format)
	358	print_berkeley_format(file);
	359	else print_sysv_format(file);
	360	}