#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_section_headers; /* -h */
boolean dump_file_header; /* -f */
int dump_symtab; /* -t */
+int dump_dynamic_symtab; /* -T */
int dump_reloc_info; /* -r */
+int dump_dynamic_reloc_info; /* -R */
int dump_ar_hdrs; /* -a */
int with_line_numbers; /* -l */
int dump_stab_section_info; /* --stabs */
/* The symbol table. */
asymbol **syms;
-/* Number of bytes allocated for `syms'. */
-unsigned int storage;
-
/* Number of symbols in `syms'. */
-unsigned int symcount = 0;
+long symcount = 0;
+
+/* The dynamic symbol table. */
+asymbol **dynsyms;
+
+/* Number of symbols in `dynsyms'. */
+long dynsymcount = 0;
/* Forward declarations. */
dump_relocs PARAMS ((bfd *abfd));
static void
-dump_symbols PARAMS ((bfd *abfd));
+dump_dynamic_relocs PARAMS ((bfd * abfd));
+
+static void
+dump_reloc_set PARAMS ((bfd *, arelent **, long));
+
+static void
+dump_symbols PARAMS ((bfd *abfd, boolean dynamic));
static void
display_bfd PARAMS ((bfd *abfd));
+
+static void
+objdump_print_address PARAMS ((bfd_vma, struct disassemble_info *));
\f
void
usage (stream, status)
int status;
{
fprintf (stream, "\
-Usage: %s [-ahifdrtxsl] [-b bfdname] [-m machine] [-j section-name]\n\
+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] [--version] [--help] objfile...\n\
+ [--stabs] [--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);
exit (status);
{"architecture", required_argument, NULL, 'm'},
{"archive-headers", no_argument, NULL, 'a'},
{"disassemble", no_argument, NULL, 'd'},
+ {"dynamic-reloc", no_argument, NULL, 'R'},
+ {"dynamic-syms", no_argument, NULL, 'T'},
{"file-headers", no_argument, NULL, 'f'},
{"full-contents", no_argument, NULL, 's'},
{"headers", no_argument, NULL, 'h'},
bfd *abfd;
{
asymbol **sy = (asymbol **) NULL;
+ long storage;
if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
{
return NULL;
}
- storage = get_symtab_upper_bound (abfd);
+ storage = bfd_get_symtab_upper_bound (abfd);
+ if (storage < 0)
+ bfd_fatal (bfd_get_filename (abfd));
+
if (storage)
{
sy = (asymbol **) xmalloc (storage);
}
symcount = bfd_canonicalize_symtab (abfd, sy);
- if (symcount <= 0)
+ 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));
+ return sy;
+}
+
+/* Read in the dynamic symbols. */
+
+static asymbol **
+slurp_dynamic_symtab (abfd)
+ bfd *abfd;
+{
+ asymbol **sy = (asymbol **) NULL;
+ long storage;
+
+ if (!(bfd_get_file_flags (abfd) & DYNAMIC))
{
- fprintf (stderr, "%s: %s: Invalid symbol table\n",
+ fprintf (stderr, "%s: %s: not a dynamic object\n",
program_name, bfd_get_filename (abfd));
- exit (1);
+ return NULL;
+ }
+
+ storage = bfd_get_dynamic_symtab_upper_bound (abfd);
+ if (storage < 0)
+ bfd_fatal (bfd_get_filename (abfd));
+
+ if (storage)
+ {
+ sy = (asymbol **) xmalloc (storage);
}
+ dynsymcount = bfd_canonicalize_dynamic_symtab (abfd, sy);
+ 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));
return sy;
}
COUNT is the number of elements in SYMBOLS.
Return the number of useful symbols. */
-int
+long
remove_useless_symbols (symbols, count)
asymbol **symbols;
- int count;
+ long count;
{
register asymbol **in_ptr = symbols, **out_ptr = symbols;
/* Print VMA symbolically to INFO if possible. */
-void
+static void
objdump_print_address (vma, info)
bfd_vma vma;
struct disassemble_info *info;
constantly churned by code doing heavy memory accesses. */
/* Indices in `syms'. */
- unsigned int min = 0;
- unsigned int max = symcount;
- unsigned int thisplace = 1;
- unsigned int oldthisplace;
+ long min = 0;
+ long max = symcount;
+ long thisplace;
- int vardiff;
+ bfd_signed_vma vardiff;
fprintf_vma (info->stream, vma);
if (symcount < 1)
return;
- /* Perform a binary search looking for the closest symbol to
- the required value. */
- while (true)
+ /* Perform a binary search looking for the closest symbol to the
+ required value. We are searching the range (min, max]. */
+ while (min + 1 < max)
{
asymbol *sym;
-#if 0
- asection *sym_sec;
-#endif
- oldthisplace = thisplace;
+
thisplace = (max + min) / 2;
- if (thisplace == oldthisplace)
- break;
sym = syms[thisplace];
+
vardiff = sym->value - vma;
-#if 0
- sym_sec = sym->section;
-#endif
if (vardiff > 0)
max = thisplace;
else if (vardiff < 0)
min = thisplace;
else
- goto found;
- }
- /* We've run out of places to look; see whether this or the
- symbol before this describes this location the best. */
-
- if (thisplace != 0)
- {
- if (syms[thisplace - 1]->value - vma < syms[thisplace]->value - vma)
{
- /* Previous symbol is in correct section and is closer. */
- thisplace--;
+ min = thisplace;
+ break;
}
}
- found:
+ /* The symbol we want is now in min, the low end of the range we
+ were searching. */
+ thisplace = min;
+
{
/* If this symbol isn't global, search for one with the same value
that is. */
bfd_vma val = syms[thisplace]->value;
- int i;
+ long i;
if (syms[thisplace]->flags & (BSF_LOCAL|BSF_DEBUGGING))
for (i = thisplace - 1; i >= 0; i--)
{
no way to tell what's desired without looking at the relocation
table. */
struct objdump_disasm_info *aux;
- int i;
+ long i;
aux = (struct objdump_disasm_info *) info->application_data;
if ((aux->abfd->flags & HAS_RELOC)
&& syms[thisplace]->section != aux->sec)
{
for (i = thisplace + 1; i < symcount; i++)
- if (syms[i]->value != syms[thisplace]->value)
- break;
- while (--i >= 0)
- if (syms[i]->section == aux->sec)
- {
- thisplace = i;
- break;
- }
+ {
+ if (syms[i]->value != syms[thisplace]->value)
+ {
+ i--;
+ break;
+ }
+ }
+ for (; i >= 0; i--)
+ {
+ if (syms[i]->section == aux->sec)
+ {
+ thisplace = i;
+ break;
+ }
+ }
}
}
fprintf (info->stream, " <%s", syms[thisplace]->name);
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_rs6000
-#define ARCH_sh
-#define ARCH_sparc
-#define ARCH_z8k
-#endif
-
void
disassemble_data (abfd)
bfd *abfd;
{
- bfd_size_type i;
+ long i;
unsigned int (*print) () = 0; /* Old style */
disassembler_ftype disassemble = 0; /* New style */
struct disassemble_info disasm_info;
}
else
{
- enum bfd_architecture a = bfd_get_arch (abfd);
- switch (a)
+ disassemble = disassembler (abfd);
+ if (!disassemble)
{
- /* 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_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;
{0, ""}
};
-void dump_stabs_1 ();
+void dump_section_stabs PARAMS ((bfd *abfd, char *stabsect_name,
+ char *strsect_name));
-/* This dumps the stabs section from object files that have a section that
+/* Dump the stabs sections from an object file that has a section that
uses Sun stabs encoding. It has to use some hooks into BFD because
string table sections are not normally visible to BFD callers. */
dump_stabs (abfd)
bfd *abfd;
{
- int i;
-
/* Allocate and initialize stab name array if first time. */
if (stab_name == NULL)
{
+ int i;
+
stab_name = (char **) xmalloc (256 * sizeof(char *));
/* Clear the array. */
for (i = 0; i < 256; i++)
stab_name[stab_print[i].value] = stab_print[i].string;
}
- dump_stabs_1 (abfd, ".stab", ".stabstr");
- dump_stabs_1 (abfd, ".stab.excl", ".stab.exclstr");
- dump_stabs_1 (abfd, ".stab.index", ".stab.indexstr");
- dump_stabs_1 (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
+ dump_section_stabs (abfd, ".stab", ".stabstr");
+ dump_section_stabs (abfd, ".stab.excl", ".stab.exclstr");
+ dump_section_stabs (abfd, ".stab.index", ".stab.indexstr");
+ dump_section_stabs (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
}
-void
-dump_stabs_1 (abfd, name1, name2)
+static struct internal_nlist *stabs;
+static bfd_size_type stab_size;
+
+static char *strtab;
+static bfd_size_type stabstr_size;
+
+/* Read ABFD's stabs section STABSECT_NAME into `stabs'
+ and string table section STRSECT_NAME into `strtab'.
+ If the section exists and was read, allocate the space and return true.
+ Otherwise return false. */
+
+boolean
+read_section_stabs (abfd, stabsect_name, strsect_name)
bfd *abfd;
- char *name1; /* Section name of .stab */
- char *name2; /* Section name of its string section */
+ char *stabsect_name;
+ char *strsect_name;
{
- Elf_Internal_Shdr *stab_hdr, *stabstr_hdr;
asection *stabsect, *stabstrsect;
- char *strtab;
- struct internal_nlist *stabs, *stabs_end;
- int i;
- int stab_size, stabstr_size;
- unsigned file_string_table_offset, next_file_string_table_offset;
- int is_elf = (0 == strncmp ("elf", abfd->xvec->name, 3));
-
- if (is_elf)
- {
- stab_hdr = bfd_elf_find_section (abfd, name1);
- }
- else
- {
- stabsect = bfd_get_section_by_name (abfd, name1);
- }
-
- if (is_elf ? (0 == stab_hdr) : (0 == stabsect))
- {
- printf ("No %s section present.\n\n", name1);
- return;
- }
- if (is_elf)
- {
- stabstr_hdr = bfd_elf_find_section (abfd, name2);
- }
- else
+ stabsect = bfd_get_section_by_name (abfd, stabsect_name);
+ if (0 == stabsect)
{
- stabstrsect = bfd_get_section_by_name (abfd, name2);
+ printf ("No %s section present\n\n", stabsect_name);
+ return false;
}
- 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), name2);
- return;
+ 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);
- stabs_end = (struct internal_nlist *) (stab_size + (char *) stabs);
- if (is_elf)
+ if (! bfd_get_section_contents (abfd, stabsect, (PTR) stabs, 0, stab_size))
{
- 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, name1,
- bfd_get_filename (abfd));
- return;
- }
- }
- else
- {
- 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, name2,
- bfd_get_filename (abfd));
- return;
- }
- }
- 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;
+}
+
#define SWAP_SYMBOL(symp, abfd) \
- { \
+{ \
(symp)->n_strx = bfd_h_get_32(abfd, \
- (unsigned char *)&(symp)->n_strx); \
+ (unsigned char *)&(symp)->n_strx); \
(symp)->n_desc = bfd_h_get_16 (abfd, \
- (unsigned char *)&(symp)->n_desc); \
+ (unsigned char *)&(symp)->n_desc); \
(symp)->n_value = bfd_h_get_32 (abfd, \
- (unsigned char *)&(symp)->n_value); \
- }
+ (unsigned char *)&(symp)->n_value); \
+}
- printf ("Contents of %s section:\n\n", name1);
- printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
+/* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
+ using string table section STRSECT_NAME (in `strtab'). */
+
+void
+print_section_stabs (abfd, stabsect_name, strsect_name)
+ bfd *abfd;
+ char *stabsect_name;
+ char *strsect_name;
+{
+ int i;
+ unsigned file_string_table_offset = 0, next_file_string_table_offset = 0;
+ struct internal_nlist *stabp = stabs,
+ *stabs_end = (struct internal_nlist *) (stab_size + (char *) stabs);
- file_string_table_offset = 0;
- next_file_string_table_offset = 0;
+ 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.
We start the index at -1 because there is a dummy symbol on
- the front of stabs-in-{coff,elf} sections that supplies sizes. */
+ the front of stabs-in-{coff,elf} sections that supplies sizes. */
- for (i = -1; stabs < stabs_end; stabs++, i++)
+ for (i = -1; stabp < stabs_end; stabp++, i++)
{
- SWAP_SYMBOL (stabs, abfd);
+ SWAP_SYMBOL (stabp, abfd);
printf ("\n%-6d ", i);
- /* Print either the stab name, or, if unnamed, print its number
+ /* Either print the stab name, or, if unnamed, print its number
again (makes consistent formatting for tools like awk). */
- if (stab_name[stabs->n_type])
- printf ("%-6s", stab_name[stabs->n_type]);
+ 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 %-6d ", stabs->n_other, stabs->n_desc);
- printf_vma (stabs->n_value);
- printf (" %-6lu", stabs->n_strx);
+ printf ("%-6d", stabp->n_type);
+ printf (" %-6d %-6d ", stabp->n_other, stabp->n_desc);
+ printf_vma (stabp->n_value);
+ printf (" %-6lu", stabp->n_strx);
/* Symbols with type == 0 (N_UNDF) specify the length of the
string table associated with this file. We use that info
to know how to relocate the *next* file's string table indices. */
- if (stabs->n_type == N_UNDF)
+ if (stabp->n_type == N_UNDF)
{
file_string_table_offset = next_file_string_table_offset;
- next_file_string_table_offset += stabs->n_value;
+ next_file_string_table_offset += stabp->n_value;
}
else
{
- /* Now, using the possibly updated string table offset, print the
+ /* Using the (possibly updated) string table offset, print the
string (if any) associated with this symbol. */
- if ((stabs->n_strx + file_string_table_offset) < stabstr_size)
- printf (" %s", &strtab[stabs->n_strx + file_string_table_offset]);
+ if ((stabp->n_strx + file_string_table_offset) < stabstr_size)
+ printf (" %s", &strtab[stabp->n_strx + file_string_table_offset]);
else
printf (" *");
}
printf ("\n\n");
}
+void
+dump_section_stabs (abfd, stabsect_name, strsect_name)
+ bfd *abfd;
+ char *stabsect_name;
+ char *strsect_name;
+{
+ if (read_section_stabs (abfd, stabsect_name, strsect_name))
+ {
+ print_section_stabs (abfd, stabsect_name, strsect_name);
+ free (stabs);
+ free (strtab);
+ }
+}
+\f
static void
dump_bfd_header (abfd)
bfd *abfd;
if (!bfd_check_format_matches (abfd, bfd_object, &matching))
{
bfd_nonfatal (bfd_get_filename (abfd));
- if (bfd_error == file_ambiguously_recognized)
+ if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
{
list_matching_formats (matching);
free (matching);
{
syms = slurp_symtab (abfd);
}
+ if (dump_dynamic_symtab || dump_dynamic_reloc_info)
+ {
+ dynsyms = slurp_dynamic_symtab (abfd);
+ }
if (dump_symtab)
- dump_symbols (abfd);
+ dump_symbols (abfd, false);
+ if (dump_dynamic_symtab)
+ dump_symbols (abfd, true);
if (dump_stab_section_info)
dump_stabs (abfd);
if (dump_reloc_info)
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
if (bfd_check_format (file, bfd_archive) == true)
{
+ bfd *last_arfile = NULL;
+
printf ("In archive %s:\n", bfd_get_filename (file));
for (;;)
{
- bfd_error = no_error;
+ bfd_set_error (bfd_error_no_error);
arfile = bfd_openr_next_archived_file (file, arfile);
if (arfile == NULL)
{
- if (bfd_error != no_more_archived_files)
+ if (bfd_get_error () != bfd_error_no_more_archived_files)
{
bfd_nonfatal (bfd_get_filename (file));
}
- return;
+ break;
}
display_bfd (arfile);
- /* Don't close the archive elements; we need them for next_archive */
+
+ if (last_arfile != NULL)
+ bfd_close (last_arfile);
+ last_arfile = arfile;
}
+
+ if (last_arfile != NULL)
+ bfd_close (last_arfile);
}
else
display_bfd (file);
/* Should perhaps share code and display with nm? */
static void
-dump_symbols (abfd)
+dump_symbols (abfd, dynamic)
bfd *abfd;
+ boolean dynamic;
{
+ asymbol **current;
+ long max;
+ long count;
- unsigned int count;
- asymbol **current = syms;
-
- printf ("SYMBOL TABLE:\n");
-
- for (count = 0; count < symcount; count++)
+ if (dynamic)
+ {
+ current = dynsyms;
+ max = dynsymcount;
+ if (max == 0)
+ return;
+ printf ("DYNAMIC SYMBOL TABLE:\n");
+ }
+ else
{
+ current = syms;
+ max = symcount;
+ if (max == 0)
+ return;
+ printf ("SYMBOL TABLE:\n");
+ }
+ for (count = 0; count < max; count++)
+ {
if (*current)
{
bfd *cur_bfd = bfd_asymbol_bfd(*current);
*current, bfd_print_symbol_all);
printf ("\n");
}
-
}
current++;
}
bfd *abfd;
{
arelent **relpp;
- unsigned int relcount;
+ long relcount;
asection *a;
for (a = abfd->sections; a != (asection *) NULL; a = a->next)
{
+ long relsize;
+
if (a == &bfd_abs_section)
continue;
if (a == &bfd_und_section)
printf ("RELOCATION RECORDS FOR [%s]:", a->name);
- if (bfd_get_reloc_upper_bound (abfd, a) == 0)
+ relsize = bfd_get_reloc_upper_bound (abfd, a);
+ if (relsize < 0)
+ bfd_fatal (bfd_get_filename (abfd));
+
+ if (relsize == 0)
{
printf (" (none)\n\n");
}
else
{
- arelent **p;
-
- relpp = (arelent **) xmalloc (bfd_get_reloc_upper_bound (abfd, a));
+ 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)
+ if (relcount < 0)
+ bfd_fatal (bfd_get_filename (abfd));
+ else if (relcount == 0)
{
printf (" (none)\n\n");
}
else
{
printf ("\n");
- /* Get column headers lined up reasonably. */
- {
- static int width;
- if (width == 0)
- {
- char buf[30];
- sprintf_vma (buf, (bfd_vma) -1);
- width = strlen (buf) - 7;
- }
- printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
- }
-
- for (p = relpp; relcount && *p != (arelent *) NULL; p++,
- relcount--)
- {
- arelent *q = *p;
- CONST char *sym_name;
- CONST char *section_name;
-
- if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
- {
- sym_name = (*(q->sym_ptr_ptr))->name;
- section_name = (*(q->sym_ptr_ptr))->section->name;
- }
- else
- {
- sym_name = NULL;
- section_name = NULL;
- }
- if (sym_name)
- {
- printf_vma (q->address);
- printf (" %-16s %s",
- q->howto->name,
- sym_name);
- }
- else
- {
- if (section_name == (CONST char *) NULL)
- section_name = "*unknown*";
- printf_vma (q->address);
- printf (" %-16s [%s]",
- q->howto->name,
- section_name);
- }
- if (q->addend)
- {
- printf ("+0x");
- printf_vma (q->addend);
- }
- printf ("\n");
- }
+ dump_reloc_set (abfd, relpp, relcount);
printf ("\n\n");
- free (relpp);
}
+ free (relpp);
}
+ }
+}
+static void
+dump_dynamic_relocs (abfd)
+ bfd *abfd;
+{
+ long relsize;
+ arelent **relpp;
+ long relcount;
+
+ printf ("DYNAMIC RELOCATION RECORDS");
+
+ relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
+ if (relsize < 0)
+ bfd_fatal (bfd_get_filename (abfd));
+
+ if (relsize == 0)
+ {
+ printf (" (none)\n\n");
+ }
+ else
+ {
+ relpp = (arelent **) xmalloc (relsize);
+ relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
+ if (relcount < 0)
+ bfd_fatal (bfd_get_filename (abfd));
+ else if (relcount == 0)
+ {
+ printf (" (none)\n\n");
+ }
+ else
+ {
+ printf ("\n");
+ dump_reloc_set (abfd, relpp, relcount);
+ printf ("\n\n");
+ }
+ free (relpp);
}
}
-\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
+static void
+dump_reloc_set (abfd, relpp, relcount)
+ bfd *abfd;
+ arelent **relpp;
+ long relcount;
+{
+ arelent **p;
+
+ /* Get column headers lined up reasonably. */
+ {
+ static int width;
+ if (width == 0)
+ {
+ char buf[30];
+ sprintf_vma (buf, (bfd_vma) -1);
+ width = strlen (buf) - 7;
+ }
+ printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
+ }
+
+ for (p = relpp; relcount && *p != (arelent *) NULL; p++, relcount--)
+ {
+ arelent *q = *p;
+ CONST char *sym_name;
+ CONST char *section_name;
+
+ if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
+ {
+ sym_name = (*(q->sym_ptr_ptr))->name;
+ section_name = (*(q->sym_ptr_ptr))->section->name;
+ }
+ else
+ {
+ sym_name = NULL;
+ section_name = NULL;
+ }
+ if (sym_name)
+ {
+ printf_vma (q->address);
+ printf (" %-16s %s",
+ q->howto->name,
+ sym_name);
+ }
+ else
+ {
+ if (section_name == (CONST char *) NULL)
+ section_name = "*unknown*";
+ printf_vma (q->address);
+ printf (" %-16s [%s]",
+ q->howto->name,
+ section_name);
+ }
+ if (q->addend)
+ {
+ printf ("+0x");
+ printf_vma (q->addend);
+ }
+ printf ("\n");
+ }
+}
+\f
/* The length of the longest architecture name + 1. */
#define LONGEST_ARCH sizeof("rs6000:6000")
static void
display_target_list ()
{
+ extern char *tmpnam ();
extern bfd_target *bfd_target_vector[];
+ char *dummy_name;
int t;
+ dummy_name = tmpnam ((char *) NULL);
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 ();
+ int t, a;
+ char *dummy_name;
/* Print heading of target names. */
- printf ("\n%*s", LONGEST_ARCH, " ");
- for (t = first; t++ < last && bfd_target_vector[t];)
+ printf ("\n%*s", (int) LONGEST_ARCH, " ");
+ for (t = first; t < last && bfd_target_vector[t]; t++)
printf ("%s ", bfd_target_vector[t]->name);
putchar ('\n');
+ dummy_name = tmpnam ((char *) NULL);
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 ", LONGEST_ARCH - 1, bfd_printable_arch_mach (a, 0));
- for (t = first; t++ < last && bfd_target_vector[t];)
+ printf ("%*s ", (int) LONGEST_ARCH - 1,
+ bfd_printable_arch_mach (a, 0));
+ 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);
}
}
char *target = default_target;
boolean seenflag = false;
- bfd_init ();
program_name = *argv;
+ xmalloc_set_program_name (program_name);
- while ((c = getopt_long (argc, argv, "ib:m:Vdlfahrtxsj:", long_options,
+ bfd_init ();
+
+ while ((c = getopt_long (argc, argv, "ib:m:VdlfahrRtTxsj:", long_options,
(int *) 0))
!= EOF)
{
case 't':
dump_symtab = 1;
break;
+ case 'T':
+ dump_dynamic_symtab = 1;
+ break;
case 'd':
disassemble = true;
break;
case 'r':
dump_reloc_info = 1;
break;
+ case 'R':
+ dump_dynamic_reloc_info = 1;
+ break;
case 'a':
dump_ar_hdrs = 1;
break;
projects / binutils.git / blobdiff