OpenE2K/binutils-gdb
12
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

merge from gcc

Browse Source
This commit is contained in:
DJ Delorie 2002-09-12 01:11:29 +00:00
parent e64f66d171
commit a54ba43fe9
7 changed files with 214 additions and 396 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
libiberty/ChangeLog
View File

@ -1,3 +1,16 @@
2002-09-10 Mike Stump <mrs@apple.com>
* splay-tree.c (splay_tree_successor): Fix comments.
2002-09-11 Zack Weinberg <zack@codesourcery.com>
* cplus-dem.c: Code under #ifdef MAIN moved to gcc/cp/cxxfilt.c.
* testsuite/Makefile.in: Adjust for test-demangle.
* testsuite/regress-demangle: Deleted.
* testsuite/test-demangle.c: New file.
* testsuite/demangle-expected: Change \$ to $ throughout, now that
this file is not being read by a shell script.
2002-09-05 Roger Sayle <roger@eyesopen.com> 2002-09-05 Roger Sayle <roger@eyesopen.com>
* regex.c: Only use "#pragma alloca" on AIX when not using gcc. * regex.c: Only use "#pragma alloca" on AIX when not using gcc.

334
libiberty/cplus-dem.c
View File

@ -4878,337 +4878,3 @@ string_append_template_idx (s, idx)
sprintf(buf, "T%d", idx); sprintf(buf, "T%d", idx);
string_append (s, buf); string_append (s, buf);
} }
/* To generate a standalone demangler program for testing purposes,
just compile and link this file with -DMAIN and libiberty.a. When
run, it demangles each command line arg, or each stdin string, and
prints the result on stdout. */
#ifdef MAIN
#include "getopt.h"
static const char *program_name;
static const char *program_version = VERSION;
static int flags = DMGL_PARAMS | DMGL_ANSI | DMGL_VERBOSE;
static void demangle_it PARAMS ((char *));
static void usage PARAMS ((FILE *, int)) ATTRIBUTE_NORETURN;
static void fatal PARAMS ((const char *)) ATTRIBUTE_NORETURN;
static void print_demangler_list PARAMS ((FILE *));
static void
demangle_it (mangled_name)
char *mangled_name;
{
char *result;
/* For command line args, also try to demangle type encodings. */
result = cplus_demangle (mangled_name, flags | DMGL_TYPES);
if (result == NULL)
{
printf ("%s\n", mangled_name);
}
else
{
printf ("%s\n", result);
free (result);
}
}
static void
print_demangler_list (stream)
FILE *stream;
{
const struct demangler_engine *demangler;
fprintf (stream, "{%s", libiberty_demanglers->demangling_style_name);
for (demangler = libiberty_demanglers + 1;
demangler->demangling_style != unknown_demangling;
++demangler)
fprintf (stream, ",%s", demangler->demangling_style_name);
fprintf (stream, "}");
}
static void
usage (stream, status)
FILE *stream;
int status;
{
fprintf (stream, "\
Usage: %s [-_] [-n] [--strip-underscores] [--no-strip-underscores] \n",
program_name);
fprintf (stream, "\
[-s ");
print_demangler_list (stream);
fprintf (stream, "]\n");
fprintf (stream, "\
[--format ");
print_demangler_list (stream);
fprintf (stream, "]\n");
fprintf (stream, "\
[--help] [--version] [arg...]\n");
exit (status);
}
#define MBUF_SIZE 32767
char mbuffer[MBUF_SIZE];
/* Defined in the automatically-generated underscore.c. */
extern int prepends_underscore;
int strip_underscore = 0;
static const struct option long_options[] = {
{"strip-underscores", no_argument, 0, '_'},
{"format", required_argument, 0, 's'},
{"help", no_argument, 0, 'h'},
{"no-strip-underscores", no_argument, 0, 'n'},
{"version", no_argument, 0, 'v'},
{0, no_argument, 0, 0}
};
/* More 'friendly' abort that prints the line and file.
config.h can #define abort fancy_abort if you like that sort of thing. */
void
fancy_abort ()
{
fatal ("Internal gcc abort.");
}
static const char *
standard_symbol_characters PARAMS ((void));
static const char *
hp_symbol_characters PARAMS ((void));
static const char *
gnu_v3_symbol_characters PARAMS ((void));
/* Return the string of non-alnum characters that may occur
as a valid symbol component, in the standard assembler symbol
syntax. */
static const char *
standard_symbol_characters ()
{
return "_$.";
}
/* Return the string of non-alnum characters that may occur
as a valid symbol name component in an HP object file.
Note that, since HP's compiler generates object code straight from
C++ source, without going through an assembler, its mangled
identifiers can use all sorts of characters that no assembler would
tolerate, so the alphabet this function creates is a little odd.
Here are some sample mangled identifiers offered by HP:
typeid*__XT24AddressIndExpClassMember_
[Vftptr]key:__dt__32OrdinaryCompareIndExpClassMemberFv
__ct__Q2_9Elf64_Dyn18{unnamed.union.#1}Fv
This still seems really weird to me, since nowhere else in this
file is there anything to recognize curly brackets, parens, etc.
I've talked with Srikanth <srikanth@cup.hp.com>, and he assures me
this is right, but I still strongly suspect that there's a
misunderstanding here.
If we decide it's better for c++filt to use HP's assembler syntax
to scrape identifiers out of its input, here's the definition of
the symbol name syntax from the HP assembler manual:
Symbols are composed of uppercase and lowercase letters, decimal
digits, dollar symbol, period (.), ampersand (&), pound sign(#) and
underscore (_). A symbol can begin with a letter, digit underscore or
dollar sign. If a symbol begins with a digit, it must contain a
non-digit character.
So have fun. */
static const char *
hp_symbol_characters ()
{
return "_$.<>#,*&[]:(){}";
}
/* Return the string of non-alnum characters that may occur
as a valid symbol component in the GNU C++ V3 ABI mangling
scheme. */
static const char *
gnu_v3_symbol_characters ()
{
return "_$.";
}
extern int main PARAMS ((int, char **));
int
main (argc, argv)
int argc;
char **argv;
{
char *result;
int c;
const char *valid_symbols;
enum demangling_styles style = auto_demangling;
program_name = argv[0];
strip_underscore = prepends_underscore;
while ((c = getopt_long (argc, argv, "_ns:", long_options, (int *) 0)) != EOF)
{
switch (c)
{
case '?':
usage (stderr, 1);
break;
case 'h':
usage (stdout, 0);
case 'n':
strip_underscore = 0;
break;
case 'v':
printf ("GNU %s (C++ demangler), version %s\n", program_name, program_version);
return (0);
case '_':
strip_underscore = 1;
break;
case 's':
{
style = cplus_demangle_name_to_style (optarg);
if (style == unknown_demangling)
{
fprintf (stderr, "%s: unknown demangling style `%s'\n",
program_name, optarg);
return (1);
}
else
cplus_demangle_set_style (style);
}
break;
}
}
if (optind < argc)
{
for ( ; optind < argc; optind++)
{
demangle_it (argv[optind]);
}
}
else
{
switch (current_demangling_style)
{
case gnu_demangling:
case lucid_demangling:
case arm_demangling:
case java_demangling:
case edg_demangling:
case gnat_demangling:
case auto_demangling:
valid_symbols = standard_symbol_characters ();
break;
case hp_demangling:
valid_symbols = hp_symbol_characters ();
break;
case gnu_v3_demangling:
valid_symbols = gnu_v3_symbol_characters ();
break;
default:
/* Folks should explicitly indicate the appropriate alphabet for
each demangling. Providing a default would allow the
question to go unconsidered. */
abort ();
}
for (;;)
{
int i = 0;
c = getchar ();
/* Try to read a label. */
while (c != EOF && (ISALNUM (c) || strchr (valid_symbols, c)))
{
if (i >= MBUF_SIZE-1)
break;
mbuffer[i++] = c;
c = getchar ();
}
if (i > 0)
{
int skip_first = 0;
if (mbuffer[0] == '.' || mbuffer[0] == '$')
++skip_first;
if (strip_underscore && mbuffer[skip_first] == '_')
++skip_first;
if (skip_first > i)
skip_first = i;
mbuffer[i] = 0;
flags |= (int) style;
result = cplus_demangle (mbuffer + skip_first, flags);
if (result)
{
if (mbuffer[0] == '.')
putc ('.', stdout);
fputs (result, stdout);
free (result);
}
else
fputs (mbuffer, stdout);
fflush (stdout);
}
if (c == EOF)
break;
putchar (c);
fflush (stdout);
}
}
return (0);
}
static void
fatal (str)
const char *str;
{
fprintf (stderr, "%s: %s\n", program_name, str);
exit (1);
}
PTR
xmalloc (size)
size_t size;
{
register PTR value = (PTR) malloc (size);
if (value == 0)
fatal ("virtual memory exhausted");
return value;
}
PTR
xrealloc (ptr, size)
PTR ptr;
size_t size;
{
register PTR value = (PTR) realloc (ptr, size);
if (value == 0)
fatal ("virtual memory exhausted");
return value;
}
#endif /* main */

4
libiberty/splay-tree.c
View File

@ -482,7 +482,7 @@ splay_tree_predecessor (sp, key)
} }
/* Return the immediate successor KEY, or NULL if there is no /* Return the immediate successor KEY, or NULL if there is no
predecessor. KEY need not be present in the tree. */ successor. KEY need not be present in the tree. */
splay_tree_node splay_tree_node
splay_tree_successor (sp, key) splay_tree_successor (sp, key)
@ -492,7 +492,7 @@ splay_tree_successor (sp, key)
int comparison; int comparison;
splay_tree_node node; splay_tree_node node;
/* If the tree is empty, there is certainly no predecessor. */ /* If the tree is empty, there is certainly no successor. */
if (!sp->root) if (!sp->root)
return NULL; return NULL;

20
libiberty/testsuite/Makefile.in
View File

@ -1,6 +1,6 @@
# #
# Makefile # Makefile
# Copyright (C) 1999 # Copyright (C) 1999, 2002
# Free Software Foundation # Free Software Foundation
# #
# This file is part of the libiberty library. # This file is part of the libiberty library.
@ -45,31 +45,25 @@ all:
check: @CHECK@ check: @CHECK@
# Run some tests of the demangler. # Run some tests of the demangler.
check-cplus-dem: test-filter $(srcdir)/demangle-expected check-cplus-dem: test-demangle $(srcdir)/demangle-expected
$(SHELL) $(srcdir)/regress-demangle $(srcdir)/demangle-expected ./test-demangle < $(srcdir)/demangle-expected
# Note that we just hard-code prepends_underscore to 0. This doesn't
# matter since any particular test can override the default if need
# be.
TEST_COMPILE = $(CC) @DEFS@ $(LIBCFLAGS) -I.. -I$(INCDIR) $(HDEFINES) TEST_COMPILE = $(CC) @DEFS@ $(LIBCFLAGS) -I.. -I$(INCDIR) $(HDEFINES)
test-filter: $(srcdir)/../cplus-dem.c test-demangle: $(srcdir)/test-demangle.c
echo 'int prepends_underscore = 0;' > test-us.c $(TEST_COMPILE) -o test-demangle \
$(TEST_COMPILE) -o test-filter -DMAIN -DVERSION='"none"' @DEFS@ \ $(srcdir)/test-demangle.c ../libiberty.a
$(srcdir)/../cplus-dem.c test-us.c -L.. -liberty
# Standard (either GNU or Cygnus) rules we don't use. # Standard (either GNU or Cygnus) rules we don't use.
info install-info clean-info dvi install etags tags installcheck: info install-info clean-info dvi install etags tags installcheck:
# The standard clean rules. # The standard clean rules.
mostlyclean: mostlyclean:
rm -f test-us.c test-filter rm -f test-demangle
clean: mostlyclean clean: mostlyclean
distclean: clean distclean: clean
rm -f Makefile rm -f Makefile
maintainer-clean realclean: distclean maintainer-clean realclean: distclean
Makefile: $(srcdir)/Makefile.in ../config.status Makefile: $(srcdir)/Makefile.in ../config.status
CONFIG_FILES=testsuite/Makefile CONFIG_HEADERS= \ CONFIG_FILES=testsuite/Makefile CONFIG_HEADERS= \
cd .. && $(SHELL) ./config.status cd .. && $(SHELL) ./config.status

34
libiberty/testsuite/demangle-expected
View File

@ -127,31 +127,31 @@ VOrder__9ivTSolverUiRP12ivInteractorT2
ivTSolver::VOrder(unsigned int, ivInteractor *&, ivInteractor *&) ivTSolver::VOrder(unsigned int, ivInteractor *&, ivInteractor *&)
# #
--format=gnu --format=gnu
_10PageButton\$__both _10PageButton$__both
PageButton::__both PageButton::__both
# #
--format=gnu --format=gnu
_3RNG\$singleMantissa _3RNG$singleMantissa
RNG::singleMantissa RNG::singleMantissa
# #
--format=gnu --format=gnu
_5IComp\$_release _5IComp$_release
IComp::_release IComp::_release
# #
--format=gnu --format=gnu
_\$_10BitmapComp _$_10BitmapComp
BitmapComp::~BitmapComp(void) BitmapComp::~BitmapComp(void)
# #
--format=gnu --format=gnu
_\$_9__io_defs _$_9__io_defs
__io_defs::~__io_defs(void) __io_defs::~__io_defs(void)
# #
--format=gnu --format=gnu
_\$_Q23foo3bar _$_Q23foo3bar
foo::bar::~bar(void) foo::bar::~bar(void)
# #
--format=gnu --format=gnu
_\$_Q33foo3bar4bell _$_Q33foo3bar4bell
foo::bar::bell::~bell(void) foo::bar::bell::~bell(void)
# #
--format=gnu --format=gnu
@ -435,11 +435,11 @@ _vt.foo.bar
foo::bar virtual table foo::bar virtual table
# #
--format=gnu --format=gnu
_vt\$foo _vt$foo
foo virtual table foo virtual table
# #
--format=gnu --format=gnu
_vt\$foo\$bar _vt$foo$bar
foo::bar virtual table foo::bar virtual table
# #
--format=gnu --format=gnu
@ -647,11 +647,11 @@ zero__8osMemoryPvUi
osMemory::zero(void *, unsigned int) osMemory::zero(void *, unsigned int)
# #
--format=gnu --format=gnu
_2T4\$N _2T4$N
T4::N T4::N
# #
--format=gnu --format=gnu
_Q22T42t1\$N _Q22T42t1$N
T4::t1::N T4::t1::N
# #
--format=gnu --format=gnu
@ -727,11 +727,11 @@ __t6vector1Zii
vector<int>::vector(int) vector<int>::vector(int)
# #
--format=gnu --format=gnu
_\$_t6vector1Zdi _$_t6vector1Zdi
vector<double>::~vector(int) vector<double>::~vector(int)
# #
--format=gnu --format=gnu
_\$_t6vector1Zii _$_t6vector1Zii
vector<int>::~vector(int) vector<int>::~vector(int)
# #
--format=gnu --format=gnu
@ -827,11 +827,11 @@ next__Ct4List1Z10VHDLEntityRQ2t4List1Z10VHDLEntity3Pix
List<VHDLEntity>::next(List<VHDLEntity>::Pix &) const List<VHDLEntity>::next(List<VHDLEntity>::Pix &) const
# #
--format=gnu --format=gnu
_GLOBAL_\$D\$set _GLOBAL_$D$set
global destructors keyed to set global destructors keyed to set
# #
--format=gnu --format=gnu
_GLOBAL_\$I\$set _GLOBAL_$I$set
global constructors keyed to set global constructors keyed to set
# #
--format=gnu --format=gnu
@ -875,7 +875,7 @@ __t8BDDHookV1ZPcRCPc
BDDHookV<char *>::BDDHookV(char *const &) BDDHookV<char *>::BDDHookV(char *const &)
# #
--format=gnu --format=gnu
_vt\$t8BDDHookV1ZPc _vt$t8BDDHookV1ZPc
BDDHookV<char *> virtual table BDDHookV<char *> virtual table
# #
--format=gnu --format=gnu
@ -2564,7 +2564,7 @@ _27_GLOBAL_.N.__12burst_app_ct.app_instance
{anonymous}::app_instance {anonymous}::app_instance
# #
--format=gnu --format=gnu
_26_GLOBAL_\$N\$_tmp_n.iilg4Gya\$app_instance _26_GLOBAL_$N$_tmp_n.iilg4Gya$app_instance
{anonymous}::app_instance {anonymous}::app_instance
# #
--format=java --format=java

30
libiberty/testsuite/regress-demangle
View File

@ -1,30 +0,0 @@
#! /bin/sh
# Run a regression test for the demangler.
# Usage: regress-demangle TEST-FILE
failures=0
count=0
sed -e '/^#/ d' "$1" | (
while read type; do
read mangled
read demangled
x="`./test-filter $type $mangled`"
count=`expr $count + 1`
if test "x$x" != "x$demangled"; then
failures=`expr $failures + 1`
echo "FAIL: $type $mangled"
echo " result: $x"
echo " expected: $demangled"
fi
done
if test $failures -eq 0; then
echo "All $count tests passed"
else
echo "$failures of $count tests failed"
fi
test $failures -eq 0
)

175
libiberty/testsuite/test-demangle.c Normal file
View File

@ -0,0 +1,175 @@
/* Demangler test program,
Copyright (C) 2002 Free Software Foundation, Inc.
Written by Zack Weinberg <zack@codesourcery.com
This file is part of GNU libiberty.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "ansidecl.h"
#include <stdio.h>
#include "libiberty.h"
#include "demangle.h"
struct line
{
size_t alloced;
char *data;
};
static unsigned int lineno;
/* Safely read a single line of arbitrary length from standard input. */
#define LINELEN 80
static void
getline(buf)
struct line *buf;
{
char *data = buf->data;
size_t alloc = buf->alloced;
size_t count = 0;
int c;
if (data == 0)
{
data = xmalloc (LINELEN);
alloc = LINELEN;
}
/* Skip comment lines. */
while ((c = getchar()) == '#')
{
while ((c = getchar()) != EOF && c != '\n');
lineno++;
}
/* c is the first character on the line, and it's not a comment
line: copy this line into the buffer and return. */
while (c != EOF && c != '\n')
{
if (count >= alloc)
{
alloc *= 2;
data = xrealloc (data, alloc);
}
data[count++] = c;
c = getchar();
}
lineno++;
data[count] = '\0';
buf->data = data;
buf->alloced = alloc;
}
/* The tester operates on a data file consisting of triples of lines:
format switch
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. */
#define FORMATS "--format="
#define FORMATL (sizeof FORMATS - 1)
int
main(argc, argv)
int argc;
char **argv;
{
enum demangling_styles style;
struct line format;
struct line input;
struct line expect;
char *fstyle;
char *result;
int failures = 0;
int tests = 0;
if (argc > 1)
{
fprintf (stderr, "usage: %s < test-set\n", argv[0]);
return 2;
}
format.data = 0;
input.data = 0;
expect.data = 0;
for (;;)
{
getline (&format);
if (feof (stdin))
break;
getline (&input);
getline (&expect);
tests++;
fstyle = format.data;
if (!strncmp (fstyle, FORMATS, FORMATL))
fstyle += FORMATL;
if (fstyle[0] == '\0')
style = auto_demangling;
else
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;
}
cplus_demangle_set_style (style);
result = cplus_demangle (input.data,
DMGL_PARAMS|DMGL_ANSI|DMGL_VERBOSE|DMGL_TYPES);
if (result
? 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);
failures++;
}
free (result);
}
free (format.data);
free (input.data);
free (expect.data);
printf ("%s: %d tests, %d failures\n", argv[0], tests, failures);
return failures ? 1 : 0;
}