OpenE2K
/
binutils-gdb
12
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
binutils-gdb/binutils/objdump.c

715 lines
15 KiB
C
Raw Normal View History

Initial revision
1991-03-21 22:29:06 +01:00
/*** 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$
$Log$
Revision 1.1 1991/03/21 21:26:48 gumby
Initial revision
* Revision 1.2 1991/03/15 18:34:14 rich
* foo
*
* Revision 1.1 1991/03/13 00:34:19 chrisb
* Initial revision
*
* Revision 1.9 1991/03/09 04:36:33 rich
* Modified Files:
* sparc-pinsn.c ostrip.c objdump.c m68k-pinsn.c i960-pinsn.c
* binutils.h
*
* Pulled sysdep.h out of bfd.h.
*
* Revision 1.8 1991/03/09 03:42:01 rich
* Modified Files:
* Makefile alloca.c ar.c i960-pinsn.c nm.c objdump.c ostrip.c
* strip.c
*
* Ports for intel960 group Portland.
*
* Revision 1.7 1991/03/08 21:54:47 rich
* Modified Files:
* Makefile ar.c binutils.h bucomm.c copy.c cplus-dem.c getopt.c
* i960-pinsn.c m68k-pinsn.c nm.c objdump.c sparc-opcode.h
* sparc-pinsn.c strip.c
*
* Verifying Portland tree with steve's last changes. Also, some partial
* porting.
*
* Revision 1.6 1991/03/08 07:46:26 sac
* Added -l option to disassembly - prints line numbers too.
*
* Revision 1.5 1991/03/07 21:50:24 sac
* More intelligent reloc printing
*
* Revision 1.4 1991/03/05 16:36:54 sac
* Fixed bug where empty symbols would print (null) on suns and crash elsewhere.
*
*/
/*
* 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 *malloc();
char *realloc();
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 */
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));
char *machine = (char *)NULL;
asymbol **syms;
asymbol **syms2;
unsigned int storage;
unsigned int symcount = 0;
void
usage ()
{
fprintf (stderr,
"usage: %s [-ahfdrtxsl] [-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 %08lx align 2**%2u\n ",
section->vma,
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(stream,"%08lx", 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 */
fprintf(stream,"%08lx (%s)", vma, 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 --;
}
}
{
char *section_name;
asection *sec = syms[thisplace]->section;
if (sec) {
section_name = sec->name;
}
else {
section_name = "abs";
}
}
if (syms[thisplace]->value > vma) {
fprintf(stream,"%08lx (%s-%lx)", vma, syms[thisplace]->name,
syms[thisplace]->value - vma);
}
else {
fprintf(stream,"%08lx (%s+%lx)", vma,
syms[thisplace]->name,
vma - syms[thisplace]->value);
}
}
}
void
disassemble_data(abfd)
bfd *abfd;
{
bfd_byte *data = NULL;
unsigned int datasize = 0;
unsigned int 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 */
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 ((size_t)i <section->size) {
if (with_line_numbers) {
static prevline;
char *filename;
char *functionname;
int line;
bfd_find_nearest_line(abfd,
section,
syms,
section->vma + i,
&filename,
&functionname,
&line);
if (filename && functionname && line && line != prevline) {
printf("%s:%d\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%08lx", 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);
}
/* Actually display the various requested regions */
void
dump_data (abfd)
bfd *abfd;
{
asection *section;
bfd_byte *data ;
unsigned int datasize = 0;
size_t 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, data, 0, section->size);
for (i= 0; i < section->size; i += onaline) {
size_t j;
printf(" %04lx ", 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; *p != (arelent *)NULL; p++) {
arelent *q = *p;
char *sym_name;
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("%08lx %-8s %s",
q->address,
q->howto->name,
sym_name);
}
else {
printf("%08lx %-8s [%s]",
q->address,
q->howto->name,
section_name);
}
if (q->addend) {
printf("+0x%lx(%ld)", q->addend, (long) q->addend);
}
printf("\n");
}
printf("\n\n");
free(relpp);
}
}
}
}
/** 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, "b: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 'x':
dump_symtab = 1;
dump_reloc_info = 1;
dump_file_header = true;
dump_ar_hdrs = 1;
dump_section_headers = 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 (optind == argc)
display_file ("a.out", target);
else
for (; optind < argc;)
display_file (argv[optind++], target);
return 0;
}