1999-05-03 09:29:11 +02:00
|
|
|
|
/* objdump.c -- dump information about an object file.
|
2001-03-13 07:43:59 +01:00
|
|
|
|
Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
|
2009-01-27 16:41:56 +01:00
|
|
|
|
2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
|
1999-05-03 09:29:11 +02:00
|
|
|
|
Free Software Foundation, Inc.
|
|
|
|
|
|
2002-08-14 17:12:07 +02:00
|
|
|
|
This file is part of GNU Binutils.
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2002-08-14 17:12:07 +02:00
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
|
it under the terms of the GNU General Public License as published by
|
2007-07-05 18:54:46 +02:00
|
|
|
|
the Free Software Foundation; either version 3, or (at your option)
|
2002-08-14 17:12:07 +02:00
|
|
|
|
any later version.
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2002-08-14 17:12:07 +02:00
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
|
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.
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2002-08-14 17:12:07 +02:00
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
|
along with this program; if not, write to the Free Software
|
2007-07-05 18:54:46 +02:00
|
|
|
|
Foundation, 51 Franklin Street - Fifth Floor, Boston,
|
|
|
|
|
MA 02110-1301, USA. */
|
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2003-09-03 10:26:52 +02:00
|
|
|
|
/* Objdump overview.
|
|
|
|
|
|
|
|
|
|
Objdump displays information about one or more object files, either on
|
|
|
|
|
their own, or inside libraries. It is commonly used as a disassembler,
|
|
|
|
|
but it can also display information about file headers, symbol tables,
|
|
|
|
|
relocations, debugging directives and more.
|
|
|
|
|
|
|
|
|
|
The flow of execution is as follows:
|
|
|
|
|
|
|
|
|
|
1. Command line arguments are checked for control switches and the
|
|
|
|
|
information to be displayed is selected.
|
|
|
|
|
|
|
|
|
|
2. Any remaining arguments are assumed to be object files, and they are
|
|
|
|
|
processed in order by display_bfd(). If the file is an archive each
|
|
|
|
|
of its elements is processed in turn.
|
|
|
|
|
|
2003-10-27 14:20:32 +01:00
|
|
|
|
3. The file's target architecture and binary file format are determined
|
2003-09-03 10:26:52 +02:00
|
|
|
|
by bfd_check_format(). If they are recognised, then dump_bfd() is
|
|
|
|
|
called.
|
|
|
|
|
|
2003-10-27 14:20:32 +01:00
|
|
|
|
4. dump_bfd() in turn calls separate functions to display the requested
|
|
|
|
|
item(s) of information(s). For example disassemble_data() is called if
|
2003-12-06 01:06:12 +01:00
|
|
|
|
a disassembly has been requested.
|
2003-09-03 10:26:52 +02:00
|
|
|
|
|
|
|
|
|
When disassembling the code loops through blocks of instructions bounded
|
2003-10-27 14:20:32 +01:00
|
|
|
|
by symbols, calling disassemble_bytes() on each block. The actual
|
2003-09-03 10:26:52 +02:00
|
|
|
|
disassembling is done by the libopcodes library, via a function pointer
|
|
|
|
|
supplied by the disassembler() function. */
|
|
|
|
|
|
2007-04-26 16:47:00 +02:00
|
|
|
|
#include "sysdep.h"
|
1999-05-03 09:29:11 +02:00
|
|
|
|
#include "bfd.h"
|
2008-01-28 16:15:32 +01:00
|
|
|
|
#include "elf-bfd.h"
|
1999-05-03 09:29:11 +02:00
|
|
|
|
#include "progress.h"
|
|
|
|
|
#include "bucomm.h"
|
2005-09-30 16:56:34 +02:00
|
|
|
|
#include "dwarf.h"
|
2002-01-29 17:46:37 +01:00
|
|
|
|
#include "getopt.h"
|
2001-09-19 07:33:36 +02:00
|
|
|
|
#include "safe-ctype.h"
|
1999-05-03 09:29:11 +02:00
|
|
|
|
#include "dis-asm.h"
|
|
|
|
|
#include "libiberty.h"
|
|
|
|
|
#include "demangle.h"
|
2009-02-03 16:48:50 +01:00
|
|
|
|
#include "filenames.h"
|
1999-05-03 09:29:11 +02:00
|
|
|
|
#include "debug.h"
|
|
|
|
|
#include "budbg.h"
|
|
|
|
|
|
2007-06-18 18:38:49 +02:00
|
|
|
|
#ifdef HAVE_MMAP
|
|
|
|
|
#include <sys/mman.h>
|
|
|
|
|
#endif
|
|
|
|
|
|
2007-06-19 23:08:17 +02:00
|
|
|
|
#include <sys/stat.h>
|
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
/* Internal headers for the ELF .stab-dump code - sorry. */
|
|
|
|
|
#define BYTES_IN_WORD 32
|
|
|
|
|
#include "aout/aout64.h"
|
|
|
|
|
|
1999-08-09 07:23:29 +02:00
|
|
|
|
/* Exit status. */
|
|
|
|
|
static int exit_status = 0;
|
|
|
|
|
|
2003-03-17 12:16:51 +01:00
|
|
|
|
static char *default_target = NULL; /* Default at runtime. */
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2003-11-19 09:21:14 +01:00
|
|
|
|
/* The following variables are set based on arguments passed on the
|
|
|
|
|
command line. */
|
2003-03-17 12:16:51 +01:00
|
|
|
|
static int show_version = 0; /* Show the version number. */
|
1999-05-03 09:29:11 +02:00
|
|
|
|
static int dump_section_contents; /* -s */
|
|
|
|
|
static int dump_section_headers; /* -h */
|
2002-11-30 09:39:46 +01:00
|
|
|
|
static bfd_boolean dump_file_header; /* -f */
|
1999-05-03 09:29:11 +02:00
|
|
|
|
static int dump_symtab; /* -t */
|
|
|
|
|
static int dump_dynamic_symtab; /* -T */
|
|
|
|
|
static int dump_reloc_info; /* -r */
|
|
|
|
|
static int dump_dynamic_reloc_info; /* -R */
|
|
|
|
|
static int dump_ar_hdrs; /* -a */
|
|
|
|
|
static int dump_private_headers; /* -p */
|
|
|
|
|
static int prefix_addresses; /* --prefix-addresses */
|
|
|
|
|
static int with_line_numbers; /* -l */
|
2002-11-30 09:39:46 +01:00
|
|
|
|
static bfd_boolean with_source_code; /* -S */
|
1999-05-03 09:29:11 +02:00
|
|
|
|
static int show_raw_insn; /* --show-raw-insn */
|
2005-09-30 16:56:34 +02:00
|
|
|
|
static int dump_dwarf_section_info; /* --dwarf */
|
1999-05-03 09:29:11 +02:00
|
|
|
|
static int dump_stab_section_info; /* --stabs */
|
|
|
|
|
static int do_demangle; /* -C, --demangle */
|
2002-11-30 09:39:46 +01:00
|
|
|
|
static bfd_boolean disassemble; /* -d */
|
|
|
|
|
static bfd_boolean disassemble_all; /* -D */
|
1999-05-03 09:29:11 +02:00
|
|
|
|
static int disassemble_zeroes; /* --disassemble-zeroes */
|
2002-11-30 09:39:46 +01:00
|
|
|
|
static bfd_boolean formats_info; /* -i */
|
1999-05-03 09:29:11 +02:00
|
|
|
|
static int wide_output; /* -w */
|
2009-07-20 15:40:48 +02:00
|
|
|
|
static int insn_width; /* --insn-width */
|
1999-05-03 09:29:11 +02:00
|
|
|
|
static bfd_vma start_address = (bfd_vma) -1; /* --start-address */
|
|
|
|
|
static bfd_vma stop_address = (bfd_vma) -1; /* --stop-address */
|
|
|
|
|
static int dump_debugging; /* --debugging */
|
2003-07-22 15:33:32 +02:00
|
|
|
|
static int dump_debugging_tags; /* --debugging-tags */
|
2004-10-08 16:54:04 +02:00
|
|
|
|
static int dump_special_syms = 0; /* --special-syms */
|
1999-05-03 09:29:11 +02:00
|
|
|
|
static bfd_vma adjust_section_vma = 0; /* --adjust-vma */
|
2000-02-08 19:38:13 +01:00
|
|
|
|
static int file_start_context = 0; /* --file-start-context */
|
2008-02-22 10:42:58 +01:00
|
|
|
|
static bfd_boolean display_file_offsets;/* -F */
|
2009-02-03 16:48:50 +01:00
|
|
|
|
static const char *prefix; /* --prefix */
|
|
|
|
|
static int prefix_strip; /* --prefix-strip */
|
|
|
|
|
static size_t prefix_length;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2003-09-03 10:26:52 +02:00
|
|
|
|
/* Pointer to an array of section names provided by
|
|
|
|
|
one or more "-j secname" command line options. */
|
|
|
|
|
static char **only;
|
|
|
|
|
/* The total number of slots in the only[] array. */
|
|
|
|
|
static size_t only_size = 0;
|
|
|
|
|
/* The number of occupied slots in the only[] array. */
|
|
|
|
|
static size_t only_used = 0;
|
|
|
|
|
|
2003-08-04 16:29:34 +02:00
|
|
|
|
/* Variables for handling include file path table. */
|
|
|
|
|
static const char **include_paths;
|
|
|
|
|
static int include_path_count;
|
|
|
|
|
|
2003-11-19 09:21:14 +01:00
|
|
|
|
/* Extra info to pass to the section disassembler and address printing
|
|
|
|
|
function. */
|
2002-08-28 12:38:51 +02:00
|
|
|
|
struct objdump_disasm_info
|
|
|
|
|
{
|
2003-09-03 10:26:52 +02:00
|
|
|
|
bfd * abfd;
|
|
|
|
|
asection * sec;
|
|
|
|
|
bfd_boolean require_sec;
|
|
|
|
|
arelent ** dynrelbuf;
|
|
|
|
|
long dynrelcount;
|
|
|
|
|
disassembler_ftype disassemble_fn;
|
2005-03-01 16:18:44 +01:00
|
|
|
|
arelent * reloc;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* Architecture to disassemble for, or default if NULL. */
|
2003-08-05 16:40:54 +02:00
|
|
|
|
static char *machine = NULL;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
1999-06-16 04:24:36 +02:00
|
|
|
|
/* Target specific options to the disassembler. */
|
2003-08-05 16:40:54 +02:00
|
|
|
|
static char *disassembler_options = NULL;
|
1999-06-16 04:24:36 +02:00
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
/* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN. */
|
|
|
|
|
static enum bfd_endian endian = BFD_ENDIAN_UNKNOWN;
|
|
|
|
|
|
|
|
|
|
/* The symbol table. */
|
|
|
|
|
static asymbol **syms;
|
|
|
|
|
|
|
|
|
|
/* Number of symbols in `syms'. */
|
|
|
|
|
static long symcount = 0;
|
|
|
|
|
|
|
|
|
|
/* The sorted symbol table. */
|
|
|
|
|
static asymbol **sorted_syms;
|
|
|
|
|
|
|
|
|
|
/* Number of symbols in `sorted_syms'. */
|
|
|
|
|
static long sorted_symcount = 0;
|
|
|
|
|
|
|
|
|
|
/* The dynamic symbol table. */
|
|
|
|
|
static asymbol **dynsyms;
|
|
|
|
|
|
2004-04-22 16:45:32 +02:00
|
|
|
|
/* The synthetic symbol table. */
|
|
|
|
|
static asymbol *synthsyms;
|
|
|
|
|
static long synthcount = 0;
|
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
/* Number of symbols in `dynsyms'. */
|
|
|
|
|
static long dynsymcount = 0;
|
|
|
|
|
|
2003-03-17 12:16:51 +01:00
|
|
|
|
static bfd_byte *stabs;
|
|
|
|
|
static bfd_size_type stab_size;
|
|
|
|
|
|
|
|
|
|
static char *strtab;
|
|
|
|
|
static bfd_size_type stabstr_size;
|
2007-10-31 17:09:53 +01:00
|
|
|
|
|
|
|
|
|
static bfd_boolean is_relocatable = FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
static void
|
2003-07-29 17:40:37 +02:00
|
|
|
|
usage (FILE *stream, int status)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2002-01-23 17:12:56 +01:00
|
|
|
|
fprintf (stream, _("Usage: %s <option(s)> <file(s)>\n"), program_name);
|
|
|
|
|
fprintf (stream, _(" Display information from object <file(s)>.\n"));
|
|
|
|
|
fprintf (stream, _(" At least one of the following switches must be given:\n"));
|
1999-05-03 09:29:11 +02:00
|
|
|
|
fprintf (stream, _("\
|
2000-07-12 21:52:17 +02:00
|
|
|
|
-a, --archive-headers Display archive header information\n\
|
|
|
|
|
-f, --file-headers Display the contents of the overall file header\n\
|
|
|
|
|
-p, --private-headers Display object format specific file header contents\n\
|
|
|
|
|
-h, --[section-]headers Display the contents of the section headers\n\
|
|
|
|
|
-x, --all-headers Display the contents of all headers\n\
|
|
|
|
|
-d, --disassemble Display assembler contents of executable sections\n\
|
|
|
|
|
-D, --disassemble-all Display assembler contents of all sections\n\
|
|
|
|
|
-S, --source Intermix source code with disassembly\n\
|
|
|
|
|
-s, --full-contents Display the full contents of all sections requested\n\
|
|
|
|
|
-g, --debugging Display debug information in object file\n\
|
2003-07-22 15:33:32 +02:00
|
|
|
|
-e, --debugging-tags Display debug information using ctags style\n\
|
2000-07-12 21:52:17 +02:00
|
|
|
|
-G, --stabs Display (in raw form) any STABS info in the file\n\
|
2009-02-09 10:14:15 +01:00
|
|
|
|
-W[lLiaprmfFsoR] or\n\
|
2009-10-16 12:05:06 +02:00
|
|
|
|
--dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
|
|
|
|
|
=frames-interp,=str,=loc,=Ranges]\n\
|
2009-02-09 10:14:15 +01:00
|
|
|
|
Display DWARF info in the file\n\
|
2000-07-12 21:52:17 +02:00
|
|
|
|
-t, --syms Display the contents of the symbol table(s)\n\
|
|
|
|
|
-T, --dynamic-syms Display the contents of the dynamic symbol table\n\
|
|
|
|
|
-r, --reloc Display the relocation entries in the file\n\
|
|
|
|
|
-R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
|
2005-10-03 21:37:44 +02:00
|
|
|
|
@<file> Read options from <file>\n\
|
2002-01-23 17:12:56 +01:00
|
|
|
|
-v, --version Display this program's version number\n\
|
2000-07-12 21:52:17 +02:00
|
|
|
|
-i, --info List object formats and architectures supported\n\
|
|
|
|
|
-H, --help Display this information\n\
|
1999-11-21 12:37:21 +01:00
|
|
|
|
"));
|
|
|
|
|
if (status != 2)
|
|
|
|
|
{
|
|
|
|
|
fprintf (stream, _("\n The following switches are optional:\n"));
|
|
|
|
|
fprintf (stream, _("\
|
2000-07-12 21:52:17 +02:00
|
|
|
|
-b, --target=BFDNAME Specify the target object format as BFDNAME\n\
|
|
|
|
|
-m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
|
|
|
|
|
-j, --section=NAME Only display information for section NAME\n\
|
|
|
|
|
-M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
|
1999-11-21 12:37:21 +01:00
|
|
|
|
-EB --endian=big Assume big endian format when disassembling\n\
|
|
|
|
|
-EL --endian=little Assume little endian format when disassembling\n\
|
2000-02-08 19:38:13 +01:00
|
|
|
|
--file-start-context Include context from start of file (with -S)\n\
|
2003-08-04 16:29:34 +02:00
|
|
|
|
-I, --include=DIR Add DIR to search list for source files\n\
|
2000-07-12 21:52:17 +02:00
|
|
|
|
-l, --line-numbers Include line numbers and filenames in output\n\
|
2008-02-22 10:42:58 +01:00
|
|
|
|
-F, --file-offsets Include file offsets when displaying information\n\
|
2000-07-20 20:02:56 +02:00
|
|
|
|
-C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
|
2003-02-13 10:53:07 +01:00
|
|
|
|
The STYLE, if specified, can be `auto', `gnu',\n\
|
|
|
|
|
`lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
|
|
|
|
|
or `gnat'\n\
|
2000-07-12 21:52:17 +02:00
|
|
|
|
-w, --wide Format output for more than 80 columns\n\
|
|
|
|
|
-z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
|
2003-02-13 10:53:07 +01:00
|
|
|
|
--start-address=ADDR Only process data whose address is >= ADDR\n\
|
|
|
|
|
--stop-address=ADDR Only process data whose address is <= ADDR\n\
|
1999-11-21 12:37:21 +01:00
|
|
|
|
--prefix-addresses Print complete address alongside disassembly\n\
|
|
|
|
|
--[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
|
2009-07-20 15:40:48 +02:00
|
|
|
|
--insn-width=WIDTH Display WIDTH bytes on a signle line for -d\n\
|
2000-07-12 21:52:17 +02:00
|
|
|
|
--adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
|
2004-10-08 16:54:04 +02:00
|
|
|
|
--special-syms Include special symbols in symbol dumps\n\
|
2009-02-03 16:48:50 +01:00
|
|
|
|
--prefix=PREFIX Add PREFIX to absolute paths for -S\n\
|
|
|
|
|
--prefix-strip=LEVEL Strip initial directory names for -S\n\
|
1999-11-21 12:37:21 +01:00
|
|
|
|
\n"));
|
|
|
|
|
list_supported_targets (program_name, stream);
|
2001-07-29 07:31:43 +02:00
|
|
|
|
list_supported_architectures (program_name, stream);
|
2000-07-12 21:52:17 +02:00
|
|
|
|
|
2000-01-27 22:44:26 +01:00
|
|
|
|
disassembler_usage (stream);
|
1999-11-21 12:37:21 +01:00
|
|
|
|
}
|
2007-02-17 14:33:57 +01:00
|
|
|
|
if (REPORT_BUGS_TO[0] && status == 0)
|
2000-07-12 21:52:17 +02:00
|
|
|
|
fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
exit (status);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* 150 isn't special; it's just an arbitrary non-ASCII char value. */
|
2003-07-29 17:40:37 +02:00
|
|
|
|
enum option_values
|
|
|
|
|
{
|
|
|
|
|
OPTION_ENDIAN=150,
|
|
|
|
|
OPTION_START_ADDRESS,
|
|
|
|
|
OPTION_STOP_ADDRESS,
|
2009-02-09 10:14:15 +01:00
|
|
|
|
OPTION_DWARF,
|
2009-02-03 16:48:50 +01:00
|
|
|
|
OPTION_PREFIX,
|
|
|
|
|
OPTION_PREFIX_STRIP,
|
2009-07-20 15:40:48 +02:00
|
|
|
|
OPTION_INSN_WIDTH,
|
2003-07-29 17:40:37 +02:00
|
|
|
|
OPTION_ADJUST_VMA
|
|
|
|
|
};
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
static struct option long_options[]=
|
|
|
|
|
{
|
|
|
|
|
{"adjust-vma", required_argument, NULL, OPTION_ADJUST_VMA},
|
|
|
|
|
{"all-headers", no_argument, NULL, 'x'},
|
|
|
|
|
{"private-headers", no_argument, NULL, 'p'},
|
|
|
|
|
{"architecture", required_argument, NULL, 'm'},
|
|
|
|
|
{"archive-headers", no_argument, NULL, 'a'},
|
1999-11-21 12:37:21 +01:00
|
|
|
|
{"debugging", no_argument, NULL, 'g'},
|
2003-07-22 15:33:32 +02:00
|
|
|
|
{"debugging-tags", no_argument, NULL, 'e'},
|
2000-07-20 20:02:56 +02:00
|
|
|
|
{"demangle", optional_argument, NULL, 'C'},
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{"disassemble", no_argument, NULL, 'd'},
|
|
|
|
|
{"disassemble-all", no_argument, NULL, 'D'},
|
1999-06-16 04:24:36 +02:00
|
|
|
|
{"disassembler-options", required_argument, NULL, 'M'},
|
1999-11-21 12:37:21 +01:00
|
|
|
|
{"disassemble-zeroes", no_argument, NULL, 'z'},
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{"dynamic-reloc", no_argument, NULL, 'R'},
|
|
|
|
|
{"dynamic-syms", no_argument, NULL, 'T'},
|
|
|
|
|
{"endian", required_argument, NULL, OPTION_ENDIAN},
|
|
|
|
|
{"file-headers", no_argument, NULL, 'f'},
|
2008-02-22 10:42:58 +01:00
|
|
|
|
{"file-offsets", no_argument, NULL, 'F'},
|
2000-02-08 19:38:13 +01:00
|
|
|
|
{"file-start-context", no_argument, &file_start_context, 1},
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{"full-contents", no_argument, NULL, 's'},
|
|
|
|
|
{"headers", no_argument, NULL, 'h'},
|
|
|
|
|
{"help", no_argument, NULL, 'H'},
|
|
|
|
|
{"info", no_argument, NULL, 'i'},
|
|
|
|
|
{"line-numbers", no_argument, NULL, 'l'},
|
|
|
|
|
{"no-show-raw-insn", no_argument, &show_raw_insn, -1},
|
|
|
|
|
{"prefix-addresses", no_argument, &prefix_addresses, 1},
|
|
|
|
|
{"reloc", no_argument, NULL, 'r'},
|
|
|
|
|
{"section", required_argument, NULL, 'j'},
|
|
|
|
|
{"section-headers", no_argument, NULL, 'h'},
|
|
|
|
|
{"show-raw-insn", no_argument, &show_raw_insn, 1},
|
|
|
|
|
{"source", no_argument, NULL, 'S'},
|
2004-10-08 16:54:04 +02:00
|
|
|
|
{"special-syms", no_argument, &dump_special_syms, 1},
|
2003-08-04 16:29:34 +02:00
|
|
|
|
{"include", required_argument, NULL, 'I'},
|
2009-02-09 10:14:15 +01:00
|
|
|
|
{"dwarf", optional_argument, NULL, OPTION_DWARF},
|
1999-11-21 12:37:21 +01:00
|
|
|
|
{"stabs", no_argument, NULL, 'G'},
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{"start-address", required_argument, NULL, OPTION_START_ADDRESS},
|
|
|
|
|
{"stop-address", required_argument, NULL, OPTION_STOP_ADDRESS},
|
|
|
|
|
{"syms", no_argument, NULL, 't'},
|
|
|
|
|
{"target", required_argument, NULL, 'b'},
|
1999-11-21 12:37:21 +01:00
|
|
|
|
{"version", no_argument, NULL, 'V'},
|
|
|
|
|
{"wide", no_argument, NULL, 'w'},
|
2009-02-03 16:48:50 +01:00
|
|
|
|
{"prefix", required_argument, NULL, OPTION_PREFIX},
|
|
|
|
|
{"prefix-strip", required_argument, NULL, OPTION_PREFIX_STRIP},
|
2009-07-20 15:40:48 +02:00
|
|
|
|
{"insn-width", required_argument, NULL, OPTION_INSN_WIDTH},
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{0, no_argument, 0, 0}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static void
|
2003-07-29 17:40:37 +02:00
|
|
|
|
nonfatal (const char *msg)
|
1999-08-09 07:23:29 +02:00
|
|
|
|
{
|
|
|
|
|
bfd_nonfatal (msg);
|
|
|
|
|
exit_status = 1;
|
|
|
|
|
}
|
|
|
|
|
|
2009-07-27 19:08:03 +02:00
|
|
|
|
/* Returns TRUE if the specified section should be dumped. */
|
|
|
|
|
|
|
|
|
|
static bfd_boolean
|
|
|
|
|
process_section_p (asection * section)
|
|
|
|
|
{
|
|
|
|
|
size_t i;
|
|
|
|
|
|
|
|
|
|
if (only == NULL)
|
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < only_used; i++)
|
|
|
|
|
if (strcmp (only [i], section->name) == 0)
|
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
1999-08-09 07:23:29 +02:00
|
|
|
|
static void
|
2005-02-22 01:50:07 +01:00
|
|
|
|
dump_section_header (bfd *abfd, asection *section,
|
2003-07-29 17:40:37 +02:00
|
|
|
|
void *ignored ATTRIBUTE_UNUSED)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
char *comma = "";
|
2000-02-21 13:01:27 +01:00
|
|
|
|
unsigned int opb = bfd_octets_per_byte (abfd);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2005-04-19 23:29:46 +02:00
|
|
|
|
/* Ignore linker created section. See elfNN_ia64_object_p in
|
|
|
|
|
bfd/elfxx-ia64.c. */
|
|
|
|
|
if (section->flags & SEC_LINKER_CREATED)
|
|
|
|
|
return;
|
|
|
|
|
|
2009-07-27 19:08:03 +02:00
|
|
|
|
/* PR 10413: Skip sections that we are ignoring. */
|
|
|
|
|
if (! process_section_p (section))
|
|
|
|
|
return;
|
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
printf ("%3d %-13s %08lx ", section->index,
|
|
|
|
|
bfd_get_section_name (abfd, section),
|
2000-02-03 19:12:55 +01:00
|
|
|
|
(unsigned long) bfd_section_size (abfd, section) / opb);
|
2001-08-10 18:43:18 +02:00
|
|
|
|
bfd_printf_vma (abfd, bfd_get_section_vma (abfd, section));
|
1999-05-03 09:29:11 +02:00
|
|
|
|
printf (" ");
|
2001-08-10 18:43:18 +02:00
|
|
|
|
bfd_printf_vma (abfd, section->lma);
|
2001-09-18 12:05:55 +02:00
|
|
|
|
printf (" %08lx 2**%u", (unsigned long) section->filepos,
|
1999-05-03 09:29:11 +02:00
|
|
|
|
bfd_get_section_alignment (abfd, section));
|
|
|
|
|
if (! wide_output)
|
|
|
|
|
printf ("\n ");
|
|
|
|
|
printf (" ");
|
|
|
|
|
|
|
|
|
|
#define PF(x, y) \
|
|
|
|
|
if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
|
|
|
|
|
|
|
|
|
|
PF (SEC_HAS_CONTENTS, "CONTENTS");
|
|
|
|
|
PF (SEC_ALLOC, "ALLOC");
|
|
|
|
|
PF (SEC_CONSTRUCTOR, "CONSTRUCTOR");
|
|
|
|
|
PF (SEC_LOAD, "LOAD");
|
|
|
|
|
PF (SEC_RELOC, "RELOC");
|
|
|
|
|
PF (SEC_READONLY, "READONLY");
|
|
|
|
|
PF (SEC_CODE, "CODE");
|
|
|
|
|
PF (SEC_DATA, "DATA");
|
|
|
|
|
PF (SEC_ROM, "ROM");
|
|
|
|
|
PF (SEC_DEBUGGING, "DEBUGGING");
|
|
|
|
|
PF (SEC_NEVER_LOAD, "NEVER_LOAD");
|
|
|
|
|
PF (SEC_EXCLUDE, "EXCLUDE");
|
|
|
|
|
PF (SEC_SORT_ENTRIES, "SORT_ENTRIES");
|
2005-02-22 01:50:07 +01:00
|
|
|
|
if (bfd_get_arch (abfd) == bfd_arch_tic54x)
|
|
|
|
|
{
|
|
|
|
|
PF (SEC_TIC54X_BLOCK, "BLOCK");
|
|
|
|
|
PF (SEC_TIC54X_CLINK, "CLINK");
|
|
|
|
|
}
|
1999-08-09 05:23:37 +02:00
|
|
|
|
PF (SEC_SMALL_DATA, "SMALL_DATA");
|
2005-02-22 01:50:07 +01:00
|
|
|
|
if (bfd_get_flavour (abfd) == bfd_target_coff_flavour)
|
|
|
|
|
PF (SEC_COFF_SHARED, "SHARED");
|
* elf.c (_bfd_elf_make_section_from_shdr): Set SEC_THREAD_LOCAL
for symbols from SHF_TLS section.
(_bfd_elf_print_private_bfd_data): Add PT_TLS.
(elf_fake_sections): Set SHF_TLS for SEC_THREAD_LOCAL sections.
(map_sections_to_segments): Build PT_TLS segment if necessary.
(assign_file_positions_for_segments): Likewise.
(get_program_header_size): Account for PT_TLS segment.
(swap_out_syms): Set type of BSF_THREAD_LOCAL symbols and symbols from
SEC_THREAD_LOCAL sections to STT_TLS.
* reloc.c: Add 386 and IA-64 TLS relocs.
* section.c (SEC_THREAD_LOCAL): Define.
(SEC_CONSTRUCTOR_TEXT, SEC_CONSTRUCTOR_DATA, SEC_CONSTRUCTOR_BSS):
Remove.
* elflink.h (elf_link_add_object_symbols): Support .tcommon.
(size_dynamic_sections): If DF_STATIC_TLS, set DF_FLAGS
unconditionally.
(struct elf_final_link_info): Add first_tls_sec.
(elf_bfd_final_link): Set first_tls_sec.
Compute elf_hash_table (info)->tls_segment.
(elf_link_output_extsym): Handle STT_TLS symbols.
(elf_link_input_bfd): Likewise.
* syms.c (BSF_THREAD_LOCAL): Define.
* bfd-in2.h: Rebuilt.
* libbfd.h: Rebuilt.
* elf32-i386.c (elf_i386_tls_transition, dtpoff_base, tpoff,
elf_i386_mkobject, elf_i386_object_p): New functions.
(elf_howto_table): Add TLS relocs.
(elf_i386_reloc_type_lookup): Support TLS relocs.
(elf_i386_info_to_howto_rel): Likewise.
(struct elf_i386_link_hash_entry): Add tls_type.
(struct elf_i386_obj_tdata): New.
(elf_i386_hash_entry, elf_i386_tdata, elf_i386_local_got_tls_type):
New macros.
(struct elf_i386_link_hash_table): Add tls_ldm_got.
(link_hash_newfunc): Clear tls_type.
(elf_i386_check_relocs): Support TLS relocs.
(elf_i386_gc_sweep_hook): Likewise.
(allocate_dynrelocs): Likewise.
(elf_i386_size_dynamic_sections): Likewise.
(elf_i386_relocate_section): Likewise.
(elf_i386_finish_dynamic_symbol): Likewise.
(bfd_elf32_mkobject, elf_backend_object_p): Define.
* elfxx-ia64.c (struct elfNN_ia64_dyn_sym_info): Add tprel_offset,
dtpmod_offset, dtprel_offset, tprel_done, dtpmod_done, dtprel_done,
want_tprel, want_dtpmod, want_dtprel.
(elfNN_ia64_tprel_base, elfNN_ia64_dtprel_base): New functions.
(ia64_howto_table): Add TLS relocs, rename R_IA64_LTOFF_TP22 to
R_IA64_LTOFF_TPREL22.
(elf_code_to_howto_index): Add TLS relocs.
(elfNN_ia64_check_relocs): Support TLS relocs.
(allocate_global_data_got): Account for TLS .got data.
(allocate_dynrel_entries): Account for TLS dynamic relocations.
(elfNN_ia64_install_value): Supprt TLS relocs.
(set_got_entry): Support TLS relocs.
(elfNN_ia64_relocate_section): Likewise.
* config/obj-elf.c (elf_common): Renamed from obj_elf_common.
(obj_elf_common): Call elf_common.
(obj_elf_tls_common): New function.
(elf_pseudo_tab): Support .tls_common.
(special_sections): Add .tdata and .tbss.
(obj_elf_change_section): Set SEC_THREAD_LOCAL for SHF_TLS
sections.
(obj_elf_parse_section_letters): Support T in section flags (SHF_TLS).
(obj_elf_parse_section_letters): Include T in error message.
* config/tc-ppc.c (ppc_section_letter): Likewise.
* config/tc-alpha.c (alpha_elf_section_letter): Likewise.
(tc_gen_reloc): Handle SEC_THREAD_LOCAL the same way as
SEC_MERGE.
* config/tc-sparc.c (md_apply_fix3): Likewise.
* config/tc-i386.c (tc_i386_fix_adjustable): Add TLS relocs.
Define them if not BFD_ASSEMBLER.
(lex_got): Support @TLSGD, @TLSLDM, @GOTTPOFF, @TPOFF, @DTPOFF
and @NTPOFF.
(md_apply_fix3): Add TLS relocs.
* config/tc-ia64.c (enum reloc_func): Add FUNC_DTP_MODULE,
FUNC_DTP_RELATIVE, FUNC_TP_RELATIVE, FUNC_LT_DTP_MODULE,
FUNC_LT_DTP_RELATIVE, FUNC_LT_TP_RELATIVE.
(pseudo_func): Support @dtpmod(), @dtprel() and @tprel().
(ia64_elf_section_letter): Include T in error message.
(md_begin): Support TLS operators.
(md_operand): Likewise.
(ia64_gen_real_reloc_type): Support TLS relocs.
* testsuite/gas/i386/tlspic.s: New file.
* testsuite/gas/i386/tlsd.s: New file.
* testsuite/gas/i386/tlsnopic.s: New file.
* testsuite/gas/i386/tlsd.d: New file.
* testsuite/gas/i386/tlsnopic.d: New file.
* testsuite/gas/i386/tlspic.d: New file.
* testsuite/gas/i386/i386.exp: Add tlsd, tlsnopic and tlspic tests.
* testsuite/gas/ia64/tls.s: New file.
* testsuite/gas/ia64/tls.d: New file.
* testsuite/gas/ia64/ia64.exp: Add tls test.
* write.c (adjust_reloc_syms): Don't change symbols in
SEC_THREAD_LOCAL sections to STT_SECTION + addend.
* elf/common.h (PT_TLS, SHF_TLS, STT_TLS, DF_STATIC_TLS): Define.
* elf/ia64.h (R_IA64_LTOFF_TPREL22): Renamed from R_IA64_LTOFF_TP22.
* elf/i386.h: Add TLS relocs.
* scripttempl/elf.sc: Add .rel{,a}.t{bss,data}, .tdata and .tbss.
* ldlang.c (lang_add_section): Set SEC_THREAD_LOCAL for
output section if necessary. Handle .tbss.
(lang_size_sections): Clear _raw_size for .tbss section
(it allocates space in PT_TLS segment only).
* ldwrite.c (build_link_order): Build link order for .tbss too.
* readelf.c (get_segment_type): Add PT_TLS.
(get_elf_section_flags): Add SHF_TLS.
(get_dynamic_flags): Optimize. Add DF_STATIC_TLS.
(process_dynamic_segment): Use puts instead of printf.
(get_symbol_type): Support STT_TLS.
* objdump.c (dump_section_header): Remove SEC_CONSTRUCTOR_TEXT,
SEC_CONSTRUCTOR_DATA, SEC_CONSTRUCTOR_BSS.
Add SEC_THREAD_LOCAL.
2002-05-23 15:12:53 +02:00
|
|
|
|
PF (SEC_THREAD_LOCAL, "THREAD_LOCAL");
|
2005-04-17 16:33:06 +02:00
|
|
|
|
PF (SEC_GROUP, "GROUP");
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
if ((section->flags & SEC_LINK_ONCE) != 0)
|
|
|
|
|
{
|
|
|
|
|
const char *ls;
|
2004-07-21 17:42:58 +02:00
|
|
|
|
struct coff_comdat_info *comdat;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
switch (section->flags & SEC_LINK_DUPLICATES)
|
|
|
|
|
{
|
|
|
|
|
default:
|
|
|
|
|
abort ();
|
|
|
|
|
case SEC_LINK_DUPLICATES_DISCARD:
|
|
|
|
|
ls = "LINK_ONCE_DISCARD";
|
|
|
|
|
break;
|
|
|
|
|
case SEC_LINK_DUPLICATES_ONE_ONLY:
|
|
|
|
|
ls = "LINK_ONCE_ONE_ONLY";
|
|
|
|
|
break;
|
|
|
|
|
case SEC_LINK_DUPLICATES_SAME_SIZE:
|
|
|
|
|
ls = "LINK_ONCE_SAME_SIZE";
|
|
|
|
|
break;
|
|
|
|
|
case SEC_LINK_DUPLICATES_SAME_CONTENTS:
|
|
|
|
|
ls = "LINK_ONCE_SAME_CONTENTS";
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
printf ("%s%s", comma, ls);
|
1999-09-12 20:39:32 +02:00
|
|
|
|
|
2004-07-21 17:42:58 +02:00
|
|
|
|
comdat = bfd_coff_get_comdat_section (abfd, section);
|
|
|
|
|
if (comdat != NULL)
|
|
|
|
|
printf (" (COMDAT %s %ld)", comdat->name, comdat->symbol);
|
1999-09-12 20:39:32 +02:00
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
comma = ", ";
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
printf ("\n");
|
|
|
|
|
#undef PF
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2003-07-29 17:40:37 +02:00
|
|
|
|
dump_headers (bfd *abfd)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
printf (_("Sections:\n"));
|
1999-09-12 20:49:47 +02:00
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
#ifndef BFD64
|
1999-09-12 20:49:47 +02:00
|
|
|
|
printf (_("Idx Name Size VMA LMA File off Algn"));
|
1999-05-03 09:29:11 +02:00
|
|
|
|
#else
|
2002-05-21 18:21:18 +02:00
|
|
|
|
/* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
|
|
|
|
|
if (bfd_get_arch_size (abfd) == 32)
|
|
|
|
|
printf (_("Idx Name Size VMA LMA File off Algn"));
|
|
|
|
|
else
|
|
|
|
|
printf (_("Idx Name Size VMA LMA File off Algn"));
|
1999-05-03 09:29:11 +02:00
|
|
|
|
#endif
|
1999-09-12 20:49:47 +02:00
|
|
|
|
|
|
|
|
|
if (wide_output)
|
|
|
|
|
printf (_(" Flags"));
|
2002-08-28 12:38:51 +02:00
|
|
|
|
if (abfd->flags & HAS_LOAD_PAGE)
|
|
|
|
|
printf (_(" Pg"));
|
1999-09-12 20:49:47 +02:00
|
|
|
|
printf ("\n");
|
|
|
|
|
|
2003-07-29 17:40:37 +02:00
|
|
|
|
bfd_map_over_sections (abfd, dump_section_header, NULL);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static asymbol **
|
2003-07-29 17:40:37 +02:00
|
|
|
|
slurp_symtab (bfd *abfd)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2003-08-05 16:40:54 +02:00
|
|
|
|
asymbol **sy = NULL;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
long storage;
|
|
|
|
|
|
|
|
|
|
if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
|
|
|
|
|
{
|
|
|
|
|
symcount = 0;
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
storage = bfd_get_symtab_upper_bound (abfd);
|
|
|
|
|
if (storage < 0)
|
|
|
|
|
bfd_fatal (bfd_get_filename (abfd));
|
|
|
|
|
if (storage)
|
2009-09-10 15:40:44 +02:00
|
|
|
|
sy = (asymbol **) xmalloc (storage);
|
2002-06-03 15:02:04 +02:00
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
symcount = bfd_canonicalize_symtab (abfd, sy);
|
|
|
|
|
if (symcount < 0)
|
|
|
|
|
bfd_fatal (bfd_get_filename (abfd));
|
|
|
|
|
return sy;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Read in the dynamic symbols. */
|
|
|
|
|
|
|
|
|
|
static asymbol **
|
2003-07-29 17:40:37 +02:00
|
|
|
|
slurp_dynamic_symtab (bfd *abfd)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2003-08-05 16:40:54 +02:00
|
|
|
|
asymbol **sy = NULL;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
long storage;
|
|
|
|
|
|
|
|
|
|
storage = bfd_get_dynamic_symtab_upper_bound (abfd);
|
|
|
|
|
if (storage < 0)
|
|
|
|
|
{
|
|
|
|
|
if (!(bfd_get_file_flags (abfd) & DYNAMIC))
|
|
|
|
|
{
|
2000-04-07 06:34:50 +02:00
|
|
|
|
non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd));
|
1999-05-03 09:29:11 +02:00
|
|
|
|
dynsymcount = 0;
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bfd_fatal (bfd_get_filename (abfd));
|
|
|
|
|
}
|
|
|
|
|
if (storage)
|
2009-09-10 15:40:44 +02:00
|
|
|
|
sy = (asymbol **) xmalloc (storage);
|
2002-06-03 15:02:04 +02:00
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
dynsymcount = bfd_canonicalize_dynamic_symtab (abfd, sy);
|
|
|
|
|
if (dynsymcount < 0)
|
|
|
|
|
bfd_fatal (bfd_get_filename (abfd));
|
|
|
|
|
return sy;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Filter out (in place) symbols that are useless for disassembly.
|
|
|
|
|
COUNT is the number of elements in SYMBOLS.
|
2002-05-21 21:34:58 +02:00
|
|
|
|
Return the number of useful symbols. */
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
static long
|
2003-07-29 17:40:37 +02:00
|
|
|
|
remove_useless_symbols (asymbol **symbols, long count)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2003-07-29 17:40:37 +02:00
|
|
|
|
asymbol **in_ptr = symbols, **out_ptr = symbols;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
while (--count >= 0)
|
|
|
|
|
{
|
|
|
|
|
asymbol *sym = *in_ptr++;
|
|
|
|
|
|
|
|
|
|
if (sym->name == NULL || sym->name[0] == '\0')
|
|
|
|
|
continue;
|
2004-12-30 23:33:20 +01:00
|
|
|
|
if (sym->flags & (BSF_DEBUGGING | BSF_SECTION_SYM))
|
1999-05-03 09:29:11 +02:00
|
|
|
|
continue;
|
|
|
|
|
if (bfd_is_und_section (sym->section)
|
|
|
|
|
|| bfd_is_com_section (sym->section))
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
*out_ptr++ = sym;
|
|
|
|
|
}
|
|
|
|
|
return out_ptr - symbols;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Sort symbols into value order. */
|
|
|
|
|
|
2002-05-21 21:34:58 +02:00
|
|
|
|
static int
|
2003-07-29 17:40:37 +02:00
|
|
|
|
compare_symbols (const void *ap, const void *bp)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2003-07-29 17:40:37 +02:00
|
|
|
|
const asymbol *a = * (const asymbol **) ap;
|
|
|
|
|
const asymbol *b = * (const asymbol **) bp;
|
|
|
|
|
const char *an;
|
|
|
|
|
const char *bn;
|
|
|
|
|
size_t anl;
|
|
|
|
|
size_t bnl;
|
|
|
|
|
bfd_boolean af;
|
|
|
|
|
bfd_boolean bf;
|
|
|
|
|
flagword aflags;
|
|
|
|
|
flagword bflags;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
if (bfd_asymbol_value (a) > bfd_asymbol_value (b))
|
|
|
|
|
return 1;
|
|
|
|
|
else if (bfd_asymbol_value (a) < bfd_asymbol_value (b))
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
if (a->section > b->section)
|
|
|
|
|
return 1;
|
|
|
|
|
else if (a->section < b->section)
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
an = bfd_asymbol_name (a);
|
|
|
|
|
bn = bfd_asymbol_name (b);
|
|
|
|
|
anl = strlen (an);
|
|
|
|
|
bnl = strlen (bn);
|
|
|
|
|
|
|
|
|
|
/* The symbols gnu_compiled and gcc2_compiled convey no real
|
|
|
|
|
information, so put them after other symbols with the same value. */
|
|
|
|
|
af = (strstr (an, "gnu_compiled") != NULL
|
|
|
|
|
|| strstr (an, "gcc2_compiled") != NULL);
|
|
|
|
|
bf = (strstr (bn, "gnu_compiled") != NULL
|
|
|
|
|
|| strstr (bn, "gcc2_compiled") != NULL);
|
|
|
|
|
|
|
|
|
|
if (af && ! bf)
|
|
|
|
|
return 1;
|
|
|
|
|
if (! af && bf)
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
/* We use a heuristic for the file name, to try to sort it after
|
|
|
|
|
more useful symbols. It may not work on non Unix systems, but it
|
|
|
|
|
doesn't really matter; the only difference is precisely which
|
|
|
|
|
symbol names get printed. */
|
|
|
|
|
|
|
|
|
|
#define file_symbol(s, sn, snl) \
|
|
|
|
|
(((s)->flags & BSF_FILE) != 0 \
|
|
|
|
|
|| ((sn)[(snl) - 2] == '.' \
|
|
|
|
|
&& ((sn)[(snl) - 1] == 'o' \
|
|
|
|
|
|| (sn)[(snl) - 1] == 'a')))
|
|
|
|
|
|
|
|
|
|
af = file_symbol (a, an, anl);
|
|
|
|
|
bf = file_symbol (b, bn, bnl);
|
|
|
|
|
|
|
|
|
|
if (af && ! bf)
|
|
|
|
|
return 1;
|
|
|
|
|
if (! af && bf)
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
/* Try to sort global symbols before local symbols before function
|
|
|
|
|
symbols before debugging symbols. */
|
|
|
|
|
|
|
|
|
|
aflags = a->flags;
|
|
|
|
|
bflags = b->flags;
|
|
|
|
|
|
|
|
|
|
if ((aflags & BSF_DEBUGGING) != (bflags & BSF_DEBUGGING))
|
|
|
|
|
{
|
|
|
|
|
if ((aflags & BSF_DEBUGGING) != 0)
|
|
|
|
|
return 1;
|
|
|
|
|
else
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
if ((aflags & BSF_FUNCTION) != (bflags & BSF_FUNCTION))
|
|
|
|
|
{
|
|
|
|
|
if ((aflags & BSF_FUNCTION) != 0)
|
|
|
|
|
return -1;
|
|
|
|
|
else
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
if ((aflags & BSF_LOCAL) != (bflags & BSF_LOCAL))
|
|
|
|
|
{
|
|
|
|
|
if ((aflags & BSF_LOCAL) != 0)
|
|
|
|
|
return 1;
|
|
|
|
|
else
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
if ((aflags & BSF_GLOBAL) != (bflags & BSF_GLOBAL))
|
|
|
|
|
{
|
|
|
|
|
if ((aflags & BSF_GLOBAL) != 0)
|
|
|
|
|
return -1;
|
|
|
|
|
else
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Symbols that start with '.' might be section names, so sort them
|
|
|
|
|
after symbols that don't start with '.'. */
|
|
|
|
|
if (an[0] == '.' && bn[0] != '.')
|
|
|
|
|
return 1;
|
|
|
|
|
if (an[0] != '.' && bn[0] == '.')
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
/* Finally, if we can't distinguish them in any other way, try to
|
|
|
|
|
get consistent results by sorting the symbols by name. */
|
|
|
|
|
return strcmp (an, bn);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Sort relocs into address order. */
|
|
|
|
|
|
|
|
|
|
static int
|
2003-07-29 17:40:37 +02:00
|
|
|
|
compare_relocs (const void *ap, const void *bp)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2003-07-29 17:40:37 +02:00
|
|
|
|
const arelent *a = * (const arelent **) ap;
|
|
|
|
|
const arelent *b = * (const arelent **) bp;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
if (a->address > b->address)
|
|
|
|
|
return 1;
|
|
|
|
|
else if (a->address < b->address)
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
/* So that associated relocations tied to the same address show up
|
|
|
|
|
in the correct order, we don't do any further sorting. */
|
|
|
|
|
if (a > b)
|
|
|
|
|
return 1;
|
|
|
|
|
else if (a < b)
|
|
|
|
|
return -1;
|
|
|
|
|
else
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2003-09-03 10:26:52 +02:00
|
|
|
|
/* Print an address (VMA) to the output stream in INFO.
|
|
|
|
|
If SKIP_ZEROES is TRUE, omit leading zeroes. */
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
static void
|
2003-07-29 17:40:37 +02:00
|
|
|
|
objdump_print_value (bfd_vma vma, struct disassemble_info *info,
|
|
|
|
|
bfd_boolean skip_zeroes)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
char buf[30];
|
|
|
|
|
char *p;
|
2003-11-19 09:21:14 +01:00
|
|
|
|
struct objdump_disasm_info *aux;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2003-11-19 09:21:14 +01:00
|
|
|
|
aux = (struct objdump_disasm_info *) info->application_data;
|
2001-08-10 18:43:18 +02:00
|
|
|
|
bfd_sprintf_vma (aux->abfd, buf, vma);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
if (! skip_zeroes)
|
|
|
|
|
p = buf;
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
for (p = buf; *p == '0'; ++p)
|
|
|
|
|
;
|
|
|
|
|
if (*p == '\0')
|
|
|
|
|
--p;
|
|
|
|
|
}
|
|
|
|
|
(*info->fprintf_func) (info->stream, "%s", p);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Print the name of a symbol. */
|
|
|
|
|
|
|
|
|
|
static void
|
2003-07-29 17:40:37 +02:00
|
|
|
|
objdump_print_symname (bfd *abfd, struct disassemble_info *info,
|
|
|
|
|
asymbol *sym)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
char *alloc;
|
|
|
|
|
const char *name;
|
|
|
|
|
|
|
|
|
|
alloc = NULL;
|
|
|
|
|
name = bfd_asymbol_name (sym);
|
2002-07-02 06:21:25 +02:00
|
|
|
|
if (do_demangle && name[0] != '\0')
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
/* Demangle the name. */
|
2007-04-19 12:43:47 +02:00
|
|
|
|
alloc = bfd_demangle (abfd, name, DMGL_ANSI | DMGL_PARAMS);
|
|
|
|
|
if (alloc != NULL)
|
|
|
|
|
name = alloc;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (info != NULL)
|
2002-07-02 06:21:25 +02:00
|
|
|
|
(*info->fprintf_func) (info->stream, "%s", name);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
else
|
2002-07-02 06:21:25 +02:00
|
|
|
|
printf ("%s", name);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
if (alloc != NULL)
|
|
|
|
|
free (alloc);
|
|
|
|
|
}
|
|
|
|
|
|
2003-11-14 16:12:44 +01:00
|
|
|
|
/* Locate a symbol given a bfd and a section (from INFO->application_data),
|
|
|
|
|
and a VMA. If INFO->application_data->require_sec is TRUE, then always
|
|
|
|
|
require the symbol to be in the section. Returns NULL if there is no
|
|
|
|
|
suitable symbol. If PLACE is not NULL, then *PLACE is set to the index
|
|
|
|
|
of the symbol in sorted_syms. */
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
static asymbol *
|
2003-11-19 09:21:14 +01:00
|
|
|
|
find_symbol_for_address (bfd_vma vma,
|
|
|
|
|
struct disassemble_info *info,
|
|
|
|
|
long *place)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
/* @@ 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. */
|
|
|
|
|
|
|
|
|
|
/* Indices in `sorted_syms'. */
|
|
|
|
|
long min = 0;
|
|
|
|
|
long max = sorted_symcount;
|
|
|
|
|
long thisplace;
|
2003-11-19 09:21:14 +01:00
|
|
|
|
struct objdump_disasm_info *aux;
|
|
|
|
|
bfd *abfd;
|
|
|
|
|
asection *sec;
|
|
|
|
|
unsigned int opb;
|
2007-05-22 17:05:12 +02:00
|
|
|
|
bfd_boolean want_section;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
if (sorted_symcount < 1)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
2003-11-19 09:21:14 +01:00
|
|
|
|
aux = (struct objdump_disasm_info *) info->application_data;
|
|
|
|
|
abfd = aux->abfd;
|
|
|
|
|
sec = aux->sec;
|
2009-08-24 20:43:50 +02:00
|
|
|
|
opb = info->octets_per_byte;
|
2003-11-19 09:21:14 +01:00
|
|
|
|
|
1999-05-03 09:29:11 +02: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)
|
|
|
|
|
{
|
|
|
|
|
asymbol *sym;
|
|
|
|
|
|
|
|
|
|
thisplace = (max + min) / 2;
|
|
|
|
|
sym = sorted_syms[thisplace];
|
|
|
|
|
|
|
|
|
|
if (bfd_asymbol_value (sym) > vma)
|
|
|
|
|
max = thisplace;
|
|
|
|
|
else if (bfd_asymbol_value (sym) < vma)
|
|
|
|
|
min = thisplace;
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
min = thisplace;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* The symbol we want is now in min, the low end of the range we
|
|
|
|
|
were searching. If there are several symbols with the same
|
|
|
|
|
value, we want the first one. */
|
|
|
|
|
thisplace = min;
|
|
|
|
|
while (thisplace > 0
|
|
|
|
|
&& (bfd_asymbol_value (sorted_syms[thisplace])
|
|
|
|
|
== bfd_asymbol_value (sorted_syms[thisplace - 1])))
|
|
|
|
|
--thisplace;
|
|
|
|
|
|
2008-07-07 06:37:53 +02:00
|
|
|
|
/* Prefer a symbol in the current section if we have multple symbols
|
|
|
|
|
with the same value, as can occur with overlays or zero size
|
|
|
|
|
sections. */
|
|
|
|
|
min = thisplace;
|
|
|
|
|
while (min < max
|
|
|
|
|
&& (bfd_asymbol_value (sorted_syms[min])
|
|
|
|
|
== bfd_asymbol_value (sorted_syms[thisplace])))
|
|
|
|
|
{
|
|
|
|
|
if (sorted_syms[min]->section == sec
|
|
|
|
|
&& info->symbol_is_valid (sorted_syms[min], info))
|
|
|
|
|
{
|
|
|
|
|
thisplace = min;
|
|
|
|
|
|
|
|
|
|
if (place != NULL)
|
|
|
|
|
*place = thisplace;
|
|
|
|
|
|
|
|
|
|
return sorted_syms[thisplace];
|
|
|
|
|
}
|
|
|
|
|
++min;
|
|
|
|
|
}
|
|
|
|
|
|
2003-06-25 08:40:27 +02:00
|
|
|
|
/* If the file is relocatable, and the symbol could be from this
|
1999-05-03 09:29:11 +02:00
|
|
|
|
section, prefer a symbol from this section over symbols from
|
|
|
|
|
others, even if the other symbol's value might be closer.
|
2002-05-21 21:34:58 +02:00
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
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
|
2007-05-22 17:05:12 +02:00
|
|
|
|
table.
|
|
|
|
|
|
|
|
|
|
Also give the target a chance to reject symbols. */
|
|
|
|
|
want_section = (aux->require_sec
|
|
|
|
|
|| ((abfd->flags & HAS_RELOC) != 0
|
|
|
|
|
&& vma >= bfd_get_section_vma (abfd, sec)
|
|
|
|
|
&& vma < (bfd_get_section_vma (abfd, sec)
|
|
|
|
|
+ bfd_section_size (abfd, sec) / opb)));
|
|
|
|
|
if ((sorted_syms[thisplace]->section != sec && want_section)
|
|
|
|
|
|| !info->symbol_is_valid (sorted_syms[thisplace], info))
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
long i;
|
2008-07-07 06:37:53 +02:00
|
|
|
|
long newplace = sorted_symcount;
|
2003-03-17 12:16:51 +01:00
|
|
|
|
|
2008-07-07 06:37:53 +02:00
|
|
|
|
for (i = min - 1; i >= 0; i--)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2007-05-22 17:05:12 +02:00
|
|
|
|
if ((sorted_syms[i]->section == sec || !want_section)
|
|
|
|
|
&& info->symbol_is_valid (sorted_syms[i], info))
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2007-05-22 17:05:12 +02:00
|
|
|
|
if (newplace == sorted_symcount)
|
|
|
|
|
newplace = i;
|
|
|
|
|
|
|
|
|
|
if (bfd_asymbol_value (sorted_syms[i])
|
|
|
|
|
!= bfd_asymbol_value (sorted_syms[newplace]))
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/* Remember this symbol and keep searching until we reach
|
|
|
|
|
an earlier address. */
|
|
|
|
|
newplace = i;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2007-05-22 17:05:12 +02:00
|
|
|
|
if (newplace != sorted_symcount)
|
|
|
|
|
thisplace = newplace;
|
|
|
|
|
else
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
/* We didn't find a good symbol with a smaller value.
|
|
|
|
|
Look for one with a larger value. */
|
|
|
|
|
for (i = thisplace + 1; i < sorted_symcount; i++)
|
|
|
|
|
{
|
2007-05-22 17:05:12 +02:00
|
|
|
|
if ((sorted_syms[i]->section == sec || !want_section)
|
|
|
|
|
&& info->symbol_is_valid (sorted_syms[i], info))
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
thisplace = i;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2007-05-22 17:05:12 +02:00
|
|
|
|
if ((sorted_syms[thisplace]->section != sec && want_section)
|
|
|
|
|
|| !info->symbol_is_valid (sorted_syms[thisplace], info))
|
2003-11-14 16:12:44 +01:00
|
|
|
|
/* There is no suitable symbol. */
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
if (place != NULL)
|
|
|
|
|
*place = thisplace;
|
|
|
|
|
|
|
|
|
|
return sorted_syms[thisplace];
|
|
|
|
|
}
|
|
|
|
|
|
2003-09-03 10:26:52 +02:00
|
|
|
|
/* Print an address and the offset to the nearest symbol. */
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
static void
|
2003-07-29 17:40:37 +02:00
|
|
|
|
objdump_print_addr_with_sym (bfd *abfd, asection *sec, asymbol *sym,
|
|
|
|
|
bfd_vma vma, struct disassemble_info *info,
|
|
|
|
|
bfd_boolean skip_zeroes)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
objdump_print_value (vma, info, skip_zeroes);
|
|
|
|
|
|
|
|
|
|
if (sym == NULL)
|
|
|
|
|
{
|
|
|
|
|
bfd_vma secaddr;
|
|
|
|
|
|
|
|
|
|
(*info->fprintf_func) (info->stream, " <%s",
|
|
|
|
|
bfd_get_section_name (abfd, sec));
|
|
|
|
|
secaddr = bfd_get_section_vma (abfd, sec);
|
|
|
|
|
if (vma < secaddr)
|
|
|
|
|
{
|
|
|
|
|
(*info->fprintf_func) (info->stream, "-0x");
|
2002-11-30 09:39:46 +01:00
|
|
|
|
objdump_print_value (secaddr - vma, info, TRUE);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
else if (vma > secaddr)
|
|
|
|
|
{
|
|
|
|
|
(*info->fprintf_func) (info->stream, "+0x");
|
2002-11-30 09:39:46 +01:00
|
|
|
|
objdump_print_value (vma - secaddr, info, TRUE);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
(*info->fprintf_func) (info->stream, ">");
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
(*info->fprintf_func) (info->stream, " <");
|
|
|
|
|
objdump_print_symname (abfd, info, sym);
|
|
|
|
|
if (bfd_asymbol_value (sym) > vma)
|
|
|
|
|
{
|
|
|
|
|
(*info->fprintf_func) (info->stream, "-0x");
|
2002-11-30 09:39:46 +01:00
|
|
|
|
objdump_print_value (bfd_asymbol_value (sym) - vma, info, TRUE);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
else if (vma > bfd_asymbol_value (sym))
|
|
|
|
|
{
|
|
|
|
|
(*info->fprintf_func) (info->stream, "+0x");
|
2002-11-30 09:39:46 +01:00
|
|
|
|
objdump_print_value (vma - bfd_asymbol_value (sym), info, TRUE);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
(*info->fprintf_func) (info->stream, ">");
|
|
|
|
|
}
|
2008-02-22 10:42:58 +01:00
|
|
|
|
|
|
|
|
|
if (display_file_offsets)
|
2008-02-26 09:44:10 +01:00
|
|
|
|
info->fprintf_func (info->stream, _(" (File Offset: 0x%lx)"),
|
2008-02-22 10:42:58 +01:00
|
|
|
|
(long int)(sec->filepos + (vma - sec->vma)));
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
2003-09-03 10:26:52 +02:00
|
|
|
|
/* Print an address (VMA), symbolically if possible.
|
|
|
|
|
If SKIP_ZEROES is TRUE, don't output leading zeroes. */
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
static void
|
2003-11-19 09:21:14 +01:00
|
|
|
|
objdump_print_addr (bfd_vma vma,
|
|
|
|
|
struct disassemble_info *info,
|
2003-07-29 17:40:37 +02:00
|
|
|
|
bfd_boolean skip_zeroes)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2003-11-19 09:21:14 +01:00
|
|
|
|
struct objdump_disasm_info *aux;
|
2008-03-01 08:19:06 +01:00
|
|
|
|
asymbol *sym = NULL;
|
2005-03-01 16:18:44 +01:00
|
|
|
|
bfd_boolean skip_find = FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2008-02-26 09:44:10 +01:00
|
|
|
|
aux = (struct objdump_disasm_info *) info->application_data;
|
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
if (sorted_symcount < 1)
|
|
|
|
|
{
|
|
|
|
|
(*info->fprintf_func) (info->stream, "0x");
|
|
|
|
|
objdump_print_value (vma, info, skip_zeroes);
|
2008-02-26 09:44:10 +01:00
|
|
|
|
|
|
|
|
|
if (display_file_offsets)
|
|
|
|
|
info->fprintf_func (info->stream, _(" (File Offset: 0x%lx)"),
|
|
|
|
|
(long int)(aux->sec->filepos + (vma - aux->sec->vma)));
|
1999-05-03 09:29:11 +02:00
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2005-03-01 16:18:44 +01:00
|
|
|
|
if (aux->reloc != NULL
|
|
|
|
|
&& aux->reloc->sym_ptr_ptr != NULL
|
|
|
|
|
&& * aux->reloc->sym_ptr_ptr != NULL)
|
|
|
|
|
{
|
|
|
|
|
sym = * aux->reloc->sym_ptr_ptr;
|
|
|
|
|
|
|
|
|
|
/* Adjust the vma to the reloc. */
|
|
|
|
|
vma += bfd_asymbol_value (sym);
|
|
|
|
|
|
|
|
|
|
if (bfd_is_und_section (bfd_get_section (sym)))
|
|
|
|
|
skip_find = TRUE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!skip_find)
|
|
|
|
|
sym = find_symbol_for_address (vma, info, NULL);
|
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
objdump_print_addr_with_sym (aux->abfd, aux->sec, sym, vma, info,
|
|
|
|
|
skip_zeroes);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Print VMA to INFO. This function is passed to the disassembler
|
|
|
|
|
routine. */
|
|
|
|
|
|
|
|
|
|
static void
|
2003-07-29 17:40:37 +02:00
|
|
|
|
objdump_print_address (bfd_vma vma, struct disassemble_info *info)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
objdump_print_addr (vma, info, ! prefix_addresses);
|
|
|
|
|
}
|
|
|
|
|
|
2006-04-12 15:05:36 +02:00
|
|
|
|
/* Determine if the given address has a symbol associated with it. */
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
static int
|
2003-07-29 17:40:37 +02:00
|
|
|
|
objdump_symbol_at_address (bfd_vma vma, struct disassemble_info * info)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
asymbol * sym;
|
|
|
|
|
|
2003-11-14 16:12:44 +01:00
|
|
|
|
sym = find_symbol_for_address (vma, info, NULL);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
return (sym != NULL && (bfd_asymbol_value (sym) == vma));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Hold the last function name and the last line number we displayed
|
|
|
|
|
in a disassembly. */
|
|
|
|
|
|
|
|
|
|
static char *prev_functionname;
|
|
|
|
|
static unsigned int prev_line;
|
|
|
|
|
|
|
|
|
|
/* We keep a list of all files that we have seen when doing a
|
2003-10-27 14:20:32 +01:00
|
|
|
|
disassembly with source, so that we know how much of the file to
|
1999-05-03 09:29:11 +02:00
|
|
|
|
display. This can be important for inlined functions. */
|
|
|
|
|
|
|
|
|
|
struct print_file_list
|
|
|
|
|
{
|
|
|
|
|
struct print_file_list *next;
|
2003-08-04 16:29:34 +02:00
|
|
|
|
const char *filename;
|
|
|
|
|
const char *modname;
|
2007-06-18 18:38:49 +02:00
|
|
|
|
const char *map;
|
|
|
|
|
size_t mapsize;
|
|
|
|
|
const char **linemap;
|
|
|
|
|
unsigned maxline;
|
|
|
|
|
unsigned last_line;
|
|
|
|
|
int first;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static struct print_file_list *print_files;
|
|
|
|
|
|
|
|
|
|
/* The number of preceding context lines to show when we start
|
|
|
|
|
displaying a file for the first time. */
|
|
|
|
|
|
|
|
|
|
#define SHOW_PRECEDING_CONTEXT_LINES (5)
|
|
|
|
|
|
2008-04-28 10:30:23 +02:00
|
|
|
|
/* Read a complete file into memory. */
|
2007-06-18 18:38:49 +02:00
|
|
|
|
|
|
|
|
|
static const char *
|
|
|
|
|
slurp_file (const char *fn, size_t *size)
|
|
|
|
|
{
|
|
|
|
|
#ifdef HAVE_MMAP
|
|
|
|
|
int ps = getpagesize ();
|
|
|
|
|
size_t msize;
|
|
|
|
|
#endif
|
|
|
|
|
const char *map;
|
|
|
|
|
struct stat st;
|
2008-04-28 10:30:23 +02:00
|
|
|
|
int fd = open (fn, O_RDONLY | O_BINARY);
|
2007-06-18 18:38:49 +02:00
|
|
|
|
|
|
|
|
|
if (fd < 0)
|
|
|
|
|
return NULL;
|
|
|
|
|
if (fstat (fd, &st) < 0)
|
|
|
|
|
return NULL;
|
|
|
|
|
*size = st.st_size;
|
|
|
|
|
#ifdef HAVE_MMAP
|
|
|
|
|
msize = (*size + ps - 1) & ~(ps - 1);
|
|
|
|
|
map = mmap (NULL, msize, PROT_READ, MAP_SHARED, fd, 0);
|
|
|
|
|
if (map != (char *)-1L)
|
|
|
|
|
{
|
|
|
|
|
close(fd);
|
|
|
|
|
return map;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
2009-09-10 15:40:44 +02:00
|
|
|
|
map = (const char *) malloc (*size);
|
2007-06-18 18:38:49 +02:00
|
|
|
|
if (!map || (size_t) read (fd, (char *)map, *size) != *size)
|
|
|
|
|
{
|
|
|
|
|
free ((void *)map);
|
|
|
|
|
map = NULL;
|
|
|
|
|
}
|
|
|
|
|
close (fd);
|
|
|
|
|
return map;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#define line_map_decrease 5
|
|
|
|
|
|
|
|
|
|
/* Precompute array of lines for a mapped file. */
|
|
|
|
|
|
|
|
|
|
static const char **
|
|
|
|
|
index_file (const char *map, size_t size, unsigned int *maxline)
|
|
|
|
|
{
|
|
|
|
|
const char *p, *lstart, *end;
|
|
|
|
|
int chars_per_line = 45; /* First iteration will use 40. */
|
|
|
|
|
unsigned int lineno;
|
|
|
|
|
const char **linemap = NULL;
|
|
|
|
|
unsigned long line_map_size = 0;
|
|
|
|
|
|
|
|
|
|
lineno = 0;
|
|
|
|
|
lstart = map;
|
|
|
|
|
end = map + size;
|
|
|
|
|
|
|
|
|
|
for (p = map; p < end; p++)
|
|
|
|
|
{
|
|
|
|
|
if (*p == '\n')
|
|
|
|
|
{
|
|
|
|
|
if (p + 1 < end && p[1] == '\r')
|
|
|
|
|
p++;
|
|
|
|
|
}
|
|
|
|
|
else if (*p == '\r')
|
|
|
|
|
{
|
|
|
|
|
if (p + 1 < end && p[1] == '\n')
|
|
|
|
|
p++;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
/* End of line found. */
|
|
|
|
|
|
|
|
|
|
if (linemap == NULL || line_map_size < lineno + 1)
|
|
|
|
|
{
|
|
|
|
|
unsigned long newsize;
|
|
|
|
|
|
|
|
|
|
chars_per_line -= line_map_decrease;
|
|
|
|
|
if (chars_per_line <= 1)
|
|
|
|
|
chars_per_line = 1;
|
|
|
|
|
line_map_size = size / chars_per_line + 1;
|
|
|
|
|
if (line_map_size < lineno + 1)
|
|
|
|
|
line_map_size = lineno + 1;
|
|
|
|
|
newsize = line_map_size * sizeof (char *);
|
2009-09-10 15:40:44 +02:00
|
|
|
|
linemap = (const char **) xrealloc (linemap, newsize);
|
2007-06-18 18:38:49 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
linemap[lineno++] = lstart;
|
|
|
|
|
lstart = p + 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
*maxline = lineno;
|
|
|
|
|
return linemap;
|
|
|
|
|
}
|
|
|
|
|
|
2003-08-04 16:29:34 +02:00
|
|
|
|
/* Tries to open MODNAME, and if successful adds a node to print_files
|
|
|
|
|
linked list and returns that node. Returns NULL on failure. */
|
|
|
|
|
|
|
|
|
|
static struct print_file_list *
|
|
|
|
|
try_print_file_open (const char *origname, const char *modname)
|
|
|
|
|
{
|
|
|
|
|
struct print_file_list *p;
|
|
|
|
|
|
2009-09-10 15:40:44 +02:00
|
|
|
|
p = (struct print_file_list *) xmalloc (sizeof (struct print_file_list));
|
2003-08-04 16:29:34 +02:00
|
|
|
|
|
2007-06-18 18:38:49 +02:00
|
|
|
|
p->map = slurp_file (modname, &p->mapsize);
|
|
|
|
|
if (p->map == NULL)
|
2003-08-04 16:29:34 +02:00
|
|
|
|
{
|
2007-06-18 18:38:49 +02:00
|
|
|
|
free (p);
|
|
|
|
|
return NULL;
|
2003-08-04 16:29:34 +02:00
|
|
|
|
}
|
2007-06-18 18:38:49 +02:00
|
|
|
|
|
|
|
|
|
p->linemap = index_file (p->map, p->mapsize, &p->maxline);
|
|
|
|
|
p->last_line = 0;
|
2003-08-04 16:29:34 +02:00
|
|
|
|
p->filename = origname;
|
|
|
|
|
p->modname = modname;
|
|
|
|
|
p->next = print_files;
|
2007-06-18 18:38:49 +02:00
|
|
|
|
p->first = 1;
|
2003-08-04 16:29:34 +02:00
|
|
|
|
print_files = p;
|
|
|
|
|
return p;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* If the the source file, as described in the symtab, is not found
|
|
|
|
|
try to locate it in one of the paths specified with -I
|
|
|
|
|
If found, add location to print_files linked list. */
|
|
|
|
|
|
|
|
|
|
static struct print_file_list *
|
|
|
|
|
update_source_path (const char *filename)
|
|
|
|
|
{
|
|
|
|
|
struct print_file_list *p;
|
|
|
|
|
const char *fname;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
if (filename == NULL)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
p = try_print_file_open (filename, filename);
|
|
|
|
|
if (p != NULL)
|
|
|
|
|
return p;
|
|
|
|
|
|
|
|
|
|
if (include_path_count == 0)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
/* Get the name of the file. */
|
|
|
|
|
fname = strrchr (filename, '/');
|
|
|
|
|
#ifdef HAVE_DOS_BASED_FILE_SYSTEM
|
|
|
|
|
{
|
|
|
|
|
/* We could have a mixed forward/back slash case. */
|
|
|
|
|
char *backslash = strrchr (filename, '\\');
|
|
|
|
|
if (fname == NULL || (backslash != NULL && backslash > fname))
|
|
|
|
|
fname = backslash;
|
|
|
|
|
if (fname == NULL && filename[0] != '\0' && filename[1] == ':')
|
|
|
|
|
fname = filename + 1;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
if (fname == NULL)
|
|
|
|
|
fname = filename;
|
|
|
|
|
else
|
|
|
|
|
++fname;
|
|
|
|
|
|
|
|
|
|
/* If file exists under a new path, we need to add it to the list
|
|
|
|
|
so that show_line knows about it. */
|
|
|
|
|
for (i = 0; i < include_path_count; i++)
|
|
|
|
|
{
|
|
|
|
|
char *modname = concat (include_paths[i], "/", fname, (const char *) 0);
|
|
|
|
|
|
|
|
|
|
p = try_print_file_open (filename, modname);
|
|
|
|
|
if (p)
|
|
|
|
|
return p;
|
|
|
|
|
|
|
|
|
|
free (modname);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2007-06-18 18:38:49 +02:00
|
|
|
|
/* Print a source file line. */
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2007-06-18 18:38:49 +02:00
|
|
|
|
static void
|
|
|
|
|
print_line (struct print_file_list *p, unsigned int line)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2007-06-18 18:38:49 +02:00
|
|
|
|
const char *l;
|
2007-10-15 04:00:56 +02:00
|
|
|
|
size_t len;
|
2007-06-18 18:38:49 +02:00
|
|
|
|
|
|
|
|
|
--line;
|
|
|
|
|
if (line >= p->maxline)
|
|
|
|
|
return;
|
|
|
|
|
l = p->linemap [line];
|
2007-10-15 04:00:56 +02:00
|
|
|
|
/* Test fwrite return value to quiet glibc warning. */
|
|
|
|
|
len = strcspn (l, "\n\r");
|
|
|
|
|
if (len == 0 || fwrite (l, len, 1, stdout) == 1)
|
|
|
|
|
putchar ('\n');
|
|
|
|
|
}
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2007-06-18 18:38:49 +02:00
|
|
|
|
/* Print a range of source code lines. */
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2007-06-18 18:38:49 +02:00
|
|
|
|
static void
|
|
|
|
|
dump_lines (struct print_file_list *p, unsigned int start, unsigned int end)
|
|
|
|
|
{
|
|
|
|
|
if (p->map == NULL)
|
|
|
|
|
return;
|
|
|
|
|
while (start <= end)
|
|
|
|
|
{
|
|
|
|
|
print_line (p, start);
|
|
|
|
|
start++;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
2002-05-21 21:34:58 +02:00
|
|
|
|
}
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2003-10-27 14:20:32 +01:00
|
|
|
|
/* Show the line number, or the source line, in a disassembly
|
1999-05-03 09:29:11 +02:00
|
|
|
|
listing. */
|
|
|
|
|
|
|
|
|
|
static void
|
2003-07-29 17:40:37 +02:00
|
|
|
|
show_line (bfd *abfd, asection *section, bfd_vma addr_offset)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2002-06-08 09:38:30 +02:00
|
|
|
|
const char *filename;
|
|
|
|
|
const char *functionname;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
unsigned int line;
|
2009-02-03 16:48:50 +01:00
|
|
|
|
bfd_boolean reloc;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
if (! with_line_numbers && ! with_source_code)
|
|
|
|
|
return;
|
|
|
|
|
|
2000-02-03 19:12:55 +01:00
|
|
|
|
if (! bfd_find_nearest_line (abfd, section, syms, addr_offset, &filename,
|
1999-05-03 09:29:11 +02:00
|
|
|
|
&functionname, &line))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
if (filename != NULL && *filename == '\0')
|
|
|
|
|
filename = NULL;
|
|
|
|
|
if (functionname != NULL && *functionname == '\0')
|
|
|
|
|
functionname = NULL;
|
|
|
|
|
|
2009-02-03 16:48:50 +01:00
|
|
|
|
if (filename
|
|
|
|
|
&& IS_ABSOLUTE_PATH (filename)
|
|
|
|
|
&& prefix)
|
|
|
|
|
{
|
|
|
|
|
char *path_up;
|
|
|
|
|
const char *fname = filename;
|
|
|
|
|
char *path = (char *) alloca (prefix_length + PATH_MAX + 1);
|
|
|
|
|
|
|
|
|
|
if (prefix_length)
|
|
|
|
|
memcpy (path, prefix, prefix_length);
|
|
|
|
|
path_up = path + prefix_length;
|
|
|
|
|
|
|
|
|
|
/* Build relocated filename, stripping off leading directories
|
|
|
|
|
from the initial filename if requested. */
|
|
|
|
|
if (prefix_strip > 0)
|
|
|
|
|
{
|
|
|
|
|
int level = 0;
|
|
|
|
|
const char *s;
|
|
|
|
|
|
|
|
|
|
/* Skip selected directory levels. */
|
|
|
|
|
for (s = fname + 1; *s != '\0' && level < prefix_strip; s++)
|
|
|
|
|
if (IS_DIR_SEPARATOR(*s))
|
|
|
|
|
{
|
|
|
|
|
fname = s;
|
|
|
|
|
level++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Update complete filename. */
|
|
|
|
|
strncpy (path_up, fname, PATH_MAX);
|
|
|
|
|
path_up[PATH_MAX] = '\0';
|
|
|
|
|
|
|
|
|
|
filename = path;
|
|
|
|
|
reloc = TRUE;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
reloc = FALSE;
|
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
if (with_line_numbers)
|
|
|
|
|
{
|
|
|
|
|
if (functionname != NULL
|
|
|
|
|
&& (prev_functionname == NULL
|
|
|
|
|
|| strcmp (functionname, prev_functionname) != 0))
|
|
|
|
|
printf ("%s():\n", functionname);
|
|
|
|
|
if (line > 0 && line != prev_line)
|
|
|
|
|
printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (with_source_code
|
|
|
|
|
&& filename != NULL
|
|
|
|
|
&& line > 0)
|
|
|
|
|
{
|
|
|
|
|
struct print_file_list **pp, *p;
|
2007-06-18 18:38:49 +02:00
|
|
|
|
unsigned l;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
for (pp = &print_files; *pp != NULL; pp = &(*pp)->next)
|
|
|
|
|
if (strcmp ((*pp)->filename, filename) == 0)
|
|
|
|
|
break;
|
|
|
|
|
p = *pp;
|
|
|
|
|
|
2007-06-18 18:38:49 +02:00
|
|
|
|
if (p == NULL)
|
2009-02-03 16:48:50 +01:00
|
|
|
|
{
|
|
|
|
|
if (reloc)
|
|
|
|
|
filename = xstrdup (filename);
|
2003-08-04 16:29:34 +02:00
|
|
|
|
p = update_source_path (filename);
|
2009-02-03 16:48:50 +01:00
|
|
|
|
}
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2007-06-18 18:38:49 +02:00
|
|
|
|
if (p != NULL && line != p->last_line)
|
|
|
|
|
{
|
|
|
|
|
if (file_start_context && p->first)
|
|
|
|
|
l = 1;
|
|
|
|
|
else
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2007-06-18 18:38:49 +02:00
|
|
|
|
l = line - SHOW_PRECEDING_CONTEXT_LINES;
|
|
|
|
|
if (l >= line)
|
|
|
|
|
l = 1;
|
|
|
|
|
if (p->last_line >= l && p->last_line <= line)
|
|
|
|
|
l = p->last_line + 1;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
2007-06-18 18:38:49 +02:00
|
|
|
|
dump_lines (p, l, line);
|
|
|
|
|
p->last_line = line;
|
|
|
|
|
p->first = 0;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (functionname != NULL
|
|
|
|
|
&& (prev_functionname == NULL
|
|
|
|
|
|| strcmp (functionname, prev_functionname) != 0))
|
|
|
|
|
{
|
|
|
|
|
if (prev_functionname != NULL)
|
|
|
|
|
free (prev_functionname);
|
2009-09-10 15:40:44 +02:00
|
|
|
|
prev_functionname = (char *) xmalloc (strlen (functionname) + 1);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
strcpy (prev_functionname, functionname);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (line > 0 && line != prev_line)
|
|
|
|
|
prev_line = line;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Pseudo FILE object for strings. */
|
|
|
|
|
typedef struct
|
|
|
|
|
{
|
|
|
|
|
char *buffer;
|
2004-03-15 13:31:41 +01:00
|
|
|
|
size_t pos;
|
|
|
|
|
size_t alloc;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
} SFILE;
|
|
|
|
|
|
2003-07-29 17:40:37 +02:00
|
|
|
|
/* sprintf to a "stream". */
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
Kaveh Ghazi's printf format attribute checking patch.
bfd:
* elf32-xtensa.c (vsprint_msg): Add format attribute. Fix
format bugs.
* vms.h (_bfd_vms_debug): Add format attribute.
(_bfd_vms_debug, _bfd_hexdump): Fix typos.
binutils:
* bucomm.h (report): Add format attribute.
* dlltool.c (inform): Likewise.
* dllwrap.c (display, inform, warn): Likewise.
* objdump.c (objdump_sprintf): Likewise.
* readelf.c (error, warn): Likewise. Fix format bugs.
gas:
* config/tc-tic30.c (debug): Add format attribute. Fix format
bugs.
include:
* dis-asm.h (fprintf_ftype): Add format attribute.
opcodes:
* arc-dis.c, arm-dis.c, cris-dis.c, crx-dis.c, d10v-dis.c,
d30v-dis.c, fr30-dis.c, h8300-dis.c, h8500-dis.c, i860-dis.c,
ia64-dis.c, ip2k-dis.c, m10200-dis.c, m10300-dis.c,
m88k-dis.c, mcore-dis.c, mips-dis.c, ms1-dis.c, or32-dis.c,
ppc-dis.c, sh64-dis.c, sparc-dis.c, tic4x-dis.c, tic80-dis.c,
v850-dis.c: Fix format bugs.
* ia64-gen.c (fail, warn): Add format attribute.
* or32-opc.c (debug): Likewise.
2005-07-07 21:27:52 +02:00
|
|
|
|
static int ATTRIBUTE_PRINTF_2
|
2003-07-29 17:40:37 +02:00
|
|
|
|
objdump_sprintf (SFILE *f, const char *format, ...)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
size_t n;
|
2003-07-29 17:40:37 +02:00
|
|
|
|
va_list args;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2004-03-15 13:31:41 +01:00
|
|
|
|
while (1)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2004-03-15 13:31:41 +01:00
|
|
|
|
size_t space = f->alloc - f->pos;
|
|
|
|
|
|
|
|
|
|
va_start (args, format);
|
|
|
|
|
n = vsnprintf (f->buffer + f->pos, space, format, args);
|
2001-09-26 03:55:19 +02:00
|
|
|
|
va_end (args);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2004-03-15 13:31:41 +01:00
|
|
|
|
if (space > n)
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
f->alloc = (f->alloc + n) * 2;
|
2009-09-10 15:40:44 +02:00
|
|
|
|
f->buffer = (char *) xrealloc (f->buffer, f->alloc);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
2004-03-15 13:31:41 +01:00
|
|
|
|
f->pos += n;
|
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
return n;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* The number of zeroes we want to see before we start skipping them.
|
|
|
|
|
The number is arbitrarily chosen. */
|
|
|
|
|
|
2005-01-10 10:54:50 +01:00
|
|
|
|
#define DEFAULT_SKIP_ZEROES 8
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
/* The number of zeroes to skip at the end of a section. If the
|
|
|
|
|
number of zeroes at the end is between SKIP_ZEROES_AT_END and
|
|
|
|
|
SKIP_ZEROES, they will be disassembled. If there are fewer than
|
|
|
|
|
SKIP_ZEROES_AT_END, they will be skipped. This is a heuristic
|
|
|
|
|
attempt to avoid disassembling zeroes inserted by section
|
|
|
|
|
alignment. */
|
|
|
|
|
|
2005-01-10 10:54:50 +01:00
|
|
|
|
#define DEFAULT_SKIP_ZEROES_AT_END 3
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
/* Disassemble some data in memory between given values. */
|
|
|
|
|
|
|
|
|
|
static void
|
2003-07-29 17:40:37 +02:00
|
|
|
|
disassemble_bytes (struct disassemble_info * info,
|
|
|
|
|
disassembler_ftype disassemble_fn,
|
|
|
|
|
bfd_boolean insns,
|
|
|
|
|
bfd_byte * data,
|
|
|
|
|
bfd_vma start_offset,
|
|
|
|
|
bfd_vma stop_offset,
|
2003-07-30 05:54:15 +02:00
|
|
|
|
bfd_vma rel_offset,
|
2003-07-29 17:40:37 +02:00
|
|
|
|
arelent *** relppp,
|
|
|
|
|
arelent ** relppend)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
struct objdump_disasm_info *aux;
|
|
|
|
|
asection *section;
|
2000-02-03 19:12:55 +01:00
|
|
|
|
int octets_per_line;
|
2002-11-30 09:39:46 +01:00
|
|
|
|
bfd_boolean done_dot;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
int skip_addr_chars;
|
2000-02-03 19:12:55 +01:00
|
|
|
|
bfd_vma addr_offset;
|
2005-01-10 10:54:50 +01:00
|
|
|
|
unsigned int opb = info->octets_per_byte;
|
|
|
|
|
unsigned int skip_zeroes = info->skip_zeroes;
|
|
|
|
|
unsigned int skip_zeroes_at_end = info->skip_zeroes_at_end;
|
2005-03-01 16:18:44 +01:00
|
|
|
|
int octets = opb;
|
2004-03-15 13:31:41 +01:00
|
|
|
|
SFILE sfile;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
aux = (struct objdump_disasm_info *) info->application_data;
|
|
|
|
|
section = aux->sec;
|
|
|
|
|
|
2004-03-15 13:31:41 +01:00
|
|
|
|
sfile.alloc = 120;
|
2009-09-10 15:40:44 +02:00
|
|
|
|
sfile.buffer = (char *) xmalloc (sfile.alloc);
|
2004-03-15 13:31:41 +01:00
|
|
|
|
sfile.pos = 0;
|
|
|
|
|
|
2009-07-20 15:40:48 +02:00
|
|
|
|
if (insn_width)
|
|
|
|
|
octets_per_line = insn_width;
|
|
|
|
|
else if (insns)
|
2000-02-03 19:12:55 +01:00
|
|
|
|
octets_per_line = 4;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
else
|
2000-02-03 19:12:55 +01:00
|
|
|
|
octets_per_line = 16;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
/* Figure out how many characters to skip at the start of an
|
|
|
|
|
address, to make the disassembly look nicer. We discard leading
|
|
|
|
|
zeroes in chunks of 4, ensuring that there is always a leading
|
|
|
|
|
zero remaining. */
|
|
|
|
|
skip_addr_chars = 0;
|
|
|
|
|
if (! prefix_addresses)
|
|
|
|
|
{
|
|
|
|
|
char buf[30];
|
2008-11-10 09:45:13 +01:00
|
|
|
|
|
|
|
|
|
bfd_sprintf_vma (aux->abfd, buf, section->vma + section->size / opb);
|
|
|
|
|
|
|
|
|
|
while (buf[skip_addr_chars] == '0')
|
|
|
|
|
++skip_addr_chars;
|
|
|
|
|
|
|
|
|
|
/* Don't discard zeros on overflow. */
|
|
|
|
|
if (buf[skip_addr_chars] == '\0' && section->vma != 0)
|
|
|
|
|
skip_addr_chars = 0;
|
|
|
|
|
|
|
|
|
|
if (skip_addr_chars != 0)
|
|
|
|
|
skip_addr_chars = (skip_addr_chars - 1) & -4;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
info->insn_info_valid = 0;
|
|
|
|
|
|
2002-11-30 09:39:46 +01:00
|
|
|
|
done_dot = FALSE;
|
2000-02-03 19:12:55 +01:00
|
|
|
|
addr_offset = start_offset;
|
|
|
|
|
while (addr_offset < stop_offset)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
bfd_vma z;
|
2002-11-30 09:39:46 +01:00
|
|
|
|
bfd_boolean need_nl = FALSE;
|
2005-03-01 16:18:44 +01:00
|
|
|
|
int previous_octets;
|
|
|
|
|
|
|
|
|
|
/* Remember the length of the previous instruction. */
|
|
|
|
|
previous_octets = octets;
|
|
|
|
|
octets = 0;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2000-02-03 19:12:55 +01:00
|
|
|
|
/* If we see more than SKIP_ZEROES octets of zeroes, we just
|
2003-08-04 16:29:34 +02:00
|
|
|
|
print `...'. */
|
2000-02-03 19:12:55 +01:00
|
|
|
|
for (z = addr_offset * opb; z < stop_offset * opb; z++)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
if (data[z] != 0)
|
|
|
|
|
break;
|
|
|
|
|
if (! disassemble_zeroes
|
|
|
|
|
&& (info->insn_info_valid == 0
|
|
|
|
|
|| info->branch_delay_insns == 0)
|
2005-01-10 10:54:50 +01:00
|
|
|
|
&& (z - addr_offset * opb >= skip_zeroes
|
2002-05-21 21:34:58 +02:00
|
|
|
|
|| (z == stop_offset * opb &&
|
2005-01-10 10:54:50 +01:00
|
|
|
|
z - addr_offset * opb < skip_zeroes_at_end)))
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2000-02-03 19:12:55 +01:00
|
|
|
|
/* If there are more nonzero octets to follow, we only skip
|
2003-08-04 16:29:34 +02:00
|
|
|
|
zeroes in multiples of 4, to try to avoid running over
|
|
|
|
|
the start of an instruction which happens to start with
|
|
|
|
|
zero. */
|
2000-02-03 19:12:55 +01:00
|
|
|
|
if (z != stop_offset * opb)
|
|
|
|
|
z = addr_offset * opb + ((z - addr_offset * opb) &~ 3);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2000-02-03 19:12:55 +01:00
|
|
|
|
octets = z - addr_offset * opb;
|
2008-02-22 10:42:58 +01:00
|
|
|
|
|
|
|
|
|
/* If we are going to display more data, and we are displaying
|
|
|
|
|
file offsets, then tell the user how many zeroes we skip
|
|
|
|
|
and the file offset from where we resume dumping. */
|
|
|
|
|
if (display_file_offsets && ((addr_offset + (octets / opb)) < stop_offset))
|
|
|
|
|
printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
|
|
|
|
|
octets / opb,
|
2008-07-30 06:34:58 +02:00
|
|
|
|
(unsigned long) (section->filepos
|
|
|
|
|
+ (addr_offset + (octets / opb))));
|
2008-02-22 10:42:58 +01:00
|
|
|
|
else
|
|
|
|
|
printf ("\t...\n");
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
char buf[50];
|
|
|
|
|
int bpc = 0;
|
|
|
|
|
int pb = 0;
|
|
|
|
|
|
2002-11-30 09:39:46 +01:00
|
|
|
|
done_dot = FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
if (with_line_numbers || with_source_code)
|
2005-08-17 16:28:01 +02:00
|
|
|
|
show_line (aux->abfd, section, addr_offset);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
if (! prefix_addresses)
|
|
|
|
|
{
|
|
|
|
|
char *s;
|
|
|
|
|
|
2001-08-10 18:43:18 +02:00
|
|
|
|
bfd_sprintf_vma (aux->abfd, buf, section->vma + addr_offset);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
for (s = buf + skip_addr_chars; *s == '0'; s++)
|
|
|
|
|
*s = ' ';
|
|
|
|
|
if (*s == '\0')
|
|
|
|
|
*--s = '0';
|
|
|
|
|
printf ("%s:\t", buf + skip_addr_chars);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2002-11-30 09:39:46 +01:00
|
|
|
|
aux->require_sec = TRUE;
|
2000-02-03 19:12:55 +01:00
|
|
|
|
objdump_print_address (section->vma + addr_offset, info);
|
2002-11-30 09:39:46 +01:00
|
|
|
|
aux->require_sec = FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
putchar (' ');
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (insns)
|
|
|
|
|
{
|
2004-03-15 13:31:41 +01:00
|
|
|
|
sfile.pos = 0;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
info->fprintf_func = (fprintf_ftype) objdump_sprintf;
|
2005-03-28 14:28:17 +02:00
|
|
|
|
info->stream = &sfile;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
info->bytes_per_line = 0;
|
|
|
|
|
info->bytes_per_chunk = 0;
|
2009-06-15 13:37:26 +02:00
|
|
|
|
info->flags = disassemble_all ? DISASSEMBLE_DATA : 0;
|
2009-06-18 12:31:21 +02:00
|
|
|
|
if (machine)
|
|
|
|
|
info->flags |= USER_SPECIFIED_MACHINE_TYPE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2006-01-17 18:39:20 +01:00
|
|
|
|
if (info->disassembler_needs_relocs
|
2007-05-21 08:36:01 +02:00
|
|
|
|
&& (bfd_get_file_flags (aux->abfd) & EXEC_P) == 0
|
|
|
|
|
&& (bfd_get_file_flags (aux->abfd) & DYNAMIC) == 0
|
2006-01-17 18:39:20 +01:00
|
|
|
|
&& *relppp < relppend)
|
2005-03-01 16:18:44 +01:00
|
|
|
|
{
|
|
|
|
|
bfd_signed_vma distance_to_rel;
|
|
|
|
|
|
|
|
|
|
distance_to_rel = (**relppp)->address
|
|
|
|
|
- (rel_offset + addr_offset);
|
|
|
|
|
|
|
|
|
|
/* Check to see if the current reloc is associated with
|
|
|
|
|
the instruction that we are about to disassemble. */
|
|
|
|
|
if (distance_to_rel == 0
|
|
|
|
|
/* FIXME: This is wrong. We are trying to catch
|
|
|
|
|
relocs that are addressed part way through the
|
|
|
|
|
current instruction, as might happen with a packed
|
|
|
|
|
VLIW instruction. Unfortunately we do not know the
|
|
|
|
|
length of the current instruction since we have not
|
|
|
|
|
disassembled it yet. Instead we take a guess based
|
|
|
|
|
upon the length of the previous instruction. The
|
|
|
|
|
proper solution is to have a new target-specific
|
|
|
|
|
disassembler function which just returns the length
|
|
|
|
|
of an instruction at a given address without trying
|
|
|
|
|
to display its disassembly. */
|
|
|
|
|
|| (distance_to_rel > 0
|
|
|
|
|
&& distance_to_rel < (bfd_signed_vma) (previous_octets/ opb)))
|
|
|
|
|
{
|
2009-06-15 13:37:26 +02:00
|
|
|
|
info->flags |= INSN_HAS_RELOC;
|
2005-03-01 16:18:44 +01:00
|
|
|
|
aux->reloc = **relppp;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
aux->reloc = NULL;
|
|
|
|
|
}
|
2006-01-17 18:39:20 +01:00
|
|
|
|
|
2000-02-03 19:12:55 +01:00
|
|
|
|
octets = (*disassemble_fn) (section->vma + addr_offset, info);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
info->fprintf_func = (fprintf_ftype) fprintf;
|
|
|
|
|
info->stream = stdout;
|
2009-07-20 15:40:48 +02:00
|
|
|
|
if (insn_width == 0 && info->bytes_per_line != 0)
|
2000-02-03 19:12:55 +01:00
|
|
|
|
octets_per_line = info->bytes_per_line;
|
|
|
|
|
if (octets < 0)
|
1999-06-13 21:02:25 +02:00
|
|
|
|
{
|
2004-03-15 13:31:41 +01:00
|
|
|
|
if (sfile.pos)
|
1999-06-13 21:02:25 +02:00
|
|
|
|
printf ("%s\n", sfile.buffer);
|
|
|
|
|
break;
|
|
|
|
|
}
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
1999-07-11 22:02:30 +02:00
|
|
|
|
bfd_vma j;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2000-02-03 19:12:55 +01:00
|
|
|
|
octets = octets_per_line;
|
|
|
|
|
if (addr_offset + octets / opb > stop_offset)
|
|
|
|
|
octets = (stop_offset - addr_offset) * opb;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2000-02-03 19:12:55 +01:00
|
|
|
|
for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2001-09-19 07:33:36 +02:00
|
|
|
|
if (ISPRINT (data[j]))
|
2000-02-03 19:12:55 +01:00
|
|
|
|
buf[j - addr_offset * opb] = data[j];
|
1999-05-03 09:29:11 +02:00
|
|
|
|
else
|
2000-02-03 19:12:55 +01:00
|
|
|
|
buf[j - addr_offset * opb] = '.';
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
2000-02-03 19:12:55 +01:00
|
|
|
|
buf[j - addr_offset * opb] = '\0';
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (prefix_addresses
|
|
|
|
|
? show_raw_insn > 0
|
|
|
|
|
: show_raw_insn >= 0)
|
|
|
|
|
{
|
1999-07-11 22:02:30 +02:00
|
|
|
|
bfd_vma j;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
/* If ! prefix_addresses and ! wide_output, we print
|
2003-08-04 16:29:34 +02:00
|
|
|
|
octets_per_line octets per line. */
|
2000-02-03 19:12:55 +01:00
|
|
|
|
pb = octets;
|
|
|
|
|
if (pb > octets_per_line && ! prefix_addresses && ! wide_output)
|
|
|
|
|
pb = octets_per_line;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
if (info->bytes_per_chunk)
|
|
|
|
|
bpc = info->bytes_per_chunk;
|
|
|
|
|
else
|
|
|
|
|
bpc = 1;
|
|
|
|
|
|
2000-02-03 19:12:55 +01:00
|
|
|
|
for (j = addr_offset * opb; j < addr_offset * opb + pb; j += bpc)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
int k;
|
2004-07-22 18:52:43 +02:00
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
|
|
|
|
|
{
|
|
|
|
|
for (k = bpc - 1; k >= 0; k--)
|
|
|
|
|
printf ("%02x", (unsigned) data[j + k]);
|
|
|
|
|
putchar (' ');
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
for (k = 0; k < bpc; k++)
|
|
|
|
|
printf ("%02x", (unsigned) data[j + k]);
|
|
|
|
|
putchar (' ');
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2000-02-03 19:12:55 +01:00
|
|
|
|
for (; pb < octets_per_line; pb += bpc)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
int k;
|
|
|
|
|
|
|
|
|
|
for (k = 0; k < bpc; k++)
|
|
|
|
|
printf (" ");
|
|
|
|
|
putchar (' ');
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Separate raw data from instruction by extra space. */
|
|
|
|
|
if (insns)
|
|
|
|
|
putchar ('\t');
|
|
|
|
|
else
|
|
|
|
|
printf (" ");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (! insns)
|
|
|
|
|
printf ("%s", buf);
|
2004-03-15 13:31:41 +01:00
|
|
|
|
else if (sfile.pos)
|
|
|
|
|
printf ("%s", sfile.buffer);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
if (prefix_addresses
|
|
|
|
|
? show_raw_insn > 0
|
|
|
|
|
: show_raw_insn >= 0)
|
|
|
|
|
{
|
2000-02-03 19:12:55 +01:00
|
|
|
|
while (pb < octets)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
1999-07-11 22:02:30 +02:00
|
|
|
|
bfd_vma j;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
char *s;
|
|
|
|
|
|
|
|
|
|
putchar ('\n');
|
2000-02-03 19:12:55 +01:00
|
|
|
|
j = addr_offset * opb + pb;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2001-08-10 18:43:18 +02:00
|
|
|
|
bfd_sprintf_vma (aux->abfd, buf, section->vma + j / opb);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
for (s = buf + skip_addr_chars; *s == '0'; s++)
|
|
|
|
|
*s = ' ';
|
|
|
|
|
if (*s == '\0')
|
|
|
|
|
*--s = '0';
|
|
|
|
|
printf ("%s:\t", buf + skip_addr_chars);
|
|
|
|
|
|
2000-02-03 19:12:55 +01:00
|
|
|
|
pb += octets_per_line;
|
|
|
|
|
if (pb > octets)
|
|
|
|
|
pb = octets;
|
|
|
|
|
for (; j < addr_offset * opb + pb; j += bpc)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
int k;
|
|
|
|
|
|
|
|
|
|
if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
|
|
|
|
|
{
|
|
|
|
|
for (k = bpc - 1; k >= 0; k--)
|
|
|
|
|
printf ("%02x", (unsigned) data[j + k]);
|
|
|
|
|
putchar (' ');
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
for (k = 0; k < bpc; k++)
|
|
|
|
|
printf ("%02x", (unsigned) data[j + k]);
|
|
|
|
|
putchar (' ');
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!wide_output)
|
|
|
|
|
putchar ('\n');
|
|
|
|
|
else
|
2002-11-30 09:39:46 +01:00
|
|
|
|
need_nl = TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
2003-07-30 05:54:15 +02:00
|
|
|
|
while ((*relppp) < relppend
|
|
|
|
|
&& (**relppp)->address < rel_offset + addr_offset + octets / opb)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2003-07-30 05:54:15 +02:00
|
|
|
|
if (dump_reloc_info || dump_dynamic_reloc_info)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
arelent *q;
|
|
|
|
|
|
|
|
|
|
q = **relppp;
|
|
|
|
|
|
|
|
|
|
if (wide_output)
|
|
|
|
|
putchar ('\t');
|
|
|
|
|
else
|
|
|
|
|
printf ("\t\t\t");
|
|
|
|
|
|
2003-12-22 11:49:59 +01:00
|
|
|
|
objdump_print_value (section->vma - rel_offset + q->address,
|
|
|
|
|
info, TRUE);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2005-06-09 16:51:41 +02:00
|
|
|
|
if (q->howto == NULL)
|
|
|
|
|
printf (": *unknown*\t");
|
|
|
|
|
else if (q->howto->name)
|
|
|
|
|
printf (": %s\t", q->howto->name);
|
|
|
|
|
else
|
|
|
|
|
printf (": %d\t", q->howto->type);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL)
|
|
|
|
|
printf ("*unknown*");
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
const char *sym_name;
|
|
|
|
|
|
|
|
|
|
sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
|
|
|
|
|
if (sym_name != NULL && *sym_name != '\0')
|
|
|
|
|
objdump_print_symname (aux->abfd, info, *q->sym_ptr_ptr);
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
asection *sym_sec;
|
|
|
|
|
|
|
|
|
|
sym_sec = bfd_get_section (*q->sym_ptr_ptr);
|
|
|
|
|
sym_name = bfd_get_section_name (aux->abfd, sym_sec);
|
|
|
|
|
if (sym_name == NULL || *sym_name == '\0')
|
|
|
|
|
sym_name = "*unknown*";
|
|
|
|
|
printf ("%s", sym_name);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (q->addend)
|
|
|
|
|
{
|
|
|
|
|
printf ("+0x");
|
2002-11-30 09:39:46 +01:00
|
|
|
|
objdump_print_value (q->addend, info, TRUE);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
printf ("\n");
|
2002-11-30 09:39:46 +01:00
|
|
|
|
need_nl = FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
2003-07-30 05:54:15 +02:00
|
|
|
|
++(*relppp);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (need_nl)
|
|
|
|
|
printf ("\n");
|
|
|
|
|
|
2000-02-03 19:12:55 +01:00
|
|
|
|
addr_offset += octets / opb;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
2004-03-15 13:31:41 +01:00
|
|
|
|
|
|
|
|
|
free (sfile.buffer);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
2003-09-03 10:26:52 +02:00
|
|
|
|
static void
|
|
|
|
|
disassemble_section (bfd *abfd, asection *section, void *info)
|
|
|
|
|
{
|
2009-01-27 16:41:56 +01:00
|
|
|
|
const struct elf_backend_data * bed;
|
|
|
|
|
bfd_vma sign_adjust = 0;
|
2003-09-03 10:26:52 +02:00
|
|
|
|
struct disassemble_info * pinfo = (struct disassemble_info *) info;
|
2003-11-19 09:21:14 +01:00
|
|
|
|
struct objdump_disasm_info * paux;
|
2003-09-03 10:26:52 +02:00
|
|
|
|
unsigned int opb = pinfo->octets_per_byte;
|
|
|
|
|
bfd_byte * data = NULL;
|
|
|
|
|
bfd_size_type datasize = 0;
|
|
|
|
|
arelent ** rel_pp = NULL;
|
|
|
|
|
arelent ** rel_ppstart = NULL;
|
|
|
|
|
arelent ** rel_ppend;
|
|
|
|
|
unsigned long stop_offset;
|
|
|
|
|
asymbol * sym = NULL;
|
|
|
|
|
long place = 0;
|
|
|
|
|
long rel_count;
|
|
|
|
|
bfd_vma rel_offset;
|
|
|
|
|
unsigned long addr_offset;
|
|
|
|
|
|
|
|
|
|
/* Sections that do not contain machine
|
|
|
|
|
code are not normally disassembled. */
|
|
|
|
|
if (! disassemble_all
|
|
|
|
|
&& only == NULL
|
2004-04-24 14:39:47 +02:00
|
|
|
|
&& ((section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
|
|
|
|
|
!= (SEC_CODE | SEC_HAS_CONTENTS)))
|
2003-09-03 10:26:52 +02:00
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
if (! process_section_p (section))
|
|
|
|
|
return;
|
|
|
|
|
|
2004-06-15 03:19:13 +02:00
|
|
|
|
datasize = bfd_get_section_size (section);
|
2003-09-03 10:26:52 +02:00
|
|
|
|
if (datasize == 0)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
/* Decide which set of relocs to use. Load them if necessary. */
|
2003-11-19 09:21:14 +01:00
|
|
|
|
paux = (struct objdump_disasm_info *) pinfo->application_data;
|
2003-09-03 10:26:52 +02:00
|
|
|
|
if (paux->dynrelbuf)
|
|
|
|
|
{
|
|
|
|
|
rel_pp = paux->dynrelbuf;
|
|
|
|
|
rel_count = paux->dynrelcount;
|
|
|
|
|
/* Dynamic reloc addresses are absolute, non-dynamic are section
|
2003-10-27 14:20:32 +01:00
|
|
|
|
relative. REL_OFFSET specifies the reloc address corresponding
|
2003-09-03 10:26:52 +02:00
|
|
|
|
to the start of this section. */
|
2003-12-22 11:49:59 +01:00
|
|
|
|
rel_offset = section->vma;
|
2003-09-03 10:26:52 +02:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
rel_count = 0;
|
|
|
|
|
rel_pp = NULL;
|
|
|
|
|
rel_offset = 0;
|
|
|
|
|
|
|
|
|
|
if ((section->flags & SEC_RELOC) != 0
|
2006-01-17 18:39:20 +01:00
|
|
|
|
&& (dump_reloc_info || pinfo->disassembler_needs_relocs))
|
2003-09-03 10:26:52 +02:00
|
|
|
|
{
|
|
|
|
|
long relsize;
|
|
|
|
|
|
|
|
|
|
relsize = bfd_get_reloc_upper_bound (abfd, section);
|
|
|
|
|
if (relsize < 0)
|
|
|
|
|
bfd_fatal (bfd_get_filename (abfd));
|
|
|
|
|
|
|
|
|
|
if (relsize > 0)
|
|
|
|
|
{
|
2009-09-10 15:40:44 +02:00
|
|
|
|
rel_ppstart = rel_pp = (arelent **) xmalloc (relsize);
|
2003-09-03 10:26:52 +02:00
|
|
|
|
rel_count = bfd_canonicalize_reloc (abfd, section, rel_pp, syms);
|
|
|
|
|
if (rel_count < 0)
|
|
|
|
|
bfd_fatal (bfd_get_filename (abfd));
|
|
|
|
|
|
|
|
|
|
/* Sort the relocs by address. */
|
|
|
|
|
qsort (rel_pp, rel_count, sizeof (arelent *), compare_relocs);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
rel_ppend = rel_pp + rel_count;
|
|
|
|
|
|
2009-09-10 15:40:44 +02:00
|
|
|
|
data = (bfd_byte *) xmalloc (datasize);
|
2003-09-03 10:26:52 +02:00
|
|
|
|
|
|
|
|
|
bfd_get_section_contents (abfd, section, data, 0, datasize);
|
|
|
|
|
|
|
|
|
|
paux->sec = section;
|
|
|
|
|
pinfo->buffer = data;
|
|
|
|
|
pinfo->buffer_vma = section->vma;
|
|
|
|
|
pinfo->buffer_length = datasize;
|
|
|
|
|
pinfo->section = section;
|
|
|
|
|
|
|
|
|
|
if (start_address == (bfd_vma) -1
|
|
|
|
|
|| start_address < pinfo->buffer_vma)
|
|
|
|
|
addr_offset = 0;
|
|
|
|
|
else
|
|
|
|
|
addr_offset = start_address - pinfo->buffer_vma;
|
|
|
|
|
|
|
|
|
|
if (stop_address == (bfd_vma) -1)
|
|
|
|
|
stop_offset = datasize / opb;
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (stop_address < pinfo->buffer_vma)
|
|
|
|
|
stop_offset = 0;
|
|
|
|
|
else
|
|
|
|
|
stop_offset = stop_address - pinfo->buffer_vma;
|
|
|
|
|
if (stop_offset > pinfo->buffer_length / opb)
|
|
|
|
|
stop_offset = pinfo->buffer_length / opb;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Skip over the relocs belonging to addresses below the
|
|
|
|
|
start address. */
|
|
|
|
|
while (rel_pp < rel_ppend
|
|
|
|
|
&& (*rel_pp)->address < rel_offset + addr_offset)
|
|
|
|
|
++rel_pp;
|
|
|
|
|
|
2008-02-22 10:42:58 +01:00
|
|
|
|
if (addr_offset < stop_offset)
|
|
|
|
|
printf (_("\nDisassembly of section %s:\n"), section->name);
|
2003-09-03 10:26:52 +02:00
|
|
|
|
|
|
|
|
|
/* Find the nearest symbol forwards from our current position. */
|
2003-11-19 09:21:14 +01:00
|
|
|
|
paux->require_sec = TRUE;
|
2009-09-10 15:40:44 +02:00
|
|
|
|
sym = (asymbol *) find_symbol_for_address (section->vma + addr_offset,
|
|
|
|
|
(struct disassemble_info *) info,
|
|
|
|
|
&place);
|
2003-11-19 09:21:14 +01:00
|
|
|
|
paux->require_sec = FALSE;
|
2003-09-03 10:26:52 +02:00
|
|
|
|
|
2009-09-22 20:29:06 +02:00
|
|
|
|
/* PR 9774: If the target used signed addresses then we must make
|
|
|
|
|
sure that we sign extend the value that we calculate for 'addr'
|
|
|
|
|
in the loop below. */
|
2009-01-27 16:41:56 +01:00
|
|
|
|
if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
|
|
|
|
|
&& (bed = get_elf_backend_data (abfd)) != NULL
|
|
|
|
|
&& bed->sign_extend_vma)
|
2009-09-22 20:29:06 +02:00
|
|
|
|
sign_adjust = (bfd_vma) 1 << (bed->s->arch_size - 1);
|
2009-01-27 16:41:56 +01:00
|
|
|
|
|
2003-09-03 10:26:52 +02:00
|
|
|
|
/* Disassemble a block of instructions up to the address associated with
|
|
|
|
|
the symbol we have just found. Then print the symbol and find the
|
|
|
|
|
next symbol on. Repeat until we have disassembled the entire section
|
|
|
|
|
or we have reached the end of the address range we are interested in. */
|
|
|
|
|
while (addr_offset < stop_offset)
|
|
|
|
|
{
|
2003-11-14 16:12:44 +01:00
|
|
|
|
bfd_vma addr;
|
2003-09-03 10:26:52 +02:00
|
|
|
|
asymbol *nextsym;
|
|
|
|
|
unsigned long nextstop_offset;
|
|
|
|
|
bfd_boolean insns;
|
|
|
|
|
|
2003-11-14 16:12:44 +01:00
|
|
|
|
addr = section->vma + addr_offset;
|
2009-03-03 02:27:15 +01:00
|
|
|
|
addr = ((addr & ((sign_adjust << 1) - 1)) ^ sign_adjust) - sign_adjust;
|
2003-11-14 16:12:44 +01:00
|
|
|
|
|
|
|
|
|
if (sym != NULL && bfd_asymbol_value (sym) <= addr)
|
2003-09-03 10:26:52 +02:00
|
|
|
|
{
|
|
|
|
|
int x;
|
|
|
|
|
|
|
|
|
|
for (x = place;
|
|
|
|
|
(x < sorted_symcount
|
2003-11-14 16:12:44 +01:00
|
|
|
|
&& (bfd_asymbol_value (sorted_syms[x]) <= addr));
|
2003-09-03 10:26:52 +02:00
|
|
|
|
++x)
|
|
|
|
|
continue;
|
|
|
|
|
|
2003-11-14 16:12:44 +01:00
|
|
|
|
pinfo->symbols = sorted_syms + place;
|
2003-09-03 10:26:52 +02:00
|
|
|
|
pinfo->num_symbols = x - place;
|
2006-10-31 21:21:57 +01:00
|
|
|
|
pinfo->symtab_pos = place;
|
2003-09-03 10:26:52 +02:00
|
|
|
|
}
|
|
|
|
|
else
|
2003-11-14 16:12:44 +01:00
|
|
|
|
{
|
|
|
|
|
pinfo->symbols = NULL;
|
|
|
|
|
pinfo->num_symbols = 0;
|
2006-10-31 21:21:57 +01:00
|
|
|
|
pinfo->symtab_pos = -1;
|
2003-11-14 16:12:44 +01:00
|
|
|
|
}
|
2003-09-03 10:26:52 +02:00
|
|
|
|
|
|
|
|
|
if (! prefix_addresses)
|
|
|
|
|
{
|
|
|
|
|
pinfo->fprintf_func (pinfo->stream, "\n");
|
2003-11-14 16:12:44 +01:00
|
|
|
|
objdump_print_addr_with_sym (abfd, section, sym, addr,
|
2003-09-03 10:26:52 +02:00
|
|
|
|
pinfo, FALSE);
|
|
|
|
|
pinfo->fprintf_func (pinfo->stream, ":\n");
|
|
|
|
|
}
|
|
|
|
|
|
2003-11-14 16:12:44 +01:00
|
|
|
|
if (sym != NULL && bfd_asymbol_value (sym) > addr)
|
2003-09-03 10:26:52 +02:00
|
|
|
|
nextsym = sym;
|
|
|
|
|
else if (sym == NULL)
|
|
|
|
|
nextsym = NULL;
|
|
|
|
|
else
|
|
|
|
|
{
|
2003-11-14 16:12:44 +01:00
|
|
|
|
#define is_valid_next_sym(SYM) \
|
|
|
|
|
((SYM)->section == section \
|
|
|
|
|
&& (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
|
|
|
|
|
&& pinfo->symbol_is_valid (SYM, pinfo))
|
|
|
|
|
|
2003-09-03 10:26:52 +02:00
|
|
|
|
/* Search forward for the next appropriate symbol in
|
|
|
|
|
SECTION. Note that all the symbols are sorted
|
|
|
|
|
together into one big array, and that some sections
|
|
|
|
|
may have overlapping addresses. */
|
|
|
|
|
while (place < sorted_symcount
|
2003-11-14 16:12:44 +01:00
|
|
|
|
&& ! is_valid_next_sym (sorted_syms [place]))
|
2003-09-03 10:26:52 +02:00
|
|
|
|
++place;
|
2003-11-14 16:12:44 +01:00
|
|
|
|
|
2003-09-03 10:26:52 +02:00
|
|
|
|
if (place >= sorted_symcount)
|
|
|
|
|
nextsym = NULL;
|
|
|
|
|
else
|
|
|
|
|
nextsym = sorted_syms[place];
|
|
|
|
|
}
|
|
|
|
|
|
2003-11-14 16:12:44 +01:00
|
|
|
|
if (sym != NULL && bfd_asymbol_value (sym) > addr)
|
|
|
|
|
nextstop_offset = bfd_asymbol_value (sym) - section->vma;
|
2003-09-03 10:26:52 +02:00
|
|
|
|
else if (nextsym == NULL)
|
|
|
|
|
nextstop_offset = stop_offset;
|
|
|
|
|
else
|
2003-11-14 16:12:44 +01:00
|
|
|
|
nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;
|
|
|
|
|
|
2009-03-05 17:31:50 +01:00
|
|
|
|
if (nextstop_offset > stop_offset
|
|
|
|
|
|| nextstop_offset <= addr_offset)
|
2003-11-14 16:12:44 +01:00
|
|
|
|
nextstop_offset = stop_offset;
|
2003-09-03 10:26:52 +02:00
|
|
|
|
|
|
|
|
|
/* If a symbol is explicitly marked as being an object
|
|
|
|
|
rather than a function, just dump the bytes without
|
|
|
|
|
disassembling them. */
|
|
|
|
|
if (disassemble_all
|
|
|
|
|
|| sym == NULL
|
2009-01-14 02:26:18 +01:00
|
|
|
|
|| sym->section != section
|
2003-11-14 16:12:44 +01:00
|
|
|
|
|| bfd_asymbol_value (sym) > addr
|
2003-09-03 10:26:52 +02:00
|
|
|
|
|| ((sym->flags & BSF_OBJECT) == 0
|
|
|
|
|
&& (strstr (bfd_asymbol_name (sym), "gnu_compiled")
|
|
|
|
|
== NULL)
|
|
|
|
|
&& (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
|
|
|
|
|
== NULL))
|
|
|
|
|
|| (sym->flags & BSF_FUNCTION) != 0)
|
|
|
|
|
insns = TRUE;
|
|
|
|
|
else
|
|
|
|
|
insns = FALSE;
|
|
|
|
|
|
|
|
|
|
disassemble_bytes (pinfo, paux->disassemble_fn, insns, data,
|
|
|
|
|
addr_offset, nextstop_offset,
|
|
|
|
|
rel_offset, &rel_pp, rel_ppend);
|
2009-03-05 17:31:50 +01:00
|
|
|
|
|
2003-09-03 10:26:52 +02:00
|
|
|
|
addr_offset = nextstop_offset;
|
|
|
|
|
sym = nextsym;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
free (data);
|
|
|
|
|
|
|
|
|
|
if (rel_ppstart != NULL)
|
|
|
|
|
free (rel_ppstart);
|
|
|
|
|
}
|
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
/* Disassemble the contents of an object file. */
|
|
|
|
|
|
|
|
|
|
static void
|
2003-07-29 17:40:37 +02:00
|
|
|
|
disassemble_data (bfd *abfd)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
struct disassemble_info disasm_info;
|
|
|
|
|
struct objdump_disasm_info aux;
|
2004-04-22 16:45:32 +02:00
|
|
|
|
long i;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
print_files = NULL;
|
|
|
|
|
prev_functionname = NULL;
|
|
|
|
|
prev_line = -1;
|
|
|
|
|
|
|
|
|
|
/* We make a copy of syms to sort. We don't want to sort syms
|
|
|
|
|
because that will screw up the relocs. */
|
2004-04-22 16:45:32 +02:00
|
|
|
|
sorted_symcount = symcount ? symcount : dynsymcount;
|
2009-09-10 15:40:44 +02:00
|
|
|
|
sorted_syms = (asymbol **) xmalloc ((sorted_symcount + synthcount)
|
|
|
|
|
* sizeof (asymbol *));
|
2004-04-22 16:45:32 +02:00
|
|
|
|
memcpy (sorted_syms, symcount ? syms : dynsyms,
|
|
|
|
|
sorted_symcount * sizeof (asymbol *));
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2004-04-22 16:45:32 +02:00
|
|
|
|
sorted_symcount = remove_useless_symbols (sorted_syms, sorted_symcount);
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < synthcount; ++i)
|
|
|
|
|
{
|
|
|
|
|
sorted_syms[sorted_symcount] = synthsyms + i;
|
|
|
|
|
++sorted_symcount;
|
|
|
|
|
}
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2003-03-17 12:16:51 +01:00
|
|
|
|
/* Sort the symbols into section and symbol order. */
|
1999-05-03 09:29:11 +02:00
|
|
|
|
qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
|
|
|
|
|
|
2003-11-14 16:12:44 +01:00
|
|
|
|
init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf);
|
2003-03-17 12:16:51 +01:00
|
|
|
|
|
2003-07-29 17:40:37 +02:00
|
|
|
|
disasm_info.application_data = (void *) &aux;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
aux.abfd = abfd;
|
2002-11-30 09:39:46 +01:00
|
|
|
|
aux.require_sec = FALSE;
|
2003-09-03 10:26:52 +02:00
|
|
|
|
aux.dynrelbuf = NULL;
|
|
|
|
|
aux.dynrelcount = 0;
|
2005-03-01 16:18:44 +01:00
|
|
|
|
aux.reloc = NULL;
|
2003-09-03 10:26:52 +02:00
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
disasm_info.print_address_func = objdump_print_address;
|
|
|
|
|
disasm_info.symbol_at_address_func = objdump_symbol_at_address;
|
|
|
|
|
|
2003-08-05 16:40:54 +02:00
|
|
|
|
if (machine != NULL)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
const bfd_arch_info_type *info = bfd_scan_arch (machine);
|
2003-03-17 12:16:51 +01:00
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
if (info == NULL)
|
2003-03-17 12:16:51 +01:00
|
|
|
|
fatal (_("Can't use supplied machine %s"), machine);
|
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
abfd->arch_info = info;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (endian != BFD_ENDIAN_UNKNOWN)
|
|
|
|
|
{
|
|
|
|
|
struct bfd_target *xvec;
|
|
|
|
|
|
2009-09-10 15:40:44 +02:00
|
|
|
|
xvec = (struct bfd_target *) xmalloc (sizeof (struct bfd_target));
|
1999-05-03 09:29:11 +02:00
|
|
|
|
memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
|
|
|
|
|
xvec->byteorder = endian;
|
|
|
|
|
abfd->xvec = xvec;
|
|
|
|
|
}
|
|
|
|
|
|
2003-09-03 10:26:52 +02:00
|
|
|
|
/* Use libopcodes to locate a suitable disassembler. */
|
|
|
|
|
aux.disassemble_fn = disassembler (abfd);
|
|
|
|
|
if (!aux.disassemble_fn)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2000-04-07 06:34:50 +02:00
|
|
|
|
non_fatal (_("Can't disassemble for architecture %s\n"),
|
|
|
|
|
bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
|
1999-08-09 07:23:29 +02:00
|
|
|
|
exit_status = 1;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
disasm_info.flavour = bfd_get_flavour (abfd);
|
|
|
|
|
disasm_info.arch = bfd_get_arch (abfd);
|
|
|
|
|
disasm_info.mach = bfd_get_mach (abfd);
|
1999-06-16 04:24:36 +02:00
|
|
|
|
disasm_info.disassembler_options = disassembler_options;
|
2003-09-03 10:26:52 +02:00
|
|
|
|
disasm_info.octets_per_byte = bfd_octets_per_byte (abfd);
|
2005-01-10 10:54:50 +01:00
|
|
|
|
disasm_info.skip_zeroes = DEFAULT_SKIP_ZEROES;
|
|
|
|
|
disasm_info.skip_zeroes_at_end = DEFAULT_SKIP_ZEROES_AT_END;
|
2006-01-17 18:39:20 +01:00
|
|
|
|
disasm_info.disassembler_needs_relocs = FALSE;
|
2002-05-21 21:34:58 +02:00
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
if (bfd_big_endian (abfd))
|
1999-05-06 09:41:56 +02:00
|
|
|
|
disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
else if (bfd_little_endian (abfd))
|
1999-05-06 09:41:56 +02:00
|
|
|
|
disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
else
|
|
|
|
|
/* ??? Aborting here seems too drastic. We could default to big or little
|
|
|
|
|
instead. */
|
|
|
|
|
disasm_info.endian = BFD_ENDIAN_UNKNOWN;
|
|
|
|
|
|
2003-11-14 16:12:44 +01:00
|
|
|
|
/* Allow the target to customize the info structure. */
|
|
|
|
|
disassemble_init_for_target (& disasm_info);
|
|
|
|
|
|
2003-09-03 10:26:52 +02:00
|
|
|
|
/* Pre-load the dynamic relocs if we are going
|
|
|
|
|
to be dumping them along with the disassembly. */
|
2003-07-30 05:54:15 +02:00
|
|
|
|
if (dump_dynamic_reloc_info)
|
|
|
|
|
{
|
|
|
|
|
long relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
|
2003-09-03 10:26:52 +02:00
|
|
|
|
|
2003-07-30 05:54:15 +02:00
|
|
|
|
if (relsize < 0)
|
|
|
|
|
bfd_fatal (bfd_get_filename (abfd));
|
|
|
|
|
|
|
|
|
|
if (relsize > 0)
|
|
|
|
|
{
|
2009-09-10 15:40:44 +02:00
|
|
|
|
aux.dynrelbuf = (arelent **) xmalloc (relsize);
|
2003-11-19 09:21:14 +01:00
|
|
|
|
aux.dynrelcount = bfd_canonicalize_dynamic_reloc (abfd,
|
|
|
|
|
aux.dynrelbuf,
|
|
|
|
|
dynsyms);
|
2003-09-03 10:26:52 +02:00
|
|
|
|
if (aux.dynrelcount < 0)
|
2003-07-30 05:54:15 +02:00
|
|
|
|
bfd_fatal (bfd_get_filename (abfd));
|
|
|
|
|
|
|
|
|
|
/* Sort the relocs by address. */
|
2003-11-19 09:21:14 +01:00
|
|
|
|
qsort (aux.dynrelbuf, aux.dynrelcount, sizeof (arelent *),
|
|
|
|
|
compare_relocs);
|
2003-07-30 05:54:15 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
2006-10-31 21:21:57 +01:00
|
|
|
|
disasm_info.symtab = sorted_syms;
|
|
|
|
|
disasm_info.symtab_size = sorted_symcount;
|
2003-07-30 05:54:15 +02:00
|
|
|
|
|
2003-09-03 10:26:52 +02:00
|
|
|
|
bfd_map_over_sections (abfd, disassemble_section, & disasm_info);
|
2003-03-17 12:16:51 +01:00
|
|
|
|
|
2003-09-03 10:26:52 +02:00
|
|
|
|
if (aux.dynrelbuf != NULL)
|
|
|
|
|
free (aux.dynrelbuf);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
free (sorted_syms);
|
|
|
|
|
}
|
|
|
|
|
|
2009-02-23 20:44:58 +01:00
|
|
|
|
static int
|
|
|
|
|
load_specific_debug_section (enum dwarf_section_display_enum debug,
|
|
|
|
|
asection *sec, void *file)
|
2005-09-30 16:56:34 +02:00
|
|
|
|
{
|
|
|
|
|
struct dwarf_section *section = &debug_displays [debug].section;
|
2009-09-10 15:40:44 +02:00
|
|
|
|
bfd *abfd = (bfd *) file;
|
2005-09-30 16:56:34 +02:00
|
|
|
|
bfd_boolean ret;
|
2008-07-10 03:32:23 +02:00
|
|
|
|
int section_is_compressed;
|
2005-09-30 16:56:34 +02:00
|
|
|
|
|
|
|
|
|
/* If it is already loaded, do nothing. */
|
|
|
|
|
if (section->start != NULL)
|
|
|
|
|
return 1;
|
|
|
|
|
|
2008-07-15 20:48:34 +02:00
|
|
|
|
section_is_compressed = section->name == section->compressed_name;
|
2005-09-30 16:56:34 +02:00
|
|
|
|
|
2008-11-14 15:56:51 +01:00
|
|
|
|
section->address = 0;
|
2005-09-30 16:56:34 +02:00
|
|
|
|
section->size = bfd_get_section_size (sec);
|
2009-09-10 15:40:44 +02:00
|
|
|
|
section->start = (unsigned char *) xmalloc (section->size);
|
2005-09-30 16:56:34 +02:00
|
|
|
|
|
|
|
|
|
if (is_relocatable && debug_displays [debug].relocate)
|
|
|
|
|
ret = bfd_simple_get_relocated_section_contents (abfd,
|
|
|
|
|
sec,
|
|
|
|
|
section->start,
|
|
|
|
|
syms) != NULL;
|
|
|
|
|
else
|
|
|
|
|
ret = bfd_get_section_contents (abfd, sec, section->start, 0,
|
|
|
|
|
section->size);
|
|
|
|
|
|
2008-07-10 03:32:23 +02:00
|
|
|
|
if (! ret)
|
2005-09-30 16:56:34 +02:00
|
|
|
|
{
|
|
|
|
|
free_debug_section (debug);
|
|
|
|
|
printf (_("\nCan't get contents for section '%s'.\n"),
|
|
|
|
|
section->name);
|
2008-07-10 03:32:23 +02:00
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (section_is_compressed)
|
|
|
|
|
{
|
|
|
|
|
bfd_size_type size = section->size;
|
|
|
|
|
if (! bfd_uncompress_section_contents (§ion->start, &size))
|
|
|
|
|
{
|
|
|
|
|
free_debug_section (debug);
|
|
|
|
|
printf (_("\nCan't uncompress section '%s'.\n"), section->name);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
section->size = size;
|
2005-09-30 16:56:34 +02:00
|
|
|
|
}
|
|
|
|
|
|
2009-02-23 20:44:58 +01:00
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
load_debug_section (enum dwarf_section_display_enum debug, void *file)
|
|
|
|
|
{
|
|
|
|
|
struct dwarf_section *section = &debug_displays [debug].section;
|
2009-09-10 15:40:44 +02:00
|
|
|
|
bfd *abfd = (bfd *) file;
|
2009-02-23 20:44:58 +01:00
|
|
|
|
asection *sec;
|
|
|
|
|
|
|
|
|
|
/* If it is already loaded, do nothing. */
|
|
|
|
|
if (section->start != NULL)
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
|
|
/* Locate the debug section. */
|
|
|
|
|
sec = bfd_get_section_by_name (abfd, section->uncompressed_name);
|
|
|
|
|
if (sec != NULL)
|
|
|
|
|
section->name = section->uncompressed_name;
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
sec = bfd_get_section_by_name (abfd, section->compressed_name);
|
|
|
|
|
if (sec != NULL)
|
|
|
|
|
section->name = section->compressed_name;
|
|
|
|
|
}
|
|
|
|
|
if (sec == NULL)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
return load_specific_debug_section (debug, sec, file);
|
2005-09-30 16:56:34 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
free_debug_section (enum dwarf_section_display_enum debug)
|
|
|
|
|
{
|
|
|
|
|
struct dwarf_section *section = &debug_displays [debug].section;
|
|
|
|
|
|
|
|
|
|
if (section->start == NULL)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
free ((char *) section->start);
|
|
|
|
|
section->start = NULL;
|
|
|
|
|
section->address = 0;
|
|
|
|
|
section->size = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
dump_dwarf_section (bfd *abfd, asection *section,
|
|
|
|
|
void *arg ATTRIBUTE_UNUSED)
|
|
|
|
|
{
|
|
|
|
|
const char *name = bfd_get_section_name (abfd, section);
|
|
|
|
|
const char *match;
|
2009-09-10 15:40:44 +02:00
|
|
|
|
int i;
|
2005-09-30 16:56:34 +02:00
|
|
|
|
|
2006-09-16 20:12:17 +02:00
|
|
|
|
if (CONST_STRNEQ (name, ".gnu.linkonce.wi."))
|
2005-09-30 16:56:34 +02:00
|
|
|
|
match = ".debug_info";
|
|
|
|
|
else
|
|
|
|
|
match = name;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < max; i++)
|
2009-02-09 10:14:15 +01:00
|
|
|
|
if ((strcmp (debug_displays [i].section.uncompressed_name, match) == 0
|
|
|
|
|
|| strcmp (debug_displays [i].section.compressed_name, match) == 0)
|
|
|
|
|
&& debug_displays [i].enabled != NULL
|
|
|
|
|
&& *debug_displays [i].enabled)
|
2005-09-30 16:56:34 +02:00
|
|
|
|
{
|
2009-07-06 16:45:56 +02:00
|
|
|
|
struct dwarf_section *sec = &debug_displays [i].section;
|
2005-09-30 16:56:34 +02:00
|
|
|
|
|
2009-07-06 16:45:56 +02:00
|
|
|
|
if (strcmp (sec->uncompressed_name, match) == 0)
|
|
|
|
|
sec->name = sec->uncompressed_name;
|
|
|
|
|
else
|
|
|
|
|
sec->name = sec->compressed_name;
|
2009-09-10 15:40:44 +02:00
|
|
|
|
if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
|
|
|
|
|
section, abfd))
|
2009-07-06 16:45:56 +02:00
|
|
|
|
{
|
|
|
|
|
debug_displays [i].display (sec, abfd);
|
|
|
|
|
|
|
|
|
|
if (i != info && i != abbrev)
|
2009-09-10 15:40:44 +02:00
|
|
|
|
free_debug_section ((enum dwarf_section_display_enum) i);
|
2005-09-30 16:56:34 +02:00
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Dump the dwarf debugging information. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
dump_dwarf (bfd *abfd)
|
|
|
|
|
{
|
2007-07-10 15:52:39 +02:00
|
|
|
|
is_relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
|
2005-09-30 16:56:34 +02:00
|
|
|
|
|
|
|
|
|
/* FIXME: bfd_get_arch_size may return -1. We assume that 64bit
|
|
|
|
|
targets will return 64. */
|
|
|
|
|
eh_addr_size = bfd_get_arch_size (abfd) == 64 ? 8 : 4;
|
|
|
|
|
|
|
|
|
|
if (bfd_big_endian (abfd))
|
|
|
|
|
byte_get = byte_get_big_endian;
|
|
|
|
|
else if (bfd_little_endian (abfd))
|
|
|
|
|
byte_get = byte_get_little_endian;
|
|
|
|
|
else
|
|
|
|
|
abort ();
|
|
|
|
|
|
2008-01-28 16:15:32 +01:00
|
|
|
|
if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
|
|
|
|
|
{
|
|
|
|
|
const struct elf_backend_data *bed = get_elf_backend_data (abfd);
|
|
|
|
|
init_dwarf_regnames (bed->elf_machine_code);
|
|
|
|
|
}
|
|
|
|
|
|
2005-09-30 16:56:34 +02:00
|
|
|
|
bfd_map_over_sections (abfd, dump_dwarf_section, NULL);
|
|
|
|
|
|
|
|
|
|
free_debug_memory ();
|
|
|
|
|
}
|
|
|
|
|
|
2003-10-07 10:53:42 +02:00
|
|
|
|
/* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
|
|
|
|
|
it. Return NULL on failure. */
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2003-10-07 10:53:42 +02:00
|
|
|
|
static char *
|
|
|
|
|
read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2003-10-07 10:53:42 +02:00
|
|
|
|
asection *stabsect;
|
|
|
|
|
bfd_size_type size;
|
|
|
|
|
char *contents;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2003-10-07 10:53:42 +02:00
|
|
|
|
stabsect = bfd_get_section_by_name (abfd, sect_name);
|
2003-09-03 10:26:52 +02:00
|
|
|
|
if (stabsect == NULL)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2003-10-07 10:53:42 +02:00
|
|
|
|
printf (_("No %s section present\n\n"), sect_name);
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
2003-10-07 10:53:42 +02:00
|
|
|
|
size = bfd_section_size (abfd, stabsect);
|
2009-09-10 15:40:44 +02:00
|
|
|
|
contents = (char *) xmalloc (size);
|
2002-05-21 21:34:58 +02:00
|
|
|
|
|
2003-10-07 10:53:42 +02:00
|
|
|
|
if (! bfd_get_section_contents (abfd, stabsect, contents, 0, size))
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2000-04-07 06:34:50 +02:00
|
|
|
|
non_fatal (_("Reading %s section of %s failed: %s"),
|
2003-10-07 10:53:42 +02:00
|
|
|
|
sect_name, bfd_get_filename (abfd),
|
2000-04-07 06:34:50 +02:00
|
|
|
|
bfd_errmsg (bfd_get_error ()));
|
2003-10-07 10:53:42 +02:00
|
|
|
|
free (contents);
|
1999-08-09 07:23:29 +02:00
|
|
|
|
exit_status = 1;
|
2003-10-07 10:53:42 +02:00
|
|
|
|
return NULL;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
2003-10-07 10:53:42 +02:00
|
|
|
|
*size_ptr = size;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2003-10-07 10:53:42 +02:00
|
|
|
|
return contents;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Stabs entries use a 12 byte format:
|
|
|
|
|
4 byte string table index
|
|
|
|
|
1 byte stab type
|
|
|
|
|
1 byte stab other field
|
|
|
|
|
2 byte stab desc field
|
|
|
|
|
4 byte stab value
|
|
|
|
|
FIXME: This will have to change for a 64 bit object format. */
|
|
|
|
|
|
2003-07-29 17:40:37 +02:00
|
|
|
|
#define STRDXOFF (0)
|
|
|
|
|
#define TYPEOFF (4)
|
|
|
|
|
#define OTHEROFF (5)
|
|
|
|
|
#define DESCOFF (6)
|
|
|
|
|
#define VALOFF (8)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
#define STABSIZE (12)
|
|
|
|
|
|
|
|
|
|
/* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
|
|
|
|
|
using string table section STRSECT_NAME (in `strtab'). */
|
|
|
|
|
|
|
|
|
|
static void
|
2003-11-19 09:21:14 +01:00
|
|
|
|
print_section_stabs (bfd *abfd,
|
|
|
|
|
const char *stabsect_name,
|
|
|
|
|
unsigned *string_offset_ptr)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
int i;
|
2003-07-29 17:40:37 +02:00
|
|
|
|
unsigned file_string_table_offset = 0;
|
2003-10-07 10:53:42 +02:00
|
|
|
|
unsigned next_file_string_table_offset = *string_offset_ptr;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
bfd_byte *stabp, *stabs_end;
|
|
|
|
|
|
|
|
|
|
stabp = stabs;
|
|
|
|
|
stabs_end = stabp + stab_size;
|
|
|
|
|
|
|
|
|
|
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. */
|
|
|
|
|
for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
|
|
|
|
|
{
|
|
|
|
|
const char *name;
|
|
|
|
|
unsigned long strx;
|
|
|
|
|
unsigned char type, other;
|
|
|
|
|
unsigned short desc;
|
|
|
|
|
bfd_vma value;
|
|
|
|
|
|
|
|
|
|
strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
|
|
|
|
|
type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
|
|
|
|
|
other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
|
|
|
|
|
desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
|
|
|
|
|
value = bfd_h_get_32 (abfd, stabp + VALOFF);
|
|
|
|
|
|
|
|
|
|
printf ("\n%-6d ", i);
|
|
|
|
|
/* Either print the stab name, or, if unnamed, print its number
|
2002-05-21 21:34:58 +02:00
|
|
|
|
again (makes consistent formatting for tools like awk). */
|
1999-05-03 09:29:11 +02:00
|
|
|
|
name = bfd_get_stab_name (type);
|
|
|
|
|
if (name != NULL)
|
|
|
|
|
printf ("%-6s", name);
|
|
|
|
|
else if (type == N_UNDF)
|
|
|
|
|
printf ("HdrSym");
|
|
|
|
|
else
|
|
|
|
|
printf ("%-6d", type);
|
|
|
|
|
printf (" %-6d %-6d ", other, desc);
|
2001-08-10 18:43:18 +02:00
|
|
|
|
bfd_printf_vma (abfd, value);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
printf (" %-6lu", 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 (type == N_UNDF)
|
|
|
|
|
{
|
|
|
|
|
file_string_table_offset = next_file_string_table_offset;
|
|
|
|
|
next_file_string_table_offset += value;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* Using the (possibly updated) string table offset, print the
|
|
|
|
|
string (if any) associated with this symbol. */
|
|
|
|
|
if ((strx + file_string_table_offset) < stabstr_size)
|
|
|
|
|
printf (" %s", &strtab[strx + file_string_table_offset]);
|
|
|
|
|
else
|
|
|
|
|
printf (" *");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
printf ("\n\n");
|
2003-10-07 10:53:42 +02:00
|
|
|
|
*string_offset_ptr = next_file_string_table_offset;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
2003-09-03 10:26:52 +02:00
|
|
|
|
typedef struct
|
|
|
|
|
{
|
|
|
|
|
const char * section_name;
|
|
|
|
|
const char * string_section_name;
|
2003-10-07 10:53:42 +02:00
|
|
|
|
unsigned string_offset;
|
2003-09-03 10:26:52 +02:00
|
|
|
|
}
|
|
|
|
|
stab_section_names;
|
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
static void
|
2003-09-03 10:26:52 +02:00
|
|
|
|
find_stabs_section (bfd *abfd, asection *section, void *names)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2003-09-03 10:26:52 +02:00
|
|
|
|
int len;
|
|
|
|
|
stab_section_names * sought = (stab_section_names *) names;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
/* Check for section names for which stabsect_name is a prefix, to
|
2003-10-07 10:53:42 +02:00
|
|
|
|
handle .stab.N, etc. */
|
2003-09-03 10:26:52 +02:00
|
|
|
|
len = strlen (sought->section_name);
|
|
|
|
|
|
|
|
|
|
/* If the prefix matches, and the files section name ends with a
|
|
|
|
|
nul or a digit, then we match. I.e., we want either an exact
|
|
|
|
|
match or a section followed by a number. */
|
|
|
|
|
if (strncmp (sought->section_name, section->name, len) == 0
|
|
|
|
|
&& (section->name[len] == 0
|
2003-10-07 10:53:42 +02:00
|
|
|
|
|| (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2003-10-07 10:53:42 +02:00
|
|
|
|
if (strtab == NULL)
|
|
|
|
|
strtab = read_section_stabs (abfd, sought->string_section_name,
|
|
|
|
|
&stabstr_size);
|
|
|
|
|
|
|
|
|
|
if (strtab)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2005-02-23 13:25:57 +01:00
|
|
|
|
stabs = (bfd_byte *) read_section_stabs (abfd, section->name,
|
|
|
|
|
&stab_size);
|
2003-10-07 10:53:42 +02:00
|
|
|
|
if (stabs)
|
|
|
|
|
print_section_stabs (abfd, section->name, &sought->string_offset);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2003-03-17 12:16:51 +01:00
|
|
|
|
|
2003-09-03 10:26:52 +02:00
|
|
|
|
static void
|
|
|
|
|
dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
|
|
|
|
|
{
|
|
|
|
|
stab_section_names s;
|
|
|
|
|
|
|
|
|
|
s.section_name = stabsect_name;
|
|
|
|
|
s.string_section_name = strsect_name;
|
2003-10-07 10:53:42 +02:00
|
|
|
|
s.string_offset = 0;
|
|
|
|
|
|
2003-09-03 10:26:52 +02:00
|
|
|
|
bfd_map_over_sections (abfd, find_stabs_section, & s);
|
2003-10-07 10:53:42 +02:00
|
|
|
|
|
|
|
|
|
free (strtab);
|
|
|
|
|
strtab = NULL;
|
2003-09-03 10:26:52 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Dump the any sections containing stabs debugging information. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
dump_stabs (bfd *abfd)
|
|
|
|
|
{
|
|
|
|
|
dump_stabs_section (abfd, ".stab", ".stabstr");
|
|
|
|
|
dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
|
|
|
|
|
dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");
|
2008-08-28 18:05:03 +02:00
|
|
|
|
|
|
|
|
|
/* For Darwin. */
|
|
|
|
|
dump_stabs_section (abfd, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
|
|
|
|
|
|
2003-09-03 10:26:52 +02:00
|
|
|
|
dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
|
|
|
|
|
}
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
static void
|
2003-07-29 17:40:37 +02:00
|
|
|
|
dump_bfd_header (bfd *abfd)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
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");
|
2002-08-28 12:38:51 +02:00
|
|
|
|
PF (HAS_LOAD_PAGE, "HAS_LOAD_PAGE");
|
1999-05-03 09:29:11 +02:00
|
|
|
|
printf (_("\nstart address 0x"));
|
2001-08-10 18:43:18 +02:00
|
|
|
|
bfd_printf_vma (abfd, abfd->start_address);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
printf ("\n");
|
|
|
|
|
}
|
2003-03-17 12:16:51 +01:00
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
static void
|
2003-07-29 17:40:37 +02:00
|
|
|
|
dump_bfd_private_header (bfd *abfd)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
bfd_print_private_bfd_data (abfd, stdout);
|
|
|
|
|
}
|
|
|
|
|
|
2003-09-03 10:26:52 +02:00
|
|
|
|
|
|
|
|
|
/* Display a section in hexadecimal format with associated characters.
|
|
|
|
|
Each line prefixed by the zero padded address. */
|
1999-10-28 05:30:13 +02:00
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
static void
|
2003-09-03 10:26:52 +02:00
|
|
|
|
dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2003-09-03 10:26:52 +02:00
|
|
|
|
bfd_byte *data = 0;
|
|
|
|
|
bfd_size_type datasize;
|
|
|
|
|
bfd_size_type addr_offset;
|
|
|
|
|
bfd_size_type start_offset;
|
|
|
|
|
bfd_size_type stop_offset;
|
|
|
|
|
unsigned int opb = bfd_octets_per_byte (abfd);
|
|
|
|
|
/* Bytes per line. */
|
|
|
|
|
const int onaline = 16;
|
|
|
|
|
char buf[64];
|
|
|
|
|
int count;
|
|
|
|
|
int width;
|
|
|
|
|
|
|
|
|
|
if ((section->flags & SEC_HAS_CONTENTS) == 0)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
if (! process_section_p (section))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
if ((datasize = bfd_section_size (abfd, section)) == 0)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
/* Compute the address range to display. */
|
|
|
|
|
if (start_address == (bfd_vma) -1
|
|
|
|
|
|| start_address < section->vma)
|
|
|
|
|
start_offset = 0;
|
|
|
|
|
else
|
|
|
|
|
start_offset = start_address - section->vma;
|
|
|
|
|
|
|
|
|
|
if (stop_address == (bfd_vma) -1)
|
|
|
|
|
stop_offset = datasize / opb;
|
|
|
|
|
else
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2003-09-03 10:26:52 +02:00
|
|
|
|
if (stop_address < section->vma)
|
|
|
|
|
stop_offset = 0;
|
|
|
|
|
else
|
|
|
|
|
stop_offset = stop_address - section->vma;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2003-09-03 10:26:52 +02:00
|
|
|
|
if (stop_offset > datasize / opb)
|
|
|
|
|
stop_offset = datasize / opb;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
2008-02-26 09:44:10 +01:00
|
|
|
|
if (start_offset >= stop_offset)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
printf (_("Contents of section %s:"), section->name);
|
|
|
|
|
if (display_file_offsets)
|
2008-07-30 06:34:58 +02:00
|
|
|
|
printf (_(" (Starting at file offset: 0x%lx)"),
|
|
|
|
|
(unsigned long) (section->filepos + start_offset));
|
2008-02-26 09:44:10 +01:00
|
|
|
|
printf ("\n");
|
|
|
|
|
|
2009-09-10 15:40:44 +02:00
|
|
|
|
data = (bfd_byte *) xmalloc (datasize);
|
2008-02-26 09:44:10 +01:00
|
|
|
|
|
|
|
|
|
bfd_get_section_contents (abfd, section, data, 0, datasize);
|
|
|
|
|
|
2003-09-03 10:26:52 +02:00
|
|
|
|
width = 4;
|
2002-08-28 12:38:51 +02:00
|
|
|
|
|
2003-09-03 10:26:52 +02:00
|
|
|
|
bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
|
|
|
|
|
if (strlen (buf) >= sizeof (buf))
|
|
|
|
|
abort ();
|
2002-08-28 12:38:51 +02:00
|
|
|
|
|
2003-09-03 10:26:52 +02:00
|
|
|
|
count = 0;
|
|
|
|
|
while (buf[count] == '0' && buf[count+1] != '\0')
|
|
|
|
|
count++;
|
|
|
|
|
count = strlen (buf) - count;
|
|
|
|
|
if (count > width)
|
|
|
|
|
width = count;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2003-09-03 10:26:52 +02:00
|
|
|
|
bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
|
|
|
|
|
if (strlen (buf) >= sizeof (buf))
|
|
|
|
|
abort ();
|
2002-08-28 12:38:51 +02:00
|
|
|
|
|
2003-09-03 10:26:52 +02:00
|
|
|
|
count = 0;
|
|
|
|
|
while (buf[count] == '0' && buf[count+1] != '\0')
|
|
|
|
|
count++;
|
|
|
|
|
count = strlen (buf) - count;
|
|
|
|
|
if (count > width)
|
|
|
|
|
width = count;
|
2002-08-28 12:38:51 +02:00
|
|
|
|
|
2003-09-03 10:26:52 +02:00
|
|
|
|
for (addr_offset = start_offset;
|
|
|
|
|
addr_offset < stop_offset; addr_offset += onaline / opb)
|
1999-10-28 05:30:13 +02:00
|
|
|
|
{
|
2003-09-03 10:26:52 +02:00
|
|
|
|
bfd_size_type j;
|
1999-10-28 05:30:13 +02:00
|
|
|
|
|
2003-09-03 10:26:52 +02:00
|
|
|
|
bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
|
|
|
|
|
count = strlen (buf);
|
|
|
|
|
if ((size_t) count >= sizeof (buf))
|
|
|
|
|
abort ();
|
1999-10-28 05:30:13 +02:00
|
|
|
|
|
2003-09-03 10:26:52 +02:00
|
|
|
|
putchar (' ');
|
|
|
|
|
while (count < width)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2003-09-03 10:26:52 +02:00
|
|
|
|
putchar ('0');
|
|
|
|
|
count++;
|
|
|
|
|
}
|
|
|
|
|
fputs (buf + count - width, stdout);
|
|
|
|
|
putchar (' ');
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2003-09-03 10:26:52 +02:00
|
|
|
|
for (j = addr_offset * opb;
|
|
|
|
|
j < addr_offset * opb + onaline; j++)
|
|
|
|
|
{
|
|
|
|
|
if (j < stop_offset * opb)
|
|
|
|
|
printf ("%02x", (unsigned) (data[j]));
|
|
|
|
|
else
|
|
|
|
|
printf (" ");
|
|
|
|
|
if ((j & 3) == 3)
|
|
|
|
|
printf (" ");
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
2003-09-03 10:26:52 +02:00
|
|
|
|
printf (" ");
|
|
|
|
|
for (j = addr_offset * opb;
|
|
|
|
|
j < addr_offset * opb + onaline; j++)
|
|
|
|
|
{
|
|
|
|
|
if (j >= stop_offset * opb)
|
|
|
|
|
printf (" ");
|
|
|
|
|
else
|
|
|
|
|
printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
|
|
|
|
|
}
|
|
|
|
|
putchar ('\n');
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
2003-09-03 10:26:52 +02:00
|
|
|
|
free (data);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
2003-09-03 10:26:52 +02:00
|
|
|
|
|
2003-03-17 12:16:51 +01:00
|
|
|
|
/* Actually display the various requested regions. */
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
static void
|
2003-07-29 17:40:37 +02:00
|
|
|
|
dump_data (bfd *abfd)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2003-09-03 10:26:52 +02:00
|
|
|
|
bfd_map_over_sections (abfd, dump_section, NULL);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
2003-03-17 12:16:51 +01:00
|
|
|
|
/* Should perhaps share code and display with nm? */
|
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
static void
|
2003-07-29 17:40:37 +02:00
|
|
|
|
dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
asymbol **current;
|
|
|
|
|
long max;
|
|
|
|
|
long count;
|
|
|
|
|
|
|
|
|
|
if (dynamic)
|
|
|
|
|
{
|
|
|
|
|
current = dynsyms;
|
|
|
|
|
max = dynsymcount;
|
|
|
|
|
printf ("DYNAMIC SYMBOL TABLE:\n");
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
current = syms;
|
|
|
|
|
max = symcount;
|
|
|
|
|
printf ("SYMBOL TABLE:\n");
|
|
|
|
|
}
|
|
|
|
|
|
2002-08-26 12:14:15 +02:00
|
|
|
|
if (max == 0)
|
|
|
|
|
printf (_("no symbols\n"));
|
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
for (count = 0; count < max; count++)
|
|
|
|
|
{
|
2003-09-03 10:26:52 +02:00
|
|
|
|
bfd *cur_bfd;
|
|
|
|
|
|
|
|
|
|
if (*current == NULL)
|
2004-10-11 10:18:43 +02:00
|
|
|
|
printf (_("no information for symbol number %ld\n"), count);
|
2003-09-03 10:26:52 +02:00
|
|
|
|
|
|
|
|
|
else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
|
2004-10-11 10:18:43 +02:00
|
|
|
|
printf (_("could not determine the type of symbol number %ld\n"),
|
2003-09-03 10:26:52 +02:00
|
|
|
|
count);
|
|
|
|
|
|
2005-04-04 12:32:28 +02:00
|
|
|
|
else if (process_section_p ((* current)->section)
|
|
|
|
|
&& (dump_special_syms
|
|
|
|
|
|| !bfd_is_target_special_symbol (cur_bfd, *current)))
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2003-09-03 10:26:52 +02:00
|
|
|
|
const char *name = (*current)->name;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2003-09-03 10:26:52 +02:00
|
|
|
|
if (do_demangle && name != NULL && *name != '\0')
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
char *alloc;
|
|
|
|
|
|
2003-09-03 10:26:52 +02:00
|
|
|
|
/* If we want to demangle the name, we demangle it
|
|
|
|
|
here, and temporarily clobber it while calling
|
|
|
|
|
bfd_print_symbol. FIXME: This is a gross hack. */
|
2007-04-19 12:43:47 +02:00
|
|
|
|
alloc = bfd_demangle (cur_bfd, name, DMGL_ANSI | DMGL_PARAMS);
|
|
|
|
|
if (alloc != NULL)
|
|
|
|
|
(*current)->name = alloc;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
bfd_print_symbol (cur_bfd, stdout, *current,
|
|
|
|
|
bfd_print_symbol_all);
|
2007-04-19 12:43:47 +02:00
|
|
|
|
if (alloc != NULL)
|
|
|
|
|
{
|
|
|
|
|
(*current)->name = name;
|
|
|
|
|
free (alloc);
|
|
|
|
|
}
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
else
|
2003-09-03 10:26:52 +02:00
|
|
|
|
bfd_print_symbol (cur_bfd, stdout, *current,
|
|
|
|
|
bfd_print_symbol_all);
|
2004-10-11 10:18:43 +02:00
|
|
|
|
printf ("\n");
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
2005-04-04 12:32:28 +02:00
|
|
|
|
|
2003-09-03 10:26:52 +02:00
|
|
|
|
current++;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
2003-09-03 10:26:52 +02:00
|
|
|
|
printf ("\n\n");
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
2003-09-03 10:26:52 +02:00
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
static void
|
2003-07-29 17:40:37 +02:00
|
|
|
|
dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
arelent **p;
|
|
|
|
|
char *last_filename, *last_functionname;
|
|
|
|
|
unsigned int last_line;
|
|
|
|
|
|
|
|
|
|
/* Get column headers lined up reasonably. */
|
|
|
|
|
{
|
|
|
|
|
static int width;
|
2003-03-17 12:16:51 +01:00
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
if (width == 0)
|
|
|
|
|
{
|
|
|
|
|
char buf[30];
|
2003-09-03 10:26:52 +02:00
|
|
|
|
|
2001-08-10 18:43:18 +02:00
|
|
|
|
bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
width = strlen (buf) - 7;
|
|
|
|
|
}
|
|
|
|
|
printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
last_filename = NULL;
|
|
|
|
|
last_functionname = NULL;
|
|
|
|
|
last_line = 0;
|
|
|
|
|
|
2003-08-05 16:40:54 +02:00
|
|
|
|
for (p = relpp; relcount && *p != NULL; p++, relcount--)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
arelent *q = *p;
|
|
|
|
|
const char *filename, *functionname;
|
|
|
|
|
unsigned int line;
|
|
|
|
|
const char *sym_name;
|
|
|
|
|
const char *section_name;
|
|
|
|
|
|
|
|
|
|
if (start_address != (bfd_vma) -1
|
|
|
|
|
&& q->address < start_address)
|
|
|
|
|
continue;
|
|
|
|
|
if (stop_address != (bfd_vma) -1
|
|
|
|
|
&& q->address > stop_address)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
if (with_line_numbers
|
|
|
|
|
&& sec != NULL
|
|
|
|
|
&& bfd_find_nearest_line (abfd, sec, syms, q->address,
|
|
|
|
|
&filename, &functionname, &line))
|
|
|
|
|
{
|
|
|
|
|
if (functionname != NULL
|
|
|
|
|
&& (last_functionname == NULL
|
|
|
|
|
|| strcmp (functionname, last_functionname) != 0))
|
|
|
|
|
{
|
|
|
|
|
printf ("%s():\n", functionname);
|
|
|
|
|
if (last_functionname != NULL)
|
|
|
|
|
free (last_functionname);
|
|
|
|
|
last_functionname = xstrdup (functionname);
|
|
|
|
|
}
|
2003-03-17 12:16:51 +01:00
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
if (line > 0
|
|
|
|
|
&& (line != last_line
|
|
|
|
|
|| (filename != NULL
|
|
|
|
|
&& last_filename != NULL
|
|
|
|
|
&& strcmp (filename, last_filename) != 0)))
|
|
|
|
|
{
|
|
|
|
|
printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
|
|
|
|
|
last_line = line;
|
|
|
|
|
if (last_filename != NULL)
|
|
|
|
|
free (last_filename);
|
|
|
|
|
if (filename == NULL)
|
|
|
|
|
last_filename = NULL;
|
|
|
|
|
else
|
|
|
|
|
last_filename = xstrdup (filename);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
}
|
2003-03-17 12:16:51 +01:00
|
|
|
|
|
2005-06-09 16:51:41 +02:00
|
|
|
|
bfd_printf_vma (abfd, q->address);
|
|
|
|
|
if (q->howto == NULL)
|
|
|
|
|
printf (" *unknown* ");
|
|
|
|
|
else if (q->howto->name)
|
|
|
|
|
printf (" %-16s ", q->howto->name);
|
|
|
|
|
else
|
|
|
|
|
printf (" %-16d ", q->howto->type);
|
2008-12-04 09:04:47 +01:00
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
if (sym_name)
|
2008-12-04 09:04:47 +01:00
|
|
|
|
{
|
|
|
|
|
objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
|
|
|
|
|
}
|
1999-05-03 09:29:11 +02:00
|
|
|
|
else
|
|
|
|
|
{
|
2003-08-05 16:40:54 +02:00
|
|
|
|
if (section_name == NULL)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
section_name = "*unknown*";
|
2005-06-09 16:51:41 +02:00
|
|
|
|
printf ("[%s]", section_name);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
2003-03-17 12:16:51 +01:00
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
if (q->addend)
|
|
|
|
|
{
|
|
|
|
|
printf ("+0x");
|
2001-08-10 18:43:18 +02:00
|
|
|
|
bfd_printf_vma (abfd, q->addend);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
2003-03-17 12:16:51 +01:00
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
printf ("\n");
|
|
|
|
|
}
|
|
|
|
|
}
|
2003-08-04 16:29:34 +02:00
|
|
|
|
|
2003-09-03 10:26:52 +02:00
|
|
|
|
static void
|
2003-11-19 09:21:14 +01:00
|
|
|
|
dump_relocs_in_section (bfd *abfd,
|
|
|
|
|
asection *section,
|
|
|
|
|
void *dummy ATTRIBUTE_UNUSED)
|
2003-09-03 10:26:52 +02:00
|
|
|
|
{
|
|
|
|
|
arelent **relpp;
|
|
|
|
|
long relcount;
|
|
|
|
|
long relsize;
|
|
|
|
|
|
|
|
|
|
if ( bfd_is_abs_section (section)
|
|
|
|
|
|| bfd_is_und_section (section)
|
|
|
|
|
|| bfd_is_com_section (section)
|
|
|
|
|
|| (! process_section_p (section))
|
|
|
|
|
|| ((section->flags & SEC_RELOC) == 0))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
relsize = bfd_get_reloc_upper_bound (abfd, section);
|
|
|
|
|
if (relsize < 0)
|
|
|
|
|
bfd_fatal (bfd_get_filename (abfd));
|
|
|
|
|
|
|
|
|
|
printf ("RELOCATION RECORDS FOR [%s]:", section->name);
|
|
|
|
|
|
|
|
|
|
if (relsize == 0)
|
|
|
|
|
{
|
|
|
|
|
printf (" (none)\n\n");
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2009-09-10 15:40:44 +02:00
|
|
|
|
relpp = (arelent **) xmalloc (relsize);
|
2003-09-03 10:26:52 +02:00
|
|
|
|
relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
|
|
|
|
|
|
|
|
|
|
if (relcount < 0)
|
|
|
|
|
bfd_fatal (bfd_get_filename (abfd));
|
|
|
|
|
else if (relcount == 0)
|
|
|
|
|
printf (" (none)\n\n");
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
printf ("\n");
|
|
|
|
|
dump_reloc_set (abfd, section, relpp, relcount);
|
|
|
|
|
printf ("\n\n");
|
|
|
|
|
}
|
|
|
|
|
free (relpp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
dump_relocs (bfd *abfd)
|
|
|
|
|
{
|
|
|
|
|
bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
dump_dynamic_relocs (bfd *abfd)
|
|
|
|
|
{
|
|
|
|
|
long relsize;
|
|
|
|
|
arelent **relpp;
|
|
|
|
|
long relcount;
|
|
|
|
|
|
|
|
|
|
relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
|
|
|
|
|
if (relsize < 0)
|
|
|
|
|
bfd_fatal (bfd_get_filename (abfd));
|
|
|
|
|
|
|
|
|
|
printf ("DYNAMIC RELOCATION RECORDS");
|
|
|
|
|
|
|
|
|
|
if (relsize == 0)
|
|
|
|
|
printf (" (none)\n\n");
|
|
|
|
|
else
|
|
|
|
|
{
|
2009-09-10 15:40:44 +02:00
|
|
|
|
relpp = (arelent **) xmalloc (relsize);
|
2003-09-03 10:26:52 +02:00
|
|
|
|
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, NULL, relpp, relcount);
|
|
|
|
|
printf ("\n\n");
|
|
|
|
|
}
|
|
|
|
|
free (relpp);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2003-08-04 16:29:34 +02:00
|
|
|
|
/* Creates a table of paths, to search for source files. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
add_include_path (const char *path)
|
|
|
|
|
{
|
|
|
|
|
if (path[0] == 0)
|
|
|
|
|
return;
|
|
|
|
|
include_path_count++;
|
2009-09-10 15:40:44 +02:00
|
|
|
|
include_paths = (const char **)
|
|
|
|
|
xrealloc (include_paths, include_path_count * sizeof (*include_paths));
|
2003-08-04 16:29:34 +02:00
|
|
|
|
#ifdef HAVE_DOS_BASED_FILE_SYSTEM
|
|
|
|
|
if (path[1] == ':' && path[2] == 0)
|
|
|
|
|
path = concat (path, ".", (const char *) 0);
|
|
|
|
|
#endif
|
|
|
|
|
include_paths[include_path_count - 1] = path;
|
|
|
|
|
}
|
2003-09-03 10:26:52 +02:00
|
|
|
|
|
|
|
|
|
static void
|
2003-11-19 09:21:14 +01:00
|
|
|
|
adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
|
|
|
|
|
asection *section,
|
2005-08-17 16:28:01 +02:00
|
|
|
|
void *arg)
|
2003-09-03 10:26:52 +02:00
|
|
|
|
{
|
2005-08-17 16:28:01 +02:00
|
|
|
|
if ((section->flags & SEC_DEBUGGING) == 0)
|
|
|
|
|
{
|
|
|
|
|
bfd_boolean *has_reloc_p = (bfd_boolean *) arg;
|
|
|
|
|
section->vma += adjust_section_vma;
|
|
|
|
|
if (*has_reloc_p)
|
|
|
|
|
section->lma += adjust_section_vma;
|
|
|
|
|
}
|
2003-09-03 10:26:52 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Dump selected contents of ABFD. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
dump_bfd (bfd *abfd)
|
|
|
|
|
{
|
|
|
|
|
/* If we are adjusting section VMA's, change them all now. Changing
|
|
|
|
|
the BFD information is a hack. However, we must do it, or
|
|
|
|
|
bfd_find_nearest_line will not do the right thing. */
|
|
|
|
|
if (adjust_section_vma != 0)
|
2005-08-17 16:28:01 +02:00
|
|
|
|
{
|
|
|
|
|
bfd_boolean has_reloc = (abfd->flags & HAS_RELOC);
|
|
|
|
|
bfd_map_over_sections (abfd, adjust_addresses, &has_reloc);
|
|
|
|
|
}
|
2003-09-03 10:26:52 +02:00
|
|
|
|
|
|
|
|
|
if (! dump_debugging_tags)
|
|
|
|
|
printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd),
|
|
|
|
|
abfd->xvec->name);
|
|
|
|
|
if (dump_ar_hdrs)
|
|
|
|
|
print_arelt_descr (stdout, abfd, TRUE);
|
|
|
|
|
if (dump_file_header)
|
|
|
|
|
dump_bfd_header (abfd);
|
|
|
|
|
if (dump_private_headers)
|
|
|
|
|
dump_bfd_private_header (abfd);
|
|
|
|
|
if (! dump_debugging_tags)
|
|
|
|
|
putchar ('\n');
|
|
|
|
|
if (dump_section_headers)
|
|
|
|
|
dump_headers (abfd);
|
|
|
|
|
|
2005-09-30 16:56:34 +02:00
|
|
|
|
if (dump_symtab
|
|
|
|
|
|| dump_reloc_info
|
|
|
|
|
|| disassemble
|
|
|
|
|
|| dump_debugging
|
|
|
|
|
|| dump_dwarf_section_info)
|
2003-09-03 10:26:52 +02:00
|
|
|
|
syms = slurp_symtab (abfd);
|
2004-04-22 16:45:32 +02:00
|
|
|
|
if (dump_dynamic_symtab || dump_dynamic_reloc_info
|
|
|
|
|
|| (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
|
2003-09-03 10:26:52 +02:00
|
|
|
|
dynsyms = slurp_dynamic_symtab (abfd);
|
2004-08-17 11:07:35 +02:00
|
|
|
|
if (disassemble)
|
2004-04-22 16:45:32 +02:00
|
|
|
|
{
|
2004-08-28 05:05:18 +02:00
|
|
|
|
synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms,
|
|
|
|
|
dynsymcount, dynsyms, &synthsyms);
|
|
|
|
|
if (synthcount < 0)
|
|
|
|
|
synthcount = 0;
|
2004-04-22 16:45:32 +02:00
|
|
|
|
}
|
2003-09-03 10:26:52 +02:00
|
|
|
|
|
|
|
|
|
if (dump_symtab)
|
|
|
|
|
dump_symbols (abfd, FALSE);
|
|
|
|
|
if (dump_dynamic_symtab)
|
|
|
|
|
dump_symbols (abfd, TRUE);
|
2005-09-30 16:56:34 +02:00
|
|
|
|
if (dump_dwarf_section_info)
|
|
|
|
|
dump_dwarf (abfd);
|
2003-09-03 10:26:52 +02:00
|
|
|
|
if (dump_stab_section_info)
|
|
|
|
|
dump_stabs (abfd);
|
|
|
|
|
if (dump_reloc_info && ! disassemble)
|
|
|
|
|
dump_relocs (abfd);
|
|
|
|
|
if (dump_dynamic_reloc_info && ! disassemble)
|
|
|
|
|
dump_dynamic_relocs (abfd);
|
|
|
|
|
if (dump_section_contents)
|
|
|
|
|
dump_data (abfd);
|
|
|
|
|
if (disassemble)
|
|
|
|
|
disassemble_data (abfd);
|
|
|
|
|
|
|
|
|
|
if (dump_debugging)
|
|
|
|
|
{
|
|
|
|
|
void *dhandle;
|
|
|
|
|
|
2008-06-12 13:57:40 +02:00
|
|
|
|
dhandle = read_debugging_info (abfd, syms, symcount, TRUE);
|
2003-09-03 10:26:52 +02:00
|
|
|
|
if (dhandle != NULL)
|
|
|
|
|
{
|
2007-04-19 12:43:47 +02:00
|
|
|
|
if (!print_debugging_info (stdout, dhandle, abfd, syms,
|
|
|
|
|
bfd_demangle,
|
|
|
|
|
dump_debugging_tags ? TRUE : FALSE))
|
2003-09-03 10:26:52 +02:00
|
|
|
|
{
|
|
|
|
|
non_fatal (_("%s: printing debugging information failed"),
|
|
|
|
|
bfd_get_filename (abfd));
|
|
|
|
|
exit_status = 1;
|
|
|
|
|
}
|
|
|
|
|
}
|
2008-06-12 13:57:40 +02:00
|
|
|
|
/* PR 6483: If there was no STABS or IEEE debug
|
|
|
|
|
info in the file, try DWARF instead. */
|
|
|
|
|
else if (! dump_dwarf_section_info)
|
|
|
|
|
{
|
|
|
|
|
dump_dwarf (abfd);
|
|
|
|
|
}
|
2003-09-03 10:26:52 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (syms)
|
|
|
|
|
{
|
|
|
|
|
free (syms);
|
|
|
|
|
syms = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (dynsyms)
|
|
|
|
|
{
|
|
|
|
|
free (dynsyms);
|
|
|
|
|
dynsyms = NULL;
|
|
|
|
|
}
|
2004-04-22 16:45:32 +02:00
|
|
|
|
|
|
|
|
|
if (synthsyms)
|
|
|
|
|
{
|
|
|
|
|
free (synthsyms);
|
|
|
|
|
synthsyms = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
symcount = 0;
|
|
|
|
|
dynsymcount = 0;
|
|
|
|
|
synthcount = 0;
|
2003-09-03 10:26:52 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
display_bfd (bfd *abfd)
|
|
|
|
|
{
|
|
|
|
|
char **matching;
|
|
|
|
|
|
|
|
|
|
if (bfd_check_format_matches (abfd, bfd_object, &matching))
|
|
|
|
|
{
|
|
|
|
|
dump_bfd (abfd);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
|
|
|
|
|
{
|
|
|
|
|
nonfatal (bfd_get_filename (abfd));
|
|
|
|
|
list_matching_formats (matching);
|
|
|
|
|
free (matching);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (bfd_get_error () != bfd_error_file_not_recognized)
|
|
|
|
|
{
|
|
|
|
|
nonfatal (bfd_get_filename (abfd));
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (bfd_check_format_matches (abfd, bfd_core, &matching))
|
|
|
|
|
{
|
|
|
|
|
dump_bfd (abfd);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
nonfatal (bfd_get_filename (abfd));
|
|
|
|
|
|
|
|
|
|
if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
|
|
|
|
|
{
|
|
|
|
|
list_matching_formats (matching);
|
|
|
|
|
free (matching);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
display_file (char *filename, char *target)
|
|
|
|
|
{
|
2003-11-07 13:19:34 +01:00
|
|
|
|
bfd *file;
|
|
|
|
|
bfd *arfile = NULL;
|
|
|
|
|
|
|
|
|
|
if (get_file_size (filename) < 1)
|
2006-08-06 17:49:46 +02:00
|
|
|
|
{
|
|
|
|
|
exit_status = 1;
|
|
|
|
|
return;
|
|
|
|
|
}
|
2003-09-03 10:26:52 +02:00
|
|
|
|
|
|
|
|
|
file = bfd_openr (filename, target);
|
|
|
|
|
if (file == NULL)
|
|
|
|
|
{
|
|
|
|
|
nonfatal (filename);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* If the file is an archive, process all of its elements. */
|
|
|
|
|
if (bfd_check_format (file, bfd_archive))
|
|
|
|
|
{
|
|
|
|
|
bfd *last_arfile = NULL;
|
|
|
|
|
|
|
|
|
|
printf (_("In archive %s:\n"), bfd_get_filename (file));
|
|
|
|
|
for (;;)
|
|
|
|
|
{
|
|
|
|
|
bfd_set_error (bfd_error_no_error);
|
|
|
|
|
|
|
|
|
|
arfile = bfd_openr_next_archived_file (file, arfile);
|
|
|
|
|
if (arfile == NULL)
|
|
|
|
|
{
|
|
|
|
|
if (bfd_get_error () != bfd_error_no_more_archived_files)
|
|
|
|
|
nonfatal (bfd_get_filename (file));
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
display_bfd (arfile);
|
|
|
|
|
|
|
|
|
|
if (last_arfile != NULL)
|
|
|
|
|
bfd_close (last_arfile);
|
|
|
|
|
last_arfile = arfile;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (last_arfile != NULL)
|
|
|
|
|
bfd_close (last_arfile);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
display_bfd (file);
|
|
|
|
|
|
|
|
|
|
bfd_close (file);
|
|
|
|
|
}
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
int
|
2003-07-29 17:40:37 +02:00
|
|
|
|
main (int argc, char **argv)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
int c;
|
|
|
|
|
char *target = default_target;
|
2002-11-30 09:39:46 +01:00
|
|
|
|
bfd_boolean seenflag = FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2003-09-03 10:26:52 +02:00
|
|
|
|
#if defined (HAVE_SETLOCALE)
|
|
|
|
|
#if defined (HAVE_LC_MESSAGES)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
setlocale (LC_MESSAGES, "");
|
2001-09-19 07:33:36 +02:00
|
|
|
|
#endif
|
|
|
|
|
setlocale (LC_CTYPE, "");
|
1999-05-03 09:29:11 +02:00
|
|
|
|
#endif
|
2003-09-03 10:26:52 +02:00
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
bindtextdomain (PACKAGE, LOCALEDIR);
|
|
|
|
|
textdomain (PACKAGE);
|
|
|
|
|
|
|
|
|
|
program_name = *argv;
|
|
|
|
|
xmalloc_set_program_name (program_name);
|
|
|
|
|
|
|
|
|
|
START_PROGRESS (program_name, 0);
|
|
|
|
|
|
2005-09-30 18:37:32 +02:00
|
|
|
|
expandargv (&argc, &argv);
|
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
bfd_init ();
|
|
|
|
|
set_default_bfd_target ();
|
|
|
|
|
|
2009-02-09 10:14:15 +01:00
|
|
|
|
while ((c = getopt_long (argc, argv,
|
|
|
|
|
"pib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
|
1999-05-03 09:29:11 +02:00
|
|
|
|
long_options, (int *) 0))
|
|
|
|
|
!= EOF)
|
|
|
|
|
{
|
|
|
|
|
switch (c)
|
|
|
|
|
{
|
|
|
|
|
case 0:
|
2002-01-23 17:12:56 +01:00
|
|
|
|
break; /* We've been given a long option. */
|
1999-05-03 09:29:11 +02:00
|
|
|
|
case 'm':
|
|
|
|
|
machine = optarg;
|
|
|
|
|
break;
|
1999-06-16 04:24:36 +02:00
|
|
|
|
case 'M':
|
2003-07-17 19:02:46 +02:00
|
|
|
|
if (disassembler_options)
|
2003-07-18 13:34:41 +02:00
|
|
|
|
/* Ignore potential memory leak for now. */
|
2003-07-29 17:40:37 +02:00
|
|
|
|
disassembler_options = concat (disassembler_options, ",",
|
2008-02-07 09:39:54 +01:00
|
|
|
|
optarg, (const char *) NULL);
|
2003-07-18 13:34:41 +02:00
|
|
|
|
else
|
|
|
|
|
disassembler_options = optarg;
|
1999-06-16 04:24:36 +02:00
|
|
|
|
break;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
case 'j':
|
2003-08-04 16:29:34 +02:00
|
|
|
|
if (only_used == only_size)
|
2003-05-01 02:40:41 +02:00
|
|
|
|
{
|
|
|
|
|
only_size += 8;
|
2009-09-10 15:40:44 +02:00
|
|
|
|
only = (char **) xrealloc (only, only_size * sizeof (char *));
|
2003-05-01 02:40:41 +02:00
|
|
|
|
}
|
|
|
|
|
only [only_used++] = optarg;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
break;
|
2008-02-22 10:42:58 +01:00
|
|
|
|
case 'F':
|
|
|
|
|
display_file_offsets = TRUE;
|
|
|
|
|
break;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
case 'l':
|
2002-11-30 09:39:46 +01:00
|
|
|
|
with_line_numbers = TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
break;
|
|
|
|
|
case 'b':
|
|
|
|
|
target = optarg;
|
|
|
|
|
break;
|
1999-11-21 12:37:21 +01:00
|
|
|
|
case 'C':
|
2002-11-30 09:39:46 +01:00
|
|
|
|
do_demangle = TRUE;
|
2000-07-20 20:02:56 +02:00
|
|
|
|
if (optarg != NULL)
|
|
|
|
|
{
|
|
|
|
|
enum demangling_styles style;
|
2002-01-23 17:12:56 +01:00
|
|
|
|
|
2000-07-20 20:02:56 +02:00
|
|
|
|
style = cplus_demangle_name_to_style (optarg);
|
2002-05-21 21:34:58 +02:00
|
|
|
|
if (style == unknown_demangling)
|
2000-07-20 20:02:56 +02:00
|
|
|
|
fatal (_("unknown demangling style `%s'"),
|
|
|
|
|
optarg);
|
2002-01-23 17:12:56 +01:00
|
|
|
|
|
2000-07-20 20:02:56 +02:00
|
|
|
|
cplus_demangle_set_style (style);
|
2002-05-21 21:34:58 +02:00
|
|
|
|
}
|
1999-11-21 12:37:21 +01:00
|
|
|
|
break;
|
|
|
|
|
case 'w':
|
2002-11-30 09:39:46 +01:00
|
|
|
|
wide_output = TRUE;
|
1999-11-21 12:37:21 +01:00
|
|
|
|
break;
|
|
|
|
|
case OPTION_ADJUST_VMA:
|
|
|
|
|
adjust_section_vma = parse_vma (optarg, "--adjust-vma");
|
|
|
|
|
break;
|
|
|
|
|
case OPTION_START_ADDRESS:
|
|
|
|
|
start_address = parse_vma (optarg, "--start-address");
|
2008-02-22 10:42:58 +01:00
|
|
|
|
if ((stop_address != (bfd_vma) -1) && stop_address <= start_address)
|
|
|
|
|
fatal (_("error: the start address should be before the end address"));
|
1999-11-21 12:37:21 +01:00
|
|
|
|
break;
|
|
|
|
|
case OPTION_STOP_ADDRESS:
|
|
|
|
|
stop_address = parse_vma (optarg, "--stop-address");
|
2008-02-22 10:42:58 +01:00
|
|
|
|
if ((start_address != (bfd_vma) -1) && stop_address <= start_address)
|
|
|
|
|
fatal (_("error: the stop address should be after the start address"));
|
1999-11-21 12:37:21 +01:00
|
|
|
|
break;
|
2009-02-03 16:48:50 +01:00
|
|
|
|
case OPTION_PREFIX:
|
|
|
|
|
prefix = optarg;
|
|
|
|
|
prefix_length = strlen (prefix);
|
|
|
|
|
/* Remove an unnecessary trailing '/' */
|
|
|
|
|
while (IS_DIR_SEPARATOR (prefix[prefix_length - 1]))
|
|
|
|
|
prefix_length--;
|
|
|
|
|
break;
|
|
|
|
|
case OPTION_PREFIX_STRIP:
|
|
|
|
|
prefix_strip = atoi (optarg);
|
|
|
|
|
if (prefix_strip < 0)
|
|
|
|
|
fatal (_("error: prefix strip must be non-negative"));
|
|
|
|
|
break;
|
2009-07-20 15:40:48 +02:00
|
|
|
|
case OPTION_INSN_WIDTH:
|
|
|
|
|
insn_width = strtoul (optarg, NULL, 0);
|
|
|
|
|
if (insn_width <= 0)
|
|
|
|
|
fatal (_("error: instruction width must be positive"));
|
|
|
|
|
break;
|
1999-11-21 12:37:21 +01:00
|
|
|
|
case 'E':
|
|
|
|
|
if (strcmp (optarg, "B") == 0)
|
|
|
|
|
endian = BFD_ENDIAN_BIG;
|
|
|
|
|
else if (strcmp (optarg, "L") == 0)
|
|
|
|
|
endian = BFD_ENDIAN_LITTLE;
|
|
|
|
|
else
|
|
|
|
|
{
|
2000-04-07 06:34:50 +02:00
|
|
|
|
non_fatal (_("unrecognized -E option"));
|
1999-11-21 12:37:21 +01:00
|
|
|
|
usage (stderr, 1);
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case OPTION_ENDIAN:
|
|
|
|
|
if (strncmp (optarg, "big", strlen (optarg)) == 0)
|
|
|
|
|
endian = BFD_ENDIAN_BIG;
|
|
|
|
|
else if (strncmp (optarg, "little", strlen (optarg)) == 0)
|
|
|
|
|
endian = BFD_ENDIAN_LITTLE;
|
|
|
|
|
else
|
|
|
|
|
{
|
2000-04-07 06:34:50 +02:00
|
|
|
|
non_fatal (_("unrecognized --endian type `%s'"), optarg);
|
1999-11-21 12:37:21 +01:00
|
|
|
|
usage (stderr, 1);
|
|
|
|
|
}
|
|
|
|
|
break;
|
2002-01-23 17:12:56 +01:00
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
case 'f':
|
2002-11-30 09:39:46 +01:00
|
|
|
|
dump_file_header = TRUE;
|
|
|
|
|
seenflag = TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
break;
|
|
|
|
|
case 'i':
|
2002-11-30 09:39:46 +01:00
|
|
|
|
formats_info = TRUE;
|
|
|
|
|
seenflag = TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
break;
|
2003-08-04 16:29:34 +02:00
|
|
|
|
case 'I':
|
|
|
|
|
add_include_path (optarg);
|
|
|
|
|
break;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
case 'p':
|
2002-11-30 09:39:46 +01:00
|
|
|
|
dump_private_headers = TRUE;
|
|
|
|
|
seenflag = TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
break;
|
|
|
|
|
case 'x':
|
2002-11-30 09:39:46 +01:00
|
|
|
|
dump_private_headers = TRUE;
|
|
|
|
|
dump_symtab = TRUE;
|
|
|
|
|
dump_reloc_info = TRUE;
|
|
|
|
|
dump_file_header = TRUE;
|
|
|
|
|
dump_ar_hdrs = TRUE;
|
|
|
|
|
dump_section_headers = TRUE;
|
|
|
|
|
seenflag = TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
break;
|
|
|
|
|
case 't':
|
2002-11-30 09:39:46 +01:00
|
|
|
|
dump_symtab = TRUE;
|
|
|
|
|
seenflag = TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
break;
|
|
|
|
|
case 'T':
|
2002-11-30 09:39:46 +01:00
|
|
|
|
dump_dynamic_symtab = TRUE;
|
|
|
|
|
seenflag = TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
break;
|
|
|
|
|
case 'd':
|
2002-11-30 09:39:46 +01:00
|
|
|
|
disassemble = TRUE;
|
|
|
|
|
seenflag = TRUE;
|
1999-11-21 12:37:21 +01:00
|
|
|
|
break;
|
|
|
|
|
case 'z':
|
2002-11-30 09:39:46 +01:00
|
|
|
|
disassemble_zeroes = TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
break;
|
|
|
|
|
case 'D':
|
2002-11-30 09:39:46 +01:00
|
|
|
|
disassemble = TRUE;
|
|
|
|
|
disassemble_all = TRUE;
|
|
|
|
|
seenflag = TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
break;
|
|
|
|
|
case 'S':
|
2002-11-30 09:39:46 +01:00
|
|
|
|
disassemble = TRUE;
|
|
|
|
|
with_source_code = TRUE;
|
|
|
|
|
seenflag = TRUE;
|
1999-11-21 12:37:21 +01:00
|
|
|
|
break;
|
|
|
|
|
case 'g':
|
|
|
|
|
dump_debugging = 1;
|
2002-11-30 09:39:46 +01:00
|
|
|
|
seenflag = TRUE;
|
1999-11-21 12:37:21 +01:00
|
|
|
|
break;
|
2003-07-22 15:33:32 +02:00
|
|
|
|
case 'e':
|
|
|
|
|
dump_debugging = 1;
|
|
|
|
|
dump_debugging_tags = 1;
|
|
|
|
|
do_demangle = TRUE;
|
|
|
|
|
seenflag = TRUE;
|
|
|
|
|
break;
|
2005-09-30 16:56:34 +02:00
|
|
|
|
case 'W':
|
|
|
|
|
dump_dwarf_section_info = TRUE;
|
|
|
|
|
seenflag = TRUE;
|
2009-02-09 10:14:15 +01:00
|
|
|
|
if (optarg)
|
|
|
|
|
dwarf_select_sections_by_letters (optarg);
|
|
|
|
|
else
|
|
|
|
|
dwarf_select_sections_all ();
|
|
|
|
|
break;
|
|
|
|
|
case OPTION_DWARF:
|
|
|
|
|
dump_dwarf_section_info = TRUE;
|
|
|
|
|
seenflag = TRUE;
|
|
|
|
|
if (optarg)
|
|
|
|
|
dwarf_select_sections_by_names (optarg);
|
|
|
|
|
else
|
|
|
|
|
dwarf_select_sections_all ();
|
2005-09-30 16:56:34 +02:00
|
|
|
|
break;
|
1999-11-21 12:37:21 +01:00
|
|
|
|
case 'G':
|
2002-11-30 09:39:46 +01:00
|
|
|
|
dump_stab_section_info = TRUE;
|
|
|
|
|
seenflag = TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
break;
|
|
|
|
|
case 's':
|
2002-11-30 09:39:46 +01:00
|
|
|
|
dump_section_contents = TRUE;
|
|
|
|
|
seenflag = TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
break;
|
|
|
|
|
case 'r':
|
2002-11-30 09:39:46 +01:00
|
|
|
|
dump_reloc_info = TRUE;
|
|
|
|
|
seenflag = TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
break;
|
|
|
|
|
case 'R':
|
2002-11-30 09:39:46 +01:00
|
|
|
|
dump_dynamic_reloc_info = TRUE;
|
|
|
|
|
seenflag = TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
break;
|
|
|
|
|
case 'a':
|
2002-11-30 09:39:46 +01:00
|
|
|
|
dump_ar_hdrs = TRUE;
|
|
|
|
|
seenflag = TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
break;
|
|
|
|
|
case 'h':
|
2002-11-30 09:39:46 +01:00
|
|
|
|
dump_section_headers = TRUE;
|
|
|
|
|
seenflag = TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
break;
|
|
|
|
|
case 'H':
|
|
|
|
|
usage (stdout, 0);
|
2002-11-30 09:39:46 +01:00
|
|
|
|
seenflag = TRUE;
|
2002-01-23 17:12:56 +01:00
|
|
|
|
case 'v':
|
1999-05-03 09:29:11 +02:00
|
|
|
|
case 'V':
|
2002-11-30 09:39:46 +01:00
|
|
|
|
show_version = TRUE;
|
|
|
|
|
seenflag = TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
break;
|
2002-05-21 21:34:58 +02:00
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
default:
|
|
|
|
|
usage (stderr, 1);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (show_version)
|
|
|
|
|
print_version ("objdump");
|
|
|
|
|
|
2002-11-30 09:39:46 +01:00
|
|
|
|
if (!seenflag)
|
1999-11-21 12:37:21 +01:00
|
|
|
|
usage (stderr, 2);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
if (formats_info)
|
2003-03-24 12:28:35 +01:00
|
|
|
|
exit_status = display_info ();
|
1999-05-03 09:29:11 +02:00
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (optind == argc)
|
|
|
|
|
display_file ("a.out", target);
|
|
|
|
|
else
|
|
|
|
|
for (; optind < argc;)
|
|
|
|
|
display_file (argv[optind++], target);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
END_PROGRESS (program_name);
|
|
|
|
|
|
1999-08-09 07:23:29 +02:00
|
|
|
|
return exit_status;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|