diff options
Diffstat (limited to 'binutils/objdump.c')
| -rw-r--r-- | binutils/objdump.c | 714 |
1 files changed, 714 insertions, 0 deletions
diff --git a/binutils/objdump.c b/binutils/objdump.c new file mode 100644 index 0000000..352adc3 --- /dev/null +++ b/binutils/objdump.c @@ -0,0 +1,714 @@ +/*** 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; +} |