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 bool disassembler_color = false; /* --disassembler-color=color. */
+static bool disassembler_extended_color = false; /* --disassembler-color=extended-color. */
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
{
Use extended 8-bit color codes\n"));
fprintf (stream, _("\
--visualize-jumps=off Disable jump visualization\n\n"));
+ fprintf (stream, _("\
+ --disassembler-color=off Disable disassembler color output.\n\n"));
+ fprintf (stream, _("\
+ --disassembler-color=color Use basic colors in disassembler output.\n\n"));
list_supported_targets (program_name, stream);
list_supported_architectures (program_name, stream);
OPTION_CTF,
OPTION_CTF_PARENT,
#endif
- OPTION_VISUALIZE_JUMPS
+ OPTION_VISUALIZE_JUMPS,
+ OPTION_DISASSEMBLER_COLOR
};
static struct option long_options[]=
{"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}
};
\f
if (*p == '\0')
--p;
}
- (*inf->fprintf_func) (inf->stream, "%s", p);
+ (*inf->fprintf_styled_func) (inf->stream, dis_style_address, "%s", p);
}
/* Print the name of a symbol. */
if (inf != NULL)
{
- (*inf->fprintf_func) (inf->stream, "%s", name);
+ (*inf->fprintf_styled_func) (inf->stream, dis_style_symbol, "%s", name);
if (version_string && *version_string != '\0')
- (*inf->fprintf_func) (inf->stream, hidden ? "@%s" : "@@%s",
- version_string);
+ (*inf->fprintf_styled_func) (inf->stream, dis_style_symbol,
+ hidden ? "@%s" : "@@%s",
+ version_string);
}
else
{
if (!no_addresses)
{
objdump_print_value (vma, inf, skip_zeroes);
- (*inf->fprintf_func) (inf->stream, " ");
+ (*inf->fprintf_styled_func) (inf->stream, dis_style_text, " ");
}
if (sym == NULL)
{
bfd_vma secaddr;
- (*inf->fprintf_func) (inf->stream, "<%s",
- sanitize_string (bfd_section_name (sec)));
+ (*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_func) (inf->stream, "-0x");
+ (*inf->fprintf_styled_func) (inf->stream, dis_style_immediate,
+ "-0x");
objdump_print_value (secaddr - vma, inf, true);
}
else if (vma > secaddr)
{
- (*inf->fprintf_func) (inf->stream, "+0x");
+ (*inf->fprintf_styled_func) (inf->stream, dis_style_immediate, "+0x");
objdump_print_value (vma - secaddr, inf, true);
}
- (*inf->fprintf_func) (inf->stream, ">");
+ (*inf->fprintf_styled_func) (inf->stream, dis_style_text, ">");
}
else
{
- (*inf->fprintf_func) (inf->stream, "<");
+ (*inf->fprintf_styled_func) (inf->stream, dis_style_text, "<");
objdump_print_symname (abfd, inf, sym);
;
else if (bfd_asymbol_value (sym) > vma)
{
- (*inf->fprintf_func) (inf->stream, "-0x");
+ (*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_func) (inf->stream, "+0x");
+ (*inf->fprintf_styled_func) (inf->stream, dis_style_immediate, "+0x");
objdump_print_value (vma - bfd_asymbol_value (sym), inf, true);
}
- (*inf->fprintf_func) (inf->stream, ">");
+ (*inf->fprintf_styled_func) (inf->stream, dis_style_text, ">");
}
if (display_file_offsets)
- inf->fprintf_func (inf->stream, _(" (File Offset: 0x%lx)"),
- (long int)(sec->filepos + (vma - sec->vma)));
+ inf->fprintf_styled_func (inf->stream, dis_style_text,
+ _(" (File Offset: 0x%lx)"),
+ (long int)(sec->filepos + (vma - sec->vma)));
}
/* Print an address (VMA), symbolically if possible.
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)
+ {
+ if (disassembler_in_comment)
+ return color;
+
+ switch (style)
+ {
+ case dis_style_symbol: color = 32; break;
+ case dis_style_assembler_directive:
+ 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_extended_color)
+ {
+ if (disassembler_in_comment)
+ return 250;
+
+ switch (style)
+ {
+ case dis_style_symbol: color = 40; break;
+ case dis_style_assembler_directive:
+ 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;
+ }
+ }
+
+ 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)
+ 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. */
sfile.pos = 0;
inf->insn_info_valid = 0;
- inf->fprintf_func = (fprintf_ftype) objdump_sprintf;
- inf->stream = &sfile;
+ disassemble_set_printf (inf, &sfile, (fprintf_ftype) objdump_sprintf,
+ (fprintf_styled_ftype) objdump_styled_sprintf);
addr_offset = start_offset;
while (addr_offset < stop_offset)
/* Extract jump information. */
inf->insn_info_valid = 0;
+ disassembler_in_comment = false;
octets = (*disassemble_fn) (section->vma + addr_offset, inf);
/* Test if a jump was detected. */
if (inf->insn_info_valid
addr_offset += octets / opb;
}
- inf->fprintf_func = (fprintf_ftype) fprintf;
- inf->stream = stdout;
-
+ disassemble_set_printf (inf, (void *) stdout, (fprintf_ftype) fprintf,
+ (fprintf_styled_ftype) fprintf_styled);
free (sfile.buffer);
/* Merge jumps. */
return 1;
}
+/* Like null_print, but takes the extra STYLE argument. As this is not
+ going to print anything, the extra argument is just ignored. */
+
+static int
+null_styled_print (const void * stream ATTRIBUTE_UNUSED,
+ enum disassembler_style style ATTRIBUTE_UNUSED,
+ const char * format ATTRIBUTE_UNUSED, ...)
+{
+ return 1;
+}
+
/* Print out jump visualization. */
static void
int insn_size;
sfile.pos = 0;
- inf->fprintf_func = (fprintf_ftype) objdump_sprintf;
- inf->stream = &sfile;
+ disassemble_set_printf
+ (inf, &sfile, (fprintf_ftype) objdump_sprintf,
+ (fprintf_styled_ftype) objdump_styled_sprintf);
inf->bytes_per_line = 0;
inf->bytes_per_chunk = 0;
inf->flags = ((disassemble_all ? DISASSEMBLE_DATA : 0)
twice, but we only do this when there is a high
probability that there is a reloc that will
affect the instruction. */
- inf->fprintf_func = (fprintf_ftype) null_print;
+ disassemble_set_printf
+ (inf, inf->stream, (fprintf_ftype) null_print,
+ (fprintf_styled_ftype) null_styled_print);
insn_size = disassemble_fn (section->vma
+ addr_offset, inf);
- inf->fprintf_func = (fprintf_ftype) objdump_sprintf;
+ disassemble_set_printf
+ (inf, inf->stream,
+ (fprintf_ftype) objdump_sprintf,
+ (fprintf_styled_ftype) objdump_styled_sprintf);
}
}
inf->stop_vma = section->vma + stop_offset;
inf->stop_offset = stop_offset;
+ disassembler_in_comment = false;
insn_size = (*disassemble_fn) (section->vma + addr_offset, inf);
octets = insn_size;
inf->stop_vma = 0;
- inf->fprintf_func = (fprintf_ftype) fprintf;
- inf->stream = stdout;
+ disassemble_set_printf (inf, stdout, (fprintf_ftype) fprintf,
+ (fprintf_styled_ftype) fprintf_styled);
if (insn_width == 0 && inf->bytes_per_line != 0)
octets_per_line = inf->bytes_per_line;
if (insn_size < (int) opb)
sf.alloc = strlen (sym->name) + 40;
sf.buffer = (char*) xmalloc (sf.alloc);
sf.pos = 0;
- di.fprintf_func = (fprintf_ftype) objdump_sprintf;
- di.stream = &sf;
+ disassemble_set_printf
+ (&di, &sf, (fprintf_ftype) objdump_sprintf,
+ (fprintf_styled_ftype) objdump_styled_sprintf);
objdump_print_symname (abfd, &di, sym);
++sorted_symcount;
}
- init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf);
-
+ init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf,
+ (fprintf_styled_ftype) fprintf_styled);
disasm_info.application_data = (void *) &aux;
aux.abfd = abfd;
aux.require_sec = false;
nonfatal (_("unrecognized argument to --visualize-option"));
}
break;
+ case OPTION_DISASSEMBLER_COLOR:
+ if (streq (optarg, "off"))
+ disassembler_color = false;
+ else if (streq (optarg, "color"))
+ disassembler_color = true;
+ else if (streq (optarg, "extended-color"))
+ disassembler_extended_color = true;
+ else
+ nonfatal (_("unrecognized argument to --disassembler-color"));
+ break;
case 'E':
if (strcmp (optarg, "B") == 0)
endian = BFD_ENDIAN_BIG;
#include <string.h>
#include "bfd.h"
- typedef int (*fprintf_ftype) (void *, const char*, ...) ATTRIBUTE_FPTR_PRINTF_2;
-
enum dis_insn_type
{
dis_noninsn, /* Not a valid instruction. */
dis_dref2 /* Two data references in instruction. */
};
+/* When printing styled disassembler output, this describes what style
+ should be used. */
+
+enum disassembler_style
+{
+ /* This is the default style, use this for any additional syntax
+ (e.g. commas between operands, brackets, etc), or just as a default if
+ no other style seems appropriate. */
+ dis_style_text,
+
+ /* Use this for all instruction mnemonics, or aliases for mnemonics.
+ These should be things that correspond to real machine
+ instructions. */
+ dis_style_mnemonic,
+
+ /* For things that aren't real machine instructions, but rather
+ assembler directives, e.g. .byte, etc. */
+ dis_style_assembler_directive,
+
+ /* Use this for any register names. This may or may-not include any
+ register prefix, e.g. '$', '%', at the discretion of the target,
+ though within each target the choice to include prefixes for not
+ should be kept consistent. If the prefix is not printed with this
+ style, then dis_style_text should be used. */
+ dis_style_register,
+
+ /* Use this for any constant values used within instructions or
+ directives, unless the value is an absolute address, or an offset
+ that will be added to an address (no matter where the address comes
+ from) before use. This style may, or may-not be used for any
+ prefix to the immediate value, e.g. '$', at the discretion of the
+ target, though within each target the choice to include these
+ prefixes should be kept consistent. */
+ dis_style_immediate,
+
+ /* The style for the numerical representation of an absolute address.
+ Anything that is an address offset should use the immediate style.
+ This style may, or may-not be used for any prefix to the immediate
+ value, e.g. '$', at the discretion of the target, though within
+ each target the choice to include these prefixes should be kept
+ consistent. */
+ dis_style_address,
+
+ /* The style for any constant value within an instruction or directive
+ that represents an offset that will be added to an address before
+ use. This style may, or may-not be used for any prefix to the
+ immediate value, e.g. '$', at the discretion of the target, though
+ within each target the choice to include these prefixes should be
+ kept consistent. */
+ dis_style_address_offset,
+
+ /* The style for a symbol's name. The numerical address of a symbol
+ should use the address style above, this style is reserved for the
+ name. */
+ dis_style_symbol,
+
+ /* The start of a comment that runs to the end of the line. Anything
+ printed after a comment start might be styled differently,
+ e.g. everything might be styled as a comment, regardless of the
+ actual style used. The disassembler itself should not try to adjust
+ the style emitted for comment content, e.g. an address emitted within
+ a comment should still be given dis_style_address, in this way it is
+ up to the user of the disassembler to decide how comments should be
+ styled. */
+ dis_style_comment_start
+};
+
+typedef int (*fprintf_ftype) (void *, const char*, ...) ATTRIBUTE_FPTR_PRINTF_2;
+typedef int (*fprintf_styled_ftype) (void *, enum disassembler_style, const char*, ...) ATTRIBUTE_FPTR_PRINTF_3;
+
/* This struct is passed into the instruction decoding routine,
and is passed back out into each callback. The various fields are used
for conveying information from your main routine into your callbacks,
typedef struct disassemble_info
{
fprintf_ftype fprintf_func;
+ fprintf_styled_ftype fprintf_styled_func;
void *stream;
void *application_data;
disassembling such as the way mapping symbols are found on AArch64. */
bfd_vma stop_offset;
+ /* Set to true if the disassembler applied styling to the output,
+ otherwise, set to false. */
+ bool created_styled_output;
} disassemble_info;
/* This struct is used to pass information about valid disassembler
/* Tidy any memory allocated by targets, such as info->private_data. */
extern void disassemble_free_target (struct disassemble_info *);
+/* Set the basic disassembler print functions. */
+extern void disassemble_set_printf (struct disassemble_info *, void *,
+ fprintf_ftype, fprintf_styled_ftype);
+
/* Document any target specific options available from the disassembler. */
extern void disassembler_usage (FILE *);
/* Method to initialize a disassemble_info struct. This should be
called by all applications creating such a struct. */
extern void init_disassemble_info (struct disassemble_info *dinfo, void *stream,
- fprintf_ftype fprintf_func);
+ fprintf_ftype fprintf_func,
+ fprintf_styled_ftype fprintf_styled_func);
/* For compatibility with existing code. */
-#define INIT_DISASSEMBLE_INFO(INFO, STREAM, FPRINTF_FUNC) \
- init_disassemble_info (&(INFO), (STREAM), (fprintf_ftype) (FPRINTF_FUNC))
+#define INIT_DISASSEMBLE_INFO(INFO, STREAM, FPRINTF_FUNC, FPRINTF_STYLED_FUNC) \
+ init_disassemble_info (&(INFO), (STREAM), (fprintf_ftype) (FPRINTF_FUNC), \
+ (fprintf_styled_ftype) (FPRINTF_STYLED_FUNC))
#ifdef __cplusplus
}
projects / binutils-gdb.git / commitdiff