#include "bfd.h"
#include "sysdep.h"
#include "getopt.h"
+#include "progress.h"
#include "bucomm.h"
#include <stdio.h>
#include <ctype.h>
#include "dis-asm.h"
+#include "libiberty.h"
/* Internal headers for the ELF .stab-dump code - sorry. */
#define BYTES_IN_WORD 32
#include "aout/aout64.h"
-#include "elf/internal.h"
-extern Elf_Internal_Shdr *bfd_elf_find_section();
#ifndef FPRINTF_ALREADY_DECLARED
extern int fprintf PARAMS ((FILE *, CONST char *, ...));
int dump_dynamic_reloc_info; /* -R */
int dump_ar_hdrs; /* -a */
int with_line_numbers; /* -l */
+boolean with_source_code; /* -S */
int dump_stab_section_info; /* --stabs */
boolean disassemble; /* -d */
+boolean disassemble_all; /* -D */
boolean formats_info; /* -i */
char *only; /* -j secname */
struct objdump_disasm_info {
bfd *abfd;
asection *sec;
+ boolean require_sec;
};
/* Architecture to disassemble for, or default if NULL. */
/* Number of symbols in `syms'. */
long symcount = 0;
+/* The sorted symbol table. */
+asymbol **sorted_syms;
+
+/* Number of symbols in `sorted_syms'. */
+long sorted_symcount = 0;
+
/* The dynamic symbol table. */
asymbol **dynsyms;
static void
objdump_print_address PARAMS ((bfd_vma, struct disassemble_info *));
+
+static void
+show_line PARAMS ((bfd *, asection *, bfd_vma));
\f
void
usage (stream, status)
int status;
{
fprintf (stream, "\
-Usage: %s [-ahifdrRtTxsl] [-b bfdname] [-m machine] [-j section-name]\n\
- [--archive-headers] [--target=bfdname] [--disassemble] [--file-headers]\n\
- [--section-headers] [--headers] [--info] [--section=section-name]\n\
- [--line-numbers] [--architecture=machine] [--reloc] [--full-contents]\n\
- [--stabs] [--syms] [--all-headers] [--dynamic-syms] [--dynamic-reloc]\n\
+Usage: %s [-ahifdDrRtTxsSl] [-b bfdname] [-m machine] [-j section-name]\n\
+ [--archive-headers] [--target=bfdname] [--disassemble]\n\
+ [--disassemble-all] [--file-headers] [--section-headers] [--headers]\n\
+ [--info] [--section=section-name] [--line-numbers] [--source]\n\
+ [--architecture=machine] [--reloc] [--full-contents] [--stabs]\n\
+ [--syms] [--all-headers] [--dynamic-syms] [--dynamic-reloc]\n\
[--version] [--help] objfile...\n\
at least one option besides -l (--line-numbers) must be given\n",
program_name);
+ list_supported_targets (program_name, stream);
exit (status);
}
{"architecture", required_argument, NULL, 'm'},
{"archive-headers", no_argument, NULL, 'a'},
{"disassemble", no_argument, NULL, 'd'},
+ {"disassemble-all", no_argument, NULL, 'D'},
{"dynamic-reloc", no_argument, NULL, 'R'},
{"dynamic-syms", no_argument, NULL, 'T'},
{"file-headers", no_argument, NULL, 'f'},
{"reloc", no_argument, NULL, 'r'},
{"section", required_argument, NULL, 'j'},
{"section-headers", no_argument, NULL, 'h'},
+ {"source", no_argument, NULL, 'S'},
{"stabs", no_argument, &dump_stab_section_info, 1},
{"syms", no_argument, NULL, 't'},
{"target", required_argument, NULL, 'b'},
PF (SEC_DATA, "DATA");
PF (SEC_ROM, "ROM");
PF (SEC_DEBUGGING, "DEBUGGING");
+ PF (SEC_NEVER_LOAD, "NEVER_LOAD");
printf ("\n");
#undef PF
}
asymbol **sy = (asymbol **) NULL;
long storage;
- if (!(bfd_get_file_flags (abfd) & DYNAMIC))
- {
- fprintf (stderr, "%s: %s: not a dynamic object\n",
- program_name, bfd_get_filename (abfd));
- return NULL;
- }
-
storage = bfd_get_dynamic_symtab_upper_bound (abfd);
if (storage < 0)
- bfd_fatal (bfd_get_filename (abfd));
+ {
+ if (!(bfd_get_file_flags (abfd) & DYNAMIC))
+ {
+ fprintf (stderr, "%s: %s: not a dynamic object\n",
+ program_name, bfd_get_filename (abfd));
+ return NULL;
+ }
+
+ bfd_fatal (bfd_get_filename (abfd));
+ }
if (storage)
{
continue;
if (sym->flags & (BSF_DEBUGGING))
continue;
- if (sym->section == &bfd_und_section
+ if (bfd_is_und_section (sym->section)
|| bfd_is_com_section (sym->section))
continue;
static int
compare_symbols (ap, bp)
- PTR ap;
- PTR bp;
+ const PTR ap;
+ const PTR bp;
{
- asymbol *a = *(asymbol **)ap;
- asymbol *b = *(asymbol **)bp;
+ const asymbol *a = *(const asymbol **)ap;
+ const asymbol *b = *(const asymbol **)bp;
- if (a->value > b->value)
+ if (bfd_asymbol_value (a) > bfd_asymbol_value (b))
return 1;
- else if (a->value < b->value)
+ else if (bfd_asymbol_value (a) < bfd_asymbol_value (b))
return -1;
if (a->section > b->section)
return 0;
}
+/* Sort relocs into address order. */
+
+static int
+compare_relocs (ap, bp)
+ const PTR ap;
+ const PTR bp;
+{
+ const arelent *a = *(const arelent **)ap;
+ const arelent *b = *(const arelent **)bp;
+
+ if (a->address > b->address)
+ return 1;
+ else if (a->address < b->address)
+ return -1;
+
+ return compare_symbols ((const PTR) a->sym_ptr_ptr,
+ (const PTR) b->sym_ptr_ptr);
+}
+
/* Print VMA symbolically to INFO if possible. */
static void
operand can be present at a time, so the 2-entry cache wouldn't be
constantly churned by code doing heavy memory accesses. */
- /* Indices in `syms'. */
+ /* Indices in `sorted_syms'. */
long min = 0;
- long max = symcount;
+ long max = sorted_symcount;
long thisplace;
bfd_signed_vma vardiff;
fprintf_vma (info->stream, vma);
- if (symcount < 1)
+ if (sorted_symcount < 1)
return;
/* Perform a binary search looking for the closest symbol to the
asymbol *sym;
thisplace = (max + min) / 2;
- sym = syms[thisplace];
+ sym = sorted_syms[thisplace];
- vardiff = sym->value - vma;
+ vardiff = bfd_asymbol_value (sym) - vma;
if (vardiff > 0)
max = thisplace;
{
/* If this symbol isn't global, search for one with the same value
that is. */
- bfd_vma val = syms[thisplace]->value;
+ bfd_vma val = bfd_asymbol_value (sorted_syms[thisplace]);
long i;
- if (syms[thisplace]->flags & (BSF_LOCAL|BSF_DEBUGGING))
+ if (sorted_syms[thisplace]->flags & (BSF_LOCAL|BSF_DEBUGGING))
for (i = thisplace - 1; i >= 0; i--)
{
- if (syms[i]->value == val
- && (!(syms[i]->flags & (BSF_LOCAL|BSF_DEBUGGING))
- || ((syms[thisplace]->flags & BSF_DEBUGGING)
- && !(syms[i]->flags & BSF_DEBUGGING))))
+ if (bfd_asymbol_value (sorted_syms[i]) == val
+ && (!(sorted_syms[i]->flags & (BSF_LOCAL|BSF_DEBUGGING))
+ || ((sorted_syms[thisplace]->flags & BSF_DEBUGGING)
+ && !(sorted_syms[i]->flags & BSF_DEBUGGING))))
{
thisplace = i;
break;
}
}
- if (syms[thisplace]->flags & (BSF_LOCAL|BSF_DEBUGGING))
- for (i = thisplace + 1; i < symcount; i++)
+ if (sorted_syms[thisplace]->flags & (BSF_LOCAL|BSF_DEBUGGING))
+ for (i = thisplace + 1; i < sorted_symcount; i++)
{
- if (syms[i]->value == val
- && (!(syms[i]->flags & (BSF_LOCAL|BSF_DEBUGGING))
- || ((syms[thisplace]->flags & BSF_DEBUGGING)
- && !(syms[i]->flags & BSF_DEBUGGING))))
+ if (bfd_asymbol_value (sorted_syms[i]) == val
+ && (!(sorted_syms[i]->flags & (BSF_LOCAL|BSF_DEBUGGING))
+ || ((sorted_syms[thisplace]->flags & BSF_DEBUGGING)
+ && !(sorted_syms[i]->flags & BSF_DEBUGGING))))
{
thisplace = i;
break;
long i;
aux = (struct objdump_disasm_info *) info->application_data;
- if ((aux->abfd->flags & HAS_RELOC)
- && vma >= bfd_get_section_vma (aux->abfd, aux->sec)
- && vma < (bfd_get_section_vma (aux->abfd, aux->sec)
- + bfd_get_section_size_before_reloc (aux->sec))
- && syms[thisplace]->section != aux->sec)
+ if (sorted_syms[thisplace]->section != aux->sec
+ && (aux->require_sec
+ || ((aux->abfd->flags & HAS_RELOC) != 0
+ && vma >= bfd_get_section_vma (aux->abfd, aux->sec)
+ && vma < (bfd_get_section_vma (aux->abfd, aux->sec)
+ + bfd_get_section_size_before_reloc (aux->sec)))))
{
- for (i = thisplace + 1; i < symcount; i++)
+ for (i = thisplace + 1; i < sorted_symcount; i++)
{
- if (syms[i]->value != syms[thisplace]->value)
- {
- i--;
- break;
- }
+ if (bfd_asymbol_value (sorted_syms[i])
+ != bfd_asymbol_value (sorted_syms[thisplace]))
+ break;
}
+ --i;
for (; i >= 0; i--)
{
- if (syms[i]->section == aux->sec)
+ if (sorted_syms[i]->section == aux->sec)
{
thisplace = i;
break;
}
}
+
+ if (sorted_syms[thisplace]->section != aux->sec)
+ {
+ /* We didn't find a good symbol with a smaller value.
+ Look for one with a larger value. */
+ for (i = thisplace + 1; i < sorted_symcount; i++)
+ {
+ if (sorted_syms[i]->section == aux->sec)
+ {
+ thisplace = i;
+ break;
+ }
+ }
+ }
}
}
- fprintf (info->stream, " <%s", syms[thisplace]->name);
- if (syms[thisplace]->value > vma)
+
+ fprintf (info->stream, " <%s", sorted_syms[thisplace]->name);
+ if (bfd_asymbol_value (sorted_syms[thisplace]) > vma)
{
char buf[30], *p = buf;
- sprintf_vma (buf, syms[thisplace]->value - vma);
+ sprintf_vma (buf, bfd_asymbol_value (sorted_syms[thisplace]) - vma);
while (*p == '0')
p++;
fprintf (info->stream, "-%s", p);
}
- else if (vma > syms[thisplace]->value)
+ else if (vma > bfd_asymbol_value (sorted_syms[thisplace]))
{
char buf[30], *p = buf;
- sprintf_vma (buf, vma - syms[thisplace]->value);
+ sprintf_vma (buf, vma - bfd_asymbol_value (sorted_syms[thisplace]));
while (*p == '0')
p++;
fprintf (info->stream, "+%s", p);
fprintf (info->stream, ">");
}
-#ifdef ARCH_all
-#define ARCH_a29k
-#define ARCH_alpha
-#define ARCH_h8300
-#define ARCH_h8500
-#define ARCH_hppa
-#define ARCH_i386
-#define ARCH_i960
-#define ARCH_m68k
-#define ARCH_m88k
-#define ARCH_mips
-#define ARCH_powerpc
-#define ARCH_rs6000
-#define ARCH_sh
-#define ARCH_sparc
-#define ARCH_z8k
-#endif
+/* Hold the last function name and the last line number we displayed
+ in a disassembly. */
+
+static char *prev_functionname;
+static unsigned int prev_line;
+
+/* We keep a list of all files that we have seen when doing a
+ dissassembly with source, so that we know how much of the file to
+ display. This can be important for inlined functions. */
+
+struct print_file_list
+{
+ struct print_file_list *next;
+ char *filename;
+ unsigned int line;
+ FILE *f;
+};
+
+static struct print_file_list *print_files;
+
+/* The number of preceding context lines to show when we start
+ displaying a file for the first time. */
+
+#define SHOW_PRECEDING_CONTEXT_LINES (5)
+
+/* Skip ahead to a given line in a file, optionally printing each
+ line. */
+
+static void
+skip_to_line PARAMS ((struct print_file_list *, unsigned int, boolean));
+
+static void
+skip_to_line (p, line, show)
+ struct print_file_list *p;
+ unsigned int line;
+ boolean show;
+{
+ while (p->line < line)
+ {
+ char buf[100];
+
+ if (fgets (buf, sizeof buf, p->f) == NULL)
+ {
+ fclose (p->f);
+ p->f = NULL;
+ break;
+ }
+
+ if (show)
+ printf ("%s", buf);
+
+ if (strchr (buf, '\n') != NULL)
+ ++p->line;
+ }
+}
+
+/* Show the line number, or the source line, in a dissassembly
+ listing. */
+
+static void
+show_line (abfd, section, off)
+ bfd *abfd;
+ asection *section;
+ bfd_vma off;
+{
+ CONST char *filename;
+ CONST char *functionname;
+ unsigned int line;
+
+ if (! with_line_numbers && ! with_source_code)
+ return;
+
+ if (! bfd_find_nearest_line (abfd, section, syms, off, &filename,
+ &functionname, &line))
+ return;
+
+ if (filename != NULL && *filename == '\0')
+ filename = NULL;
+ if (functionname != NULL && *functionname == '\0')
+ functionname = NULL;
+
+ if (with_line_numbers)
+ {
+ if (functionname != NULL
+ && (prev_functionname == NULL
+ || strcmp (functionname, prev_functionname) != 0))
+ printf ("%s():\n", functionname);
+ if (line > 0 && line != prev_line)
+ printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
+ }
+
+ if (with_source_code
+ && filename != NULL
+ && line > 0)
+ {
+ struct print_file_list **pp, *p;
+
+ for (pp = &print_files; *pp != NULL; pp = &(*pp)->next)
+ if (strcmp ((*pp)->filename, filename) == 0)
+ break;
+ p = *pp;
+
+ if (p != NULL)
+ {
+ if (p != print_files)
+ {
+ int l;
+
+ /* We have reencountered a file name which we saw
+ earlier. This implies that either we are dumping out
+ code from an included file, or the same file was
+ linked in more than once. There are two common cases
+ of an included file: inline functions in a header
+ file, and a bison or flex skeleton file. In the
+ former case we want to just start printing (but we
+ back up a few lines to give context); in the latter
+ case we want to continue from where we left off. I
+ can't think of a good way to distinguish the cases,
+ so I used a heuristic based on the file name. */
+ if (strcmp (p->filename + strlen (p->filename) - 2, ".h") != 0)
+ l = p->line;
+ else
+ {
+ l = line - SHOW_PRECEDING_CONTEXT_LINES;
+ if (l <= 0)
+ l = 1;
+ }
+
+ if (p->f == NULL)
+ {
+ p->f = fopen (p->filename, "r");
+ p->line = 0;
+ }
+ if (p->f != NULL)
+ skip_to_line (p, l, false);
+
+ if (print_files->f != NULL)
+ {
+ fclose (print_files->f);
+ print_files->f = NULL;
+ }
+ }
+
+ if (p->f != NULL)
+ {
+ skip_to_line (p, line, true);
+ *pp = p->next;
+ p->next = print_files;
+ print_files = p;
+ }
+ }
+ else
+ {
+ FILE *f;
+
+ f = fopen (filename, "r");
+ if (f != NULL)
+ {
+ int l;
+
+ p = ((struct print_file_list *)
+ xmalloc (sizeof (struct print_file_list)));
+ p->filename = xmalloc (strlen (filename) + 1);
+ strcpy (p->filename, filename);
+ p->line = 0;
+ p->f = f;
+
+ if (print_files != NULL && print_files->f != NULL)
+ {
+ fclose (print_files->f);
+ print_files->f = NULL;
+ }
+ p->next = print_files;
+ print_files = p;
+
+ l = line - SHOW_PRECEDING_CONTEXT_LINES;
+ if (l <= 0)
+ l = 1;
+ skip_to_line (p, l, false);
+ if (p->f != NULL)
+ skip_to_line (p, line, true);
+ }
+ }
+ }
+
+ if (functionname != NULL
+ && (prev_functionname == NULL
+ || strcmp (functionname, prev_functionname) != 0))
+ {
+ if (prev_functionname != NULL)
+ free (prev_functionname);
+ prev_functionname = xmalloc (strlen (functionname) + 1);
+ strcpy (prev_functionname, functionname);
+ }
+
+ if (line > 0 && line != prev_line)
+ prev_line = line;
+}
void
disassemble_data (abfd)
{
long i;
unsigned int (*print) () = 0; /* Old style */
- disassembler_ftype disassemble = 0; /* New style */
+ disassembler_ftype disassemble_fn = 0; /* New style */
struct disassemble_info disasm_info;
struct objdump_disasm_info aux;
-
- int prevline;
- CONST char *prev_function = "";
-
asection *section;
-
boolean done_dot = false;
- /* Replace symbol section relative values with abs values. */
- for (i = 0; i < symcount; i++)
- {
- syms[i]->value += syms[i]->section->vma;
- }
+ print_files = NULL;
+ prev_functionname = NULL;
+ prev_line = -1;
- symcount = remove_useless_symbols (syms, symcount);
+ /* We make a copy of syms to sort. We don't want to sort syms
+ because that will screw up the relocs. */
+ sorted_syms = (asymbol **) xmalloc (symcount * sizeof (asymbol *));
+ memcpy (sorted_syms, syms, symcount * sizeof (asymbol *));
+
+ sorted_symcount = remove_useless_symbols (sorted_syms, symcount);
/* Sort the symbols into section and symbol order */
- qsort (syms, symcount, sizeof (asymbol *), compare_symbols);
+ qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
INIT_DISASSEMBLE_INFO(disasm_info, stdout);
disasm_info.application_data = (PTR) &aux;
}
else
{
- enum bfd_architecture a = bfd_get_arch (abfd);
- switch (a)
+ disassemble_fn = disassembler (abfd);
+ if (!disassemble_fn)
{
- /* If you add a case to this table, also add it to the
- ARCH_all definition right above this function. */
-#ifdef ARCH_a29k
- case bfd_arch_a29k:
- /* As far as I know we only handle big-endian 29k objects. */
- disassemble = print_insn_big_a29k;
- break;
-#endif
-#ifdef ARCH_alpha
- case bfd_arch_alpha:
- disassemble = print_insn_alpha;
- break;
-#endif
-#ifdef ARCH_h8300
- case bfd_arch_h8300:
- if (bfd_get_mach(abfd) == bfd_mach_h8300h)
- disassemble = print_insn_h8300h;
- else
- disassemble = print_insn_h8300;
- break;
-#endif
-#ifdef ARCH_h8500
- case bfd_arch_h8500:
- disassemble = print_insn_h8500;
- break;
-#endif
-#ifdef ARCH_hppa
- case bfd_arch_hppa:
- disassemble = print_insn_hppa;
- break;
-#endif
-#ifdef ARCH_i386
- case bfd_arch_i386:
- disassemble = print_insn_i386;
- break;
-#endif
-#ifdef ARCH_i960
- case bfd_arch_i960:
- disassemble = print_insn_i960;
- break;
-#endif
-#ifdef ARCH_m68k
- case bfd_arch_m68k:
- disassemble = print_insn_m68k;
- break;
-#endif
-#ifdef ARCH_m88k
- case bfd_arch_m88k:
- disassemble = print_insn_m88k;
- break;
-#endif
-#ifdef ARCH_mips
- case bfd_arch_mips:
- if (abfd->xvec->byteorder_big_p)
- disassemble = print_insn_big_mips;
- else
- disassemble = print_insn_little_mips;
- break;
-#endif
-#ifdef ARCH_powerpc
- case bfd_arch_powerpc:
- if (abfd->xvec->byteorder_big_p)
- disassemble = print_insn_big_powerpc;
- else
- disassemble = print_insn_little_powerpc;
- break;
-#endif
-#ifdef ARCH_rs6000
- case bfd_arch_rs6000:
- disassemble = print_insn_rs6000;
- break;
-#endif
-#ifdef ARCH_sh
- case bfd_arch_sh:
- disassemble = print_insn_sh;
- break;
-#endif
-#ifdef ARCH_sparc
- case bfd_arch_sparc:
- disassemble = print_insn_sparc;
- break;
-#endif
-#ifdef ARCH_z8k
- case bfd_arch_z8k:
- if (bfd_get_mach(abfd) == bfd_mach_z8001)
- disassemble = print_insn_z8001;
- else
- disassemble = print_insn_z8002;
- break;
-#endif
- default:
fprintf (stderr, "%s: Can't disassemble for architecture %s\n",
program_name,
- bfd_printable_arch_mach (a, 0));
+ bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
exit (1);
}
-
}
for (section = abfd->sections;
{
bfd_byte *data = NULL;
bfd_size_type datasize = 0;
-
- if (!(section->flags & SEC_LOAD))
+ arelent **relbuf = NULL;
+ arelent **relpp = NULL;
+ arelent **relppend = NULL;
+
+ if ((section->flags & SEC_LOAD) == 0
+ || (! disassemble_all
+ && only == NULL
+ && (section->flags & SEC_CODE) == 0))
continue;
if (only != (char *) NULL && strcmp (only, section->name) != 0)
continue;
+ if (dump_reloc_info
+ && (section->flags & SEC_RELOC) != 0)
+ {
+ long relsize;
+
+ relsize = bfd_get_reloc_upper_bound (abfd, section);
+ if (relsize < 0)
+ bfd_fatal (bfd_get_filename (abfd));
+
+ if (relsize > 0)
+ {
+ long relcount;
+
+ relbuf = (arelent **) xmalloc (relsize);
+ relcount = bfd_canonicalize_reloc (abfd, section, relbuf, syms);
+ if (relcount < 0)
+ bfd_fatal (bfd_get_filename (abfd));
+
+ /* Sort the relocs by address. */
+ qsort (relbuf, relcount, sizeof (arelent *), compare_relocs);
+
+ relpp = relbuf;
+ relppend = relpp + relcount;
+ }
+ }
+
printf ("Disassembly of section %s:\n", section->name);
datasize = bfd_get_section_size_before_reloc (section);
i = 0;
while (i < disasm_info.buffer_length)
{
+ int bytes;
+
if (data[i] == 0 && data[i + 1] == 0 && data[i + 2] == 0 &&
data[i + 3] == 0)
{
printf ("...\n");
done_dot = true;
}
- i += 4;
+ bytes = 4;
}
else
{
done_dot = false;
- if (with_line_numbers)
- {
- CONST char *filename;
- CONST char *functionname;
- unsigned int line;
-
- if (bfd_find_nearest_line (abfd,
- section,
- syms,
- section->vma + i,
- &filename,
- &functionname,
- &line))
- {
- if (functionname && *functionname
- && strcmp(functionname, prev_function))
- {
- printf ("%s():\n", functionname);
- prev_function = functionname;
- }
- if (!filename)
- filename = "???";
- if (line && line != prevline)
- {
- printf ("%s:%u\n", filename, line);
- prevline = line;
- }
- }
- }
+ if (with_line_numbers || with_source_code)
+ show_line (abfd, section, i);
+ aux.require_sec = true;
objdump_print_address (section->vma + i, &disasm_info);
+ aux.require_sec = false;
putchar (' ');
- if (disassemble) /* New style */
+ if (disassemble_fn)
{
- int bytes = (*disassemble)(section->vma + i,
- &disasm_info);
+ /* New style */
+ bytes = (*disassemble_fn) (section->vma + i, &disasm_info);
if (bytes < 0)
break;
- i += bytes;
}
- else /* Old style */
- i += print (section->vma + i,
- data + i,
- stdout);
+ else
+ {
+ /* Old style */
+ bytes = print (section->vma + i, data + i, stdout);
+ }
putchar ('\n');
}
+
+ if (dump_reloc_info
+ && (section->flags & SEC_RELOC) != 0)
+ {
+ while (relpp < relppend
+ && ((*relpp)->address >= i
+ && (*relpp)->address < i + bytes))
+ {
+ arelent *q;
+ const char *sym_name;
+
+ q = *relpp;
+
+ printf ("\t\tRELOC: ");
+
+ printf_vma (section->vma + q->address);
+
+ printf (" %s ", q->howto->name);
+
+ if (q->sym_ptr_ptr != NULL
+ && *q->sym_ptr_ptr != NULL)
+ {
+ sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
+ if (sym_name == NULL || *sym_name == '\0')
+ {
+ asection *sym_sec;
+
+ sym_sec = bfd_get_section (*q->sym_ptr_ptr);
+ sym_name = bfd_get_section_name (abfd, sym_sec);
+ if (sym_name == NULL || *sym_name == '\0')
+ sym_name = "*unknown*";
+ }
+ }
+
+ printf ("%s", sym_name);
+
+ if (q->addend)
+ {
+ printf ("+0x");
+ printf_vma (q->addend);
+ }
+
+ printf ("\n");
+
+ ++relpp;
+ }
+ }
+
+ i += bytes;
}
+
free (data);
+ if (relbuf != NULL)
+ free (relbuf);
}
}
\f
char *stabsect_name;
char *strsect_name;
{
- Elf_Internal_Shdr *stab_hdr, *stabstr_hdr;
asection *stabsect, *stabstrsect;
- int is_elf = (0 == strncmp ("elf", abfd->xvec->name, 3));
-
- if (is_elf)
- stab_hdr = bfd_elf_find_section (abfd, stabsect_name);
- else
- stabsect = bfd_get_section_by_name (abfd, stabsect_name);
- if (is_elf ? (0 == stab_hdr) : (0 == stabsect))
+ stabsect = bfd_get_section_by_name (abfd, stabsect_name);
+ if (0 == stabsect)
{
printf ("No %s section present\n\n", stabsect_name);
return false;
}
- if (is_elf)
- stabstr_hdr = bfd_elf_find_section (abfd, strsect_name);
- else
- stabstrsect = bfd_get_section_by_name (abfd, strsect_name);
-
- if (is_elf ? (0 == stabstr_hdr) : (0 == stabstrsect))
+ 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);
return false;
}
- stab_size = (is_elf ? stab_hdr ->sh_size : bfd_section_size (abfd, stabsect));
- stabstr_size = (is_elf ? stabstr_hdr->sh_size : bfd_section_size (abfd, stabstrsect));
+ stab_size = bfd_section_size (abfd, stabsect);
+ stabstr_size = bfd_section_size (abfd, stabstrsect);
stabs = (struct internal_nlist *) xmalloc (stab_size);
strtab = (char *) xmalloc (stabstr_size);
- if (is_elf)
- {
- if (bfd_seek (abfd, stab_hdr->sh_offset, SEEK_SET) < 0 ||
- stab_size != bfd_read ((PTR) stabs, stab_size, 1, abfd))
- {
- fprintf (stderr, "%s: Reading %s section of %s failed\n",
- program_name, stabsect_name,
- bfd_get_filename (abfd));
- free (stabs);
- free (strtab);
- return false;
- }
- }
- else
+ if (! bfd_get_section_contents (abfd, stabsect, (PTR) stabs, 0, stab_size))
{
- 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 ()));
+ free (stabs);
+ free (strtab);
+ return false;
}
- if (is_elf)
- {
- if (bfd_seek (abfd, stabstr_hdr->sh_offset, SEEK_SET) < 0 ||
- stabstr_size != bfd_read ((PTR) strtab, stabstr_size, 1, abfd))
- {
- fprintf (stderr, "%s: Reading %s section of %s failed\n",
- program_name, strsect_name,
- bfd_get_filename (abfd));
- free (stabs);
- free (strtab);
- return false;
- }
- }
- else
+ if (! bfd_get_section_contents (abfd, stabstrsect, (PTR) strtab, 0,
+ stabstr_size))
{
- 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 ()));
+ free (stabs);
+ free (strtab);
+ return false;
}
+
return true;
}
again (makes consistent formatting for tools like awk). */
if (stab_name[stabp->n_type])
printf ("%-6s", stab_name[stabp->n_type]);
+ else if (stabp->n_type == N_UNDF)
+ printf ("HdrSym");
else
- printf ("%-6d", i);
+ printf ("%-6d", stabp->n_type);
printf (" %-6d %-6d ", stabp->n_other, stabp->n_desc);
printf_vma (stabp->n_value);
printf (" %-6lu", stabp->n_strx);
dump_symbols (abfd, true);
if (dump_stab_section_info)
dump_stabs (abfd);
- if (dump_reloc_info)
+ if (dump_reloc_info && ! disassemble)
dump_relocs (abfd);
if (dump_dynamic_reloc_info)
dump_dynamic_relocs (abfd);
if (dump_section_contents)
dump_data (abfd);
- /* Note that disassemble_data re-orders the syms table, but that is
- safe - as long as it is done last! */
if (disassemble)
disassemble_data (abfd);
}
{
long relsize;
- if (a == &bfd_abs_section)
+ if (bfd_is_abs_section (a))
continue;
- if (a == &bfd_und_section)
+ if (bfd_is_und_section (a))
continue;
if (bfd_is_com_section (a))
continue;
else
{
relpp = (arelent **) xmalloc (relsize);
- /* Note that this must be done *before* we sort the syms table. */
relcount = bfd_canonicalize_reloc (abfd, a, relpp, syms);
if (relcount < 0)
bfd_fatal (bfd_get_filename (abfd));
}
}
\f
-/* A file to open each BFD on. It will never actually be written to. */
-#ifdef unix
-#define _DUMMY_NAME_ "/dev/null"
-#else
-#define _DUMMY_NAME_ "##dummy"
-#endif
-
/* The length of the longest architecture name + 1. */
#define LONGEST_ARCH sizeof("rs6000:6000")
+#ifndef L_tmpnam
+#define L_tmpnam 25
+#endif
+
/* List the targets that BFD is configured to support, each followed
by its endianness and the architectures it supports. */
static void
display_target_list ()
{
+ extern char *tmpnam ();
extern bfd_target *bfd_target_vector[];
+ char tmparg[L_tmpnam];
+ char *dummy_name;
int t;
+ dummy_name = tmpnam (tmparg);
for (t = 0; bfd_target_vector[t]; t++)
{
- int a;
bfd_target *p = bfd_target_vector[t];
- bfd *abfd = bfd_openw (_DUMMY_NAME_, p->name);
+ bfd *abfd = bfd_openw (dummy_name, p->name);
+ int a;
- /* It *is* possible that bfd_openw might fail; avoid the
- tragic consequences that would otherwise ensue. */
- if (abfd == NULL)
- {
- bfd_nonfatal (_DUMMY_NAME_);
- return;
- }
- bfd_set_format (abfd, bfd_object);
printf ("%s\n (header %s, data %s)\n", p->name,
p->header_byteorder_big_p ? "big endian" : "little endian",
p->byteorder_big_p ? "big endian" : "little endian");
+
+ if (abfd == NULL)
+ {
+ bfd_nonfatal (dummy_name);
+ continue;
+ }
+
+ if (! bfd_set_format (abfd, bfd_object))
+ {
+ if (bfd_get_error () != bfd_error_invalid_operation)
+ bfd_nonfatal (p->name);
+ continue;
+ }
+
for (a = (int) bfd_arch_obscure + 1; a < (int) bfd_arch_last; a++)
if (bfd_set_arch_mach (abfd, (enum bfd_architecture) a, 0))
printf (" %s\n",
bfd_printable_arch_mach ((enum bfd_architecture) a, 0));
}
+ unlink (dummy_name);
}
/* Print a table showing which architectures are supported for entries
int first;
int last;
{
- int t, a;
extern bfd_target *bfd_target_vector[];
+ extern char *tmpnam ();
+ char tmparg[L_tmpnam];
+ int t, a;
+ char *dummy_name;
/* Print heading of target names. */
printf ("\n%*s", (int) LONGEST_ARCH, " ");
- for (t = first; t++ < last && bfd_target_vector[t];)
+ for (t = first; t < last && bfd_target_vector[t]; t++)
printf ("%s ", bfd_target_vector[t]->name);
putchar ('\n');
+ dummy_name = tmpnam (tmparg);
for (a = (int) bfd_arch_obscure + 1; a < (int) bfd_arch_last; a++)
if (strcmp (bfd_printable_arch_mach (a, 0), "UNKNOWN!") != 0)
{
printf ("%*s ", (int) LONGEST_ARCH - 1,
bfd_printable_arch_mach (a, 0));
- for (t = first; t++ < last && bfd_target_vector[t];)
+ for (t = first; t < last && bfd_target_vector[t]; t++)
{
bfd_target *p = bfd_target_vector[t];
- bfd *abfd = bfd_openw (_DUMMY_NAME_, p->name);
+ boolean ok = true;
+ bfd *abfd = bfd_openw (dummy_name, p->name);
- /* Just in case the open failed somehow. */
if (abfd == NULL)
{
- bfd_nonfatal (_DUMMY_NAME_);
- return;
+ bfd_nonfatal (p->name);
+ ok = false;
}
- bfd_set_format (abfd, bfd_object);
- if (bfd_set_arch_mach (abfd, a, 0))
+
+ if (ok)
+ {
+ if (! bfd_set_format (abfd, bfd_object))
+ {
+ if (bfd_get_error () != bfd_error_invalid_operation)
+ bfd_nonfatal (p->name);
+ ok = false;
+ }
+ }
+
+ if (ok)
+ {
+ if (! bfd_set_arch_mach (abfd, a, 0))
+ ok = false;
+ }
+
+ if (ok)
printf ("%s ", p->name);
else
{
}
putchar ('\n');
}
+ unlink (dummy_name);
}
/* Print tables of all the target-architecture combinations that
if (columns == 0)
columns = 80;
- for (t = 0; bfd_target_vector[t];)
+ t = 0;
+ while (bfd_target_vector[t] != NULL)
{
int oldt = t, wid;
- for (wid = LONGEST_ARCH; bfd_target_vector[t] && wid < columns; t++)
- wid += strlen (bfd_target_vector[t]->name) + 1;
- t--;
- if (oldt == t)
- break;
+ wid = LONGEST_ARCH + strlen (bfd_target_vector[t]->name) + 1;
+ ++t;
+ while (wid < columns && bfd_target_vector[t] != NULL)
+ {
+ int newwid;
+
+ newwid = wid + strlen (bfd_target_vector[t]->name) + 1;
+ if (newwid >= columns)
+ break;
+ wid = newwid;
+ ++t;
+ }
display_info_table (oldt, t);
}
}
program_name = *argv;
xmalloc_set_program_name (program_name);
+ START_PROGRESS (program_name, 0);
+
bfd_init ();
- while ((c = getopt_long (argc, argv, "ib:m:VdlfahrRtTxsj:", long_options,
+ while ((c = getopt_long (argc, argv, "ib:m:VdDlfahrRtTxsSj:", long_options,
(int *) 0))
!= EOF)
{
case 'd':
disassemble = true;
break;
+ case 'D':
+ disassemble = disassemble_all = true;
+ break;
+ case 'S':
+ disassemble = true;
+ with_source_code = true;
+ break;
case 's':
dump_section_contents = 1;
break;
for (; optind < argc;)
display_file (argv[optind++], target);
}
+
+ END_PROGRESS (program_name);
+
return 0;
}
projects / deliverable / binutils-gdb.git / blobdiff