OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

cp-demangle.c (d_encoding): When DMGL_PARAMS is not set... 

* cp-demangle.c (d_encoding): When DMGL_PARAMS is not set, strip
	CV-qualifiers from D_COMP_LOCAL_NAME right subtree.
	* cplus-dem.c (demangle_arm_hp_template): Set DMGL_PARAMS when
	demangling template parameters.
	* testsuite/test-demangle.c (fail): New static function.
	(main): Support new options in input file: --no-params,
	--is-v3-ctor, and --is-v3-dtor.
	* testsuite/demangle-expected: Add --no-params to most tests, and
	add the correct result when parameters are not demangled.  Add
	some simple tests for V3 constructor/destructor recognition.

From-SVN: r75336
This commit is contained in:
Ian Lance Taylor 2004-01-02 20:33:55 +00:00 committed by Ian Lance Taylor
parent 3864b6fe3d
commit e4796f1c88
5 changed files with 2071 additions and 1132 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
libiberty/ChangeLog
View File

@ -1,3 +1,16 @@
2004-01-02 Ian Lance Taylor <ian@wasabisystems.com>
* cp-demangle.c (d_encoding): When DMGL_PARAMS is not set, strip
CV-qualifiers from D_COMP_LOCAL_NAME right subtree.
* cplus-dem.c (demangle_arm_hp_template): Set DMGL_PARAMS when
demangling template parameters.
* testsuite/test-demangle.c (fail): New static function.
(main): Support new options in input file: --no-params,
--is-v3-ctor, and --is-v3-dtor.
* testsuite/demangle-expected: Add --no-params to most tests, and
add the correct result when parameters are not demangled. Add
some simple tests for V3 constructor/destructor recognition.
2003-12-25 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
* cp-demangle.c (is_ctor_or_dtor): Fix error in last change.

19
libiberty/cp-demangle.c
View File

@ -1,5 +1,5 @@
/* Demangler for g++ V3 ABI.
Copyright (C) 2003 Free Software Foundation, Inc.
Copyright (C) 2003, 2004 Free Software Foundation, Inc.
Written by Ian Lance Taylor <ian@wasabisystems.com>.
This file is part of the libiberty library, which is part of GCC.
@ -1109,6 +1109,23 @@ d_encoding (di, top_level)
|| dc->type == D_COMP_VOLATILE_THIS
|| dc->type == D_COMP_CONST_THIS)
dc = d_left (dc);
/* If the top level is a D_COMP_LOCAL_NAME, then there may
be CV-qualifiers on its right argument which really apply
here; this happens when parsing a class which is local to
a function. */
if (dc->type == D_COMP_LOCAL_NAME)
{
struct d_comp *dcr;
dcr = d_right (dc);
while (dcr->type == D_COMP_RESTRICT_THIS
|| dcr->type == D_COMP_VOLATILE_THIS
|| dcr->type == D_COMP_CONST_THIS)
dcr = d_left (dcr);
dc->u.s_binary.right = dcr;
}
return dc;
}

23
libiberty/cplus-dem.c
View File

@ -1,6 +1,6 @@
/* Demangler for GNU C++
Copyright 1989, 1991, 1994, 1995, 1996, 1997, 1998, 1999,
2000, 2001 Free Software Foundation, Inc.
2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
Written by James Clark (jjc@jclark.uucp)
Rewritten by Fred Fish (fnf@cygnus.com) for ARM and Lucid demangling
Modified by Satish Pai (pai@apollo.hp.com) for HP demangling
@ -2318,6 +2318,7 @@ demangle_arm_hp_template (work, mangled, n, declp)
if (HP_DEMANGLING && ((*mangled)[n] == 'X'))
{
char *start_spec_args = NULL;
int hold_options;
/* First check for and omit template specialization pseudo-arguments,
such as in "Spec<#1,#1.*>" */
@ -2330,6 +2331,12 @@ demangle_arm_hp_template (work, mangled, n, declp)
string_init (&arg);
if (work->temp_start == -1) /* non-recursive call */
work->temp_start = declp->p - declp->b;
/* We want to unconditionally demangle parameter types in
template parameters. */
hold_options = work->options;
work->options |= DMGL_PARAMS;
string_append (declp, "<");
while (1)
{
@ -2376,17 +2383,25 @@ demangle_arm_hp_template (work, mangled, n, declp)
string_delete (&arg);
if (**mangled == '_')
(*mangled)++;
work->options = hold_options;
return;
}
/* ARM template? (Also handles HP cfront extensions) */
else if (arm_pt (work, *mangled, n, &p, &args))
{
int hold_options;
string type_str;
string_init (&arg);
string_appendn (declp, *mangled, p - *mangled);
if (work->temp_start == -1) /* non-recursive call */
work->temp_start = declp->p - declp->b;
/* We want to unconditionally demangle parameter types in
template parameters. */
hold_options = work->options;
work->options |= DMGL_PARAMS;
string_append (declp, "<");
/* should do error checking here */
while (args < e) {
@ -2430,7 +2445,10 @@ demangle_arm_hp_template (work, mangled, n, declp)
/* Fail if we didn't make any progress: prevent infinite loop. */
if (args == old_args)
return;
{
work->options = hold_options;
return;
}
}
}
string_appends (declp, &arg);
@ -2441,6 +2459,7 @@ demangle_arm_hp_template (work, mangled, n, declp)
if (args >= e)
--declp->p; /* remove extra comma */
string_append (declp, ">");
work->options = hold_options;
}
else if (n>10 && strncmp (*mangled, "_GLOBAL_", 8) == 0
&& (*mangled)[9] == 'N'

2980
libiberty/testsuite/demangle-expected
View File

File diff suppressed because it is too large Load Diff

168
libiberty/testsuite/test-demangle.c
View File

@ -1,5 +1,5 @@
/* Demangler test program,
Copyright (C) 2002 Free Software Foundation, Inc.
Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
Written by Zack Weinberg <zack@codesourcery.com
This file is part of GNU libiberty.
@ -80,16 +80,39 @@ getline(buf)
buf->alloced = alloc;
}
/* The tester operates on a data file consisting of triples of lines:
format switch
static void
fail (lineno, opts, in, out, exp)
int lineno;
const char *opts;
const char *in;
const char *out;
const char *exp;
{
printf ("\
FAIL at line %d, options %s:\n\
in: %s\n\
out: %s\n\
exp: %s\n",
lineno, opts, in, out != NULL ? out : "(null)", exp);
}
/* The tester operates on a data file consisting of groups of lines:
options
input to be demangled
expected output
The format switch is expected to be either the empty string, a
line of the form --format=<name>, or just <name> by itself. */
Supported options:
--format=<name> Sets the demangling style.
--no-params There are two lines of expected output; the first
is with DMGL_PARAMS, the second is without it.
--is-v3-ctor Calls is_gnu_v3_mangled_ctor on input; expected
output is an integer representing ctor_kind.
--is-v3-dtor Likewise, but for dtors.
#define FORMATS "--format="
#define FORMATL (sizeof FORMATS - 1)
For compatibility, just in case it matters, the options line may be
empty, to mean --format=auto. If it doesn't start with --, then it
may contain only a format name.
*/
int
main(argc, argv)
@ -97,10 +120,12 @@ main(argc, argv)
char **argv;
{
enum demangling_styles style;
int no_params;
int is_v3_ctor;
int is_v3_dtor;
struct line format;
struct line input;
struct line expect;
char *fstyle;
char *result;
int failures = 0;
int tests = 0;
@ -126,20 +151,98 @@ main(argc, argv)
tests++;
fstyle = format.data;
if (!strncmp (fstyle, FORMATS, FORMATL))
fstyle += FORMATL;
if (fstyle[0] == '\0')
no_params = 0;
is_v3_ctor = 0;
is_v3_dtor = 0;
if (format.data[0] == '\0')
style = auto_demangling;
else
style = cplus_demangle_name_to_style (fstyle);
if (style == unknown_demangling)
else if (format.data[0] != '-')
{
printf ("FAIL at line %d: unknown demangling style %s\n",
lineno, fstyle);
failures++;
style = cplus_demangle_name_to_style (format.data);
if (style == unknown_demangling)
{
printf ("FAIL at line %d: unknown demangling style %s\n",
lineno, format.data);
failures++;
continue;
}
}
else
{
char *p;
char *opt;
p = format.data;
while (*p != '\0')
{
char c;
opt = p;
p += strcspn (p, " \t=");
c = *p;
*p = '\0';
if (strcmp (opt, "--format") == 0 && c == '=')
{
char *fstyle;
*p = c;
++p;
fstyle = p;
p += strcspn (p, " \t");
c = *p;
*p = '\0';
style = cplus_demangle_name_to_style (fstyle);
if (style == unknown_demangling)
{
printf ("FAIL at line %d: unknown demangling style %s\n",
lineno, fstyle);
failures++;
continue;
}
}
else if (strcmp (opt, "--no-params") == 0)
no_params = 1;
else if (strcmp (opt, "--is-v3-ctor") == 0)
is_v3_ctor = 1;
else if (strcmp (opt, "--is-v3-dtor") == 0)
is_v3_dtor = 1;
else
{
printf ("FAIL at line %d: unrecognized option %s\n",
lineno, opt);
failures++;
continue;
}
*p = c;
p += strspn (p, " \t");
}
}
if (is_v3_ctor || is_v3_dtor)
{
char buf[20];
if (is_v3_ctor)
{
enum gnu_v3_ctor_kinds kc;
kc = is_gnu_v3_mangled_ctor (input.data);
sprintf (buf, "%d", (int) kc);
}
else
{
enum gnu_v3_dtor_kinds kd;
kd = is_gnu_v3_mangled_dtor (input.data);
sprintf (buf, "%d", (int) kd);
}
if (strcmp (buf, expect.data) != 0)
{
fail (lineno, format.data, input.data, buf, expect.data);
failures++;
}
continue;
}
@ -152,18 +255,25 @@ main(argc, argv)
? strcmp (result, expect.data)
: strcmp (input.data, expect.data))
{
printf ("\
FAIL at line %d, style %s:\n\
in: %s\n\
out: %s\n\
exp: %s\n",
lineno, fstyle,
input.data,
result,
expect.data);
fail (lineno, format.data, input.data, result, expect.data);
failures++;
}
free (result);
if (no_params)
{
getline (&expect);
result = cplus_demangle (input.data, DMGL_ANSI|DMGL_TYPES);
if (result
? strcmp (result, expect.data)
: strcmp (input.data, expect.data))
{
fail (lineno, format.data, input.data, result, expect.data);
failures++;
}
free (result);
}
}
free (format.data);