From b3aa80b45c4f46029efeb204bb9f2d2c4278a0e5 Mon Sep 17 00:00:00 2001
|
From: Nick Clifton <nickc@redhat.com>
|
Date: Tue, 9 Nov 2021 13:25:42 +0000
|
Subject: [PATCH] Add --unicode option to control how unicode characters are
|
handled by display tools.
|
|
* nm.c: Add --unicode option to control how unicode characters are
|
handled.
|
* objdump.c: Likewise.
|
* readelf.c: Likewise.
|
* strings.c: Likewise.
|
* binutils.texi: Document the new feature.
|
* NEWS: Document the new feature.
|
* testsuite/binutils-all/unicode.exp: New file.
|
* testsuite/binutils-all/nm.hex.unicode
|
* testsuite/binutils-all/strings.escape.unicode
|
* testsuite/binutils-all/objdump.highlight.unicode
|
* testsuite/binutils-all/readelf.invalid.unicode
|
|
CVE: CVE-2021-42574
|
Upstream-Status: Backport [https://sourceware.org/git/?p=binutils-gdb.git;a=commit;h=b3aa80b45c4f46029efeb204bb9f2d2c4278a0e5]
|
|
RP: Added tweak uint -> unsigned int partial backport of
|
https://sourceware.org/git/?p=binutils-gdb.git;a=commitdiff;h=795588aec4f894206863c938bd6d716895886009
|
|
Signed-off-by: pgowda <pgowda.cve@gmail.com>
|
---
|
binutils/ChangeLog | 15 +
|
binutils/NEWS | 9 +
|
binutils/doc/binutils.texi | 78 ++++
|
binutils/nm.c | 228 ++++++++++-
|
binutils/objdump.c | 235 ++++++++++--
|
binutils/readelf.c | 190 +++++++++-
|
binutils/strings.c | 757 ++++++++++++++++++++++++++++++++++---
|
7 files changed, 1409 insertions(+), 103 deletions(-)
|
|
diff --git a/binutils/ChangeLog b/binutils/ChangeLog
|
--- a/binutils/ChangeLog 2021-12-19 19:00:27.038540406 -0800
|
+++ b/binutils/ChangeLog 2021-12-19 19:28:42.733565078 -0800
|
@@ -1,3 +1,18 @@
|
+2021-11-09 Nick Clifton <nickc@redhat.com>
|
+
|
+ * nm.c: Add --unicode option to control how unicode characters are
|
+ handled.
|
+ * objdump.c: Likewise.
|
+ * readelf.c: Likewise.
|
+ * strings.c: Likewise.
|
+ * binutils.texi: Document the new feature.
|
+ * NEWS: Document the new feature.
|
+ * testsuite/binutils-all/unicode.exp: New file.
|
+ * testsuite/binutils-all/nm.hex.unicode
|
+ * testsuite/binutils-all/strings.escape.unicode
|
+ * testsuite/binutils-all/objdump.highlight.unicode
|
+ * testsuite/binutils-all/readelf.invalid.unicode
|
+
|
2021-07-16 Nick Clifton <nickc@redhat.com>
|
|
* po/sv.po: Updated Swedish translation.
|
diff --git a/binutils/doc/binutils.texi b/binutils/doc/binutils.texi
|
--- a/binutils/doc/binutils.texi 2021-12-19 19:00:27.042540338 -0800
|
+++ b/binutils/doc/binutils.texi 2021-12-19 19:27:56.526354667 -0800
|
@@ -812,6 +812,7 @@ nm [@option{-A}|@option{-o}|@option{--pr
|
[@option{-s}|@option{--print-armap}]
|
[@option{-t} @var{radix}|@option{--radix=}@var{radix}]
|
[@option{-u}|@option{--undefined-only}]
|
+ [@option{-U} @var{method}] [@option{--unicode=}@var{method}]
|
[@option{-V}|@option{--version}]
|
[@option{-X 32_64}]
|
[@option{--defined-only}]
|
@@ -1132,6 +1133,21 @@ Use @var{radix} as the radix for printin
|
@cindex undefined symbols
|
Display only undefined symbols (those external to each object file).
|
|
+@item -U @var{[d|i|l|e|x|h]}
|
+@itemx --unicode=@var{[default|invalid|locale|escape|hex|highlight]}
|
+Controls the display of UTF-8 encoded mulibyte characters in strings.
|
+The default (@option{--unicode=default}) is to give them no special
|
+treatment. The @option{--unicode=locale} option displays the sequence
|
+in the current locale, which may or may not support them. The options
|
+@option{--unicode=hex} and @option{--unicode=invalid} display them as
|
+hex byte sequences enclosed by either angle brackets or curly braces.
|
+
|
+The @option{--unicode=escape} option displays them as escape sequences
|
+(@var{\uxxxx}) and the @option{--unicode=highlight} option displays
|
+them as escape sequences highlighted in red (if supported by the
|
+output device). The colouring is intended to draw attention to the
|
+presence of unicode sequences where they might not be expected.
|
+
|
@item -V
|
@itemx --version
|
Show the version number of @command{nm} and exit.
|
@@ -2247,6 +2263,7 @@ objdump [@option{-a}|@option{--archive-h
|
[@option{--prefix-strip=}@var{level}]
|
[@option{--insn-width=}@var{width}]
|
[@option{--visualize-jumps[=color|=extended-color|=off]}
|
+ [@option{-U} @var{method}] [@option{--unicode=}@var{method}]
|
[@option{-V}|@option{--version}]
|
[@option{-H}|@option{--help}]
|
@var{objfile}@dots{}
|
@@ -2921,6 +2938,21 @@ When displaying symbols include those wh
|
special in some way and which would not normally be of interest to the
|
user.
|
|
+@item -U @var{[d|i|l|e|x|h]}
|
+@itemx --unicode=@var{[default|invalid|locale|escape|hex|highlight]}
|
+Controls the display of UTF-8 encoded mulibyte characters in strings.
|
+The default (@option{--unicode=default}) is to give them no special
|
+treatment. The @option{--unicode=locale} option displays the sequence
|
+in the current locale, which may or may not support them. The options
|
+@option{--unicode=hex} and @option{--unicode=invalid} display them as
|
+hex byte sequences enclosed by either angle brackets or curly braces.
|
+
|
+The @option{--unicode=escape} option displays them as escape sequences
|
+(@var{\uxxxx}) and the @option{--unicode=highlight} option displays
|
+them as escape sequences highlighted in red (if supported by the
|
+output device). The colouring is intended to draw attention to the
|
+presence of unicode sequences where they might not be expected.
|
+
|
@item -V
|
@itemx --version
|
Print the version number of @command{objdump} and exit.
|
@@ -3197,6 +3229,7 @@ strings [@option{-afovV}] [@option{-}@va
|
[@option{-n} @var{min-len}] [@option{--bytes=}@var{min-len}]
|
[@option{-t} @var{radix}] [@option{--radix=}@var{radix}]
|
[@option{-e} @var{encoding}] [@option{--encoding=}@var{encoding}]
|
+ [@option{-U} @var{method}] [@option{--unicode=}@var{method}]
|
[@option{-}] [@option{--all}] [@option{--print-file-name}]
|
[@option{-T} @var{bfdname}] [@option{--target=}@var{bfdname}]
|
[@option{-w}] [@option{--include-all-whitespace}]
|
@@ -3288,6 +3321,28 @@ single-8-bit-byte characters, @samp{b} =
|
littleendian. Useful for finding wide character strings. (@samp{l}
|
and @samp{b} apply to, for example, Unicode UTF-16/UCS-2 encodings).
|
|
+@item -U @var{[d|i|l|e|x|h]}
|
+@itemx --unicode=@var{[default|invalid|locale|escape|hex|highlight]}
|
+Controls the display of UTF-8 encoded mulibyte characters in strings.
|
+The default (@option{--unicode=default}) is to give them no special
|
+treatment, and instead rely upon the setting of the
|
+@option{--encoding} option. The other values for this option
|
+automatically enable @option{--encoding=S}.
|
+
|
+The @option{--unicode=invalid} option treats them as non-graphic
|
+characters and hence not part of a valid string. All the remaining
|
+options treat them as valid string characters.
|
+
|
+The @option{--unicode=locale} option displays them in the current
|
+locale, which may or may not support UTF-8 encoding. The
|
+@option{--unicode=hex} option displays them as hex byte sequences
|
+enclosed between @var{<>} characters. The @option{--unicode=escape}
|
+option displays them as escape sequences (@var{\uxxxx}) and the
|
+@option{--unicode=highlight} option displays them as escape sequences
|
+highlighted in red (if supported by the output device). The colouring
|
+is intended to draw attention to the presence of unicode sequences
|
+where they might not be expected.
|
+
|
@item -T @var{bfdname}
|
@itemx --target=@var{bfdname}
|
@cindex object code format
|
@@ -4796,6 +4851,7 @@ readelf [@option{-a}|@option{--all}]
|
[@option{--demangle@var{=style}}|@option{--no-demangle}]
|
[@option{--quiet}]
|
[@option{--recurse-limit}|@option{--no-recurse-limit}]
|
+ [@option{-U} @var{method}|@option{--unicode=}@var{method}]
|
[@option{-n}|@option{--notes}]
|
[@option{-r}|@option{--relocs}]
|
[@option{-u}|@option{--unwind}]
|
@@ -4962,6 +5018,28 @@ necessary in order to demangle truly com
|
that if the recursion limit is disabled then stack exhaustion is
|
possible and any bug reports about such an event will be rejected.
|
|
+@item -U @var{[d|i|l|e|x|h]}
|
+@itemx --unicode=[default|invalid|locale|escape|hex|highlight]
|
+Controls the display of non-ASCII characters in identifier names.
|
+The default (@option{--unicode=locale} or @option{--unicode=default}) is
|
+to treat them as multibyte characters and display them in the current
|
+locale. All other versions of this option treat the bytes as UTF-8
|
+encoded values and attempt to interpret them. If they cannot be
|
+interpreted or if the @option{--unicode=invalid} option is used then
|
+they are displayed as a sequence of hex bytes, encloses in curly
|
+parethesis characters.
|
+
|
+Using the @option{--unicode=escape} option will display the characters
|
+as as unicode escape sequences (@var{\uxxxx}). Using the
|
+@option{--unicode=hex} will display the characters as hex byte
|
+sequences enclosed between angle brackets.
|
+
|
+Using the @option{--unicode=highlight} will display the characters as
|
+unicode escape sequences but it will also highlighted them in red,
|
+assuming that colouring is supported by the output device. The
|
+colouring is intended to draw attention to the presence of unicode
|
+sequences when they might not be expected.
|
+
|
@item -e
|
@itemx --headers
|
Display all the headers in the file. Equivalent to @option{-h -l -S}.
|
diff --git a/binutils/NEWS b/binutils/NEWS
|
--- a/binutils/NEWS 2021-12-19 19:00:27.038540406 -0800
|
+++ b/binutils/NEWS 2021-12-19 19:30:04.764162972 -0800
|
@@ -1,5 +1,14 @@
|
-*- text -*-
|
|
+* Tools which display symbols or strings (readelf, strings, nm, objdump)
|
+ have a new command line option which controls how unicode characters are
|
+ handled. By default they are treated as normal for the tool. Using
|
+ --unicode=locale will display them according to the current locale.
|
+ Using --unicode=hex will display them as hex byte values, whilst
|
+ --unicode=escape will display them as escape sequences. In addition
|
+ using --unicode=highlight will display them as unicode escape sequences
|
+ highlighted in red (if supported by the output device).
|
+
|
Changes in 2.37:
|
|
* The readelf tool has a new command line option which can be used to specify
|
diff --git a/binutils/nm.c b/binutils/nm.c
|
--- a/binutils/nm.c 2021-12-19 19:00:27.046540270 -0800
|
+++ b/binutils/nm.c 2021-12-19 19:36:34.797491555 -0800
|
@@ -38,6 +38,11 @@
|
#include "bucomm.h"
|
#include "plugin-api.h"
|
#include "plugin.h"
|
+#include "safe-ctype.h"
|
+
|
+#ifndef streq
|
+#define streq(a,b) (strcmp ((a),(b)) == 0)
|
+#endif
|
|
/* When sorting by size, we use this structure to hold the size and a
|
pointer to the minisymbol. */
|
@@ -216,6 +221,18 @@ static const char *plugin_target = NULL;
|
static bfd *lineno_cache_bfd;
|
static bfd *lineno_cache_rel_bfd;
|
|
+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;
|
+
|
enum long_option_values
|
{
|
OPTION_TARGET = 200,
|
@@ -260,6 +277,7 @@ static struct option long_options[] =
|
{"target", required_argument, 0, OPTION_TARGET},
|
{"defined-only", no_argument, &defined_only, 1},
|
{"undefined-only", no_argument, &undefined_only, 1},
|
+ {"unicode", required_argument, NULL, 'U'},
|
{"version", no_argument, &show_version, 1},
|
{"with-symbol-versions", no_argument, &with_symbol_versions, 1},
|
{"without-symbol-versions", no_argument, &with_symbol_versions, 0},
|
@@ -313,6 +331,8 @@ usage (FILE *stream, int status)
|
-t, --radix=RADIX Use RADIX for printing symbol values\n\
|
--target=BFDNAME Specify the target object format as BFDNAME\n\
|
-u, --undefined-only Display only undefined symbols\n\
|
+ -U {d|s|i|x|e|h} Specify how to treat UTF-8 encoded unicode characters\n\
|
+ --unicode={default|show|invalid|hex|escape|highlight}\n\
|
--with-symbol-versions Display version strings after symbol names\n\
|
-X 32_64 (ignored)\n\
|
@FILE Read options from FILE\n\
|
@@ -432,6 +452,187 @@ get_coff_symbol_type (const struct inter
|
return bufp;
|
}
|
|
+/* 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 += sprintf (out, "%c", unicode_display == unicode_hex ? '<' : '{');
|
+ out += sprintf (out, "0x");
|
+ for (j = 0; j < nchars; j++)
|
+ out += sprintf (out, "%02x", in [j]);
|
+ out += sprintf (out, "%c", 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, "\033[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;
|
+}
|
+
|
+/* Convert any UTF-8 encoded characters in NAME into the form specified by
|
+ unicode_display. Also converts control characters. Returns a static
|
+ buffer if conversion was necessary.
|
+ Code stolen from objdump.c:sanitize_string(). */
|
+
|
+static const char *
|
+convert_utf8 (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;
|
+ if (buffer_len < (strlen (in) * 9))
|
+ {
|
+ free ((void *) buffer);
|
+ buffer_len = strlen (in) * 9;
|
+ buffer = xmalloc (buffer_len + 1);
|
+ }
|
+
|
+ 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 - 1), out, & num_consumed);
|
+ in += num_consumed - 1;
|
+ }
|
+ else
|
+ *out++ = c;
|
+ }
|
+ while (1);
|
+
|
+ *out = 0;
|
+ return buffer;
|
+}
|
+
|
/* Print symbol name NAME, read from ABFD, with printf format FORM,
|
demangling it if requested. */
|
|
@@ -444,6 +645,7 @@ print_symname (const char *form, struct
|
|
if (name == NULL)
|
name = info->sinfo->name;
|
+
|
if (!with_symbol_versions
|
&& bfd_get_flavour (abfd) == bfd_target_elf_flavour)
|
{
|
@@ -451,6 +653,7 @@ print_symname (const char *form, struct
|
if (atver)
|
*atver = 0;
|
}
|
+
|
if (do_demangle && *name)
|
{
|
alloc = bfd_demangle (abfd, name, demangle_flags);
|
@@ -458,6 +661,11 @@ print_symname (const char *form, struct
|
name = alloc;
|
}
|
|
+ if (unicode_display != unicode_default)
|
+ {
|
+ name = convert_utf8 (name);
|
+ }
|
+
|
if (info != NULL && info->elfinfo && with_symbol_versions)
|
{
|
const char *version_string;
|
@@ -1807,7 +2015,7 @@ main (int argc, char **argv)
|
fatal (_("fatal error: libbfd ABI mismatch"));
|
set_default_bfd_target ();
|
|
- while ((c = getopt_long (argc, argv, "aABCDef:gHhjJlnopPrSst:uvVvX:",
|
+ while ((c = getopt_long (argc, argv, "aABCDef:gHhjJlnopPrSst:uU:vVvX:",
|
long_options, (int *) 0)) != EOF)
|
{
|
switch (c)
|
@@ -1900,6 +2108,24 @@ main (int argc, char **argv)
|
case 'u':
|
undefined_only = 1;
|
break;
|
+
|
+ case 'U':
|
+ if (streq (optarg, "default") || streq (optarg, "d"))
|
+ unicode_display = unicode_default;
|
+ else if (streq (optarg, "locale") || streq (optarg, "l"))
|
+ unicode_display = unicode_locale;
|
+ else if (streq (optarg, "escape") || streq (optarg, "e"))
|
+ unicode_display = unicode_escape;
|
+ else if (streq (optarg, "invalid") || streq (optarg, "i"))
|
+ unicode_display = unicode_invalid;
|
+ else if (streq (optarg, "hex") || streq (optarg, "x"))
|
+ unicode_display = unicode_hex;
|
+ else if (streq (optarg, "highlight") || streq (optarg, "h"))
|
+ unicode_display = unicode_highlight;
|
+ else
|
+ fatal (_("invalid argument to -U/--unicode: %s"), optarg);
|
+ break;
|
+
|
case 'V':
|
show_version = 1;
|
break;
|
diff --git a/binutils/objdump.c b/binutils/objdump.c
|
--- a/binutils/objdump.c 2021-12-19 19:00:27.046540270 -0800
|
+++ b/binutils/objdump.c 2021-12-19 19:43:09.438736729 -0800
|
@@ -204,6 +204,18 @@ static const struct objdump_private_desc
|
|
/* 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
|
@@ -330,6 +342,9 @@ usage (FILE *stream, int status)
|
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"));
|
@@ -420,17 +435,23 @@ 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'},
|
- {"private", required_argument, NULL, 'P'},
|
{"architecture", required_argument, NULL, 'm'},
|
{"archive-headers", no_argument, NULL, 'a'},
|
+#ifdef ENABLE_LIBCTF
|
+ {"ctf", required_argument, NULL, OPTION_CTF},
|
+ {"ctf-parent", required_argument, NULL, OPTION_CTF_PARENT},
|
+#endif
|
{"debugging", no_argument, NULL, 'g'},
|
{"debugging-tags", no_argument, NULL, 'e'},
|
{"demangle", optional_argument, NULL, 'C'},
|
{"disassemble", optional_argument, NULL, 'd'},
|
{"disassemble-all", no_argument, NULL, 'D'},
|
- {"disassembler-options", required_argument, NULL, 'M'},
|
{"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},
|
@@ -440,16 +461,23 @@ static struct option long_options[]=
|
{"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-show-raw-insn", no_argument, &show_raw_insn, -1},
|
{"no-addresses", no_argument, &no_addresses, 1},
|
- {"process-links", no_argument, &process_links, true},
|
+ {"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},
|
- {"no-recurse-limit", no_argument, NULL, OPTION_NO_RECURSE_LIMIT},
|
- {"no-recursion-limit", no_argument, NULL, OPTION_NO_RECURSE_LIMIT},
|
{"reloc", no_argument, NULL, 'r'},
|
{"section", required_argument, NULL, 'j'},
|
{"section-headers", no_argument, NULL, 'h'},
|
@@ -457,28 +485,16 @@ static struct option long_options[]=
|
{"source", no_argument, NULL, 'S'},
|
{"source-comment", optional_argument, NULL, OPTION_SOURCE_COMMENT},
|
{"special-syms", no_argument, &dump_special_syms, 1},
|
- {"include", required_argument, NULL, 'I'},
|
- {"dwarf", optional_argument, NULL, OPTION_DWARF},
|
-#ifdef ENABLE_LIBCTF
|
- {"ctf", required_argument, NULL, OPTION_CTF},
|
- {"ctf-parent", required_argument, NULL, OPTION_CTF_PARENT},
|
-#endif
|
{"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'},
|
- {"wide", no_argument, NULL, 'w'},
|
- {"prefix", required_argument, NULL, OPTION_PREFIX},
|
- {"prefix-strip", required_argument, NULL, OPTION_PREFIX_STRIP},
|
- {"insn-width", required_argument, NULL, OPTION_INSN_WIDTH},
|
- {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
|
- {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
|
- {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
|
- {"inlines", no_argument, 0, OPTION_INLINES},
|
{"visualize-jumps", optional_argument, 0, OPTION_VISUALIZE_JUMPS},
|
- {0, no_argument, 0, 0}
|
+ {"wide", no_argument, NULL, 'w'},
|
+ {NULL, no_argument, NULL, 0}
|
};
|
|
static void
|
@@ -488,9 +504,121 @@ nonfatal (const char *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 += sprintf (out, "%c", unicode_display == unicode_hex ? '<' : '{');
|
+ out += sprintf (out, "0x");
|
+ for (j = 0; j < nchars; j++)
|
+ out += sprintf (out, "%02x", in [j]);
|
+ out += sprintf (out, "%c", 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, "\033[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 necessary.
|
+
|
+ If unicode display is enabled, then also handles the
|
+ conversion of unicode characters. */
|
|
static const char *
|
sanitize_string (const char * in)
|
@@ -508,40 +636,50 @@ sanitize_string (const char * in)
|
of cases it will not be needed. */
|
do
|
{
|
- char c = *in++;
|
+ 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;
|
- if (buffer_len < (strlen (in) * 2))
|
+ if (buffer_len < (strlen (in) * 9))
|
{
|
free ((void *) buffer);
|
- buffer_len = strlen (in) * 2;
|
+ buffer_len = strlen (in) * 9;
|
buffer = xmalloc (buffer_len + 1);
|
}
|
|
out = buffer;
|
do
|
{
|
- char c = *in++;
|
+ unsigned char c = *in++;
|
|
if (c == 0)
|
break;
|
|
- if (!ISCNTRL (c))
|
- *out++ = c;
|
- else
|
+ 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 - 1), out, & num_consumed);
|
+ in += num_consumed - 1;
|
+ }
|
+ else
|
+ *out++ = c;
|
}
|
while (1);
|
|
@@ -4529,6 +4667,24 @@ dump_symbols (bfd *abfd ATTRIBUTE_UNUSED
|
free (alloc);
|
}
|
}
|
+ else if (unicode_display != unicode_default
|
+ && name != NULL && *name != '\0')
|
+ {
|
+ const char * sanitized_name;
|
+
|
+ /* If we want to sanitize the name, we do it here, and
|
+ temporarily clobber it while calling bfd_print_symbol.
|
+ FIXME: This is a gross hack. */
|
+ sanitized_name = sanitize_string (name);
|
+ if (sanitized_name != name)
|
+ (*current)->name = sanitized_name;
|
+ else
|
+ sanitized_name = NULL;
|
+ bfd_print_symbol (cur_bfd, stdout, *current,
|
+ bfd_print_symbol_all);
|
+ if (sanitized_name != NULL)
|
+ (*current)->name = name;
|
+ }
|
else
|
bfd_print_symbol (cur_bfd, stdout, *current,
|
bfd_print_symbol_all);
|
@@ -5212,7 +5368,7 @@ main (int argc, char **argv)
|
set_default_bfd_target ();
|
|
while ((c = getopt_long (argc, argv,
|
- "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
|
+ "CDE:FGHI:LM:P:RSTU:VW::ab:defghij:lm:prstvwxz",
|
long_options, (int *) 0))
|
!= EOF)
|
{
|
@@ -5495,6 +5651,23 @@ main (int argc, char **argv)
|
seenflag = true;
|
break;
|
|
+ case 'U':
|
+ if (streq (optarg, "default") || streq (optarg, "d"))
|
+ unicode_display = unicode_default;
|
+ else if (streq (optarg, "locale") || streq (optarg, "l"))
|
+ unicode_display = unicode_locale;
|
+ else if (streq (optarg, "escape") || streq (optarg, "e"))
|
+ unicode_display = unicode_escape;
|
+ else if (streq (optarg, "invalid") || streq (optarg, "i"))
|
+ unicode_display = unicode_invalid;
|
+ else if (streq (optarg, "hex") || streq (optarg, "x"))
|
+ unicode_display = unicode_hex;
|
+ else if (streq (optarg, "highlight") || streq (optarg, "h"))
|
+ unicode_display = unicode_highlight;
|
+ else
|
+ fatal (_("invalid argument to -U/--unicode: %s"), optarg);
|
+ break;
|
+
|
case 'H':
|
usage (stdout, 0);
|
/* No need to set seenflag or to break - usage() does not return. */
|
diff --git a/binutils/readelf.c b/binutils/readelf.c
|
--- a/binutils/readelf.c 2021-12-19 19:00:27.058540065 -0800
|
+++ b/binutils/readelf.c 2021-12-19 19:27:56.538354462 -0800
|
@@ -328,6 +328,19 @@ typedef enum print_mode
|
}
|
print_mode;
|
|
+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;
|
+
|
+
|
/* Versioned symbol info. */
|
enum versioned_symbol_info
|
{
|
@@ -632,11 +645,18 @@ print_symbol (signed int width, const ch
|
if (c == 0)
|
break;
|
|
- /* Do not print control characters directly as they can affect terminal
|
- settings. Such characters usually appear in the names generated
|
- by the assembler for local labels. */
|
- if (ISCNTRL (c))
|
+ if (ISPRINT (c))
|
+ {
|
+ putchar (c);
|
+ width_remaining --;
|
+ num_printed ++;
|
+ }
|
+ else if (ISCNTRL (c))
|
{
|
+ /* Do not print control characters directly as they can affect terminal
|
+ settings. Such characters usually appear in the names generated
|
+ by the assembler for local labels. */
|
+
|
if (width_remaining < 2)
|
break;
|
|
@@ -644,11 +664,137 @@ print_symbol (signed int width, const ch
|
width_remaining -= 2;
|
num_printed += 2;
|
}
|
- else if (ISPRINT (c))
|
+ else if (c == 0x7f)
|
{
|
- putchar (c);
|
- width_remaining --;
|
- num_printed ++;
|
+ if (width_remaining < 5)
|
+ break;
|
+ printf ("<DEL>");
|
+ width_remaining -= 5;
|
+ num_printed += 5;
|
+ }
|
+ else if (unicode_display != unicode_locale
|
+ && unicode_display != unicode_default)
|
+ {
|
+ /* Display unicode characters as something else. */
|
+ unsigned char bytes[4];
|
+ bool is_utf8;
|
+ unsigned int nbytes;
|
+
|
+ bytes[0] = c;
|
+
|
+ if (bytes[0] < 0xc0)
|
+ {
|
+ nbytes = 1;
|
+ is_utf8 = false;
|
+ }
|
+ else
|
+ {
|
+ bytes[1] = *symbol++;
|
+
|
+ if ((bytes[1] & 0xc0) != 0x80)
|
+ {
|
+ is_utf8 = false;
|
+ /* Do not consume this character. It may only
|
+ be the first byte in the sequence that was
|
+ corrupt. */
|
+ --symbol;
|
+ nbytes = 1;
|
+ }
|
+ else if ((bytes[0] & 0x20) == 0)
|
+ {
|
+ is_utf8 = true;
|
+ nbytes = 2;
|
+ }
|
+ else
|
+ {
|
+ bytes[2] = *symbol++;
|
+
|
+ if ((bytes[2] & 0xc0) != 0x80)
|
+ {
|
+ is_utf8 = false;
|
+ symbol -= 2;
|
+ nbytes = 1;
|
+ }
|
+ else if ((bytes[0] & 0x10) == 0)
|
+ {
|
+ is_utf8 = true;
|
+ nbytes = 3;
|
+ }
|
+ else
|
+ {
|
+ bytes[3] = *symbol++;
|
+
|
+ nbytes = 4;
|
+
|
+ if ((bytes[3] & 0xc0) != 0x80)
|
+ {
|
+ is_utf8 = false;
|
+ symbol -= 3;
|
+ nbytes = 1;
|
+ }
|
+ else
|
+ is_utf8 = true;
|
+ }
|
+ }
|
+ }
|
+
|
+ if (unicode_display == unicode_invalid)
|
+ is_utf8 = false;
|
+
|
+ if (unicode_display == unicode_hex || ! is_utf8)
|
+ {
|
+ unsigned int i;
|
+
|
+ if (width_remaining < (nbytes * 2) + 2)
|
+ break;
|
+
|
+ putchar (is_utf8 ? '<' : '{');
|
+ printf ("0x");
|
+ for (i = 0; i < nbytes; i++)
|
+ printf ("%02x", bytes[i]);
|
+ putchar (is_utf8 ? '>' : '}');
|
+ }
|
+ else
|
+ {
|
+ if (unicode_display == unicode_highlight && isatty (1))
|
+ printf ("\x1B[31;47m"); /* Red. */
|
+
|
+ switch (nbytes)
|
+ {
|
+ case 2:
|
+ if (width_remaining < 6)
|
+ break;
|
+ printf ("\\u%02x%02x",
|
+ (bytes[0] & 0x1c) >> 2,
|
+ ((bytes[0] & 0x03) << 6) | (bytes[1] & 0x3f));
|
+ break;
|
+ case 3:
|
+ if (width_remaining < 6)
|
+ break;
|
+ printf ("\\u%02x%02x",
|
+ ((bytes[0] & 0x0f) << 4) | ((bytes[1] & 0x3c) >> 2),
|
+ ((bytes[1] & 0x03) << 6) | (bytes[2] & 0x3f));
|
+ break;
|
+ case 4:
|
+ if (width_remaining < 8)
|
+ break;
|
+ printf ("\\u%02x%02x%02x",
|
+ ((bytes[0] & 0x07) << 6) | ((bytes[1] & 0x3c) >> 2),
|
+ ((bytes[1] & 0x03) << 6) | ((bytes[2] & 0x3c) >> 2),
|
+ ((bytes[2] & 0x03) << 6) | (bytes[3] & 0x3f));
|
+
|
+ break;
|
+ default:
|
+ /* URG. */
|
+ break;
|
+ }
|
+
|
+ if (unicode_display == unicode_highlight && isatty (1))
|
+ printf ("\033[0m"); /* Default colour. */
|
+ }
|
+
|
+ if (bytes[nbytes - 1] == 0)
|
+ break;
|
}
|
else
|
{
|
@@ -4668,6 +4814,7 @@ static struct option options[] =
|
{"syms", no_argument, 0, 's'},
|
{"silent-truncation",no_argument, 0, 'T'},
|
{"section-details", no_argument, 0, 't'},
|
+ {"unicode", required_argument, NULL, 'U'},
|
{"unwind", no_argument, 0, 'u'},
|
{"version-info", no_argument, 0, 'V'},
|
{"version", no_argument, 0, 'v'},
|
@@ -4744,6 +4891,12 @@ usage (FILE * stream)
|
fprintf (stream, _("\
|
--no-recurse-limit Disable a demangling recursion limit\n"));
|
fprintf (stream, _("\
|
+ -U[dlexhi] --unicode=[default|locale|escape|hex|highlight|invalid]\n\
|
+ Display unicode characters as determined by the current locale\n\
|
+ (default), escape sequences, \"<hex sequences>\", highlighted\n\
|
+ escape sequences, or treat them as invalid and display as\n\
|
+ \"{hex sequences}\"\n"));
|
+ fprintf (stream, _("\
|
-n --notes Display the core notes (if present)\n"));
|
fprintf (stream, _("\
|
-r --relocs Display the relocations (if present)\n"));
|
@@ -4928,7 +5081,7 @@ parse_args (struct dump_data *dumpdata,
|
usage (stderr);
|
|
while ((c = getopt_long
|
- (argc, argv, "ACDHILNPR:STVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
|
+ (argc, argv, "ACDHILNPR:STU:VWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
|
{
|
switch (c)
|
{
|
@@ -5130,6 +5283,25 @@ parse_args (struct dump_data *dumpdata,
|
/* Ignored for backward compatibility. */
|
break;
|
|
+ case 'U':
|
+ if (optarg == NULL)
|
+ error (_("Missing arg to -U/--unicode")); /* Can this happen ? */
|
+ else if (streq (optarg, "default") || streq (optarg, "d"))
|
+ unicode_display = unicode_default;
|
+ else if (streq (optarg, "locale") || streq (optarg, "l"))
|
+ unicode_display = unicode_locale;
|
+ else if (streq (optarg, "escape") || streq (optarg, "e"))
|
+ unicode_display = unicode_escape;
|
+ else if (streq (optarg, "invalid") || streq (optarg, "i"))
|
+ unicode_display = unicode_invalid;
|
+ else if (streq (optarg, "hex") || streq (optarg, "x"))
|
+ unicode_display = unicode_hex;
|
+ else if (streq (optarg, "highlight") || streq (optarg, "h"))
|
+ unicode_display = unicode_highlight;
|
+ else
|
+ error (_("invalid argument to -U/--unicode: %s"), optarg);
|
+ break;
|
+
|
case OPTION_SYM_BASE:
|
sym_base = 0;
|
if (optarg != NULL)
|
diff --git a/binutils/strings.c b/binutils/strings.c
|
--- a/binutils/strings.c 2021-12-19 19:00:27.058540065 -0800
|
+++ b/binutils/strings.c 2021-12-19 19:48:26.205313218 -0800
|
@@ -55,6 +55,19 @@
|
-T {bfdname}
|
Specify a non-default object file format.
|
|
+ --unicode={default|locale|invalid|hex|escape|highlight}
|
+ -u {d|l|i|x|e|h}
|
+ Determine how to handle UTF-8 unicode characters. The default
|
+ is no special treatment. All other versions of this option
|
+ only apply if the encoding is valid and enabling the option
|
+ implies --encoding=S.
|
+ The 'locale' option displays the characters according to the
|
+ current locale. The 'invalid' option treats them as
|
+ non-string characters. The 'hex' option displays them as hex
|
+ byte sequences. The 'escape' option displays them as escape
|
+ sequences and the 'highlight' option displays them as
|
+ coloured escape sequences.
|
+
|
--output-separator=sep_string
|
-s sep_string String used to separate parsed strings in output.
|
Default is newline.
|
@@ -76,6 +89,22 @@
|
#include "safe-ctype.h"
|
#include "bucomm.h"
|
|
+#ifndef streq
|
+#define streq(a,b) (strcmp ((a),(b)) == 0)
|
+#endif
|
+
|
+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;
|
+
|
#define STRING_ISGRAPHIC(c) \
|
( (c) >= 0 \
|
&& (c) <= 255 \
|
@@ -94,7 +123,7 @@ extern int errno;
|
static int address_radix;
|
|
/* Minimum length of sequence of graphic chars to trigger output. */
|
-static int string_min;
|
+static unsigned int string_min;
|
|
/* Whether or not we include all whitespace as a graphic char. */
|
static bool include_all_whitespace;
|
@@ -121,21 +150,22 @@ static char *output_separator;
|
static struct option long_options[] =
|
{
|
{"all", no_argument, NULL, 'a'},
|
+ {"bytes", required_argument, NULL, 'n'},
|
{"data", no_argument, NULL, 'd'},
|
+ {"encoding", required_argument, NULL, 'e'},
|
+ {"help", no_argument, NULL, 'h'},
|
+ {"include-all-whitespace", no_argument, NULL, 'w'},
|
+ {"output-separator", required_argument, NULL, 's'},
|
{"print-file-name", no_argument, NULL, 'f'},
|
- {"bytes", required_argument, NULL, 'n'},
|
{"radix", required_argument, NULL, 't'},
|
- {"include-all-whitespace", no_argument, NULL, 'w'},
|
- {"encoding", required_argument, NULL, 'e'},
|
{"target", required_argument, NULL, 'T'},
|
- {"output-separator", required_argument, NULL, 's'},
|
- {"help", no_argument, NULL, 'h'},
|
+ {"unicode", required_argument, NULL, 'U'},
|
{"version", no_argument, NULL, 'v'},
|
{NULL, 0, NULL, 0}
|
};
|
|
static bool strings_file (char *);
|
-static void print_strings (const char *, FILE *, file_ptr, int, int, char *);
|
+static void print_strings (const char *, FILE *, file_ptr, int, char *);
|
static void usage (FILE *, int) ATTRIBUTE_NORETURN;
|
|
int main (int, char **);
|
@@ -171,7 +201,7 @@ main (int argc, char **argv)
|
encoding = 's';
|
output_separator = NULL;
|
|
- while ((optc = getopt_long (argc, argv, "adfhHn:wot:e:T:s:Vv0123456789",
|
+ while ((optc = getopt_long (argc, argv, "adfhHn:wot:e:T:s:U:Vv0123456789",
|
long_options, (int *) 0)) != EOF)
|
{
|
switch (optc)
|
@@ -244,6 +274,23 @@ main (int argc, char **argv)
|
output_separator = optarg;
|
break;
|
|
+ case 'U':
|
+ if (streq (optarg, "default") || streq (optarg, "d"))
|
+ unicode_display = unicode_default;
|
+ else if (streq (optarg, "locale") || streq (optarg, "l"))
|
+ unicode_display = unicode_locale;
|
+ else if (streq (optarg, "escape") || streq (optarg, "e"))
|
+ unicode_display = unicode_escape;
|
+ else if (streq (optarg, "invalid") || streq (optarg, "i"))
|
+ unicode_display = unicode_invalid;
|
+ else if (streq (optarg, "hex") || streq (optarg, "x"))
|
+ unicode_display = unicode_hex;
|
+ else if (streq (optarg, "highlight") || streq (optarg, "h"))
|
+ unicode_display = unicode_highlight;
|
+ else
|
+ fatal (_("invalid argument to -U/--unicode: %s"), optarg);
|
+ break;
|
+
|
case 'V':
|
case 'v':
|
print_version ("strings");
|
@@ -258,6 +305,9 @@ main (int argc, char **argv)
|
}
|
}
|
|
+ if (unicode_display != unicode_default)
|
+ encoding = 'S';
|
+
|
if (numeric_opt != 0)
|
{
|
string_min = (int) strtoul (argv[numeric_opt - 1] + 1, &s, 0);
|
@@ -293,14 +343,14 @@ main (int argc, char **argv)
|
{
|
datasection_only = false;
|
SET_BINARY (fileno (stdin));
|
- print_strings ("{standard input}", stdin, 0, 0, 0, (char *) NULL);
|
+ print_strings ("{standard input}", stdin, 0, 0, (char *) NULL);
|
files_given = true;
|
}
|
else
|
{
|
for (; optind < argc; ++optind)
|
{
|
- if (strcmp (argv[optind], "-") == 0)
|
+ if (streq (argv[optind], "-"))
|
datasection_only = false;
|
else
|
{
|
@@ -342,7 +392,7 @@ strings_a_section (bfd *abfd, asection *
|
}
|
|
*got_a_section = true;
|
- print_strings (filename, NULL, sect->filepos, 0, sectsize, (char *) mem);
|
+ print_strings (filename, NULL, sect->filepos, sectsize, (char *) mem);
|
free (mem);
|
}
|
|
@@ -427,7 +477,7 @@ strings_file (char *file)
|
return false;
|
}
|
|
- print_strings (file, stream, (file_ptr) 0, 0, 0, (char *) 0);
|
+ print_strings (file, stream, (file_ptr) 0, 0, (char *) NULL);
|
|
if (fclose (stream) == EOF)
|
{
|
@@ -551,6 +601,626 @@ unget_part_char (long c, file_ptr *addre
|
}
|
}
|
}
|
+
|
+static void
|
+print_filename_and_address (const char * filename, file_ptr address)
|
+{
|
+ if (print_filenames)
|
+ printf ("%s: ", filename);
|
+
|
+ if (! print_addresses)
|
+ return;
|
+
|
+ switch (address_radix)
|
+ {
|
+ case 8:
|
+ if (sizeof (address) > sizeof (long))
|
+ {
|
+#ifndef __MSVCRT__
|
+ printf ("%7llo ", (unsigned long long) address);
|
+#else
|
+ printf ("%7I64o ", (unsigned long long) address);
|
+#endif
|
+ }
|
+ else
|
+ printf ("%7lo ", (unsigned long) address);
|
+ break;
|
+
|
+ case 10:
|
+ if (sizeof (address) > sizeof (long))
|
+ {
|
+#ifndef __MSVCRT__
|
+ printf ("%7llu ", (unsigned long long) address);
|
+#else
|
+ printf ("%7I64d ", (unsigned long long) address);
|
+#endif
|
+ }
|
+ else
|
+ printf ("%7ld ", (long) address);
|
+ break;
|
+
|
+ case 16:
|
+ if (sizeof (address) > sizeof (long))
|
+ {
|
+#ifndef __MSVCRT__
|
+ printf ("%7llx ", (unsigned long long) address);
|
+#else
|
+ printf ("%7I64x ", (unsigned long long) address);
|
+#endif
|
+ }
|
+ else
|
+ printf ("%7lx ", (unsigned long) address);
|
+ break;
|
+ }
|
+}
|
+
|
+/* Return non-zero if the bytes starting at BUFFER form a valid UTF-8 encoding.
|
+ If the encoding is valid then returns the number of bytes it uses. */
|
+
|
+static unsigned int
|
+is_valid_utf8 (const unsigned char * buffer, unsigned long buflen)
|
+{
|
+ if (buffer[0] < 0xc0)
|
+ return 0;
|
+
|
+ if (buflen < 2)
|
+ return 0;
|
+
|
+ if ((buffer[1] & 0xc0) != 0x80)
|
+ return 0;
|
+
|
+ if ((buffer[0] & 0x20) == 0)
|
+ return 2;
|
+
|
+ if (buflen < 3)
|
+ return 0;
|
+
|
+ if ((buffer[2] & 0xc0) != 0x80)
|
+ return 0;
|
+
|
+ if ((buffer[0] & 0x10) == 0)
|
+ return 3;
|
+
|
+ if (buflen < 4)
|
+ return 0;
|
+
|
+ if ((buffer[3] & 0xc0) != 0x80)
|
+ return 0;
|
+
|
+ return 4;
|
+}
|
+
|
+/* Display a UTF-8 encoded character in BUFFER according to the setting
|
+ of unicode_display. The character is known to be valid.
|
+ Returns the number of bytes consumed. */
|
+
|
+static unsigned int
|
+display_utf8_char (const unsigned char * buffer)
|
+{
|
+ unsigned int j;
|
+ unsigned int utf8_len;
|
+
|
+ switch (buffer[0] & 0x30)
|
+ {
|
+ case 0x00:
|
+ case 0x10:
|
+ utf8_len = 2;
|
+ break;
|
+ case 0x20:
|
+ utf8_len = 3;
|
+ break;
|
+ default:
|
+ utf8_len = 4;
|
+ }
|
+
|
+ switch (unicode_display)
|
+ {
|
+ default:
|
+ fprintf (stderr, "ICE: unexpected unicode display type\n");
|
+ break;
|
+
|
+ case unicode_escape:
|
+ case unicode_highlight:
|
+ if (unicode_display == unicode_highlight && isatty (1))
|
+ printf ("\x1B[31;47m"); /* Red. */
|
+
|
+ switch (utf8_len)
|
+ {
|
+ case 2:
|
+ printf ("\\u%02x%02x",
|
+ ((buffer[0] & 0x1c) >> 2),
|
+ ((buffer[0] & 0x03) << 6) | (buffer[1] & 0x3f));
|
+ break;
|
+
|
+ case 3:
|
+ printf ("\\u%02x%02x",
|
+ ((buffer[0] & 0x0f) << 4) | ((buffer[1] & 0x3c) >> 2),
|
+ ((buffer[1] & 0x03) << 6) | ((buffer[2] & 0x3f)));
|
+ break;
|
+
|
+ case 4:
|
+ printf ("\\u%02x%02x%02x",
|
+ ((buffer[0] & 0x07) << 6) | ((buffer[1] & 0x3c) >> 2),
|
+ ((buffer[1] & 0x03) << 6) | ((buffer[2] & 0x3c) >> 2),
|
+ ((buffer[2] & 0x03) << 6) | ((buffer[3] & 0x3f)));
|
+ break;
|
+ default:
|
+ /* URG. */
|
+ break;
|
+ }
|
+
|
+ if (unicode_display == unicode_highlight && isatty (1))
|
+ printf ("\033[0m"); /* Default colour. */
|
+ break;
|
+
|
+ case unicode_hex:
|
+ putchar ('<');
|
+ printf ("0x");
|
+ for (j = 0; j < utf8_len; j++)
|
+ printf ("%02x", buffer [j]);
|
+ putchar ('>');
|
+ break;
|
+
|
+ case unicode_locale:
|
+ printf ("%.1s", buffer);
|
+ break;
|
+ }
|
+
|
+ return utf8_len;
|
+}
|
+
|
+/* Display strings in BUFFER. Treat any UTF-8 encoded characters encountered
|
+ according to the setting of the unicode_display variable. The buffer
|
+ contains BUFLEN bytes.
|
+
|
+ Display the characters as if they started at ADDRESS and are contained in
|
+ FILENAME. */
|
+
|
+static void
|
+print_unicode_buffer (const char * filename,
|
+ file_ptr address,
|
+ const unsigned char * buffer,
|
+ unsigned long buflen)
|
+{
|
+ /* Paranoia checks... */
|
+ if (filename == NULL
|
+ || buffer == NULL
|
+ || unicode_display == unicode_default
|
+ || encoding != 'S'
|
+ || encoding_bytes != 1)
|
+ {
|
+ fprintf (stderr, "ICE: bad arguments to print_unicode_buffer\n");
|
+ return;
|
+ }
|
+
|
+ if (buflen == 0)
|
+ return;
|
+
|
+ /* We must only display strings that are at least string_min *characters*
|
+ long. So we scan the buffer in two stages. First we locate the start
|
+ of a potential string. Then we walk along it until we have found
|
+ string_min characters. Then we go back to the start point and start
|
+ displaying characters according to the unicode_display setting. */
|
+
|
+ unsigned long start_point = 0;
|
+ unsigned long i = 0;
|
+ unsigned int char_len = 1;
|
+ unsigned int num_found = 0;
|
+
|
+ for (i = 0; i < buflen; i += char_len)
|
+ {
|
+ int c = buffer[i];
|
+
|
+ char_len = 1;
|
+
|
+ /* Find the first potential character of a string. */
|
+ if (! STRING_ISGRAPHIC (c))
|
+ {
|
+ num_found = 0;
|
+ continue;
|
+ }
|
+
|
+ if (c > 126)
|
+ {
|
+ if (c < 0xc0)
|
+ {
|
+ num_found = 0;
|
+ continue;
|
+ }
|
+
|
+ if ((char_len = is_valid_utf8 (buffer + i, buflen - i)) == 0)
|
+ {
|
+ char_len = 1;
|
+ num_found = 0;
|
+ continue;
|
+ }
|
+
|
+ if (unicode_display == unicode_invalid)
|
+ {
|
+ /* We have found a valid UTF-8 character, but we treat it as non-graphic. */
|
+ num_found = 0;
|
+ continue;
|
+ }
|
+ }
|
+
|
+ if (num_found == 0)
|
+ /* We have found a potential starting point for a string. */
|
+ start_point = i;
|
+
|
+ ++ num_found;
|
+
|
+ if (num_found >= string_min)
|
+ break;
|
+ }
|
+
|
+ if (num_found < string_min)
|
+ return;
|
+
|
+ print_filename_and_address (filename, address + start_point);
|
+
|
+ /* We have found string_min characters. Display them and any
|
+ more that follow. */
|
+ for (i = start_point; i < buflen; i += char_len)
|
+ {
|
+ int c = buffer[i];
|
+
|
+ char_len = 1;
|
+
|
+ if (! STRING_ISGRAPHIC (c))
|
+ break;
|
+ else if (c < 127)
|
+ putchar (c);
|
+ else if (! is_valid_utf8 (buffer + i, buflen - i))
|
+ break;
|
+ else if (unicode_display == unicode_invalid)
|
+ break;
|
+ else
|
+ char_len = display_utf8_char (buffer + i);
|
+ }
|
+
|
+ if (output_separator)
|
+ fputs (output_separator, stdout);
|
+ else
|
+ putchar ('\n');
|
+
|
+ /* FIXME: Using tail recursion here is lazy programming... */
|
+ print_unicode_buffer (filename, address + i, buffer + i, buflen - i);
|
+}
|
+
|
+static int
|
+get_unicode_byte (FILE * stream,
|
+ unsigned char * putback,
|
+ unsigned int * num_putback,
|
+ unsigned int * num_read)
|
+{
|
+ if (* num_putback > 0)
|
+ {
|
+ * num_putback = * num_putback - 1;
|
+ return putback [* num_putback];
|
+ }
|
+
|
+ * num_read = * num_read + 1;
|
+
|
+#if defined(HAVE_GETC_UNLOCKED) && HAVE_DECL_GETC_UNLOCKED
|
+ return getc_unlocked (stream);
|
+#else
|
+ return getc (stream);
|
+#endif
|
+}
|
+
|
+/* Helper function for print_unicode_stream. */
|
+
|
+static void
|
+print_unicode_stream_body (const char * filename,
|
+ file_ptr address,
|
+ FILE * stream,
|
+ unsigned char * putback_buf,
|
+ unsigned int num_putback,
|
+ unsigned char * print_buf)
|
+{
|
+ /* It would be nice if we could just read the stream into a buffer
|
+ and then process if with print_unicode_buffer. But the input
|
+ might be huge or it might time-locked (eg stdin). So instead
|
+ we go one byte at a time... */
|
+
|
+ file_ptr start_point = 0;
|
+ unsigned int num_read = 0;
|
+ unsigned int num_chars = 0;
|
+ unsigned int num_print = 0;
|
+ int c = 0;
|
+
|
+ /* Find a series of string_min characters. Put them into print_buf. */
|
+ do
|
+ {
|
+ if (num_chars >= string_min)
|
+ break;
|
+
|
+ c = get_unicode_byte (stream, putback_buf, & num_putback, & num_read);
|
+ if (c == EOF)
|
+ break;
|
+
|
+ if (! STRING_ISGRAPHIC (c))
|
+ {
|
+ num_chars = num_print = 0;
|
+ continue;
|
+ }
|
+
|
+ if (num_chars == 0)
|
+ start_point = num_read - 1;
|
+
|
+ if (c < 127)
|
+ {
|
+ print_buf[num_print] = c;
|
+ num_chars ++;
|
+ num_print ++;
|
+ continue;
|
+ }
|
+
|
+ if (c < 0xc0)
|
+ {
|
+ num_chars = num_print = 0;
|
+ continue;
|
+ }
|
+
|
+ /* We *might* have a UTF-8 sequence. Time to start peeking. */
|
+ char utf8[4];
|
+
|
+ utf8[0] = c;
|
+ c = get_unicode_byte (stream, putback_buf, & num_putback, & num_read);
|
+ if (c == EOF)
|
+ break;
|
+ utf8[1] = c;
|
+
|
+ if ((utf8[1] & 0xc0) != 0x80)
|
+ {
|
+ /* Invalid UTF-8. */
|
+ putback_buf[num_putback++] = utf8[1];
|
+ num_chars = num_print = 0;
|
+ continue;
|
+ }
|
+ else if ((utf8[0] & 0x20) == 0)
|
+ {
|
+ /* A valid 2-byte UTF-8 encoding. */
|
+ if (unicode_display == unicode_invalid)
|
+ {
|
+ putback_buf[num_putback++] = utf8[1];
|
+ num_chars = num_print = 0;
|
+ }
|
+ else
|
+ {
|
+ print_buf[num_print ++] = utf8[0];
|
+ print_buf[num_print ++] = utf8[1];
|
+ num_chars ++;
|
+ }
|
+ continue;
|
+ }
|
+
|
+ c = get_unicode_byte (stream, putback_buf, & num_putback, & num_read);
|
+ if (c == EOF)
|
+ break;
|
+ utf8[2] = c;
|
+
|
+ if ((utf8[2] & 0xc0) != 0x80)
|
+ {
|
+ /* Invalid UTF-8. */
|
+ putback_buf[num_putback++] = utf8[2];
|
+ putback_buf[num_putback++] = utf8[1];
|
+ num_chars = num_print = 0;
|
+ continue;
|
+ }
|
+ else if ((utf8[0] & 0x10) == 0)
|
+ {
|
+ /* A valid 3-byte UTF-8 encoding. */
|
+ if (unicode_display == unicode_invalid)
|
+ {
|
+ putback_buf[num_putback++] = utf8[2];
|
+ putback_buf[num_putback++] = utf8[1];
|
+ num_chars = num_print = 0;
|
+ }
|
+ else
|
+ {
|
+ print_buf[num_print ++] = utf8[0];
|
+ print_buf[num_print ++] = utf8[1];
|
+ print_buf[num_print ++] = utf8[2];
|
+ num_chars ++;
|
+ }
|
+ continue;
|
+ }
|
+
|
+ c = get_unicode_byte (stream, putback_buf, & num_putback, & num_read);
|
+ if (c == EOF)
|
+ break;
|
+ utf8[3] = c;
|
+
|
+ if ((utf8[3] & 0xc0) != 0x80)
|
+ {
|
+ /* Invalid UTF-8. */
|
+ putback_buf[num_putback++] = utf8[3];
|
+ putback_buf[num_putback++] = utf8[2];
|
+ putback_buf[num_putback++] = utf8[1];
|
+ num_chars = num_print = 0;
|
+ }
|
+ /* We have a valid 4-byte UTF-8 encoding. */
|
+ else if (unicode_display == unicode_invalid)
|
+ {
|
+ putback_buf[num_putback++] = utf8[3];
|
+ putback_buf[num_putback++] = utf8[1];
|
+ putback_buf[num_putback++] = utf8[2];
|
+ num_chars = num_print = 0;
|
+ }
|
+ else
|
+ {
|
+ print_buf[num_print ++] = utf8[0];
|
+ print_buf[num_print ++] = utf8[1];
|
+ print_buf[num_print ++] = utf8[2];
|
+ print_buf[num_print ++] = utf8[3];
|
+ num_chars ++;
|
+ }
|
+ }
|
+ while (1);
|
+
|
+ if (num_chars >= string_min)
|
+ {
|
+ /* We know that we have string_min valid characters in print_buf,
|
+ and there may be more to come in the stream. Start displaying
|
+ them. */
|
+
|
+ print_filename_and_address (filename, address + start_point);
|
+
|
+ unsigned int i;
|
+ for (i = 0; i < num_print;)
|
+ {
|
+ if (print_buf[i] < 127)
|
+ putchar (print_buf[i++]);
|
+ else
|
+ i += display_utf8_char (print_buf + i);
|
+ }
|
+
|
+ /* OK so now we have to start read unchecked bytes. */
|
+
|
+ /* Find a series of string_min characters. Put them into print_buf. */
|
+ do
|
+ {
|
+ c = get_unicode_byte (stream, putback_buf, & num_putback, & num_read);
|
+ if (c == EOF)
|
+ break;
|
+
|
+ if (! STRING_ISGRAPHIC (c))
|
+ break;
|
+
|
+ if (c < 127)
|
+ {
|
+ putchar (c);
|
+ continue;
|
+ }
|
+
|
+ if (c < 0xc0)
|
+ break;
|
+
|
+ /* We *might* have a UTF-8 sequence. Time to start peeking. */
|
+ unsigned char utf8[4];
|
+
|
+ utf8[0] = c;
|
+ c = get_unicode_byte (stream, putback_buf, & num_putback, & num_read);
|
+ if (c == EOF)
|
+ break;
|
+ utf8[1] = c;
|
+
|
+ if ((utf8[1] & 0xc0) != 0x80)
|
+ {
|
+ /* Invalid UTF-8. */
|
+ putback_buf[num_putback++] = utf8[1];
|
+ break;
|
+ }
|
+ else if ((utf8[0] & 0x20) == 0)
|
+ {
|
+ /* Valid 2-byte UTF-8. */
|
+ if (unicode_display == unicode_invalid)
|
+ {
|
+ putback_buf[num_putback++] = utf8[1];
|
+ break;
|
+ }
|
+ else
|
+ {
|
+ (void) display_utf8_char (utf8);
|
+ continue;
|
+ }
|
+ }
|
+
|
+ c = get_unicode_byte (stream, putback_buf, & num_putback, & num_read);
|
+ if (c == EOF)
|
+ break;
|
+ utf8[2] = c;
|
+
|
+ if ((utf8[2] & 0xc0) != 0x80)
|
+ {
|
+ /* Invalid UTF-8. */
|
+ putback_buf[num_putback++] = utf8[2];
|
+ putback_buf[num_putback++] = utf8[1];
|
+ break;
|
+ }
|
+ else if ((utf8[0] & 0x10) == 0)
|
+ {
|
+ /* Valid 3-byte UTF-8. */
|
+ if (unicode_display == unicode_invalid)
|
+ {
|
+ putback_buf[num_putback++] = utf8[2];
|
+ putback_buf[num_putback++] = utf8[1];
|
+ break;
|
+ }
|
+ else
|
+ {
|
+ (void) display_utf8_char (utf8);
|
+ continue;
|
+ }
|
+ }
|
+
|
+ c = get_unicode_byte (stream, putback_buf, & num_putback, & num_read);
|
+ if (c == EOF)
|
+ break;
|
+ utf8[3] = c;
|
+
|
+ if ((utf8[3] & 0xc0) != 0x80)
|
+ {
|
+ /* Invalid UTF-8. */
|
+ putback_buf[num_putback++] = utf8[3];
|
+ putback_buf[num_putback++] = utf8[2];
|
+ putback_buf[num_putback++] = utf8[1];
|
+ break;
|
+ }
|
+ else if (unicode_display == unicode_invalid)
|
+ {
|
+ putback_buf[num_putback++] = utf8[3];
|
+ putback_buf[num_putback++] = utf8[2];
|
+ putback_buf[num_putback++] = utf8[1];
|
+ break;
|
+ }
|
+ else
|
+ /* A valid 4-byte UTF-8 encoding. */
|
+ (void) display_utf8_char (utf8);
|
+ }
|
+ while (1);
|
+
|
+ if (output_separator)
|
+ fputs (output_separator, stdout);
|
+ else
|
+ putchar ('\n');
|
+ }
|
+
|
+ if (c != EOF)
|
+ /* FIXME: Using tail recursion here is lazy, but it works. */
|
+ print_unicode_stream_body (filename, address + num_read, stream, putback_buf, num_putback, print_buf);
|
+}
|
+
|
+/* Display strings read in from STREAM. Treat any UTF-8 encoded characters
|
+ encountered according to the setting of the unicode_display variable.
|
+ The stream is positioned at ADDRESS and is attached to FILENAME. */
|
+
|
+static void
|
+print_unicode_stream (const char * filename,
|
+ file_ptr address,
|
+ FILE * stream)
|
+{
|
+ /* Paranoia checks... */
|
+ if (filename == NULL
|
+ || stream == NULL
|
+ || unicode_display == unicode_default
|
+ || encoding != 'S'
|
+ || encoding_bytes != 1)
|
+ {
|
+ fprintf (stderr, "ICE: bad arguments to print_unicode_stream\n");
|
+ return;
|
+ }
|
+
|
+ /* Allocate space for string_min 4-byte utf-8 characters. */
|
+ unsigned char * print_buf = xmalloc ((4 * string_min) + 1);
|
+ /* We should never have to put back more than 4 bytes. */
|
+ unsigned char putback_buf[5];
|
+ unsigned int num_putback = 0;
|
+
|
+ print_unicode_stream_body (filename, address, stream, putback_buf, num_putback, print_buf);
|
+ free (print_buf);
|
+}
|
|
/* Find the strings in file FILENAME, read from STREAM.
|
Assume that STREAM is positioned so that the next byte read
|
@@ -566,20 +1236,29 @@ unget_part_char (long c, file_ptr *addre
|
|
static void
|
print_strings (const char *filename, FILE *stream, file_ptr address,
|
- int stop_point, int magiccount, char *magic)
|
+ int magiccount, char *magic)
|
{
|
+ if (unicode_display != unicode_default)
|
+ {
|
+ if (magic != NULL)
|
+ print_unicode_buffer (filename, address,
|
+ (const unsigned char *) magic, magiccount);
|
+
|
+ if (stream != NULL)
|
+ print_unicode_stream (filename, address, stream);
|
+ return;
|
+ }
|
+
|
char *buf = (char *) xmalloc (sizeof (char) * (string_min + 1));
|
|
while (1)
|
{
|
file_ptr start;
|
- int i;
|
+ unsigned int i;
|
long c;
|
|
/* See if the next `string_min' chars are all graphic chars. */
|
tryline:
|
- if (stop_point && address >= stop_point)
|
- break;
|
start = address;
|
for (i = 0; i < string_min; i++)
|
{
|
@@ -601,51 +1280,7 @@ print_strings (const char *filename, FIL
|
|
/* We found a run of `string_min' graphic characters. Print up
|
to the next non-graphic character. */
|
-
|
- if (print_filenames)
|
- printf ("%s: ", filename);
|
- if (print_addresses)
|
- switch (address_radix)
|
- {
|
- case 8:
|
- if (sizeof (start) > sizeof (long))
|
- {
|
-#ifndef __MSVCRT__
|
- printf ("%7llo ", (unsigned long long) start);
|
-#else
|
- printf ("%7I64o ", (unsigned long long) start);
|
-#endif
|
- }
|
- else
|
- printf ("%7lo ", (unsigned long) start);
|
- break;
|
-
|
- case 10:
|
- if (sizeof (start) > sizeof (long))
|
- {
|
-#ifndef __MSVCRT__
|
- printf ("%7llu ", (unsigned long long) start);
|
-#else
|
- printf ("%7I64d ", (unsigned long long) start);
|
-#endif
|
- }
|
- else
|
- printf ("%7ld ", (long) start);
|
- break;
|
-
|
- case 16:
|
- if (sizeof (start) > sizeof (long))
|
- {
|
-#ifndef __MSVCRT__
|
- printf ("%7llx ", (unsigned long long) start);
|
-#else
|
- printf ("%7I64x ", (unsigned long long) start);
|
-#endif
|
- }
|
- else
|
- printf ("%7lx ", (unsigned long) start);
|
- break;
|
- }
|
+ print_filename_and_address (filename, start);
|
|
buf[i] = '\0';
|
fputs (buf, stdout);
|
@@ -697,6 +1332,8 @@ usage (FILE *stream, int status)
|
-T --target=<BFDNAME> Specify the binary file format\n\
|
-e --encoding={s,S,b,l,B,L} Select character size and endianness:\n\
|
s = 7-bit, S = 8-bit, {b,l} = 16-bit, {B,L} = 32-bit\n\
|
+ --unicode={default|show|invalid|hex|escape|highlight}\n\
|
+ -u {d|s|i|x|e|h} Specify how to treat UTF-8 encoded unicode characters\n\
|
-s --output-separator=<string> String used to separate strings in output.\n\
|
@<file> Read options from <file>\n\
|
-h --help Display this information\n\
|
