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

/*** objdump.c -- dump information about an object file. */

/* Copyright (C) 1990, 1991 Free Software Foundation, Inc.

This file is part of BFD, the Binary File Diddler.

BFD 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 1, or (at your option)
any later version.

BFD 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 BFD; see the file COPYING.  If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */

/* 
   $Id$
*/
/*
 * Until there is other documentation, refer to the manual page dump(1) in
 * the system 5 program's reference manual
 */

#include "sysdep.h"
#include "bfd.h"
#include "getopt.h"
#include <stdio.h>
#include <ctype.h>


char *xmalloc();

char *default_target = NULL;	/* default at runtime */

char *program_name = NULL;

int dump_section_contents;	/* -s */
int dump_section_headers;	/* -h */
boolean dump_file_header;	/* -f */
int dump_symtab;		/* -t */
int dump_reloc_info;		/* -r */
int dump_ar_hdrs;		/* -a */
int with_line_numbers;          /* -l */
boolean disassemble;             /* -d */
boolean info;	             /* -i */
char *only;

PROTO (void, display_file, (char *filename, char *target));
PROTO (void, dump_data, (bfd *abfd));
PROTO (void, dump_relocs, (bfd *abfd));
PROTO (void, dump_symbols, (bfd *abfd));
PROTO (void, print_arelt_descr, (bfd *abfd, boolean verbose));


\f
char *machine = (char *)NULL;
  asymbol **syms;
  asymbol **syms2;


unsigned int storage;

unsigned int symcount = 0;

void
usage ()
{
  fprintf (stderr,
	   "usage: %s [-ahifdrtxsl] [-m machine] [-j section_name] obj ...\n",
	   program_name);
  exit (1);
}

static struct option long_options[] = 
	{{"syms",   0, &dump_symtab,	      1},
	 {"reloc",  0, &dump_reloc_info,      1},
	 {"header", 0, &dump_section_headers, 1},
	 {0, 0, 0, 0}};


static void
dump_headers(abfd)
bfd *abfd;
{
  asection *section;
  for (section = abfd->sections;
       section != (asection *) NULL;
       section = section->next) 
    {
      char *comma = "";
#define PF(x,y) \
      if (section->flags & x) {  printf("%s%s",comma,y); comma = ", "; }

      printf("SECTION %d [%s]\t: size %08x",
	     section->index,
	     section->name,
(unsigned)     section->size);
      printf(" vma ");
printf_vma(section->vma);
printf(" align 2**%2u\n ",
	     section->alignment_power);
      PF(SEC_ALLOC,"ALLOC");
      PF(SEC_LOAD,"LOAD");
      PF(SEC_RELOC,"RELOC");
      PF(SEC_BALIGN,"BALIGN");
      PF(SEC_READONLY,"READONLY");
      PF(SEC_CODE,"CODE");
      PF(SEC_DATA,"DATA");
      PF(SEC_ROM,"ROM");
      printf("\n");
#undef PF
    }
}

static asymbol **
slurp_symtab(abfd)
bfd *abfd;
{
  asymbol **sy;
  if (!(bfd_get_file_flags (abfd) & HAS_SYMS)) {
    (void) printf ("No symbols in \"%s\".\n", bfd_get_filename (abfd));
    return(NULL);
  }

  storage = get_symtab_upper_bound (abfd);
  if (storage) {
    sy = (asymbol **) malloc (storage);
    if (sy == NULL) {
      fprintf (stderr, "%s: out of memory.\n", program_name);
      exit (1);
    }
  }
  symcount = bfd_canonicalize_symtab (abfd, sy);
return sy;
}
/* Sort symbols into value order */
static int comp(ap,bp)
asymbol **ap;
asymbol **bp;
{
  asymbol *a = *ap;
  asymbol *b = *bp;
  int diff;

  if ( a->name== (char *)NULL || (a->flags &( BSF_DEBUGGING| BSF_UNDEFINED) )) 
    a->the_bfd = 0;
  if  ( b->name== (char *)NULL || (b->flags &( BSF_DEBUGGING|BSF_UNDEFINED))) 
    b->the_bfd =0;

  diff = a->the_bfd - b->the_bfd;
  if (diff) {
    return -diff;
  }
  diff = a->value - b->value;
  if (diff) {
    return diff;
  }
  return   a->section - b->section;
}

/* Print the supplied address symbolically if possible */
void
print_address(vma, stream)
bfd_vma vma;
FILE *stream;
{
  /* Perform a binary search looking for the closest symbol to
     the required value */

  unsigned int min = 0;
  unsigned int max = symcount;

  unsigned int thisplace = 1;
  unsigned int oldthisplace ;

  int vardiff;
  if (symcount == 0) {
    fprintf_vma(stream, vma);
  }
  else {
    while (true) {
      oldthisplace = thisplace;
      thisplace = (max + min )/2  ;
      if (thisplace == oldthisplace) break;
	vardiff = syms[thisplace]->value - vma;

      if (vardiff) {
	if (vardiff > 0) {
	  max = thisplace;
	}
	else {
	  min = thisplace;
	}
      }
      else {
  	/* Totally awesome! the exact right symbol */
 	char *match_name = syms[thisplace]->name;
 	int sym_len = strlen(match_name);
 	/* Avoid "filename.o" as a match */
 	if (sym_len > 2
 	    && match_name[sym_len - 2] == '.'
 	    && match_name[sym_len - 1] == 'o'
 	    && thisplace + 1 < symcount
 	    && syms[thisplace+1]->value == vma)
 	    match_name = syms[thisplace+1]->name;
	/* Totally awesome! the exact right symbol */
	fprintf_vma(stream, vma);
	fprintf(stream," (%s)", syms[thisplace]->name);
	return;
      }
    }
    /* We've run out of places to look, print the symbol before this one */
    /* see if this or the symbol before describes this location the best */

    if (thisplace != 0) {
      if (syms[thisplace-1]->value - vma >
	  syms[thisplace]->value-vma) {
	/* Previous symbol is in correct section and is closer */
	thisplace --;
      }
    }
    
      fprintf_vma(stream, vma);
    if (syms[thisplace]->value > vma) {
      fprintf(stream," (%s-)", syms[thisplace]->name);
      fprintf_vma(stream,  syms[thisplace]->value - vma);

    }
    else {
      fprintf(stream," (%s+)", syms[thisplace]->name);
      fprintf_vma(stream, vma -  syms[thisplace]->value);


    }
  }
}

void
disassemble_data(abfd)
bfd *abfd;
{
  bfd_byte *data = NULL;
  bfd_size_type datasize = 0;
  bfd_size_type i;
  int (*print)() ;
  int print_insn_m68k();
  int print_insn_i960();
  int print_insn_sparc();
  enum bfd_architecture a;
  unsigned long m;
  asection *section;
  /* Replace symbol section relative values with abs values */
  boolean done_dot = false;
  
  for (i = 0; i < symcount; i++) {
    if (syms[i]->section != (asection *)NULL) {
      syms[i]->value += syms[i]->section->vma;
    }
  }

  /* We keep a copy of the symbols in the original order */
  syms2 = slurp_symtab(abfd);

  /* Sort the symbols into section and symbol order */
  (void)   qsort(syms, symcount, sizeof(asymbol *), comp);

  /* Find the first useless symbol */
    { unsigned int i;
      for (i =0; i < symcount; i++) {
	if (syms[i]->the_bfd == 0) {
	  symcount =i;
	  break;
	}
      }
    }


  if (machine!= (char *)NULL) {
    if (bfd_scan_arch_mach(machine, &a, &m) == false) {
      fprintf(stderr,"%s: Can't use supplied machine %s\n",
	      program_name,
	      machine);
      exit(1);
    }
  }
  else {
    a =   bfd_get_architecture(abfd);
  }
  switch (a) {

  case bfd_arch_sparc:
    print = print_insn_sparc;
    break;
  case bfd_arch_m68k:
    print = print_insn_m68k;
    break;
  case bfd_arch_i960:
    print = print_insn_i960;
    break;
  default:
    fprintf(stderr,"%s: Can't disassemble for architecture %s\n",
	    program_name,
	    bfd_printable_arch_mach(bfd_get_architecture(abfd),0));
    exit(1);
  }


  for (section = abfd->sections;
       section != (asection *)NULL;
       section =  section->next) {

    if (only == (char *)NULL || strcmp(only,section->name) == 0){
      printf("Disassembly of section %s:\n", section->name);

      if (section->size == 0) continue;

      data = (bfd_byte *)malloc(section->size);

      if (data == (bfd_byte *)NULL) {
	fprintf (stderr, "%s: memory exhausted.\n", program_name);
	exit (1);
      }
      datasize = section->size;


      bfd_get_section_contents (abfd, section, data, 0, section->size);

      i = 0;
      while (i <section->size) {
	if (data[i] ==0 && data[i+1] == 0 && data[i+2] == 0 &&
	    data[i+3] == 0) {
	  if (done_dot == false) {
	    printf("...\n");
	    done_dot=true;
	  }
	  i+=4;
	}
	else {
	  done_dot = false;
	  if (with_line_numbers) {
	    static prevline;
	    CONST char *filename;
	    CONST char *functionname;
	    unsigned int line;
	    bfd_find_nearest_line(abfd,
				  section,
				  syms,
				  section->vma + i,
				  &filename,
				  &functionname,
				  &line);

	    if (filename && functionname && line && line != prevline) {
	      printf("%s:%u\n", filename, line);
	      prevline = line;
	    }
	  }
	  print_address(section->vma + i, stdout);
	  printf(" ");

	  i +=   print(section->vma + i, 
		       data + i,
		       stdout);
	  putchar ('\n')  ;  
	}
      }


      free(data);
    }
  }
}

void
display_bfd (abfd)
     bfd *abfd;
{

  if (!bfd_check_format (abfd, bfd_object)) {
    fprintf (stderr,"%s: %s not an object file\n", program_name,
	     abfd->filename);
    return;
  }
  printf ("\n%s:     file format %s\n", abfd->filename, abfd->xvec->name);
  if (dump_ar_hdrs) print_arelt_descr (abfd, true);

  if (dump_file_header) {
    char *comma = "";

    printf("architecture: %s, ",
	   bfd_printable_arch_mach (bfd_get_architecture (abfd),
				    bfd_get_machine (abfd)));
    printf("flags 0x%08x:\n", abfd->flags);
    
#define PF(x, y)    if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
    PF(HAS_RELOC, "HAS_RELOC");
    PF(EXEC_P, "EXEC_P");
    PF(HAS_LINENO, "HAS_LINENO");
    PF(HAS_DEBUG, "HAS_DEBUG");
    PF(HAS_SYMS, "HAS_SYMS");
    PF(HAS_LOCALS, "HAS_LOCALS");
    PF(DYNAMIC, "DYNAMIC");
    PF(WP_TEXT, "WP_TEXT");
    PF(D_PAGED, "D_PAGED");
    printf("\nstart address 0x");
    printf_vma(abfd->start_address);
  }
  printf("\n");

  if (dump_section_headers)
    dump_headers(abfd);
  if (dump_symtab || dump_reloc_info || disassemble) {
syms =  slurp_symtab(abfd);
  }
  if (dump_symtab) dump_symbols (abfd);
  if (dump_reloc_info) dump_relocs(abfd);
  if (dump_section_contents) dump_data (abfd);
  if (disassemble) disassemble_data(abfd);
}

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

  file = bfd_openr (filename, target);
  if (file == NULL) {
    bfd_perror (filename);
    return;
  }

  if (bfd_check_format (file, bfd_archive) == true) {
    printf ("In archive %s:\n", bfd_get_filename (file));
    for(;;) {
      bfd_error = no_error;

      arfile = bfd_openr_next_archived_file (file, arfile);
      if (arfile == NULL) {
	if (bfd_error != no_more_archived_files)
	  bfd_perror (bfd_get_filename(file));
	return;
      }

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

  bfd_close(file);
}
\f
/* Actually display the various requested regions */


void
dump_data (abfd)
     bfd *abfd;
{
  asection *section;
  bfd_byte  *data ;
  bfd_size_type datasize = 0;
  bfd_size_type i;

  for (section = abfd->sections; section != NULL; section =
       section->next) {
    int onaline = 16;

    if (only == (char *)NULL || 
	strcmp(only,section->name) == 0){


      printf("Contents of section %s:\n", section->name);

      if (section->size == 0) continue;
      data = (bfd_byte *)malloc(section->size);
      if (data == (bfd_byte *)NULL) {
	fprintf (stderr, "%s: memory exhausted.\n", program_name);
	exit (1);
      }
      datasize = section->size;


      bfd_get_section_contents (abfd, section, (PTR)data, 0, section->size);

      for (i= 0; i < section->size; i += onaline) {
	bfd_size_type j;
	printf(" %04lx ", (unsigned long int)(i + section->vma));
	for (j = i; j < i+ onaline; j++) {
	  if (j < section->size)
	    printf("%02x", (unsigned)(data[j]));
	  else 
	    printf("  ");
	  if ((j & 3 ) == 3) printf(" ");
	}

	printf(" ");
	for (j = i; j < i+onaline ; j++) {
	  if (j >= section->size)
	    printf(" ");
	  else
	    printf("%c", isprint(data[j]) ?data[j] : '.');
	}
	putchar ('\n');
      }
    }

    free (data);
  }
}


/* Should perhaps share code and display with nm? */
void
dump_symbols (abfd)
     bfd *abfd;
{

  unsigned int count;
  asymbol **current = syms;
  printf("SYMBOL TABLE:\n");

  for (count = 0; count < symcount; count++) {
    if ((*current)->the_bfd) {
      bfd_print_symbol((*current)->the_bfd,
		       stdout,
		       *current, bfd_print_symbol_all_enum);

      printf("\n");
    }
    current++;
  }
  printf("\n");
  printf("\n");
}


void
dump_relocs(abfd)
bfd *abfd;
{
  arelent **relpp;
  unsigned int relcount;
  asection *a;
  for (a = abfd->sections; a != (asection *)NULL; a = a->next) {
    printf("RELOCATION RECORDS FOR [%s]:",a->name);
    
    if (get_reloc_upper_bound(abfd, a) == 0) {
      printf(" (none)\n\n");
    }
    else {
      arelent **p;

      relpp = (arelent **) xmalloc( get_reloc_upper_bound(abfd,a) );
      relcount = bfd_canonicalize_reloc(abfd,a,relpp, syms);
      if (relcount == 0) {
	printf(" (none)\n\n");
      }
      else {
	printf("\n");
	printf("OFFSET   TYPE      VALUE \n");

	for (p =relpp; relcount && *p != (arelent *)NULL; p++,
	     relcount --) {
	  arelent *q = *p;
	  CONST char *sym_name;
	  CONST char *section_name =	    q->section == (asection *)NULL ? "*abs" :
	  q->section->name;
	  if (q->sym_ptr_ptr && *q->sym_ptr_ptr) {
	    sym_name =  (*(q->sym_ptr_ptr))->name ;
	  }
	  else {
	    sym_name = 0;
	  }
	  if (sym_name) {
	    printf_vma(q->address);
	    printf(" %-8s  %s",
		   q->howto->name,
		   sym_name);
	  }
	  else {
	    printf_vma(q->address);
	    printf(" %-8s  [%s]",
		   q->howto->name,
		   section_name);
	  }
	  if (q->addend) {
	    printf("+0x");
	    printf_vma(q->addend);
	  }
	  printf("\n");
	}
	printf("\n\n");
	free(relpp);
      }
    }

  }
}

static void
DEFUN_VOID(display_info)
{
  unsigned int i;
  extern bfd_target *target_vector[];

  enum	    bfd_architecture j;
  i = 0;
  printf("BFD header file version %s\n", BFD_VERSION);
  while (target_vector[i] != (bfd_target *)NULL) 
      {
	bfd_target *p = target_vector[i];
	bfd *abfd = bfd_openw("##dummy",p->name);
	printf("%s\n (header %s, data %s)\n", p->name,	
	       p->header_byteorder_big_p ? "big endian" : "little endian",
	       p->byteorder_big_p ? "big endian" : "little endian" );
	  {
	    enum	    bfd_architecture j;
	    for (j = (int)bfd_arch_obscure +1; j <(int) bfd_arch_last; j++) 
		{
		  if (bfd_set_arch_mach(abfd, j, 0)) 
		      {
			printf("  %s\n", bfd_printable_arch_mach(j,0));
		      }
		}

	  }
	i++;
      }
  /* Again as a table */
  printf("%12s"," ");
  for (i = 0; target_vector[i]; i++) {
    printf("%s ",target_vector[i]->name);
  }
  printf("\n");
  for (j = (int)bfd_arch_obscure +1; (int)j <(int) bfd_arch_last; j++) {
    printf("%11s ", bfd_printable_arch_mach(j,0));
    for (i = 0; target_vector[i]; i++) {
	{
	  bfd_target *p = target_vector[i];
	  bfd *abfd = bfd_openw("##dummy",p->name);
	  int l = strlen(p->name);
	  int ok = bfd_set_arch_mach(abfd, j, 0);
	  if (ok) {
	    printf("%s ", p->name);
	  }
	  else {
	    while (l--) {
	      printf("%c",ok?'*':'-');
	    }
	    printf(" ");
	  }

	}
    }

    printf("\n");
  }
}
/** main and like trivia */
int
main (argc, argv)
     int argc;
     char **argv;
{
  int c;
  extern int optind;
  extern char *optarg;
  char *target = default_target;
  boolean seenflag = false;
  int ind = 0;

  program_name = *argv;

  while ((c = getopt_long (argc, argv, "Aib:m:dlfahrtxsj:", long_options, &ind))
	 != EOF) {
    seenflag = true;
    switch (c) {
    case 'm':
      machine = optarg;
      break;
    case 'j':
      only = optarg;
      break;
    case 'l':
      with_line_numbers = 1;
      break;
    case 'b':
      target = optarg;
      break;
    case 'f':
      dump_file_header = true;
      break;
    case 'i':
      info = true;
      break;
    case 'x':
      dump_symtab = 1; 
      dump_reloc_info = 1;
      dump_file_header = true;
      dump_ar_hdrs = 1;
      dump_section_headers = 1;
      break;
 case 'A':
      disassemble = true;
      dump_ar_hdrs = 1;
      dump_file_header = true;
      dump_reloc_info = 1;
      dump_section_headers = 1;
      dump_symtab = 1; 
      break;
      
    case  0 : break;		/* we've been given a long option */
    case 't': dump_symtab = 1; break;
    case 'd': disassemble = true ; break;
    case 's': dump_section_contents = 1; break;
    case 'r': dump_reloc_info = 1; break;
    case 'a': dump_ar_hdrs = 1; break;
    case 'h': dump_section_headers = 1; break;
    default:
      usage ();
    }
  }

  if (seenflag == false)
    usage ();

  if (info) {
    display_info();
  }
  else {
  if (optind == argc)
    display_file ("a.out", target);
  else
    for (; optind < argc;)
      display_file (argv[optind++], target);
}
  return 0;
}
Commit	Line	Data
2fa0b342 DHW	1	/*** objdump.c -- dump information about an object file. */
	2
	3	/* Copyright (C) 1990, 1991 Free Software Foundation, Inc.
	4
	5	This file is part of BFD, the Binary File Diddler.
	6
	7	BFD 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 1, or (at your option)
	10	any later version.
	11
	12	BFD 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 BFD; see the file COPYING. If not, write to
	19	the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
	20
	21	/*
	22	$Id$
2fa0b342 DHW	23	*/
	24	/*
	25	* Until there is other documentation, refer to the manual page dump(1) in
	26	* the system 5 program's reference manual
	27	*/
	28
	29	#include "sysdep.h"
	30	#include "bfd.h"
	31	#include "getopt.h"
	32	#include <stdio.h>
	33	#include <ctype.h>
	34
bf661056 SC	35
bf661056 SC	36
2fa0b342 DHW	37	char *xmalloc();
	38
	39	char default_target = NULL; / default at runtime */
	40
	41	char *program_name = NULL;
	42
	43	int dump_section_contents; /* -s */
	44	int dump_section_headers; /* -h */
	45	boolean dump_file_header; /* -f */
	46	int dump_symtab; /* -t */
	47	int dump_reloc_info; /* -r */
	48	int dump_ar_hdrs; /* -a */
	49	int with_line_numbers; /* -l */
	50	boolean disassemble; /* -d */
9872a49c	51	boolean info; /* -i */
2fa0b342 DHW	52	char *only;
	53
	54	PROTO (void, display_file, (char filename, char target));
	55	PROTO (void, dump_data, (bfd *abfd));
	56	PROTO (void, dump_relocs, (bfd *abfd));
	57	PROTO (void, dump_symbols, (bfd *abfd));
	58	PROTO (void, print_arelt_descr, (bfd *abfd, boolean verbose));
	59
	60
	61
	62
	63
	64
	65	\f
	66	char machine = (char )NULL;
	67	asymbol **syms;
	68	asymbol **syms2;
	69
	70
	71	unsigned int storage;
	72
	73	unsigned int symcount = 0;
	74
	75	void
	76	usage ()
	77	{
	78	fprintf (stderr,
9872a49c	79	"usage: %s [-ahifdrtxsl] [-m machine] [-j section_name] obj ...\n",
2fa0b342 DHW	80	program_name);
	81	exit (1);
	82	}
	83
	84	static struct option long_options[] =
	85	{{"syms", 0, &dump_symtab, 1},
	86	{"reloc", 0, &dump_reloc_info, 1},
	87	{"header", 0, &dump_section_headers, 1},
	88	{0, 0, 0, 0}};
	89
	90
	91
	92	static void
	93	dump_headers(abfd)
	94	bfd *abfd;
	95	{
	96	asection *section;
	97	for (section = abfd->sections;
	98	section != (asection *) NULL;
	99	section = section->next)
	100	{
	101	char *comma = "";
	102	#define PF(x,y) \
	103	if (section->flags & x) { printf("%s%s",comma,y); comma = ", "; }
	104
	105	printf("SECTION %d [%s]\t: size %08x",
	106	section->index,
	107	section->name,
	108	(unsigned) section->size);
fc5d6074 SC	109	printf(" vma ");
	110	printf_vma(section->vma);
	111	printf(" align 2**%2u\n ",
2fa0b342 DHW	112	section->alignment_power);
	113	PF(SEC_ALLOC,"ALLOC");
	114	PF(SEC_LOAD,"LOAD");
	115	PF(SEC_RELOC,"RELOC");
	116	PF(SEC_BALIGN,"BALIGN");
	117	PF(SEC_READONLY,"READONLY");
	118	PF(SEC_CODE,"CODE");
	119	PF(SEC_DATA,"DATA");
	120	PF(SEC_ROM,"ROM");
	121	printf("\n");
	122	#undef PF
	123	}
	124	}
	125
	126	static asymbol **
	127	slurp_symtab(abfd)
	128	bfd *abfd;
	129	{
	130	asymbol **sy;
	131	if (!(bfd_get_file_flags (abfd) & HAS_SYMS)) {
	132	(void) printf ("No symbols in \"%s\".\n", bfd_get_filename (abfd));
	133	return(NULL);
	134	}
	135
	136	storage = get_symtab_upper_bound (abfd);
	137	if (storage) {
	138	sy = (asymbol **) malloc (storage);
	139	if (sy == NULL) {
	140	fprintf (stderr, "%s: out of memory.\n", program_name);
	141	exit (1);
	142	}
	143	}
	144	symcount = bfd_canonicalize_symtab (abfd, sy);
	145	return sy;
	146	}
	147	/* Sort symbols into value order */
	148	static int comp(ap,bp)
	149	asymbol **ap;
	150	asymbol **bp;
	151	{
	152	asymbol a = ap;
	153	asymbol b = bp;
	154	int diff;
	155
	156	if ( a->name== (char *)NULL \|\| (a->flags &( BSF_DEBUGGING\| BSF_UNDEFINED) ))
	157	a->the_bfd = 0;
	158	if ( b->name== (char *)NULL \|\| (b->flags &( BSF_DEBUGGING\|BSF_UNDEFINED)))
	159	b->the_bfd =0;
	160
	161	diff = a->the_bfd - b->the_bfd;
	162	if (diff) {
	163	return -diff;
	164	}
	165	diff = a->value - b->value;
	166	if (diff) {
	167	return diff;
	168	}
	169	return a->section - b->section;
	170	}
	171
	172	/* Print the supplied address symbolically if possible */
	173	void
	174	print_address(vma, stream)
	175	bfd_vma vma;
176	FILE *stream;
177	{
178	/* Perform a binary search looking for the closest symbol to
179	the required value */
180
181	unsigned int min = 0;
182	unsigned int max = symcount;
183
184	unsigned int thisplace = 1;
185	unsigned int oldthisplace ;
186
187	int vardiff;
fc5d6074 SC	188	if (symcount == 0) {
	189	fprintf_vma(stream, vma);
	190	}
2fa0b342 DHW	191	else {
	192	while (true) {
	193	oldthisplace = thisplace;
	194	thisplace = (max + min )/2 ;
	195	if (thisplace == oldthisplace) break;
2fa0b342 DHW	196	vardiff = syms[thisplace]->value - vma;
	197
	198	if (vardiff) {
	199	if (vardiff > 0) {
	200	max = thisplace;
	201	}
	202	else {
	203	min = thisplace;
	204	}
	205	}
	206	else {
fc5d6074 SC	207	/* Totally awesome! the exact right symbol */
	208	char *match_name = syms[thisplace]->name;
	209	int sym_len = strlen(match_name);
	210	/* Avoid "filename.o" as a match */
	211	if (sym_len > 2
	212	&& match_name[sym_len - 2] == '.'
	213	&& match_name[sym_len - 1] == 'o'
	214	&& thisplace + 1 < symcount
	215	&& syms[thisplace+1]->value == vma)
	216	match_name = syms[thisplace+1]->name;
2fa0b342	217	/* Totally awesome! the exact right symbol */
fc5d6074 SC	218	fprintf_vma(stream, vma);
fc5d6074 SC	219	fprintf(stream," (%s)", syms[thisplace]->name);
2fa0b342 DHW	220	return;
	221	}
	222	}
	223	/* We've run out of places to look, print the symbol before this one */
	224	/* see if this or the symbol before describes this location the best */
	225
	226	if (thisplace != 0) {
	227	if (syms[thisplace-1]->value - vma >
	228	syms[thisplace]->value-vma) {
	229	/* Previous symbol is in correct section and is closer */
	230	thisplace --;
	231	}
	232	}
	233
fc5d6074	234	fprintf_vma(stream, vma);
2fa0b342	235	if (syms[thisplace]->value > vma) {
fc5d6074 SC	236	fprintf(stream," (%s-)", syms[thisplace]->name);
fc5d6074 SC	237	fprintf_vma(stream, syms[thisplace]->value - vma);
2fa0b342 DHW	238
	239	}
	240	else {
fc5d6074 SC	241	fprintf(stream," (%s+)", syms[thisplace]->name);
	242	fprintf_vma(stream, vma - syms[thisplace]->value);
	243
	244
2fa0b342 DHW	245	}
	246	}
	247	}
	248
	249	void
	250	disassemble_data(abfd)
	251	bfd *abfd;
	252	{
	253	bfd_byte *data = NULL;
fc5d6074 SC	254	bfd_size_type datasize = 0;
fc5d6074 SC	255	bfd_size_type i;
2fa0b342 DHW	256	int (*print)() ;
	257	int print_insn_m68k();
	258	int print_insn_i960();
	259	int print_insn_sparc();
	260	enum bfd_architecture a;
	261	unsigned long m;
	262	asection *section;
	263	/* Replace symbol section relative values with abs values */
96d7950b	264	boolean done_dot = false;
2fa0b342 DHW	265
	266	for (i = 0; i < symcount; i++) {
	267	if (syms[i]->section != (asection *)NULL) {
	268	syms[i]->value += syms[i]->section->vma;
	269	}
	270	}
	271
	272	/* We keep a copy of the symbols in the original order */
	273	syms2 = slurp_symtab(abfd);
	274
	275	/* Sort the symbols into section and symbol order */
	276	(void) qsort(syms, symcount, sizeof(asymbol *), comp);
	277
	278	/* Find the first useless symbol */
fc5d6074 SC	279	{ unsigned int i;
	280	for (i =0; i < symcount; i++) {
	281	if (syms[i]->the_bfd == 0) {
	282	symcount =i;
	283	break;
	284	}
2fa0b342 DHW	285	}
2fa0b342 DHW	286	}
2fa0b342 DHW	287
	288
	289	if (machine!= (char *)NULL) {
	290	if (bfd_scan_arch_mach(machine, &a, &m) == false) {
	291	fprintf(stderr,"%s: Can't use supplied machine %s\n",
	292	program_name,
	293	machine);
	294	exit(1);
	295	}
	296	}
	297	else {
	298	a = bfd_get_architecture(abfd);
	299	}
	300	switch (a) {
	301
	302	case bfd_arch_sparc:
	303	print = print_insn_sparc;
	304	break;
	305	case bfd_arch_m68k:
	306	print = print_insn_m68k;
	307	break;
	308	case bfd_arch_i960:
	309	print = print_insn_i960;
	310	break;
	311	default:
	312	fprintf(stderr,"%s: Can't disassemble for architecture %s\n",
	313	program_name,
	314	bfd_printable_arch_mach(bfd_get_architecture(abfd),0));
	315	exit(1);
	316	}
	317
	318
	319	for (section = abfd->sections;
	320	section != (asection *)NULL;
	321	section = section->next) {
	322
	323	if (only == (char *)NULL \|\| strcmp(only,section->name) == 0){
	324	printf("Disassembly of section %s:\n", section->name);
	325
	326	if (section->size == 0) continue;
	327
	328	data = (bfd_byte *)malloc(section->size);
	329
	330	if (data == (bfd_byte *)NULL) {
	331	fprintf (stderr, "%s: memory exhausted.\n", program_name);
	332	exit (1);
	333	}
	334	datasize = section->size;
	335
	336
	337	bfd_get_section_contents (abfd, section, data, 0, section->size);
	338
	339	i = 0;
fc5d6074	340	while (i <section->size) {
96d7950b SC	341	if (data[i] ==0 && data[i+1] == 0 && data[i+2] == 0 &&
	342	data[i+3] == 0) {
	343	if (done_dot == false) {
	344	printf("...\n");
	345	done_dot=true;
2fa0b342	346	}
96d7950b	347	i+=4;
2fa0b342	348	}
96d7950b SC	349	else {
	350	done_dot = false;
	351	if (with_line_numbers) {
	352	static prevline;
	353	CONST char *filename;
	354	CONST char *functionname;
	355	unsigned int line;
	356	bfd_find_nearest_line(abfd,
	357	section,
	358	syms,
	359	section->vma + i,
	360	&filename,
	361	&functionname,
	362	&line);
	363
	364	if (filename && functionname && line && line != prevline) {
	365	printf("%s:%u\n", filename, line);
	366	prevline = line;
	367	}
	368	}
	369	print_address(section->vma + i, stdout);
	370	printf(" ");
2fa0b342	371
96d7950b SC	372	i += print(section->vma + i,
	373	data + i,
	374	stdout);
	375	putchar ('\n') ;
	376	}
2fa0b342 DHW	377	}
	378
	379
	380
2fa0b342 DHW	381	free(data);
	382	}
	383	}
	384	}
	385
	386	void
	387	display_bfd (abfd)
	388	bfd *abfd;
	389	{
	390
	391	if (!bfd_check_format (abfd, bfd_object)) {
	392	fprintf (stderr,"%s: %s not an object file\n", program_name,
	393	abfd->filename);
	394	return;
	395	}
	396	printf ("\n%s: file format %s\n", abfd->filename, abfd->xvec->name);
	397	if (dump_ar_hdrs) print_arelt_descr (abfd, true);
	398
	399	if (dump_file_header) {
	400	char *comma = "";
	401
	402	printf("architecture: %s, ",
	403	bfd_printable_arch_mach (bfd_get_architecture (abfd),
	404	bfd_get_machine (abfd)));
	405	printf("flags 0x%08x:\n", abfd->flags);
	406
	407	#define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
	408	PF(HAS_RELOC, "HAS_RELOC");
	409	PF(EXEC_P, "EXEC_P");
	410	PF(HAS_LINENO, "HAS_LINENO");
	411	PF(HAS_DEBUG, "HAS_DEBUG");
	412	PF(HAS_SYMS, "HAS_SYMS");
	413	PF(HAS_LOCALS, "HAS_LOCALS");
	414	PF(DYNAMIC, "DYNAMIC");
	415	PF(WP_TEXT, "WP_TEXT");
	416	PF(D_PAGED, "D_PAGED");
fc5d6074 SC	417	printf("\nstart address 0x");
fc5d6074 SC	418	printf_vma(abfd->start_address);
2fa0b342 DHW	419	}
	420	printf("\n");
	421
	422	if (dump_section_headers)
	423	dump_headers(abfd);
	424	if (dump_symtab \|\| dump_reloc_info \|\| disassemble) {
	425	syms = slurp_symtab(abfd);
	426	}
	427	if (dump_symtab) dump_symbols (abfd);
	428	if (dump_reloc_info) dump_relocs(abfd);
	429	if (dump_section_contents) dump_data (abfd);
	430	if (disassemble) disassemble_data(abfd);
	431	}
	432
	433	void
	434	display_file (filename, target)
	435	char *filename;
	436	char *target;
	437	{
	438	bfd file, arfile = (bfd *) NULL;
	439
	440	file = bfd_openr (filename, target);
	441	if (file == NULL) {
	442	bfd_perror (filename);
	443	return;
	444	}
	445
	446	if (bfd_check_format (file, bfd_archive) == true) {
	447	printf ("In archive %s:\n", bfd_get_filename (file));
	448	for(;;) {
	449	bfd_error = no_error;
	450
	451	arfile = bfd_openr_next_archived_file (file, arfile);
	452	if (arfile == NULL) {
	453	if (bfd_error != no_more_archived_files)
	454	bfd_perror (bfd_get_filename(file));
	455	return;
	456	}
	457
	458	display_bfd (arfile);
	459	/* Don't close the archive elements; we need them for next_archive */
	460	}
	461	}
	462	else
	463	display_bfd(file);
	464
	465	bfd_close(file);
	466	}
	467	\f
	468	/* Actually display the various requested regions */
	469
	470
	471
	472
	473
	474
	475
	476
	477
	478
	479	void
	480	dump_data (abfd)
	481	bfd *abfd;
	482	{
483	asection *section;
484	bfd_byte *data ;
fc5d6074 SC	485	bfd_size_type datasize = 0;
fc5d6074 SC	486	bfd_size_type i;
2fa0b342 DHW	487
	488	for (section = abfd->sections; section != NULL; section =
	489	section->next) {
	490	int onaline = 16;
	491
	492	if (only == (char *)NULL \|\|
	493	strcmp(only,section->name) == 0){
	494
	495
	496
	497	printf("Contents of section %s:\n", section->name);
	498
	499	if (section->size == 0) continue;
	500	data = (bfd_byte *)malloc(section->size);
	501	if (data == (bfd_byte *)NULL) {
	502	fprintf (stderr, "%s: memory exhausted.\n", program_name);
	503	exit (1);
	504	}
	505	datasize = section->size;
	506
	507
fc5d6074	508	bfd_get_section_contents (abfd, section, (PTR)data, 0, section->size);
2fa0b342 DHW	509
2fa0b342 DHW	510	for (i= 0; i < section->size; i += onaline) {
fc5d6074 SC	511	bfd_size_type j;
fc5d6074 SC	512	printf(" %04lx ", (unsigned long int)(i + section->vma));
2fa0b342 DHW	513	for (j = i; j < i+ onaline; j++) {
	514	if (j < section->size)
	515	printf("%02x", (unsigned)(data[j]));
	516	else
	517	printf(" ");
	518	if ((j & 3 ) == 3) printf(" ");
	519	}
	520
	521	printf(" ");
	522	for (j = i; j < i+onaline ; j++) {
	523	if (j >= section->size)
	524	printf(" ");
	525	else
	526	printf("%c", isprint(data[j]) ?data[j] : '.');
	527	}
	528	putchar ('\n');
	529	}
	530	}
	531
	532	free (data);
	533	}
	534	}
	535
	536
	537
	538	/* Should perhaps share code and display with nm? */
	539	void
	540	dump_symbols (abfd)
	541	bfd *abfd;
	542	{
	543
	544	unsigned int count;
	545	asymbol **current = syms;
	546	printf("SYMBOL TABLE:\n");
	547
	548	for (count = 0; count < symcount; count++) {
	549	if ((*current)->the_bfd) {
	550	bfd_print_symbol((*current)->the_bfd,
	551	stdout,
	552	*current, bfd_print_symbol_all_enum);
	553
	554	printf("\n");
	555	}
	556	current++;
	557	}
	558	printf("\n");
	559	printf("\n");
	560	}
	561
	562
	563	void
	564	dump_relocs(abfd)
	565	bfd *abfd;
	566	{
	567	arelent **relpp;
	568	unsigned int relcount;
	569	asection *a;
	570	for (a = abfd->sections; a != (asection *)NULL; a = a->next) {
	571	printf("RELOCATION RECORDS FOR [%s]:",a->name);
	572
	573	if (get_reloc_upper_bound(abfd, a) == 0) {
	574	printf(" (none)\n\n");
	575	}
	576	else {
577	arelent **p;
578
579	relpp = (arelent **) xmalloc( get_reloc_upper_bound(abfd,a) );
580	relcount = bfd_canonicalize_reloc(abfd,a,relpp, syms);
581	if (relcount == 0) {
582	printf(" (none)\n\n");
583	}
584	else {
585	printf("\n");
586	printf("OFFSET TYPE VALUE \n");
587
fc5d6074 SC	588	for (p =relpp; relcount && p != (arelent )NULL; p++,
fc5d6074 SC	589	relcount --) {
2fa0b342	590	arelent q = p;
bf661056 SC	591	CONST char *sym_name;
bf661056 SC	592	CONST char section_name = q->section == (asection )NULL ? "*abs" :
2fa0b342 DHW	593	q->section->name;
	594	if (q->sym_ptr_ptr && *q->sym_ptr_ptr) {
	595	sym_name = (*(q->sym_ptr_ptr))->name ;
	596	}
	597	else {
	598	sym_name = 0;
	599	}
	600	if (sym_name) {
fc5d6074 SC	601	printf_vma(q->address);
fc5d6074 SC	602	printf(" %-8s %s",
2fa0b342 DHW	603	q->howto->name,
	604	sym_name);
	605	}
	606	else {
fc5d6074 SC	607	printf_vma(q->address);
fc5d6074 SC	608	printf(" %-8s [%s]",
2fa0b342 DHW	609	q->howto->name,
	610	section_name);
	611	}
	612	if (q->addend) {
fc5d6074 SC	613	printf("+0x");
fc5d6074 SC	614	printf_vma(q->addend);
2fa0b342 DHW	615	}
	616	printf("\n");
	617	}
	618	printf("\n\n");
	619	free(relpp);
	620	}
	621	}
	622
	623	}
	624	}
	625
9872a49c SC	626	static void
	627	DEFUN_VOID(display_info)
	628	{
	629	unsigned int i;
	630	extern bfd_target *target_vector[];
	631
	632	enum bfd_architecture j;
	633	i = 0;
	634	printf("BFD header file version %s\n", BFD_VERSION);
	635	while (target_vector[i] != (bfd_target *)NULL)
	636	{
	637	bfd_target *p = target_vector[i];
	638	bfd *abfd = bfd_openw("##dummy",p->name);
	639	printf("%s\n (header %s, data %s)\n", p->name,
	640	p->header_byteorder_big_p ? "big endian" : "little endian",
	641	p->byteorder_big_p ? "big endian" : "little endian" );
	642	{
	643	enum bfd_architecture j;
fc5d6074	644	for (j = (int)bfd_arch_obscure +1; j <(int) bfd_arch_last; j++)
9872a49c SC	645	{
	646	if (bfd_set_arch_mach(abfd, j, 0))
	647	{
	648	printf(" %s\n", bfd_printable_arch_mach(j,0));
	649	}
	650	}
2fa0b342	651
9872a49c SC	652	}
	653	i++;
	654	}
	655	/* Again as a table */
	656	printf("%12s"," ");
	657	for (i = 0; target_vector[i]; i++) {
	658	printf("%s ",target_vector[i]->name);
	659	}
	660	printf("\n");
fc5d6074	661	for (j = (int)bfd_arch_obscure +1; (int)j <(int) bfd_arch_last; j++) {
9872a49c SC	662	printf("%11s ", bfd_printable_arch_mach(j,0));
	663	for (i = 0; target_vector[i]; i++) {
	664	{
	665	bfd_target *p = target_vector[i];
	666	bfd *abfd = bfd_openw("##dummy",p->name);
	667	int l = strlen(p->name);
	668	int ok = bfd_set_arch_mach(abfd, j, 0);
	669	if (ok) {
	670	printf("%s ", p->name);
	671	}
	672	else {
	673	while (l--) {
	674	printf("%c",ok?'*':'-');
	675	}
	676	printf(" ");
	677	}
	678
	679	}
	680	}
	681
	682	printf("\n");
	683	}
	684	}
2fa0b342 DHW	685	/** main and like trivia */
	686	int
	687	main (argc, argv)
	688	int argc;
	689	char **argv;
	690	{
	691	int c;
	692	extern int optind;
	693	extern char *optarg;
	694	char *target = default_target;
	695	boolean seenflag = false;
	696	int ind = 0;
	697
	698	program_name = *argv;
	699
7cffe88a	700	while ((c = getopt_long (argc, argv, "Aib:m:dlfahrtxsj:", long_options, &ind))
2fa0b342 DHW	701	!= EOF) {
	702	seenflag = true;
	703	switch (c) {
	704	case 'm':
	705	machine = optarg;
	706	break;
	707	case 'j':
	708	only = optarg;
	709	break;
	710	case 'l':
	711	with_line_numbers = 1;
	712	break;
	713	case 'b':
	714	target = optarg;
	715	break;
	716	case 'f':
	717	dump_file_header = true;
	718	break;
9872a49c SC	719	case 'i':
	720	info = true;
	721	break;
2fa0b342 DHW	722	case 'x':
	723	dump_symtab = 1;
	724	dump_reloc_info = 1;
	725	dump_file_header = true;
	726	dump_ar_hdrs = 1;
	727	dump_section_headers = 1;
	728	break;
7cffe88a RP	729	case 'A':
	730	disassemble = true;
	731	dump_ar_hdrs = 1;
	732	dump_file_header = true;
	733	dump_reloc_info = 1;
	734	dump_section_headers = 1;
	735	dump_symtab = 1;
	736	break;
	737
2fa0b342 DHW	738	case 0 : break; /* we've been given a long option */
	739	case 't': dump_symtab = 1; break;
	740	case 'd': disassemble = true ; break;
	741	case 's': dump_section_contents = 1; break;
	742	case 'r': dump_reloc_info = 1; break;
	743	case 'a': dump_ar_hdrs = 1; break;
	744	case 'h': dump_section_headers = 1; break;
	745	default:
	746	usage ();
	747	}
	748	}
	749
	750	if (seenflag == false)
	751	usage ();
	752
9872a49c SC	753	if (info) {
	754	display_info();
	755	}
	756	else {
2fa0b342 DHW	757	if (optind == argc)
	758	display_file ("a.out", target);
	759	else
	760	for (; optind < argc;)
	761	display_file (argv[optind++], target);
9872a49c	762	}
2fa0b342 DHW	763	return 0;
2fa0b342 DHW	764	}