Google Git
Sign in
gnu / binutils-gdb / 4076f962e8cd73219dfd48a6f682df1ab391c48c / . / binutils / objdump.c
blob: 324254658c609fa78ed8b1720736e1f9954f7a03 [file] [log] [blame]
/* objdump.c -- dump information about an object file.
Copyright (C) 1990-2024 Free Software Foundation, Inc.
This file is part of GNU Binutils.
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
the Free Software Foundation; either version 3, or (at your option)
any later version.
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.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, 51 Franklin Street - Fifth Floor, Boston,
MA 02110-1301, USA. */
/* 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.
3. The file's target architecture and binary file format are determined
by bfd_check_format(). If they are recognised, then dump_bfd() is
called.
4. dump_bfd() in turn calls separate functions to display the requested
item(s) of information(s). For example disassemble_data() is called if
a disassembly has been requested.
When disassembling the code loops through blocks of instructions bounded
by symbols, calling disassemble_bytes() on each block. The actual
disassembling is done by the libopcodes library, via a function pointer
supplied by the disassembler() function. */
#include "sysdep.h"
#include "bfd.h"
#include "elf-bfd.h"
#include "coff-bfd.h"
#include "bucomm.h"
#include "elfcomm.h"
#include "demanguse.h"
#include "dwarf.h"
#include "ctf-api.h"
#include "sframe-api.h"
#include "getopt.h"
#include "safe-ctype.h"
#include "dis-asm.h"
#include "libiberty.h"
#include "demangle.h"
#include "filenames.h"
#include "debug.h"
#include "budbg.h"
#include "objdump.h"
#ifdef HAVE_MMAP
#include <sys/mman.h>
#endif
#ifdef HAVE_LIBDEBUGINFOD
#include <elfutils/debuginfod.h>
#endif
/* Internal headers for the ELF .stab-dump code - sorry. */
#define BYTES_IN_WORD 32
#include "aout/aout64.h"
/* Exit status. */
static int exit_status = 0;
static char *default_target = NULL; /* Default at runtime. */
/* The following variables are set based on arguments passed on the
command line. */
static int show_version = 0; /* Show the version number. */
static int dump_section_contents; /* -s */
static int dump_section_headers; /* -h */
static bool dump_file_header; /* -f */
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 char *dump_private_options; /* -P */
static int no_addresses; /* --no-addresses */
static int prefix_addresses; /* --prefix-addresses */
static int with_line_numbers; /* -l */
static bool with_source_code; /* -S */
static int show_raw_insn; /* --show-raw-insn */
static int dump_dwarf_section_info; /* --dwarf */
static int dump_stab_section_info; /* --stabs */
static int dump_ctf_section_info; /* --ctf */
static char *dump_ctf_section_name;
static char *dump_ctf_parent_name; /* --ctf-parent */
static char *dump_ctf_parent_section_name; /* --ctf-parent-section */
static int dump_sframe_section_info; /* --sframe */
static char *dump_sframe_section_name;
static int do_demangle; /* -C, --demangle */
static bool disassemble; /* -d */
static bool disassemble_all; /* -D */
static int disassemble_zeroes; /* --disassemble-zeroes */
static bool formats_info; /* -i */
int wide_output; /* -w */
static int insn_width; /* --insn-width */
static bfd_vma start_address = (bfd_vma) -1; /* --start-address */
static bfd_vma stop_address = (bfd_vma) -1; /* --stop-address */
static int dump_debugging; /* --debugging */
static int dump_debugging_tags; /* --debugging-tags */
static int suppress_bfd_header;
static int dump_special_syms = 0; /* --special-syms */
static bfd_vma adjust_section_vma = 0; /* --adjust-vma */
static int file_start_context = 0; /* --file-start-context */
static bool display_file_offsets; /* -F */
static const char *prefix; /* --prefix */
static int prefix_strip; /* --prefix-strip */
static size_t prefix_length;
static bool unwind_inlines; /* --inlines. */
static const char * disasm_sym; /* Disassembly start symbol. */
static const char * source_comment; /* --source_comment. */
static bool visualize_jumps = false; /* --visualize-jumps. */
static bool color_output = false; /* --visualize-jumps=color. */
static bool extended_color_output = false; /* --visualize-jumps=extended-color. */
static int process_links = false; /* --process-links. */
static int show_all_symbols; /* --show-all-symbols. */
static bool decompressed_dumps = false; /* -Z, --decompress. */
static enum color_selection
{
on_if_terminal_output,
on, /* --disassembler-color=color. */
off, /* --disassembler-color=off. */
extended /* --disassembler-color=extended-color. */
} disassembler_color =
#if DEFAULT_FOR_COLORED_DISASSEMBLY
on_if_terminal_output;
#else
off;
#endif
static int dump_any_debugging;
static int demangle_flags = DMGL_ANSI | DMGL_PARAMS;
/* This is reset to false each time we enter the disassembler, and set true
when the disassembler emits something in the dis_style_comment_start
style. Once this is true, all further output on that line is done in
the comment style. This only has an effect when disassembler coloring
is turned on. */
static bool disassembler_in_comment = false;
/* A structure to record the sections mentioned in -j switches. */
struct only
{
const char *name; /* The name of the section. */
bool seen; /* A flag to indicate that the section has been found in one or more input files. */
struct only *next; /* Pointer to the next structure in the list. */
};
/* Pointer to an array of 'only' structures.
This pointer is NULL if the -j switch has not been used. */
static struct only * only_list = NULL;
/* Variables for handling include file path table. */
static const char **include_paths;
static int include_path_count;
/* Extra info to pass to the section disassembler and address printing
function. */
struct objdump_disasm_info
{
bfd *abfd;
bool require_sec;
disassembler_ftype disassemble_fn;
arelent *reloc;
const char *symbol;
};
/* Architecture to disassemble for, or default if NULL. */
static char *machine = NULL;
/* Target specific options to the disassembler. */
static char *disassembler_options = NULL;
/* 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;
/* The synthetic symbol table. */
static asymbol *synthsyms;
static long synthcount = 0;
/* Number of symbols in `dynsyms'. */
static long dynsymcount = 0;
static bfd_byte *stabs;
static bfd_size_type stab_size;
static bfd_byte *strtab;
static bfd_size_type stabstr_size;
/* Handlers for -P/--private. */
static const struct objdump_private_desc * const objdump_private_vectors[] =
{
OBJDUMP_PRIVATE_VECTORS
NULL
};
/* The list of detected jumps inside a function. */
static struct jump_info *detected_jumps = NULL;
typedef enum unicode_display_type
{
unicode_default = 0,
unicode_locale,
unicode_escape,
unicode_hex,
unicode_highlight,
unicode_invalid
} unicode_display_type;
static unicode_display_type unicode_display = unicode_default;
static void usage (FILE *, int) ATTRIBUTE_NORETURN;
static void
usage (FILE *stream, int status)
{
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"));
fprintf (stream, _("\
-a, --archive-headers Display archive header information\n"));
fprintf (stream, _("\
-f, --file-headers Display the contents of the overall file header\n"));
fprintf (stream, _("\
-p, --private-headers Display object format specific file header contents\n"));
fprintf (stream, _("\
-P, --private=OPT,OPT... Display object format specific contents\n"));
fprintf (stream, _("\
-h, --[section-]headers Display the contents of the section headers\n"));
fprintf (stream, _("\
-x, --all-headers Display the contents of all headers\n"));
fprintf (stream, _("\
-d, --disassemble Display assembler contents of executable sections\n"));
fprintf (stream, _("\
-D, --disassemble-all Display assembler contents of all sections\n"));
fprintf (stream, _("\
--disassemble=<sym> Display assembler contents from <sym>\n"));
fprintf (stream, _("\
-S, --source Intermix source code with disassembly\n"));
fprintf (stream, _("\
--source-comment[=<txt>] Prefix lines of source code with <txt>\n"));
fprintf (stream, _("\
-s, --full-contents Display the full contents of all sections requested\n"));
fprintf (stream, _("\
-Z, --decompress Decompress section(s) before displaying their contents\n"));
fprintf (stream, _("\
-g, --debugging Display debug information in object file\n"));
fprintf (stream, _("\
-e, --debugging-tags Display debug information using ctags style\n"));
fprintf (stream, _("\
-G, --stabs Display (in raw form) any STABS info in the file\n"));
fprintf (stream, _("\
-W, --dwarf[a/=abbrev, A/=addr, r/=aranges, c/=cu_index, L/=decodedline,\n\
f/=frames, F/=frames-interp, g/=gdb_index, i/=info, o/=loc,\n\
m/=macro, p/=pubnames, t/=pubtypes, R/=Ranges, l/=rawline,\n\
s/=str, O/=str-offsets, u/=trace_abbrev, T/=trace_aranges,\n\
U/=trace_info]\n\
Display the contents of DWARF debug sections\n"));
fprintf (stream, _("\
-Wk,--dwarf=links Display the contents of sections that link to\n\
separate debuginfo files\n"));
#if DEFAULT_FOR_FOLLOW_LINKS
fprintf (stream, _("\
-WK,--dwarf=follow-links\n\
Follow links to separate debug info files (default)\n"));
fprintf (stream, _("\
-WN,--dwarf=no-follow-links\n\
Do not follow links to separate debug info files\n"));
#else
fprintf (stream, _("\
-WK,--dwarf=follow-links\n\
Follow links to separate debug info files\n"));
fprintf (stream, _("\
-WN,--dwarf=no-follow-links\n\
Do not follow links to separate debug info files\n\
(default)\n"));
#endif
#if HAVE_LIBDEBUGINFOD
fprintf (stream, _("\
-WD --dwarf=use-debuginfod\n\
When following links, also query debuginfod servers (default)\n"));
fprintf (stream, _("\
-WE --dwarf=do-not-use-debuginfod\n\
When following links, do not query debuginfod servers\n"));
#endif
fprintf (stream, _("\
-L, --process-links Display the contents of non-debug sections in\n\
separate debuginfo files. (Implies -WK)\n"));
#ifdef ENABLE_LIBCTF
fprintf (stream, _("\
--ctf[=SECTION] Display CTF info from SECTION, (default `.ctf')\n"));
#endif
fprintf (stream, _("\
--sframe[=SECTION] Display SFrame info from SECTION, (default '.sframe')\n"));
fprintf (stream, _("\
-t, --syms Display the contents of the symbol table(s)\n"));
fprintf (stream, _("\
-T, --dynamic-syms Display the contents of the dynamic symbol table\n"));
fprintf (stream, _("\
-r, --reloc Display the relocation entries in the file\n"));
fprintf (stream, _("\
-R, --dynamic-reloc Display the dynamic relocation entries in the file\n"));
fprintf (stream, _("\
@<file> Read options from <file>\n"));
fprintf (stream, _("\
-v, --version Display this program's version number\n"));
fprintf (stream, _("\
-i, --info List object formats and architectures supported\n"));
fprintf (stream, _("\
-H, --help Display this information\n"));
if (status != 2)
{
const struct objdump_private_desc * const *desc;
fprintf (stream, _("\n The following switches are optional:\n"));
fprintf (stream, _("\
-b, --target=BFDNAME Specify the target object format as BFDNAME\n"));
fprintf (stream, _("\
-m, --architecture=MACHINE Specify the target architecture as MACHINE\n"));
fprintf (stream, _("\
-j, --section=NAME Only display information for section NAME\n"));
fprintf (stream, _("\
-M, --disassembler-options=OPT Pass text OPT on to the disassembler\n"));
fprintf (stream, _("\
-EB --endian=big Assume big endian format when disassembling\n"));
fprintf (stream, _("\
-EL --endian=little Assume little endian format when disassembling\n"));
fprintf (stream, _("\
--file-start-context Include context from start of file (with -S)\n"));
fprintf (stream, _("\
-I, --include=DIR Add DIR to search list for source files\n"));
fprintf (stream, _("\
-l, --line-numbers Include line numbers and filenames in output\n"));
fprintf (stream, _("\
-F, --file-offsets Include file offsets when displaying information\n"));
fprintf (stream, _("\
-C, --demangle[=STYLE] Decode mangled/processed symbol names\n"));
display_demangler_styles (stream, _("\
STYLE can be "));
fprintf (stream, _("\
--recurse-limit Enable a limit on recursion whilst demangling\n\
(default)\n"));
fprintf (stream, _("\
--no-recurse-limit Disable a limit on recursion whilst demangling\n"));
fprintf (stream, _("\
-w, --wide Format output for more than 80 columns\n"));
fprintf (stream, _("\
-U[d|l|i|x|e|h] Controls the display of UTF-8 unicode characters\n\
--unicode=[default|locale|invalid|hex|escape|highlight]\n"));
fprintf (stream, _("\
-z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n"));
fprintf (stream, _("\
--start-address=ADDR Only process data whose address is >= ADDR\n"));
fprintf (stream, _("\
--stop-address=ADDR Only process data whose address is < ADDR\n"));
fprintf (stream, _("\
--no-addresses Do not print address alongside disassembly\n"));
fprintf (stream, _("\
--prefix-addresses Print complete address alongside disassembly\n"));
fprintf (stream, _("\
--[no-]show-raw-insn Display hex alongside symbolic disassembly\n"));
fprintf (stream, _("\
--insn-width=WIDTH Display WIDTH bytes on a single line for -d\n"));
fprintf (stream, _("\
--adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n"));
fprintf (stream, _("\
--show-all-symbols When disassembling, display all symbols at a given address\n"));
fprintf (stream, _("\
--special-syms Include special symbols in symbol dumps\n"));
fprintf (stream, _("\
--inlines Print all inlines for source line (with -l)\n"));
fprintf (stream, _("\
--prefix=PREFIX Add PREFIX to absolute paths for -S\n"));
fprintf (stream, _("\
--prefix-strip=LEVEL Strip initial directory names for -S\n"));
fprintf (stream, _("\
--dwarf-depth=N Do not display DIEs at depth N or greater\n"));
fprintf (stream, _("\
--dwarf-start=N Display DIEs starting at offset N\n"));
fprintf (stream, _("\
--dwarf-check Make additional dwarf consistency checks.\n"));
#ifdef ENABLE_LIBCTF
fprintf (stream, _("\
--ctf-parent=NAME Use CTF archive member NAME as the CTF parent\n"));
#endif
fprintf (stream, _("\
--visualize-jumps Visualize jumps by drawing ASCII art lines\n"));
fprintf (stream, _("\
--visualize-jumps=color Use colors in the ASCII art\n"));
fprintf (stream, _("\
--visualize-jumps=extended-color\n\
Use extended 8-bit color codes\n"));
fprintf (stream, _("\
--visualize-jumps=off Disable jump visualization\n"));
#if DEFAULT_FOR_COLORED_DISASSEMBLY
fprintf (stream, _("\
--disassembler-color=off Disable disassembler color output.\n"));
fprintf (stream, _("\
--disassembler-color=terminal Enable disassembler color output if displaying on a terminal. (default)\n"));
#else
fprintf (stream, _("\
--disassembler-color=off Disable disassembler color output. (default)\n"));
fprintf (stream, _("\
--disassembler-color=terminal Enable disassembler color output if displaying on a terminal.\n"));
#endif
fprintf (stream, _("\
--disassembler-color=on Enable disassembler color output.\n"));
fprintf (stream, _("\
--disassembler-color=extended Use 8-bit colors in disassembler output.\n\n"));
list_supported_targets (program_name, stream);
list_supported_architectures (program_name, stream);
disassembler_usage (stream);
if (objdump_private_vectors[0] != NULL)
{
fprintf (stream,
_("\nOptions supported for -P/--private switch:\n"));
for (desc = objdump_private_vectors; *desc != NULL; desc++)
(*desc)->help (stream);
}
}
if (REPORT_BUGS_TO[0] && status == 0)
fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
exit (status);
}
/* 150 isn't special; it's just an arbitrary non-ASCII char value. */
enum option_values
{
OPTION_ENDIAN=150,
OPTION_START_ADDRESS,
OPTION_STOP_ADDRESS,
OPTION_DWARF,
OPTION_PREFIX,
OPTION_PREFIX_STRIP,
OPTION_INSN_WIDTH,
OPTION_ADJUST_VMA,
OPTION_DWARF_DEPTH,
OPTION_DWARF_CHECK,
OPTION_DWARF_START,
OPTION_RECURSE_LIMIT,
OPTION_NO_RECURSE_LIMIT,
OPTION_INLINES,
OPTION_SOURCE_COMMENT,
#ifdef ENABLE_LIBCTF
OPTION_CTF,
OPTION_CTF_PARENT,
OPTION_CTF_PARENT_SECTION,
#endif
OPTION_SFRAME,
OPTION_VISUALIZE_JUMPS,
OPTION_DISASSEMBLER_COLOR
};
static struct option long_options[]=
{
{"adjust-vma", required_argument, NULL, OPTION_ADJUST_VMA},
{"all-headers", no_argument, NULL, 'x'},
{"architecture", required_argument, NULL, 'm'},
{"archive-headers", no_argument, NULL, 'a'},
#ifdef ENABLE_LIBCTF
{"ctf", optional_argument, NULL, OPTION_CTF},
{"ctf-parent", required_argument, NULL, OPTION_CTF_PARENT},
{"ctf-parent-section", required_argument, NULL, OPTION_CTF_PARENT_SECTION},
#endif
{"debugging", no_argument, NULL, 'g'},
{"debugging-tags", no_argument, NULL, 'e'},
{"decompress", no_argument, NULL, 'Z'},
{"demangle", optional_argument, NULL, 'C'},
{"disassemble", optional_argument, NULL, 'd'},
{"disassemble-all", no_argument, NULL, 'D'},
{"disassemble-zeroes", no_argument, NULL, 'z'},
{"disassembler-options", required_argument, NULL, 'M'},
{"dwarf", optional_argument, NULL, OPTION_DWARF},
{"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
{"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
{"dwarf-start", required_argument, 0, OPTION_DWARF_START},
{"dynamic-reloc", no_argument, NULL, 'R'},
{"dynamic-syms", no_argument, NULL, 'T'},
{"endian", required_argument, NULL, OPTION_ENDIAN},
{"file-headers", no_argument, NULL, 'f'},
{"file-offsets", no_argument, NULL, 'F'},
{"file-start-context", no_argument, &file_start_context, 1},
{"full-contents", no_argument, NULL, 's'},
{"headers", no_argument, NULL, 'h'},
{"help", no_argument, NULL, 'H'},
{"include", required_argument, NULL, 'I'},
{"info", no_argument, NULL, 'i'},
{"inlines", no_argument, 0, OPTION_INLINES},
{"insn-width", required_argument, NULL, OPTION_INSN_WIDTH},
{"line-numbers", no_argument, NULL, 'l'},
{"no-addresses", no_argument, &no_addresses, 1},
{"no-recurse-limit", no_argument, NULL, OPTION_NO_RECURSE_LIMIT},
{"no-recursion-limit", no_argument, NULL, OPTION_NO_RECURSE_LIMIT},
{"no-show-raw-insn", no_argument, &show_raw_insn, -1},
{"prefix", required_argument, NULL, OPTION_PREFIX},
{"prefix-addresses", no_argument, &prefix_addresses, 1},
{"prefix-strip", required_argument, NULL, OPTION_PREFIX_STRIP},
{"private", required_argument, NULL, 'P'},
{"private-headers", no_argument, NULL, 'p'},
{"process-links", no_argument, &process_links, true},
{"recurse-limit", no_argument, NULL, OPTION_RECURSE_LIMIT},
{"recursion-limit", no_argument, NULL, OPTION_RECURSE_LIMIT},
{"reloc", no_argument, NULL, 'r'},
{"section", required_argument, NULL, 'j'},
{"section-headers", no_argument, NULL, 'h'},
{"sframe", optional_argument, NULL, OPTION_SFRAME},
{"show-all-symbols", no_argument, &show_all_symbols, 1},
{"show-raw-insn", no_argument, &show_raw_insn, 1},
{"source", no_argument, NULL, 'S'},
{"source-comment", optional_argument, NULL, OPTION_SOURCE_COMMENT},
{"special-syms", no_argument, &dump_special_syms, 1},
{"stabs", no_argument, NULL, 'G'},
{"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'},
{"unicode", required_argument, NULL, 'U'},
{"version", no_argument, NULL, 'V'},
{"visualize-jumps", optional_argument, 0, OPTION_VISUALIZE_JUMPS},
{"wide", no_argument, NULL, 'w'},
{"disassembler-color", required_argument, NULL, OPTION_DISASSEMBLER_COLOR},
{NULL, no_argument, NULL, 0}
};
static void
my_bfd_nonfatal (const char *msg)
{
bfd_nonfatal (msg);
exit_status = 1;
}
/* Convert a potential UTF-8 encoded sequence in IN into characters in OUT.
The conversion format is controlled by the unicode_display variable.
Returns the number of characters added to OUT.
Returns the number of bytes consumed from IN in CONSUMED.
Always consumes at least one byte and displays at least one character. */
static unsigned int
display_utf8 (const unsigned char * in, char * out, unsigned int * consumed)
{
char * orig_out = out;
unsigned int nchars = 0;
unsigned int j;
if (unicode_display == unicode_default)
goto invalid;
if (in[0] < 0xc0)
goto invalid;
if ((in[1] & 0xc0) != 0x80)
goto invalid;
if ((in[0] & 0x20) == 0)
{
nchars = 2;
goto valid;
}
if ((in[2] & 0xc0) != 0x80)
goto invalid;
if ((in[0] & 0x10) == 0)
{
nchars = 3;
goto valid;
}
if ((in[3] & 0xc0) != 0x80)
goto invalid;
nchars = 4;
valid:
switch (unicode_display)
{
case unicode_locale:
/* Copy the bytes into the output buffer as is. */
memcpy (out, in, nchars);
out += nchars;
break;
case unicode_invalid:
case unicode_hex:
*out++ = unicode_display == unicode_hex ? '<' : '{';
*out++ = '0';
*out++ = 'x';
for (j = 0; j < nchars; j++)
out += sprintf (out, "%02x", in [j]);
*out++ = unicode_display == unicode_hex ? '>' : '}';
break;
case unicode_highlight:
if (isatty (1))
out += sprintf (out, "\x1B[31;47m"); /* Red. */
/* Fall through. */
case unicode_escape:
switch (nchars)
{
case 2:
out += sprintf (out, "\\u%02x%02x",
((in[0] & 0x1c) >> 2),
((in[0] & 0x03) << 6) | (in[1] & 0x3f));
break;
case 3:
out += sprintf (out, "\\u%02x%02x",
((in[0] & 0x0f) << 4) | ((in[1] & 0x3c) >> 2),
((in[1] & 0x03) << 6) | ((in[2] & 0x3f)));
break;
case 4:
out += sprintf (out, "\\u%02x%02x%02x",
((in[0] & 0x07) << 6) | ((in[1] & 0x3c) >> 2),
((in[1] & 0x03) << 6) | ((in[2] & 0x3c) >> 2),
((in[2] & 0x03) << 6) | ((in[3] & 0x3f)));
break;
default:
/* URG. */
break;
}
if (unicode_display == unicode_highlight && isatty (1))
out += sprintf (out, "\x1B[0m"); /* Default colour. */
break;
default:
/* URG */
break;
}
* consumed = nchars;
return out - orig_out;
invalid:
/* Not a valid UTF-8 sequence. */
*out = *in;
* consumed = 1;
return 1;
}
/* Returns a version of IN with any control characters
replaced by escape sequences. Uses a static buffer
if necessary.
If unicode display is enabled, then also handles the
conversion of unicode characters. */
static const char *
sanitize_string (const char * in)
{
static char * buffer = NULL;
static size_t buffer_len = 0;
const char * original = in;
char * out;
/* Paranoia. */
if (in == NULL)
return "";
/* See if any conversion is necessary. In the majority
of cases it will not be needed. */
do
{
unsigned char c = *in++;
if (c == 0)
return original;
if (ISCNTRL (c))
break;
if (unicode_display != unicode_default && c >= 0xc0)
break;
}
while (1);
/* Copy the input, translating as needed. */
in = original;
/* For 2 char unicode, max out is 12 (colour escapes) + 6, ie. 9 per in
For hex, max out is 8 for 2 char unicode, ie. 4 per in.
3 and 4 char unicode produce less output for input. */
size_t max_needed = strlen (in) * 9 + 1;
if (buffer_len < max_needed)
{
buffer_len = max_needed;
free (buffer);
buffer = xmalloc (buffer_len);
}
out = buffer;
do
{
unsigned char c = *in++;
if (c == 0)
break;
if (ISCNTRL (c))
{
*out++ = '^';
*out++ = c + 0x40;
}
else if (unicode_display != unicode_default && c >= 0xc0)
{
unsigned int num_consumed;
out += display_utf8 ((const unsigned char *) --in, out, &num_consumed);
in += num_consumed;
}
else
*out++ = c;
}
while (1);
*out = 0;
return buffer;
}
/* Returns TRUE if the specified section should be dumped. */
static bool
process_section_p (asection * section)
{
struct only * only;
if (only_list == NULL)
return true;
for (only = only_list; only; only = only->next)
if (strcmp (only->name, section->name) == 0)
{
only->seen = true;
return true;
}
return false;
}
/* Add an entry to the 'only' list. */
static void
add_only (char * name)
{
struct only * only;
/* First check to make sure that we do not
already have an entry for this name. */
for (only = only_list; only; only = only->next)
if (strcmp (only->name, name) == 0)
return;
only = xmalloc (sizeof * only);
only->name = name;
only->seen = false;
only->next = only_list;
only_list = only;
}
/* Release the memory used by the 'only' list.
PR 11225: Issue a warning message for unseen sections.
Only do this if none of the sections were seen. This is mainly to support
tools like the GAS testsuite where an object file is dumped with a list of
generic section names known to be present in a range of different file
formats. */
static void
free_only_list (void)
{
bool at_least_one_seen = false;
struct only * only;
struct only * next;
if (only_list == NULL)
return;
for (only = only_list; only; only = only->next)
if (only->seen)
{
at_least_one_seen = true;
break;
}
for (only = only_list; only; only = next)
{
if (! at_least_one_seen)
{
non_fatal (_("section '%s' mentioned in a -j option, "
"but not found in any input file"),
only->name);
exit_status = 1;
}
next = only->next;
free (only);
}
}
static void
dump_section_header (bfd *abfd, asection *section, void *data)
{
char *comma = "";
unsigned int opb = bfd_octets_per_byte (abfd, section);
int longest_section_name = *((int *) data);
/* Ignore linker created section. See elfNN_ia64_object_p in
bfd/elfxx-ia64.c. */
if (section->flags & SEC_LINKER_CREATED)
return;
/* PR 10413: Skip sections that we are ignoring. */
if (! process_section_p (section))
return;
printf ("%3d %-*s %08lx ", section->index, longest_section_name,
sanitize_string (bfd_section_name (section)),
(unsigned long) bfd_section_size (section) / opb);
bfd_printf_vma (abfd, bfd_section_vma (section));
printf (" ");
bfd_printf_vma (abfd, section->lma);
printf (" %08lx 2**%u", (unsigned long) section->filepos,
bfd_section_alignment (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");
if (bfd_get_arch (abfd) == bfd_arch_tic54x)
{
PF (SEC_TIC54X_BLOCK, "BLOCK");
PF (SEC_TIC54X_CLINK, "CLINK");
}
PF (SEC_SMALL_DATA, "SMALL_DATA");
if (bfd_get_flavour (abfd) == bfd_target_coff_flavour)
{
PF (SEC_COFF_SHARED, "SHARED");
PF (SEC_COFF_NOREAD, "NOREAD");
}
else if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
{
PF (SEC_ELF_OCTETS, "OCTETS");
PF (SEC_ELF_PURECODE, "PURECODE");
}
PF (SEC_THREAD_LOCAL, "THREAD_LOCAL");
PF (SEC_GROUP, "GROUP");
if (bfd_get_arch (abfd) == bfd_arch_mep)
{
PF (SEC_MEP_VLIW, "VLIW");
}
if ((section->flags & SEC_LINK_ONCE) != 0)
{
const char *ls;
struct coff_comdat_info *comdat;
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);
comdat = bfd_coff_get_comdat_section (abfd, section);
if (comdat != NULL)
printf (" (COMDAT %s %ld)", comdat->name, comdat->symbol);
comma = ", ";
}
if (bfd_is_section_compressed (abfd, section))
printf ("%sCOMPRESSED", comma);
printf ("\n");
#undef PF
}
/* Called on each SECTION in ABFD, update the int variable pointed to by
DATA which contains the string length of the longest section name. */
static void
find_longest_section_name (bfd *abfd ATTRIBUTE_UNUSED,
asection *section, void *data)
{
int *longest_so_far = (int *) data;
const char *name;
int len;
/* Ignore linker created section. */
if (section->flags & SEC_LINKER_CREATED)
return;
/* Skip sections that we are ignoring. */
if (! process_section_p (section))
return;
name = bfd_section_name (section);
len = (int) strlen (name);
if (len > *longest_so_far)
*longest_so_far = len;
}
static void
dump_headers (bfd *abfd)
{
/* The default width of 13 is just an arbitrary choice. */
int max_section_name_length = 13;
int bfd_vma_width;
#ifndef BFD64
bfd_vma_width = 10;
#else
/* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
if (bfd_get_arch_size (abfd) == 32)
bfd_vma_width = 10;
else
bfd_vma_width = 18;
#endif
printf (_("Sections:\n"));
if (wide_output)
bfd_map_over_sections (abfd, find_longest_section_name,
&max_section_name_length);
printf (_("Idx %-*s Size %-*s%-*sFile off Algn"),
max_section_name_length, "Name",
bfd_vma_width, "VMA",
bfd_vma_width, "LMA");
if (wide_output)
printf (_(" Flags"));
printf ("\n");
bfd_map_over_sections (abfd, dump_section_header,
&max_section_name_length);
}
static asymbol **
slurp_symtab (bfd *abfd)
{
symcount = 0;
if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
return NULL;
long storage = bfd_get_symtab_upper_bound (abfd);
if (storage < 0)
{
non_fatal (_("failed to read symbol table from: %s"),
bfd_get_filename (abfd));
my_bfd_nonfatal (_("error message was"));
}
if (storage <= 0)
return NULL;
asymbol **sy = (asymbol **) xmalloc (storage);
symcount = bfd_canonicalize_symtab (abfd, sy);
if (symcount < 0)
{
my_bfd_nonfatal (bfd_get_filename (abfd));
free (sy);
sy = NULL;
symcount = 0;
}
return sy;
}
/* Read in the dynamic symbols. */
static asymbol **
slurp_dynamic_symtab (bfd *abfd)
{
dynsymcount = 0;
long storage = bfd_get_dynamic_symtab_upper_bound (abfd);
if (storage < 0)
{
if (!(bfd_get_file_flags (abfd) & DYNAMIC))
{
non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd));
exit_status = 1;
return NULL;
}
my_bfd_nonfatal (bfd_get_filename (abfd));
}
if (storage <= 0)
return NULL;
asymbol **sy = (asymbol **) xmalloc (storage);
dynsymcount = bfd_canonicalize_dynamic_symtab (abfd, sy);
if (dynsymcount < 0)
{
my_bfd_nonfatal (bfd_get_filename (abfd));
free (sy);
sy = NULL;
dynsymcount = 0;
}
return sy;
}
/* Some symbol names are significant and should be kept in the
table of sorted symbol names, even if they are marked as
debugging/section symbols. */
static bool
is_significant_symbol_name (const char * name)
{
return startswith (name, ".plt") || startswith (name, ".got");
}
/* Filter out (in place) symbols that are useless for disassembly.
COUNT is the number of elements in SYMBOLS.
Return the number of useful symbols. */
static long
remove_useless_symbols (asymbol **symbols, long count)
{
asymbol **in_ptr = symbols, **out_ptr = symbols;
while (--count >= 0)
{
asymbol *sym = *in_ptr++;
if (sym->name == NULL || sym->name[0] == '\0')
continue;
if ((sym->flags & (BSF_DEBUGGING | BSF_SECTION_SYM))
&& ! is_significant_symbol_name (sym->name))
continue;
if (bfd_is_und_section (sym->section)
|| bfd_is_com_section (sym->section))
continue;
*out_ptr++ = sym;
}
return out_ptr - symbols;
}
static const asection *compare_section;
/* Sort symbols into value order. */
static int
compare_symbols (const void *ap, const void *bp)
{
const asymbol *a = * (const asymbol **) ap;
const asymbol *b = * (const asymbol **) bp;
const char *an;
const char *bn;
size_t anl;
size_t bnl;
bool as, af, bs, bf;
flagword aflags;
flagword bflags;
if (bfd_asymbol_value (a) > bfd_asymbol_value (b))
return 1;
else if (bfd_asymbol_value (a) < bfd_asymbol_value (b))
return -1;
/* Prefer symbols from the section currently being disassembled.
Don't sort symbols from other sections by section, since there
isn't much reason to prefer one section over another otherwise.
See sym_ok comment for why we compare by section name. */
as = strcmp (compare_section->name, a->section->name) == 0;
bs = strcmp (compare_section->name, b->section->name) == 0;
if (as && !bs)
return -1;
if (!as && bs)
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 \
|| ((snl) > 2 \
&& (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;
/* Sort function and object symbols before global symbols before
local symbols before section 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_SECTION_SYM) != (bflags & BSF_SECTION_SYM))
{
if ((aflags & BSF_SECTION_SYM) != 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_OBJECT) != (bflags & BSF_OBJECT))
{
if ((aflags & BSF_OBJECT) != 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;
}
/* Sort larger size ELF symbols before smaller. See PR20337. */
bfd_vma asz = 0;
if ((a->flags & (BSF_SECTION_SYM | BSF_SYNTHETIC)) == 0
&& bfd_get_flavour (bfd_asymbol_bfd (a)) == bfd_target_elf_flavour)
asz = ((elf_symbol_type *) a)->internal_elf_sym.st_size;
bfd_vma bsz = 0;
if ((b->flags & (BSF_SECTION_SYM | BSF_SYNTHETIC)) == 0
&& bfd_get_flavour (bfd_asymbol_bfd (b)) == bfd_target_elf_flavour)
bsz = ((elf_symbol_type *) b)->internal_elf_sym.st_size;
if (asz != bsz)
return asz > bsz ? -1 : 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
compare_relocs (const void *ap, const void *bp)
{
const arelent *a = * (const arelent **) ap;
const arelent *b = * (const arelent **) bp;
if (a->address > b->address)
return 1;
else if (a->address < b->address)
return -1;
/* 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;
}
/* Print an address (VMA) to the output stream in INFO.
If SKIP_ZEROES is TRUE, omit leading zeroes. */
static void
objdump_print_value (bfd_vma vma, struct disassemble_info *inf,
bool skip_zeroes)
{
char buf[30];
char *p;
struct objdump_disasm_info *aux;
aux = (struct objdump_disasm_info *) inf->application_data;
bfd_sprintf_vma (aux->abfd, buf, vma);
if (! skip_zeroes)
p = buf;
else
{
for (p = buf; *p == '0'; ++p)
;
if (*p == '\0')
--p;
}
(*inf->fprintf_styled_func) (inf->stream, dis_style_address, "%s", p);
}
/* Print the name of a symbol. */
static void
objdump_print_symname (bfd *abfd, struct disassemble_info *inf,
asymbol *sym)
{
char *alloc;
const char *name, *version_string = NULL;
bool hidden = false;
alloc = NULL;
name = bfd_asymbol_name (sym);
if (do_demangle && name[0] != '\0')
{
/* Demangle the name. */
alloc = bfd_demangle (abfd, name, demangle_flags);
if (alloc != NULL)
name = alloc;
}
if ((sym->flags & (BSF_SECTION_SYM | BSF_SYNTHETIC)) == 0)
version_string = bfd_get_symbol_version_string (abfd, sym, true,
&hidden);
if (bfd_is_und_section (bfd_asymbol_section (sym)))
hidden = true;
name = sanitize_string (name);
if (inf != NULL)
{
(*inf->fprintf_styled_func) (inf->stream, dis_style_symbol, "%s", name);
if (version_string && *version_string != '\0')
(*inf->fprintf_styled_func) (inf->stream, dis_style_symbol,
hidden ? "@%s" : "@@%s",
version_string);
}
else
{
printf ("%s", name);
if (version_string && *version_string != '\0')
printf (hidden ? "@%s" : "@@%s", version_string);
}
if (alloc != NULL)
free (alloc);
}
static inline bool
sym_ok (bool want_section,
bfd *abfd ATTRIBUTE_UNUSED,
long place,
asection *sec,
struct disassemble_info *inf)
{
if (want_section)
{
/* NB: An object file can have different sections with the same
section name. Compare compare section pointers if they have
the same owner. */
if (sorted_syms[place]->section->owner == sec->owner
&& sorted_syms[place]->section != sec)
return false;
/* Note - we cannot just compare section pointers because they could
be different, but the same... Ie the symbol that we are trying to
find could have come from a separate debug info file. Under such
circumstances the symbol will be associated with a section in the
debug info file, whilst the section we want is in a normal file.
So the section pointers will be different, but the section names
will be the same. */
if (strcmp (bfd_section_name (sorted_syms[place]->section),
bfd_section_name (sec)) != 0)
return false;
}
return inf->symbol_is_valid (sorted_syms[place], inf);
}
/* 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. */
static asymbol *
find_symbol_for_address (bfd_vma vma,
struct disassemble_info *inf,
long *place)
{
/* @@ 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_count = sorted_symcount;
long thisplace;
struct objdump_disasm_info *aux;
bfd *abfd;
asection *sec;
unsigned int opb;
bool want_section;
long rel_count;
if (sorted_symcount < 1)
return NULL;
aux = (struct objdump_disasm_info *) inf->application_data;
abfd = aux->abfd;
sec = inf->section;
opb = inf->octets_per_byte;
/* Perform a binary search looking for the closest symbol to the
required value. We are searching the range (min, max_count]. */
while (min + 1 < max_count)
{
asymbol *sym;
thisplace = (max_count + min) / 2;
sym = sorted_syms[thisplace];
if (bfd_asymbol_value (sym) > vma)
max_count = 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;
/* 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_count
&& (bfd_asymbol_value (sorted_syms[min])
== bfd_asymbol_value (sorted_syms[thisplace])))
{
if (sym_ok (true, abfd, min, sec, inf))
{
thisplace = min;
if (place != NULL)
*place = thisplace;
return sorted_syms[thisplace];
}
++min;
}
/* If the file is relocatable, and the symbol could be from this
section, prefer a symbol from this section over symbols from
others, even if the other symbol's value might be closer.
Note that this may be wrong for some symbol references if the
sections have overlapping memory ranges, but in that case there's
no way to tell what's desired without looking at the relocation
table.
Also give the target a chance to reject symbols. */
want_section = (aux->require_sec
|| ((abfd->flags & HAS_RELOC) != 0
&& vma >= bfd_section_vma (sec)
&& vma < (bfd_section_vma (sec)
+ bfd_section_size (sec) / opb)));
if (! sym_ok (want_section, abfd, thisplace, sec, inf))
{
long i;
long newplace = sorted_symcount;
for (i = min - 1; i >= 0; i--)
{
if (sym_ok (want_section, abfd, i, sec, inf))
{
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;
}
}
if (newplace != sorted_symcount)
thisplace = newplace;
else
{
/* We didn't find a good symbol with a smaller value.
Look for one with a larger value. */
for (i = thisplace + 1; i < sorted_symcount; i++)
{
if (sym_ok (want_section, abfd, i, sec, inf))
{
thisplace = i;
break;
}
}
}
if (! sym_ok (want_section, abfd, thisplace, sec, inf))
/* There is no suitable symbol. */
return NULL;
}
/* If we have not found an exact match for the specified address
and we have dynamic relocations available, then we can produce
a better result by matching a relocation to the address and
using the symbol associated with that relocation. */
rel_count = inf->dynrelcount;
if (!want_section
&& sorted_syms[thisplace]->value != vma
&& rel_count > 0
&& inf->dynrelbuf != NULL
&& inf->dynrelbuf[0]->address <= vma
&& inf->dynrelbuf[rel_count - 1]->address >= vma
/* If we have matched a synthetic symbol, then stick with that. */
&& (sorted_syms[thisplace]->flags & BSF_SYNTHETIC) == 0)
{
arelent ** rel_low;
arelent ** rel_high;
rel_low = inf->dynrelbuf;
rel_high = rel_low + rel_count - 1;
while (rel_low <= rel_high)
{
arelent **rel_mid = &rel_low[(rel_high - rel_low) / 2];
arelent * rel = *rel_mid;
if (rel->address == vma)
{
/* Absolute relocations do not provide a more helpful
symbolic address. Find a non-absolute relocation
with the same address. */
arelent **rel_vma = rel_mid;
for (rel_mid--;
rel_mid >= rel_low && rel_mid[0]->address == vma;
rel_mid--)
rel_vma = rel_mid;
for (; rel_vma <= rel_high && rel_vma[0]->address == vma;
rel_vma++)
{
rel = *rel_vma;
if (rel->sym_ptr_ptr != NULL
&& ! bfd_is_abs_section ((* rel->sym_ptr_ptr)->section))
{
if (place != NULL)
* place = thisplace;
return * rel->sym_ptr_ptr;
}
}
break;
}
if (vma < rel->address)
rel_high = rel_mid;
else if (vma >= rel_mid[1]->address)
rel_low = rel_mid + 1;
else
break;
}
}
if (place != NULL)
*place = thisplace;
return sorted_syms[thisplace];
}
/* Print an address and the offset to the nearest symbol. */
static void
objdump_print_addr_with_sym (bfd *abfd, asection *sec, asymbol *sym,
bfd_vma vma, struct disassemble_info *inf,
bool skip_zeroes)
{
if (!no_addresses)
{
objdump_print_value (vma, inf, skip_zeroes);
(*inf->fprintf_styled_func) (inf->stream, dis_style_text, " ");
}
if (sym == NULL)
{
bfd_vma secaddr;
(*inf->fprintf_styled_func) (inf->stream, dis_style_text,"<");
(*inf->fprintf_styled_func) (inf->stream, dis_style_symbol, "%s",
sanitize_string (bfd_section_name (sec)));
secaddr = bfd_section_vma (sec);
if (vma < secaddr)
{
(*inf->fprintf_styled_func) (inf->stream, dis_style_immediate,
"-0x");
objdump_print_value (secaddr - vma, inf, true);
}
else if (vma > secaddr)
{
(*inf->fprintf_styled_func) (inf->stream, dis_style_immediate, "+0x");
objdump_print_value (vma - secaddr, inf, true);
}
(*inf->fprintf_styled_func) (inf->stream, dis_style_text, ">");
}
else
{
(*inf->fprintf_styled_func) (inf->stream, dis_style_text, "<");
objdump_print_symname (abfd, inf, sym);
if (bfd_asymbol_value (sym) == vma)
;
/* Undefined symbols in an executables and dynamic objects do not have
a value associated with them, so it does not make sense to display
an offset relative to them. Normally we would not be provided with
this kind of symbol, but the target backend might choose to do so,
and the code in find_symbol_for_address might return an as yet
unresolved symbol associated with a dynamic reloc. */
else if ((bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC))
&& bfd_is_und_section (sym->section))
;
else if (bfd_asymbol_value (sym) > vma)
{
(*inf->fprintf_styled_func) (inf->stream, dis_style_immediate,"-0x");
objdump_print_value (bfd_asymbol_value (sym) - vma, inf, true);
}
else if (vma > bfd_asymbol_value (sym))
{
(*inf->fprintf_styled_func) (inf->stream, dis_style_immediate, "+0x");
objdump_print_value (vma - bfd_asymbol_value (sym), inf, true);
}
(*inf->fprintf_styled_func) (inf->stream, dis_style_text, ">");
}
if (display_file_offsets)
inf->fprintf_styled_func (inf->stream, dis_style_text,
_(" (File Offset: 0x%lx)"),
(long int)(sec->filepos + (vma - sec->vma)));
}
/* Displays all symbols in the sorted symbol table starting at PLACE
which match the address VMA. Assumes that show_all_symbols == true. */
static void
display_extra_syms (long place,
bfd_vma vma,
struct disassemble_info *inf)
{
struct objdump_disasm_info *aux = (struct objdump_disasm_info *) inf->application_data;
if (place == 0)
return;
bool first = true;
for (; place < sorted_symcount; place++)
{
asymbol *sym = sorted_syms[place];
if (bfd_asymbol_value (sym) != vma)
break;
if (! inf->symbol_is_valid (sym, inf))
continue;
if (first && ! do_wide)
inf->fprintf_styled_func (inf->stream, dis_style_immediate, ",\n\t<");
else
inf->fprintf_styled_func (inf->stream, dis_style_immediate, ", <");
objdump_print_symname (aux->abfd, inf, sym);
inf->fprintf_styled_func (inf->stream, dis_style_immediate, ">");
first = false;
}
}
/* Print an address (VMA), symbolically if possible.
If SKIP_ZEROES is TRUE, don't output leading zeroes. */
static void
objdump_print_addr (bfd_vma vma,
struct disassemble_info *inf,
bool skip_zeroes)
{
struct objdump_disasm_info *aux;
asymbol *sym = NULL;
bool skip_find = false;
long place = 0;
aux = (struct objdump_disasm_info *) inf->application_data;
if (sorted_symcount < 1)
{
if (!no_addresses)
{
(*inf->fprintf_styled_func) (inf->stream, dis_style_address, "0x");
objdump_print_value (vma, inf, skip_zeroes);
}
if (display_file_offsets)
inf->fprintf_styled_func (inf->stream, dis_style_text,
_(" (File Offset: 0x%lx)"),
(long int) (inf->section->filepos
+ (vma - inf->section->vma)));
return;
}
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_asymbol_section (sym)))
skip_find = true;
}
if (!skip_find)
sym = find_symbol_for_address (vma, inf, &place);
objdump_print_addr_with_sym (aux->abfd, inf->section, sym, vma, inf,
skip_zeroes);
/* If requested, display any extra symbols at this address. */
if (sym == NULL || ! show_all_symbols)
return;
if (place)
display_extra_syms (place + 1, vma, inf);
/* If we found an absolute symbol in the reloc (ie: "*ABS*+0x....")
and there is a valid symbol at the address contained in the absolute symbol
then display any extra symbols that match this address. This helps
particularly with relocations for PLT entries. */
if (startswith (sym->name, BFD_ABS_SECTION_NAME "+"))
{
bfd_vma addr = strtoul (sym->name + strlen (BFD_ABS_SECTION_NAME "+"), NULL, 0);
if (addr && addr != vma)
{
sym = find_symbol_for_address (addr, inf, &place);
if (sym)
display_extra_syms (place, addr, inf);
}
}
}
/* Print VMA to INFO. This function is passed to the disassembler
routine. */
static void
objdump_print_address (bfd_vma vma, struct disassemble_info *inf)
{
objdump_print_addr (vma, inf, ! prefix_addresses);
}
/* Determine if the given address has a symbol associated with it. */
static asymbol *
objdump_symbol_at_address (bfd_vma vma, struct disassemble_info * inf)
{
asymbol * sym;
sym = find_symbol_for_address (vma, inf, NULL);
if (sym != NULL && bfd_asymbol_value (sym) == vma)
return sym;
return NULL;
}
/* Hold the last function name and the last line number we displayed
in a disassembly. */
static char *prev_functionname;
static unsigned int prev_line;
static unsigned int prev_discriminator;
/* We keep a list of all files that we have seen when doing a
disassembly with source, so that we know how much of the file to
display. This can be important for inlined functions. */
struct print_file_list
{
struct print_file_list *next;
const char *filename;
const char *modname;
const char *map;
size_t mapsize;
const char **linemap;
unsigned maxline;
unsigned last_line;
unsigned max_printed;
int first;
};
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)
#if HAVE_LIBDEBUGINFOD
/* Return a hex string represention of the build-id. */
unsigned char *
get_build_id (void * data)
{
unsigned i;
char * build_id_str;
bfd * abfd = (bfd *) data;
const struct bfd_build_id * build_id;
build_id = abfd->build_id;
if (build_id == NULL)
return NULL;
build_id_str = malloc (build_id->size * 2 + 1);
if (build_id_str == NULL)
return NULL;
for (i = 0; i < build_id->size; i++)
sprintf (build_id_str + (i * 2), "%02x", build_id->data[i]);
build_id_str[build_id->size * 2] = '\0';
return (unsigned char *) build_id_str;
}
/* Search for a separate debug file matching ABFD's build-id. */
static bfd *
find_separate_debug (const bfd * abfd)
{
const struct bfd_build_id * build_id = abfd->build_id;
separate_info * i = first_separate_info;
if (build_id == NULL || i == NULL)
return NULL;
while (i != NULL)
{
const bfd * i_bfd = (bfd *) i->handle;
if (abfd != NULL && i_bfd->build_id != NULL)
{
const unsigned char * data = i_bfd->build_id->data;
size_t size = i_bfd->build_id->size;
if (size == build_id->size
&& memcmp (data, build_id->data, size) == 0)
return (bfd *) i->handle;
}
i = i->next;
}
return NULL;
}
/* Search for a separate debug file matching ABFD's .gnu_debugaltlink
build-id. */
static bfd *
find_alt_debug (const bfd * abfd)
{
size_t namelen;
size_t id_len;
const char * name;
struct dwarf_section * section;
const struct bfd_build_id * build_id = abfd->build_id;
separate_info * i = first_separate_info;
if (i == NULL
|| build_id == NULL
|| !load_debug_section (gnu_debugaltlink, (void *) abfd))
return NULL;
section = &debug_displays[gnu_debugaltlink].section;
if (section == NULL)
return NULL;
name = (const char *) section->start;
namelen = strnlen (name, section->size) + 1;
if (namelen == 1)
return NULL;
if (namelen >= section->size)
return NULL;
id_len = section->size - namelen;
if (id_len < 0x14)
return NULL;
/* Compare the .gnu_debugaltlink build-id with the build-ids of the
known separate_info files. */
while (i != NULL)
{
const bfd * i_bfd = (bfd *) i->handle;
if (i_bfd != NULL && i_bfd->build_id != NULL)
{
const unsigned char * data = i_bfd->build_id->data;
size_t size = i_bfd->build_id->size;
if (id_len == size
&& memcmp (section->start + namelen, data, size) == 0)
return (bfd *) i->handle;
}
i = i->next;
}
return NULL;
}
#endif /* HAVE_LIBDEBUGINFOD */
/* Reads the contents of file FN into memory. Returns a pointer to the buffer.
Also returns the size of the buffer in SIZE_RETURN and a filled out
stat structure in FST_RETURN. Returns NULL upon failure. */
static const char *
slurp_file (const char * fn,
size_t * size_return,
struct stat * fst_return,
bfd * abfd ATTRIBUTE_UNUSED)
{
#ifdef HAVE_MMAP
int ps;
size_t msize;
#endif
const char *map;
int fd;
/* Paranoia. */
if (fn == NULL || * fn == 0 || size_return == NULL || fst_return == NULL)
return NULL;
fd = open (fn, O_RDONLY | O_BINARY);
#if HAVE_LIBDEBUGINFOD
if (fd < 0 && use_debuginfod && fn[0] == '/' && abfd != NULL)
{
unsigned char *build_id = get_build_id (abfd);
if (build_id)
{
debuginfod_client *client = debuginfod_begin ();
if (client)
{
fd = debuginfod_find_source (client, build_id, 0, fn, NULL);
debuginfod_end (client);
}
free (build_id);
}
}
#endif
if (fd < 0)
return NULL;
if (fstat (fd, fst_return) < 0)
{
close (fd);
return NULL;
}
*size_return = fst_return->st_size;
#ifdef HAVE_MMAP
ps = getpagesize ();
msize = (*size_return + ps - 1) & ~(ps - 1);
map = mmap (NULL, msize, PROT_READ, MAP_SHARED, fd, 0);
if (map != (char *) -1L)
{
close (fd);
return map;
}
#endif
map = (const char *) malloc (*size_return);
if (!map || (size_t) read (fd, (char *) map, *size_return) != *size_return)
{
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 *);
linemap = (const char **) xrealloc (linemap, newsize);
}
linemap[lineno++] = lstart;
lstart = p + 1;
}
*maxline = lineno;
return linemap;
}
/* Tries to open MODNAME, and if successful adds a node to print_files
linked list and returns that node. Also fills in the stat structure
pointed to by FST_RETURN. Returns NULL on failure. */
static struct print_file_list *
try_print_file_open (const char * origname,
const char * modname,
struct stat * fst_return,
bfd * abfd)
{
struct print_file_list *p;
p = (struct print_file_list *) xmalloc (sizeof (struct print_file_list));
p->map = slurp_file (modname, &p->mapsize, fst_return, abfd);
if (p->map == NULL)
{
free (p);
return NULL;
}
p->linemap = index_file (p->map, p->mapsize, &p->maxline);
p->last_line = 0;
p->max_printed = 0;
p->filename = origname;
p->modname = modname;
p->next = print_files;
p->first = 1;
print_files = p;
return p;
}
/* If 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, bfd *abfd)
{
struct print_file_list *p;
const char *fname;
struct stat fst;
int i;
p = try_print_file_open (filename, filename, &fst, abfd);
if (p == NULL)
{
if (include_path_count == 0)
return NULL;
/* Get the name of the file. */
fname = lbasename (filename);
/* 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, &fst, abfd);
if (p)
break;
free (modname);
}
}
if (p != NULL)
{
long mtime = bfd_get_mtime (abfd);
if (fst.st_mtime > mtime)
warn (_("source file %s is more recent than object file\n"),
filename);
}
return p;
}
/* Print a source file line. */
static void
print_line (struct print_file_list *p, unsigned int linenum)
{
const char *l;
size_t len;
if (linenum >= p->maxline)
return;
l = p->linemap [linenum];
if (source_comment != NULL && strlen (l) > 0)
printf ("%s", source_comment);
len = strcspn (l, "\n\r");
/* Test fwrite return value to quiet glibc warning. */
if (len == 0 || fwrite (l, len, 1, stdout) == 1)
putchar ('\n');
}
/* Print a range of source code lines. */
static void
dump_lines (struct print_file_list *p, unsigned int start, unsigned int end)
{
if (p->map == NULL)
return;
if (start != 0)
--start;
while (start < end)
{
print_line (p, start);
start++;
}
}
/* Show the line number, or the source line, in a disassembly
listing. */
static void
show_line (bfd *abfd, asection *section, bfd_vma addr_offset)
{
const char *filename;
const char *functionname;
unsigned int linenumber;
unsigned int discriminator;
bool reloc;
char *path = NULL;
if (! with_line_numbers && ! with_source_code)
return;
#ifdef HAVE_LIBDEBUGINFOD
{
bfd *debug_bfd;
const char *alt_filename = NULL;
if (use_debuginfod)
{
bfd *alt_bfd;
/* PR 29075: Check for separate debuginfo and .gnu_debugaltlink files.
They need to be passed to bfd_find_nearest_line_with_alt in case they
were downloaded from debuginfod. Otherwise libbfd will attempt to
search for them and fail to locate them. */
debug_bfd = find_separate_debug (abfd);
if (debug_bfd == NULL)
debug_bfd = abfd;
alt_bfd = find_alt_debug (debug_bfd);
if (alt_bfd != NULL)
alt_filename = bfd_get_filename (alt_bfd);
}
else
debug_bfd = abfd;
bfd_set_error (bfd_error_no_error);
if (! bfd_find_nearest_line_with_alt (debug_bfd, alt_filename,
section, syms,
addr_offset, &filename,
&functionname, &linenumber,
&discriminator))
{
if (bfd_get_error () == bfd_error_no_error)
return;
if (! bfd_find_nearest_line_discriminator (abfd, section, syms,
addr_offset, &filename,
&functionname, &linenumber,
&discriminator))
return;
}
}
#else
if (! bfd_find_nearest_line_discriminator (abfd, section, syms, addr_offset,
&filename, &functionname,
&linenumber, &discriminator))
return;
#endif
if (filename != NULL && *filename == '\0')
filename = NULL;
if (functionname != NULL && *functionname == '\0')
functionname = NULL;
if (filename
&& IS_ABSOLUTE_PATH (filename)
&& prefix)
{
char *path_up;
const char *fname = filename;
path = xmalloc (prefix_length + 1 + strlen (filename));
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. */
strcpy (path_up, fname);
filename = path;
reloc = true;
}
else
reloc = false;
if (with_line_numbers)
{
if (functionname != NULL
&& (prev_functionname == NULL
|| strcmp (functionname, prev_functionname) != 0))
{
char *demangle_alloc = NULL;
if (do_demangle && functionname[0] != '\0')
{
/* Demangle the name. */
demangle_alloc = bfd_demangle (abfd, functionname,
demangle_flags);
}
/* Demangling adds trailing parens, so don't print those. */
if (demangle_alloc != NULL)
printf ("%s:\n", sanitize_string (demangle_alloc));
else
printf ("%s():\n", sanitize_string (functionname));
prev_line = -1;
free (demangle_alloc);
}
if (linenumber > 0
&& (linenumber != prev_line
|| discriminator != prev_discriminator))
{
if (discriminator > 0)
printf ("%s:%u (discriminator %u)\n",
filename == NULL ? "???" : sanitize_string (filename),
linenumber, discriminator);
else
printf ("%s:%u\n", filename == NULL
? "???" : sanitize_string (filename),
linenumber);
}
if (unwind_inlines)
{
const char *filename2;
const char *functionname2;
unsigned line2;
while (bfd_find_inliner_info (abfd, &filename2, &functionname2,
&line2))
{
printf ("inlined by %s:%u",
sanitize_string (filename2), line2);
printf (" (%s)\n", sanitize_string (functionname2));
}
}
}
if (with_source_code
&& filename != NULL
&& linenumber > 0)
{
struct print_file_list **pp, *p;
unsigned l;
for (pp = &print_files; *pp != NULL; pp = &(*pp)->next)
if (filename_cmp ((*pp)->filename, filename) == 0)
break;
p = *pp;
if (p == NULL)
{
if (reloc)
filename = xstrdup (filename);
p = update_source_path (filename, abfd);
}
if (p != NULL && linenumber != p->last_line)
{
if (file_start_context && p->first)
l = 1;
else
{
l = linenumber - SHOW_PRECEDING_CONTEXT_LINES;
if (l >= linenumber)
l = 1;
if (p->max_printed >= l)
{
if (p->max_printed < linenumber)
l = p->max_printed + 1;
else
l = linenumber;
}
}
dump_lines (p, l, linenumber);
if (p->max_printed < linenumber)
p->max_printed = linenumber;
p->last_line = linenumber;
p->first = 0;
}
}
if (functionname != NULL
&& (prev_functionname == NULL
|| strcmp (functionname, prev_functionname) != 0))
{
if (prev_functionname != NULL)
free (prev_functionname);
prev_functionname = (char *) xmalloc (strlen (functionname) + 1);
strcpy (prev_functionname, functionname);
}
if (linenumber > 0 && linenumber != prev_line)
prev_line = linenumber;
if (discriminator != prev_discriminator)
prev_discriminator = discriminator;
if (path)
free (path);
}
/* Pseudo FILE object for strings. */
typedef struct
{
char *buffer;
size_t pos;
size_t alloc;
} SFILE;
/* sprintf to a "stream". */
static int ATTRIBUTE_PRINTF_2
objdump_sprintf (SFILE *f, const char *format, ...)
{
size_t n;
va_list args;
while (1)
{
size_t space = f->alloc - f->pos;
va_start (args, format);
n = vsnprintf (f->buffer + f->pos, space, format, args);
va_end (args);
if (space > n)
break;
f->alloc = (f->alloc + n) * 2;
f->buffer = (char *) xrealloc (f->buffer, f->alloc);
}
f->pos += n;
return n;
}
/* Return an integer greater than, or equal to zero, representing the color
for STYLE, or -1 if no color should be used. */
static int
objdump_color_for_disassembler_style (enum disassembler_style style)
{
int color = -1;
if (style == dis_style_comment_start)
disassembler_in_comment = true;
if (disassembler_color == on)
{
if (disassembler_in_comment)
return color;
switch (style)
{
case dis_style_symbol:
color = 32;
break;
case dis_style_assembler_directive:
case dis_style_sub_mnemonic:
case dis_style_mnemonic:
color = 33;
break;
case dis_style_register:
color = 34;
break;
case dis_style_address:
case dis_style_address_offset:
case dis_style_immediate:
color = 35;
break;
default:
case dis_style_text:
color = -1;
break;
}
}
else if (disassembler_color == extended)
{
if (disassembler_in_comment)
return 250;
switch (style)
{
case dis_style_symbol:
color = 40;
break;
case dis_style_assembler_directive:
case dis_style_sub_mnemonic:
case dis_style_mnemonic:
color = 142;
break;
case dis_style_register:
color = 27;
break;
case dis_style_address:
case dis_style_address_offset:
case dis_style_immediate:
color = 134;
break;
default:
case dis_style_text:
color = -1;
break;
}
}
else if (disassembler_color != off)
bfd_fatal (_("disassembly color not correctly selected"));
return color;
}
/* Like objdump_sprintf, but add in escape sequences to highlight the
content according to STYLE. */
static int ATTRIBUTE_PRINTF_3
objdump_styled_sprintf (SFILE *f, enum disassembler_style style,
const char *format, ...)
{
size_t n;
va_list args;
int color = objdump_color_for_disassembler_style (style);
if (color >= 0)
{
while (1)
{
size_t space = f->alloc - f->pos;
if (disassembler_color == on)
n = snprintf (f->buffer + f->pos, space, "\033[%dm", color);
else
n = snprintf (f->buffer + f->pos, space, "\033[38;5;%dm", color);
if (space > n)
break;
f->alloc = (f->alloc + n) * 2;
f->buffer = (char *) xrealloc (f->buffer, f->alloc);
}
f->pos += n;
}
while (1)
{
size_t space = f->alloc - f->pos;
va_start (args, format);
n = vsnprintf (f->buffer + f->pos, space, format, args);
va_end (args);
if (space > n)
break;
f->alloc = (f->alloc + n) * 2;
f->buffer = (char *) xrealloc (f->buffer, f->alloc);
}
f->pos += n;
if (color >= 0)
{
while (1)
{
size_t space = f->alloc - f->pos;
n = snprintf (f->buffer + f->pos, space, "\033[0m");
if (space > n)
break;
f->alloc = (f->alloc + n) * 2;
f->buffer = (char *) xrealloc (f->buffer, f->alloc);
}
f->pos += n;
}
return n;
}
/* We discard the styling information here. This function is only used
when objdump is printing auxiliary information, the symbol headers, and
disassembly address, or the bytes of the disassembled instruction. We
don't (currently) apply styling to any of this stuff, so, for now, just
print the content with no additional style added. */
static int ATTRIBUTE_PRINTF_3
fprintf_styled (FILE *f, enum disassembler_style style ATTRIBUTE_UNUSED,
const char *fmt, ...)
{
int res;
va_list ap;
va_start (ap, fmt);
res = vfprintf (f, fmt, ap);
va_end (ap);
return res;
}
/* Code for generating (colored) diagrams of control flow start and end
points. */
/* Structure used to store the properties of a jump. */
struct jump_info
{
/* The next jump, or NULL if this is the last object. */
struct jump_info *next;
/* The previous jump, or NULL if this is the first object. */
struct jump_info *prev;
/* The start addresses of the jump. */
struct
{
/* The list of start addresses. */
bfd_vma *addresses;
/* The number of elements. */
size_t count;
/* The maximum number of elements that fit into the array. */
size_t max_count;
} start;
/* The end address of the jump. */
bfd_vma end;
/* The drawing level of the jump. */
int level;
};
/* Construct a jump object for a jump from start
to end with the corresponding level. */
static struct jump_info *
jump_info_new (bfd_vma start, bfd_vma end, int level)
{
struct jump_info *result = xmalloc (sizeof (struct jump_info));
result->next = NULL;
result->prev = NULL;
result->start.addresses = xmalloc (sizeof (bfd_vma *) * 2);
result->start.addresses[0] = start;
result->start.count = 1;
result->start.max_count = 2;
result->end = end;
result->level = level;
return result;
}
/* Free a jump object and return the next object
or NULL if this was the last one. */
static struct jump_info *
jump_info_free (struct jump_info *ji)
{
struct jump_info *result = NULL;
if (ji)
{
result = ji->next;
if (ji->start.addresses)
free (ji->start.addresses);
free (ji);
}
return result;
}
/* Get the smallest value of all start and end addresses. */
static bfd_vma
jump_info_min_address (const struct jump_info *ji)
{
bfd_vma min_address = ji->end;
size_t i;
for (i = ji->start.count; i-- > 0;)
if (ji->start.addresses[i] < min_address)
min_address = ji->start.addresses[i];
return min_address;
}
/* Get the largest value of all start and end addresses. */
static bfd_vma
jump_info_max_address (const struct jump_info *ji)
{
bfd_vma max_address = ji->end;
size_t i;
for (i = ji->start.count; i-- > 0;)
if (ji->start.addresses[i] > max_address)
max_address = ji->start.addresses[i];
return max_address;
}
/* Get the target address of a jump. */
static bfd_vma
jump_info_end_address (const struct jump_info *ji)
{
return ji->end;
}
/* Test if an address is one of the start addresses of a jump. */
static bool
jump_info_is_start_address (const struct jump_info *ji, bfd_vma address)
{
bool result = false;
size_t i;
for (i = ji->start.count; i-- > 0;)
if (address == ji->start.addresses[i])
{
result = true;
break;
}
return result;
}
/* Test if an address is the target address of a jump. */
static bool
jump_info_is_end_address (const struct jump_info *ji, bfd_vma address)
{
return (address == ji->end);
}
/* Get the difference between the smallest and largest address of a jump. */
static bfd_vma
jump_info_size (const struct jump_info *ji)
{
return jump_info_max_address (ji) - jump_info_min_address (ji);
}
/* Unlink a jump object from a list. */
static void
jump_info_unlink (struct jump_info *node,
struct jump_info **base)
{
if (node->next)
node->next->prev = node->prev;
if (node->prev)
node->prev->next = node->next;
else
*base = node->next;
node->next = NULL;
node->prev = NULL;
}
/* Insert unlinked jump info node into a list. */
static void
jump_info_insert (struct jump_info *node,
struct jump_info *target,
struct jump_info **base)
{
node->next = target;
node->prev = target->prev;
target->prev = node;
if (node->prev)
node->prev->next = node;
else
*base = node;
}
/* Add unlinked node to the front of a list. */
static void
jump_info_add_front (struct jump_info *node,
struct jump_info **base)
{
node->next = *base;
if (node->next)
node->next->prev = node;
node->prev = NULL;
*base = node;
}
/* Move linked node to target position. */
static void
jump_info_move_linked (struct jump_info *node,
struct jump_info *target,
struct jump_info **base)
{
/* Unlink node. */
jump_info_unlink (node, base);
/* Insert node at target position. */
jump_info_insert (node, target, base);
}
/* Test if two jumps intersect. */
static bool
jump_info_intersect (const struct jump_info *a,
const struct jump_info *b)
{
return ((jump_info_max_address (a) >= jump_info_min_address (b))
&& (jump_info_min_address (a) <= jump_info_max_address (b)));
}
/* Merge two compatible jump info objects. */
static void
jump_info_merge (struct jump_info **base)
{
struct jump_info *a;
for (a = *base; a; a = a->next)
{
struct jump_info *b;
for (b = a->next; b; b = b->next)
{
/* Merge both jumps into one. */
if (a->end == b->end)
{
/* Reallocate addresses. */
size_t needed_size = a->start.count + b->start.count;
size_t i;
if (needed_size > a->start.max_count)
{
a->start.max_count += b->start.max_count;
a->start.addresses =
xrealloc (a->start.addresses,
a->start.max_count * sizeof (bfd_vma *));
}
/* Append start addresses. */
for (i = 0; i < b->start.count; ++i)
a->start.addresses[a->start.count++] =
b->start.addresses[i];
/* Remove and delete jump. */
struct jump_info *tmp = b->prev;
jump_info_unlink (b, base);
jump_info_free (b);
b = tmp;
}
}
}
}
/* Sort jumps by their size and starting point using a stable
minsort. This could be improved if sorting performance is
an issue, for example by using mergesort. */
static void
jump_info_sort (struct jump_info **base)
{
struct jump_info *current_element = *base;
while (current_element)
{
struct jump_info *best_match = current_element;
struct jump_info *runner = current_element->next;
bfd_vma best_size = jump_info_size (best_match);
while (runner)
{
bfd_vma runner_size = jump_info_size (runner);
if ((runner_size < best_size)
|| ((runner_size == best_size)
&& (jump_info_min_address (runner)
< jump_info_min_address (best_match))))
{
best_match = runner;
best_size = runner_size;
}
runner = runner->next;
}
if (best_match == current_element)
current_element = current_element->next;
else
jump_info_move_linked (best_match, current_element, base);
}
}
/* Visualize all jumps at a given address. */
static void
jump_info_visualize_address (bfd_vma address,
int max_level,
char *line_buffer,
uint8_t *color_buffer)
{
struct jump_info *ji = detected_jumps;
size_t len = (max_level + 1) * 3;
/* Clear line buffer. */
memset (line_buffer, ' ', len);
memset (color_buffer, 0, len);
/* Iterate over jumps and add their ASCII art. */
while (ji)
{
/* Discard jumps that are never needed again. */
if (jump_info_max_address (ji) < address)
{
struct jump_info *tmp = ji;
ji = ji->next;
jump_info_unlink (tmp, &detected_jumps);
jump_info_free (tmp);
continue;
}
/* This jump intersects with the current address. */
if (jump_info_min_address (ji) <= address)
{
/* Hash target address to get an even
distribution between all values. */
bfd_vma hash_address = jump_info_end_address (ji);
uint8_t color = iterative_hash_object (hash_address, 0);
/* Fetch line offset. */
int offset = (max_level - ji->level) * 3;
/* Draw start line. */
if (jump_info_is_start_address (ji, address))
{
size_t i = offset + 1;
for (; i < len - 1; ++i)
if (line_buffer[i] == ' ')
{
line_buffer[i] = '-';
color_buffer[i] = color;
}
if (line_buffer[i] == ' ')
{
line_buffer[i] = '-';
color_buffer[i] = color;
}
else if (line_buffer[i] == '>')
{
line_buffer[i] = 'X';
color_buffer[i] = color;
}
if (line_buffer[offset] == ' ')
{
if (address <= ji->end)
line_buffer[offset] =
(jump_info_min_address (ji) == address) ? ',': '+';
else
line_buffer[offset] =
(jump_info_max_address (ji) == address) ? '\'': '+';
color_buffer[offset] = color;
}
}
/* Draw jump target. */
else if (jump_info_is_end_address (ji, address))
{
size_t i = offset + 1;
for (; i < len - 1; ++i)
if (line_buffer[i] == ' ')
{
line_buffer[i] = '-';
color_buffer[i] = color;
}
if (line_buffer[i] == ' ')
{
line_buffer[i] = '>';
color_buffer[i] = color;
}
else if (line_buffer[i] == '-')
{
line_buffer[i] = 'X';
color_buffer[i] = color;
}
if (line_buffer[offset] == ' ')
{
if (jump_info_min_address (ji) < address)
line_buffer[offset] =
(jump_info_max_address (ji) > address) ? '>' : '\'';
else
line_buffer[offset] = ',';
color_buffer[offset] = color;
}
}
/* Draw intermediate line segment. */
else if (line_buffer[offset] == ' ')
{
line_buffer[offset] = '|';
color_buffer[offset] = color;
}
}
ji = ji->next;
}
}
/* Clone of disassemble_bytes to detect jumps inside a function. */
/* FIXME: is this correct? Can we strip it down even further? */
static struct jump_info *
disassemble_jumps (struct disassemble_info * inf,
disassembler_ftype disassemble_fn,
bfd_vma start_offset,
bfd_vma stop_offset,
bfd_vma rel_offset,
arelent ** relpp,