/* objdump.c -- dump information about an object file.
- Copyright 1990, 91, 92, 93, 94, 95, 1996 Free Software Foundation, Inc.
+ Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 98, 1999
+ Free Software Foundation, Inc.
This file is part of GNU Binutils.
#include <ctype.h>
#include "dis-asm.h"
#include "libiberty.h"
+#include "demangle.h"
#include "debug.h"
#include "budbg.h"
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 */
static boolean formats_info; /* -i */
static char *only; /* -j secname */
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 */
/* Extra info to pass to the disassembler address printing function. */
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;
/* Number of symbols in `dynsyms'. */
static long dynsymcount = 0;
-/* Forward declarations. */
+/* Static declarations. */
+
+static void
+usage PARAMS ((FILE *, int));
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));
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
-objdump_print_value PARAMS ((bfd_vma, struct disassemble_info *));
+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 *));
static void
objdump_print_addr_with_sym PARAMS ((bfd *, asection *, asymbol *, bfd_vma,
- struct disassemble_info *));
+ struct disassemble_info *, boolean));
+
+static void
+objdump_print_addr PARAMS ((bfd_vma, struct disassemble_info *, boolean));
static void
objdump_print_address PARAMS ((bfd_vma, struct disassemble_info *));
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 *));
\f
static void
usage (stream, status)
FILE *stream;
int status;
{
- fprintf (stream, "\
-Usage: %s [-ahifdDprRtTxsSlw] [-b bfdname] [-m machine] [-j section-name]\n\
+ fprintf (stream, _("\
+Usage: %s [-ahifCdDprRtTxsSlw] [-b bfdname] [-m machine] \n\
+ [-j section-name] [-M disassembler-options]\n\
[--archive-headers] [--target=bfdname] [--debugging] [--disassemble]\n\
- [--disassemble-all] [--file-headers] [--section-headers] [--headers]\n\
- [--info] [--section=section-name] [--line-numbers] [--source]\n",
+ [--disassemble-all] [--disassemble-zeroes] [--file-headers]\n\
+ [--section-headers] [--headers]\n\
+ [--info] [--section=section-name] [--line-numbers] [--source]\n"),
program_name);
- fprintf (stream, "\
+ 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");
+ [--prefix-addresses] [--[no-]show-raw-insn] [--demangle]\n\
+ [--adjust-vma=offset] [-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);
if (status == 0)
- fprintf (stream, "Report bugs to bug-gnu-utils@prep.ai.mit.edu\n");
+ fprintf (stream, _("Report bugs to bug-gnu-utils@gnu.org\n"));
exit (status);
}
#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},
+ {"demangle", no_argument, &do_demangle, 1},
{"disassemble", no_argument, NULL, 'd'},
{"disassemble-all", no_argument, NULL, 'D'},
+ {"disassembler-options", required_argument, NULL, 'M'},
+ {"disassemble-zeroes", no_argument, &disassemble_zeroes, 1},
{"dynamic-reloc", no_argument, NULL, 'R'},
{"dynamic-syms", no_argument, NULL, 'T'},
{"endian", required_argument, NULL, OPTION_ENDIAN},
{"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'},
\f
static void
dump_section_header (abfd, section, ignored)
- bfd *abfd;
+ bfd *abfd ATTRIBUTE_UNUSED;
asection *section;
- PTR ignored;
+ PTR ignored ATTRIBUTE_UNUSED;
{
char *comma = "";
PF (SEC_NEVER_LOAD, "NEVER_LOAD");
PF (SEC_EXCLUDE, "EXCLUDE");
PF (SEC_SORT_ENTRIES, "SORT_ENTRIES");
+ PF (SEC_SMALL_DATA, "SMALL_DATA");
+ PF (SEC_SHARED, "SHARED");
if ((section->flags & SEC_LINK_ONCE) != 0)
{
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\n"));
#else
- printf ("Idx Name Size VMA LMA File off Algn\n");
+ printf (_("Idx Name Size VMA LMA File off Algn\n"));
#endif
bfd_map_over_sections (abfd, dump_section_header, (PTR) NULL);
}
if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
{
- printf ("No symbols in \"%s\".\n", bfd_get_filename (abfd));
+ fprintf (stderr, _("%s: no symbols\n"), bfd_get_filename (abfd));
symcount = 0;
return NULL;
}
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));
+ fprintf (stderr, _("%s: no symbols\n"), bfd_get_filename (abfd));
return sy;
}
{
if (!(bfd_get_file_flags (abfd) & DYNAMIC))
{
- fprintf (stderr, "%s: %s: not a dynamic object\n",
+ fprintf (stderr, _("%s: %s: not a dynamic object\n"),
program_name, bfd_get_filename (abfd));
dynsymcount = 0;
return NULL;
if (dynsymcount < 0)
bfd_fatal (bfd_get_filename (abfd));
if (dynsymcount == 0)
- fprintf (stderr, "%s: %s: No dynamic symbols\n",
+ fprintf (stderr, _("%s: %s: No dynamic symbols\n"),
program_name, bfd_get_filename (abfd));
return sy;
}
return 0;
}
-/* Print VMA to STREAM with no leading zeroes. */
+/* Print VMA to STREAM. If SKIP_ZEROES is true, omit leading zeroes. */
static void
-objdump_print_value (vma, info)
+objdump_print_value (vma, info, skip_zeroes)
bfd_vma vma;
struct disassemble_info *info;
+ boolean skip_zeroes;
{
char buf[30];
char *p;
sprintf_vma (buf, vma);
- for (p = buf; *p == '0'; ++p)
- ;
- if (*p == '\0')
- --p;
+ if (! skip_zeroes)
+ p = buf;
+ else
+ {
+ for (p = buf; *p == '0'; ++p)
+ ;
+ if (*p == '\0')
+ --p;
+ }
(*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,
/* Print an address to INFO symbolically. */
static void
-objdump_print_addr_with_sym (abfd, sec, sym, vma, info)
+objdump_print_addr_with_sym (abfd, sec, sym, vma, info, skip_zeroes)
bfd *abfd;
asection *sec;
asymbol *sym;
bfd_vma vma;
struct disassemble_info *info;
+ boolean skip_zeroes;
{
- char buf[30];
-
- sprintf_vma (buf, vma);
- (*info->fprintf_func) (info->stream, "%s", buf);
+ objdump_print_value (vma, info, skip_zeroes);
if (sym == NULL)
{
secaddr = bfd_get_section_vma (abfd, sec);
if (vma < secaddr)
{
- (*info->fprintf_func) (info->stream, "-");
- objdump_print_value (secaddr - vma, info);
+ (*info->fprintf_func) (info->stream, "-0x");
+ objdump_print_value (secaddr - vma, info, true);
}
else if (vma > secaddr)
{
- (*info->fprintf_func) (info->stream, "+");
- objdump_print_value (vma - secaddr, info);
+ (*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, "-");
- objdump_print_value (bfd_asymbol_value (sym) - vma, info);
+ (*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, "+");
- objdump_print_value (vma - bfd_asymbol_value (sym), info);
+ (*info->fprintf_func) (info->stream, "+0x");
+ objdump_print_value (vma - bfd_asymbol_value (sym), info, true);
}
(*info->fprintf_func) (info->stream, ">");
}
}
-/* Print VMA symbolically to INFO if possible. */
+/* Print VMA to INFO, symbolically if possible. If SKIP_ZEROES is
+ true, don't output leading zeroes. */
static void
-objdump_print_address (vma, info)
+objdump_print_addr (vma, info, skip_zeroes)
bfd_vma vma;
struct disassemble_info *info;
+ boolean skip_zeroes;
{
struct objdump_disasm_info *aux;
asymbol *sym;
if (sorted_symcount < 1)
{
- char buf[30];
-
- sprintf_vma (buf, vma);
- (*info->fprintf_func) (info->stream, "%s", buf);
+ (*info->fprintf_func) (info->stream, "0x");
+ objdump_print_value (vma, info, skip_zeroes);
return;
}
aux = (struct objdump_disasm_info *) info->application_data;
sym = find_symbol_for_address (aux->abfd, aux->sec, vma, aux->require_sec,
(long *) NULL);
- objdump_print_addr_with_sym (aux->abfd, aux->sec, sym, vma, info);
+ objdump_print_addr_with_sym (aux->abfd, aux->sec, sym, vma, info,
+ skip_zeroes);
+}
+
+/* Print VMA to INFO. This function is passed to the disassembler
+ routine. */
+
+static void
+objdump_print_address (vma, info)
+ bfd_vma vma;
+ struct disassemble_info *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
}
/* 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)
+ {
+ fprintf (stderr, _("Out of virtual memory\n"));
+ exit (1);
+ }
+
+ 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. */
disassembler_ftype disassemble_fn;
boolean insns;
bfd_byte *data;
- long start;
- long stop;
+ bfd_vma start;
+ bfd_vma stop;
arelent ***relppp;
arelent **relppend;
{
asection *section;
int bytes_per_line;
boolean done_dot;
- long i;
+ int skip_addr_chars;
+ bfd_vma i;
aux = (struct objdump_disasm_info *) info->application_data;
section = aux->sec;
else
bytes_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
+ zeroes in chunks of 4, ensuring that there is always a leading
+ zero remaining. */
+ skip_addr_chars = 0;
+ if (! prefix_addresses)
+ {
+ char buf[30];
+ char *s;
+
+ sprintf_vma (buf,
+ section->vma + bfd_section_size (section->owner, section));
+ s = buf;
+ while (s[0] == '0' && s[1] == '0' && s[2] == '0' && s[3] == '0'
+ && s[4] == '0')
+ {
+ skip_addr_chars += 4;
+ s += 4;
+ }
+ }
+
info->insn_info_valid = 0;
done_dot = false;
i = start;
while (i < stop)
{
- long z;
- int bytes;
+ bfd_vma z;
+ int bytes = 0;
boolean need_nl = false;
/* If we see more than SKIP_ZEROES bytes of zeroes, we just
for (z = i; z < stop; z++)
if (data[z] != 0)
break;
- if ((info->insn_info_valid == 0
- || info->branch_delay_insns == 0)
+ 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)))
{
}
else
{
- char buf[1000];
+ char buf[50];
SFILE sfile;
+ int bpc = 0;
int pb = 0;
done_dot = false;
show_line (aux->abfd, section, i);
if (! prefix_addresses)
- printf ("%6lx:\t", (unsigned long) (i - start));
+ {
+ char *s;
+
+ sprintf_vma (buf, section->vma + i);
+ for (s = buf + skip_addr_chars; *s == '0'; s++)
+ *s = ' ';
+ if (*s == '\0')
+ *--s = '0';
+ printf ("%s:\t", buf + skip_addr_chars);
+ }
else
{
aux->require_sec = true;
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;
+
+ /* FIXME: This is wrong. It tests the number of bytes
+ in the last instruction, not the current one. */
+ if (*relppp < relppend
+ && (**relppp)->address >= i
+ && (**relppp)->address < i + bytes)
+ info->flags = INSN_HAS_RELOC;
+ else
+ info->flags = 0;
+
bytes = (*disassemble_fn) (section->vma + i, 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;
+ {
+ 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)
buf[j - i] = '\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
- four bytes per line. */
+ bytes_per_line bytes per line. */
pb = bytes;
if (pb > bytes_per_line && ! prefix_addresses && ! wide_output)
pb = bytes_per_line;
- for (j = i; j < i + pb; ++j)
+ if (info->bytes_per_chunk)
+ bpc = info->bytes_per_chunk;
+ else
+ bpc = 1;
+
+ for (j = i; j < i + 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 (' ');
+ }
}
- for (; pb < bytes_per_line; ++pb)
- printf (" ");
+ for (; pb < bytes_per_line; pb += bpc)
+ {
+ int k;
+
+ for (k = 0; k < bpc; k++)
+ printf (" ");
+ putchar (' ');
+ }
/* Separate raw data from instruction by extra space. */
if (insns)
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)
{
- long j;
+ bfd_vma j;
+ char *s;
putchar ('\n');
j = i + pb;
- printf ("%6lx:\t", (unsigned long) (j - start));
+
+ sprintf_vma (buf, section->vma + j);
+ 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)
+ for (; j < i + 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 (' ');
+ }
}
}
}
&& (**relppp)->address < (bfd_vma) i + bytes))
{
arelent *q;
- const char *sym_name;
q = **relppp;
else
printf ("\t\t\t");
- objdump_print_value (section->vma + q->address - start, info);
+ objdump_print_value (section->vma + q->address, info, true);
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)
{
printf ("+0x");
- objdump_print_value (q->addend, info);
+ objdump_print_value (q->addend, info, true);
}
printf ("\n");
INIT_DISASSEMBLE_INFO(disasm_info, stdout, fprintf);
disasm_info.application_data = (PTR) &aux;
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;
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",
+ fprintf (stderr, _("%s: Can't use supplied machine %s\n"),
program_name,
machine);
exit (1);
disassemble_fn = disassembler (abfd);
if (!disassemble_fn)
{
- fprintf (stderr, "%s: Can't disassemble for architecture %s\n",
+ fprintf (stderr, _("%s: Can't disassemble for architecture %s\n"),
program_name,
bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
- exit (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. */
arelent **relpp = NULL;
arelent **relppend = NULL;
long stop;
+ asymbol *sym = NULL;
+ long place = 0;
if ((section->flags & SEC_LOAD) == 0
|| (! disassemble_all
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)
stop = disasm_info.buffer_length;
}
- 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 + i,
+ true, &place);
- sym = find_symbol_for_address (abfd, section, i, true, &place);
- ++place;
- while (i < stop)
+ while (i < stop)
+ {
+ asymbol *nextsym;
+ long nextstop;
+ boolean insns;
+
+ if (sym != NULL && bfd_asymbol_value (sym) <= section->vma + i)
{
- 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 + i);
+ ++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,
- &disasm_info);
+ &disasm_info,
+ false);
printf (":\n");
-
- if (sym == NULL)
+ }
+
+ if (sym != NULL && bfd_asymbol_value (sym) > section->vma + i)
+ nextsym = sym;
+ else if (sym == NULL)
+ nextsym = NULL;
+ else
+ {
+ while (place < sorted_symcount
+ /* ??? Why the test for != section? */
+ && (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)
+ nextsym = sorted_syms[place];
+ }
+
+ if (sym != NULL && bfd_asymbol_value (sym) > section->vma + i)
+ {
+ nextstop = bfd_asymbol_value (sym) - section->vma;
+ if (nextstop > stop)
+ nextstop = stop;
+ }
+ else if (nextsym == NULL)
+ nextstop = stop;
+ else
+ {
+ nextstop = bfd_asymbol_value (nextsym) - section->vma;
+ if (nextstop > stop)
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;
}
+
+ /* 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 + i
+ || ((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;
}
-
+
free (data);
if (relbuf != NULL)
free (relbuf);
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,
+ fprintf (stderr, _("%s: %s has no %s section\n"), program_name,
bfd_get_filename (abfd), strsect_name);
return false;
}
if (! bfd_get_section_contents (abfd, stabsect, (PTR) stabs, 0, stab_size))
{
- fprintf (stderr, "%s: Reading %s section of %s failed: %s\n",
+ fprintf (stderr, _("%s: Reading %s section of %s failed: %s\n"),
program_name, stabsect_name, bfd_get_filename (abfd),
bfd_errmsg (bfd_get_error ()));
free (stabs);
if (! bfd_get_section_contents (abfd, stabstrsect, (PTR) strtab, 0,
stabstr_size))
{
- fprintf (stderr, "%s: Reading %s section of %s failed: %s\n",
+ fprintf (stderr, _("%s: Reading %s section of %s failed: %s\n"),
program_name, strsect_name, bfd_get_filename (abfd),
bfd_errmsg (bfd_get_error ()));
free (stabs);
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;
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.
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))
{
{
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");
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");
}
return;
}
- printf ("\n%s: file format %s\n", bfd_get_filename (abfd),
+ /* 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)
+ {
+ asection *s;
+
+ for (s = abfd->sections; s != NULL; s = s->next)
+ {
+ s->vma += adjust_section_vma;
+ s->lma += adjust_section_vma;
+ }
+ }
+
+ printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd),
abfd->xvec->name);
if (dump_ar_hdrs)
print_arelt_descr (stdout, abfd, true);
if (dhandle != NULL)
{
if (! print_debugging_info (stdout, dhandle))
- fprintf (stderr, "%s: printing debugging information failed\n",
+ fprintf (stderr, _("%s: printing debugging information failed\n"),
bfd_get_filename (abfd));
}
}
{
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);
{
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;
/* Should perhaps share code and display with nm? */
static void
dump_symbols (abfd, dynamic)
- bfd *abfd;
+ bfd *abfd ATTRIBUTE_UNUSED;
boolean dynamic;
{
asymbol **current;
{
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");
}
}
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
{
int t, columns;
extern bfd_target *bfd_target_vector[];
char *colum;
- extern char *getenv ();
columns = 0;
colum = getenv ("COLUMNS");
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 ();
}
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:VCdDlfahrRtTxsSj:wE:",
long_options, (int *) 0))
!= EOF)
{
case 'm':
machine = optarg;
break;
+ case 'M':
+ disassembler_options = optarg;
+ break;
case 'j':
only = optarg;
break;
case 'T':
dump_dynamic_symtab = 1;
break;
+ case 'C':
+ do_demangle = 1;
+ break;
case 'd':
disassemble = true;
break;
case 'w':
wide_output = 1;
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;
endian = BFD_ENDIAN_LITTLE;
else
{
- fprintf (stderr, "%s: unrecognized -E option\n", program_name);
+ fprintf (stderr, _("%s: unrecognized -E option\n"), program_name);
usage (stderr, 1);
}
break;
endian = BFD_ENDIAN_LITTLE;
else
{
- fprintf (stderr, "%s: unrecognized --endian type `%s'\n",
+ fprintf (stderr, _("%s: unrecognized --endian type `%s'\n"),
program_name, optarg);
usage (stderr, 1);
}