X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=binutils%2Fobjdump.c;h=a5ab114903eccb00cdd098c292824de4d318688e;hb=37cc8ec1be0959c1878e79fd2baed888da4a2775;hp=77a8d710da1358166011b4fda683fa2bc8a712fc;hpb=33a795ddf320478214403b4c6d73220cde9dbb01;p=deliverable%2Fbinutils-gdb.git diff --git a/binutils/objdump.c b/binutils/objdump.c index 77a8d710da..a5ab114903 100644 --- a/binutils/objdump.c +++ b/binutils/objdump.c @@ -1,5 +1,6 @@ /* objdump.c -- dump information about an object file. - Copyright 1990, 91, 92, 93, 94, 95, 96, 1997 Free Software Foundation, Inc. + Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 98, 99, 2000 + Free Software Foundation, Inc. This file is part of GNU Binutils. @@ -24,6 +25,7 @@ Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include #include "dis-asm.h" #include "libiberty.h" +#include "demangle.h" #include "debug.h" #include "budbg.h" @@ -42,6 +44,9 @@ Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ extern int fprintf PARAMS ((FILE *, const char *, ...)); #endif +/* Exit status. */ +static int exit_status = 0; + static char *default_target = NULL; /* default at runtime */ static int show_version = 0; /* show the version number */ @@ -59,6 +64,7 @@ static int with_line_numbers; /* -l */ static boolean with_source_code; /* -S */ static int show_raw_insn; /* --show-raw-insn */ static int dump_stab_section_info; /* --stabs */ +static int do_demangle; /* -C, --demangle */ static boolean disassemble; /* -d */ static boolean disassemble_all; /* -D */ static int disassemble_zeroes; /* --disassemble-zeroes */ @@ -68,6 +74,8 @@ static int wide_output; /* -w */ static bfd_vma start_address = (bfd_vma) -1; /* --start-address */ static bfd_vma stop_address = (bfd_vma) -1; /* --stop-address */ static int dump_debugging; /* --debugging */ +static bfd_vma adjust_section_vma = 0; /* --adjust-vma */ +static int file_start_context = 0; /* --file-start-context */ /* Extra info to pass to the disassembler address printing function. */ struct objdump_disasm_info { @@ -79,6 +87,9 @@ struct objdump_disasm_info { /* Architecture to disassemble for, or default if NULL. */ static char *machine = (char *) NULL; +/* Target specific options to the disassembler. */ +static char *disassembler_options = (char *) NULL; + /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */ static enum bfd_endian endian = BFD_ENDIAN_UNKNOWN; @@ -100,11 +111,23 @@ static asymbol **dynsyms; /* Number of symbols in `dynsyms'. */ static long dynsymcount = 0; -/* Forward declarations. */ +/* Static declarations. */ + +static void +usage PARAMS ((FILE *, int)); + +static void +nonfatal PARAMS ((const char *)); static void display_file PARAMS ((char *filename, char *target)); +static void +dump_section_header PARAMS ((bfd *, asection *, PTR)); + +static void +dump_headers PARAMS ((bfd *)); + static void dump_data PARAMS ((bfd *abfd)); @@ -120,12 +143,33 @@ dump_reloc_set PARAMS ((bfd *, asection *, arelent **, long)); static void dump_symbols PARAMS ((bfd *abfd, boolean dynamic)); +static void +dump_bfd_header PARAMS ((bfd *)); + +static void +dump_bfd_private_header PARAMS ((bfd *)); + static void display_bfd PARAMS ((bfd *abfd)); +static void +display_target_list PARAMS ((void)); + +static void +display_info_table PARAMS ((int, int)); + +static void +display_target_tables PARAMS ((void)); + +static void +display_info PARAMS ((void)); + static void objdump_print_value PARAMS ((bfd_vma, struct disassemble_info *, boolean)); +static void +objdump_print_symname PARAMS ((bfd *, struct disassemble_info *, asymbol *)); + static asymbol * find_symbol_for_address PARAMS ((bfd *, asection *, bfd_vma, boolean, long *)); @@ -144,38 +188,93 @@ show_line PARAMS ((bfd *, asection *, bfd_vma)); static void disassemble_bytes PARAMS ((struct disassemble_info *, disassembler_ftype, - boolean, bfd_byte *, long, long, arelent ***, - arelent **)); + boolean, bfd_byte *, bfd_vma, bfd_vma, + arelent ***, arelent **)); static void disassemble_data PARAMS ((bfd *)); static const char * endian_string PARAMS ((enum bfd_endian)); + +static asymbol ** +slurp_symtab PARAMS ((bfd *)); + +static asymbol ** +slurp_dynamic_symtab PARAMS ((bfd *)); + +static long +remove_useless_symbols PARAMS ((asymbol **, long)); + +static int +compare_symbols PARAMS ((const PTR, const PTR)); + +static int +compare_relocs PARAMS ((const PTR, const PTR)); + +static void +dump_stabs PARAMS ((bfd *)); + +static boolean +read_section_stabs PARAMS ((bfd *, const char *, const char *)); + +static void +print_section_stabs PARAMS ((bfd *, const char *, const char *)); static void usage (stream, status) FILE *stream; int status; { - fprintf (stream, "\ -Usage: %s [-ahifdDprRtTxsSlw] [-b bfdname] [-m machine] [-j section-name]\n\ - [--archive-headers] [--target=bfdname] [--debugging] [--disassemble]\n\ - [--disassemble-all] [--disassemble-zeroes] [--file-headers]\n\ - [--section-headers] [--headers]\n\ - [--info] [--section=section-name] [--line-numbers] [--source]\n", - program_name); - fprintf (stream, "\ - [--architecture=machine] [--reloc] [--full-contents] [--stabs]\n\ - [--syms] [--all-headers] [--dynamic-syms] [--dynamic-reloc]\n\ - [--wide] [--version] [--help] [--private-headers]\n\ - [--start-address=addr] [--stop-address=addr]\n\ - [--prefix-addresses] [--show-raw-insn]\n\ - [-EB|-EL] [--endian={big|little}] objfile...\n\ -at least one option besides -l (--line-numbers) must be given\n"); - list_supported_targets (program_name, stream); + fprintf (stream, _("Usage: %s file(s)\n"), program_name); + fprintf (stream, _(" At least one of the following switches must be given:\n")); + fprintf (stream, _("\ + -a --archive-headers Display archive header information\n\ + -f --file-headers Display the contents of the overall file header\n\ + -p --private-headers Display object format specific file header contents\n\ + -h --[section-]headers Display the contents of the section headers\n\ + -x --all-headers Display the contents of all headers\n\ + -d --disassemble Display assembler contents of executable sections\n\ + -D --disassemble-all Display assembler contents of all sections\n\ + -S --source Intermix source code with disassembly\n\ + -s --full-contents Display the full contents of all sections requested\n\ + -g --debugging Display debug information in object file\n\ + -G --stabs Display the STABS contents of an ELF format file\n\ + -t --syms Display the contents of the symbol table(s)\n\ + -T --dynamic-syms Display the contents of the dynamic symbol table\n\ + -r --reloc Display the relocation entries in the file\n\ + -R --dynamic-reloc Display the dynamic relocation entries in the file\n\ + -V --version Display this program's version number\n\ + -i --info List object formats and architectures supported\n\ + -H --help Display this information\n\ +")); + if (status != 2) + { + fprintf (stream, _("\n The following switches are optional:\n")); + fprintf (stream, _("\ + -b --target Specify the target object format as \n\ + -m --architecture Specify the target architecture as \n\ + -j --section Only display information for section \n\ + -M --disassembler-options Pass text on to the disassembler\n\ + -EB --endian=big Assume big endian format when disassembling\n\ + -EL --endian=little Assume little endian format when disassembling\n\ + --file-start-context Include context from start of file (with -S)\n\ + -l --line-numbers Include line numbers and filenames in output\n\ + -C --demangle Decode mangled/processed symbol names\n\ + -w --wide Format output for more than 80 columns\n\ + -z --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\ + --start-address Only process data whoes address is >= \n\ + --stop-address Only process data whoes address is <= \n\ + --prefix-addresses Print complete address alongside disassembly\n\ + --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\ + --adjust-vma Add to all displayed section addresses\n\ +\n")); + list_supported_targets (program_name, stream); + + disassembler_usage (stream); + } if (status == 0) - fprintf (stream, "Report bugs to bug-gnu-utils@prep.ai.mit.edu\n"); + fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO); exit (status); } @@ -184,53 +283,68 @@ at least one option besides -l (--line-numbers) must be given\n"); #define OPTION_ENDIAN (150) #define OPTION_START_ADDRESS (OPTION_ENDIAN + 1) #define OPTION_STOP_ADDRESS (OPTION_START_ADDRESS + 1) +#define OPTION_ADJUST_VMA (OPTION_STOP_ADDRESS + 1) static struct option long_options[]= { + {"adjust-vma", required_argument, NULL, OPTION_ADJUST_VMA}, {"all-headers", no_argument, NULL, 'x'}, {"private-headers", no_argument, NULL, 'p'}, {"architecture", required_argument, NULL, 'm'}, {"archive-headers", no_argument, NULL, 'a'}, - {"debugging", no_argument, &dump_debugging, 1}, + {"debugging", no_argument, NULL, 'g'}, + {"demangle", no_argument, NULL, 'C'}, {"disassemble", no_argument, NULL, 'd'}, {"disassemble-all", no_argument, NULL, 'D'}, - {"disassemble-zeroes", no_argument, &disassemble_zeroes, 1}, + {"disassembler-options", required_argument, NULL, 'M'}, + {"disassemble-zeroes", no_argument, NULL, 'z'}, {"dynamic-reloc", no_argument, NULL, 'R'}, {"dynamic-syms", no_argument, NULL, 'T'}, {"endian", required_argument, NULL, OPTION_ENDIAN}, {"file-headers", no_argument, NULL, 'f'}, + {"file-start-context", no_argument, &file_start_context, 1}, {"full-contents", no_argument, NULL, 's'}, {"headers", no_argument, NULL, 'h'}, {"help", no_argument, NULL, 'H'}, {"info", no_argument, NULL, 'i'}, {"line-numbers", no_argument, NULL, 'l'}, + {"no-show-raw-insn", no_argument, &show_raw_insn, -1}, {"prefix-addresses", no_argument, &prefix_addresses, 1}, {"reloc", no_argument, NULL, 'r'}, {"section", required_argument, NULL, 'j'}, {"section-headers", no_argument, NULL, 'h'}, {"show-raw-insn", no_argument, &show_raw_insn, 1}, {"source", no_argument, NULL, 'S'}, - {"stabs", no_argument, &dump_stab_section_info, 1}, + {"stabs", no_argument, NULL, 'G'}, {"start-address", required_argument, NULL, OPTION_START_ADDRESS}, {"stop-address", required_argument, NULL, OPTION_STOP_ADDRESS}, {"syms", no_argument, NULL, 't'}, {"target", required_argument, NULL, 'b'}, - {"version", no_argument, &show_version, 1}, - {"wide", no_argument, &wide_output, 'w'}, + {"version", no_argument, NULL, 'V'}, + {"wide", no_argument, NULL, 'w'}, {0, no_argument, 0, 0} }; static void +nonfatal (msg) + const char *msg; +{ + bfd_nonfatal (msg); + exit_status = 1; +} + +static void dump_section_header (abfd, section, ignored) - bfd *abfd; + bfd *abfd ATTRIBUTE_UNUSED; asection *section; - PTR ignored; + PTR ignored ATTRIBUTE_UNUSED; { char *comma = ""; + unsigned int opb = bfd_octets_per_byte (abfd); printf ("%3d %-13s %08lx ", section->index, bfd_get_section_name (abfd, section), - (unsigned long) bfd_section_size (abfd, section)); + (unsigned long) bfd_section_size (abfd, section) / opb); printf_vma (bfd_get_section_vma (abfd, section)); printf (" "); printf_vma (section->lma); @@ -262,6 +376,10 @@ dump_section_header (abfd, section, ignored) PF (SEC_NEVER_LOAD, "NEVER_LOAD"); PF (SEC_EXCLUDE, "EXCLUDE"); PF (SEC_SORT_ENTRIES, "SORT_ENTRIES"); + PF (SEC_BLOCK, "BLOCK"); + PF (SEC_CLINK, "CLINK"); + PF (SEC_SMALL_DATA, "SMALL_DATA"); + PF (SEC_SHARED, "SHARED"); if ((section->flags & SEC_LINK_ONCE) != 0) { @@ -285,6 +403,11 @@ dump_section_header (abfd, section, ignored) break; } printf ("%s%s", comma, ls); + + if (section->comdat != NULL) + printf (" (COMDAT %s %ld)", section->comdat->name, + section->comdat->symbol); + comma = ", "; } @@ -296,12 +419,18 @@ static void dump_headers (abfd) bfd *abfd; { - printf ("Sections:\n"); + printf (_("Sections:\n")); + #ifndef BFD64 - printf ("Idx Name Size VMA LMA File off Algn\n"); + printf (_("Idx Name Size VMA LMA File off Algn")); #else - printf ("Idx Name Size VMA LMA File off Algn\n"); + printf (_("Idx Name Size VMA LMA File off Algn")); #endif + + if (wide_output) + printf (_(" Flags")); + printf ("\n"); + bfd_map_over_sections (abfd, dump_section_header, (PTR) NULL); } @@ -314,7 +443,7 @@ slurp_symtab (abfd) if (!(bfd_get_file_flags (abfd) & HAS_SYMS)) { - printf ("No symbols in \"%s\".\n", bfd_get_filename (abfd)); + non_fatal (_("%s: no symbols"), bfd_get_filename (abfd)); symcount = 0; return NULL; } @@ -331,8 +460,7 @@ slurp_symtab (abfd) if (symcount < 0) bfd_fatal (bfd_get_filename (abfd)); if (symcount == 0) - fprintf (stderr, "%s: %s: No symbols\n", - program_name, bfd_get_filename (abfd)); + non_fatal (_("%s: no symbols"), bfd_get_filename (abfd)); return sy; } @@ -350,8 +478,7 @@ slurp_dynamic_symtab (abfd) { if (!(bfd_get_file_flags (abfd) & DYNAMIC)) { - fprintf (stderr, "%s: %s: not a dynamic object\n", - program_name, bfd_get_filename (abfd)); + non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd)); dynsymcount = 0; return NULL; } @@ -367,8 +494,7 @@ slurp_dynamic_symtab (abfd) if (dynsymcount < 0) bfd_fatal (bfd_get_filename (abfd)); if (dynsymcount == 0) - fprintf (stderr, "%s: %s: No dynamic symbols\n", - program_name, bfd_get_filename (abfd)); + non_fatal (_("%s: No dynamic symbols"), bfd_get_filename (abfd)); return sy; } @@ -557,6 +683,44 @@ objdump_print_value (vma, info, skip_zeroes) (*info->fprintf_func) (info->stream, "%s", p); } +/* Print the name of a symbol. */ + +static void +objdump_print_symname (abfd, info, sym) + bfd *abfd; + struct disassemble_info *info; + asymbol *sym; +{ + char *alloc; + const char *name; + const char *print; + + alloc = NULL; + name = bfd_asymbol_name (sym); + if (! do_demangle || name[0] == '\0') + print = name; + else + { + /* Demangle the name. */ + if (bfd_get_symbol_leading_char (abfd) == name[0]) + ++name; + + alloc = cplus_demangle (name, DMGL_ANSI | DMGL_PARAMS); + if (alloc == NULL) + print = name; + else + print = alloc; + } + + if (info != NULL) + (*info->fprintf_func) (info->stream, "%s", print); + else + printf ("%s", print); + + if (alloc != NULL) + free (alloc); +} + /* Locate a symbol given a bfd, a section, and a VMA. If REQUIRE_SEC is true, then always require the symbol to be in the section. This returns NULL if there is no suitable symbol. If PLACE is not NULL, @@ -579,6 +743,7 @@ find_symbol_for_address (abfd, sec, vma, require_sec, place) long min = 0; long max = sorted_symcount; long thisplace; + unsigned int opb = bfd_octets_per_byte (abfd); if (sorted_symcount < 1) return NULL; @@ -626,7 +791,7 @@ find_symbol_for_address (abfd, sec, vma, require_sec, place) || ((abfd->flags & HAS_RELOC) != 0 && vma >= bfd_get_section_vma (abfd, sec) && vma < (bfd_get_section_vma (abfd, sec) - + bfd_section_size (abfd, sec))))) + + bfd_section_size (abfd, sec) / opb)))) { long i; @@ -704,27 +869,28 @@ objdump_print_addr_with_sym (abfd, sec, sym, vma, info, skip_zeroes) secaddr = bfd_get_section_vma (abfd, sec); if (vma < secaddr) { - (*info->fprintf_func) (info->stream, "-"); + (*info->fprintf_func) (info->stream, "-0x"); objdump_print_value (secaddr - vma, info, true); } else if (vma > secaddr) { - (*info->fprintf_func) (info->stream, "+"); + (*info->fprintf_func) (info->stream, "+0x"); objdump_print_value (vma - secaddr, info, true); } (*info->fprintf_func) (info->stream, ">"); } else { - (*info->fprintf_func) (info->stream, " <%s", sym->name); + (*info->fprintf_func) (info->stream, " <"); + objdump_print_symname (abfd, info, sym); if (bfd_asymbol_value (sym) > vma) { - (*info->fprintf_func) (info->stream, "-"); + (*info->fprintf_func) (info->stream, "-0x"); objdump_print_value (bfd_asymbol_value (sym) - vma, info, true); } else if (vma > bfd_asymbol_value (sym)) { - (*info->fprintf_func) (info->stream, "+"); + (*info->fprintf_func) (info->stream, "+0x"); objdump_print_value (vma - bfd_asymbol_value (sym), info, true); } (*info->fprintf_func) (info->stream, ">"); @@ -745,6 +911,7 @@ objdump_print_addr (vma, info, skip_zeroes) if (sorted_symcount < 1) { + (*info->fprintf_func) (info->stream, "0x"); objdump_print_value (vma, info, skip_zeroes); return; } @@ -767,6 +934,27 @@ objdump_print_address (vma, info) objdump_print_addr (vma, info, ! prefix_addresses); } +/* Determine of the given address has a symbol associated with it. */ + +static int +objdump_symbol_at_address (vma, info) + bfd_vma vma; + struct disassemble_info * info; +{ + struct objdump_disasm_info * aux; + asymbol * sym; + + /* No symbols - do not bother checking. */ + if (sorted_symcount < 1) + return 0; + + aux = (struct objdump_disasm_info *) info->application_data; + sym = find_symbol_for_address (aux->abfd, aux->sec, vma, aux->require_sec, + (long *) NULL); + + return (sym != NULL && (bfd_asymbol_value (sym) == vma)); +} + /* Hold the last function name and the last line number we displayed in a disassembly. */ @@ -827,10 +1015,10 @@ skip_to_line (p, line, show) listing. */ static void -show_line (abfd, section, off) +show_line (abfd, section, addr_offset) bfd *abfd; asection *section; - bfd_vma off; + bfd_vma addr_offset; { CONST char *filename; CONST char *functionname; @@ -839,7 +1027,7 @@ show_line (abfd, section, off) if (! with_line_numbers && ! with_source_code) return; - if (! bfd_find_nearest_line (abfd, section, syms, off, &filename, + if (! bfd_find_nearest_line (abfd, section, syms, addr_offset, &filename, &functionname, &line)) return; @@ -891,8 +1079,8 @@ show_line (abfd, section, off) else { l = line - SHOW_PRECEDING_CONTEXT_LINES; - if (l <= 0) - l = 1; + if (l < 0) + l = 0; } if (p->f == NULL) @@ -942,9 +1130,12 @@ show_line (abfd, section, off) p->next = print_files; print_files = p; - l = line - SHOW_PRECEDING_CONTEXT_LINES; - if (l <= 0) - l = 1; + if (file_start_context) + l = 0; + else + l = line - SHOW_PRECEDING_CONTEXT_LINES; + if (l < 0) + l = 0; skip_to_line (p, l, false); if (p->f != NULL) skip_to_line (p, line, true); @@ -967,45 +1158,68 @@ show_line (abfd, section, off) } /* Pseudo FILE object for strings. */ -typedef struct { +typedef struct +{ char *buffer; + size_t size; char *current; } SFILE; /* sprintf to a "stream" */ -#ifdef ANSI_PROTOTYPES static int +#ifdef ANSI_PROTOTYPES objdump_sprintf (SFILE *f, const char *format, ...) -{ - int n; - va_list args; - - va_start (args, format); - vsprintf (f->current, format, args); - f->current += n = strlen (f->current); - va_end (args); - return n; -} #else -static int objdump_sprintf (va_alist) va_dcl +#endif { - int n; +#ifndef ANSI_PROTOTYPES SFILE *f; const char *format; +#endif + char *buf; va_list args; + size_t n; +#ifdef ANSI_PROTOTYPES + va_start (args, format); +#else va_start (args); f = va_arg (args, SFILE *); format = va_arg (args, const char *); - vsprintf (f->current, format, args); - f->current += n = strlen (f->current); +#endif + + vasprintf (&buf, format, args); + va_end (args); + + if (buf == NULL) + { + fatal (_("Out of virtual memory")); + } + + n = strlen (buf); + + while ((size_t) ((f->buffer + f->size) - f->current) < n + 1) + { + size_t curroff; + + curroff = f->current - f->buffer; + f->size *= 2; + f->buffer = xrealloc (f->buffer, f->size); + f->current = f->buffer + curroff; + } + + memcpy (f->current, buf, n); + f->current += n; + f->current[0] = '\0'; + + free (buf); + return n; } -#endif /* The number of zeroes we want to see before we start skipping them. The number is arbitrarily chosen. */ @@ -1024,31 +1238,33 @@ objdump_sprintf (va_alist) /* Disassemble some data in memory between given values. */ static void -disassemble_bytes (info, disassemble_fn, insns, data, start, stop, relppp, +disassemble_bytes (info, disassemble_fn, insns, data, + start_offset, stop_offset, relppp, relppend) struct disassemble_info *info; disassembler_ftype disassemble_fn; boolean insns; bfd_byte *data; - long start; - long stop; + bfd_vma start_offset; + bfd_vma stop_offset; arelent ***relppp; arelent **relppend; { struct objdump_disasm_info *aux; asection *section; - int bytes_per_line; + int octets_per_line; boolean done_dot; int skip_addr_chars; - long i; + bfd_vma addr_offset; + int opb = info->octets_per_byte; aux = (struct objdump_disasm_info *) info->application_data; section = aux->sec; if (insns) - bytes_per_line = 4; + octets_per_line = 4; else - bytes_per_line = 16; + octets_per_line = 16; /* Figure out how many characters to skip at the start of an address, to make the disassembly look nicer. We discard leading @@ -1060,8 +1276,8 @@ disassemble_bytes (info, disassemble_fn, insns, data, start, stop, relppp, char buf[30]; char *s; - sprintf_vma (buf, - section->vma + bfd_section_size (section->owner, section)); + sprintf_vma (buf, section->vma + + bfd_section_size (section->owner, section) / opb); s = buf; while (s[0] == '0' && s[1] == '0' && s[2] == '0' && s[3] == '0' && s[4] == '0') @@ -1074,51 +1290,53 @@ disassemble_bytes (info, disassemble_fn, insns, data, start, stop, relppp, info->insn_info_valid = 0; done_dot = false; - i = start; - while (i < stop) + addr_offset = start_offset; + while (addr_offset < stop_offset) { - long z; - int bytes; + bfd_vma z; + int octets = 0; boolean need_nl = false; - /* If we see more than SKIP_ZEROES bytes of zeroes, we just + /* If we see more than SKIP_ZEROES octets of zeroes, we just print `...'. */ - for (z = i; z < stop; z++) + for (z = addr_offset * opb; z < stop_offset * opb; z++) if (data[z] != 0) break; if (! disassemble_zeroes && (info->insn_info_valid == 0 || info->branch_delay_insns == 0) - && (z - i >= SKIP_ZEROES - || (z == stop && z - i < SKIP_ZEROES_AT_END))) + && (z - addr_offset * opb >= SKIP_ZEROES + || (z == stop_offset * opb && + z - addr_offset * opb < SKIP_ZEROES_AT_END))) { printf ("\t...\n"); - /* If there are more nonzero bytes to follow, we only skip + /* If there are more nonzero octets to follow, we only skip zeroes in multiples of 4, to try to avoid running over the start of an instruction which happens to start with zero. */ - if (z != stop) - z = i + ((z - i) &~ 3); + if (z != stop_offset * opb) + z = addr_offset * opb + ((z - addr_offset * opb) &~ 3); - bytes = z - i; + octets = z - addr_offset * opb; } else { - char buf[1000]; + char buf[50]; SFILE sfile; - int bpc, pb = 0; + int bpc = 0; + int pb = 0; done_dot = false; if (with_line_numbers || with_source_code) - show_line (aux->abfd, section, i); + show_line (aux->abfd, section, addr_offset); if (! prefix_addresses) { char *s; - sprintf_vma (buf, section->vma + i); + sprintf_vma (buf, section->vma + addr_offset); for (s = buf + skip_addr_chars; *s == '0'; s++) *s = ' '; if (*s == '\0') @@ -1128,78 +1346,103 @@ disassemble_bytes (info, disassemble_fn, insns, data, start, stop, relppp, else { aux->require_sec = true; - objdump_print_address (section->vma + i, info); + objdump_print_address (section->vma + addr_offset, info); aux->require_sec = false; putchar (' '); } if (insns) { - sfile.buffer = sfile.current = buf; + sfile.size = 120; + sfile.buffer = xmalloc (sfile.size); + sfile.current = sfile.buffer; info->fprintf_func = (fprintf_ftype) objdump_sprintf; info->stream = (FILE *) &sfile; info->bytes_per_line = 0; info->bytes_per_chunk = 0; - bytes = (*disassemble_fn) (section->vma + i, info); + + /* FIXME: This is wrong. It tests the number of octets + in the last instruction, not the current one. */ + if (*relppp < relppend + && (**relppp)->address >= addr_offset + && (**relppp)->address < addr_offset + octets / opb) + info->flags = INSN_HAS_RELOC; + else + info->flags = 0; + + octets = (*disassemble_fn) (section->vma + addr_offset, info); info->fprintf_func = (fprintf_ftype) fprintf; info->stream = stdout; if (info->bytes_per_line != 0) - bytes_per_line = info->bytes_per_line; - if (bytes < 0) - break; + octets_per_line = info->bytes_per_line; + if (octets < 0) + { + if (sfile.current != sfile.buffer) + printf ("%s\n", sfile.buffer); + free (sfile.buffer); + break; + } } else { - long j; + bfd_vma j; - bytes = bytes_per_line; - if (i + bytes > stop) - bytes = stop - i; + octets = octets_per_line; + if (addr_offset + octets / opb > stop_offset) + octets = (stop_offset - addr_offset) * opb; - for (j = i; j < i + bytes; ++j) + for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j) { if (isprint (data[j])) - buf[j - i] = data[j]; + buf[j - addr_offset * opb] = data[j]; else - buf[j - i] = '.'; + buf[j - addr_offset * opb] = '.'; } - buf[j - i] = '\0'; + buf[j - addr_offset * opb] = '\0'; } - if (! prefix_addresses || show_raw_insn) + if (prefix_addresses + ? show_raw_insn > 0 + : show_raw_insn >= 0) { - long j; + bfd_vma j; /* If ! prefix_addresses and ! wide_output, we print - bytes_per_line bytes per line. */ - pb = bytes; - if (pb > bytes_per_line && ! prefix_addresses && ! wide_output) - pb = bytes_per_line; + octets_per_line octets per line. */ + pb = octets; + if (pb > octets_per_line && ! prefix_addresses && ! wide_output) + pb = octets_per_line; if (info->bytes_per_chunk) bpc = info->bytes_per_chunk; else bpc = 1; - for (j = i; j < i + pb; j += bpc) + for (j = addr_offset * opb; j < addr_offset * opb + pb; j += bpc) { int k; if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE) { - for (k=bpc-1; k >= 0; k--) - printf ("%02x", (unsigned) data[j+k]); + for (k = bpc - 1; k >= 0; k--) + printf ("%02x", (unsigned) data[j + k]); putchar (' '); } else { - for (k=0; k < bpc; k++) - printf ("%02x", (unsigned) data[j+k]); + for (k = 0; k < bpc; k++) + printf ("%02x", (unsigned) data[j + k]); putchar (' '); } } - for (; pb < bytes_per_line; ++pb) - printf (" "); + for (; pb < octets_per_line; pb += bpc) + { + int k; + + for (k = 0; k < bpc; k++) + printf (" "); + putchar (' '); + } /* Separate raw data from instruction by extra space. */ if (insns) @@ -1208,32 +1451,52 @@ disassemble_bytes (info, disassemble_fn, insns, data, start, stop, relppp, printf (" "); } - printf ("%s", buf); + if (! insns) + printf ("%s", buf); + else + { + printf ("%s", sfile.buffer); + free (sfile.buffer); + } - if (! prefix_addresses || show_raw_insn) + if (prefix_addresses + ? show_raw_insn > 0 + : show_raw_insn >= 0) { - while (pb < bytes) + while (pb < octets) { - long j; + bfd_vma j; char *s; putchar ('\n'); - j = i + pb; + j = addr_offset * opb + pb; - sprintf_vma (buf, section->vma + j); + sprintf_vma (buf, section->vma + j / opb); for (s = buf + skip_addr_chars; *s == '0'; s++) *s = ' '; if (*s == '\0') *--s = '0'; printf ("%s:\t", buf + skip_addr_chars); - pb += bytes_per_line; - if (pb > bytes) - pb = bytes; - for (; j < i + pb; ++j) + pb += octets_per_line; + if (pb > octets) + pb = octets; + for (; j < addr_offset * opb + pb; j += bpc) { - printf ("%02x", (unsigned) data[j]); - putchar (' '); + int k; + + if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE) + { + for (k = bpc - 1; k >= 0; k--) + printf ("%02x", (unsigned) data[j + k]); + putchar (' '); + } + else + { + for (k = 0; k < bpc; k++) + printf ("%02x", (unsigned) data[j + k]); + putchar (' '); + } } } } @@ -1248,11 +1511,10 @@ disassemble_bytes (info, disassemble_fn, insns, data, start, stop, relppp, && (section->flags & SEC_RELOC) != 0) { while ((*relppp) < relppend - && ((**relppp)->address >= (bfd_vma) i - && (**relppp)->address < (bfd_vma) i + bytes)) + && ((**relppp)->address >= (bfd_vma) addr_offset + && (**relppp)->address < (bfd_vma) addr_offset + octets / opb)) { arelent *q; - const char *sym_name; q = **relppp; @@ -1265,24 +1527,26 @@ disassemble_bytes (info, disassemble_fn, insns, data, start, stop, relppp, printf (": %s\t", q->howto->name); - if (q->sym_ptr_ptr != NULL - && *q->sym_ptr_ptr != NULL) + if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL) + printf ("*unknown*"); + else { + const char *sym_name; + sym_name = bfd_asymbol_name (*q->sym_ptr_ptr); - if (sym_name == NULL || *sym_name == '\0') + if (sym_name != NULL && *sym_name != '\0') + objdump_print_symname (aux->abfd, info, *q->sym_ptr_ptr); + else { asection *sym_sec; sym_sec = bfd_get_section (*q->sym_ptr_ptr); - sym_name = bfd_get_section_name (abfd, sym_sec); + sym_name = bfd_get_section_name (aux->abfd, sym_sec); if (sym_name == NULL || *sym_name == '\0') sym_name = "*unknown*"; + printf ("%s", sym_name); } } - else - sym_name = "*unknown*"; - - printf ("%s", sym_name); if (q->addend) { @@ -1299,7 +1563,7 @@ disassemble_bytes (info, disassemble_fn, insns, data, start, stop, relppp, if (need_nl) printf ("\n"); - i += bytes; + addr_offset += octets / opb; } } @@ -1309,11 +1573,12 @@ static void disassemble_data (abfd) bfd *abfd; { - long i; + unsigned long addr_offset; disassembler_ftype disassemble_fn; struct disassemble_info disasm_info; struct objdump_disasm_info aux; asection *section; + unsigned int opb = bfd_octets_per_byte (abfd); print_files = NULL; prev_functionname = NULL; @@ -1334,16 +1599,15 @@ disassemble_data (abfd) aux.abfd = abfd; aux.require_sec = false; disasm_info.print_address_func = objdump_print_address; + disasm_info.symbol_at_address_func = objdump_symbol_at_address; + disasm_info.octets_per_byte = opb; if (machine != (char *) NULL) { const bfd_arch_info_type *info = bfd_scan_arch (machine); if (info == NULL) { - fprintf (stderr, "%s: Can't use supplied machine %s\n", - program_name, - machine); - exit (1); + fatal (_("Can't use supplied machine %s"), machine); } abfd->arch_info = info; } @@ -1361,19 +1625,21 @@ disassemble_data (abfd) disassemble_fn = disassembler (abfd); if (!disassemble_fn) { - fprintf (stderr, "%s: Can't disassemble for architecture %s\n", - program_name, - bfd_printable_arch_mach (bfd_get_arch (abfd), 0)); - exit (1); + non_fatal (_("Can't disassemble for architecture %s\n"), + bfd_printable_arch_mach (bfd_get_arch (abfd), 0)); + exit_status = 1; + return; } disasm_info.flavour = bfd_get_flavour (abfd); disasm_info.arch = bfd_get_arch (abfd); disasm_info.mach = bfd_get_mach (abfd); + disasm_info.disassembler_options = disassembler_options; + if (bfd_big_endian (abfd)) - disasm_info.endian = BFD_ENDIAN_BIG; + disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG; else if (bfd_little_endian (abfd)) - disasm_info.endian = BFD_ENDIAN_LITTLE; + disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE; else /* ??? Aborting here seems too drastic. We could default to big or little instead. */ @@ -1388,7 +1654,9 @@ disassemble_data (abfd) arelent **relbuf = NULL; arelent **relpp = NULL; arelent **relppend = NULL; - long stop; + unsigned long stop_offset; + asymbol *sym = NULL; + long place = 0; if ((section->flags & SEC_LOAD) == 0 || (! disassemble_all @@ -1421,10 +1689,19 @@ disassemble_data (abfd) relpp = relbuf; relppend = relpp + relcount; + + /* Skip over the relocs belonging to addresses below the + start address. */ + if (start_address != (bfd_vma) -1) + { + while (relpp < relppend + && (*relpp)->address < start_address) + ++relpp; + } } } - printf ("Disassembly of section %s:\n", section->name); + printf (_("Disassembly of section %s:\n"), section->name); datasize = bfd_get_section_size_before_reloc (section); if (datasize == 0) @@ -1440,93 +1717,114 @@ disassemble_data (abfd) disasm_info.buffer_length = datasize; if (start_address == (bfd_vma) -1 || start_address < disasm_info.buffer_vma) - i = 0; + addr_offset = 0; else - i = start_address - disasm_info.buffer_vma; + addr_offset = start_address - disasm_info.buffer_vma; if (stop_address == (bfd_vma) -1) - stop = datasize; + stop_offset = datasize / opb; else { if (stop_address < disasm_info.buffer_vma) - stop = 0; + stop_offset = 0; else - stop = stop_address - disasm_info.buffer_vma; - if (stop > disasm_info.buffer_length) - stop = disasm_info.buffer_length; + stop_offset = stop_address - disasm_info.buffer_vma; + if (stop_offset > disasm_info.buffer_length / opb) + stop_offset = disasm_info.buffer_length / opb; } - if (prefix_addresses) - disassemble_bytes (&disasm_info, disassemble_fn, true, data, i, stop, - &relpp, relppend); - else - { - asymbol *sym; - long place; + sym = find_symbol_for_address (abfd, section, section->vma + addr_offset, + true, &place); - sym = find_symbol_for_address (abfd, section, i, true, &place); - ++place; - while (i < stop) + while (addr_offset < stop_offset) + { + asymbol *nextsym; + unsigned long nextstop_offset; + boolean insns; + + if (sym != NULL && bfd_asymbol_value (sym) <= section->vma + addr_offset) { - asymbol *nextsym; - long nextstop; - boolean insns; + int x; - disasm_info.symbol = sym; + for (x = place; + (x < sorted_symcount + && bfd_asymbol_value (sorted_syms[x]) <= section->vma + addr_offset); + ++x) + continue; + disasm_info.symbols = & sorted_syms[place]; + disasm_info.num_symbols = x - place; + } + else + disasm_info.symbols = NULL; + if (! prefix_addresses) + { printf ("\n"); objdump_print_addr_with_sym (abfd, section, sym, - section->vma + i, + section->vma + addr_offset, &disasm_info, false); printf (":\n"); - - if (sym == NULL) + } + + if (sym != NULL && bfd_asymbol_value (sym) > section->vma + addr_offset) + nextsym = sym; + else if (sym == NULL) + nextsym = NULL; + else + { + /* Search forward for the next appropriate symbol in + SECTION. Note that all the symbols are sorted + together into one big array, and that some sections + may have overlapping addresses. */ + while (place < sorted_symcount + && (sorted_syms[place]->section != section + || (bfd_asymbol_value (sorted_syms[place]) + <= bfd_asymbol_value (sym)))) + ++place; + if (place >= sorted_symcount) nextsym = NULL; else - { - while (place < sorted_symcount - && (sorted_syms[place]->section != section - || (bfd_asymbol_value (sorted_syms[place]) - <= bfd_asymbol_value (sym)))) - ++place; - if (place >= sorted_symcount) - nextsym = NULL; - else - nextsym = sorted_syms[place]; - } - - if (nextsym == NULL) - nextstop = stop; - else - { - nextstop = bfd_asymbol_value (nextsym) - section->vma; - if (nextstop > stop) - nextstop = stop; - } - - /* If a symbol is explicitly marked as being an object - rather than a function, just dump the bytes without - disassembling them. */ - if (disassemble_all - || sym == NULL - || ((sym->flags & BSF_OBJECT) == 0 - && (strstr (bfd_asymbol_name (sym), "gnu_compiled") - == NULL) - && (strstr (bfd_asymbol_name (sym), "gcc2_compiled") - == NULL)) - || (sym->flags & BSF_FUNCTION) != 0) - insns = true; - else - insns = false; - - disassemble_bytes (&disasm_info, disassemble_fn, insns, data, i, - nextstop, &relpp, relppend); - - i = nextstop; - sym = nextsym; + nextsym = sorted_syms[place]; } + + if (sym != NULL && bfd_asymbol_value (sym) > section->vma + addr_offset) + { + nextstop_offset = bfd_asymbol_value (sym) - section->vma; + if (nextstop_offset > stop_offset) + nextstop_offset = stop_offset; + } + else if (nextsym == NULL) + nextstop_offset = stop_offset; + else + { + nextstop_offset = bfd_asymbol_value (nextsym) - section->vma; + if (nextstop_offset > stop_offset) + nextstop_offset = stop_offset; + } + + /* If a symbol is explicitly marked as being an object + rather than a function, just dump the bytes without + disassembling them. */ + if (disassemble_all + || sym == NULL + || bfd_asymbol_value (sym) > section->vma + addr_offset + || ((sym->flags & BSF_OBJECT) == 0 + && (strstr (bfd_asymbol_name (sym), "gnu_compiled") + == NULL) + && (strstr (bfd_asymbol_name (sym), "gcc2_compiled") + == NULL)) + || (sym->flags & BSF_FUNCTION) != 0) + insns = true; + else + insns = false; + + disassemble_bytes (&disasm_info, disassemble_fn, insns, data, + addr_offset, nextstop_offset, &relpp, relppend); + + addr_offset = nextstop_offset; + sym = nextsym; } - + free (data); if (relbuf != NULL) free (relbuf); @@ -1569,23 +1867,24 @@ static bfd_size_type stabstr_size; static boolean read_section_stabs (abfd, stabsect_name, strsect_name) bfd *abfd; - char *stabsect_name; - char *strsect_name; + const char *stabsect_name; + const char *strsect_name; { asection *stabsect, *stabstrsect; stabsect = bfd_get_section_by_name (abfd, stabsect_name); if (0 == stabsect) { - printf ("No %s section present\n\n", stabsect_name); + printf (_("No %s section present\n\n"), stabsect_name); return false; } stabstrsect = bfd_get_section_by_name (abfd, strsect_name); if (0 == stabstrsect) { - fprintf (stderr, "%s: %s has no %s section\n", program_name, - bfd_get_filename (abfd), strsect_name); + non_fatal (_("%s has no %s section"), + bfd_get_filename (abfd), strsect_name); + exit_status = 1; return false; } @@ -1597,22 +1896,24 @@ read_section_stabs (abfd, stabsect_name, strsect_name) if (! bfd_get_section_contents (abfd, stabsect, (PTR) stabs, 0, stab_size)) { - fprintf (stderr, "%s: Reading %s section of %s failed: %s\n", - program_name, stabsect_name, bfd_get_filename (abfd), - bfd_errmsg (bfd_get_error ())); + non_fatal (_("Reading %s section of %s failed: %s"), + stabsect_name, bfd_get_filename (abfd), + bfd_errmsg (bfd_get_error ())); free (stabs); free (strtab); + exit_status = 1; return false; } if (! bfd_get_section_contents (abfd, stabstrsect, (PTR) strtab, 0, stabstr_size)) { - fprintf (stderr, "%s: Reading %s section of %s failed: %s\n", - program_name, strsect_name, bfd_get_filename (abfd), - bfd_errmsg (bfd_get_error ())); + non_fatal (_("Reading %s section of %s failed: %s\n"), + strsect_name, bfd_get_filename (abfd), + bfd_errmsg (bfd_get_error ())); free (stabs); free (strtab); + exit_status = 1; return false; } @@ -1640,8 +1941,8 @@ read_section_stabs (abfd, stabsect_name, strsect_name) static void print_section_stabs (abfd, stabsect_name, strsect_name) bfd *abfd; - char *stabsect_name; - char *strsect_name; + const char *stabsect_name; + const char *strsect_name ATTRIBUTE_UNUSED; { int i; unsigned file_string_table_offset = 0, next_file_string_table_offset = 0; @@ -1650,7 +1951,7 @@ print_section_stabs (abfd, stabsect_name, strsect_name) stabp = stabs; stabs_end = stabp + stab_size; - printf ("Contents of %s section:\n\n", stabsect_name); + printf (_("Contents of %s section:\n\n"), stabsect_name); printf ("Symnum n_type n_othr n_desc n_value n_strx String\n"); /* Loop through all symbols and print them. @@ -1727,11 +2028,12 @@ dump_section_stabs (abfd, stabsect_name, strsect_name) len = strlen (stabsect_name); -/* If the prefix matches, and the files section name ends with a nul or a digit, - then we match. Ie: we want either an exact match or a a section followed by - a number. */ + /* If the prefix matches, and the files section name ends with a + nul or a digit, then we match. I.e., we want either an exact + match or a section followed by a number. */ if (strncmp (stabsect_name, s->name, len) == 0 - && (s->name[len] == '\000' || isdigit (s->name[len]))) + && (s->name[len] == '\000' + || isdigit ((unsigned char) s->name[len]))) { if (read_section_stabs (abfd, s->name, strsect_name)) { @@ -1749,10 +2051,10 @@ dump_bfd_header (abfd) { char *comma = ""; - printf ("architecture: %s, ", + printf (_("architecture: %s, "), bfd_printable_arch_mach (bfd_get_arch (abfd), bfd_get_mach (abfd))); - printf ("flags 0x%08x:\n", abfd->flags); + 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"); @@ -1765,7 +2067,7 @@ dump_bfd_header (abfd) PF (WP_TEXT, "WP_TEXT"); PF (D_PAGED, "D_PAGED"); PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE"); - printf ("\nstart address 0x"); + printf (_("\nstart address 0x")); printf_vma (abfd->start_address); printf ("\n"); } @@ -1777,24 +2079,27 @@ bfd *abfd; bfd_print_private_bfd_data (abfd, stdout); } +/* Dump selected contents of ABFD */ + static void -display_bfd (abfd) +dump_bfd (abfd) bfd *abfd; { - char **matching; - - if (!bfd_check_format_matches (abfd, bfd_object, &matching)) + /* If we are adjusting section VMA's, change them all now. Changing + the BFD information is a hack. However, we must do it, or + bfd_find_nearest_line will not do the right thing. */ + if (adjust_section_vma != 0) { - bfd_nonfatal (bfd_get_filename (abfd)); - if (bfd_get_error () == bfd_error_file_ambiguously_recognized) + asection *s; + + for (s = abfd->sections; s != NULL; s = s->next) { - list_matching_formats (matching); - free (matching); + s->vma += adjust_section_vma; + s->lma += adjust_section_vma; } - return; } - printf ("\n%s: file format %s\n", bfd_get_filename (abfd), + printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd), abfd->xvec->name); if (dump_ar_hdrs) print_arelt_descr (stdout, abfd, true); @@ -1835,8 +2140,11 @@ display_bfd (abfd) if (dhandle != NULL) { if (! print_debugging_info (stdout, dhandle)) - fprintf (stderr, "%s: printing debugging information failed\n", - bfd_get_filename (abfd)); + { + non_fatal (_("%s: printing debugging information failed"), + bfd_get_filename (abfd)); + exit_status = 1; + } } } if (syms) @@ -1851,6 +2159,47 @@ display_bfd (abfd) } } +static void +display_bfd (abfd) + bfd *abfd; +{ + char **matching; + + if (bfd_check_format_matches (abfd, bfd_object, &matching)) + { + dump_bfd (abfd); + return; + } + + if (bfd_get_error () == bfd_error_file_ambiguously_recognized) + { + nonfatal (bfd_get_filename (abfd)); + list_matching_formats (matching); + free (matching); + return; + } + + if (bfd_get_error () != bfd_error_file_not_recognized) + { + nonfatal (bfd_get_filename (abfd)); + return; + } + + if (bfd_check_format_matches (abfd, bfd_core, &matching)) + { + dump_bfd (abfd); + return; + } + + nonfatal (bfd_get_filename (abfd)); + + if (bfd_get_error () == bfd_error_file_ambiguously_recognized) + { + list_matching_formats (matching); + free (matching); + } +} + static void display_file (filename, target) char *filename; @@ -1861,7 +2210,7 @@ display_file (filename, target) file = bfd_openr (filename, target); if (file == NULL) { - bfd_nonfatal (filename); + nonfatal (filename); return; } @@ -1869,7 +2218,7 @@ display_file (filename, target) { bfd *last_arfile = NULL; - printf ("In archive %s:\n", bfd_get_filename (file)); + printf (_("In archive %s:\n"), bfd_get_filename (file)); for (;;) { bfd_set_error (bfd_error_no_error); @@ -1878,9 +2227,7 @@ display_file (filename, target) if (arfile == NULL) { if (bfd_get_error () != bfd_error_no_more_archived_files) - { - bfd_nonfatal (bfd_get_filename (file)); - } + nonfatal (bfd_get_filename (file)); break; } @@ -1909,8 +2256,9 @@ dump_data (abfd) asection *section; bfd_byte *data = 0; bfd_size_type datasize = 0; - bfd_size_type i; - bfd_size_type start, stop; + bfd_size_type addr_offset; + bfd_size_type start_offset, stop_offset; + unsigned int opb = bfd_octets_per_byte (abfd); for (section = abfd->sections; section != NULL; section = section->next) @@ -1922,7 +2270,7 @@ dump_data (abfd) { if (section->flags & SEC_HAS_CONTENTS) { - printf ("Contents of section %s:\n", section->name); + printf (_("Contents of section %s:\n"), section->name); if (bfd_section_size (abfd, section) == 0) continue; @@ -1934,28 +2282,31 @@ dump_data (abfd) if (start_address == (bfd_vma) -1 || start_address < section->vma) - start = 0; + start_offset = 0; else - start = start_address - section->vma; + start_offset = start_address - section->vma; if (stop_address == (bfd_vma) -1) - stop = bfd_section_size (abfd, section); + stop_offset = bfd_section_size (abfd, section) / opb; else { if (stop_address < section->vma) - stop = 0; + stop_offset = 0; else - stop = stop_address - section->vma; - if (stop > bfd_section_size (abfd, section)) - stop = bfd_section_size (abfd, section); + stop_offset = stop_address - section->vma; + if (stop_offset > bfd_section_size (abfd, section) / opb) + stop_offset = bfd_section_size (abfd, section) / opb; } - for (i = start; i < stop; i += onaline) + for (addr_offset = start_offset; + addr_offset < stop_offset; addr_offset += onaline) { bfd_size_type j; - printf (" %04lx ", (unsigned long int) (i + section->vma)); - for (j = i; j < i + onaline; j++) + printf (" %04lx ", (unsigned long int) + (addr_offset + section->vma)); + for (j = addr_offset * opb; + j < addr_offset * opb + onaline; j++) { - if (j < stop) + if (j < stop_offset * opb) printf ("%02x", (unsigned) (data[j])); else printf (" "); @@ -1964,9 +2315,9 @@ dump_data (abfd) } printf (" "); - for (j = i; j < i + onaline; j++) + for (j = addr_offset; j < addr_offset * opb + onaline; j++) { - if (j >= stop) + if (j >= stop_offset * opb) printf (" "); else printf ("%c", isprint (data[j]) ? data[j] : '.'); @@ -1982,7 +2333,7 @@ dump_data (abfd) /* Should perhaps share code and display with nm? */ static void dump_symbols (abfd, dynamic) - bfd *abfd; + bfd *abfd ATTRIBUTE_UNUSED; boolean dynamic; { asymbol **current; @@ -2010,12 +2361,40 @@ dump_symbols (abfd, dynamic) { if (*current) { - bfd *cur_bfd = bfd_asymbol_bfd(*current); - if (cur_bfd) + bfd *cur_bfd = bfd_asymbol_bfd (*current); + + if (cur_bfd != NULL) { - bfd_print_symbol (cur_bfd, - stdout, - *current, bfd_print_symbol_all); + const char *name; + char *alloc; + + name = bfd_asymbol_name (*current); + alloc = NULL; + if (do_demangle && name != NULL && *name != '\0') + { + const char *n; + + /* If we want to demangle the name, we demangle it + here, and temporarily clobber it while calling + bfd_print_symbol. FIXME: This is a gross hack. */ + + n = name; + if (bfd_get_symbol_leading_char (cur_bfd) == *n) + ++n; + alloc = cplus_demangle (n, DMGL_ANSI | DMGL_PARAMS); + if (alloc != NULL) + (*current)->name = alloc; + else + (*current)->name = n; + } + + bfd_print_symbol (cur_bfd, stdout, *current, + bfd_print_symbol_all); + + (*current)->name = name; + if (alloc != NULL) + free (alloc); + printf ("\n"); } } @@ -2207,9 +2586,12 @@ dump_reloc_set (abfd, sec, relpp, relcount) if (sym_name) { printf_vma (q->address); - printf (" %-16s %s", - q->howto->name, - sym_name); + if (q->howto->name) + printf (" %-16s ", q->howto->name); + else + printf (" %-16d ", q->howto->type); + objdump_print_symname (abfd, (struct disassemble_info *) NULL, + *q->sym_ptr_ptr); } else { @@ -2267,14 +2649,14 @@ display_target_list () if (abfd == NULL) { - bfd_nonfatal (dummy_name); + nonfatal (dummy_name); continue; } if (! bfd_set_format (abfd, bfd_object)) { if (bfd_get_error () != bfd_error_invalid_operation) - bfd_nonfatal (p->name); + nonfatal (p->name); continue; } @@ -2320,7 +2702,7 @@ display_info_table (first, last) if (abfd == NULL) { - bfd_nonfatal (p->name); + nonfatal (p->name); ok = false; } @@ -2329,7 +2711,7 @@ display_info_table (first, last) if (! bfd_set_format (abfd, bfd_object)) { if (bfd_get_error () != bfd_error_invalid_operation) - bfd_nonfatal (p->name); + nonfatal (p->name); ok = false; } } @@ -2365,7 +2747,6 @@ display_target_tables () int t, columns; extern bfd_target *bfd_target_vector[]; char *colum; - extern char *getenv (); columns = 0; colum = getenv ("COLUMNS"); @@ -2398,7 +2779,7 @@ display_target_tables () static void display_info () { - printf ("BFD header file version %s\n", BFD_VERSION); + printf (_("BFD header file version %s\n"), BFD_VERSION); display_target_list (); display_target_tables (); } @@ -2412,19 +2793,24 @@ main (argc, argv) char *target = default_target; boolean seenflag = false; +#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES) + setlocale (LC_MESSAGES, ""); +#endif + bindtextdomain (PACKAGE, LOCALEDIR); + textdomain (PACKAGE); + program_name = *argv; xmalloc_set_program_name (program_name); START_PROGRESS (program_name, 0); bfd_init (); + set_default_bfd_target (); - while ((c = getopt_long (argc, argv, "pib:m:VdDlfahrRtTxsSj:wE:", + while ((c = getopt_long (argc, argv, "pib:m:M:VCdDlfahHrRtTxsSj:wE:zgG", long_options, (int *) 0)) != EOF) { - if (c != 'l' && c != OPTION_START_ADDRESS && c != OPTION_STOP_ADDRESS) - seenflag = true; switch (c) { case 0: @@ -2432,100 +2818,138 @@ main (argc, argv) case 'm': machine = optarg; break; + case 'M': + disassembler_options = optarg; + break; case 'j': only = optarg; break; case 'l': - with_line_numbers = 1; + with_line_numbers = true; break; case 'b': target = optarg; break; + case 'C': + do_demangle = true; + break; + case 'w': + wide_output = true; + break; + case OPTION_ADJUST_VMA: + adjust_section_vma = parse_vma (optarg, "--adjust-vma"); + break; + case OPTION_START_ADDRESS: + start_address = parse_vma (optarg, "--start-address"); + break; + case OPTION_STOP_ADDRESS: + stop_address = parse_vma (optarg, "--stop-address"); + break; + case 'E': + if (strcmp (optarg, "B") == 0) + endian = BFD_ENDIAN_BIG; + else if (strcmp (optarg, "L") == 0) + endian = BFD_ENDIAN_LITTLE; + else + { + non_fatal (_("unrecognized -E option")); + usage (stderr, 1); + } + break; + case OPTION_ENDIAN: + if (strncmp (optarg, "big", strlen (optarg)) == 0) + endian = BFD_ENDIAN_BIG; + else if (strncmp (optarg, "little", strlen (optarg)) == 0) + endian = BFD_ENDIAN_LITTLE; + else + { + non_fatal (_("unrecognized --endian type `%s'"), optarg); + usage (stderr, 1); + } + break; + case 'f': dump_file_header = true; + seenflag = true; break; case 'i': formats_info = true; + seenflag = true; break; case 'p': - dump_private_headers = 1; + dump_private_headers = true; + seenflag = true; break; case 'x': - dump_private_headers = 1; - dump_symtab = 1; - dump_reloc_info = 1; + dump_private_headers = true; + dump_symtab = true; + dump_reloc_info = true; dump_file_header = true; - dump_ar_hdrs = 1; - dump_section_headers = 1; + dump_ar_hdrs = true; + dump_section_headers = true; + seenflag = true; break; case 't': - dump_symtab = 1; + dump_symtab = true; + seenflag = true; break; case 'T': - dump_dynamic_symtab = 1; + dump_dynamic_symtab = true; + seenflag = true; break; case 'd': disassemble = true; + seenflag = true; + break; + case 'z': + disassemble_zeroes = true; break; case 'D': - disassemble = disassemble_all = true; + disassemble = true; + disassemble_all = true; + seenflag = true; break; case 'S': disassemble = true; with_source_code = true; + seenflag = true; + break; + case 'g': + dump_debugging = 1; + seenflag = true; + break; + case 'G': + dump_stab_section_info = true; + seenflag = true; break; case 's': - dump_section_contents = 1; + dump_section_contents = true; + seenflag = true; break; case 'r': - dump_reloc_info = 1; + dump_reloc_info = true; + seenflag = true; break; case 'R': - dump_dynamic_reloc_info = 1; + dump_dynamic_reloc_info = true; + seenflag = true; break; case 'a': - dump_ar_hdrs = 1; + dump_ar_hdrs = true; + seenflag = true; break; case 'h': - dump_section_headers = 1; + dump_section_headers = true; + seenflag = true; break; case 'H': usage (stdout, 0); + seenflag = true; case 'V': - show_version = 1; - break; - case 'w': - wide_output = 1; - break; - case OPTION_START_ADDRESS: - start_address = parse_vma (optarg, "--start-address"); - break; - case OPTION_STOP_ADDRESS: - stop_address = parse_vma (optarg, "--stop-address"); - break; - case 'E': - if (strcmp (optarg, "B") == 0) - endian = BFD_ENDIAN_BIG; - else if (strcmp (optarg, "L") == 0) - endian = BFD_ENDIAN_LITTLE; - else - { - fprintf (stderr, "%s: unrecognized -E option\n", program_name); - usage (stderr, 1); - } - break; - case OPTION_ENDIAN: - if (strncmp (optarg, "big", strlen (optarg)) == 0) - endian = BFD_ENDIAN_BIG; - else if (strncmp (optarg, "little", strlen (optarg)) == 0) - endian = BFD_ENDIAN_LITTLE; - else - { - fprintf (stderr, "%s: unrecognized --endian type `%s'\n", - program_name, optarg); - usage (stderr, 1); - } + show_version = true; + seenflag = true; break; + default: usage (stderr, 1); } @@ -2535,12 +2959,10 @@ main (argc, argv) print_version ("objdump"); if (seenflag == false) - usage (stderr, 1); + usage (stderr, 2); if (formats_info) - { - display_info (); - } + display_info (); else { if (optind == argc) @@ -2552,5 +2974,5 @@ main (argc, argv) END_PROGRESS (program_name); - return 0; + return exit_status; }