------- Additional Comments From nickc at redhat dot com 2005-10-11 12:34
-------
Subject: Re: New: c++filt no longer works with stdin
Hi HJ,
> [EMAIL PROTECTED] testsuite]$ cat foo.s
> .type _Z1fv, @function
> [EMAIL PROTECTED] testsuite]$
> /export/build/gnu/binutils-import/build-i686-linux/binutils/cxxfilt < foo.s
> .type
> f()
> function
> [EMAIL PROTECTED] testsuite]$ /usr/bin/c++filt < foo.s
> .type f(), @function
>
However, decoding these definitions on the command line using the old
c++filt does not work properly either:
% cxxfilt .type _Z1fv, @function
.type
_Z1fv,
@function
> Those special handling for `.', `$' and `_' used to be for stdin only.
> I think it makes some sense since they are added to assembly code.
But users can easily look in assembly code, find a mangled name and then
try to pass it to c++filt on the command line, expecting to see the
demangled name. This is why I feel that c++filt should have the same
behaviour regardless of where it obtains the mangled names.
I agree that when it is reading from stdin c++filt should preserve the
whitespace of its input, so that definitely does need fixing.
> The reason for
>
> /* For command line args, also try to demangle type encodings. */
> result = cplus_demangle (mangled_name, flags | DMGL_TYPES);
>
> is that the assembly code may have
>
> .section .eh_frame,"a",@progbits
> .ident "GCC: (GNU) 4.1.0 20051007 (experimental)"
Ok - I also agree that demangling types by default is a bad idea. But I
still believe that it ought to be possible to demangle them, even when
the input comes from stdin.
So please could you consider the attached patch. It does three things:
* Makes type demangling no be enabled by default (for either stdin or
the command line).
* Copies the whitespace read from stdin to stdout, preserving the
formating of the input whilst demangling its contents.
* Updates the documentation to describe why there is a difference
between the demangling of names read on the command line and names read
from the standard input.
Cheers
Nick
binutils/ChangeLog
2005-10-11 Nick Clifton <[EMAIL PROTECTED]>
PR binutils/1437
* cxxfilt.c (flags): Remove DMGL_TYPES;
(long_options): Rename --no-types to --types.
(usage): Likewise.
(demangle_it): Add a comment describing why _ and $ prefixes are
skipped. Use printf rather than puts to emit the demangled output
in order to avoid emitting a new line character.
(main): Have the -t flag enable type demangling.
Emit a newline after every demangled command line argument.
Copy whitespace from stdin to stdout.
* doc/binutils.texi (c++filt): Document the change to the -t
switch.
Document why demangling names on the command line is slightly
different to demangling names read from the standard input.
Index: binutils/cxxfilt.c
===================================================================
RCS file: /cvs/src/src/binutils/cxxfilt.c,v
retrieving revision 1.9
diff -c -3 -p -r1.9 cxxfilt.c
*** binutils/cxxfilt.c 4 Oct 2005 11:03:38 -0000 1.9
--- binutils/cxxfilt.c 11 Oct 2005 12:25:45 -0000
***************
*** 30,36 ****
#include "getopt.h"
#include "safe-ctype.h"
! static int flags = DMGL_PARAMS | DMGL_ANSI | DMGL_VERBOSE | DMGL_TYPES;
static int strip_underscore = TARGET_PREPENDS_UNDERSCORE;
static const struct option long_options[] =
--- 30,36 ----
#include "getopt.h"
#include "safe-ctype.h"
! static int flags = DMGL_PARAMS | DMGL_ANSI | DMGL_VERBOSE;
static int strip_underscore = TARGET_PREPENDS_UNDERSCORE;
static const struct option long_options[] =
*************** static const struct option long_options[
*** 40,47 ****
{"help", no_argument, NULL, 'h'},
{"no-params", no_argument, NULL, 'p'},
{"no-strip-underscores", no_argument, NULL, 'n'},
- {"no-types", no_argument, NULL, 't'},
{"no-verbose", no_argument, NULL, 'i'},
{"version", no_argument, NULL, 'v'},
{NULL, no_argument, NULL, 0}
};
--- 40,47 ----
{"help", no_argument, NULL, 'h'},
{"no-params", no_argument, NULL, 'p'},
{"no-strip-underscores", no_argument, NULL, 'n'},
{"no-verbose", no_argument, NULL, 'i'},
+ {"types", no_argument, NULL, 't'},
{"version", no_argument, NULL, 'v'},
{NULL, no_argument, NULL, 0}
};
*************** demangle_it (char *mangled_name)
*** 52,57 ****
--- 52,60 ----
char *result;
unsigned int skip_first = 0;
+ /* _ and $ are sometimes found at the start of function names
+ in assembler sources in order to distinguish them from other
+ names (eg register names). So skip them here. */
if (mangled_name[0] == '.' || mangled_name[0] == '$')
++skip_first;
if (strip_underscore && mangled_name[skip_first] == '_')
*************** demangle_it (char *mangled_name)
*** 60,71 ****
result = cplus_demangle (mangled_name + skip_first, flags);
if (result == NULL)
! puts (mangled_name);
else
{
if (mangled_name[0] == '.')
putchar ('.');
! puts (result);
free (result);
}
}
--- 63,74 ----
result = cplus_demangle (mangled_name + skip_first, flags);
if (result == NULL)
! printf (mangled_name);
else
{
if (mangled_name[0] == '.')
putchar ('.');
! printf (result);
free (result);
}
}
*************** Options are:\n\
*** 99,106 ****
TARGET_PREPENDS_UNDERSCORE ? "" : " (default)");
fprintf (stream, "\
[-p|--no-params] Do not display function arguments\n\
- [-t|--no-types] Do not try to demangle type encodings\n\
[-i|--no-verbose] Do not show implementation details (if any)\n\
[-s|--format ");
print_demangler_list (stream);
fprintf (stream, "]\n");
--- 102,109 ----
TARGET_PREPENDS_UNDERSCORE ? "" : " (default)");
fprintf (stream, "\
[-p|--no-params] Do not display function arguments\n\
[-i|--no-verbose] Do not show implementation details (if any)\n\
+ [-t|--types] Also attempt to demangle type encodings\n\
[-s|--format ");
print_demangler_list (stream);
fprintf (stream, "]\n");
*************** main (int argc, char **argv)
*** 191,197 ****
flags &= ~ DMGL_PARAMS;
break;
case 't':
! flags &= ~ DMGL_TYPES;
break;
case 'i':
flags &= ~ DMGL_VERBOSE;
--- 194,200 ----
flags &= ~ DMGL_PARAMS;
break;
case 't':
! flags |= DMGL_TYPES;
break;
case 'i':
flags &= ~ DMGL_VERBOSE;
*************** main (int argc, char **argv)
*** 218,224 ****
if (optind < argc)
{
for ( ; optind < argc; optind++)
! demangle_it (argv[optind]);
return 0;
}
--- 221,230 ----
if (optind < argc)
{
for ( ; optind < argc; optind++)
! {
! demangle_it (argv[optind]);
! putchar ('\n');
! }
return 0;
}
*************** main (int argc, char **argv)
*** 264,274 ****
{
mbuffer[i] = 0;
demangle_it (mbuffer);
- fflush (stdout);
}
if (c == EOF)
break;
}
return 0;
}
--- 270,285 ----
{
mbuffer[i] = 0;
demangle_it (mbuffer);
}
+
if (c == EOF)
break;
+
+ /* Echo the whitespace characters so that the output looks
+ like the input, only with the mangled names demangled. */
+ putchar (c);
}
+ fflush (stdout);
return 0;
}
Index: binutils/doc/binutils.texi
===================================================================
RCS file: /cvs/src/src/binutils/doc/binutils.texi,v
retrieving revision 1.82
diff -c -3 -p -r1.82 binutils.texi
*** binutils/doc/binutils.texi 11 Oct 2005 04:49:16 -0000 1.82
--- binutils/doc/binutils.texi 11 Oct 2005 12:25:46 -0000
*************** the Info entries for @file{binutils}.
*** 2399,2405 ****
c++filt [EMAIL PROTECTED]|@option{--strip-underscores}]
[EMAIL PROTECTED]|@option{--no-strip-underscores}]
[EMAIL PROTECTED]|@option{--no-params}]
! [EMAIL PROTECTED]|@option{--no-types}]
[EMAIL PROTECTED]|@option{--no-verbose}]
[EMAIL PROTECTED] @var{format}|@[EMAIL PROTECTED]
[EMAIL PROTECTED] [EMAIL PROTECTED] [EMAIL PROTECTED]@dots{}]
--- 2399,2405 ----
c++filt [EMAIL PROTECTED]|@option{--strip-underscores}]
[EMAIL PROTECTED]|@option{--no-strip-underscores}]
[EMAIL PROTECTED]|@option{--no-params}]
! [EMAIL PROTECTED]|@option{--types}]
[EMAIL PROTECTED]|@option{--no-verbose}]
[EMAIL PROTECTED] @var{format}|@[EMAIL PROTECTED]
[EMAIL PROTECTED] [EMAIL PROTECTED] [EMAIL PROTECTED]@dots{}]
*************** c++filt [EMAIL PROTECTED]|@option{--strip-und
*** 2409,2439 ****
@c man begin DESCRIPTION cxxfilt
@kindex cxxfilt
! The C++ and Java languages provides function overloading, which means
! that you can write many functions with the same name (providing each
! takes parameters of different types). All C++ and Java function names
! are encoded into a low-level assembly label (this process is known as
! @dfn{mangling}). The @command{c++filt}
! @footnote{MS-DOS does not allow @kbd{+} characters in file names, so on
MS-DOS this program is named @command{CXXFILT}.}
program does the inverse mapping: it decodes (@dfn{demangles}) low-level
! names into user-level names so that the linker can keep these overloaded
! functions from clashing.
Every alphanumeric word (consisting of letters, digits, underscores,
dollars, or periods) seen in the input is a potential mangled name.
If the name decodes into a C++ name, the C++ name replaces the
! low-level name in the output.
! You can use @command{c++filt} to decipher individual symbols:
@example
c++filt @var{symbol}
@end example
If no @var{symbol} arguments are given, @command{c++filt} reads symbol
! names from the standard input and writes the demangled names to the
! standard output. All results are printed on the standard output.
@c man end
--- 2409,2475 ----
@c man begin DESCRIPTION cxxfilt
@kindex cxxfilt
! The C++ and Java languages provide function overloading, which means
! that you can write many functions with the same name, providing that
! each function takes parameters of different types. In order to be
! able to distinguish these similarly named functions C++ and Java
! encode them into a low-level assembler name which uniquely identifies
! each different version. This process is known as @dfn{mangling}. The
! @command{c++filt}
! @footnote{MS-DOS does not allow @kbd{+} characters in file names, so on
MS-DOS this program is named @command{CXXFILT}.}
program does the inverse mapping: it decodes (@dfn{demangles}) low-level
! names into user-level names so that they can be read.
Every alphanumeric word (consisting of letters, digits, underscores,
dollars, or periods) seen in the input is a potential mangled name.
If the name decodes into a C++ name, the C++ name replaces the
! low-level name in the output, otherwise the original word is output.
! In this way you can pass an entire assembler source file, containing
! mangled names, through @command{c++filt} and see the same source file
! containing demangled names.
! You can also use @command{c++filt} to decipher individual symbols by
! passing them on the command line:
@example
c++filt @var{symbol}
@end example
If no @var{symbol} arguments are given, @command{c++filt} reads symbol
! names from the standard input instead. All the results are printed on
! the standard output. The difference between reading names from the
! command line versus reading names from the standard input is that
! command line arguments are expected to be just mangled names and no
! checking is performed to seperate them from surrounding text. Thus
! for example:
!
! @smallexample
! c++filt -n _Z1fv
! @end smallexample
!
! will work and demangle the name to ``f()'' whereas:
!
! @smallexample
! c++filt -n _Z1fv,
! @end smallexample
!
! will not work. (Note the extra comma at the end of the mangled
! name which makes it invalid). This command however will work:
!
! @smallexample
! echo _Z1fv, | c++filt -n
! @end smallexample
!
! and will display ``f(),'' ie the demangled name followed by a
! trailing comma. This behaviour is because when the names are read
! from the standard input it is expected that they might be part of an
! assembler source file where there might be extra, extraneous
! characters trailing after a mangled name. eg:
!
! @smallexample
! .type _Z1fv, @@function
! @end smallexample
@c man end
*************** When demangling the name of a function,
*** 2462,2470 ****
the function's parameters.
@item -t
! @itemx --no-types
! Do not attempt to demangle types. This is enabled by default, but it
! may not be desired if you are interested in mangled function names.
@item -i
@itemx --no-verbose
--- 2498,2509 ----
the function's parameters.
@item -t
! @itemx --types
! Attempt to demangle types as well as function names. This is disabled
! by default since mangled types are normally only used internally in
! the compiler, and they can be confused with non-mangled names. eg
! a function called ``a'' treated as a mangled type name would be
! demangled to ``signed char''.
@item -i
@itemx --no-verbose
--
http://sourceware.org/bugzilla/show_bug.cgi?id=1437
------- You are receiving this mail because: -------
You are on the CC list for the bug, or are watching someone who is.
_______________________________________________
bug-binutils mailing list
bug-binutils@gnu.org
http://lists.gnu.org/mailman/listinfo/bug-binutils
