diff mbox

gdb: Remove support for old mangling schemes

Message ID 20190108232208.17487-1-simon.marchi@ericsson.com
State New, archived
Headers

Commit Message

Simon Marchi Jan. 8, 2019, 11:22 p.m. UTC 
  An upcoming sync with gcc's libiberty [1] will remove support for old
mangling schemes (GNU v2, Lucid, ARM, HP and EDG).  It will remove the
cplus_demangle_opname function, so we need to get rid of its usages in
GDB (it's a GNU v2 specific function).

I think the changes are mostly relatively obvious, some hacks that were
necessary to support overloaded operators with GNU v2 mangling are not
needed anymore.

The change in stabsread.c is perhaps less obvious.  I think we could get
rid of more code in that region that is specific to old mangling
schemes, but I chose to do only the minimal changes required to remove
the cplus_demangle_opname uses.  There is also a detailed comment just
above that explaining how GNU v2 and v3 mangled symbols are handled, I
decided to leave it as-is, since I wasn't sure which part to remove,
change or leave there.

I tested the changes locally, and they are being tested on the buildbot
at the moment.

[1] The commit "Remove support for demangling GCC 2.x era mangling
schemes.", specifically.

gdb/ChangeLog:

	* gdbtypes.c (check_stub_method_group): Remove handling of old
	mangling schemes.
	* linespec.c (find_methods): Likewise.
	* stabsread.c (read_member_functions): Likewise.
	* valops.c (search_struct_method): Likewise.
	(value_struct_elt_for_reference): Likewise.

gdb/testsuite/ChangeLog:

	* gdb.cp/demangle.exp (test_gnu_style_demangling): Rename to...
	(test_gnuv3_style_demangling): ... this.
	(test_lucid_style_demangling): Remove.
	(test_arm_style_demangling): Remove.
	(test_hp_style_demangling): Remove.
	(do_tests): Remove calls to the above.
---
 gdb/gdbtypes.c                    |   32 +-
 gdb/linespec.c                    |   11 -
 gdb/stabsread.c                   |   20 -
 gdb/testsuite/gdb.cp/demangle.exp | 1419 +----------------------------
 gdb/valops.c                      |   23 -
 5 files changed, 6 insertions(+), 1499 deletions(-)

Comments

Keith Seitz Jan. 9, 2019, 12:24 a.m. UTC | #1 
On 1/8/19 3:22 PM, Simon Marchi wrote:
> An upcoming sync with gcc's libiberty [1] will remove support for old
> mangling schemes (GNU v2, Lucid, ARM, HP and EDG).  It will remove the
> cplus_demangle_opname function, so we need to get rid of its usages in
> GDB (it's a GNU v2 specific function).

Thank you so much for doing this. I was working on my own version of this
before other work got in the way.

Your patch looks just about identical to mine, and I had a few additional
questions about my own patch that I needed to answer.

I would think this should have/deserve doc and NEWS changes.

The manual talks about several demangling-related features which
raised questions for me about the general support for gnu-v2 code. If
libiberty is removing support for v2 demangling, how useful will GDB be
without the ability to demangle v2 symbols? Should we deprecate or remove
that, too? /me opens can of worms

WRT docs specifically, "set cp-abi" and "set demangling-style" still carry
either direct or indirect mentions of the different ABIs/mangling schemes in
the documentation that are now no longer valid, e.g., "lucid" and "arm".
Some comments in demangle.c do, too.

The help system references that exist today/right now, I presume, will disappear
when the libiberty patch goes back in (when libiberty_demanglers is updated), so
I *think* there's nothing to do there. 

Now the bonus. :-)

> diff --git a/gdb/testsuite/gdb.cp/demangle.exp b/gdb/testsuite/gdb.cp/demangle.exp
> index 698231b82b4..9231b54f787 100644
> --- a/gdb/testsuite/gdb.cp/demangle.exp
> +++ b/gdb/testsuite/gdb.cp/demangle.exp
> -
> -
>  proc catch_demangling_errors {command} {
>      if {[catch $command result]} {
>  	puts "ERROR: demangle.exp: while running $command: $result"
> @@ -1593,10 +183,7 @@ proc do_tests {} {
>      # Using catch_demangling_errors this way ensures that, if one of
>      # the functions raises a Tcl error, then it'll get reported, and
>      # the rest of the functions will still run.
> -    catch_demangling_errors test_lucid_style_demangling
> -    catch_demangling_errors test_gnu_style_demangling
> -    catch_demangling_errors test_arm_style_demangling
> -    catch_demangling_errors test_hp_style_demangling
> +    catch_demangling_errors test_gnuv3_style_demangling
>  

Please consider getting rid of catch_demangling_errors and removing the
"error" calls in set_demangling_style. They are not needed, and in fact,
they cause the test suite to hang if that error is ever called. I ran
across this while prepping my patch, and planned to remove it.

Of course, this (nit) is sorta orthogonal, so please feel free to ask me to do it!
;-)

Keith
Eli Zaretskii Jan. 9, 2019, 3:38 a.m. UTC | #2 
> From: Simon Marchi <simon.marchi@ericsson.com>
> CC: Simon Marchi <simon.marchi@ericsson.com>
> Date: Tue, 8 Jan 2019 23:22:22 +0000
> 
> An upcoming sync with gcc's libiberty [1] will remove support for old
> mangling schemes (GNU v2, Lucid, ARM, HP and EDG).  It will remove the
> cplus_demangle_opname function, so we need to get rid of its usages in
> GDB (it's a GNU v2 specific function).

This would mean new GDB releases will not be able to debug old
programs, is that right?  If so, perhaps we should instead keep our
local version of the relative functions, so that GDB will not regress
in that way.  Our considerations in this matter are different from
those of GCC.
Simon Marchi Jan. 9, 2019, 4:11 a.m. UTC | #3 
On 2019-01-08 22:38, Eli Zaretskii wrote:
>> From: Simon Marchi <simon.marchi@ericsson.com>
>> CC: Simon Marchi <simon.marchi@ericsson.com>
>> Date: Tue, 8 Jan 2019 23:22:22 +0000
>> 
>> An upcoming sync with gcc's libiberty [1] will remove support for old
>> mangling schemes (GNU v2, Lucid, ARM, HP and EDG).  It will remove the
>> cplus_demangle_opname function, so we need to get rid of its usages in
>> GDB (it's a GNU v2 specific function).
> 
> This would mean new GDB releases will not be able to debug old
> programs, is that right?  If so, perhaps we should instead keep our
> local version of the relative functions, so that GDB will not regress
> in that way.  Our considerations in this matter are different from
> those of GCC.

We're talking about really old programs here.  IIUC, the GNU v2 mangling 
was used in the GCC 2.95 era, which is around 2002.  I think it's fine 
to drop support for this.  If you had a system from that era, you would 
have a hard time compiling today's GDB on it.  And even if you just had 
an old binary on a recent systems, well the older GDB releases are 
always available.  I don't think it's worth our time to keep 
compatibility with that.  Just testing it would probably be a nightmare.

I don't know much about the other mangling schemes, but I assume they 
are equally ancient.  Maybe somebody else can give more info about them.

Simon
Simon Marchi Jan. 9, 2019, 4:36 a.m. UTC | #4 
On 2019-01-08 19:24, Keith Seitz wrote:
> On 1/8/19 3:22 PM, Simon Marchi wrote:
>> An upcoming sync with gcc's libiberty [1] will remove support for old
>> mangling schemes (GNU v2, Lucid, ARM, HP and EDG).  It will remove the
>> cplus_demangle_opname function, so we need to get rid of its usages in
>> GDB (it's a GNU v2 specific function).
> 
> Thank you so much for doing this. I was working on my own version of 
> this
> before other work got in the way.

Thanks for looking at mine then!

> Your patch looks just about identical to mine, and I had a few 
> additional
> questions about my own patch that I needed to answer.
> 
> I would think this should have/deserve doc and NEWS changes.

I agree.

> The manual talks about several demangling-related features which
> raised questions for me about the general support for gnu-v2 code. If
> libiberty is removing support for v2 demangling, how useful will GDB be
> without the ability to demangle v2 symbols? Should we deprecate or 
> remove
> that, too? /me opens can of worms

Yes, probably.  The goal of this patch is to unblock the sync'ing with 
gcc's libiberty (remove usages of cplus_demangle_opname), but we can 
certainly do some cleanup later.

> WRT docs specifically, "set cp-abi" and "set demangling-style" still 
> carry
> either direct or indirect mentions of the different ABIs/mangling 
> schemes in
> the documentation that are now no longer valid, e.g., "lucid" and 
> "arm".
> Some comments in demangle.c do, too.

Well, this patch has the effect of removing those demangling styles, so 
it should certainly update the doc for "set demangle-style".  But it 
doesn't touch the cp-abi, so I won't change that part in this patch 
(although as you noted, gnu-v2 will probably be useless if binaries with 
this ABI also use the "gnu" demangling style).

> The help system references that exist today/right now, I presume, will 
> disappear
> when the libiberty patch goes back in (when libiberty_demanglers is 
> updated), so
> I *think* there's nothing to do there.

Indeed, "set demangle-style" and "set demande-style<TAB>" are both 
automatically updated.

> Now the bonus. :-)
> 
>> diff --git a/gdb/testsuite/gdb.cp/demangle.exp 
>> b/gdb/testsuite/gdb.cp/demangle.exp
>> index 698231b82b4..9231b54f787 100644
>> --- a/gdb/testsuite/gdb.cp/demangle.exp
>> +++ b/gdb/testsuite/gdb.cp/demangle.exp
>> -
>> -
>>  proc catch_demangling_errors {command} {
>>      if {[catch $command result]} {
>>  	puts "ERROR: demangle.exp: while running $command: $result"
>> @@ -1593,10 +183,7 @@ proc do_tests {} {
>>      # Using catch_demangling_errors this way ensures that, if one of
>>      # the functions raises a Tcl error, then it'll get reported, and
>>      # the rest of the functions will still run.
>> -    catch_demangling_errors test_lucid_style_demangling
>> -    catch_demangling_errors test_gnu_style_demangling
>> -    catch_demangling_errors test_arm_style_demangling
>> -    catch_demangling_errors test_hp_style_demangling
>> +    catch_demangling_errors test_gnuv3_style_demangling
>> 
> 
> Please consider getting rid of catch_demangling_errors and removing the
> "error" calls in set_demangling_style. They are not needed, and in 
> fact,
> they cause the test suite to hang if that error is ever called. I ran
> across this while prepping my patch, and planned to remove it.
> 
> Of course, this (nit) is sorta orthogonal, so please feel free to ask
> me to do it!
> ;-)

Right, I noticed the hang too.  I was thinking of doing a pass of 
cleanup/modernization on that file after, as I spotted some other things 
(such as unused "global").  I won't ask you to do it nor prevent you :P.

Simon
Tom Tromey Jan. 9, 2019, 4:53 p.m. UTC | #5 
>>>>> "Simon" == Simon Marchi <simon.marchi@polymtl.ca> writes:

Simon> We're talking about really old programs here.  IIUC, the GNU v2
Simon> mangling was used in the GCC 2.95 era, which is around 2002.  I think
Simon> it's fine to drop support for this.  If you had a system from that
Simon> era, you would have a hard time compiling today's GDB on it.  And even
Simon> if you just had an old binary on a recent systems, well the older GDB
Simon> releases are always available.

FWIW, I agree.  This is old enough to drop.
We can always resurrect the code if there's a compelling reason, but I
don't think that will have to happen.

Tom
Tom Tromey Jan. 9, 2019, 4:59 p.m. UTC | #6 
>>>>> "Keith" == Keith Seitz <keiths@redhat.com> writes:

Keith> The manual talks about several demangling-related features which
Keith> raised questions for me about the general support for gnu-v2 code. If
Keith> libiberty is removing support for v2 demangling, how useful will GDB be
Keith> without the ability to demangle v2 symbols? Should we deprecate or remove
Keith> that, too? /me opens can of worms

I tend to think removing the GNU v2 ABI support would be fine.
It's long since obsolete.  If someone out there still requires gcc 2.95,
I suppose they can either build an old gdb as well, or use "set lang c".

Tom
Pedro Alves Jan. 9, 2019, 6:53 p.m. UTC | #7 
On 01/09/2019 04:59 PM, Tom Tromey wrote:
>>>>>> "Keith" == Keith Seitz <keiths@redhat.com> writes:
> 
> Keith> The manual talks about several demangling-related features which
> Keith> raised questions for me about the general support for gnu-v2 code. If
> Keith> libiberty is removing support for v2 demangling, how useful will GDB be
> Keith> without the ability to demangle v2 symbols? Should we deprecate or remove
> Keith> that, too? /me opens can of worms
> 
> I tend to think removing the GNU v2 ABI support would be fine.
> It's long since obsolete.  If someone out there still requires gcc 2.95,
> I suppose they can either build an old gdb as well, or use "set lang c".

+1

For those not involved earlier, note that impact on gdb was also
discussed before the libiberty code was dropped.  It was only removed
because we gave our blessing.  FWIW, here was my opinion on it:

 https://sourceware.org/ml/gdb-patches/2018-12/msg00091.html

Thanks,
Pedro Alves
diff mbox

Patch

diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index 6fb32885c99..d1ca304a924 100644
--- a/gdb/gdbtypes.c
+++ b/gdb/gdbtypes.c
@@ -2736,37 +2736,11 @@  check_stub_method_group (struct type *type, int method_id)
 {
   int len = TYPE_FN_FIELDLIST_LENGTH (type, method_id);
   struct fn_field *f = TYPE_FN_FIELDLIST1 (type, method_id);
-  int j, found_stub = 0;
 
-  for (j = 0; j < len; j++)
-    if (TYPE_FN_FIELD_STUB (f, j))
-      {
-	found_stub = 1;
+  for (int j = 0; j < len; j++)
+    {
+      if (TYPE_FN_FIELD_STUB (f, j))
 	check_stub_method (type, method_id, j);
-      }
-
-  /* GNU v3 methods with incorrect names were corrected when we read
-     in type information, because it was cheaper to do it then.  The
-     only GNU v2 methods with incorrect method names are operators and
-     destructors; destructors were also corrected when we read in type
-     information.
-
-     Therefore the only thing we need to handle here are v2 operator
-     names.  */
-  if (found_stub && !startswith (TYPE_FN_FIELD_PHYSNAME (f, 0), "_Z"))
-    {
-      int ret;
-      char dem_opname[256];
-
-      ret = cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type, 
-							   method_id),
-				   dem_opname, DMGL_ANSI);
-      if (!ret)
-	ret = cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type, 
-							     method_id),
-				     dem_opname, 0);
-      if (ret)
-	TYPE_FN_FIELDLIST_NAME (type, method_id) = xstrdup (dem_opname);
     }
 }
 
diff --git a/gdb/linespec.c b/gdb/linespec.c
index b1ab462e663..cfa8a53640e 100644
--- a/gdb/linespec.c
+++ b/gdb/linespec.c
@@ -1251,17 +1251,6 @@  find_methods (struct type *t, enum language t_lang, const char *name,
 	   --method_counter)
 	{
 	  const char *method_name = TYPE_FN_FIELDLIST_NAME (t, method_counter);
-	  char dem_opname[64];
-
-	  if (startswith (method_name, "__") ||
-	      startswith (method_name, "op") ||
-	      startswith (method_name, "type"))
-	    {
-	      if (cplus_demangle_opname (method_name, dem_opname, DMGL_ANSI))
-		method_name = dem_opname;
-	      else if (cplus_demangle_opname (method_name, dem_opname, 0))
-		method_name = dem_opname;
-	    }
 
 	  if (symbol_name_compare (method_name, lookup_name, NULL))
 	    {
diff --git a/gdb/stabsread.c b/gdb/stabsread.c
index 55c7623aaab..8d2599f56b2 100644
--- a/gdb/stabsread.c
+++ b/gdb/stabsread.c
@@ -2552,7 +2552,6 @@  read_member_functions (struct field_info *fip, const char **pp,
 	}
       else
 	{
-	  int has_stub = 0;
 	  int has_destructor = 0, has_other = 0;
 	  int is_v3 = 0;
 	  struct next_fnfield *tmp_sublist;
@@ -2616,8 +2615,6 @@  read_member_functions (struct field_info *fip, const char **pp,
 	  tmp_sublist = sublist;
 	  while (tmp_sublist != NULL)
 	    {
-	      if (tmp_sublist->fn_field.is_stub)
-		has_stub = 1;
 	      if (tmp_sublist->fn_field.physname[0] == '_'
 		  && tmp_sublist->fn_field.physname[1] == 'Z')
 		is_v3 = 1;
@@ -2704,23 +2701,6 @@  read_member_functions (struct field_info *fip, const char **pp,
 			  "~", main_fn_name, (char *)NULL);
 	      xfree (main_fn_name);
 	    }
-	  else if (!has_stub)
-	    {
-	      char dem_opname[256];
-	      int ret;
-
-	      ret = cplus_demangle_opname (new_fnlist->fn_fieldlist.name,
-					      dem_opname, DMGL_ANSI);
-	      if (!ret)
-		ret = cplus_demangle_opname (new_fnlist->fn_fieldlist.name,
-					     dem_opname, 0);
-	      if (ret)
-		new_fnlist->fn_fieldlist.name
-		  = ((const char *)
-		     obstack_copy0 (&objfile->objfile_obstack, dem_opname,
-				    strlen (dem_opname)));
-	      xfree (main_fn_name);
-	    }
 
 	  new_fnlist->fn_fieldlist.fn_fields
 	    = OBSTACK_CALLOC (&objfile->objfile_obstack, length, fn_field);
diff --git a/gdb/testsuite/gdb.cp/demangle.exp b/gdb/testsuite/gdb.cp/demangle.exp
index 698231b82b4..9231b54f787 100644
--- a/gdb/testsuite/gdb.cp/demangle.exp
+++ b/gdb/testsuite/gdb.cp/demangle.exp
@@ -110,419 +110,13 @@  proc test_demangling_exact {test result} {
     test_demangling_core gdb_test_exact $test $result
 }
 
-
-
 #
-#  Test gnu style name demangling
+#  Test gnu-v3 style name demangling
 #
 
-proc test_gnu_style_demangling {} {
+proc test_gnuv3_style_demangling {} {
     global gdb_prompt
 
-    test_demangling "gnu: Abort__FP6EditoriPCc" \
-	"Abort\[(\]+Editor \[*\]+, int, (const char|char const) \[*\]+\[)\]+"
-    test_demangling_exact "gnu: AddAlignment__9ivTSolverUiP12ivInteractorP7ivTGlue" "ivTSolver::AddAlignment(unsigned int, ivInteractor *, ivTGlue *)"
-    test_demangling "gnu: Append__15NameChooserViewPCc" \
-	"NameChooserView::Append\[(\]+(const char|char const) \[*\]+\[)\]+"
-    test_demangling_exact "gnu: ArrowheadIntersects__9ArrowLineP9ArrowheadR6BoxObjP7Graphic" "ArrowLine::ArrowheadIntersects(Arrowhead *, BoxObj &, Graphic *)"
-    test_demangling_exact "gnu: AtEnd__13ivRubberGroup" "ivRubberGroup::AtEnd(void)"
-    test_demangling_exact "gnu: BgFilter__9ivTSolverP12ivInteractor" "ivTSolver::BgFilter(ivInteractor *)"
-    test_demangling "gnu: BitPatterntoa__FRC10BitPatternccc" \
-	"BitPatterntoa\[(\]+(const BitPattern|BitPattern const) &, char, char, char\[)\]+"
-    test_demangling_exact "gnu: Check__6UArrayi" "UArray::Check(int)"
-    test_demangling_exact "gnu: CoreConstDecls__8TextCodeR7ostream" "TextCode::CoreConstDecls(ostream &)"
-    test_demangling_exact "gnu: Detach__8StateVarP12StateVarView" "StateVar::Detach(StateVarView *)"
-    test_demangling_exact "gnu: Done__9ComponentG8Iterator" "Component::Done(Iterator)"
-    test_demangling "gnu: DrawDestinationTransformedImage__FP7_XImageiiT0iiUlUiiiUiUlUlP4_XGCRC13ivTransformeriiii" \
-	"DrawDestinationTransformedImage\[(\]+_XImage \[*\]+, int, int, _XImage \[*\]+, int, int, unsigned long, unsigned int, int, int, unsigned int, unsigned long, unsigned long, _XGC \[*\]+, (const ivTransformer|ivTransformer const) &, int, int, int, int\[)\]+"
-
-    test_demangling "gnu: Edit__12StringEditorPCcii" \
-	"StringEditor::Edit\[(\]+(const char|char const) \[*\]+, int, int\[)\]+"
-    test_demangling_exact "gnu: Effect__11RelateManipR7ivEvent" "RelateManip::Effect(ivEvent &)"
-    test_demangling "gnu: FilterName__FPCc" \
-	"FilterName\[(\]+(const char|char const) \[*\]+\[)\]+"
-    test_demangling "gnu: Filter__6PSTextPCci" \
-	"PSText::Filter\[(\]+(const char|char const) \[*\]+, int\[)\]+"
-    test_demangling "gnu: FindColor__7CatalogPCciii" \
-	"Catalog::FindColor\[(\]+(const char|char const) \[*\]+, int, int, int\[)\]+"
-    test_demangling_exact "gnu: FindFixed__FRP4CNetP4CNet" "FindFixed(CNet *&, CNet *)"
-    test_demangling "gnu: FindFont__7CatalogPCcN21" \
-	"Catalog::FindFont\[(\]+(const char|char const) \[*\]+, (const char|char const) \[*\]+, (const char|char const) \[*\]+\[)\]+"
-    test_demangling_exact "gnu: Fix48_abort__FR8twolongs" "Fix48_abort(twolongs &)"
-    test_demangling_exact "gnu: GetBarInfo__15iv2_6_VScrollerP13ivPerspectiveRiT2" "iv2_6_VScroller::GetBarInfo(ivPerspective *, int &, int &)"
-    test_demangling_exact "gnu: GetBgColor__C9ivPainter" "ivPainter::GetBgColor(void) const"
-
-    test_demangling "gnu: Iisdouble__FPC6IntRep" \
-	"Iisdouble\[(\]+(const IntRep|IntRep const) \[*\]+\[)\]+"
-    test_demangling_exact "gnu: InsertBody__15H_PullrightMenuii" "H_PullrightMenu::InsertBody(int, int)"
-    test_demangling_exact "gnu: InsertCharacter__9TextManipc" "TextManip::InsertCharacter(char)"
-
-    test_demangling_exact "gnu: InsertToplevel__7ivWorldP12ivInteractorT1" "ivWorld::InsertToplevel(ivInteractor *, ivInteractor *)"
-    test_demangling_exact "gnu: InsertToplevel__7ivWorldP12ivInteractorT1iiUi" "ivWorld::InsertToplevel(ivInteractor *, ivInteractor *, int, int, unsigned int)"
-    test_demangling "gnu: IsADirectory__FPCcR4stat" \
-	"IsADirectory\[(\]+(const char|char const) \[*\]+, stat &\[)\]+"
-    test_demangling_exact "gnu: IsAGroup__FP11GraphicViewP11GraphicComp" "IsAGroup(GraphicView *, GraphicComp *)"
-    test_demangling_exact "gnu: IsA__10ButtonCodeUl" "ButtonCode::IsA(unsigned long)"
-
-    test_demangling_exact "gnu: ReadName__FR7istreamPc" "ReadName(istream &, char *)"
-    test_demangling_exact "gnu: Redraw__13StringBrowseriiii" "StringBrowser::Redraw(int, int, int, int)"
-    test_demangling_exact "gnu: Rotate__13ivTransformerf" "ivTransformer::Rotate(float)"
-    test_demangling_exact "gnu: Rotated__C13ivTransformerf" "ivTransformer::Rotated(float) const"
-    test_demangling_exact "gnu: Round__Ff" "Round(float)"
-
-    test_demangling_exact "gnu: SetExport__16MemberSharedNameUi" "MemberSharedName::SetExport(unsigned int)"
-    test_demangling_exact "gnu: Set__14ivControlState13ControlStatusUi" "ivControlState::Set(ControlStatus, unsigned int)"
-    test_demangling_exact "gnu: Set__5DFacePcii" "DFace::Set(char *, int, int)"
-
-    test_demangling_exact "gnu: VConvert__9ivTSolverP12ivInteractorRP8TElementT2" "ivTSolver::VConvert(ivInteractor *, TElement *&, TElement *&)"
-    test_demangling_exact "gnu: VConvert__9ivTSolverP7ivTGlueRP8TElement" "ivTSolver::VConvert(ivTGlue *, TElement *&)"
-    test_demangling_exact "gnu: VOrder__9ivTSolverUiRP12ivInteractorT2" "ivTSolver::VOrder(unsigned int, ivInteractor *&, ivInteractor *&)"
-    test_demangling "gnu: Valid__7CatalogPCcRP4Tool" \
-	"Catalog::Valid\[(\]+(const char|char const) \[*\]+, Tool \[*\]+&\[)\]+"
-    test_demangling_exact "gnu: _10PageButton\$__both" "PageButton::__both"
-    test_demangling_exact "gnu: _3RNG\$singleMantissa" "RNG::singleMantissa"
-    test_demangling_exact "gnu: _5IComp\$_release" "IComp::_release"
-    test_demangling_exact "gnu: _\$_10BitmapComp" "BitmapComp::~BitmapComp(void)"
-
-    test_demangling_exact "gnu: _\$_9__io_defs" "__io_defs::~__io_defs(void)"
-    test_demangling_exact "gnu: _\$_Q23foo3bar" "foo::bar::~bar(void)"
-    test_demangling_exact "gnu: _\$_Q33foo3bar4bell" "foo::bar::bell::~bell(void)"
-    test_demangling_exact "gnu: __10ivTelltaleiP7ivGlyph" "ivTelltale::ivTelltale(int, ivGlyph *)"
-    test_demangling_exact "gnu: __10ivViewportiP12ivInteractorUi" "ivViewport::ivViewport(int, ivInteractor *, unsigned int)"
-    test_demangling_exact "gnu: __10ostrstream" "ostrstream::ostrstream(void)"
-    test_demangling_exact "gnu: __10ostrstreamPcii" "ostrstream::ostrstream(char *, int, int)"
-    test_demangling "gnu: __11BasicDialogiPCcP13ivButtonStateN22Ui" \
-	"BasicDialog::BasicDialog\[(\]+int, (const char|char const) \[*\]+, ivButtonState \[*\]+, (const char|char const) \[*\]+, (const char|char const) \[*\]+, unsigned int\[)\]+"
-    test_demangling_exact "gnu: __11BitmapTablei" "BitmapTable::BitmapTable(int)"
-    test_demangling_exact "gnu: __12ViewportCodeP12ViewportComp" "ViewportCode::ViewportCode(ViewportComp *)"
-    test_demangling "gnu: __12iv2_6_BorderiPCci" \
-	"iv2_6_Border::iv2_6_Border\[(\]+int, (const char|char const) \[*\]+, int\[)\]+"
-    test_demangling_exact "gnu: __12iv2_6_Borderii" "iv2_6_Border::iv2_6_Border(int, int)"
-    test_demangling "gnu: __12ivBackgroundiP7ivGlyphPC7ivColor" \
-	"ivBackground::ivBackground\[(\]+int, ivGlyph \[*\]+, (const ivColor|ivColor const) \[*\]+\[)\]+"
-    test_demangling_exact "gnu: __12ivBreak_Listl" "ivBreak_List::ivBreak_List(long)"
-    test_demangling "gnu: __14TextInteractoriPCcUi" \
-	"TextInteractor::TextInteractor\[(\]+int, (const char|char const) \[*\]+, unsigned int\[)\]+"
-    test_demangling_exact "gnu: __14iv2_6_MenuItemiP12ivInteractor" "iv2_6_MenuItem::iv2_6_MenuItem(int, ivInteractor *)"
-    test_demangling "gnu: __14iv2_6_MenuItemiPCcP12ivInteractor" \
-	"iv2_6_MenuItem::iv2_6_MenuItem\[(\]+int, (const char|char const) \[*\]+, ivInteractor \[*\]+\[)\]+"
-
-    test_demangling_exact "gnu: __20DisplayList_IteratorR11DisplayList" "DisplayList_Iterator::DisplayList_Iterator(DisplayList &)"
-    test_demangling_exact "gnu: __3fooRT0" "foo::foo(foo &)"
-    test_demangling_exact "gnu: __3fooiN31" "foo::foo(int, int, int, int)"
-    test_demangling "gnu: __3fooiPCc" \
-	"foo::foo\[(\]+int, (const char|char const) \[*\]+\[)\]+"
-    test_demangling_exact "gnu: __3fooiRT0iT2iT2" "foo::foo(int, foo &, int, foo &, int, foo &)"
-    test_demangling "gnu: __6GetOptiPPcPCc" \
-	"GetOpt::GetOpt\[(\]+int, char \[*\]+\[*\]+, (const char|char const) \[*\]+\[)\]+"
-    test_demangling_exact "gnu: __6KeyMapPT0" "KeyMap::KeyMap(KeyMap *)"
-    test_demangling "gnu: __7ivWorldPCcRiPPcPC12ivOptionDescPC14ivPropertyData" \
-	"ivWorld::ivWorld\[(\]+(const char|char const) \[*\]+, int &, char \[*\]+\[*\]+, (const ivOptionDesc|ivOptionDesc const) \[*\]+, (const ivPropertyData|ivPropertyData const) \[*\]+\[)\]+"
-    test_demangling "gnu: __7procbufPCci" \
-	"procbuf::procbuf\[(\]+(const char|char const) \[*\]+, int\[)\]+"
-    test_demangling_exact "gnu: __8ArrowCmdP6EditorUiUi" "ArrowCmd::ArrowCmd(Editor *, unsigned int, unsigned int)"
-
-    test_demangling_exact "gnu: __9F_EllipseiiiiP7Graphic" "F_Ellipse::F_Ellipse(int, int, int, int, Graphic *)"
-    test_demangling_exact "gnu: __9FrameDataP9FrameCompi" "FrameData::FrameData(FrameComp *, int)"
-    test_demangling_exact "gnu: __9HVGraphicP9CanvasVarP7Graphic" "HVGraphic::HVGraphic(CanvasVar *, Graphic *)"
-    test_demangling_exact "gnu: __Q23foo3bar" "foo::bar::bar(void)"
-    test_demangling_exact "gnu: __Q33foo3bar4bell" "foo::bar::bell::bell(void)"
-    test_demangling_exact "gnu: __aa__3fooRT0" "foo::operator&&(foo &)"
-    test_demangling_exact "gnu: __aad__3fooRT0" "foo::operator&=(foo &)"
-    test_demangling_exact "gnu: __ad__3fooRT0" "foo::operator&(foo &)"
-    test_demangling_exact "gnu: __adv__3fooRT0" "foo::operator/=(foo &)"
-    test_demangling_exact "gnu: __aer__3fooRT0" "foo::operator^=(foo &)"
-    test_demangling_exact "gnu: __als__3fooRT0" "foo::operator<<=(foo &)"
-    test_demangling_exact "gnu: __amd__3fooRT0" "foo::operator%=(foo &)"
-    test_demangling_exact "gnu: __ami__3fooRT0" "foo::operator-=(foo &)"
-    test_demangling_exact "gnu: __aml__3FixRT0" "Fix::operator*=(Fix &)"
-    test_demangling_exact "gnu: __aml__5Fix16i" "Fix16::operator*=(int)"
-    test_demangling_exact "gnu: __aml__5Fix32RT0" "Fix32::operator*=(Fix32 &)"
-    test_demangling_exact "gnu: __aor__3fooRT0" "foo::operator|=(foo &)"
-    test_demangling_exact "gnu: __apl__3fooRT0" "foo::operator+=(foo &)"
-    test_demangling_exact "gnu: __ars__3fooRT0" "foo::operator>>=(foo &)"
-
-    test_demangling_exact "gnu: __as__3fooRT0" "foo::operator=(foo &)"
-    test_demangling_exact "gnu: __cl__3fooRT0" "foo::operator()(foo &)"
-    test_demangling_exact "gnu: __cl__6Normal" "Normal::operator()(void)"
-    test_demangling_exact "gnu: __cl__6Stringii" "String::operator()(int, int)"
-    test_demangling_exact "gnu: __cm__3fooRT0" "foo::operator, (foo &)"
-    test_demangling_exact "gnu: __co__3foo" "foo::operator~(void)"
-    test_demangling_exact "gnu: __dl__3fooPv" "foo::operator delete(void *)"
-    test_demangling_exact "gnu: __dv__3fooRT0" "foo::operator/(foo &)"
-    test_demangling_exact "gnu: __eq__3fooRT0" "foo::operator==(foo &)"
-    test_demangling_exact "gnu: __er__3fooRT0" "foo::operator^(foo &)"
-    test_demangling_exact "gnu: __ge__3fooRT0" "foo::operator>=(foo &)"
-    test_demangling_exact "gnu: __gt__3fooRT0" "foo::operator>(foo &)"
-    test_demangling_exact "gnu: __le__3fooRT0" "foo::operator<=(foo &)"
-    test_demangling_exact "gnu: __ls__3fooRT0" "foo::operator<<(foo &)"
-    test_demangling_exact "gnu: __ls__FR7ostreamPFR3ios_R3ios" "operator<<(ostream &, ios &(*)(ios &))"
-    test_demangling_exact "gnu: __ls__FR7ostreamR3Fix" "operator<<(ostream &, Fix &)"
-    test_demangling_exact "gnu: __lt__3fooRT0" "foo::operator<(foo &)"
-    test_demangling_exact "gnu: __md__3fooRT0" "foo::operator%(foo &)"
-    test_demangling_exact "gnu: __mi__3fooRT0" "foo::operator-(foo &)"
-    test_demangling_exact "gnu: __ml__3fooRT0" "foo::operator*(foo &)"
-    test_demangling_exact "gnu: __mm__3fooi" "foo::operator--(int)"
-
-    test_demangling_exact "gnu: __ne__3fooRT0" "foo::operator!=(foo &)"
-    test_demangling "gnu: __ne__FRC7ComplexT0" \
-	"operator!=\[(\]+(const Complex|Complex const) &, (const Complex|Complex const) &\[)\]+"
-    test_demangling "gnu: __ne__FRC7Complexd" \
-	"operator!=\[(\]+(const Complex|Complex const) &, double\[)\]+"
-    test_demangling "gnu: __ne__FRC9SubStringRC6String" \
-	"operator!=\[(\]+(const SubString|SubString const) &, (const String|String const) &\[)\]+"
-    test_demangling_exact "gnu: __nt__3foo" "foo::operator!(void)"
-    test_demangling_exact "gnu: __nw__3fooi" "foo::operator new(int)"
-    test_demangling_exact "gnu: __oo__3fooRT0" "foo::operator||(foo &)"
-    test_demangling_exact "gnu: __opPc__3foo" "foo::operator char *(void)"
-    test_demangling_exact "gnu: __opi__3foo" "foo::operator int(void)"
-    test_demangling_exact "gnu: __or__3fooRT0" "foo::operator|(foo &)"
-    test_demangling_exact "gnu: __pl__3fooRT0" "foo::operator+(foo &)"
-    test_demangling_exact "gnu: __pp__3fooi" "foo::operator++(int)"
-    test_demangling_exact "gnu: __rf__3foo" "foo::operator->(void)"
-    test_demangling_exact "gnu: __rm__3fooRT0" "foo::operator->*(foo &)"
-    test_demangling_exact "gnu: __rs__3fooRT0" "foo::operator>>(foo &)"
-    test_demangling "gnu: __vc__3fooRT0" "foo::operator\\\[\\\]\\(foo &\\)"
-    test_demangling "gnu: _gsub__6StringRC5RegexPCci" \
-	"String::_gsub\[(\]+(const Regex|Regex const) &, (const char|char const) \[*\]+, int\[)\]+"
-    test_demangling_exact "gnu: _new_Fix__FUs" "_new_Fix(unsigned short)"
-
-    # gcc 2.4.5 (and earlier) style virtual tables.  We want to continue to
-    # correctly demangle these even if newer compilers use a different form.
-    test_demangling_exact "gnu: _vt.foo" "foo virtual table"
-    test_demangling_exact "gnu: _vt.foo.bar" "foo::bar virtual table"
-    test_demangling_exact "gnu: _vt\$foo" "foo virtual table"
-    test_demangling_exact "gnu: _vt\$foo\$bar" "foo::bar virtual table"
-
-    test_demangling_exact "gnu: append__7ivGlyphPT0" "ivGlyph::append(ivGlyph *)"
-    test_demangling "gnu: arg__FRC7Complex" \
-	"arg\[(\]+(const Complex|Complex const) &\[)\]+"
-    test_demangling_exact "gnu: clearok__FP7_win_sti" "clearok(_win_st *, int)"
-
-    test_demangling_exact "gnu: complexfunc2__FPFPc_i" "complexfunc2(int (*)(char *))"
-    test_demangling_exact "gnu: complexfunc3__FPFPFPl_s_i" "complexfunc3(int (*)(short (*)(long *)))"
-    test_demangling_exact "gnu: complexfunc4__FPFPFPc_s_i" "complexfunc4(int (*)(short (*)(char *)))"
-    test_demangling_exact "gnu: complexfunc5__FPFPc_PFl_i" "complexfunc5(int (*(*)(char *))(long))"
-    test_demangling_exact "gnu: complexfunc6__FPFPi_PFl_i" "complexfunc6(int (*(*)(int *))(long))"
-    test_demangling_exact "gnu: complexfunc7__FPFPFPc_i_PFl_i" "complexfunc7(int (*(*)(int (*)(char *)))(long))"
-    test_demangling "gnu: contains__C9BitStringRC10BitPattern" \
-	"BitString::contains\[(\]+(const BitPattern|BitPattern const) &\[)\]+ const"
-    test_demangling "gnu: contains__C9BitStringRC12BitSubStringi" \
-	"BitString::contains\[(\]+(const BitSubString|BitSubString const) &, int\[)\]+ const"
-    test_demangling "gnu: contains__C9BitStringRT0" \
-	"BitString::contains\[(\]+(const BitString|BitString const) &\[)\]+ const"
-    test_demangling "gnu: div__FPC6IntRepT0P6IntRep" \
-	"div\[(\]+(const IntRep|IntRep const) \[*\]+, (const IntRep|IntRep const) \[*\]+, IntRep \[*\]+\[)\]+"
-    test_demangling "gnu: div__FPC6IntReplP6IntRep" \
-	"div\[(\]+(const IntRep|IntRep const) \[*\]+, long, IntRep \[*\]+\[)\]+"
-    test_demangling "gnu: div__FRC8RationalT0R8Rational" \
-	"div\[(\]+(const Rational|Rational const) &, (const Rational|Rational const) &, Rational &\[)\]+"
-    test_demangling "gnu: divide__FRC7IntegerT0R7IntegerT2" \
-	"divide\[(\]+(const Integer|Integer const) &, (const Integer|Integer const) &, Integer &, Integer &\[)\]+"
-    test_demangling "gnu: divide__FRC7IntegerlR7IntegerRl" \
-	"divide\[(\]+(const Integer|Integer const) &, long, Integer &, long &\[)\]+"
-    test_demangling "gnu: enable__14DocumentViewerPCcUi" \
-	"DocumentViewer::enable\[(\]+(const char|char const) \[*\]+, unsigned int\[)\]+"
-
-    test_demangling_exact "gnu: foo__FiN30" "foo(int, int, int, int)"
-    test_demangling_exact "gnu: foo__FiR3fooiT1iT1" "foo(int, foo &, int, foo &, int, foo &)"
-    test_demangling_exact "gnu: foo___3barl" "bar::foo_(long)"
-    test_demangling_exact "gnu: insert__15ivClippingStacklRP8_XRegion" "ivClippingStack::insert(long, _XRegion *&)"
-    test_demangling_exact "gnu: insert__16ChooserInfo_ListlR11ChooserInfo" "ChooserInfo_List::insert(long, ChooserInfo &)"
-    test_demangling_exact "gnu: insert__17FontFamilyRepListlRP15ivFontFamilyRep" "FontFamilyRepList::insert(long, ivFontFamilyRep *&)"
-    test_demangling_exact "gnu: leaveok__FP7_win_stc" "leaveok(_win_st *, char)"
-    test_demangling_exact "gnu: left_mover__C7ivMFKitP12ivAdjustableP7ivStyle" "ivMFKit::left_mover(ivAdjustable *, ivStyle *) const"
-    test_demangling "gnu: matches__C9BitStringRC10BitPatterni" \
-	"BitString::matches\[(\]+(const BitPattern|BitPattern const) &, int\[)\]+ const"
-    test_demangling "gnu: matches__C9SubStringRC5Regex" \
-	"SubString::matches\[(\]+(const Regex|Regex const) &\[)\]+ const"
-
-    test_demangling_exact "gnu: overload1arg__FSc" "overload1arg(signed char)"
-    test_demangling_exact "gnu: overload1arg__FUc" "overload1arg(unsigned char)"
-    test_demangling_exact "gnu: overload1arg__FUi" "overload1arg(unsigned int)"
-    test_demangling_exact "gnu: overload1arg__FUl" "overload1arg(unsigned long)"
-    test_demangling_exact "gnu: overload1arg__FUs" "overload1arg(unsigned short)"
-    test_demangling_exact "gnu: overload1arg__Fc" "overload1arg(char)"
-    test_demangling_exact "gnu: overload1arg__Fd" "overload1arg(double)"
-    test_demangling_exact "gnu: overload1arg__Ff" "overload1arg(float)"
-    test_demangling_exact "gnu: overload1arg__Fi" "overload1arg(int)"
-    test_demangling_exact "gnu: overload1arg__Fl" "overload1arg(long)"
-    test_demangling_exact "gnu: overload1arg__Fs" "overload1arg(short)"
-    test_demangling_exact "gnu: overload1arg__Fv" "overload1arg(void)"
-    test_demangling_exact "gnu: overloadargs__Fi" "overloadargs(int)"
-    test_demangling_exact "gnu: overloadargs__Fii" "overloadargs(int, int)"
-    test_demangling_exact "gnu: overloadargs__Fiii" "overloadargs(int, int, int)"
-    test_demangling_exact "gnu: overloadargs__Fiiii" "overloadargs(int, int, int, int)"
-
-    test_demangling_exact "gnu: overloadargs__Fiiiii" "overloadargs(int, int, int, int, int)"
-    test_demangling_exact "gnu: overloadargs__Fiiiiii" "overloadargs(int, int, int, int, int, int)"
-    test_demangling_exact "gnu: overloadargs__Fiiiiiii" "overloadargs(int, int, int, int, int, int, int)"
-    test_demangling_exact "gnu: overloadargs__Fiiiiiiii" "overloadargs(int, int, int, int, int, int, int, int)"
-    test_demangling_exact "gnu: overloadargs__Fiiiiiiiii" "overloadargs(int, int, int, int, int, int, int, int, int)"
-    test_demangling_exact "gnu: overloadargs__Fiiiiiiiiii" "overloadargs(int, int, int, int, int, int, int, int, int, int)"
-    test_demangling_exact "gnu: overloadargs__Fiiiiiiiiiii" "overloadargs(int, int, int, int, int, int, int, int, int, int, int)"
-    test_demangling "gnu: pick__13ivCompositionP8ivCanvasRC12ivAllocationiR5ivHit" \
-	"ivComposition::pick\[(\]+ivCanvas \[*\]+, (const ivAllocation|ivAllocation const) &, int, ivHit &\[)\]+"
-    test_demangling "gnu: pointer__C11ivHScrollerRC7ivEventRC12ivAllocation" \
-	"ivHScroller::pointer\[(\]+(const ivEvent|ivEvent const) &, (const ivAllocation|ivAllocation const) &\[)\]+ const"
-    test_demangling_exact "gnu: poke__8ivRasterUlUlffff" "ivRaster::poke(unsigned long, unsigned long, float, float, float, float)"
-    test_demangling_exact "gnu: polar__Fdd" "polar(double, double)"
-    test_demangling "gnu: read__10osStdInputRPCc" \
-	"osStdInput::read\[(\]+(const char|char const) \[*\]+&\[)\]+"
-
-    test_demangling_exact "gnu: scale__13ivTransformerff" "ivTransformer::scale(float, float)"
-    test_demangling "gnu: scanw__12CursesWindowPCce" \
-	"CursesWindow::scanw\[(\]+(const char|char const) \[*\]+,...\[)\]+"
-    test_demangling "gnu: scmp__FPCcT0" \
-	"scmp\[(\]+(const char|char const) \[*\]+, (const char|char const) \[*\]+\[)\]+"
-    test_demangling_exact "gnu: sgetn__7filebufPci" "filebuf::sgetn(char *, int)"
-    test_demangling_exact "gnu: shift__FP5_FrepiT0" "shift(_Frep *, int, _Frep *)"
-    test_demangling_exact "gnu: test__C6BitSeti" "BitSet::test(int) const"
-    test_demangling_exact "gnu: test__C6BitSetii" "BitSet::test(int, int) const"
-    test_demangling "gnu: testbit__FRC7Integerl" \
-	"testbit\[(\]+(const Integer|Integer const) &, long\[)\]+"
-    test_demangling_exact "gnu: text_source__8Documentl" "Document::text_source(long)"
-    test_demangling_exact "gnu: variance__6Erlangd" "Erlang::variance(double)"
-    test_demangling "gnu: vform__8iostreamPCcPc" \
-	"iostream::vform\[(\]+(const char|char const) \[*\]+, char \[*\]+\[)\]+"
-    test_demangling_exact "gnu: view__14DocumentViewerP8ItemViewP11TabularItem" "DocumentViewer::view(ItemView *, TabularItem *)"
-    test_demangling_exact "gnu: xy_extents__11ivExtensionffff" "ivExtension::xy_extents(float, float, float, float)"
-    test_demangling_exact "gnu: zero__8osMemoryPvUi" "osMemory::zero(void *, unsigned int)"
-    test_demangling_exact "gnu: _2T4\$N" "T4::N"
-    test_demangling_exact "gnu: _Q22T42t1\$N" "T4::t1::N"
-    test_demangling_exact "gnu: get__2T1" "T1::get(void)"
-    test_demangling_exact "gnu: get__Q22T11a" "T1::a::get(void)"
-    test_demangling_exact "gnu: get__Q32T11a1b" "T1::a::b::get(void)"
-    test_demangling_exact "gnu: get__Q42T11a1b1c" "T1::a::b::c::get(void)"
-    test_demangling_exact "gnu: get__Q52T11a1b1c1d" "T1::a::b::c::d::get(void)"
-    test_demangling_exact "gnu: put__2T1i" "T1::put(int)"
-    test_demangling_exact "gnu: put__Q22T11ai" "T1::a::put(int)"
-    test_demangling_exact "gnu: put__Q32T11a1bi" "T1::a::b::put(int)"
-    test_demangling_exact "gnu: put__Q42T11a1b1ci" "T1::a::b::c::put(int)"
-    test_demangling_exact "gnu: put__Q52T11a1b1c1di" "T1::a::b::c::d::put(int)"
-
-    test_demangling_exact "gnu: bar__3fooPv"       "foo::bar(void *)"
-    test_demangling "gnu: bar__3fooPCv" \
-	"foo::bar\[(\]+(const void|void const) *\[*\]+\[)\]+"
-    test_demangling_exact "gnu: bar__C3fooPv"      "foo::bar(void *) const"
-    test_demangling "gnu: bar__C3fooPCv" \
-	"foo::bar\[(\]+(const void|void const) *\[*\]+\[)\]+ const"
-    test_demangling_exact "gnu: __eq__3fooRT0"     "foo::operator==(foo &)"
-    test_demangling "gnu: __eq__3fooRC3foo" \
-	 "foo::operator==\[(\]+(const foo|foo const) &\[)\]+"
-    test_demangling_exact "gnu: __eq__C3fooR3foo"  "foo::operator==(foo &) const"
-    test_demangling "gnu: __eq__C3fooRT0" \
-	   "foo::operator==\[(\]+(const foo|foo const) &\[)\]+ const"
-
-    test_demangling_exact "gnu: elem__t6vector1Zdi" "vector<double>::elem(int)"
-    test_demangling_exact "gnu: elem__t6vector1Zii" "vector<int>::elem(int)"
-    test_demangling_exact "gnu: __t6vector1Zdi"     "vector<double>::vector(int)"
-    test_demangling_exact "gnu: __t6vector1Zii"     "vector<int>::vector(int)"
-    test_demangling_exact "gnu: _\$_t6vector1Zdi"    "vector<double>::~vector(int)"
-    test_demangling_exact "gnu: _\$_t6vector1Zii"    "vector<int>::~vector(int)"
-
-    test_demangling_exact "gnu: __nw__t2T11ZcUi" "T1<char>::operator new(unsigned int)"
-    test_demangling_exact "gnu: __nw__t2T11Z1tUi" "T1<t>::operator new(unsigned int)"
-    test_demangling_exact "gnu: __dl__t2T11ZcPv" "T1<char>::operator delete(void *)"
-    test_demangling_exact "gnu: __dl__t2T11Z1tPv" "T1<t>::operator delete(void *)"
-    test_demangling_exact "gnu: __t2T11Zci" "T1<char>::T1(int)"
-    test_demangling_exact "gnu: __t2T11Zc" "T1<char>::T1(void)"
-    test_demangling_exact "gnu: __t2T11Z1ti" "T1<t>::T1(int)"
-    test_demangling_exact "gnu: __t2T11Z1t" "T1<t>::T1(void)"
-
-    test_demangling_exact "gnu: __Q2t4List1Z10VHDLEntity3Pix" \
-	"List<VHDLEntity>::Pix::Pix(void)"
-
-    test_demangling_exact "gnu: __Q2t4List1Z10VHDLEntity3PixPQ2t4List1Z10VHDLEntity7element" \
-	"List<VHDLEntity>::Pix::Pix(List<VHDLEntity>::element *)"
-
-    test_demangling_exact "gnu: __Q2t4List1Z10VHDLEntity3PixRCQ2t4List1Z10VHDLEntity3Pix" \
-	"List<VHDLEntity>::Pix::Pix(List<VHDLEntity>::Pix const &)"
-
-    test_demangling_exact "gnu: __Q2t4List1Z10VHDLEntity7elementRC10VHDLEntityPT0" \
-	"List<VHDLEntity>::element::element(VHDLEntity const &, List<VHDLEntity>::element *)"
-
-    test_demangling_exact "gnu: __Q2t4List1Z10VHDLEntity7elementRCQ2t4List1Z10VHDLEntity7element" \
-	"List<VHDLEntity>::element::element(List<VHDLEntity>::element const &)"
-
-    test_demangling_exact "gnu: __cl__C11VHDLLibraryGt4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntity" \
-	"VHDLLibrary::operator()(PixX<VHDLLibrary, VHDLLibraryRep, List<VHDLEntity> >) const"
-
-    test_demangling_exact "gnu: __cl__Ct4List1Z10VHDLEntityRCQ2t4List1Z10VHDLEntity3Pix" \
-	"List<VHDLEntity>::operator()(List<VHDLEntity>::Pix const &) const"
-
-    test_demangling_exact "gnu: __ne__FPvRCQ2t4List1Z10VHDLEntity3Pix" \
-	"operator!=(void *, List<VHDLEntity>::Pix const &)"
-
-    test_demangling_exact "gnu: __ne__FPvRCt4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntity" \
-	"operator!=(void *, PixX<VHDLLibrary, VHDLLibraryRep, List<VHDLEntity> > const &)"
-
-    test_demangling_exact "gnu: __t4List1Z10VHDLEntityRCt4List1Z10VHDLEntity" \
-	"List<VHDLEntity>::List(List<VHDLEntity> const &)"
-
-    test_demangling_exact "gnu: __t4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntity" \
-	"PixX<VHDLLibrary, VHDLLibraryRep, List<VHDLEntity> >::PixX(void)"
-
-    test_demangling_exact "gnu: __t4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntityP14VHDLLibraryRepGQ2t4List1Z10VHDLEntity3Pix" \
-	"PixX<VHDLLibrary, VHDLLibraryRep, List<VHDLEntity> >::PixX(VHDLLibraryRep *, List<VHDLEntity>::Pix)"
-
-    test_demangling_exact "gnu: __t4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntityRCt4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntity" \
-	"PixX<VHDLLibrary, VHDLLibraryRep, List<VHDLEntity> >::PixX(PixX<VHDLLibrary, VHDLLibraryRep, List<VHDLEntity> > const &)"
-
-    test_demangling_exact "gnu: nextE__C11VHDLLibraryRt4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntity" \
-	"VHDLLibrary::nextE(PixX<VHDLLibrary, VHDLLibraryRep, List<VHDLEntity> > &) const"
-
-    test_demangling_exact "gnu: next__Ct4List1Z10VHDLEntityRQ2t4List1Z10VHDLEntity3Pix" \
-	"List<VHDLEntity>::next(List<VHDLEntity>::Pix &) const"
-
-    test_demangling_exact "gnu: _GLOBAL_\$D\$set" "global destructors keyed to set"
-
-    test_demangling_exact "gnu: _GLOBAL_\$I\$set" "global constructors keyed to set"
-
-    test_demangling_exact "gnu: __as__t5ListS1ZUiRCt5ListS1ZUi" \
-	"ListS<unsigned int>::operator=(ListS<unsigned int> const &)"
-
-    test_demangling_exact "gnu: __cl__Ct5ListS1ZUiRCQ2t5ListS1ZUi3Vix" \
-	"ListS<unsigned int>::operator()(ListS<unsigned int>::Vix const &) const"
-
-    test_demangling_exact "gnu: __cl__Ct5SetLS1ZUiRCQ2t5SetLS1ZUi3Vix" \
-	"SetLS<unsigned int>::operator()(SetLS<unsigned int>::Vix const &) const"
-
-    test_demangling_exact "gnu: __t10ListS_link1ZUiRCUiPT0" \
-	"ListS_link<unsigned int>::ListS_link(unsigned int const &, ListS_link<unsigned int> *)"
-
-    test_demangling_exact "gnu: __t10ListS_link1ZUiRCt10ListS_link1ZUi" \
-	"ListS_link<unsigned int>::ListS_link(ListS_link<unsigned int> const &)"
-
-    test_demangling_exact "gnu: __t5ListS1ZUiRCt5ListS1ZUi" \
-	"ListS<unsigned int>::ListS(ListS<unsigned int> const &)"
-
-    test_demangling_exact "gnu: next__Ct5ListS1ZUiRQ2t5ListS1ZUi3Vix" \
-	"ListS<unsigned int>::next(ListS<unsigned int>::Vix &) const"
-
-    test_demangling_exact "gnu: __ne__FPvRCQ2t5SetLS1ZUi3Vix" \
-	"operator!=(void *, SetLS<unsigned int>::Vix const &)"
-    test_demangling_exact "gnu: __t8ListElem1Z5LabelRt4List1Z5Label" \
-	"ListElem<Label>::ListElem(List<Label> &)"
-    test_demangling_exact "gnu: __t8BDDHookV1ZPcRCPc" \
-	"BDDHookV<char *>::BDDHookV(char *const &)"
-
-    test_demangling_exact "gnu: _vt\$t8BDDHookV1ZPc" "BDDHookV<char *> virtual table"
-
-    test_demangling_exact "gnu: __ne__FPvRCQ211BDDFunction4VixB" \
-	"operator!=(void *, BDDFunction::VixB const &)"
-    test_demangling_exact "gnu: __eq__FPvRCQ211BDDFunction4VixB" \
-	"operator==(void *, BDDFunction::VixB const &)"
-
-    test_demangling_exact "gnu: relativeId__CQ36T_phi210T_preserve8FPC_nextRCQ26T_phi210T_preserveRC10Parameters" \
-	 "T_phi2::T_preserve::FPC_next::relativeId(T_phi2::T_preserve const &, Parameters const &) const"
-
-    test_demangling_exact "gnu: _Utf390_1__1_9223372036854775807__9223372036854775" \
-	    "Can't demangle \"_Utf390_1__1_9223372036854775807__9223372036854775\""
-    test_demangling_exact "gnu: foo__I40" "foo(int64_t)"
-    test_demangling_exact "gnu: foo__I_200_" "foo(int512_t)"
-    test_demangling_exact "gnu: foo__I_200" "Can't demangle \"foo__I_200\""
-
     # Rvalue reference tests
     test_demangling_exact "gnu-v3: _ZN9ArrowLine19ArrowheadIntersectsEP9ArrowheadO6BoxObjP7Graphic" "ArrowLine::ArrowheadIntersects(Arrowhead*, BoxObj&&, Graphic*)"
     test_demangling "gnu-v3: _Z13BitPatterntoaOK10BitPatternccc" \
@@ -560,1012 +154,8 @@  proc test_gnu_style_demangling {} {
 	"VHDLLibrary::nextE(PixX<VHDLLibrary, VHDLLibraryRep, List<VHDLEntity> >&&) const"
     test_demangling_exact "gnu-v3: _ZNK4ListI10VHDLEntityE4nextEONS1_3PixE" \
 	"List<VHDLEntity>::next(List<VHDLEntity>::Pix&&) const"
-
-    ## Buffer overrun.  Should make GDB crash.  Woo hoo!
-    test_demangling_exact "gnu: foo__I_4000000000000000000000000000000000000000000000000000000000000000000000000" "Can't demangle \"foo__I_4000000000000000000000000000000000000000000000000000000000000000000000000\""
-
-    ## 1999-04-19: "Fix from Dale Hawkins".  Shouldn't segfault.
-    # Accept even a dubious demangling; the string is ambiguous.
-
-    gdb_test_multiple "demangle __thunk_64__0RL__list__Q29CosNaming20_proxy_NamingContextUlRPt25_CORBA_Unbounded_Sequence1ZQ29CosNaming7BindingRPQ29CosNaming15BindingIterator" "gnu: __thunk_64__0RL__list__Q29CosNaming20_proxy_NamingContextUlRPt25_CORBA_Unbounded_Sequence1ZQ29CosNaming7BindingRPQ29CosNaming15BindingIterator" {
-	-re "virtual function thunk \\(delta:-64\\) for CosNaming::_proxy_NamingContext::_0RL__list\\(unsigned long, _CORBA_Unbounded_Sequence<CosNaming::Binding> \\*\\&, CosNaming::BindingIterator \\*\\&\\)\r\n$gdb_prompt $" {
-	    pass "gnu: __thunk_64__0RL__list__Q29CosNaming20_proxy_NamingContextUlRPt25_CORBA_Unbounded_Sequence1ZQ29CosNaming7BindingRPQ29CosNaming15BindingIterator"
-	}
-	-re ".*Can't demangle \"__thunk_64__0RL__list__Q29CosNaming20_proxy_NamingContextUlRPt25_CORBA_Unbounded_Sequence1ZQ29CosNaming7BindingRPQ29CosNaming15BindingIterator\"\r\n$gdb_prompt $" {
-	    pass "gnu: __thunk_64__0RL__list__Q29CosNaming20_proxy_NamingContextUlRPt25_CORBA_Unbounded_Sequence1ZQ29CosNaming7BindingRPQ29CosNaming15BindingIterator"
-	}
-    }
-}
-
-#
-#  Test lucid style name demangling
-#
-
-proc test_lucid_style_demangling {} {
-    test_demangling_exact "lucid: WS__FR7istream" "WS(istream &)"
-    test_demangling_exact "lucid: __aa__3fooFR3foo" "foo::operator&&(foo &)"
-    test_demangling_exact "lucid: __aad__3fooFR3foo" "foo::operator&=(foo &)"
-    test_demangling_exact "lucid: __ad__3fooFR3foo" "foo::operator&(foo &)"
-    test_demangling_exact "lucid: __adv__3fooFR3foo" "foo::operator/=(foo &)"
-    test_demangling_exact "lucid: __adv__7complexF7complex" "complex::operator/=(complex)"
-    test_demangling_exact "lucid: __aer__3fooFR3foo" "foo::operator^=(foo &)"
-    test_demangling_exact "lucid: __als__3fooFR3foo" "foo::operator<<=(foo &)"
-    test_demangling_exact "lucid: __amd__3fooFR3foo" "foo::operator%=(foo &)"
-    test_demangling_exact "lucid: __ami__3fooFR3foo" "foo::operator-=(foo &)"
-    test_demangling_exact "lucid: __amu__3fooFR3foo" "foo::operator*=(foo &)"
-    test_demangling_exact "lucid: __amu__7complexF7complex" "complex::operator*=(complex)"
-    test_demangling_exact "lucid: __aor__3fooFR3foo" "foo::operator|=(foo &)"
-    test_demangling_exact "lucid: __apl__3fooFR3foo" "foo::operator+=(foo &)"
-    test_demangling_exact "lucid: __ars__3fooFR3foo" "foo::operator>>=(foo &)"
-    test_demangling_exact "lucid: __as__18istream_withassignFP9streambuf" "istream_withassign::operator=(streambuf *)"
-    test_demangling_exact "lucid: __as__18istream_withassignFR7istream" "istream_withassign::operator=(istream &)"
-    test_demangling_exact "lucid: __as__3fooFR3foo" "foo::operator=(foo &)"
-    test_demangling_exact "lucid: __as__3iosFR3ios" "ios::operator=(ios &)"
-    test_demangling_exact "lucid: __cl__3fooFR3foo" "foo::operator()(foo &)"
-    test_demangling_exact "lucid: __cm__3fooFR3foo" "foo::operator, (foo &)"
-
-    test_demangling_exact "lucid: __co__3fooFv" "foo::operator~(void)"
-    test_demangling_exact "lucid: __ct__10istrstreamFPc" "istrstream::istrstream(char *)"
-    test_demangling_exact "lucid: __ct__10istrstreamFPci" "istrstream::istrstream(char *, int)"
-    test_demangling_exact "lucid: __ct__10ostrstreamFPciT2" "ostrstream::ostrstream(char *, int, int)"
-    test_demangling_exact "lucid: __ct__10ostrstreamFv" "ostrstream::ostrstream(void)"
-    test_demangling_exact "lucid: __ct__10smanip_intFPFR3iosi_R3iosi" "smanip_int::smanip_int(ios &(*)(ios &, int), int)"
-    test_demangling "lucid: __ct__11c_exceptionFPcRC7complexT2" "c_exception::c_exception\[(\]+char \[*\]+, (const complex|complex const) &, (const complex|complex const) &\[)\]+"
-    test_demangling "lucid: __ct__11fstreambaseFPCciT2" "fstreambase::fstreambase\[(\]+(const char|char const) \[*\]+, int, int\[)\]+"
-    test_demangling_exact "lucid: __ct__11fstreambaseFi" "fstreambase::fstreambase(int)"
-    test_demangling_exact "lucid: __ct__11fstreambaseFiPcT1" "fstreambase::fstreambase(int, char *, int)"
-    test_demangling_exact "lucid: __ct__11fstreambaseFv" "fstreambase::fstreambase(void)"
-    test_demangling_exact "lucid: __ct__11smanip_longFPFR3iosl_R3iosl" "smanip_long::smanip_long(ios &(*)(ios &, long), long)"
-    test_demangling_exact "lucid: __ct__11stdiostreamFP4FILE" "stdiostream::stdiostream(FILE *)"
-    test_demangling_exact "lucid: __ct__12strstreambufFPFl_PvPFPv_v" "strstreambuf::strstreambuf(void *(*)(long), void (*)(void *))"
-    test_demangling_exact "lucid: __ct__12strstreambufFPUciT1" "strstreambuf::strstreambuf(unsigned char *, int, unsigned char *)"
-    test_demangling_exact "lucid: __ct__12strstreambufFPciT1" "strstreambuf::strstreambuf(char *, int, char *)"
-    test_demangling_exact "lucid: __ct__12strstreambufFi" "strstreambuf::strstreambuf(int)"
-    test_demangling_exact "lucid: __ct__12strstreambufFv" "strstreambuf::strstreambuf(void)"
-    test_demangling_exact "lucid: __ct__13strstreambaseFPciT1" "strstreambase::strstreambase(char *, int, char *)"
-    test_demangling_exact "lucid: __ct__3fooFR3foo" "foo::foo(foo &)"
-
-    test_demangling_exact "lucid: __ct__3fooFi" "foo::foo(int)"
-    test_demangling_exact "lucid: __ct__3fooFiN31" "foo::foo(int, int, int, int)"
-    test_demangling "lucid: __ct__3fooFiPCc" \
-	"foo::foo\[(\]+int, (const char|char const) \[*\]+\[)\]+"
-    test_demangling_exact "lucid: __ct__3fooFiR3fooT1T2T1T2" "foo::foo(int, foo &, int, foo &, int, foo &)"
-    test_demangling_exact "lucid: __ct__3iosFP9streambuf" "ios::ios(streambuf *)"
-    test_demangling_exact "lucid: __ct__7filebufFiPcT1" "filebuf::filebuf(int, char *, int)"
-    test_demangling "lucid: __ct__7fstreamFPCciT2" \
-	"fstream::fstream\[(\]+(const char|char const) \[*\]+, int, int\[)\]+"
-    test_demangling_exact "lucid: __ct__7fstreamFiPcT1" "fstream::fstream(int, char *, int)"
-    test_demangling_exact "lucid: __ct__7istreamFP9streambuf" "istream::istream(streambuf *)"
-    test_demangling_exact "lucid: __ct__7istreamFP9streambufiP7ostream" "istream::istream(streambuf *, int, ostream *)"
-    test_demangling_exact "lucid: __ct__7istreamFiPcT1" "istream::istream(int, char *, int)"
-    test_demangling_exact "lucid: __ct__7istreamFiT1P7ostream" "istream::istream(int, int, ostream *)"
-    test_demangling_exact "lucid: __ct__7ostreamFP9streambuf" "ostream::ostream(streambuf *)"
-    test_demangling_exact "lucid: __ct__7ostreamFiPc" "ostream::ostream(int, char *)"
-    test_demangling "lucid: __ct__8ifstreamFPCciT2" \
-	"ifstream::ifstream\[(\]+(const char|char const) \[*\]+, int, int\[)\]+"
-    test_demangling_exact "lucid: __ct__8ifstreamFiPcT1" "ifstream::ifstream(int, char *, int)"
-
-    test_demangling_exact "lucid: __ct__Q23foo3barFv" "foo::bar::bar(void)"
-    test_demangling_exact "lucid: __ct__Q33foo3bar4bellFv" "foo::bar::bell::bell(void)"
-    test_demangling_exact "lucid: __dl__3fooSFPv" "foo::operator delete(void *) static"
-    test_demangling_exact "lucid: __dl__FPv" "operator delete(void *)"
-    test_demangling_exact "lucid: __dt__10istrstreamFv" "istrstream::~istrstream(void)"
-
-    test_demangling_exact "lucid: __dt__Q23foo3barFv" "foo::bar::~bar(void)"
-    test_demangling_exact "lucid: __dt__Q33foo3bar4bellFv" "foo::bar::bell::~bell(void)"
-    test_demangling_exact "lucid: __dv__3fooFR3foo" "foo::operator/(foo &)"
-    test_demangling_exact "lucid: __dv__F7complexT1" "operator/(complex, complex)"
-    test_demangling_exact "lucid: __eq__3fooFR3foo" "foo::operator==(foo &)"
-    test_demangling_exact "lucid: __er__3fooFR3foo" "foo::operator^(foo &)"
-    test_demangling_exact "lucid: __ge__3fooFR3foo" "foo::operator>=(foo &)"
-    test_demangling_exact "lucid: __gt__3fooFR3foo" "foo::operator>(foo &)"
-    test_demangling_exact "lucid: __le__3fooFR3foo" "foo::operator<=(foo &)"
-    test_demangling_exact "lucid: __ls__3fooFR3foo" "foo::operator<<(foo &)"
-    test_demangling_exact "lucid: __ls__7ostreamFP9streambuf" "ostream::operator<<(streambuf *)"
-
-    test_demangling "lucid: __ls__7ostreamFPCc" \
-	"ostream::operator<<\[(\]+(const char|char const) \[*\]+\[)\]+"
-    test_demangling_exact "lucid: __ls__7ostreamFPFR3ios_R3ios" "ostream::operator<<(ios &(*)(ios &))"
-    test_demangling_exact "lucid: __ls__7ostreamFPv" "ostream::operator<<(void *)"
-    test_demangling_exact "lucid: __ls__7ostreamFUi" "ostream::operator<<(unsigned int)"
-    test_demangling_exact "lucid: __ls__7ostreamFUl" "ostream::operator<<(unsigned long)"
-    test_demangling_exact "lucid: __ls__7ostreamFd" "ostream::operator<<(double)"
-    test_demangling_exact "lucid: __ls__7ostreamFf" "ostream::operator<<(float)"
-    test_demangling_exact "lucid: __ls__7ostreamFi" "ostream::operator<<(int)"
-    test_demangling_exact "lucid: __ls__7ostreamFl" "ostream::operator<<(long)"
-    test_demangling_exact "lucid: __ls__FR7ostream7complex" "operator<<(ostream &, complex)"
-    test_demangling_exact "lucid: __lt__3fooFR3foo" "foo::operator<(foo &)"
-    test_demangling_exact "lucid: __md__3fooFR3foo" "foo::operator%(foo &)"
-    test_demangling_exact "lucid: __mi__3fooFR3foo" "foo::operator-(foo &)"
-    test_demangling_exact "lucid: __ml__3fooFR3foo" "foo::operator*(foo &)"
-    test_demangling_exact "lucid: __ml__F7complexT1" "operator*(complex, complex)"
-    test_demangling_exact "lucid: __mm__3fooFi" "foo::operator--(int)"
-    test_demangling_exact "lucid: __ne__3fooFR3foo" "foo::operator!=(foo &)"
-    test_demangling_exact "lucid: __nt__3fooFv" "foo::operator!(void)"
-    test_demangling_exact "lucid: __nw__3fooSFi" "foo::operator new(int) static"
-    test_demangling_exact "lucid: __nw__FUi" "operator new(unsigned int)"
-    test_demangling_exact "lucid: __nw__FUiPv" "operator new(unsigned int, void *)"
-    test_demangling_exact "lucid: __oo__3fooFR3foo" "foo::operator||(foo &)"
-    test_demangling_exact "lucid: __opPc__3fooFv" "foo::operator char *(void)"
-    test_demangling_exact "lucid: __opi__3fooFv" "foo::operator int(void)"
-    test_demangling_exact "lucid: __or__3fooFR3foo" "foo::operator|(foo &)"
-
-    test_demangling_exact "lucid: __pl__3fooFR3foo" "foo::operator+(foo &)"
-    test_demangling_exact "lucid: __pp__3fooFi" "foo::operator++(int)"
-    test_demangling_exact "lucid: __pt__3fooFv" "foo::operator->(void)"
-    test_demangling_exact "lucid: __rm__3fooFR3foo" "foo::operator->*(foo &)"
-    test_demangling_exact "lucid: __rs__3fooFR3foo" "foo::operator>>(foo &)"
-    test_demangling_exact "lucid: __rs__7istreamFP9streambuf" "istream::operator>>(streambuf *)"
-    test_demangling_exact "lucid: __rs__7istreamFPFR3ios_R3ios" "istream::operator>>(ios &(*)(ios &))"
-    test_demangling_exact "lucid: __rs__7istreamFPFR7istream_R7istream" "istream::operator>>(istream &(*)(istream &))"
-    test_demangling_exact "lucid: __rs__7istreamFPUc" "istream::operator>>(unsigned char *)"
-    test_demangling_exact "lucid: __rs__7istreamFPc" "istream::operator>>(char *)"
-    test_demangling_exact "lucid: __rs__7istreamFRUi" "istream::operator>>(unsigned int &)"
-    test_demangling_exact "lucid: __rs__7istreamFRUl" "istream::operator>>(unsigned long &)"
-    test_demangling_exact "lucid: __rs__7istreamFRUs" "istream::operator>>(unsigned short &)"
-    test_demangling_exact "lucid: __rs__7istreamFRd" "istream::operator>>(double &)"
-    test_demangling_exact "lucid: __rs__7istreamFRf" "istream::operator>>(float &)"
-    test_demangling_exact "lucid: __rs__7istreamFRi" "istream::operator>>(int &)"
-    test_demangling_exact "lucid: __rs__7istreamFRl" "istream::operator>>(long &)"
-    test_demangling_exact "lucid: __rs__7istreamFRs" "istream::operator>>(short &)"
-    test_demangling_exact "lucid: __rs__FR7istreamR7complex" "operator>>(istream &, complex &)"
-    test_demangling "lucid: __vc__3fooFR3foo" "foo::operator\\\[\\\]\\(foo &\\)"
-    test_demangling_exact "lucid: __vtbl__10istrstream" "istrstream virtual table"
-    test_demangling_exact "lucid: __vtbl__17ostream__iostream__19iostream_withassign" "iostream_withassign::ostream__iostream virtual table"
-
-    test_demangling_exact "lucid: __vtbl__3ios" "ios virtual table"
-    test_demangling_exact "lucid: __vtbl__3ios__13strstreambase" "strstreambase::ios virtual table"
-
-    # GDB 930414 demangles this as t_cc_main_ (obviously wrong).
-    # GDB 930701 gets into an infinite loop.
-    # GDB 930727 says "Can't demangle".
-    # What is the correct demangling?  FIXME.
-
-    # NOTE: carlton/2003-01-17: No, don't FIXME, just obsolete lucid.
-    # I'm KFAILing this rather than deleting it for form's sake.
-    setup_kfail "gdb/945" "*-*-*"
-    test_demangling_exact "lucid: __vtbl__3foo__vt_cc_main_" ""
-
-    test_demangling_exact "lucid: abs__F7complex" "abs(complex)"
-    test_demangling_exact "lucid: allocate__9streambufFv" "streambuf::allocate(void)"
-    test_demangling_exact "lucid: attach__11fstreambaseFi" "fstreambase::attach(int)"
-    test_demangling_exact "lucid: bitalloc__3iosSFv" "ios::bitalloc(void) static"
-    test_demangling_exact "lucid: chr__FiT1" "chr(int, int)"
-    test_demangling_exact "lucid: complex_error__FR11c_exception" "complex_error(c_exception &)"
-    test_demangling_exact "lucid: complexfunc2__FPFPc_i" "complexfunc2(int (*)(char *))"
-    test_demangling_exact "lucid: complexfunc3__FPFPFPl_s_i" "complexfunc3(int (*)(short (*)(long *)))"
-
-    test_demangling_exact "lucid: complexfunc4__FPFPFPc_s_i" "complexfunc4(int (*)(short (*)(char *)))"
-    test_demangling_exact "lucid: complexfunc5__FPFPc_PFl_i" "complexfunc5(int (*(*)(char *))(long))"
-    test_demangling_exact "lucid: complexfunc6__FPFPi_PFl_i" "complexfunc6(int (*(*)(int *))(long))"
-    test_demangling_exact "lucid: complexfunc7__FPFPFPc_i_PFl_i" "complexfunc7(int (*(*)(int (*)(char *)))(long))"
-    test_demangling_exact "lucid: complicated_put__7ostreamFc" "ostream::complicated_put(char)"
-    test_demangling_exact "lucid: conv10__FlPc" "conv10(long, char *)"
-    test_demangling_exact "lucid: conv16__FUlPc" "conv16(unsigned long, char *)"
-    test_demangling_exact "lucid: dec__FR3ios" "dec(ios &)"
-    test_demangling_exact "lucid: dec__Fli" "dec(long, int)"
-    test_demangling_exact "lucid: dofield__FP7ostreamPciT2T3" "dofield(ostream *, char *, int, char *, int)"
-
-    test_demangling_exact "lucid: flags__3iosFl" "ios::flags(long)"
-    test_demangling_exact "lucid: flags__3iosFv" "ios::flags(void)"
-    test_demangling_exact "lucid: foo__FiN31" "foo(int, int, int, int)"
-    test_demangling_exact "lucid: foo__FiR3fooT1T2T1T2" "foo(int, foo &, int, foo &, int, foo &)"
-    test_demangling_exact "lucid: foo___3barFl" "bar::foo_(long)"
-    test_demangling "lucid: form__FPCce" "form\[(\]+(const char|char const) \[*\]+,...\[)\]+"
-    test_demangling_exact "lucid: get__7istreamFPcic" "istream::get(char *, int, char)"
-    test_demangling_exact "lucid: get__7istreamFR9streambufc" "istream::get(streambuf &, char)"
-    test_demangling_exact "lucid: get_complicated__7istreamFRUc" "istream::get_complicated(unsigned char &)"
-    test_demangling_exact "lucid: get_complicated__7istreamFRc" "istream::get_complicated(char &)"
-    test_demangling_exact "lucid: getline__7istreamFPUcic" "istream::getline(unsigned char *, int, char)"
-    test_demangling_exact "lucid: getline__7istreamFPcic" "istream::getline(char *, int, char)"
-
-    test_demangling_exact "lucid: ignore__7istreamFiT1" "istream::ignore(int, int)"
-    test_demangling_exact "lucid: init__12strstreambufFPciT1" "strstreambuf::init(char *, int, char *)"
-    test_demangling_exact "lucid: init__3iosFP9streambuf" "ios::init(streambuf *)"
-    test_demangling_exact "lucid: initcount__13Iostream_init" "Iostream_init::initcount"
-    test_demangling_exact "lucid: ipfx__7istreamFi" "istream::ipfx(int)"
-    test_demangling_exact "lucid: ls_complicated__7ostreamFUc" "ostream::ls_complicated(unsigned char)"
-    test_demangling_exact "lucid: ls_complicated__7ostreamFc" "ostream::ls_complicated(char)"
-    test_demangling "lucid: open__11fstreambaseFPCciT2" \
-	"fstreambase::open\[(\]+(const char|char const) \[*\]+, int, int\[)\]+"
-    test_demangling "lucid: open__7filebufFPCciT2" \
-	"filebuf::open\[(\]+(const char|char const) \[*\]+, int, int\[)\]+"
-
-    test_demangling_exact "lucid: overload1arg__FSc" "overload1arg(signed char)"
-    test_demangling_exact "lucid: overload1arg__FUc" "overload1arg(unsigned char)"
-    test_demangling_exact "lucid: overload1arg__FUi" "overload1arg(unsigned int)"
-    test_demangling_exact "lucid: overload1arg__FUl" "overload1arg(unsigned long)"
-    test_demangling_exact "lucid: overload1arg__FUs" "overload1arg(unsigned short)"
-    test_demangling_exact "lucid: overload1arg__Fc" "overload1arg(char)"
-    test_demangling_exact "lucid: overload1arg__Fd" "overload1arg(double)"
-    test_demangling_exact "lucid: overload1arg__Ff" "overload1arg(float)"
-    test_demangling_exact "lucid: overload1arg__Fi" "overload1arg(int)"
-    test_demangling_exact "lucid: overload1arg__Fl" "overload1arg(long)"
-    test_demangling_exact "lucid: overload1arg__Fs" "overload1arg(short)"
-    test_demangling_exact "lucid: overload1arg__Fv" "overload1arg(void)"
-    test_demangling_exact "lucid: overloadargs__FiN21" "overloadargs(int, int, int)"
-    test_demangling_exact "lucid: overloadargs__FiN31" "overloadargs(int, int, int, int)"
-    test_demangling_exact "lucid: overloadargs__FiN41" "overloadargs(int, int, int, int, int)"
-    test_demangling_exact "lucid: overloadargs__FiN51" "overloadargs(int, int, int, int, int, int)"
-    test_demangling_exact "lucid: overloadargs__FiN61" "overloadargs(int, int, int, int, int, int, int)"
-
-    test_demangling_exact "lucid: overloadargs__FiN71" "overloadargs(int, int, int, int, int, int, int, int)"
-    test_demangling_exact "lucid: overloadargs__FiN81" "overloadargs(int, int, int, int, int, int, int, int, int)"
-    test_demangling_exact "lucid: overloadargs__FiN91" "overloadargs(int, int, int, int, int, int, int, int, int, int)"
-    test_demangling_exact "lucid: overloadargs__FiN91N11" "overloadargs(int, int, int, int, int, int, int, int, int, int, int)"
-    test_demangling_exact "lucid: overloadargs__FiT1" "overloadargs(int, int)"
-    test_demangling_exact "lucid: polar__FdT1" "polar(double, double)"
-    test_demangling_exact "lucid: pow__F7complexT1" "pow(complex, complex)"
-    test_demangling_exact "lucid: pow__F7complexd" "pow(complex, double)"
-    test_demangling_exact "lucid: pow__F7complexi" "pow(complex, int)"
-    test_demangling_exact "lucid: pow__Fd7complex" "pow(double, complex)"
-    test_demangling_exact "lucid: pstart__FPciT2" "pstart(char *, int, int)"
-    test_demangling_exact "lucid: put__7ostreamFc" "ostream::put(char)"
-
-    test_demangling_exact "lucid: read__7istreamFPci" "istream::read(char *, int)"
-    test_demangling_exact "lucid: resetiosflags__FR3iosl" "resetiosflags(ios &, long)"
-    test_demangling_exact "lucid: restore_errno__FRi" "restore_errno(int &)"
-    test_demangling_exact "lucid: rs_complicated__7istreamFRUc" "istream::rs_complicated(unsigned char &)"
-    test_demangling_exact "lucid: rs_complicated__7istreamFRc" "istream::rs_complicated(char &)"
-    test_demangling_exact "lucid: seekg__7istreamFl8seek_dir" "istream::seekg(long, seek_dir)"
-    test_demangling_exact "lucid: seekoff__12strstreambufFl8seek_diri" "strstreambuf::seekoff(long, seek_dir, int)"
-    test_demangling_exact "lucid: seekoff__9streambufFlQ2_3ios12ios_seek_diri" "streambuf::seekoff(long, ios::ios_seek_dir, int)"
-    test_demangling_exact "lucid: seekpos__9streambufFli" "streambuf::seekpos(long, int)"
-    test_demangling_exact "lucid: set_new_handler__FPFv_v" "set_new_handler(void (*)(void))"
-    test_demangling_exact "lucid: setb__9streambufFPcT1i" "streambuf::setb(char *, char *, int)"
-
-    test_demangling_exact "lucid: setb__FR3iosi" "setb(ios &, int)"
-    test_demangling_exact "lucid: setbuf__11fstreambaseFPci" "fstreambase::setbuf(char *, int)"
-    test_demangling_exact "lucid: setbuf__9streambufFPUci" "streambuf::setbuf(unsigned char *, int)"
-    test_demangling_exact "lucid: setbuf__9streambufFPciT2" "streambuf::setbuf(char *, int, int)"
-    test_demangling_exact "lucid: setf__3iosFlT1" "ios::setf(long, long)"
-    test_demangling_exact "lucid: setfill__FR3iosi" "setfill(ios &, int)"
-    test_demangling_exact "lucid: setg__9streambufFPcN21" "streambuf::setg(char *, char *, char *)"
-    test_demangling_exact "lucid: setp__9streambufFPcT1" "streambuf::setp(char *, char *)"
-
-    test_demangling "lucid: sputn__9streambufFPCci" \
-	"streambuf::sputn\[(\]+(const char|char const) \[*\]+, int\[)\]+"
-    test_demangling "lucid: str__FPCci" \
-	"str\[(\]+(const char|char const) \[*\]+, int\[)\]+"
-    test_demangling_exact "lucid: tie__3iosFP7ostream" "ios::tie(ostream *)"
-    test_demangling_exact "lucid: uconv10__FUlPc" "uconv10(unsigned long, char *)"
-
-    test_demangling "lucid: write__7ostreamFPCci" \
-	"ostream::write\[(\]+(const char|char const) \[*\]+, int\[)\]+"
-    test_demangling_exact "lucid: xget__7istreamFPc" "istream::xget(char *)"
-    test_demangling_exact "lucid: xsgetn__9streambufFPci" "streambuf::xsgetn(char *, int)"
-    test_demangling "lucid: xsputn__9streambufFPCci" \
-	"streambuf::xsputn\[(\]+(const char|char const) \[*\]+, int\[)\]+"
-
-    test_demangling_exact "lucid: _Utf390_1__1_9223372036854775807__9223372036854775" \
-	    "Can't demangle \"_Utf390_1__1_9223372036854775807__9223372036854775\""
 }
 
-#
-#  Test arm style name demangling
-#
-
-proc test_arm_style_demangling {} {
-    test_demangling_exact "arm: __dt__21T5__pt__11_PFiPPdPv_iFv" "T5<int (*)(int, double **, void *)>::~T5(void)"
-
-    test_demangling_exact "arm: __ct__1cFi" "c::c(int)"
-
-    test_demangling_exact "arm: __dt__11T5__pt__2_iFv" "T5<int>::~T5(void)"
-
-    test_demangling_exact "arm: __dt__11T5__pt__2_cFv" "T5<char>::~T5(void)"
-
-    test_demangling_exact "arm: __ct__2T2Fi" "T2::T2(int)"
-    test_demangling_exact "arm: __dt__2T1Fv" "T1::~T1(void)"
-
-    test_demangling_exact "arm: __dt__12T5__pt__3_1xFv" "T5<x>::~T5(void)"
-
-    test_demangling_exact "arm: __dt__17T5__pt__8_PFcPv_iFv" "T5<int (*)(char, void *)>::~T5(void)"
-
-    test_demangling "arm: g__FP1cPC1cT1" \
-	"g\[(\]+c *\[*\]+, (const c|c const) *\[*\]+, c *\[*\]+\[)\]+"
-    test_demangling "arm: g__FPUlPCUlT1" \
-	"g\[(\]+unsigned long \[*\]+, (const unsigned long|unsigned long const) \[*\]+, unsigned long \[*\]+\[)\]+"
-    test_demangling "arm: g__FPUiPCUiT1" \
-	"g\[(\]+unsigned int \[*\]+, (const unsigned int|unsigned int const) \[*\]+, unsigned int \[*\]+\[)\]+"
-    test_demangling "arm: g__FPUsPCUsT1" \
-	"g\[(\]+unsigned short \[*\]+, (const unsigned short|unsigned short const) \[*\]+, unsigned short \[*\]+\[)\]+"
-    test_demangling "arm: g__FPUcPCUcT1" \
-	"g\[(\]+unsigned char \[*\]+, (const unsigned char|unsigned char const) \[*\]+, unsigned char \[*\]+\[)\]+"
-    test_demangling "arm: g__F1TPlPClT2" \
-	"g\[(\]+T, long \[*\]+, (const long|long const) \[*\]+, long \[*\]+\[)\]+"
-    test_demangling "arm: g__F1RRlRClT2" \
-	"g\[(\]+R, long &, (const long|long const) &, long &\[)\]+"
-    test_demangling "arm: g__F1TPiPCiT2" \
-	"g\[(\]+T, int \[*\]+, (const int|int const) \[*\]+, int \[*\]+\[)\]+"
-    test_demangling "arm: g__F1RRiRCiT2" \
-	"g\[(\]+R, int &, (const int|int const) &, int &\[)\]+"
-    test_demangling "arm: g__F1TPsPCsT2" \
-	"g\[(\]+T, short \[*\]+, (const short|short const) \[*\]+, short \[*\]+\[)\]+"
-    test_demangling "arm: g__F1RRsRCsT2" \
-	"g\[(\]+R, short &, (const short|short const) &, short &\[)\]+"
-    test_demangling "arm: g__F1TPcPCcT2" \
-	"g\[(\]+T, char \[*\]+, (const char|char const) \[*\]+, char \[*\]+\[)\]+"
-    test_demangling "arm: g__F1RRcRCcT2" \
-	"g\[(\]+R, char &, (const char|char const) &, char &\[)\]+"
-
-    test_demangling_exact "arm: __ct__21T5__pt__11_PFiPPdPv_iFi" "T5<int (*)(int, double **, void *)>::T5(int)"
-
-    test_demangling "arm: __gt__FRC2T2c" \
-	"operator>\[(\]+(const T2|T2 const) &, char\[)\]+"
-    test_demangling "arm: __ge__FRC2T2c" \
-	"operator>=\[(\]+(const T2|T2 const) &, char\[)\]+"
-    test_demangling "arm: __lt__FRC2T2c" \
-	"operator<\[(\]+(const T2|T2 const) &, char\[)\]+"
-
-    test_demangling "arm: __le__FRC2T2c" \
-	"operator<=\[(\]+(const T2|T2 const) &, char\[)\]+"
-    test_demangling "arm: __ne__FRC2T2c" \
-	"operator!=\[(\]+(const T2|T2 const) &, char\[)\]+"
-    test_demangling "arm: __eq__FRC2T2c" \
-	"operator==\[(\]+(const T2|T2 const) &, char\[)\]+"
-    test_demangling_exact "arm: __amd__FR2T2i" "operator%=(T2 &, int)"
-    test_demangling_exact "arm: __adv__FR2T2i" "operator/=(T2 &, int)"
-    test_demangling_exact "arm: __amu__FR2T2i" "operator*=(T2 &, int)"
-    test_demangling_exact "arm: __ami__FR2T2i" "operator-=(T2 &, int)"
-    test_demangling_exact "arm: __apl__FR2T2i" "operator+=(T2 &, int)"
-    test_demangling_exact "arm: __nw__2T1SFUi" "T1::operator new(unsigned int) static"
-    test_demangling_exact "arm: __dl__2T1SFPv" "T1::operator delete(void *) static"
-    test_demangling_exact "arm: put__2T7SFi" "T7::put(int) static"
-
-    test_demangling_exact "arm: __dl__12T5__pt__3_1xSFPv" "T5<x>::operator delete(void *) static"
-
-    test_demangling_exact "arm: h__FUc" "h(unsigned char)"
-    test_demangling_exact "arm: f__Fic" "f(int, char)"
-    test_demangling_exact "arm: h__FUi" "h(unsigned int)"
-    test_demangling_exact "arm: h__Fci" "h(char, int)"
-    test_demangling_exact "arm: h__FUl" "h(unsigned long)"
-    test_demangling_exact "arm: h__Fcl" "h(char, long)"
-    test_demangling_exact "arm: h__FUs" "h(unsigned short)"
-    test_demangling_exact "arm: h__Fcs" "h(char, short)"
-    test_demangling "arm: __amd__FR2T2RC2T2" \
-	"operator%=\[(\]+T2 &, (const T2|T2 const) &\[)\]+"
-    test_demangling "arm: __adv__FR2T2RC2T2" \
-	"operator/=\[(\]+T2 &, (const T2|T2 const) &\[)\]+"
-    test_demangling "arm: __amu__FR2T2RC2T2" \
-	"operator\[*\]+=\[(\]+T2 &, (const T2|T2 const) &\[)\]+"
-    test_demangling "arm: __ami__FR2T2RC2T2" \
-	"operator-=\[(\]+T2 &, (const T2|T2 const) &\[)\]+"
-    test_demangling "arm: __apl__FR2T2RC2T2" \
-	"operator\[+\]+=\[(\]+T2 &, (const T2|T2 const) &\[)\]+"
-
-    test_demangling "arm: g__F1SRPUlRPCUlT2" \
-	"g\[(\]+S, unsigned long \[*\]+&, (const unsigned long|unsigned long const) \[*\]+&, unsigned long \[*\]+&\[)\]+"
-    test_demangling "arm: g__F1SRPUiRPCUiT2" \
-	"g\[(\]+S, unsigned int \[*\]+&, (const unsigned int|unsigned int const) \[*\]+&, unsigned int \[*\]+&\[)\]+"
-    test_demangling "arm: g__F1SRPUsRPCUsT2" \
-	"g\[(\]+S, unsigned short \[*\]+&, (const unsigned short|unsigned short const) \[*\]+&, unsigned short \[*\]+&\[)\]+"
-    test_demangling "arm: g__F1SRPUcRPCUcT2" \
-	"g\[(\]+S, unsigned char \[*\]+&, (const unsigned char|unsigned char const) \[*\]+&, unsigned char \[*\]+&\[)\]+"
-    test_demangling "arm: g__F1T1SRPlRPClT3" \
-	"g\[(\]+T, S, long \[*\]+&, (const long|long const) \[*\]+&, long \[*\]+&\[)\]+"
-    test_demangling "arm: g__F1T1SRPiRPCiT3" \
-	"g\[(\]+T, S, int \[*\]+&, (const int|int const) \[*\]+&, int \[*\]+&\[)\]+"
-    test_demangling "arm: g__F1T1SRPcRPCcT3" \
-	"g\[(\]+T, S, char \[*\]+&, (const char|char const) \[*\]+&, char \[*\]+&\[)\]+"
-
-    test_demangling_exact "arm: X__12T5__pt__3_1x" "T5<x>::X"
-
-    test_demangling_exact "arm: __ct__11T5__pt__2_iFi" "T5<int>::T5(int)"
-
-    test_demangling_exact "arm: __ct__11T5__pt__2_cFi" "T5<char>::T5(int)"
-
-    test_demangling "arm: __gt__FRC2T2T1" \
-	"operator>\[(\]+(const T2|T2 const) &, (const T2|T2 const) &\[)\]+"
-    test_demangling "arm: __ge__FRC2T2T1" \
-	"operator>=\[(\]+(const T2|T2 const) &, (const T2|T2 const) &\[)\]+"
-    test_demangling "arm: __lt__FRC2T2T1" \
-	"operator<\[(\]+(const T2|T2 const) &, (const T2|T2 const) &\[)\]+"
-    test_demangling "arm: __le__FRC2T2T1" \
-	"operator<=\[(\]+(const T2|T2 const) &, (const T2|T2 const) &\[)\]+"
-    test_demangling "arm: __ne__FRC2T2T1" \
-	"operator!=\[(\]+(const T2|T2 const) &, (const T2|T2 const) &\[)\]+"
-    test_demangling "arm: __eq__FRC2T2T1" \
-	"operator==\[(\]+(const T2|T2 const) &, (const T2|T2 const) &\[)\]+"
-    test_demangling "arm: g__FcR1cRC1cT2" \
-	"g\[(\]+char, c &, (const c|c const) &, c &\[)\]+"
-    test_demangling "arm: g__FcRPdRPCdT2" \
-	"g\[(\]+char, double *\[*\]+&, (const double|double const) *\[*\]+&, double *\[*\]+&\[)\]+"
-    test_demangling "arm: g__FcRPfRPCfT2" \
-	"g\[(\]+char, float *\[*\]+&, (const float|float const) *\[*\]+&, float *\[*\]+&\[)\]+"
-    test_demangling_exact "arm: h__FcT1" "h(char, char)"
-    test_demangling_exact "arm: f__Ficd" "f(int, char, double)"
-    test_demangling "arm: g__F1T1SdRPsRPCsT4" \
-	"g\[(\]+T, S, double, short \[*\]+&, (const short|short const) \[*\]+&, short \[*\]+&\[)\]+"
-    test_demangling "arm: g__F1cC1cT1" \
-	"g\[(\]+c, (const c|c const), c\[)\]+"
-    test_demangling "arm: g__FPdPCdT1" \
-	"g\[(\]+double *\[*\]+, (const double|double const) *\[*\]+, double *\[*\]+\[)\]+"
-    test_demangling "arm: g__FPfPCfT1" \
-	"g\[(\]+float *\[*\]+, (const float|float const) *\[*\]+, float *\[*\]+\[)\]+"
-
-    test_demangling "arm: g__FUlCUlT1" \
-	"g\[(\]+unsigned long, (const unsigned long|unsigned long const), unsigned long\[)\]+"
-    test_demangling "arm: g__FPlPClT1" \
-	"g\[(\]+long \[*\]+, (const long|long const) \[*\]+, long \[*\]+\[)\]+"
-    test_demangling "arm: g__FUiCUiT1" \
-	"g\[(\]+unsigned int, (const unsigned int|unsigned int const), unsigned int\[)\]+"
-    test_demangling "arm: g__FPiPCiT1" \
-	"g\[(\]+int \[*\]+, (const int|int const) \[*\]+, int \[*\]+\[)\]+"
-    test_demangling "arm: g__FUsCUsT1" \
-	"g\[(\]+unsigned short, (const unsigned short|unsigned short const), unsigned short\[)\]+"
-    test_demangling "arm: g__FPsPCsT1" \
-	"g\[(\]+short \[*\]+, (const short|short const) \[*\]+, short \[*\]+\[)\]+"
-    test_demangling "arm: g__FUcCUcT1" \
-	"g\[(\]+unsigned char, (const unsigned char|unsigned char const), unsigned char\[)\]+"
-    test_demangling "arm: g__FPcPCcT1" \
-	"g\[(\]+char \[*\]+, (const char|char const) \[*\]+, char \[*\]+\[)\]+"
-    test_demangling "arm: g__F1TlClT2" \
-	"g\[(\]+T, long, (const long|long const), long\[)\]+"
-    test_demangling "arm: g__F1TiCiT2" \
-	"g\[(\]+T, int, (const int|int const), int\[)\]+"
-    test_demangling "arm: g__F1TsCsT2" \
-	"g\[(\]+T, short, (const short|short const), short\[)\]+"
-    test_demangling "arm: g__F1TcCcT2" \
-	"g\[(\]+T, char, (const char|char const), char\[)\]+"
-
-    test_demangling_exact "arm: __dl__17T5__pt__8_PFcPv_iSFPv" "T5<int (*)(char, void *)>::operator delete(void *) static"
-
-    test_demangling "arm: printf__FPCce" \
-	"printf\[(\]+(const char|char const) \[*\]+,...\[)\]+"
-
-    test_demangling_exact "arm: X__17T5__pt__8_PFcPv_i" "T5<int (*)(char, void *)>::X"
-
-    test_demangling_exact "arm: __ct__12T5__pt__3_1xFi" "T5<x>::T5(int)"
-
-    test_demangling "arm: g__F1SRUlRCUlT2" \
-	"g\[(\]+S, unsigned long &, (const unsigned long|unsigned long const) &, unsigned long &\[)\]+"
-    test_demangling "arm: g__F1SRPlRPClT2" \
-	"g\[(\]+S, long \[*\]+&, (const long|long const) \[*\]+&, long \[*\]+&\[)\]+"
-    test_demangling "arm: g__F1RRUiRCUiT2" \
-	"g\[(\]+R, unsigned int &, (const unsigned int|unsigned int const) &, unsigned int &\[)\]+"
-    test_demangling "arm: g__F1SRPiRPCiT2" \
-	"g\[(\]+S, int \[*\]+&, (const int|int const) \[*\]+&, int \[*\]+&\[)\]+"
-    test_demangling "arm: g__F1RRUsRCUsT2" \
-	"g\[(\]+R, unsigned short &, (const unsigned short|unsigned short const) &, unsigned short &\[)\]+"
-    test_demangling "arm: g__F1SRPsRPCsT2" \
-	"g\[(\]+S, short \[*\]+&, (const short|short const) \[*\]+&, short \[*\]+&\[)\]+"
-    test_demangling "arm: g__F1RRUcRCUcT2" \
-	"g\[(\]+R, unsigned char &, (const unsigned char|unsigned char const) &, unsigned char &\[)\]+"
-    test_demangling "arm: g__F1SRPcRPCcT2" \
-	"g\[(\]+S, char \[*\]+&, (const char|char const) \[*\]+&, char \[*\]+&\[)\]+"
-    test_demangling "arm: g__F1T1RRlRClT3" \
-	"g\[(\]+T, R, long &, (const long|long const) &, long &\[)\]+"
-    test_demangling "arm: g__F1T1RRiRCiT3" \
-	"g\[(\]+T, R, int &, (const int|int const) &, int &\[)\]+"
-    test_demangling "arm: g__F1T1RRsRCsT3" \
-	"g\[(\]+T, R, short &, (const short|short const) &, short &\[)\]+"
-    test_demangling "arm: g__F1T1RRcRCcT3" \
-	"g\[(\]+T, R, char &, (const char|char const) &, char &\[)\]+"
-
-    test_demangling_exact "arm: __dl__21T5__pt__11_PFiPPdPv_iSFPv" "T5<int (*)(int, double **, void *)>::operator delete(void *) static"
-
-    test_demangling_exact "arm: __std__foo" "global destructors keyed to foo"
-
-    test_demangling_exact "arm: __sti__bar" "global constructors keyed to bar"
-
-    test_demangling_exact "arm: f__FicdPcPFci_v" "f(int, char, double, char *, void (*)(char, int))"
-    test_demangling_exact "arm: f__FicdPcPFic_v" "f(int, char, double, char *, void (*)(int, char))"
-    test_demangling_exact "arm: get__2T7SFv" "T7::get(void) static"
-
-    test_demangling_exact "arm: X__21T5__pt__11_PFiPPdPv_i" "T5<int (*)(int, double **, void *)>::X"
-
-    test_demangling "arm: g__FcRdRCdT2" \
-	"g\[(\]+char, double &, (const double|double const) &, double &\[)\]+"
-    test_demangling "arm: g__FcRfRCfT2" \
-	"g\[(\]+char, float &, (const float|float const) &, float &\[)\]+"
-    test_demangling "arm: __md__FC2T2i" \
-	"operator%\[(\]+(const T2|T2 const), int\[)\]+"
-    test_demangling "arm: __dv__FC2T2i" \
-	"operator/\[(\]+(const T2|T2 const), int\[)\]+"
-    test_demangling "arm: __ml__FC2T2i" \
-	"operator\[*\]+\[(\]+(const T2|T2 const), int\[)\]+"
-    test_demangling "arm: __mi__FC2T2i" \
-	"operator-\[(\]+(const T2|T2 const), int\[)\]+"
-    test_demangling "arm: __pl__FC2T2i" \
-	"operator\[+\]+\[(\]+(const T2|T2 const), int\[)\]+"
-
-    test_demangling_exact "arm: __dl__11T5__pt__2_iSFPv" "T5<int>::operator delete(void *) static"
-
-    test_demangling_exact "arm: __dl__11T5__pt__2_cSFPv" "T5<char>::operator delete(void *) static"
-
-    test_demangling_exact "arm: h__Fc" "h(char)"
-    test_demangling_exact "arm: h__Fd" "h(double)"
-    test_demangling_exact "arm: h__Ff" "h(float)"
-    test_demangling_exact "arm: h__Fi" "h(int)"
-    test_demangling_exact "arm: f__Fi" "f(int)"
-    test_demangling_exact "arm: h__Fl" "h(long)"
-
-    test_demangling_exact "arm: h__Fs" "h(short)"
-    test_demangling "arm: __md__FC2T2RC2T2" \
-	"operator%\[(\]+(const T2|T2 const), (const T2|T2 const) &\[)\]+"
-    test_demangling "arm: __dv__FC2T2RC2T2" \
-	"operator/\[(\]+(const T2|T2 const), (const T2|T2 const) &\[)\]+"
-    test_demangling "arm: __ml__FC2T2RC2T2" \
-	"operator\[*\]+\[(\]+(const T2|T2 const), (const T2|T2 const) &\[)\]+"
-    test_demangling "arm: __mi__FC2T2RC2T2" \
-	"operator-\[(\]+(const T2|T2 const), (const T2|T2 const) &\[)\]+"
-    test_demangling "arm: __pl__FC2T2RC2T2" \
-	"operator\[+\]+\[(\]+(const T2|T2 const), (const T2|T2 const) &\[)\]+"
-    test_demangling "arm: g__FcRP1cRPC1cT2" \
-	"g\[(\]+char, c *\[*\]+&, (const c|c const) *\[*\]+&, c *\[*\]+&\[)\]+"
-
-    test_demangling_exact "arm: X__11T5__pt__2_c" "T5<char>::X"
-
-    test_demangling_exact "arm: X__11T5__pt__2_i" "T5<int>::X"
-
-    test_demangling "arm: g__FdCdT1" \
-	"g\[(\]+double, (const double|double const), double\[)\]+"
-    test_demangling "arm: g__FfCfT1" \
-	"g\[(\]+float, (const float|float const), float\[)\]+"
-    test_demangling "arm: g__FlClT1" \
-	"g\[(\]+long, (const long|long const), long\[)\]+"
-    test_demangling "arm: g__FiCiT1" \
-	"g\[(\]+int, (const int|int const), int\[)\]+"
-    test_demangling "arm: g__FsCsT1" \
-	"g\[(\]+short, (const short|short const), short\[)\]+"
-    test_demangling "arm: g__FcCcT1" \
-	"g\[(\]+char, (const char|char const), char\[)\]+"
-
-    test_demangling_exact "arm: __ct__17T5__pt__8_PFcPv_iFi" "T5<int (*)(char, void *)>::T5(int)"
-
-    test_demangling_exact "arm: f__FicdPc" "f(int, char, double, char *)"
-    test_demangling_exact "arm: __nw__FUi" "operator new(unsigned int)"
-    test_demangling_exact "arm: __ct__Q3_2T11a1bSFi" "T1::a::b::b(int) static"
-    test_demangling_exact "arm: __dt__Q3_2T11a1bSFi" "T1::a::b::~b(int) static"
-    test_demangling_exact "arm: put__Q3_2T11a1bSFi" "T1::a::b::put(int) static"
-    test_demangling_exact "arm: get__Q2_2T11aSFv" "T1::a::get(void) static"
-    test_demangling_exact "arm: put__2T1SFi" "T1::put(int) static"
-    test_demangling_exact "arm: put__Q5_2T11a1b1c1dSFi" "T1::a::b::c::d::put(int) static"
-    test_demangling_exact "arm: get__Q4_2T11a1b1cSFv" "T1::a::b::c::get(void) static"
-    test_demangling_exact "arm: put__Q2_2T11aSFi" "T1::a::put(int) static"
-    test_demangling_exact "arm: put__Q4_2T11a1b1cSFi" "T1::a::b::c::put(int) static"
-    test_demangling_exact "arm: get__Q3_2T11a1bSFv" "T1::a::b::get(void) static"
-    test_demangling_exact "arm: get__2T1SFv" "T1::get(void) static"
-    test_demangling_exact "arm: get__Q5_2T11a1b1c1dSFv" "T1::a::b::c::d::get(void) static"
-
-    test_demangling_exact "arm: __dt__11T1__pt__2_cFv" "T1<char>::~T1(void)"
-
-    test_demangling_exact "arm: __dt__12T1__pt__3_1tFv" "T1<t>::~T1(void)"
-
-    test_demangling_exact "arm: __dl__12T1__pt__3_1tSFPv" "T1<t>::operator delete(void *) static"
-
-    test_demangling_exact "arm: __ct__11T1__pt__2_cFi" "T1<char>::T1(int)"
-
-    test_demangling_exact "arm: __ct__11T1__pt__2_cFv" "T1<char>::T1(void)"
-
-    test_demangling_exact "arm: __ct__12T1__pt__3_1tFi" "T1<t>::T1(int)"
-
-    test_demangling_exact "arm: __ct__12T1__pt__3_1tFv" "T1<t>::T1(void)"
-
-    test_demangling_exact "arm: __dl__11T1__pt__2_cSFPv" "T1<char>::operator delete(void *) static"
-
-    test_demangling_exact "arm: bar__3fooFPv"       "foo::bar(void *)"
-    test_demangling "arm: bar__3fooFPCv" \
-	     "foo::bar\[(\]+(const void|void const) *\[*\]+\[)\]+"
-    test_demangling_exact "arm: bar__3fooCFPv"      "foo::bar(void *) const"
-    test_demangling "arm: bar__3fooCFPCv" \
-	    "foo::bar\[(\]+(const void|void const) *\[*\]+\[)\]+ const"
-    test_demangling_exact "arm: __eq__3fooFR3foo"   "foo::operator==(foo &)"
-    test_demangling "arm: __eq__3fooFRC3foo" \
-	 "foo::operator==\[(\]+(const foo|foo const) &\[)\]+"
-    test_demangling_exact "arm: __eq__3fooCFR3foo"  "foo::operator==(foo &) const"
-    test_demangling "arm: __eq__3fooCFRC3foo" \
-	"foo::operator==\[(\]+(const foo|foo const) &\[)\]+ const"
-
-    test_demangling_exact "arm: elem__15vector__pt__2_dFi" "vector<double>::elem(int)"
-
-    test_demangling_exact "arm: elem__15vector__pt__2_iFi" "vector<int>::elem(int)"
-
-    test_demangling_exact "arm: __ct__15vector__pt__2_dFi" "vector<double>::vector(int)"
-
-    test_demangling_exact "arm: __ct__15vector__pt__2_iFi" "vector<int>::vector(int)"
-
-    test_demangling_exact "arm: __ct__25DListNode__pt__9_R6RLabelFR6RLabelP25DListNode__pt__9_R6RLabelT2" \
-	"DListNode<RLabel &>::DListNode(RLabel &, DListNode<RLabel &> *, DListNode<RLabel &> *)"
-
-    test_demangling_exact "arm: bar__3fooFiT16FooBar" "foo::bar(int, int, FooBar)"
-
-    test_demangling_exact "arm: bar__3fooFPiN51PdN37PcN211T1iN215" \
-      "foo::bar(int *, int *, int *, int *, int *, int *, double *, double *, double *, double *, char *, char *, char *, int *, int, int, int)"
-
-    test_demangling_exact "arm: _Utf390_1__1_9223372036854775807__9223372036854775" \
-	    "Can't demangle \"_Utf390_1__1_9223372036854775807__9223372036854775\""
-}
-
-proc test_hp_style_demangling {} {
-
-    # HP aCC mangling style is based on ARM for all the basic stuff,
-    # so first we use some of the ARM tests here.  Later we have HP-specific
-    # tests.
-        
-    test_demangling "hp: g__FP1cPC1cT1" \
-	"g\[(\]+c *\[*\]+, (const c|c const) *\[*\]+, c *\[*\]+\[)\]+"
-    test_demangling "hp: g__FPUlPCUlT1" \
-	"g\[(\]+unsigned long \[*\]+, (const unsigned long|unsigned long const) \[*\]+, unsigned long \[*\]+\[)\]+"
-    test_demangling "hp: g__FPUiPCUiT1" \
-	"g\[(\]+unsigned int \[*\]+, (const unsigned int|unsigned int const) \[*\]+, unsigned int \[*\]+\[)\]+"
-    test_demangling "hp: g__FPUsPCUsT1" \
-	"g\[(\]+unsigned short \[*\]+, (const unsigned short|unsigned short const) \[*\]+, unsigned short \[*\]+\[)\]+"
-    test_demangling "hp: g__FPUcPCUcT1" \
-	"g\[(\]+unsigned char \[*\]+, (const unsigned char|unsigned char const) \[*\]+, unsigned char \[*\]+\[)\]+"
-    test_demangling "hp: g__F1TPlPClT2" \
-	"g\[(\]+T, long \[*\]+, (const long|long const) \[*\]+, long \[*\]+\[)\]+"
-    test_demangling "hp: g__F1RRlRClT2" \
-	"g\[(\]+R, long &, (const long|long const) &, long &\[)\]+"
-    test_demangling "hp: g__F1TPiPCiT2" \
-	"g\[(\]+T, int \[*\]+, (const int|int const) \[*\]+, int \[*\]+\[)\]+"
-    test_demangling "hp: g__F1RRiRCiT2" \
-	"g\[(\]+R, int &, (const int|int const) &, int &\[)\]+"
-    test_demangling "hp: g__F1TPsPCsT2" \
-	"g\[(\]+T, short \[*\]+, (const short|short const) \[*\]+, short \[*\]+\[)\]+"
-    test_demangling "hp: g__F1RRsRCsT2" \
-	"g\[(\]+R, short &, (const short|short const) &, short &\[)\]+"
-    test_demangling "hp: g__F1TPcPCcT2" \
-	"g\[(\]+T, char \[*\]+, (const char|char const) \[*\]+, char \[*\]+\[)\]+"
-    test_demangling "hp: g__F1RRcRCcT2" \
-	"g\[(\]+R, char &, (const char|char const) &, char &\[)\]+"
-
-    test_demangling "hp: __gt__FRC2T2c" \
-	"operator>\[(\]+(const T2|T2 const) &, char\[)\]+"
-    test_demangling "hp: __ge__FRC2T2c" \
-	"operator>=\[(\]+(const T2|T2 const) &, char\[)\]+"
-    test_demangling "hp: __lt__FRC2T2c" \
-	"operator<\[(\]+(const T2|T2 const) &, char\[)\]+"
-
-    test_demangling "hp: __le__FRC2T2c" \
-	"operator<=\[(\]+(const T2|T2 const) &, char\[)\]+"
-    test_demangling "hp: __ne__FRC2T2c" \
-	"operator!=\[(\]+(const T2|T2 const) &, char\[)\]+"
-    test_demangling "hp: __eq__FRC2T2c" \
-	"operator==\[(\]+(const T2|T2 const) &, char\[)\]+"
-    test_demangling_exact "hp: __amd__FR2T2i" "operator%=(T2 &, int)"
-    test_demangling_exact "hp: __adv__FR2T2i" "operator/=(T2 &, int)"
-    test_demangling_exact "hp: __amu__FR2T2i" "operator*=(T2 &, int)"
-    test_demangling_exact "hp: __ami__FR2T2i" "operator-=(T2 &, int)"
-    test_demangling_exact "hp: __apl__FR2T2i" "operator+=(T2 &, int)"
-    test_demangling_exact "hp: __nw__2T1SFUi" "T1::operator new(unsigned int) static"
-    test_demangling_exact "hp: __dl__2T1SFPv" "T1::operator delete(void *) static"
-    test_demangling_exact "hp: put__2T7SFi" "T7::put(int) static"
-
-    test_demangling_exact "hp: h__FUc" "h(unsigned char)"
-    test_demangling_exact "hp: f__Fic" "f(int, char)"
-    test_demangling_exact "hp: h__FUi" "h(unsigned int)"
-    test_demangling_exact "hp: h__Fci" "h(char, int)"
-    test_demangling_exact "hp: h__FUl" "h(unsigned long)"
-    test_demangling_exact "hp: h__Fcl" "h(char, long)"
-    test_demangling_exact "hp: h__FUs" "h(unsigned short)"
-    test_demangling_exact "hp: h__Fcs" "h(char, short)"
-    test_demangling "hp: __amd__FR2T2RC2T2" \
-	"operator%=\[(\]+T2 &, (const T2|T2 const) &\[)\]+"
-    test_demangling "hp: __adv__FR2T2RC2T2" \
-	"operator/=\[(\]+T2 &, (const T2|T2 const) &\[)\]+"
-    test_demangling "hp: __amu__FR2T2RC2T2" \
-	"operator\[*\]+=\[(\]+T2 &, (const T2|T2 const) &\[)\]+"
-    test_demangling "hp: __ami__FR2T2RC2T2" \
-	"operator-=\[(\]+T2 &, (const T2|T2 const) &\[)\]+"
-    test_demangling "hp: __apl__FR2T2RC2T2" \
-	"operator\[+\]+=\[(\]+T2 &, (const T2|T2 const) &\[)\]+"
-
-    test_demangling "hp: g__F1SRPUlRPCUlT2" \
-	"g\[(\]+S, unsigned long \[*\]+&, (const unsigned long|unsigned long const) \[*\]+&, unsigned long \[*\]+&\[)\]+"
-    test_demangling "hp: g__F1SRPUiRPCUiT2" \
-	"g\[(\]+S, unsigned int \[*\]+&, (const unsigned int|unsigned int const) \[*\]+&, unsigned int \[*\]+&\[)\]+"
-    test_demangling "hp: g__F1SRPUsRPCUsT2" \
-	"g\[(\]+S, unsigned short \[*\]+&, (const unsigned short|unsigned short const) \[*\]+&, unsigned short \[*\]+&\[)\]+"
-    test_demangling "hp: g__F1SRPUcRPCUcT2" \
-	"g\[(\]+S, unsigned char \[*\]+&, (const unsigned char|unsigned char const) \[*\]+&, unsigned char \[*\]+&\[)\]+"
-    test_demangling "hp: g__F1T1SRPlRPClT3" \
-	"g\[(\]+T, S, long \[*\]+&, (const long|long const) \[*\]+&, long \[*\]+&\[)\]+"
-    test_demangling "hp: g__F1T1SRPiRPCiT3" \
-	"g\[(\]+T, S, int \[*\]+&, (const int|int const) \[*\]+&, int \[*\]+&\[)\]+"
-    test_demangling "hp: g__F1T1SRPcRPCcT3" \
-	"g\[(\]+T, S, char \[*\]+&, (const char|char const) \[*\]+&, char \[*\]+&\[)\]+"
-
-
-    test_demangling "hp: __gt__FRC2T2T1" \
-	"operator>\[(\]+(const T2|T2 const) &, (const T2|T2 const) &\[)\]+"
-    test_demangling "hp: __ge__FRC2T2T1" \
-	"operator>=\[(\]+(const T2|T2 const) &, (const T2|T2 const) &\[)\]+"
-    test_demangling "hp: __lt__FRC2T2T1" \
-	"operator<\[(\]+(const T2|T2 const) &, (const T2|T2 const) &\[)\]+"
-    test_demangling "hp: __le__FRC2T2T1" \
-	"operator<=\[(\]+(const T2|T2 const) &, (const T2|T2 const) &\[)\]+"
-    test_demangling "hp: __ne__FRC2T2T1" \
-	"operator!=\[(\]+(const T2|T2 const) &, (const T2|T2 const) &\[)\]+"
-    test_demangling "hp: __eq__FRC2T2T1" \
-	"operator==\[(\]+(const T2|T2 const) &, (const T2|T2 const) &\[)\]+"
-    test_demangling "hp: g__FcR1cRC1cT2" \
-	"g\[(\]+char, c &, (const c|c const) &, c &\[)\]+"
-    test_demangling "hp: g__FcRPdRPCdT2" \
-	"g\[(\]+char, double *\[*\]+&, (const double|double const) *\[*\]+&, double *\[*\]+&\[)\]+"
-    test_demangling "hp: g__FcRPfRPCfT2" \
-	"g\[(\]+char, float *\[*\]+&, (const float|float const) *\[*\]+&, float *\[*\]+&\[)\]+"
-    test_demangling_exact "hp: h__FcT1" "h(char, char)"
-    test_demangling_exact "hp: f__Ficd" "f(int, char, double)"
-    test_demangling "hp: g__F1T1SdRPsRPCsT4" \
-	"g\[(\]+T, S, double, short \[*\]+&, (const short|short const) \[*\]+&, short \[*\]+&\[)\]+"
-    test_demangling "hp: g__F1cC1cT1" \
-	"g\[(\]+c, (const c|c const), c\[)\]+"
-    test_demangling "hp: g__FPdPCdT1" \
-	"g\[(\]+double *\[*\]+, (const double|double const) *\[*\]+, double *\[*\]+\[)\]+"
-    test_demangling "hp: g__FPfPCfT1" \
-	"g\[(\]+float *\[*\]+, (const float|float const) *\[*\]+, float *\[*\]+\[)\]+"
-
-    test_demangling "hp: g__FUlCUlT1" \
-	"g\[(\]+unsigned long, (const unsigned long|unsigned long const), unsigned long\[)\]+"
-    test_demangling "hp: g__FPlPClT1" \
-	"g\[(\]+long \[*\]+, (const long|long const) \[*\]+, long \[*\]+\[)\]+"
-    test_demangling "hp: g__FUiCUiT1" \
-	"g\[(\]+unsigned int, (const unsigned int|unsigned int const), unsigned int\[)\]+"
-    test_demangling "hp: g__FPiPCiT1" \
-	"g\[(\]+int \[*\]+, (const int|int const) \[*\]+, int \[*\]+\[)\]+"
-    test_demangling "hp: g__FUsCUsT1" \
-	"g\[(\]+unsigned short, (const unsigned short|unsigned short const), unsigned short\[)\]+"
-    test_demangling "hp: g__FPsPCsT1" \
-	"g\[(\]+short \[*\]+, (const short|short const) \[*\]+, short \[*\]+\[)\]+"
-    test_demangling "hp: g__FUcCUcT1" \
-	"g\[(\]+unsigned char, (const unsigned char|unsigned char const), unsigned char\[)\]+"
-    test_demangling "hp: g__FPcPCcT1" \
-	"g\[(\]+char \[*\]+, (const char|char const) \[*\]+, char \[*\]+\[)\]+"
-    test_demangling "hp: g__F1TlClT2" \
-	"g\[(\]+T, long, (const long|long const), long\[)\]+"
-    test_demangling "hp: g__F1TiCiT2" \
-	"g\[(\]+T, int, (const int|int const), int\[)\]+"
-    test_demangling "hp: g__F1TsCsT2" \
-	"g\[(\]+T, short, (const short|short const), short\[)\]+"
-    test_demangling "hp: g__F1TcCcT2" \
-	"g\[(\]+T, char, (const char|char const), char\[)\]+"
-
-    test_demangling "hp: printf__FPCce" \
-	"printf\[(\]+(const char|char const) \[*\]+,...\[)\]+"
-
-
-    test_demangling "hp: g__F1SRUlRCUlT2" \
-	"g\[(\]+S, unsigned long &, (const unsigned long|unsigned long const) &, unsigned long &\[)\]+"
-    test_demangling "hp: g__F1SRPlRPClT2" \
-	"g\[(\]+S, long \[*\]+&, (const long|long const) \[*\]+&, long \[*\]+&\[)\]+"
-    test_demangling "hp: g__F1RRUiRCUiT2" \
-	"g\[(\]+R, unsigned int &, (const unsigned int|unsigned int const) &, unsigned int &\[)\]+"
-    test_demangling "hp: g__F1SRPiRPCiT2" \
-	"g\[(\]+S, int \[*\]+&, (const int|int const) \[*\]+&, int \[*\]+&\[)\]+"
-    test_demangling "hp: g__F1RRUsRCUsT2" \
-	"g\[(\]+R, unsigned short &, (const unsigned short|unsigned short const) &, unsigned short &\[)\]+"
-    test_demangling "hp: g__F1SRPsRPCsT2" \
-	"g\[(\]+S, short \[*\]+&, (const short|short const) \[*\]+&, short \[*\]+&\[)\]+"
-    test_demangling "hp: g__F1RRUcRCUcT2" \
-	"g\[(\]+R, unsigned char &, (const unsigned char|unsigned char const) &, unsigned char &\[)\]+"
-    test_demangling "hp: g__F1SRPcRPCcT2" \
-	"g\[(\]+S, char \[*\]+&, (const char|char const) \[*\]+&, char \[*\]+&\[)\]+"
-    test_demangling "hp: g__F1T1RRlRClT3" \
-	"g\[(\]+T, R, long &, (const long|long const) &, long &\[)\]+"
-    test_demangling "hp: g__F1T1RRiRCiT3" \
-	"g\[(\]+T, R, int &, (const int|int const) &, int &\[)\]+"
-    test_demangling "hp: g__F1T1RRsRCsT3" \
-	"g\[(\]+T, R, short &, (const short|short const) &, short &\[)\]+"
-    test_demangling "hp: g__F1T1RRcRCcT3" \
-	"g\[(\]+T, R, char &, (const char|char const) &, char &\[)\]+"
-
-
-    test_demangling_exact "hp: f__FicdPcPFci_v" "f(int, char, double, char *, void (*)(char, int))"
-    test_demangling_exact "hp: f__FicdPcPFic_v" "f(int, char, double, char *, void (*)(int, char))"
-    test_demangling_exact "hp: get__2T7SFv" "T7::get(void) static"
-
-
-    test_demangling "hp: g__FcRdRCdT2" \
-	"g\[(\]+char, double &, (const double|double const) &, double &\[)\]+"
-    test_demangling "hp: g__FcRfRCfT2" \
-	"g\[(\]+char, float &, (const float|float const) &, float &\[)\]+"
-    test_demangling "hp: __md__FC2T2i" \
-	"operator%\[(\]+(const T2|T2 const), int\[)\]+"
-    test_demangling "hp: __dv__FC2T2i" \
-	"operator/\[(\]+(const T2|T2 const), int\[)\]+"
-    test_demangling "hp: __ml__FC2T2i" \
-	"operator\[*\]+\[(\]+(const T2|T2 const), int\[)\]+"
-    test_demangling "hp: __mi__FC2T2i" \
-	"operator-\[(\]+(const T2|T2 const), int\[)\]+"
-    test_demangling "hp: __pl__FC2T2i" \
-	"operator\[+\]+\[(\]+(const T2|T2 const), int\[)\]+"
-
-
-    test_demangling_exact "hp: h__Fc" "h(char)"
-    test_demangling_exact "hp: h__Fd" "h(double)"
-    test_demangling_exact "hp: h__Ff" "h(float)"
-    test_demangling_exact "hp: h__Fi" "h(int)"
-    test_demangling_exact "hp: f__Fi" "f(int)"
-    test_demangling_exact "hp: h__Fl" "h(long)"
-
-    test_demangling_exact "hp: h__Fs" "h(short)"
-    test_demangling "hp: __md__FC2T2RC2T2" \
-	"operator%\[(\]+(const T2|T2 const), (const T2|T2 const) &\[)\]+"
-    test_demangling "hp: __dv__FC2T2RC2T2" \
-	"operator/\[(\]+(const T2|T2 const), (const T2|T2 const) &\[)\]+"
-    test_demangling "hp: __ml__FC2T2RC2T2" \
-	"operator\[*\]+\[(\]+(const T2|T2 const), (const T2|T2 const) &\[)\]+"
-    test_demangling "hp: __mi__FC2T2RC2T2" \
-	"operator-\[(\]+(const T2|T2 const), (const T2|T2 const) &\[)\]+"
-    test_demangling "hp: __pl__FC2T2RC2T2" \
-	"operator\[+\]+\[(\]+(const T2|T2 const), (const T2|T2 const) &\[)\]+"
-    test_demangling "hp: g__FcRP1cRPC1cT2" \
-	"g\[(\]+char, c *\[*\]+&, (const c|c const) *\[*\]+&, c *\[*\]+&\[)\]+"
-
-
-    test_demangling "hp: g__FdCdT1" \
-	"g\[(\]+double, (const double|double const), double\[)\]+"
-    test_demangling "hp: g__FfCfT1" \
-	"g\[(\]+float, (const float|float const), float\[)\]+"
-    test_demangling "hp: g__FlClT1" \
-	"g\[(\]+long, (const long|long const), long\[)\]+"
-    test_demangling "hp: g__FiCiT1" \
-	"g\[(\]+int, (const int|int const), int\[)\]+"
-    test_demangling "hp: g__FsCsT1" \
-	"g\[(\]+short, (const short|short const), short\[)\]+"
-    test_demangling "hp: g__FcCcT1" \
-	"g\[(\]+char, (const char|char const), char\[)\]+"
-
-
-    test_demangling_exact "hp: f__FicdPc" "f(int, char, double, char *)"
-    test_demangling_exact "hp: __nw__FUi" "operator new(unsigned int)"
-    test_demangling_exact "hp: __ct__Q3_2T11a1bSFi" "T1::a::b::b(int) static"
-    test_demangling_exact "hp: __dt__Q3_2T11a1bSFi" "T1::a::b::~b(int) static"
-    test_demangling_exact "hp: put__Q3_2T11a1bSFi" "T1::a::b::put(int) static"
-    test_demangling_exact "hp: get__Q2_2T11aSFv" "T1::a::get(void) static"
-    test_demangling_exact "hp: put__2T1SFi" "T1::put(int) static"
-    test_demangling_exact "hp: put__Q5_2T11a1b1c1dSFi" "T1::a::b::c::d::put(int) static"
-    test_demangling_exact "hp: get__Q4_2T11a1b1cSFv" "T1::a::b::c::get(void) static"
-    test_demangling_exact "hp: put__Q2_2T11aSFi" "T1::a::put(int) static"
-    test_demangling_exact "hp: put__Q4_2T11a1b1cSFi" "T1::a::b::c::put(int) static"
-    test_demangling_exact "hp: get__Q3_2T11a1bSFv" "T1::a::b::get(void) static"
-    test_demangling_exact "hp: get__2T1SFv" "T1::get(void) static"
-    test_demangling_exact "hp: get__Q5_2T11a1b1c1dSFv" "T1::a::b::c::d::get(void) static"
-
-
-    test_demangling_exact "hp: bar__3fooFPv"       "foo::bar(void *)"
-    test_demangling "hp: bar__3fooFPCv" \
-	     "foo::bar\[(\]+(const void|void const) *\[*\]+\[)\]+"
-    test_demangling_exact "hp: bar__3fooCFPv"      "foo::bar(void *) const"
-    test_demangling "hp: bar__3fooCFPCv" \
-	    "foo::bar\[(\]+(const void|void const) *\[*\]+\[)\]+ const"
-    test_demangling_exact "hp: __eq__3fooFR3foo"   "foo::operator==(foo &)"
-    test_demangling "hp: __eq__3fooFRC3foo" \
-	 "foo::operator==\[(\]+(const foo|foo const) &\[)\]+"
-    test_demangling_exact "hp: __eq__3fooCFR3foo"  "foo::operator==(foo &) const"
-    test_demangling "hp: __eq__3fooCFRC3foo" \
-	"foo::operator==\[(\]+(const foo|foo const) &\[)\]+ const"
-
-    test_demangling_exact "hp: bar__3fooFiT16FooBar" "foo::bar(int, int, FooBar)"
-
-    test_demangling_exact "hp: bar__3fooFPiN51PdN37PcN211T1iN215" \
-      "foo::bar(int *, int *, int *, int *, int *, int *, double *, double *, double *, double *, char *, char *, char *, int *, int, int, int)"
-
-
-    # HP aCC specific tests. HP aCC demangling does not use __pt__ for
-    # template specifications.  There are other differences as well.
-
-    test_demangling_exact "hp: __dt__2T5XTPFiPPdPv_i__Fv" "T5<int (*)(int, double **, void *)>::~T5(void)"
-
-    test_demangling_exact "hp: __ct__1cFi" "c::c(int)"
-
-    test_demangling_exact "hp: __dt__2T5XTi__Fv" "T5<int>::~T5(void)"
-
-    test_demangling_exact "hp: __dt__2T5XTc__Fv" "T5<char>::~T5(void)"
-
-    test_demangling_exact "hp: __ct__2T2Fi" "T2::T2(int)"
-    test_demangling_exact "hp: __dt__2T1Fv" "T1::~T1(void)"
-
-    test_demangling_exact "hp: __dt__2T5XT1x__Fv" "T5<x>::~T5(void)"
-
-    test_demangling_exact "hp: __dt__2T5XTPFcPv_i__Fv" "T5<int (*)(char, void *)>::~T5(void)"
-    
-    test_demangling_exact "hp: __ct__2T5XTPFiPPdPv_i__Fi" "T5<int (*)(int, double **, void *)>::T5(int)"
-
-    test_demangling_exact "hp: __dl__2T5XT1x__SFPv" "T5<x>::operator delete(void *) static"
-    
-    test_demangling_exact "hp: X__2T5XT1x" "T5<x>::X"
-
-    test_demangling_exact "hp: __ct__2T5XTi__Fi" "T5<int>::T5(int)"
-
-    test_demangling_exact "hp: __ct__2T5XTc__Fi" "T5<char>::T5(int)"
-
-    test_demangling_exact "hp: __dl__2T5XTPFcPv_i__SFPv" "T5<int (*)(char, void *)>::operator delete(void *) static"
-
-    test_demangling_exact "hp: X__2T5XTPFcPv_i" "T5<int (*)(char, void *)>::X"
-
-    test_demangling_exact "hp: __ct__2T5XT1x__Fi" "T5<x>::T5(int)"
-
-    test_demangling_exact "hp: __dl__2T5XTPFiPPdPv_i__SFPv" "T5<int (*)(int, double **, void *)>::operator delete(void *) static"
-    test_demangling_exact "hp: X__2T5XTPFiPPdPv_i" "T5<int (*)(int, double **, void *)>::X"
-
-    test_demangling_exact "hp: __dl__2T5XTi__SFPv" "T5<int>::operator delete(void *) static"
-
-    test_demangling_exact "hp: __dl__2T5XTc__SFPv" "T5<char>::operator delete(void *) static"
-
-    test_demangling_exact "hp: X__2T5XTc" "T5<char>::X"
-
-    test_demangling_exact "hp: X__2T5XTi" "T5<int>::X"
-
-    test_demangling_exact "hp: __ct__2T5XTPFcPv_i__Fi" "T5<int (*)(char, void *)>::T5(int)"
-    
-    test_demangling_exact "hp: __dt__2T1XTc__Fv" "T1<char>::~T1(void)"
-
-    test_demangling_exact "hp: __dt__2T1XT1t__Fv" "T1<t>::~T1(void)"
-
-    test_demangling_exact "hp: __dl__2T1XT1t__SFPv" "T1<t>::operator delete(void *) static"
-
-    test_demangling_exact "hp: __ct__2T1XTc__Fi" "T1<char>::T1(int)"
-
-    test_demangling_exact "hp: __ct__2T1XTc__Fv" "T1<char>::T1(void)"
-
-    test_demangling_exact "hp: __ct__2T1XT1t__Fi" "T1<t>::T1(int)"
-
-    test_demangling_exact "hp: __ct__2T1XT1t__Fv" "T1<t>::T1(void)"
-
-    test_demangling_exact "hp: __dl__2T1XTc__SFPv" "T1<char>::operator delete(void *) static"
-
-    test_demangling_exact "hp: elem__6vectorXTd__Fi" "vector<double>::elem(int)"
-
-    test_demangling_exact "hp: elem__6vectorXTi__Fi" "vector<int>::elem(int)"
-
-    test_demangling_exact "hp: __ct__6vectorXTd__Fi" "vector<double>::vector(int)"
-
-    test_demangling_exact "hp: __ct__6vectorXTi__Fi" "vector<int>::vector(int)"
-
-    test_demangling_exact "hp: __ct__9DListNodeXTR6RLabel__FR6RLabelP9DListNodeXTR6RLabel_T2" \
-	"DListNode<RLabel &>::DListNode(RLabel &, DListNode<RLabel &> *, DListNode<RLabel &> *)"
-
-
-    # Absolute integer constants in template args
-
-    test_demangling_exact "hp: elem__6vectorXTiUP34__Fi" "vector<int,34U>::elem(int)"
-    test_demangling_exact "hp: elem__6vectorXUP2701Td__Fi" "vector<2701U,double>::elem(int)"
-    test_demangling_exact "hp: elem__6vectorXTiSP334__Fi" "vector<int,334>::elem(int)"
-    test_demangling_exact "hp: elem__6vectorXTiSN67__Fi" "vector<int,-67>::elem(int)"
-    test_demangling_exact "hp: elem__6vectorXTiSM__SCFPPd" "vector<int,-2147483648>::elem(double **) static const"
-    test_demangling_exact "hp: elem__6vectorXTiSN67UP4000TRs__Fi" "vector<int,-67,4000U,short &>::elem(int)"
-    test_demangling_exact "hp: elem__6vectorXTiSN67TRdTFPv_i__Fi" "vector<int,-67,double &,int (void *)>::elem(int)"
-    test_demangling_exact "hp: X__6vectorXTiSN67TdTPvUP5TRs" "vector<int,-67,double,void *,5U,short &>::X"
-
-    # Named constants in template args
-
-    test_demangling_exact "hp: elem__6vectorXTiA3foo__Fi" "vector<int,&foo>::elem(int)"
-    test_demangling_exact "hp: elem__6vectorXTiA3fooTPvA5Label__FiPPvT2" "vector<int,&foo,void *,&Label>::elem(int, void **, void **)"
-    test_demangling_exact "hp: elem__6vectorXTiSN42A3foo__Fi" "vector<int,-42,&foo>::elem(int)"
-
-    # Alternate entry points for functions
-
-    test_demangling_exact "hp: __ct__2T5XTPFcPv_i__Fi_2" "T5<int (*)(char, void *)>::T5(int)"
-    test_demangling_exact "hp: __ct__2T5XTPFcPv_i__Fi_19" "T5<int (*)(char, void *)>::T5(int)"
-    test_demangling_exact "hp: f__FicdPcPFci_v_34" "f(int, char, double, char *, void (*)(char, int))"
-
-
-    # Template partial specializations
-
-# FIXME!  The # characters don't go through expect, and backslashes don't seem to work.
-#    test_demangling_exact "hp: spec__13Spec<#1,#1.*>XTiTPi_FPi" "Spec<int,int *>::spec(int *)"
-#    test_demangling_exact "hp: spec__16Spec<#1,#1.&,#1>XTiTRiTi_FPi" "Spec<int,int &, int>::spec(int *)"
-# Fake test -- replace # with %
-    test_demangling_exact "hp: spec__13Spec<%1,%1.*>XTiTPi_FPi" "Spec<int,int *>::spec(int *)"
-    test_demangling_exact "hp: spec__16Spec<%1,%1.&,%1>XTiTRiTi_FPi" "Spec<int,int &,int>::spec(int *)"
-
-    # Global template functions
-
-    test_demangling_exact "hp: add__XTc_FcT1" "add<char>(char, char)"
-    test_demangling_exact "hp: add__XTcSP9A5label_FcPPlT1" "add<char,9,&label>(char, long **, char)"
-    test_demangling_exact "hp: add__XTPfTFPd_f_FcT1" "add<float *,float (double *)>(char, char)"
-
-    # Template for template arg
-
-    test_demangling_exact "hp: unLink__12basic_stringXTcT18string_char_traitsXTc_T9allocator_Fv" "basic_string<char,string_char_traits<char>,allocator>::unLink(void)"
-
-    test_demangling_exact "hp: _Utf390_1__1_9223372036854775807__9223372036854775" \
-	    "Can't demangle \"_Utf390_1__1_9223372036854775807__9223372036854775\""
-}
-
-
 proc catch_demangling_errors {command} {
     if {[catch $command result]} {
 	puts "ERROR: demangle.exp: while running $command: $result"
@@ -1593,10 +183,7 @@  proc do_tests {} {
     # Using catch_demangling_errors this way ensures that, if one of
     # the functions raises a Tcl error, then it'll get reported, and
     # the rest of the functions will still run.
-    catch_demangling_errors test_lucid_style_demangling
-    catch_demangling_errors test_gnu_style_demangling
-    catch_demangling_errors test_arm_style_demangling
-    catch_demangling_errors test_hp_style_demangling
+    catch_demangling_errors test_gnuv3_style_demangling
 
     # Verify specifying demangle language.
     gdb_test_no_output "set language unknown"
diff --git a/gdb/valops.c b/gdb/valops.c
index 75ff7058b7c..2f5a4c815f2 100644
--- a/gdb/valops.c
+++ b/gdb/valops.c
@@ -1980,23 +1980,12 @@  search_struct_method (const char *name, struct value **arg1p,
   int i;
   struct value *v;
   int name_matched = 0;
-  char dem_opname[64];
 
   type = check_typedef (type);
   for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--)
     {
       const char *t_field_name = TYPE_FN_FIELDLIST_NAME (type, i);
 
-      /* FIXME!  May need to check for ARM demangling here.  */
-      if (startswith (t_field_name, "__") ||
-	  startswith (t_field_name, "op") ||
-	  startswith (t_field_name, "type"))
-	{
-	  if (cplus_demangle_opname (t_field_name, dem_opname, DMGL_ANSI))
-	    t_field_name = dem_opname;
-	  else if (cplus_demangle_opname (t_field_name, dem_opname, 0))
-	    t_field_name = dem_opname;
-	}
       if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
 	{
 	  int j = TYPE_FN_FIELDLIST_LENGTH (type, i) - 1;
@@ -3421,19 +3410,7 @@  value_struct_elt_for_reference (struct type *domain, int offset,
   for (i = TYPE_NFN_FIELDS (t) - 1; i >= 0; --i)
     {
       const char *t_field_name = TYPE_FN_FIELDLIST_NAME (t, i);
-      char dem_opname[64];
 
-      if (startswith (t_field_name, "__") 
-	  || startswith (t_field_name, "op") 
-	  || startswith (t_field_name, "type"))
-	{
-	  if (cplus_demangle_opname (t_field_name, 
-				     dem_opname, DMGL_ANSI))
-	    t_field_name = dem_opname;
-	  else if (cplus_demangle_opname (t_field_name, 
-					  dem_opname, 0))
-	    t_field_name = dem_opname;
-	}
       if (t_field_name && strcmp (t_field_name, name) == 0)
 	{
 	  int j;