1992-01-25 06:49:24 +08:00
|
|
|
|
/* objdump.c -- dump information about an object file.
|
1994-01-23 08:31:14 +08:00
|
|
|
|
Copyright 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
|
1991-03-22 05:29:06 +08:00
|
|
|
|
|
1993-07-16 00:46:50 +08:00
|
|
|
|
This file is part of GNU Binutils.
|
1991-03-22 05:29:06 +08:00
|
|
|
|
|
1993-07-16 00:46:50 +08:00
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
1991-03-22 05:29:06 +08:00
|
|
|
|
it under the terms of the GNU General Public License as published by
|
1992-01-25 06:49:24 +08:00
|
|
|
|
the Free Software Foundation; either version 2, or (at your option)
|
1991-03-22 05:29:06 +08:00
|
|
|
|
any later version.
|
|
|
|
|
|
1993-07-16 00:46:50 +08:00
|
|
|
|
This program is distributed in the hope that it will be useful,
|
1991-03-22 05:29:06 +08:00
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
1993-07-16 00:46:50 +08:00
|
|
|
|
along with this program; if not, write to the Free Software
|
|
|
|
|
Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
|
1991-03-22 05:29:06 +08:00
|
|
|
|
|
|
|
|
|
#include "bfd.h"
|
1992-01-25 06:49:24 +08:00
|
|
|
|
#include "sysdep.h"
|
1991-03-22 05:29:06 +08:00
|
|
|
|
#include "getopt.h"
|
1993-10-30 02:15:01 +08:00
|
|
|
|
#include "bucomm.h"
|
1991-03-22 05:29:06 +08:00
|
|
|
|
#include <stdio.h>
|
|
|
|
|
#include <ctype.h>
|
1993-03-19 08:12:50 +08:00
|
|
|
|
#include "dis-asm.h"
|
1994-06-03 23:00:55 +08:00
|
|
|
|
#include "libiberty.h"
|
1991-03-22 05:29:06 +08:00
|
|
|
|
|
1992-06-11 16:23:11 +08:00
|
|
|
|
/* Internal headers for the ELF .stab-dump code - sorry. */
|
|
|
|
|
#define BYTES_IN_WORD 32
|
|
|
|
|
#include "aout/aout64.h"
|
1991-04-19 06:14:53 +09:00
|
|
|
|
|
1993-10-23 02:04:09 +08:00
|
|
|
|
#ifndef FPRINTF_ALREADY_DECLARED
|
1993-04-27 09:39:38 +08:00
|
|
|
|
extern int fprintf PARAMS ((FILE *, CONST char *, ...));
|
1993-10-23 02:04:09 +08:00
|
|
|
|
#endif
|
1991-03-22 05:29:06 +08:00
|
|
|
|
|
|
|
|
|
char *default_target = NULL; /* default at runtime */
|
|
|
|
|
|
1993-10-30 02:15:01 +08:00
|
|
|
|
extern char *program_version;
|
1991-03-22 05:29:06 +08:00
|
|
|
|
|
1992-08-19 11:25:51 +08:00
|
|
|
|
int show_version = 0; /* show the version number */
|
1991-03-22 05:29:06 +08:00
|
|
|
|
int dump_section_contents; /* -s */
|
|
|
|
|
int dump_section_headers; /* -h */
|
|
|
|
|
boolean dump_file_header; /* -f */
|
|
|
|
|
int dump_symtab; /* -t */
|
1994-04-07 10:04:34 +08:00
|
|
|
|
int dump_dynamic_symtab; /* -T */
|
1991-03-22 05:29:06 +08:00
|
|
|
|
int dump_reloc_info; /* -r */
|
1994-04-07 10:04:34 +08:00
|
|
|
|
int dump_dynamic_reloc_info; /* -R */
|
1991-03-22 05:29:06 +08:00
|
|
|
|
int dump_ar_hdrs; /* -a */
|
1992-06-10 22:57:25 +08:00
|
|
|
|
int with_line_numbers; /* -l */
|
1993-09-23 13:21:21 +08:00
|
|
|
|
int dump_stab_section_info; /* --stabs */
|
1992-06-10 22:57:25 +08:00
|
|
|
|
boolean disassemble; /* -d */
|
1994-09-16 09:59:30 +08:00
|
|
|
|
boolean disassemble_all; /* -D */
|
1993-10-30 02:15:01 +08:00
|
|
|
|
boolean formats_info; /* -i */
|
1993-09-01 02:15:50 +08:00
|
|
|
|
char *only; /* -j secname */
|
|
|
|
|
|
1994-02-03 08:25:30 +08:00
|
|
|
|
/* Extra info to pass to the disassembler address printing function. */
|
1993-09-01 02:15:50 +08:00
|
|
|
|
struct objdump_disasm_info {
|
|
|
|
|
bfd *abfd;
|
|
|
|
|
asection *sec;
|
1994-09-16 23:30:38 +08:00
|
|
|
|
boolean require_sec;
|
1993-09-01 02:15:50 +08:00
|
|
|
|
};
|
1991-03-22 05:29:06 +08:00
|
|
|
|
|
1994-02-03 08:25:30 +08:00
|
|
|
|
/* Architecture to disassemble for, or default if NULL. */
|
1992-06-10 22:57:25 +08:00
|
|
|
|
char *machine = (char *) NULL;
|
1994-01-27 06:11:18 +08:00
|
|
|
|
|
|
|
|
|
/* The symbol table. */
|
1992-06-10 22:57:25 +08:00
|
|
|
|
asymbol **syms;
|
1991-03-22 05:29:06 +08:00
|
|
|
|
|
1994-01-27 06:11:18 +08:00
|
|
|
|
/* Number of symbols in `syms'. */
|
1994-03-31 06:06:17 +08:00
|
|
|
|
long symcount = 0;
|
1991-03-22 05:29:06 +08:00
|
|
|
|
|
1994-04-07 10:04:34 +08:00
|
|
|
|
/* The dynamic symbol table. */
|
|
|
|
|
asymbol **dynsyms;
|
|
|
|
|
|
|
|
|
|
/* Number of symbols in `dynsyms'. */
|
|
|
|
|
long dynsymcount = 0;
|
|
|
|
|
|
1993-02-22 23:31:30 +08:00
|
|
|
|
/* Forward declarations. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
display_file PARAMS ((char *filename, char *target));
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
dump_data PARAMS ((bfd *abfd));
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
dump_relocs PARAMS ((bfd *abfd));
|
|
|
|
|
|
|
|
|
|
static void
|
1994-04-07 10:04:34 +08:00
|
|
|
|
dump_dynamic_relocs PARAMS ((bfd * abfd));
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
dump_reloc_set PARAMS ((bfd *, arelent **, long));
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
dump_symbols PARAMS ((bfd *abfd, boolean dynamic));
|
1994-01-14 06:34:51 +08:00
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
display_bfd PARAMS ((bfd *abfd));
|
1994-03-30 05:34:44 +08:00
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
objdump_print_address PARAMS ((bfd_vma, struct disassemble_info *));
|
1993-02-22 23:31:30 +08:00
|
|
|
|
|
1991-03-22 05:29:06 +08:00
|
|
|
|
void
|
1993-07-16 00:46:50 +08:00
|
|
|
|
usage (stream, status)
|
|
|
|
|
FILE *stream;
|
|
|
|
|
int status;
|
1991-03-22 05:29:06 +08:00
|
|
|
|
{
|
1993-07-16 00:46:50 +08:00
|
|
|
|
fprintf (stream, "\
|
1994-09-16 09:59:30 +08:00
|
|
|
|
Usage: %s [-ahifdDrRtTxsl] [-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]\n\
|
|
|
|
|
[--architecture=machine] [--reloc] [--full-contents] [--stabs]\n\
|
|
|
|
|
[--syms] [--all-headers] [--dynamic-syms] [--dynamic-reloc]\n\
|
1994-04-07 10:04:34 +08:00
|
|
|
|
[--version] [--help] objfile...\n\
|
1994-01-14 06:34:51 +08:00
|
|
|
|
at least one option besides -l (--line-numbers) must be given\n",
|
1993-07-16 00:46:50 +08:00
|
|
|
|
program_name);
|
|
|
|
|
exit (status);
|
1991-03-22 05:29:06 +08:00
|
|
|
|
}
|
|
|
|
|
|
1992-06-10 22:57:25 +08:00
|
|
|
|
static struct option long_options[]=
|
|
|
|
|
{
|
1994-01-14 06:34:51 +08:00
|
|
|
|
{"all-headers", no_argument, NULL, 'x'},
|
|
|
|
|
{"architecture", required_argument, NULL, 'm'},
|
|
|
|
|
{"archive-headers", no_argument, NULL, 'a'},
|
|
|
|
|
{"disassemble", no_argument, NULL, 'd'},
|
1994-09-16 09:59:30 +08:00
|
|
|
|
{"disassemble-all", no_argument, NULL, 'D'},
|
1994-04-07 10:04:34 +08:00
|
|
|
|
{"dynamic-reloc", no_argument, NULL, 'R'},
|
|
|
|
|
{"dynamic-syms", no_argument, NULL, 'T'},
|
1994-01-14 06:34:51 +08:00
|
|
|
|
{"file-headers", no_argument, NULL, 'f'},
|
|
|
|
|
{"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'},
|
|
|
|
|
{"reloc", no_argument, NULL, 'r'},
|
|
|
|
|
{"section", required_argument, NULL, 'j'},
|
|
|
|
|
{"section-headers", no_argument, NULL, 'h'},
|
1992-06-11 16:23:11 +08:00
|
|
|
|
{"stabs", no_argument, &dump_stab_section_info, 1},
|
1994-01-14 06:34:51 +08:00
|
|
|
|
{"syms", no_argument, NULL, 't'},
|
|
|
|
|
{"target", required_argument, NULL, 'b'},
|
|
|
|
|
{"version", no_argument, &show_version, 1},
|
1993-04-29 14:45:39 +08:00
|
|
|
|
{0, no_argument, 0, 0}
|
|
|
|
|
};
|
1994-01-27 06:11:18 +08:00
|
|
|
|
|
1991-03-22 05:29:06 +08:00
|
|
|
|
static void
|
1994-01-27 06:11:18 +08:00
|
|
|
|
dump_section_header (abfd, section, ignored)
|
1992-06-10 22:57:25 +08:00
|
|
|
|
bfd *abfd;
|
1994-01-27 06:11:18 +08:00
|
|
|
|
asection *section;
|
|
|
|
|
PTR ignored;
|
1991-03-22 05:29:06 +08:00
|
|
|
|
{
|
1994-01-27 06:11:18 +08:00
|
|
|
|
char *comma = "";
|
1992-06-10 22:57:25 +08:00
|
|
|
|
|
1991-03-22 05:29:06 +08:00
|
|
|
|
#define PF(x,y) \
|
1994-01-27 06:11:18 +08:00
|
|
|
|
if (section->flags & x) { printf("%s%s",comma,y); comma = ", "; }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
printf ("SECTION %d [%s]\t: size %08x",
|
|
|
|
|
section->index,
|
|
|
|
|
section->name,
|
|
|
|
|
(unsigned) bfd_get_section_size_before_reloc (section));
|
|
|
|
|
printf (" vma ");
|
|
|
|
|
printf_vma (section->vma);
|
|
|
|
|
printf (" align 2**%u\n ",
|
|
|
|
|
section->alignment_power);
|
|
|
|
|
PF (SEC_ALLOC, "ALLOC");
|
|
|
|
|
PF (SEC_CONSTRUCTOR, "CONSTRUCTOR");
|
|
|
|
|
PF (SEC_CONSTRUCTOR_TEXT, "CONSTRUCTOR TEXT");
|
|
|
|
|
PF (SEC_CONSTRUCTOR_DATA, "CONSTRUCTOR DATA");
|
|
|
|
|
PF (SEC_CONSTRUCTOR_BSS, "CONSTRUCTOR BSS");
|
|
|
|
|
PF (SEC_LOAD, "LOAD");
|
|
|
|
|
PF (SEC_RELOC, "RELOC");
|
1993-09-01 02:15:50 +08:00
|
|
|
|
#ifdef SEC_BALIGN
|
1994-01-27 06:11:18 +08:00
|
|
|
|
PF (SEC_BALIGN, "BALIGN");
|
1993-09-01 02:15:50 +08:00
|
|
|
|
#endif
|
1994-01-27 06:11:18 +08:00
|
|
|
|
PF (SEC_READONLY, "READONLY");
|
|
|
|
|
PF (SEC_CODE, "CODE");
|
|
|
|
|
PF (SEC_DATA, "DATA");
|
|
|
|
|
PF (SEC_ROM, "ROM");
|
|
|
|
|
PF (SEC_DEBUGGING, "DEBUGGING");
|
1994-09-14 02:18:01 +08:00
|
|
|
|
PF (SEC_NEVER_LOAD, "NEVER_LOAD");
|
1994-01-27 06:11:18 +08:00
|
|
|
|
printf ("\n");
|
1991-03-22 05:29:06 +08:00
|
|
|
|
#undef PF
|
|
|
|
|
}
|
|
|
|
|
|
1994-01-27 06:11:18 +08:00
|
|
|
|
static void
|
|
|
|
|
dump_headers (abfd)
|
|
|
|
|
bfd *abfd;
|
|
|
|
|
{
|
|
|
|
|
bfd_map_over_sections (abfd, dump_section_header, (PTR) NULL);
|
|
|
|
|
}
|
|
|
|
|
|
1991-03-22 05:29:06 +08:00
|
|
|
|
static asymbol **
|
1994-01-25 21:27:56 +08:00
|
|
|
|
slurp_symtab (abfd)
|
|
|
|
|
bfd *abfd;
|
1991-03-22 05:29:06 +08:00
|
|
|
|
{
|
1992-06-10 22:57:25 +08:00
|
|
|
|
asymbol **sy = (asymbol **) NULL;
|
1994-03-31 06:06:17 +08:00
|
|
|
|
long storage;
|
1991-03-22 05:29:06 +08:00
|
|
|
|
|
1992-06-10 22:57:25 +08:00
|
|
|
|
if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
|
|
|
|
|
{
|
1994-01-27 06:11:18 +08:00
|
|
|
|
printf ("No symbols in \"%s\".\n", bfd_get_filename (abfd));
|
|
|
|
|
return NULL;
|
1992-06-10 22:57:25 +08:00
|
|
|
|
}
|
|
|
|
|
|
1994-03-31 06:06:17 +08:00
|
|
|
|
storage = bfd_get_symtab_upper_bound (abfd);
|
|
|
|
|
if (storage < 0)
|
|
|
|
|
bfd_fatal (bfd_get_filename (abfd));
|
|
|
|
|
|
1992-06-10 22:57:25 +08:00
|
|
|
|
if (storage)
|
|
|
|
|
{
|
1994-01-14 06:34:51 +08:00
|
|
|
|
sy = (asymbol **) xmalloc (storage);
|
1992-06-10 22:57:25 +08:00
|
|
|
|
}
|
|
|
|
|
symcount = bfd_canonicalize_symtab (abfd, sy);
|
1994-03-31 06:06:17 +08:00
|
|
|
|
if (symcount < 0)
|
|
|
|
|
bfd_fatal (bfd_get_filename (abfd));
|
|
|
|
|
if (symcount == 0)
|
1994-04-07 10:04:34 +08:00
|
|
|
|
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;
|
|
|
|
|
|
|
|
|
|
storage = bfd_get_dynamic_symtab_upper_bound (abfd);
|
|
|
|
|
if (storage < 0)
|
1994-09-14 02:18:01 +08:00
|
|
|
|
{
|
|
|
|
|
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));
|
|
|
|
|
}
|
1994-04-07 10:04:34 +08:00
|
|
|
|
|
|
|
|
|
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));
|
1992-06-10 22:57:25 +08:00
|
|
|
|
return sy;
|
1991-03-22 05:29:06 +08:00
|
|
|
|
}
|
1992-06-10 22:57:25 +08:00
|
|
|
|
|
1994-01-27 06:11:18 +08:00
|
|
|
|
/* Filter out (in place) symbols that are useless for disassembly.
|
|
|
|
|
COUNT is the number of elements in SYMBOLS.
|
|
|
|
|
Return the number of useful symbols. */
|
1993-06-19 05:37:21 +08:00
|
|
|
|
|
1994-03-31 06:06:17 +08:00
|
|
|
|
long
|
1994-01-27 06:11:18 +08:00
|
|
|
|
remove_useless_symbols (symbols, count)
|
|
|
|
|
asymbol **symbols;
|
1994-03-31 06:06:17 +08:00
|
|
|
|
long count;
|
1993-06-19 05:37:21 +08:00
|
|
|
|
{
|
1994-01-27 06:11:18 +08:00
|
|
|
|
register asymbol **in_ptr = symbols, **out_ptr = symbols;
|
1993-06-19 05:37:21 +08:00
|
|
|
|
|
1994-01-27 06:11:18 +08:00
|
|
|
|
while (--count >= 0)
|
1993-06-19 05:37:21 +08:00
|
|
|
|
{
|
|
|
|
|
asymbol *sym = *in_ptr++;
|
|
|
|
|
|
|
|
|
|
if (sym->name == NULL || sym->name[0] == '\0')
|
|
|
|
|
continue;
|
|
|
|
|
if (sym->flags & (BSF_DEBUGGING))
|
|
|
|
|
continue;
|
1994-09-14 02:18:01 +08:00
|
|
|
|
if (bfd_is_und_section (sym->section)
|
1993-06-19 05:37:21 +08:00
|
|
|
|
|| bfd_is_com_section (sym->section))
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
*out_ptr++ = sym;
|
|
|
|
|
}
|
1994-01-27 06:11:18 +08:00
|
|
|
|
return out_ptr - symbols;
|
1993-06-19 05:37:21 +08:00
|
|
|
|
}
|
|
|
|
|
|
1994-01-23 08:31:14 +08:00
|
|
|
|
/* Sort symbols into value order. */
|
|
|
|
|
|
1992-06-10 22:57:25 +08:00
|
|
|
|
static int
|
1994-01-23 08:31:14 +08:00
|
|
|
|
compare_symbols (ap, bp)
|
1994-09-16 09:59:30 +08:00
|
|
|
|
const PTR ap;
|
|
|
|
|
const PTR bp;
|
1991-03-22 05:29:06 +08:00
|
|
|
|
{
|
1994-09-16 09:59:30 +08:00
|
|
|
|
const asymbol *a = *(const asymbol **)ap;
|
|
|
|
|
const asymbol *b = *(const asymbol **)bp;
|
1991-03-22 05:29:06 +08:00
|
|
|
|
|
1993-06-19 05:37:21 +08:00
|
|
|
|
if (a->value > b->value)
|
|
|
|
|
return 1;
|
|
|
|
|
else if (a->value < b->value)
|
|
|
|
|
return -1;
|
1991-03-22 05:29:06 +08:00
|
|
|
|
|
1993-06-19 05:37:21 +08:00
|
|
|
|
if (a->section > b->section)
|
|
|
|
|
return 1;
|
|
|
|
|
else if (a->section < b->section)
|
|
|
|
|
return -1;
|
|
|
|
|
return 0;
|
1991-03-22 05:29:06 +08:00
|
|
|
|
}
|
|
|
|
|
|
1994-09-16 09:59:30 +08:00
|
|
|
|
/* 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);
|
|
|
|
|
}
|
|
|
|
|
|
1994-01-27 06:11:18 +08:00
|
|
|
|
/* Print VMA symbolically to INFO if possible. */
|
|
|
|
|
|
1994-03-30 05:34:44 +08:00
|
|
|
|
static void
|
1993-04-10 02:22:57 +08:00
|
|
|
|
objdump_print_address (vma, info)
|
1992-06-10 22:57:25 +08:00
|
|
|
|
bfd_vma vma;
|
1993-04-10 02:22:57 +08:00
|
|
|
|
struct disassemble_info *info;
|
1991-03-22 05:29:06 +08:00
|
|
|
|
{
|
1993-09-01 02:15:50 +08:00
|
|
|
|
/* @@ For relocateable files, should filter out symbols belonging to
|
|
|
|
|
the wrong section. Unfortunately, not enough information is supplied
|
|
|
|
|
to this routine to determine the correct section in all cases. */
|
|
|
|
|
/* @@ Would it speed things up to cache the last two symbols returned,
|
|
|
|
|
and maybe their address ranges? For many processors, only one memory
|
|
|
|
|
operand can be present at a time, so the 2-entry cache wouldn't be
|
|
|
|
|
constantly churned by code doing heavy memory accesses. */
|
1991-03-22 05:29:06 +08:00
|
|
|
|
|
1994-01-27 06:11:18 +08:00
|
|
|
|
/* Indices in `syms'. */
|
1994-03-31 06:06:17 +08:00
|
|
|
|
long min = 0;
|
|
|
|
|
long max = symcount;
|
|
|
|
|
long thisplace;
|
1991-03-22 05:29:06 +08:00
|
|
|
|
|
1994-03-30 05:34:44 +08:00
|
|
|
|
bfd_signed_vma vardiff;
|
1991-03-22 05:29:06 +08:00
|
|
|
|
|
1993-06-19 05:37:21 +08:00
|
|
|
|
fprintf_vma (info->stream, vma);
|
|
|
|
|
|
1994-01-27 06:11:18 +08:00
|
|
|
|
if (symcount < 1)
|
|
|
|
|
return;
|
|
|
|
|
|
1994-03-30 05:34:44 +08:00
|
|
|
|
/* Perform a binary search looking for the closest symbol to the
|
|
|
|
|
required value. We are searching the range (min, max]. */
|
|
|
|
|
while (min + 1 < max)
|
1992-06-10 22:57:25 +08:00
|
|
|
|
{
|
1994-01-27 06:11:18 +08:00
|
|
|
|
asymbol *sym;
|
1994-03-30 05:34:44 +08:00
|
|
|
|
|
1994-01-27 06:11:18 +08:00
|
|
|
|
thisplace = (max + min) / 2;
|
|
|
|
|
sym = syms[thisplace];
|
1994-03-30 05:34:44 +08:00
|
|
|
|
|
1994-01-27 06:11:18 +08:00
|
|
|
|
vardiff = sym->value - vma;
|
|
|
|
|
|
|
|
|
|
if (vardiff > 0)
|
|
|
|
|
max = thisplace;
|
|
|
|
|
else if (vardiff < 0)
|
|
|
|
|
min = thisplace;
|
|
|
|
|
else
|
1992-06-10 22:57:25 +08:00
|
|
|
|
{
|
1994-03-30 05:34:44 +08:00
|
|
|
|
min = thisplace;
|
|
|
|
|
break;
|
1992-06-10 22:57:25 +08:00
|
|
|
|
}
|
1994-01-27 06:11:18 +08:00
|
|
|
|
}
|
1991-05-21 08:15:15 +09:00
|
|
|
|
|
1994-03-30 05:34:44 +08:00
|
|
|
|
/* The symbol we want is now in min, the low end of the range we
|
|
|
|
|
were searching. */
|
|
|
|
|
thisplace = min;
|
|
|
|
|
|
1994-01-27 06:11:18 +08:00
|
|
|
|
{
|
|
|
|
|
/* If this symbol isn't global, search for one with the same value
|
|
|
|
|
that is. */
|
|
|
|
|
bfd_vma val = syms[thisplace]->value;
|
1994-03-31 06:06:17 +08:00
|
|
|
|
long i;
|
1994-01-27 06:11:18 +08:00
|
|
|
|
if (syms[thisplace]->flags & (BSF_LOCAL|BSF_DEBUGGING))
|
|
|
|
|
for (i = thisplace - 1; i >= 0; i--)
|
1992-06-10 22:57:25 +08:00
|
|
|
|
{
|
1994-01-27 06:11:18 +08:00
|
|
|
|
if (syms[i]->value == val
|
|
|
|
|
&& (!(syms[i]->flags & (BSF_LOCAL|BSF_DEBUGGING))
|
|
|
|
|
|| ((syms[thisplace]->flags & BSF_DEBUGGING)
|
|
|
|
|
&& !(syms[i]->flags & BSF_DEBUGGING))))
|
1992-06-10 22:57:25 +08:00
|
|
|
|
{
|
1994-01-27 06:11:18 +08:00
|
|
|
|
thisplace = i;
|
|
|
|
|
break;
|
1992-06-10 22:57:25 +08:00
|
|
|
|
}
|
|
|
|
|
}
|
1994-01-27 06:11:18 +08:00
|
|
|
|
if (syms[thisplace]->flags & (BSF_LOCAL|BSF_DEBUGGING))
|
|
|
|
|
for (i = thisplace + 1; i < symcount; i++)
|
|
|
|
|
{
|
|
|
|
|
if (syms[i]->value == val
|
|
|
|
|
&& (!(syms[i]->flags & (BSF_LOCAL|BSF_DEBUGGING))
|
|
|
|
|
|| ((syms[thisplace]->flags & BSF_DEBUGGING)
|
|
|
|
|
&& !(syms[i]->flags & BSF_DEBUGGING))))
|
1993-09-01 02:15:50 +08:00
|
|
|
|
{
|
1994-01-27 06:11:18 +08:00
|
|
|
|
thisplace = i;
|
|
|
|
|
break;
|
1993-09-01 02:15:50 +08:00
|
|
|
|
}
|
1994-01-27 06:11:18 +08:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
{
|
|
|
|
|
/* If the file is relocateable, and the symbol could be from this
|
|
|
|
|
section, prefer a symbol from this section over symbols from
|
|
|
|
|
others, even if the other symbol's value might be closer.
|
|
|
|
|
|
|
|
|
|
Note that this may be wrong for some symbol references if the
|
|
|
|
|
sections have overlapping memory ranges, but in that case there's
|
|
|
|
|
no way to tell what's desired without looking at the relocation
|
|
|
|
|
table. */
|
|
|
|
|
struct objdump_disasm_info *aux;
|
1994-03-31 06:06:17 +08:00
|
|
|
|
long i;
|
1994-01-27 06:11:18 +08:00
|
|
|
|
|
|
|
|
|
aux = (struct objdump_disasm_info *) info->application_data;
|
1994-09-16 23:30:38 +08:00
|
|
|
|
if ((aux->require_sec
|
|
|
|
|
|| (aux->abfd->flags & HAS_RELOC) != 0)
|
1994-01-27 06:11:18 +08:00
|
|
|
|
&& 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)
|
|
|
|
|
{
|
|
|
|
|
for (i = thisplace + 1; i < symcount; i++)
|
1994-03-30 05:34:44 +08:00
|
|
|
|
{
|
|
|
|
|
if (syms[i]->value != syms[thisplace]->value)
|
1994-09-14 02:18:01 +08:00
|
|
|
|
break;
|
1994-03-30 05:34:44 +08:00
|
|
|
|
}
|
1994-09-14 02:18:01 +08:00
|
|
|
|
--i;
|
1994-03-30 05:34:44 +08:00
|
|
|
|
for (; i >= 0; i--)
|
|
|
|
|
{
|
|
|
|
|
if (syms[i]->section == aux->sec)
|
|
|
|
|
{
|
|
|
|
|
thisplace = i;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
1993-09-01 02:15:50 +08:00
|
|
|
|
}
|
1994-01-27 06:11:18 +08:00
|
|
|
|
}
|
|
|
|
|
fprintf (info->stream, " <%s", syms[thisplace]->name);
|
|
|
|
|
if (syms[thisplace]->value > vma)
|
|
|
|
|
{
|
|
|
|
|
char buf[30], *p = buf;
|
|
|
|
|
sprintf_vma (buf, syms[thisplace]->value - vma);
|
|
|
|
|
while (*p == '0')
|
|
|
|
|
p++;
|
|
|
|
|
fprintf (info->stream, "-%s", p);
|
|
|
|
|
}
|
|
|
|
|
else if (vma > syms[thisplace]->value)
|
|
|
|
|
{
|
|
|
|
|
char buf[30], *p = buf;
|
|
|
|
|
sprintf_vma (buf, vma - syms[thisplace]->value);
|
|
|
|
|
while (*p == '0')
|
|
|
|
|
p++;
|
|
|
|
|
fprintf (info->stream, "+%s", p);
|
1991-03-22 05:29:06 +08:00
|
|
|
|
}
|
1994-01-27 06:11:18 +08:00
|
|
|
|
fprintf (info->stream, ">");
|
1991-03-22 05:29:06 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
1992-06-10 22:57:25 +08:00
|
|
|
|
disassemble_data (abfd)
|
|
|
|
|
bfd *abfd;
|
1991-03-22 05:29:06 +08:00
|
|
|
|
{
|
1994-03-31 06:06:17 +08:00
|
|
|
|
long i;
|
1994-02-03 08:25:30 +08:00
|
|
|
|
unsigned int (*print) () = 0; /* Old style */
|
1994-09-16 09:59:30 +08:00
|
|
|
|
disassembler_ftype disassemble_fn = 0; /* New style */
|
1993-03-19 08:12:50 +08:00
|
|
|
|
struct disassemble_info disasm_info;
|
1993-09-01 02:15:50 +08:00
|
|
|
|
struct objdump_disasm_info aux;
|
1993-03-19 08:12:50 +08:00
|
|
|
|
|
1994-09-15 04:21:21 +08:00
|
|
|
|
int prevline = 0;
|
|
|
|
|
char *prev_function = NULL;
|
1992-01-25 06:49:24 +08:00
|
|
|
|
|
1991-03-22 05:29:06 +08:00
|
|
|
|
asection *section;
|
1992-06-10 22:57:25 +08:00
|
|
|
|
|
1991-06-07 10:33:38 +09:00
|
|
|
|
boolean done_dot = false;
|
1992-06-10 22:57:25 +08:00
|
|
|
|
|
1994-09-16 09:59:30 +08:00
|
|
|
|
/* If we are dumping relocation information, read the relocs for
|
|
|
|
|
each section we are going to disassemble. We must do this before
|
|
|
|
|
we sort the symbols. */
|
|
|
|
|
if (dump_reloc_info)
|
|
|
|
|
{
|
|
|
|
|
for (section = abfd->sections;
|
|
|
|
|
section != (asection *) NULL;
|
|
|
|
|
section = section->next)
|
|
|
|
|
{
|
|
|
|
|
long relsize;
|
|
|
|
|
arelent **relpp;
|
|
|
|
|
|
|
|
|
|
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 ((section->flags & SEC_RELOC) == 0)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
/* We store the reloc information in the reloc_count and
|
|
|
|
|
orelocation fields. */
|
|
|
|
|
|
|
|
|
|
relsize = bfd_get_reloc_upper_bound (abfd, section);
|
|
|
|
|
if (relsize < 0)
|
|
|
|
|
bfd_fatal (bfd_get_filename (abfd));
|
|
|
|
|
|
|
|
|
|
if (relsize == 0)
|
|
|
|
|
section->reloc_count = 0;
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
long relcount;
|
|
|
|
|
|
|
|
|
|
relpp = (arelent **) xmalloc (relsize);
|
|
|
|
|
relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
|
|
|
|
|
if (relcount < 0)
|
|
|
|
|
bfd_fatal (bfd_get_filename (abfd));
|
|
|
|
|
section->reloc_count = relcount;
|
|
|
|
|
section->orelocation = relpp;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
1994-02-03 08:25:30 +08:00
|
|
|
|
/* Replace symbol section relative values with abs values. */
|
1992-06-10 22:57:25 +08:00
|
|
|
|
for (i = 0; i < symcount; i++)
|
|
|
|
|
{
|
1991-03-22 05:29:06 +08:00
|
|
|
|
syms[i]->value += syms[i]->section->vma;
|
1992-06-10 22:57:25 +08:00
|
|
|
|
}
|
1991-03-22 05:29:06 +08:00
|
|
|
|
|
1993-06-19 05:37:21 +08:00
|
|
|
|
symcount = remove_useless_symbols (syms, symcount);
|
1991-03-22 05:29:06 +08:00
|
|
|
|
|
|
|
|
|
/* Sort the symbols into section and symbol order */
|
1994-01-27 06:11:18 +08:00
|
|
|
|
qsort (syms, symcount, sizeof (asymbol *), compare_symbols);
|
1991-03-22 05:29:06 +08:00
|
|
|
|
|
1994-02-03 08:25:30 +08:00
|
|
|
|
INIT_DISASSEMBLE_INFO(disasm_info, stdout);
|
|
|
|
|
disasm_info.application_data = (PTR) &aux;
|
|
|
|
|
aux.abfd = abfd;
|
|
|
|
|
disasm_info.print_address_func = objdump_print_address;
|
|
|
|
|
|
1992-06-10 22:57:25 +08:00
|
|
|
|
if (machine != (char *) NULL)
|
|
|
|
|
{
|
1994-02-03 08:25:30 +08:00
|
|
|
|
bfd_arch_info_type *info = bfd_scan_arch (machine);
|
|
|
|
|
if (info == NULL)
|
1992-06-10 22:57:25 +08:00
|
|
|
|
{
|
|
|
|
|
fprintf (stderr, "%s: Can't use supplied machine %s\n",
|
|
|
|
|
program_name,
|
|
|
|
|
machine);
|
|
|
|
|
exit (1);
|
|
|
|
|
}
|
|
|
|
|
abfd->arch_info = info;
|
1991-03-22 05:29:06 +08:00
|
|
|
|
}
|
1991-10-05 12:50:54 +08:00
|
|
|
|
|
1994-02-03 08:25:30 +08:00
|
|
|
|
/* See if we can disassemble using bfd. */
|
1991-10-05 12:50:54 +08:00
|
|
|
|
|
1992-06-10 22:57:25 +08:00
|
|
|
|
if (abfd->arch_info->disassemble)
|
|
|
|
|
{
|
|
|
|
|
print = abfd->arch_info->disassemble;
|
1991-10-05 12:50:54 +08:00
|
|
|
|
}
|
1992-06-10 22:57:25 +08:00
|
|
|
|
else
|
|
|
|
|
{
|
1994-09-16 09:59:30 +08:00
|
|
|
|
disassemble_fn = disassembler (abfd);
|
|
|
|
|
if (!disassemble_fn)
|
1992-06-10 22:57:25 +08:00
|
|
|
|
{
|
|
|
|
|
fprintf (stderr, "%s: Can't disassemble for architecture %s\n",
|
|
|
|
|
program_name,
|
1994-06-03 23:00:55 +08:00
|
|
|
|
bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
|
1992-06-10 22:57:25 +08:00
|
|
|
|
exit (1);
|
|
|
|
|
}
|
|
|
|
|
}
|
1991-03-22 05:29:06 +08:00
|
|
|
|
|
|
|
|
|
for (section = abfd->sections;
|
1992-06-10 22:57:25 +08:00
|
|
|
|
section != (asection *) NULL;
|
|
|
|
|
section = section->next)
|
1992-02-07 04:15:19 +08:00
|
|
|
|
{
|
1994-02-03 08:25:30 +08:00
|
|
|
|
bfd_byte *data = NULL;
|
|
|
|
|
bfd_size_type datasize = 0;
|
1994-09-16 09:59:30 +08:00
|
|
|
|
arelent **relpp = NULL;
|
|
|
|
|
arelent **relppend = NULL;
|
1991-03-22 05:29:06 +08:00
|
|
|
|
|
1994-09-16 09:59:30 +08:00
|
|
|
|
if ((section->flags & SEC_LOAD) == 0
|
|
|
|
|
|| (! disassemble_all
|
|
|
|
|
&& only == NULL
|
|
|
|
|
&& (section->flags & SEC_CODE) == 0))
|
1994-02-03 08:25:30 +08:00
|
|
|
|
continue;
|
|
|
|
|
if (only != (char *) NULL && strcmp (only, section->name) != 0)
|
|
|
|
|
continue;
|
1991-03-22 05:29:06 +08:00
|
|
|
|
|
1994-09-16 09:59:30 +08:00
|
|
|
|
if (dump_reloc_info
|
|
|
|
|
&& (section->flags & SEC_RELOC) != 0)
|
|
|
|
|
{
|
|
|
|
|
/* Sort the relocs by address. */
|
|
|
|
|
qsort (section->orelocation, section->reloc_count,
|
|
|
|
|
sizeof (arelent *), compare_relocs);
|
|
|
|
|
relpp = section->orelocation;
|
|
|
|
|
relppend = relpp + section->reloc_count;
|
|
|
|
|
}
|
|
|
|
|
|
1994-02-03 08:25:30 +08:00
|
|
|
|
printf ("Disassembly of section %s:\n", section->name);
|
1991-03-22 05:29:06 +08:00
|
|
|
|
|
1994-02-03 08:25:30 +08:00
|
|
|
|
datasize = bfd_get_section_size_before_reloc (section);
|
|
|
|
|
if (datasize == 0)
|
|
|
|
|
continue;
|
1991-03-22 05:29:06 +08:00
|
|
|
|
|
1994-02-03 08:25:30 +08:00
|
|
|
|
data = (bfd_byte *) xmalloc ((size_t) datasize);
|
1991-03-22 05:29:06 +08:00
|
|
|
|
|
1994-02-03 08:25:30 +08:00
|
|
|
|
bfd_get_section_contents (abfd, section, data, 0, datasize);
|
1991-03-22 05:29:06 +08:00
|
|
|
|
|
1994-02-03 08:25:30 +08:00
|
|
|
|
aux.sec = section;
|
|
|
|
|
disasm_info.buffer = data;
|
|
|
|
|
disasm_info.buffer_vma = section->vma;
|
|
|
|
|
disasm_info.buffer_length = datasize;
|
|
|
|
|
i = 0;
|
|
|
|
|
while (i < disasm_info.buffer_length)
|
|
|
|
|
{
|
1994-09-16 09:59:30 +08:00
|
|
|
|
int bytes;
|
|
|
|
|
|
1994-02-03 08:25:30 +08:00
|
|
|
|
if (data[i] == 0 && data[i + 1] == 0 && data[i + 2] == 0 &&
|
|
|
|
|
data[i + 3] == 0)
|
1992-06-10 22:57:25 +08:00
|
|
|
|
{
|
1994-02-03 08:25:30 +08:00
|
|
|
|
if (done_dot == false)
|
1992-06-10 22:57:25 +08:00
|
|
|
|
{
|
1994-02-03 08:25:30 +08:00
|
|
|
|
printf ("...\n");
|
|
|
|
|
done_dot = true;
|
1992-02-07 04:15:19 +08:00
|
|
|
|
}
|
1994-09-16 09:59:30 +08:00
|
|
|
|
bytes = 4;
|
1994-02-03 08:25:30 +08:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
done_dot = false;
|
|
|
|
|
if (with_line_numbers)
|
1992-06-10 22:57:25 +08:00
|
|
|
|
{
|
1994-02-03 08:25:30 +08:00
|
|
|
|
CONST char *filename;
|
|
|
|
|
CONST char *functionname;
|
|
|
|
|
unsigned int line;
|
|
|
|
|
|
|
|
|
|
if (bfd_find_nearest_line (abfd,
|
|
|
|
|
section,
|
|
|
|
|
syms,
|
|
|
|
|
section->vma + i,
|
|
|
|
|
&filename,
|
|
|
|
|
&functionname,
|
|
|
|
|
&line))
|
1992-06-10 22:57:25 +08:00
|
|
|
|
{
|
1994-09-15 04:21:21 +08:00
|
|
|
|
if (functionname
|
|
|
|
|
&& *functionname != '\0'
|
|
|
|
|
&& (prev_function == NULL
|
|
|
|
|
|| strcmp (functionname, prev_function) != 0))
|
1994-02-03 08:25:30 +08:00
|
|
|
|
{
|
|
|
|
|
printf ("%s():\n", functionname);
|
1994-09-15 04:21:21 +08:00
|
|
|
|
if (prev_function != NULL)
|
|
|
|
|
free (prev_function);
|
|
|
|
|
prev_function = xmalloc (strlen (functionname) + 1);
|
|
|
|
|
strcpy (prev_function, functionname);
|
1994-02-03 08:25:30 +08:00
|
|
|
|
}
|
|
|
|
|
if (!filename)
|
|
|
|
|
filename = "???";
|
|
|
|
|
if (line && line != prevline)
|
1992-06-10 22:57:25 +08:00
|
|
|
|
{
|
1994-02-03 08:25:30 +08:00
|
|
|
|
printf ("%s:%u\n", filename, line);
|
|
|
|
|
prevline = line;
|
1992-06-10 22:57:25 +08:00
|
|
|
|
}
|
|
|
|
|
}
|
1994-02-03 08:25:30 +08:00
|
|
|
|
}
|
1994-09-16 23:30:38 +08:00
|
|
|
|
aux.require_sec = true;
|
1994-02-03 08:25:30 +08:00
|
|
|
|
objdump_print_address (section->vma + i, &disasm_info);
|
1994-09-16 23:30:38 +08:00
|
|
|
|
aux.require_sec = false;
|
1994-02-03 08:25:30 +08:00
|
|
|
|
putchar (' ');
|
1992-02-07 04:15:19 +08:00
|
|
|
|
|
1994-09-16 09:59:30 +08:00
|
|
|
|
if (disassemble_fn)
|
1994-02-03 08:25:30 +08:00
|
|
|
|
{
|
1994-09-16 09:59:30 +08:00
|
|
|
|
/* New style */
|
|
|
|
|
bytes = (*disassemble_fn) (section->vma + i, &disasm_info);
|
1994-02-03 08:25:30 +08:00
|
|
|
|
if (bytes < 0)
|
|
|
|
|
break;
|
1992-06-10 22:57:25 +08:00
|
|
|
|
}
|
1994-09-16 09:59:30 +08:00
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* Old style */
|
|
|
|
|
bytes = print (section->vma + i, data + i, stdout);
|
|
|
|
|
}
|
1994-02-03 08:25:30 +08:00
|
|
|
|
putchar ('\n');
|
1991-06-07 10:33:38 +09:00
|
|
|
|
}
|
1994-09-16 09:59:30 +08:00
|
|
|
|
|
|
|
|
|
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;
|
1991-06-07 10:33:38 +09:00
|
|
|
|
}
|
1994-02-03 08:25:30 +08:00
|
|
|
|
free (data);
|
1991-03-22 05:29:06 +08:00
|
|
|
|
}
|
|
|
|
|
}
|
1992-06-11 16:23:11 +08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Define a table of stab values and print-strings. We wish the initializer
|
|
|
|
|
could be a direct-mapped table, but instead we build one the first
|
|
|
|
|
time we need it. */
|
|
|
|
|
|
1994-01-18 06:03:42 +08:00
|
|
|
|
char **stab_name;
|
1992-06-11 16:23:11 +08:00
|
|
|
|
|
|
|
|
|
struct stab_print {
|
|
|
|
|
int value;
|
1994-01-18 06:03:42 +08:00
|
|
|
|
char *string;
|
1992-06-11 16:23:11 +08:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct stab_print stab_print[] = {
|
|
|
|
|
#define __define_stab(NAME, CODE, STRING) {CODE, STRING},
|
|
|
|
|
#include "aout/stab.def"
|
|
|
|
|
#undef __define_stab
|
1994-01-14 06:34:51 +08:00
|
|
|
|
{0, ""}
|
1992-06-11 16:23:11 +08:00
|
|
|
|
};
|
|
|
|
|
|
1994-02-04 06:21:28 +08:00
|
|
|
|
void dump_section_stabs PARAMS ((bfd *abfd, char *stabsect_name,
|
|
|
|
|
char *strsect_name));
|
1992-08-19 11:25:51 +08:00
|
|
|
|
|
1994-02-04 06:21:28 +08:00
|
|
|
|
/* Dump the stabs sections from an object file that has a section that
|
1992-06-11 16:23:11 +08:00
|
|
|
|
uses Sun stabs encoding. It has to use some hooks into BFD because
|
|
|
|
|
string table sections are not normally visible to BFD callers. */
|
|
|
|
|
|
|
|
|
|
void
|
1993-09-23 13:21:21 +08:00
|
|
|
|
dump_stabs (abfd)
|
1992-06-11 16:23:11 +08:00
|
|
|
|
bfd *abfd;
|
|
|
|
|
{
|
1994-01-18 06:03:42 +08:00
|
|
|
|
/* Allocate and initialize stab name array if first time. */
|
|
|
|
|
if (stab_name == NULL)
|
1992-06-11 16:23:11 +08:00
|
|
|
|
{
|
1994-02-04 06:21:28 +08:00
|
|
|
|
int i;
|
|
|
|
|
|
1994-01-18 06:03:42 +08:00
|
|
|
|
stab_name = (char **) xmalloc (256 * sizeof(char *));
|
|
|
|
|
/* Clear the array. */
|
1992-06-11 16:23:11 +08:00
|
|
|
|
for (i = 0; i < 256; i++)
|
1994-01-18 06:03:42 +08:00
|
|
|
|
stab_name[i] = NULL;
|
|
|
|
|
/* Fill in the defined stabs. */
|
|
|
|
|
for (i = 0; *stab_print[i].string; i++)
|
|
|
|
|
stab_name[stab_print[i].value] = stab_print[i].string;
|
1992-06-11 16:23:11 +08:00
|
|
|
|
}
|
|
|
|
|
|
1994-02-04 06:21:28 +08:00
|
|
|
|
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$");
|
1992-08-19 11:25:51 +08:00
|
|
|
|
}
|
|
|
|
|
|
1994-02-04 06:21:28 +08:00
|
|
|
|
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)
|
1992-08-19 11:25:51 +08:00
|
|
|
|
bfd *abfd;
|
1994-02-04 06:21:28 +08:00
|
|
|
|
char *stabsect_name;
|
|
|
|
|
char *strsect_name;
|
1992-08-19 11:25:51 +08:00
|
|
|
|
{
|
1993-09-23 13:21:21 +08:00
|
|
|
|
asection *stabsect, *stabstrsect;
|
|
|
|
|
|
1994-06-21 04:31:46 +08:00
|
|
|
|
stabsect = bfd_get_section_by_name (abfd, stabsect_name);
|
|
|
|
|
if (0 == stabsect)
|
1992-06-11 16:23:11 +08:00
|
|
|
|
{
|
1994-02-04 06:21:28 +08:00
|
|
|
|
printf ("No %s section present\n\n", stabsect_name);
|
|
|
|
|
return false;
|
1992-06-11 16:23:11 +08:00
|
|
|
|
}
|
|
|
|
|
|
1994-06-21 04:31:46 +08:00
|
|
|
|
stabstrsect = bfd_get_section_by_name (abfd, strsect_name);
|
|
|
|
|
if (0 == stabstrsect)
|
1992-06-11 16:23:11 +08:00
|
|
|
|
{
|
1994-01-22 13:11:40 +08:00
|
|
|
|
fprintf (stderr, "%s: %s has no %s section\n", program_name,
|
1994-02-04 06:21:28 +08:00
|
|
|
|
bfd_get_filename (abfd), strsect_name);
|
|
|
|
|
return false;
|
1992-06-11 16:23:11 +08:00
|
|
|
|
}
|
1993-09-23 13:21:21 +08:00
|
|
|
|
|
1994-06-21 04:31:46 +08:00
|
|
|
|
stab_size = bfd_section_size (abfd, stabsect);
|
|
|
|
|
stabstr_size = bfd_section_size (abfd, stabstrsect);
|
1992-06-11 16:23:11 +08:00
|
|
|
|
|
1993-09-23 13:21:21 +08:00
|
|
|
|
stabs = (struct internal_nlist *) xmalloc (stab_size);
|
|
|
|
|
strtab = (char *) xmalloc (stabstr_size);
|
1992-06-11 16:23:11 +08:00
|
|
|
|
|
1994-06-21 04:31:46 +08:00
|
|
|
|
if (! bfd_get_section_contents (abfd, stabsect, (PTR) stabs, 0, stab_size))
|
1993-09-23 13:21:21 +08:00
|
|
|
|
{
|
1994-06-21 04:31:46 +08:00
|
|
|
|
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;
|
1992-06-11 16:23:11 +08:00
|
|
|
|
}
|
1991-03-22 05:29:06 +08:00
|
|
|
|
|
1994-06-21 04:31:46 +08:00
|
|
|
|
if (! bfd_get_section_contents (abfd, stabstrsect, (PTR) strtab, 0,
|
|
|
|
|
stabstr_size))
|
1993-09-23 13:21:21 +08:00
|
|
|
|
{
|
1994-06-21 04:31:46 +08:00
|
|
|
|
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;
|
1992-06-11 16:23:11 +08:00
|
|
|
|
}
|
1994-06-21 04:31:46 +08:00
|
|
|
|
|
1994-02-04 06:21:28 +08:00
|
|
|
|
return true;
|
|
|
|
|
}
|
1992-06-11 16:23:11 +08:00
|
|
|
|
|
|
|
|
|
#define SWAP_SYMBOL(symp, abfd) \
|
1994-02-04 06:21:28 +08:00
|
|
|
|
{ \
|
1992-06-11 16:23:11 +08:00
|
|
|
|
(symp)->n_strx = bfd_h_get_32(abfd, \
|
1994-02-04 06:21:28 +08:00
|
|
|
|
(unsigned char *)&(symp)->n_strx); \
|
1992-06-11 16:23:11 +08:00
|
|
|
|
(symp)->n_desc = bfd_h_get_16 (abfd, \
|
1994-02-04 06:21:28 +08:00
|
|
|
|
(unsigned char *)&(symp)->n_desc); \
|
1992-06-11 16:23:11 +08:00
|
|
|
|
(symp)->n_value = bfd_h_get_32 (abfd, \
|
1994-02-04 06:21:28 +08:00
|
|
|
|
(unsigned char *)&(symp)->n_value); \
|
|
|
|
|
}
|
1992-06-11 16:23:11 +08:00
|
|
|
|
|
1994-02-04 06:21:28 +08:00
|
|
|
|
/* 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);
|
1992-06-11 16:23:11 +08:00
|
|
|
|
|
1994-02-04 06:21:28 +08:00
|
|
|
|
printf ("Contents of %s section:\n\n", stabsect_name);
|
|
|
|
|
printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
|
1992-08-19 11:25:51 +08:00
|
|
|
|
|
|
|
|
|
/* Loop through all symbols and print them.
|
|
|
|
|
|
|
|
|
|
We start the index at -1 because there is a dummy symbol on
|
1994-02-04 06:21:28 +08:00
|
|
|
|
the front of stabs-in-{coff,elf} sections that supplies sizes. */
|
1992-08-19 11:25:51 +08:00
|
|
|
|
|
1994-02-04 06:21:28 +08:00
|
|
|
|
for (i = -1; stabp < stabs_end; stabp++, i++)
|
1992-06-11 16:23:11 +08:00
|
|
|
|
{
|
1994-02-04 06:21:28 +08:00
|
|
|
|
SWAP_SYMBOL (stabp, abfd);
|
1994-01-18 06:03:42 +08:00
|
|
|
|
printf ("\n%-6d ", i);
|
1994-02-04 06:21:28 +08:00
|
|
|
|
/* Either print the stab name, or, if unnamed, print its number
|
1994-01-18 06:03:42 +08:00
|
|
|
|
again (makes consistent formatting for tools like awk). */
|
1994-02-04 06:21:28 +08:00
|
|
|
|
if (stab_name[stabp->n_type])
|
|
|
|
|
printf ("%-6s", stab_name[stabp->n_type]);
|
1994-06-03 23:00:55 +08:00
|
|
|
|
else if (stabp->n_type == N_UNDF)
|
|
|
|
|
printf ("HdrSym");
|
1994-01-18 06:03:42 +08:00
|
|
|
|
else
|
1994-06-03 23:00:55 +08:00
|
|
|
|
printf ("%-6d", stabp->n_type);
|
1994-02-04 06:21:28 +08:00
|
|
|
|
printf (" %-6d %-6d ", stabp->n_other, stabp->n_desc);
|
|
|
|
|
printf_vma (stabp->n_value);
|
|
|
|
|
printf (" %-6lu", stabp->n_strx);
|
1992-08-19 11:25:51 +08:00
|
|
|
|
|
|
|
|
|
/* 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. */
|
|
|
|
|
|
1994-02-04 06:21:28 +08:00
|
|
|
|
if (stabp->n_type == N_UNDF)
|
1992-08-19 11:25:51 +08:00
|
|
|
|
{
|
|
|
|
|
file_string_table_offset = next_file_string_table_offset;
|
1994-02-04 06:21:28 +08:00
|
|
|
|
next_file_string_table_offset += stabp->n_value;
|
1992-08-19 11:25:51 +08:00
|
|
|
|
}
|
|
|
|
|
else
|
1993-10-30 02:15:01 +08:00
|
|
|
|
{
|
1994-02-04 06:21:28 +08:00
|
|
|
|
/* Using the (possibly updated) string table offset, print the
|
1993-10-30 02:15:01 +08:00
|
|
|
|
string (if any) associated with this symbol. */
|
|
|
|
|
|
1994-02-04 06:21:28 +08:00
|
|
|
|
if ((stabp->n_strx + file_string_table_offset) < stabstr_size)
|
|
|
|
|
printf (" %s", &strtab[stabp->n_strx + file_string_table_offset]);
|
1993-10-30 02:15:01 +08:00
|
|
|
|
else
|
|
|
|
|
printf (" *");
|
|
|
|
|
}
|
1992-06-11 16:23:11 +08:00
|
|
|
|
}
|
|
|
|
|
printf ("\n\n");
|
|
|
|
|
}
|
1992-08-19 11:25:51 +08:00
|
|
|
|
|
1994-02-04 06:21:28 +08:00
|
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
1994-01-22 13:11:40 +08:00
|
|
|
|
static void
|
1994-01-27 06:11:18 +08:00
|
|
|
|
dump_bfd_header (abfd)
|
|
|
|
|
bfd *abfd;
|
|
|
|
|
{
|
|
|
|
|
char *comma = "";
|
|
|
|
|
|
|
|
|
|
printf ("architecture: %s, ",
|
|
|
|
|
bfd_printable_arch_mach (bfd_get_arch (abfd),
|
|
|
|
|
bfd_get_mach (abfd)));
|
|
|
|
|
printf ("flags 0x%08x:\n", abfd->flags);
|
|
|
|
|
|
|
|
|
|
#define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
|
|
|
|
|
PF (HAS_RELOC, "HAS_RELOC");
|
|
|
|
|
PF (EXEC_P, "EXEC_P");
|
|
|
|
|
PF (HAS_LINENO, "HAS_LINENO");
|
|
|
|
|
PF (HAS_DEBUG, "HAS_DEBUG");
|
|
|
|
|
PF (HAS_SYMS, "HAS_SYMS");
|
|
|
|
|
PF (HAS_LOCALS, "HAS_LOCALS");
|
|
|
|
|
PF (DYNAMIC, "DYNAMIC");
|
|
|
|
|
PF (WP_TEXT, "WP_TEXT");
|
|
|
|
|
PF (D_PAGED, "D_PAGED");
|
|
|
|
|
PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
|
|
|
|
|
printf ("\nstart address 0x");
|
|
|
|
|
printf_vma (abfd->start_address);
|
|
|
|
|
}
|
|
|
|
|
|
1994-01-14 06:34:51 +08:00
|
|
|
|
static void
|
1991-03-22 05:29:06 +08:00
|
|
|
|
display_bfd (abfd)
|
|
|
|
|
bfd *abfd;
|
|
|
|
|
{
|
1994-01-25 07:38:03 +08:00
|
|
|
|
char **matching;
|
|
|
|
|
|
|
|
|
|
if (!bfd_check_format_matches (abfd, bfd_object, &matching))
|
1992-06-10 22:57:25 +08:00
|
|
|
|
{
|
1994-02-03 08:25:30 +08:00
|
|
|
|
bfd_nonfatal (bfd_get_filename (abfd));
|
1994-03-30 05:34:44 +08:00
|
|
|
|
if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
|
1994-01-25 07:38:03 +08:00
|
|
|
|
{
|
|
|
|
|
list_matching_formats (matching);
|
|
|
|
|
free (matching);
|
|
|
|
|
}
|
1992-06-10 22:57:25 +08:00
|
|
|
|
return;
|
|
|
|
|
}
|
1994-01-27 06:11:18 +08:00
|
|
|
|
|
1994-02-03 08:25:30 +08:00
|
|
|
|
printf ("\n%s: file format %s\n", bfd_get_filename (abfd),
|
|
|
|
|
abfd->xvec->name);
|
1992-06-10 22:57:25 +08:00
|
|
|
|
if (dump_ar_hdrs)
|
|
|
|
|
print_arelt_descr (stdout, abfd, true);
|
|
|
|
|
if (dump_file_header)
|
1994-01-27 06:11:18 +08:00
|
|
|
|
dump_bfd_header (abfd);
|
|
|
|
|
putchar ('\n');
|
1991-03-22 05:29:06 +08:00
|
|
|
|
if (dump_section_headers)
|
1992-06-10 22:57:25 +08:00
|
|
|
|
dump_headers (abfd);
|
|
|
|
|
if (dump_symtab || dump_reloc_info || disassemble)
|
|
|
|
|
{
|
|
|
|
|
syms = slurp_symtab (abfd);
|
|
|
|
|
}
|
1994-04-07 10:04:34 +08:00
|
|
|
|
if (dump_dynamic_symtab || dump_dynamic_reloc_info)
|
|
|
|
|
{
|
|
|
|
|
dynsyms = slurp_dynamic_symtab (abfd);
|
|
|
|
|
}
|
1992-06-10 22:57:25 +08:00
|
|
|
|
if (dump_symtab)
|
1994-04-07 10:04:34 +08:00
|
|
|
|
dump_symbols (abfd, false);
|
|
|
|
|
if (dump_dynamic_symtab)
|
|
|
|
|
dump_symbols (abfd, true);
|
1992-06-11 16:23:11 +08:00
|
|
|
|
if (dump_stab_section_info)
|
1993-09-23 13:21:21 +08:00
|
|
|
|
dump_stabs (abfd);
|
1994-09-16 09:59:30 +08:00
|
|
|
|
if (dump_reloc_info && ! disassemble)
|
1992-06-10 22:57:25 +08:00
|
|
|
|
dump_relocs (abfd);
|
1994-04-07 10:04:34 +08:00
|
|
|
|
if (dump_dynamic_reloc_info)
|
|
|
|
|
dump_dynamic_relocs (abfd);
|
1992-06-10 22:57:25 +08:00
|
|
|
|
if (dump_section_contents)
|
|
|
|
|
dump_data (abfd);
|
1993-06-19 05:37:21 +08:00
|
|
|
|
/* Note that disassemble_data re-orders the syms table, but that is
|
|
|
|
|
safe - as long as it is done last! */
|
1992-06-10 22:57:25 +08:00
|
|
|
|
if (disassemble)
|
|
|
|
|
disassemble_data (abfd);
|
1991-03-22 05:29:06 +08:00
|
|
|
|
}
|
|
|
|
|
|
1993-02-22 23:31:30 +08:00
|
|
|
|
static void
|
1991-03-22 05:29:06 +08:00
|
|
|
|
display_file (filename, target)
|
|
|
|
|
char *filename;
|
|
|
|
|
char *target;
|
|
|
|
|
{
|
|
|
|
|
bfd *file, *arfile = (bfd *) NULL;
|
|
|
|
|
|
|
|
|
|
file = bfd_openr (filename, target);
|
1992-06-10 22:57:25 +08:00
|
|
|
|
if (file == NULL)
|
|
|
|
|
{
|
1994-02-03 08:25:30 +08:00
|
|
|
|
bfd_nonfatal (filename);
|
1992-06-10 22:57:25 +08:00
|
|
|
|
return;
|
|
|
|
|
}
|
1991-03-22 05:29:06 +08:00
|
|
|
|
|
1992-06-10 22:57:25 +08:00
|
|
|
|
if (bfd_check_format (file, bfd_archive) == true)
|
|
|
|
|
{
|
1994-03-30 05:34:44 +08:00
|
|
|
|
bfd *last_arfile = NULL;
|
|
|
|
|
|
1992-06-10 22:57:25 +08:00
|
|
|
|
printf ("In archive %s:\n", bfd_get_filename (file));
|
|
|
|
|
for (;;)
|
|
|
|
|
{
|
1994-03-30 05:34:44 +08:00
|
|
|
|
bfd_set_error (bfd_error_no_error);
|
1992-06-10 22:57:25 +08:00
|
|
|
|
|
|
|
|
|
arfile = bfd_openr_next_archived_file (file, arfile);
|
|
|
|
|
if (arfile == NULL)
|
|
|
|
|
{
|
1994-03-30 05:34:44 +08:00
|
|
|
|
if (bfd_get_error () != bfd_error_no_more_archived_files)
|
1993-04-29 14:45:39 +08:00
|
|
|
|
{
|
1994-02-03 08:25:30 +08:00
|
|
|
|
bfd_nonfatal (bfd_get_filename (file));
|
1993-04-29 14:45:39 +08:00
|
|
|
|
}
|
1994-03-30 05:34:44 +08:00
|
|
|
|
break;
|
1992-06-10 22:57:25 +08:00
|
|
|
|
}
|
1991-03-22 05:29:06 +08:00
|
|
|
|
|
1992-06-10 22:57:25 +08:00
|
|
|
|
display_bfd (arfile);
|
1994-03-30 05:34:44 +08:00
|
|
|
|
|
|
|
|
|
if (last_arfile != NULL)
|
|
|
|
|
bfd_close (last_arfile);
|
|
|
|
|
last_arfile = arfile;
|
1992-06-10 22:57:25 +08:00
|
|
|
|
}
|
1994-03-30 05:34:44 +08:00
|
|
|
|
|
|
|
|
|
if (last_arfile != NULL)
|
|
|
|
|
bfd_close (last_arfile);
|
1991-03-22 05:29:06 +08:00
|
|
|
|
}
|
|
|
|
|
else
|
1992-06-10 22:57:25 +08:00
|
|
|
|
display_bfd (file);
|
1991-03-22 05:29:06 +08:00
|
|
|
|
|
1992-06-10 22:57:25 +08:00
|
|
|
|
bfd_close (file);
|
1991-03-22 05:29:06 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Actually display the various requested regions */
|
|
|
|
|
|
1993-02-22 23:31:30 +08:00
|
|
|
|
static void
|
1991-03-22 05:29:06 +08:00
|
|
|
|
dump_data (abfd)
|
|
|
|
|
bfd *abfd;
|
|
|
|
|
{
|
|
|
|
|
asection *section;
|
1992-06-10 22:57:25 +08:00
|
|
|
|
bfd_byte *data = 0;
|
1991-05-21 08:15:15 +09:00
|
|
|
|
bfd_size_type datasize = 0;
|
|
|
|
|
bfd_size_type i;
|
1991-03-22 05:29:06 +08:00
|
|
|
|
|
|
|
|
|
for (section = abfd->sections; section != NULL; section =
|
1992-06-10 22:57:25 +08:00
|
|
|
|
section->next)
|
|
|
|
|
{
|
|
|
|
|
int onaline = 16;
|
1991-03-22 05:29:06 +08:00
|
|
|
|
|
1992-06-10 22:57:25 +08:00
|
|
|
|
if (only == (char *) NULL ||
|
|
|
|
|
strcmp (only, section->name) == 0)
|
1992-05-02 06:45:45 +08:00
|
|
|
|
{
|
1992-06-10 22:57:25 +08:00
|
|
|
|
if (section->flags & SEC_HAS_CONTENTS)
|
|
|
|
|
{
|
|
|
|
|
printf ("Contents of section %s:\n", section->name);
|
|
|
|
|
|
1993-09-23 13:21:21 +08:00
|
|
|
|
if (bfd_section_size (abfd, section) == 0)
|
1992-06-10 22:57:25 +08:00
|
|
|
|
continue;
|
1994-01-14 06:34:51 +08:00
|
|
|
|
data = (bfd_byte *) xmalloc ((size_t) bfd_section_size (abfd, section));
|
1993-09-23 13:21:21 +08:00
|
|
|
|
datasize = bfd_section_size (abfd, section);
|
1991-03-22 05:29:06 +08:00
|
|
|
|
|
|
|
|
|
|
1993-09-23 13:21:21 +08:00
|
|
|
|
bfd_get_section_contents (abfd, section, (PTR) data, 0, bfd_section_size (abfd, section));
|
1991-03-22 05:29:06 +08:00
|
|
|
|
|
1993-09-23 13:21:21 +08:00
|
|
|
|
for (i = 0; i < bfd_section_size (abfd, section); i += onaline)
|
1992-06-10 22:57:25 +08:00
|
|
|
|
{
|
|
|
|
|
bfd_size_type j;
|
|
|
|
|
|
|
|
|
|
printf (" %04lx ", (unsigned long int) (i + section->vma));
|
|
|
|
|
for (j = i; j < i + onaline; j++)
|
|
|
|
|
{
|
1993-09-23 13:21:21 +08:00
|
|
|
|
if (j < bfd_section_size (abfd, section))
|
1992-06-10 22:57:25 +08:00
|
|
|
|
printf ("%02x", (unsigned) (data[j]));
|
|
|
|
|
else
|
|
|
|
|
printf (" ");
|
|
|
|
|
if ((j & 3) == 3)
|
|
|
|
|
printf (" ");
|
|
|
|
|
}
|
1991-03-22 05:29:06 +08:00
|
|
|
|
|
1992-06-10 22:57:25 +08:00
|
|
|
|
printf (" ");
|
|
|
|
|
for (j = i; j < i + onaline; j++)
|
|
|
|
|
{
|
1993-09-23 13:21:21 +08:00
|
|
|
|
if (j >= bfd_section_size (abfd, section))
|
1992-06-10 22:57:25 +08:00
|
|
|
|
printf (" ");
|
|
|
|
|
else
|
|
|
|
|
printf ("%c", isprint (data[j]) ? data[j] : '.');
|
|
|
|
|
}
|
|
|
|
|
putchar ('\n');
|
|
|
|
|
}
|
1993-02-22 23:31:30 +08:00
|
|
|
|
free (data);
|
1992-05-02 06:45:45 +08:00
|
|
|
|
}
|
1991-03-22 05:29:06 +08:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Should perhaps share code and display with nm? */
|
1993-02-22 23:31:30 +08:00
|
|
|
|
static void
|
1994-04-07 10:04:34 +08:00
|
|
|
|
dump_symbols (abfd, dynamic)
|
1991-03-22 05:29:06 +08:00
|
|
|
|
bfd *abfd;
|
1994-04-07 10:04:34 +08:00
|
|
|
|
boolean dynamic;
|
1991-03-22 05:29:06 +08:00
|
|
|
|
{
|
1994-04-07 10:04:34 +08:00
|
|
|
|
asymbol **current;
|
|
|
|
|
long max;
|
1994-03-31 06:06:17 +08:00
|
|
|
|
long count;
|
1991-03-22 05:29:06 +08:00
|
|
|
|
|
1994-04-07 10:04:34 +08:00
|
|
|
|
if (dynamic)
|
1992-06-10 22:57:25 +08:00
|
|
|
|
{
|
1994-04-07 10:04:34 +08:00
|
|
|
|
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");
|
|
|
|
|
}
|
1991-03-22 05:29:06 +08:00
|
|
|
|
|
1994-04-07 10:04:34 +08:00
|
|
|
|
for (count = 0; count < max; count++)
|
|
|
|
|
{
|
1993-02-22 23:31:30 +08:00
|
|
|
|
if (*current)
|
1992-06-10 22:57:25 +08:00
|
|
|
|
{
|
1993-02-22 23:31:30 +08:00
|
|
|
|
bfd *cur_bfd = bfd_asymbol_bfd(*current);
|
|
|
|
|
if (cur_bfd)
|
|
|
|
|
{
|
|
|
|
|
bfd_print_symbol (cur_bfd,
|
|
|
|
|
stdout,
|
|
|
|
|
*current, bfd_print_symbol_all);
|
|
|
|
|
printf ("\n");
|
|
|
|
|
}
|
1992-06-10 22:57:25 +08:00
|
|
|
|
}
|
|
|
|
|
current++;
|
1991-03-22 05:29:06 +08:00
|
|
|
|
}
|
1992-06-10 22:57:25 +08:00
|
|
|
|
printf ("\n");
|
|
|
|
|
printf ("\n");
|
1991-03-22 05:29:06 +08:00
|
|
|
|
}
|
|
|
|
|
|
1993-02-22 23:31:30 +08:00
|
|
|
|
static void
|
1992-06-10 22:57:25 +08:00
|
|
|
|
dump_relocs (abfd)
|
|
|
|
|
bfd *abfd;
|
1991-03-22 05:29:06 +08:00
|
|
|
|
{
|
|
|
|
|
arelent **relpp;
|
1994-03-31 06:06:17 +08:00
|
|
|
|
long relcount;
|
1991-03-22 05:29:06 +08:00
|
|
|
|
asection *a;
|
1992-06-10 22:57:25 +08:00
|
|
|
|
|
|
|
|
|
for (a = abfd->sections; a != (asection *) NULL; a = a->next)
|
|
|
|
|
{
|
1994-03-31 06:06:17 +08:00
|
|
|
|
long relsize;
|
|
|
|
|
|
1994-09-14 02:18:01 +08:00
|
|
|
|
if (bfd_is_abs_section (a))
|
1992-06-10 22:57:25 +08:00
|
|
|
|
continue;
|
1994-09-14 02:18:01 +08:00
|
|
|
|
if (bfd_is_und_section (a))
|
1992-06-10 22:57:25 +08:00
|
|
|
|
continue;
|
1993-02-22 23:31:30 +08:00
|
|
|
|
if (bfd_is_com_section (a))
|
1992-06-10 22:57:25 +08:00
|
|
|
|
continue;
|
|
|
|
|
|
1993-09-01 02:15:50 +08:00
|
|
|
|
if (only)
|
|
|
|
|
{
|
|
|
|
|
if (strcmp (only, a->name))
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
else if ((a->flags & SEC_RELOC) == 0)
|
|
|
|
|
continue;
|
|
|
|
|
|
1992-06-10 22:57:25 +08:00
|
|
|
|
printf ("RELOCATION RECORDS FOR [%s]:", a->name);
|
|
|
|
|
|
1994-03-31 06:06:17 +08:00
|
|
|
|
relsize = bfd_get_reloc_upper_bound (abfd, a);
|
|
|
|
|
if (relsize < 0)
|
|
|
|
|
bfd_fatal (bfd_get_filename (abfd));
|
|
|
|
|
|
|
|
|
|
if (relsize == 0)
|
1992-06-10 22:57:25 +08:00
|
|
|
|
{
|
|
|
|
|
printf (" (none)\n\n");
|
1992-01-25 06:49:24 +08:00
|
|
|
|
}
|
1992-06-10 22:57:25 +08:00
|
|
|
|
else
|
|
|
|
|
{
|
1994-03-31 06:06:17 +08:00
|
|
|
|
relpp = (arelent **) xmalloc (relsize);
|
1993-06-19 05:37:21 +08:00
|
|
|
|
/* Note that this must be done *before* we sort the syms table. */
|
1992-06-10 22:57:25 +08:00
|
|
|
|
relcount = bfd_canonicalize_reloc (abfd, a, relpp, syms);
|
1994-03-31 06:06:17 +08:00
|
|
|
|
if (relcount < 0)
|
|
|
|
|
bfd_fatal (bfd_get_filename (abfd));
|
|
|
|
|
else if (relcount == 0)
|
1992-06-10 22:57:25 +08:00
|
|
|
|
{
|
|
|
|
|
printf (" (none)\n\n");
|
1992-01-25 06:49:24 +08:00
|
|
|
|
}
|
1992-06-10 22:57:25 +08:00
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
printf ("\n");
|
1994-04-07 10:04:34 +08:00
|
|
|
|
dump_reloc_set (abfd, relpp, relcount);
|
1992-06-10 22:57:25 +08:00
|
|
|
|
printf ("\n\n");
|
1992-01-25 06:49:24 +08:00
|
|
|
|
}
|
1994-04-07 10:04:34 +08:00
|
|
|
|
free (relpp);
|
1991-03-22 05:29:06 +08:00
|
|
|
|
}
|
1994-04-07 10:04:34 +08:00
|
|
|
|
}
|
|
|
|
|
}
|
1991-03-22 05:29:06 +08:00
|
|
|
|
|
1994-04-07 10:04:34 +08:00
|
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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");
|
1992-01-25 06:49:24 +08:00
|
|
|
|
}
|
1991-03-22 05:29:06 +08:00
|
|
|
|
}
|
1994-01-27 06:11:18 +08:00
|
|
|
|
|
|
|
|
|
/* The length of the longest architecture name + 1. */
|
|
|
|
|
#define LONGEST_ARCH sizeof("rs6000:6000")
|
|
|
|
|
|
|
|
|
|
/* List the targets that BFD is configured to support, each followed
|
|
|
|
|
by its endianness and the architectures it supports. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
display_target_list ()
|
|
|
|
|
{
|
1994-04-22 11:47:57 +08:00
|
|
|
|
extern char *tmpnam ();
|
1994-01-27 06:11:18 +08:00
|
|
|
|
extern bfd_target *bfd_target_vector[];
|
1994-04-22 11:47:57 +08:00
|
|
|
|
char *dummy_name;
|
1994-01-27 06:11:18 +08:00
|
|
|
|
int t;
|
|
|
|
|
|
1994-04-22 11:47:57 +08:00
|
|
|
|
dummy_name = tmpnam ((char *) NULL);
|
1994-01-27 06:11:18 +08:00
|
|
|
|
for (t = 0; bfd_target_vector[t]; t++)
|
|
|
|
|
{
|
|
|
|
|
bfd_target *p = bfd_target_vector[t];
|
1994-04-22 11:47:57 +08:00
|
|
|
|
bfd *abfd = bfd_openw (dummy_name, p->name);
|
1994-06-03 23:00:55 +08:00
|
|
|
|
int a;
|
|
|
|
|
|
|
|
|
|
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");
|
1994-01-27 06:11:18 +08:00
|
|
|
|
|
1994-02-01 10:52:22 +08:00
|
|
|
|
if (abfd == NULL)
|
|
|
|
|
{
|
1994-04-22 11:47:57 +08:00
|
|
|
|
bfd_nonfatal (dummy_name);
|
1994-06-03 23:00:55 +08:00
|
|
|
|
continue;
|
1994-02-01 10:52:22 +08:00
|
|
|
|
}
|
1994-06-03 23:00:55 +08:00
|
|
|
|
|
|
|
|
|
if (! bfd_set_format (abfd, bfd_object))
|
|
|
|
|
{
|
|
|
|
|
if (bfd_get_error () != bfd_error_invalid_operation)
|
|
|
|
|
bfd_nonfatal (p->name);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
1994-01-27 06:11:18 +08:00
|
|
|
|
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));
|
|
|
|
|
}
|
1994-04-22 11:47:57 +08:00
|
|
|
|
unlink (dummy_name);
|
1994-01-27 06:11:18 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Print a table showing which architectures are supported for entries
|
|
|
|
|
FIRST through LAST-1 of bfd_target_vector (targets across,
|
|
|
|
|
architectures down). */
|
|
|
|
|
|
1991-04-24 01:02:09 +09:00
|
|
|
|
static void
|
1994-01-25 21:27:56 +08:00
|
|
|
|
display_info_table (first, last)
|
|
|
|
|
int first;
|
|
|
|
|
int last;
|
1991-04-24 01:02:09 +09:00
|
|
|
|
{
|
1994-01-25 21:27:56 +08:00
|
|
|
|
extern bfd_target *bfd_target_vector[];
|
1994-04-22 11:47:57 +08:00
|
|
|
|
extern char *tmpnam ();
|
|
|
|
|
int t, a;
|
|
|
|
|
char *dummy_name;
|
1991-04-24 01:02:09 +09:00
|
|
|
|
|
1994-01-27 06:11:18 +08:00
|
|
|
|
/* Print heading of target names. */
|
1994-03-31 06:06:17 +08:00
|
|
|
|
printf ("\n%*s", (int) LONGEST_ARCH, " ");
|
1994-06-03 23:00:55 +08:00
|
|
|
|
for (t = first; t < last && bfd_target_vector[t]; t++)
|
1994-01-27 06:11:18 +08:00
|
|
|
|
printf ("%s ", bfd_target_vector[t]->name);
|
|
|
|
|
putchar ('\n');
|
1991-04-24 01:02:09 +09:00
|
|
|
|
|
1994-04-22 11:47:57 +08:00
|
|
|
|
dummy_name = tmpnam ((char *) NULL);
|
1994-01-27 06:11:18 +08:00
|
|
|
|
for (a = (int) bfd_arch_obscure + 1; a < (int) bfd_arch_last; a++)
|
|
|
|
|
if (strcmp (bfd_printable_arch_mach (a, 0), "UNKNOWN!") != 0)
|
1991-10-05 12:50:54 +08:00
|
|
|
|
{
|
1994-03-31 06:06:17 +08:00
|
|
|
|
printf ("%*s ", (int) LONGEST_ARCH - 1,
|
|
|
|
|
bfd_printable_arch_mach (a, 0));
|
1994-06-03 23:00:55 +08:00
|
|
|
|
for (t = first; t < last && bfd_target_vector[t]; t++)
|
1992-06-10 22:57:25 +08:00
|
|
|
|
{
|
1994-01-27 06:11:18 +08:00
|
|
|
|
bfd_target *p = bfd_target_vector[t];
|
1994-06-03 23:00:55 +08:00
|
|
|
|
boolean ok = true;
|
1994-04-22 11:47:57 +08:00
|
|
|
|
bfd *abfd = bfd_openw (dummy_name, p->name);
|
1992-06-10 22:57:25 +08:00
|
|
|
|
|
1994-02-01 10:52:22 +08:00
|
|
|
|
if (abfd == NULL)
|
|
|
|
|
{
|
1994-06-03 23:00:55 +08:00
|
|
|
|
bfd_nonfatal (p->name);
|
|
|
|
|
ok = false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (ok)
|
|
|
|
|
{
|
|
|
|
|
if (! bfd_set_format (abfd, bfd_object))
|
|
|
|
|
{
|
|
|
|
|
if (bfd_get_error () != bfd_error_invalid_operation)
|
|
|
|
|
bfd_nonfatal (p->name);
|
|
|
|
|
ok = false;
|
|
|
|
|
}
|
1994-02-01 10:52:22 +08:00
|
|
|
|
}
|
1994-06-03 23:00:55 +08:00
|
|
|
|
|
|
|
|
|
if (ok)
|
|
|
|
|
{
|
|
|
|
|
if (! bfd_set_arch_mach (abfd, a, 0))
|
|
|
|
|
ok = false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (ok)
|
1992-06-10 22:57:25 +08:00
|
|
|
|
printf ("%s ", p->name);
|
|
|
|
|
else
|
1991-10-05 12:50:54 +08:00
|
|
|
|
{
|
1994-01-27 06:11:18 +08:00
|
|
|
|
int l = strlen (p->name);
|
1992-06-10 22:57:25 +08:00
|
|
|
|
while (l--)
|
1994-01-27 06:11:18 +08:00
|
|
|
|
putchar ('-');
|
|
|
|
|
putchar (' ');
|
1991-10-05 12:50:54 +08:00
|
|
|
|
}
|
|
|
|
|
}
|
1994-01-27 06:11:18 +08:00
|
|
|
|
putchar ('\n');
|
1991-10-05 12:50:54 +08:00
|
|
|
|
}
|
1994-04-22 11:47:57 +08:00
|
|
|
|
unlink (dummy_name);
|
1991-04-24 01:02:09 +09:00
|
|
|
|
}
|
1992-06-10 22:57:25 +08:00
|
|
|
|
|
1994-01-27 06:11:18 +08:00
|
|
|
|
/* Print tables of all the target-architecture combinations that
|
|
|
|
|
BFD has been configured to support. */
|
|
|
|
|
|
1992-06-10 22:57:25 +08:00
|
|
|
|
static void
|
1994-01-27 06:11:18 +08:00
|
|
|
|
display_target_tables ()
|
1992-06-10 22:57:25 +08:00
|
|
|
|
{
|
1994-01-27 06:11:18 +08:00
|
|
|
|
int t, columns;
|
1994-01-25 21:27:56 +08:00
|
|
|
|
extern bfd_target *bfd_target_vector[];
|
1994-01-27 06:11:18 +08:00
|
|
|
|
char *colum;
|
1992-06-10 22:57:25 +08:00
|
|
|
|
extern char *getenv ();
|
|
|
|
|
|
|
|
|
|
columns = 0;
|
1994-01-27 06:11:18 +08:00
|
|
|
|
colum = getenv ("COLUMNS");
|
|
|
|
|
if (colum != NULL)
|
1992-06-10 22:57:25 +08:00
|
|
|
|
columns = atoi (colum);
|
1994-01-27 06:11:18 +08:00
|
|
|
|
if (columns == 0)
|
1992-06-10 22:57:25 +08:00
|
|
|
|
columns = 80;
|
1994-01-27 06:11:18 +08:00
|
|
|
|
|
1994-06-03 23:00:55 +08:00
|
|
|
|
t = 0;
|
|
|
|
|
while (bfd_target_vector[t] != NULL)
|
1992-06-10 22:57:25 +08:00
|
|
|
|
{
|
1994-01-27 06:11:18 +08:00
|
|
|
|
int oldt = t, wid;
|
|
|
|
|
|
1994-06-03 23:00:55 +08:00
|
|
|
|
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;
|
|
|
|
|
}
|
1994-01-27 06:11:18 +08:00
|
|
|
|
display_info_table (oldt, t);
|
1992-06-10 22:57:25 +08:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
1994-01-27 06:11:18 +08:00
|
|
|
|
static void
|
|
|
|
|
display_info ()
|
|
|
|
|
{
|
|
|
|
|
printf ("BFD header file version %s\n", BFD_VERSION);
|
|
|
|
|
display_target_list ();
|
|
|
|
|
display_target_tables ();
|
|
|
|
|
}
|
|
|
|
|
|
1991-03-22 05:29:06 +08:00
|
|
|
|
int
|
|
|
|
|
main (argc, argv)
|
|
|
|
|
int argc;
|
|
|
|
|
char **argv;
|
|
|
|
|
{
|
|
|
|
|
int c;
|
|
|
|
|
char *target = default_target;
|
|
|
|
|
boolean seenflag = false;
|
|
|
|
|
|
|
|
|
|
program_name = *argv;
|
1994-03-30 05:34:44 +08:00
|
|
|
|
xmalloc_set_program_name (program_name);
|
|
|
|
|
|
|
|
|
|
bfd_init ();
|
1991-03-22 05:29:06 +08:00
|
|
|
|
|
1994-09-16 09:59:30 +08:00
|
|
|
|
while ((c = getopt_long (argc, argv, "ib:m:VdDlfahrRtTxsj:", long_options,
|
1993-04-29 14:45:39 +08:00
|
|
|
|
(int *) 0))
|
1992-06-10 22:57:25 +08:00
|
|
|
|
!= EOF)
|
|
|
|
|
{
|
|
|
|
|
seenflag = true;
|
|
|
|
|
switch (c)
|
|
|
|
|
{
|
1993-07-16 00:46:50 +08:00
|
|
|
|
case 0:
|
|
|
|
|
break; /* we've been given a long option */
|
1992-06-10 22:57:25 +08:00
|
|
|
|
case 'm':
|
|
|
|
|
machine = optarg;
|
|
|
|
|
break;
|
|
|
|
|
case 'j':
|
|
|
|
|
only = optarg;
|
|
|
|
|
break;
|
|
|
|
|
case 'l':
|
|
|
|
|
with_line_numbers = 1;
|
|
|
|
|
break;
|
|
|
|
|
case 'b':
|
|
|
|
|
target = optarg;
|
|
|
|
|
break;
|
|
|
|
|
case 'f':
|
|
|
|
|
dump_file_header = true;
|
|
|
|
|
break;
|
|
|
|
|
case 'i':
|
1993-10-30 02:15:01 +08:00
|
|
|
|
formats_info = true;
|
1992-06-10 22:57:25 +08:00
|
|
|
|
break;
|
|
|
|
|
case 'x':
|
|
|
|
|
dump_symtab = 1;
|
|
|
|
|
dump_reloc_info = 1;
|
|
|
|
|
dump_file_header = true;
|
|
|
|
|
dump_ar_hdrs = 1;
|
|
|
|
|
dump_section_headers = 1;
|
|
|
|
|
break;
|
|
|
|
|
case 't':
|
|
|
|
|
dump_symtab = 1;
|
|
|
|
|
break;
|
1994-04-07 10:04:34 +08:00
|
|
|
|
case 'T':
|
|
|
|
|
dump_dynamic_symtab = 1;
|
|
|
|
|
break;
|
1992-06-10 22:57:25 +08:00
|
|
|
|
case 'd':
|
|
|
|
|
disassemble = true;
|
|
|
|
|
break;
|
1994-09-16 09:59:30 +08:00
|
|
|
|
case 'D':
|
|
|
|
|
disassemble = disassemble_all = true;
|
|
|
|
|
break;
|
1992-06-10 22:57:25 +08:00
|
|
|
|
case 's':
|
|
|
|
|
dump_section_contents = 1;
|
|
|
|
|
break;
|
|
|
|
|
case 'r':
|
|
|
|
|
dump_reloc_info = 1;
|
|
|
|
|
break;
|
1994-04-07 10:04:34 +08:00
|
|
|
|
case 'R':
|
|
|
|
|
dump_dynamic_reloc_info = 1;
|
|
|
|
|
break;
|
1992-06-10 22:57:25 +08:00
|
|
|
|
case 'a':
|
|
|
|
|
dump_ar_hdrs = 1;
|
|
|
|
|
break;
|
|
|
|
|
case 'h':
|
|
|
|
|
dump_section_headers = 1;
|
|
|
|
|
break;
|
1993-07-16 00:46:50 +08:00
|
|
|
|
case 'H':
|
|
|
|
|
usage (stdout, 0);
|
1992-08-19 11:25:51 +08:00
|
|
|
|
case 'V':
|
|
|
|
|
show_version = 1;
|
|
|
|
|
break;
|
1992-06-10 22:57:25 +08:00
|
|
|
|
default:
|
1993-07-16 00:46:50 +08:00
|
|
|
|
usage (stderr, 1);
|
1992-06-10 22:57:25 +08:00
|
|
|
|
}
|
1991-03-22 05:29:06 +08:00
|
|
|
|
}
|
|
|
|
|
|
1992-08-19 11:25:51 +08:00
|
|
|
|
if (show_version)
|
1993-07-16 00:46:50 +08:00
|
|
|
|
{
|
|
|
|
|
printf ("GNU %s version %s\n", program_name, program_version);
|
|
|
|
|
exit (0);
|
|
|
|
|
}
|
1992-08-19 11:25:51 +08:00
|
|
|
|
|
1991-03-22 05:29:06 +08:00
|
|
|
|
if (seenflag == false)
|
1993-07-16 00:46:50 +08:00
|
|
|
|
usage (stderr, 1);
|
1991-03-22 05:29:06 +08:00
|
|
|
|
|
1993-10-30 02:15:01 +08:00
|
|
|
|
if (formats_info)
|
1992-06-10 22:57:25 +08:00
|
|
|
|
{
|
|
|
|
|
display_info ();
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (optind == argc)
|
|
|
|
|
display_file ("a.out", target);
|
|
|
|
|
else
|
|
|
|
|
for (; optind < argc;)
|
|
|
|
|
display_file (argv[optind++], target);
|
|
|
|
|
}
|
1991-03-22 05:29:06 +08:00
|
|
|
|
return 0;
|
|
|
|
|
}
|