CbC/CbC_gcc: libiberty/cp-demangle.c comparison

comparison libiberty/cp-demangle.c @ 111:04ced10e8804

gcc 7

author	kono
date	Fri, 27 Oct 2017 22:46:09 +0900
parents	f6334be47118
children	84e7813d76e9

comparison

equal deleted inserted replaced

-:561a7518be6b
+:04ced10e8804
 /* Demangler for g++ V3 ABI.
-Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
+Copyright (C) 2003-2017 Free Software Foundation, Inc.
-Free Software Foundation, Inc.
 Written by Ian Lance Taylor <ian@wasabisystems.com>.
 This file is part of the libiberty library, which is part of GCC.
 This file is free software; you can redistribute it and/or modify
 any arguments, or, if none, demangles stdin.
 CP_DEMANGLE_DEBUG
 If defined, turns on debugging mode, which prints information on
 stdout about the mangled string.  This is not generally useful.
-*/
+CHECK_DEMANGLER
+If defined, additional sanity checks will be performed.  It will
+cause some slowdown, but will allow to catch out-of-bound access
+errors earlier.  This macro is intended for testing and debugging.  */
 #if defined (_AIX) && !defined (__GNUC__)
 #pragma alloca
 #endif
 extern char *alloca ();
 #  endif /* __GNUC__ */
 # endif /* alloca */
 #endif /* HAVE_ALLOCA_H */
+#ifdef HAVE_LIMITS_H
+#include <limits.h>
+#endif
+#ifndef INT_MAX
+# define INT_MAX       (int)(((unsigned int) ~0) >> 1)          /* 0x7FFFFFFF */
+#endif
 #include "ansidecl.h"
 #include "libiberty.h"
 #include "demangle.h"
 #include "cp-demangle.h"
 #define cplus_demangle_type d_type
 static struct demangle_component *d_type (struct d_info *);
 #define cplus_demangle_print d_print
-static char *d_print (int, const struct demangle_component *, int, size_t *);
+static char *d_print (int, struct demangle_component *, int, size_t *);
 #define cplus_demangle_print_callback d_print_callback
-static int d_print_callback (int, const struct demangle_component *,
+static int d_print_callback (int, struct demangle_component *,
 demangle_callbackref, void *);
 #define cplus_demangle_init_info d_init_info
 static void d_init_info (const char *, int, size_t, struct d_info *);
 {
 /* Next modifier on the list.  These are in the reverse of the order
 in which they appeared in the mangled string.  */
 struct d_print_mod *next;
 /* The modifier.  */
-const struct demangle_component *mod;
+struct demangle_component *mod;
 /* Whether this modifier was printed.  */
 int printed;
 /* The list of templates which applies to this modifier.  */
 struct d_print_template *templates;
 };
 size_t alc;
 /* Set to 1 if we had a memory allocation failure.  */
 int allocation_failure;
 };
+/* Stack of components, innermost first, used to avoid loops.  */
+struct d_component_stack
+{
+/* This component.  */
+const struct demangle_component *dc;
+/* This component's parent.  */
+const struct d_component_stack *parent;
+};
+/* A demangle component and some scope captured when it was first
+traversed.  */
+struct d_saved_scope
+{
+/* The component whose scope this is.  */
+const struct demangle_component *container;
+/* The list of templates, if any, that was current when this
+scope was captured.  */
+struct d_print_template *templates;
+};
+/* Checkpoint structure to allow backtracking.  This holds copies
+of the fields of struct d_info that need to be restored
+if a trial parse needs to be backtracked over.  */
+struct d_info_checkpoint
+{
+const char *n;
+int next_comp;
+int next_sub;
+int expansion;
+};
+/* Maximum number of times d_print_comp may be called recursively.  */
+#define MAX_RECURSION_COUNT 1024
 enum { D_PRINT_BUFFER_LENGTH = 256 };
 struct d_print_info
 {
-/* The options passed to the demangler.  */
-int options;
 /* Fixed-length allocated buffer for demangled data, flushed to the
 callback with a NUL termination once full.  */
 char buf[D_PRINT_BUFFER_LENGTH];
 /* Current length of data in buffer.  */
 size_t len;
 /* The current list of modifiers (e.g., pointer, reference, etc.),
 if any.  */
 struct d_print_mod *modifiers;
 /* Set to 1 if we saw a demangling error.  */
 int demangle_failure;
+/* Number of times d_print_comp was recursively called.  Should not
+be bigger than MAX_RECURSION_COUNT.  */
+int recursion;
+/* Non-zero if we're printing a lambda argument.  A template
+parameter reference actually means 'auto'.  */
+int is_lambda_arg;
 /* The current index into any template argument packs we are using
-for printing.  */
+for printing, or -1 to print the whole pack.  */
 int pack_index;
 /* Number of d_print_flush calls so far.  */
 unsigned long int flush_count;
+/* Stack of components, innermost first, used to avoid loops.  */
+const struct d_component_stack *component_stack;
+/* Array of saved scopes for evaluating substitutions.  */
+struct d_saved_scope *saved_scopes;
+/* Index of the next unused saved scope in the above array.  */
+int next_saved_scope;
+/* Number of saved scopes in the above array.  */
+int num_saved_scopes;
+/* Array of templates for saving into scopes.  */
+struct d_print_template *copy_templates;
+/* Index of the next unused copy template in the above array.  */
+int next_copy_template;
+/* Number of copy templates in the above array.  */
+int num_copy_templates;
+/* The nearest enclosing template, if any.  */
+const struct demangle_component *current_template;
 };
 #ifdef CP_DEMANGLE_DEBUG
 static void d_dump (struct demangle_component *, int);
 #endif
 static struct demangle_component *
 d_make_dtor (struct d_info *, enum gnu_v3_dtor_kinds,
 struct demangle_component *);
 static struct demangle_component *
-d_make_template_param (struct d_info *, long);
+d_make_template_param (struct d_info *, int);
 static struct demangle_component *
 d_make_sub (struct d_info *, const char *, int);
 static int
 static struct demangle_component *d_unqualified_name (struct d_info *);
 static struct demangle_component *d_source_name (struct d_info *);
-static long d_number (struct d_info *);
+static int d_number (struct d_info *);
 static struct demangle_component *d_identifier (struct d_info *, int);
 static struct demangle_component *d_operator_name (struct d_info *);
 static struct demangle_component *d_special_name (struct d_info *);
+static struct demangle_component *d_parmlist (struct d_info *);
 static int d_call_offset (struct d_info *, int);
 static struct demangle_component *d_ctor_dtor_name (struct d_info *);
 static struct demangle_component **
 d_cv_qualifiers (struct d_info *, struct demangle_component **, int);
 static struct demangle_component *
+d_ref_qualifier (struct d_info *, struct demangle_component *);
+static struct demangle_component *
 d_function_type (struct d_info *);
 static struct demangle_component *
 d_bare_function_type (struct d_info *, int);
 static struct demangle_component *
 d_template_param (struct d_info *);
 static struct demangle_component *d_template_args (struct d_info *);
+static struct demangle_component *d_template_args_1 (struct d_info *);
 static struct demangle_component *
 d_template_arg (struct d_info *);
 static struct demangle_component *d_expression (struct d_info *);
 static int d_discriminator (struct d_info *);
 static struct demangle_component *d_lambda (struct d_info *);
 static struct demangle_component *d_unnamed_type (struct d_info *);
+static struct demangle_component *
+d_clone_suffix (struct d_info *, struct demangle_component *);
 static int
 d_add_substitution (struct d_info *, struct demangle_component *);
 static struct demangle_component *d_substitution (struct d_info *, int);
+static void d_checkpoint (struct d_info *, struct d_info_checkpoint *);
+static void d_backtrack (struct d_info *, struct d_info_checkpoint *);
 static void d_growable_string_init (struct d_growable_string *, size_t);
 static inline void
 d_growable_string_resize (struct d_growable_string *, size_t);
 const char *, size_t);
 static void
 d_growable_string_callback_adapter (const char *, size_t, void *);
 static void
-d_print_init (struct d_print_info *, int, demangle_callbackref, void *);
+d_print_init (struct d_print_info *, demangle_callbackref, void *,
+	      const struct demangle_component *);
 static inline void d_print_error (struct d_print_info *);
 static inline int d_print_saw_error (struct d_print_info *);
 static inline void d_append_string (struct d_print_info *, const char *);
 static inline char d_last_char (struct d_print_info *);
 static void
-d_print_comp (struct d_print_info *, const struct demangle_component *);
+d_print_comp (struct d_print_info *, int, struct demangle_component *);
 static void
 d_print_java_identifier (struct d_print_info *, const char *, int);
 static void
-d_print_mod_list (struct d_print_info *, struct d_print_mod *, int);
+d_print_mod_list (struct d_print_info *, int, struct d_print_mod *, int);
 static void
-d_print_mod (struct d_print_info *, const struct demangle_component *);
+d_print_mod (struct d_print_info *, int, struct demangle_component *);
 static void
-d_print_function_type (struct d_print_info *,
+d_print_function_type (struct d_print_info *, int,
-const struct demangle_component *,
+struct demangle_component *,
 struct d_print_mod *);
 static void
-d_print_array_type (struct d_print_info *,
+d_print_array_type (struct d_print_info *, int,
-const struct demangle_component *,
+struct demangle_component *,
 struct d_print_mod *);
 static void
-d_print_expr_op (struct d_print_info *, const struct demangle_component *);
+d_print_expr_op (struct d_print_info *, int, struct demangle_component *);
-static void
+static void d_print_cast (struct d_print_info *, int,
-d_print_cast (struct d_print_info *, const struct demangle_component *);
+			  struct demangle_component *);
+static void d_print_conversion (struct d_print_info *, int,
+				struct demangle_component *);
 static int d_demangle_callback (const char *, int,
 demangle_callbackref, void *);
 static char *d_demangle (const char *, int, size_t *);
+#define FNQUAL_COMPONENT_CASE				\
+case DEMANGLE_COMPONENT_RESTRICT_THIS:		\
+case DEMANGLE_COMPONENT_VOLATILE_THIS:		\
+case DEMANGLE_COMPONENT_CONST_THIS:			\
+case DEMANGLE_COMPONENT_REFERENCE_THIS:		\
+case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:	\
+case DEMANGLE_COMPONENT_TRANSACTION_SAFE:		\
+case DEMANGLE_COMPONENT_NOEXCEPT:			\
+case DEMANGLE_COMPONENT_THROW_SPEC
+/* True iff TYPE is a demangling component representing a
+function-type-qualifier.  */
+static int
+is_fnqual_component_type (enum demangle_component_type type)
+{
+switch (type)
+{
+FNQUAL_COMPONENT_CASE:
+return 1;
+default:
+break;
+}
+return 0;
+}
 #ifdef CP_DEMANGLE_DEBUG
 static void
 d_dump (struct demangle_component *dc, int indent)
 {
 switch (dc->type)
 {
 case DEMANGLE_COMPONENT_NAME:
 printf ("name '%.*s'\n", dc->u.s_name.len, dc->u.s_name.s);
 return;
+case DEMANGLE_COMPONENT_TAGGED_NAME:
+printf ("tagged name\n");
+d_dump (dc->u.s_binary.left, indent + 2);
+d_dump (dc->u.s_binary.right, indent + 2);
+return;
 case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
 printf ("template parameter %ld\n", dc->u.s_number.number);
+return;
+case DEMANGLE_COMPONENT_FUNCTION_PARAM:
+printf ("function parameter %ld\n", dc->u.s_number.number);
 return;
 case DEMANGLE_COMPONENT_CTOR:
 printf ("constructor %d\n", (int) dc->u.s_ctor.kind);
 d_dump (dc->u.s_ctor.name, indent + 2);
 return;
 printf ("reference temporary\n");
 break;
 case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
 printf ("hidden alias\n");
 break;
+case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
+printf ("transaction clone\n");
+break;
+case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
+printf ("non-transaction clone\n");
+break;
 case DEMANGLE_COMPONENT_RESTRICT:
 printf ("restrict\n");
 break;
 case DEMANGLE_COMPONENT_VOLATILE:
 printf ("volatile\n");
 printf ("volatile this\n");
 break;
 case DEMANGLE_COMPONENT_CONST_THIS:
 printf ("const this\n");
 break;
+case DEMANGLE_COMPONENT_REFERENCE_THIS:
+printf ("reference this\n");
+break;
+case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
+printf ("rvalue reference this\n");
+break;
+case DEMANGLE_COMPONENT_TRANSACTION_SAFE:
+printf ("transaction_safe this\n");
+break;
 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
 printf ("vendor type qualifier\n");
 break;
 case DEMANGLE_COMPONENT_POINTER:
 printf ("pointer\n");
 break;
 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
 printf ("pointer to member type\n");
 break;
 case DEMANGLE_COMPONENT_FIXED_TYPE:
-printf ("fixed-point type\n");
+printf ("fixed-point type, accum? %d, sat? %d\n",
+dc->u.s_fixed.accum, dc->u.s_fixed.sat);
+d_dump (dc->u.s_fixed.length, indent + 2);
 break;
 case DEMANGLE_COMPONENT_ARGLIST:
 printf ("argument list\n");
 break;
 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
 printf ("template argument list\n");
 break;
+case DEMANGLE_COMPONENT_INITIALIZER_LIST:
+printf ("initializer list\n");
+break;
 case DEMANGLE_COMPONENT_CAST:
 printf ("cast\n");
 break;
+case DEMANGLE_COMPONENT_CONVERSION:
+printf ("conversion operator\n");
+break;
+case DEMANGLE_COMPONENT_NULLARY:
+printf ("nullary operator\n");
+break;
 case DEMANGLE_COMPONENT_UNARY:
 printf ("unary operator\n");
 break;
 case DEMANGLE_COMPONENT_BINARY:
 printf ("binary operator\n");
 printf ("compound name\n");
 break;
 case DEMANGLE_COMPONENT_CHARACTER:
 printf ("character '%c'\n",  dc->u.s_character.character);
 return;
+case DEMANGLE_COMPONENT_NUMBER:
+printf ("number %ld\n", dc->u.s_number.number);
+return;
 case DEMANGLE_COMPONENT_DECLTYPE:
 printf ("decltype\n");
 break;
 case DEMANGLE_COMPONENT_PACK_EXPANSION:
 printf ("pack expansion\n");
 break;
+case DEMANGLE_COMPONENT_TLS_INIT:
+printf ("tls init function\n");
+break;
+case DEMANGLE_COMPONENT_TLS_WRAPPER:
+printf ("tls wrapper function\n");
+break;
+case DEMANGLE_COMPONENT_DEFAULT_ARG:
+printf ("default argument %d\n", dc->u.s_unary_num.num);
+d_dump (dc->u.s_unary_num.sub, indent+2);
+return;
+case DEMANGLE_COMPONENT_LAMBDA:
+printf ("lambda %d\n", dc->u.s_unary_num.num);
+d_dump (dc->u.s_unary_num.sub, indent+2);
+return;
 }
 d_dump (d_left (dc), indent + 2);
 d_dump (d_right (dc), indent + 2);
 }
 int
 cplus_demangle_fill_name (struct demangle_component *p, const char *s, int len)
 {
 if (p == NULL || s == NULL || len == 0)
 return 0;
+p->d_printing = 0;
 p->type = DEMANGLE_COMPONENT_NAME;
 p->u.s_name.s = s;
 p->u.s_name.len = len;
 return 1;
 }
 cplus_demangle_fill_extended_operator (struct demangle_component *p, int args,
 struct demangle_component *name)
 {
 if (p == NULL || args < 0 || name == NULL)
 return 0;
+p->d_printing = 0;
 p->type = DEMANGLE_COMPONENT_EXTENDED_OPERATOR;
 p->u.s_extended_operator.args = args;
 p->u.s_extended_operator.name = name;
 return 1;
 }
 struct demangle_component *name)
 {
 if (p == NULL
 || name == NULL
 || (int) kind < gnu_v3_complete_object_ctor
-|| (int) kind > gnu_v3_complete_object_allocating_ctor)
+|| (int) kind > gnu_v3_object_ctor_group)
 return 0;
+p->d_printing = 0;
 p->type = DEMANGLE_COMPONENT_CTOR;
 p->u.s_ctor.kind = kind;
 p->u.s_ctor.name = name;
 return 1;
 }
 struct demangle_component *name)
 {
 if (p == NULL
 || name == NULL
 || (int) kind < gnu_v3_deleting_dtor
-|| (int) kind > gnu_v3_base_object_dtor)
+|| (int) kind > gnu_v3_object_dtor_group)
 return 0;
+p->d_printing = 0;
 p->type = DEMANGLE_COMPONENT_DTOR;
 p->u.s_dtor.kind = kind;
 p->u.s_dtor.name = name;
 return 1;
 }
 struct demangle_component *p;
 if (di->next_comp >= di->num_comps)
 return NULL;
 p = &di->comps[di->next_comp];
+p->d_printing = 0;
 ++di->next_comp;
 return p;
 }
 /* Add a new generic component.  */
 {
 /* These types require two parameters.  */
 case DEMANGLE_COMPONENT_QUAL_NAME:
 case DEMANGLE_COMPONENT_LOCAL_NAME:
 case DEMANGLE_COMPONENT_TYPED_NAME:
+case DEMANGLE_COMPONENT_TAGGED_NAME:
 case DEMANGLE_COMPONENT_TEMPLATE:
 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
 case DEMANGLE_COMPONENT_UNARY:
 case DEMANGLE_COMPONENT_BINARY:
 case DEMANGLE_COMPONENT_BINARY_ARGS:
 case DEMANGLE_COMPONENT_TRINARY:
 case DEMANGLE_COMPONENT_TRINARY_ARG1:
-case DEMANGLE_COMPONENT_TRINARY_ARG2:
 case DEMANGLE_COMPONENT_LITERAL:
 case DEMANGLE_COMPONENT_LITERAL_NEG:
 case DEMANGLE_COMPONENT_COMPOUND_NAME:
 case DEMANGLE_COMPONENT_VECTOR_TYPE:
+case DEMANGLE_COMPONENT_CLONE:
 if (left == NULL || right == NULL)
 	return NULL;
 break;
 /* These types only require one parameter.  */
 case DEMANGLE_COMPONENT_THUNK:
 case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
 case DEMANGLE_COMPONENT_COVARIANT_THUNK:
 case DEMANGLE_COMPONENT_JAVA_CLASS:
 case DEMANGLE_COMPONENT_GUARD:
+case DEMANGLE_COMPONENT_TLS_INIT:
+case DEMANGLE_COMPONENT_TLS_WRAPPER:
 case DEMANGLE_COMPONENT_REFTEMP:
 case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
+case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
+case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
 case DEMANGLE_COMPONENT_POINTER:
 case DEMANGLE_COMPONENT_REFERENCE:
 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
 case DEMANGLE_COMPONENT_COMPLEX:
 case DEMANGLE_COMPONENT_IMAGINARY:
 case DEMANGLE_COMPONENT_VENDOR_TYPE:
 case DEMANGLE_COMPONENT_CAST:
+case DEMANGLE_COMPONENT_CONVERSION:
 case DEMANGLE_COMPONENT_JAVA_RESOURCE:
 case DEMANGLE_COMPONENT_DECLTYPE:
 case DEMANGLE_COMPONENT_PACK_EXPANSION:
 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
+case DEMANGLE_COMPONENT_NULLARY:
+case DEMANGLE_COMPONENT_TRINARY_ARG2:
 if (left == NULL)
 	return NULL;
 break;
 /* This needs a right parameter, but the left parameter can be
 	 empty.  */
 case DEMANGLE_COMPONENT_ARRAY_TYPE:
+case DEMANGLE_COMPONENT_INITIALIZER_LIST:
 if (right == NULL)
 	return NULL;
 break;
 /* These are allowed to have no parameters--in some cases they
 	 will be filled in later.  */
 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
 case DEMANGLE_COMPONENT_RESTRICT:
 case DEMANGLE_COMPONENT_VOLATILE:
 case DEMANGLE_COMPONENT_CONST:
-case DEMANGLE_COMPONENT_RESTRICT_THIS:
-case DEMANGLE_COMPONENT_VOLATILE_THIS:
-case DEMANGLE_COMPONENT_CONST_THIS:
 case DEMANGLE_COMPONENT_ARGLIST:
 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
+FNQUAL_COMPONENT_CASE:
 break;
 /* Other types should not be seen here.  */
 default:
 return NULL;
 }
 /* Add a new template parameter.  */
 static struct demangle_component *
-d_make_template_param (struct d_info *di, long i)
+d_make_template_param (struct d_info *di, int i)
 {
 struct demangle_component *p;
 p = d_make_empty (di);
 if (p != NULL)
 }
 /* Add a new function parameter.  */
 static struct demangle_component *
-d_make_function_param (struct d_info *di, long i)
+d_make_function_param (struct d_info *di, int i)
 {
 struct demangle_component *p;
 p = d_make_empty (di);
 if (p != NULL)
 p->u.s_string.len = len;
 }
 return p;
 }
-/* <mangled-name> ::= _Z <encoding>
+/* <mangled-name> ::= _Z <encoding> [<clone-suffix>]*
 TOP_LEVEL is non-zero when called at the top level.  */
 CP_STATIC_IF_GLIBCPP_V3
 struct demangle_component *
 cplus_demangle_mangled_name (struct d_info *di, int top_level)
 {
+struct demangle_component *p;
 if (! d_check_char (di, '_')
 /* Allow missing _ if not at toplevel to work around a
 	 bug in G++ abi-version=2 mangling; see the comment in
 	 write_template_arg.  */
 && top_level)
 return NULL;
 if (! d_check_char (di, 'Z'))
 return NULL;
-return d_encoding (di, top_level);
+p = d_encoding (di, top_level);
+/* If at top level and parsing parameters, check for a clone
+suffix.  */
+if (top_level && (di->options & DMGL_PARAMS) != 0)
+while (d_peek_char (di) == '.'
+	   && (IS_LOWER (d_peek_next_char (di))
+	       || d_peek_next_char (di) == '_'
+	       || IS_DIGIT (d_peek_next_char (di))))
+p = d_clone_suffix (di, p);
+return p;
 }
 /* Return whether a function should have a return type.  The argument
 is the function name, which may be qualified in various ways.  The
 rules are that template functions have return types with some
 return 0;
 switch (dc->type)
 {
 default:
 return 0;
+case DEMANGLE_COMPONENT_LOCAL_NAME:
+return has_return_type (d_right (dc));
 case DEMANGLE_COMPONENT_TEMPLATE:
 return ! is_ctor_dtor_or_conversion (d_left (dc));
-case DEMANGLE_COMPONENT_RESTRICT_THIS:
+FNQUAL_COMPONENT_CASE:
-case DEMANGLE_COMPONENT_VOLATILE_THIS:
-case DEMANGLE_COMPONENT_CONST_THIS:
 return has_return_type (d_left (dc));
 }
 }
 /* Return whether a name is a constructor, a destructor, or a
 case DEMANGLE_COMPONENT_QUAL_NAME:
 case DEMANGLE_COMPONENT_LOCAL_NAME:
 return is_ctor_dtor_or_conversion (d_right (dc));
 case DEMANGLE_COMPONENT_CTOR:
 case DEMANGLE_COMPONENT_DTOR:
-case DEMANGLE_COMPONENT_CAST:
+case DEMANGLE_COMPONENT_CONVERSION:
 return 1;
 }
 }
 /* <encoding> ::= <(function) name> <bare-function-type>
 static struct demangle_component *
 d_encoding (struct d_info *di, int top_level)
 {
 char peek = d_peek_char (di);
+struct demangle_component *dc;
 if (peek == 'G' || peek == 'T')
-return d_special_name (di);
+dc = d_special_name (di);
 else
 {
-struct demangle_component *dc;
 dc = d_name (di);
-if (dc != NULL && top_level && (di->options & DMGL_PARAMS) == 0)
+if (!dc)
+	/* Failed already.  */;
+else if (top_level && (di->options & DMGL_PARAMS) == 0)
 	{
 	  /* Strip off any initial CV-qualifiers, as they really apply
 	     to the `this' parameter, and they were not output by the
 	     v2 demangler without DMGL_PARAMS.  */
-	  while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS
+	  while (is_fnqual_component_type (dc->type))
-		 || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS
-		 || dc->type == DEMANGLE_COMPONENT_CONST_THIS)
 	    dc = d_left (dc);
 	  /* If the top level is a DEMANGLE_COMPONENT_LOCAL_NAME, then
-	     there may be CV-qualifiers on its right argument which
+	     there may be function-qualifiers on its right argument which
 	     really apply here; this happens when parsing a class
 	     which is local to a function.  */
 	  if (dc->type == DEMANGLE_COMPONENT_LOCAL_NAME)
+	    while (is_fnqual_component_type (d_right (dc)->type))
+	      d_right (dc) = d_left (d_right (dc));
+	}
+else
+	{
+	  peek = d_peek_char (di);
+	  if (peek != '\0' && peek != 'E')
 	    {
-	      struct demangle_component *dcr;
+	      struct demangle_component *ftype;
-	      dcr = d_right (dc);
+	      ftype = d_bare_function_type (di, has_return_type (dc));
-	      while (dcr->type == DEMANGLE_COMPONENT_RESTRICT_THIS
+	      if (ftype)
-		     || dcr->type == DEMANGLE_COMPONENT_VOLATILE_THIS
+		{
-		     || dcr->type == DEMANGLE_COMPONENT_CONST_THIS)
+		  /* If this is a non-top-level local-name, clear the
-		dcr = d_left (dcr);
+		     return type, so it doesn't confuse the user by
-	      dc->u.s_binary.right = dcr;
+		     being confused with the return type of whaever
+		     this is nested within.  */
+		  if (!top_level && dc->type == DEMANGLE_COMPONENT_LOCAL_NAME
+		      && ftype->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
+		    d_left (ftype) = NULL;
+		  dc = d_make_comp (di, DEMANGLE_COMPONENT_TYPED_NAME,
+				    dc, ftype);
+		}
+	      else
+		dc = NULL;
 	    }
-	  return dc;
 	}
+}
-peek = d_peek_char (di);
-if (dc == NULL || peek == '\0' || peek == 'E')
+return dc;
-	return dc;
+}
-return d_make_comp (di, DEMANGLE_COMPONENT_TYPED_NAME, dc,
-			  d_bare_function_type (di, has_return_type (dc)));
+/* <tagged-name> ::= <name> B <source-name> */
-}
+static struct demangle_component *
+d_abi_tags (struct d_info *di, struct demangle_component *dc)
+{
+struct demangle_component *hold_last_name;
+char peek;
+/* Preserve the last name, so the ABI tag doesn't clobber it.  */
+hold_last_name = di->last_name;
+while (peek = d_peek_char (di),
+	 peek == 'B')
+{
+struct demangle_component *tag;
+d_advance (di, 1);
+tag = d_source_name (di);
+dc = d_make_comp (di, DEMANGLE_COMPONENT_TAGGED_NAME, dc, tag);
+}
+di->last_name = hold_last_name;
+return dc;
 }
 /* <name> ::= <nested-name>
 ::= <unscoped-name>
 ::= <unscoped-template-name> <template-args>
 return d_nested_name (di);
 case 'Z':
 return d_local_name (di);
-case 'L':
 case 'U':
 return d_unqualified_name (di);
 case 'S':
 {
 	  }
 	return dc;
 }
+case 'L':
 default:
 dc = d_unqualified_name (di);
 if (d_peek_char (di) == 'I')
 	{
 	  /* This is <template-args>, which means that we just saw
 	}
 return dc;
 }
 }
-/* <nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E
+/* <nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
-::= N [<CV-qualifiers>] <template-prefix> <template-args> E
+::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix> <template-args> E
 */
 static struct demangle_component *
 d_nested_name (struct d_info *di)
 {
 struct demangle_component *ret;
 struct demangle_component **pret;
+struct demangle_component *rqual;
 if (! d_check_char (di, 'N'))
 return NULL;
 pret = d_cv_qualifiers (di, &ret, 1);
 if (pret == NULL)
 return NULL;
+/* Parse the ref-qualifier now and then attach it
+once we have something to attach it to.  */
+rqual = d_ref_qualifier (di, NULL);
 *pret = d_prefix (di);
 if (*pret == NULL)
 return NULL;
+if (rqual)
+{
+d_left (rqual) = ret;
+ret = rqual;
+}
 if (! d_check_char (di, 'E'))
 return NULL;
 return ret;
 }
 /* <prefix> ::= <prefix> <unqualified-name>
 ::= <template-prefix> <template-args>
 ::= <template-param>
+::= <decltype>
 ::=
 ::= <substitution>
 <template-prefix> ::= <prefix> <(template) unqualified-name>
 ::= <template-param>
 /* The older code accepts a <local-name> here, but I don't see
 	 that in the grammar.  The older code does not accept a
 	 <template-param> here.  */
 comb_type = DEMANGLE_COMPONENT_QUAL_NAME;
-if (IS_DIGIT (peek)
+if (peek == 'D')
+	{
+	  char peek2 = d_peek_next_char (di);
+	  if (peek2 == 'T' || peek2 == 't')
+	    /* Decltype.  */
+	    dc = cplus_demangle_type (di);
+	  else
+	    /* Destructor name.  */
+	    dc = d_unqualified_name (di);
+	}
+else if (IS_DIGIT (peek)
 	  || IS_LOWER (peek)
 	  || peek == 'C'
-	  || peek == 'D'
 	  || peek == 'U'
 	  || peek == 'L')
 	dc = d_unqualified_name (di);
 else if (peek == 'S')
 	dc = d_substitution (di, 1);
 */
 static struct demangle_component *
 d_unqualified_name (struct d_info *di)
 {
+struct demangle_component *ret;
 char peek;
 peek = d_peek_char (di);
 if (IS_DIGIT (peek))
-return d_source_name (di);
+ret = d_source_name (di);
 else if (IS_LOWER (peek))
 {
-struct demangle_component *ret;
+if (peek == 'o' && d_peek_next_char (di) == 'n')
+	d_advance (di, 2);
 ret = d_operator_name (di);
 if (ret != NULL && ret->type == DEMANGLE_COMPONENT_OPERATOR)
-	di->expansion += sizeof "operator" + ret->u.s_operator.op->len - 2;
+	{
-return ret;
+	  di->expansion += sizeof "operator" + ret->u.s_operator.op->len - 2;
+	  if (!strcmp (ret->u.s_operator.op->code, "li"))
+	    ret = d_make_comp (di, DEMANGLE_COMPONENT_UNARY, ret,
+			       d_source_name (di));
+	}
 }
 else if (peek == 'C' || peek == 'D')
-return d_ctor_dtor_name (di);
+ret = d_ctor_dtor_name (di);
 else if (peek == 'L')
 {
-struct demangle_component * ret;
 d_advance (di, 1);
 ret = d_source_name (di);
 if (ret == NULL)
 	return NULL;
 if (! d_discriminator (di))
 	return NULL;
-return ret;
 }
 else if (peek == 'U')
 {
 switch (d_peek_next_char (di))
 	{
 	case 'l':
-	  return d_lambda (di);
+	  ret = d_lambda (di);
+	  break;
 	case 't':
-	  return d_unnamed_type (di);
+	  ret = d_unnamed_type (di);
+	  break;
 	default:
 	  return NULL;
 	}
 }
 else
 return NULL;
+if (d_peek_char (di) == 'B')
+ret = d_abi_tags (di, ret);
+return ret;
 }
 /* <source-name> ::= <(positive length) number> <identifier>  */
 static struct demangle_component *
 d_source_name (struct d_info *di)
 {
-long len;
+int len;
 struct demangle_component *ret;
 len = d_number (di);
 if (len <= 0)
 return NULL;
 return ret;
 }
 /* number ::= [n] <(non-negative decimal integer)>  */
-static long
+static int
 d_number (struct d_info *di)
 {
 int negative;
 char peek;
-long ret;
+int ret;
 negative = 0;
 peek = d_peek_char (di);
 if (peek == 'n')
 {
 	{
 	  if (negative)
 	    ret = - ret;
 	  return ret;
 	}
+if (ret > ((INT_MAX - (peek - '0')) / 10))
+return -1;
 ret = ret * 10 + peek - '0';
 d_advance (di, 1);
 peek = d_peek_char (di);
 }
 }
 }
 /* operator_name ::= many different two character encodings.
 ::= cv <type>
 ::= v <digit> <source-name>
-*/
+This list is sorted for binary search.  */
 #define NL(s) s, (sizeof s) - 1
 CP_STATIC_IF_GLIBCPP_V3
 const struct demangle_operator_info cplus_demangle_operators[] =
 { "aN", NL ("&="),        2 },
 { "aS", NL ("="),         2 },
 { "aa", NL ("&&"),        2 },
 { "ad", NL ("&"),         1 },
 { "an", NL ("&"),         2 },
+{ "at", NL ("alignof "),   1 },
+{ "az", NL ("alignof "),   1 },
+{ "cc", NL ("const_cast"), 2 },
 { "cl", NL ("()"),        2 },
 { "cm", NL (","),         2 },
 { "co", NL ("~"),         1 },
 { "dV", NL ("/="),        2 },
-{ "da", NL ("delete[]"),  1 },
+{ "da", NL ("delete[] "), 1 },
+{ "dc", NL ("dynamic_cast"), 2 },
 { "de", NL ("*"),         1 },
-{ "dl", NL ("delete"),    1 },
+{ "dl", NL ("delete "),   1 },
+{ "ds", NL (".*"),        2 },
 { "dt", NL ("."),         2 },
 { "dv", NL ("/"),         2 },
 { "eO", NL ("^="),        2 },
 { "eo", NL ("^"),         2 },
 { "eq", NL ("=="),        2 },
+{ "fL", NL ("..."),       3 },
+{ "fR", NL ("..."),       3 },
+{ "fl", NL ("..."),       2 },
+{ "fr", NL ("..."),       2 },
 { "ge", NL (">="),        2 },
+{ "gs", NL ("::"),	    1 },
 { "gt", NL (">"),         2 },
 { "ix", NL ("[]"),        2 },
 { "lS", NL ("<<="),       2 },
 { "le", NL ("<="),        2 },
+{ "li", NL ("operator\"\" "), 1 },
 { "ls", NL ("<<"),        2 },
 { "lt", NL ("<"),         2 },
 { "mI", NL ("-="),        2 },
 { "mL", NL ("*="),        2 },
 { "mi", NL ("-"),         2 },
 { "ml", NL ("*"),         2 },
 { "mm", NL ("--"),        1 },
-{ "na", NL ("new[]"),     1 },
+{ "na", NL ("new[]"),     3 },
 { "ne", NL ("!="),        2 },
 { "ng", NL ("-"),         1 },
 { "nt", NL ("!"),         1 },
-{ "nw", NL ("new"),       1 },
+{ "nw", NL ("new"),       3 },
 { "oR", NL ("|="),        2 },
 { "oo", NL ("||"),        2 },
 { "or", NL ("|"),         2 },
 { "pL", NL ("+="),        2 },
 { "pl", NL ("+"),         2 },
 { "ps", NL ("+"),         1 },
 { "pt", NL ("->"),        2 },
 { "qu", NL ("?"),         3 },
 { "rM", NL ("%="),        2 },
 { "rS", NL (">>="),       2 },
+{ "rc", NL ("reinterpret_cast"), 2 },
 { "rm", NL ("%"),         2 },
 { "rs", NL (">>"),        2 },
+{ "sP", NL ("sizeof..."), 1 },
+{ "sZ", NL ("sizeof..."), 1 },
+{ "sc", NL ("static_cast"), 2 },
 { "st", NL ("sizeof "),   1 },
 { "sz", NL ("sizeof "),   1 },
-{ "at", NL ("alignof "),   1 },
+{ "tr", NL ("throw"),     0 },
-{ "az", NL ("alignof "),   1 },
+{ "tw", NL ("throw "),    1 },
 { NULL, NULL, 0,          0 }
 };
 static struct demangle_component *
 d_operator_name (struct d_info *di)
 c1 = d_next_char (di);
 c2 = d_next_char (di);
 if (c1 == 'v' && IS_DIGIT (c2))
 return d_make_extended_operator (di, c2 - '0', d_source_name (di));
 else if (c1 == 'c' && c2 == 'v')
-return d_make_comp (di, DEMANGLE_COMPONENT_CAST,
+{
-			cplus_demangle_type (di), NULL);
+struct demangle_component *type;
+int was_conversion = di->is_conversion;
+struct demangle_component *res;
+di->is_conversion = ! di->is_expression;
+type = cplus_demangle_type (di);
+if (di->is_conversion)
+	res = d_make_comp (di, DEMANGLE_COMPONENT_CONVERSION, type, NULL);
+else
+	res = d_make_comp (di, DEMANGLE_COMPONENT_CAST, type, NULL);
+di->is_conversion = was_conversion;
+return res;
+}
 else
 {
 /* LOW is the inclusive lower bound.  */
 int low = 0;
 /* HIGH is the exclusive upper bound.  We subtract one to ignore
 static struct demangle_component *
 d_java_resource (struct d_info *di)
 {
 struct demangle_component *p = NULL;
 struct demangle_component *next = NULL;
-long len, i;
+int len, i;
 char c;
 const char *str;
 len = d_number (di);
 if (len <= 1)
 ::= TF <type>
 ::= TJ <type>
 ::= GR <name>
 		  ::= GA <encoding>
 		  ::= Gr <resource name>
+		  ::= GTt <encoding>
+		  ::= GTn <encoding>
 */
 static struct demangle_component *
 d_special_name (struct d_info *di)
 {
 			      d_encoding (di, 0), NULL);
 	case 'C':
 	  {
 	    struct demangle_component *derived_type;
-	    long offset;
+	    int offset;
 	    struct demangle_component *base_type;
 	    derived_type = cplus_demangle_type (di);
 	    offset = d_number (di);
 	    if (offset < 0)
 			      cplus_demangle_type (di), NULL);
 	case 'J':
 	  return d_make_comp (di, DEMANGLE_COMPONENT_JAVA_CLASS,
 			      cplus_demangle_type (di), NULL);
+	case 'H':
+	  return d_make_comp (di, DEMANGLE_COMPONENT_TLS_INIT,
+			      d_name (di), NULL);
+	case 'W':
+	  return d_make_comp (di, DEMANGLE_COMPONENT_TLS_WRAPPER,
+			      d_name (di), NULL);
 	default:
 	  return NULL;
 	}
 }
 else if (d_check_char (di, 'G'))
 {
 switch (d_next_char (di))
 	{
 	case 'V':
-	  return d_make_comp (di, DEMANGLE_COMPONENT_GUARD, d_name (di), NULL);
+	  return d_make_comp (di, DEMANGLE_COMPONENT_GUARD,
+			      d_name (di), NULL);
 	case 'R':
-	  return d_make_comp (di, DEMANGLE_COMPONENT_REFTEMP, d_name (di),
+	  {
-			      NULL);
+	    struct demangle_component *name = d_name (di);
+	    return d_make_comp (di, DEMANGLE_COMPONENT_REFTEMP, name,
+				d_number_component (di));
+	  }
 	case 'A':
 	  return d_make_comp (di, DEMANGLE_COMPONENT_HIDDEN_ALIAS,
 			      d_encoding (di, 0), NULL);
+	case 'T':
+	  switch (d_next_char (di))
+	    {
+	    case 'n':
+	      return d_make_comp (di, DEMANGLE_COMPONENT_NONTRANSACTION_CLONE,
+				  d_encoding (di, 0), NULL);
+	    default:
+	      /* ??? The proposal is that other letters (such as 'h') stand
+		 for different variants of transaction cloning, such as
+		 compiling directly for hardware transaction support.  But
+		 they still should all be transactional clones of some sort
+		 so go ahead and call them that.  */
+	    case 't':
+	      return d_make_comp (di, DEMANGLE_COMPONENT_TRANSACTION_CLONE,
+				  d_encoding (di, 0), NULL);
+	    }
 	case 'r':
 	  return d_java_resource (di);
 	default:
 switch (d_peek_char (di))
 {
 case 'C':
 {
 	enum gnu_v3_ctor_kinds kind;
+	int inheriting = 0;
+	if (d_peek_next_char (di) == 'I')
+	  {
+	    inheriting = 1;
+	    d_advance (di, 1);
+	  }
 	switch (d_peek_next_char (di))
 	  {
 	  case '1':
 	    kind = gnu_v3_complete_object_ctor;
 	    kind = gnu_v3_base_object_ctor;
 	    break;
 	  case '3':
 	    kind = gnu_v3_complete_object_allocating_ctor;
 	    break;
+case '4':
+	    kind = gnu_v3_unified_ctor;
+	    break;
+	  case '5':
+	    kind = gnu_v3_object_ctor_group;
+	    break;
 	  default:
 	    return NULL;
 	  }
 	d_advance (di, 2);
+	if (inheriting)
+	  cplus_demangle_type (di);
 	return d_make_ctor (di, kind, di->last_name);
 }
 case 'D':
 {
 	    kind = gnu_v3_complete_object_dtor;
 	    break;
 	  case '2':
 	    kind = gnu_v3_base_object_dtor;
 	    break;
+/*  digit '3' is not used */
+	  case '4':
+	    kind = gnu_v3_unified_dtor;
+	    break;
+	  case '5':
+	    kind = gnu_v3_object_dtor_group;
+	    break;
 	  default:
 	    return NULL;
 	  }
 	d_advance (di, 2);
 	return d_make_dtor (di, kind, di->last_name);
 }
 default:
 return NULL;
 }
+}
+/* True iff we're looking at an order-insensitive type-qualifier, including
+function-type-qualifiers.  */
+static int
+next_is_type_qual (struct d_info *di)
+{
+char peek = d_peek_char (di);
+if (peek == 'r' || peek == 'V' || peek == 'K')
+return 1;
+if (peek == 'D')
+{
+peek = d_peek_next_char (di);
+if (peek == 'x' || peek == 'o' || peek == 'O' || peek == 'w')
+	return 1;
+}
+return 0;
 }
 /* <type> ::= <builtin-type>
 ::= <function-type>
 ::= <class-enum-type>
 order-sensitive.  So we just assume that they are all
 order-sensitive.  g++ 3.4 supports only one vendor qualifier,
 __vector, and it treats it as order-sensitive when mangling
 names.  */
-peek = d_peek_char (di);
+if (next_is_type_qual (di))
-if (peek == 'r' || peek == 'V' || peek == 'K')
 {
 struct demangle_component **pret;
 pret = d_cv_qualifiers (di, &ret, 0);
 if (pret == NULL)
 	return NULL;
-*pret = cplus_demangle_type (di);
+if (d_peek_char (di) == 'F')
-if (! *pret || ! d_add_substitution (di, ret))
+	{
+	  /* cv-qualifiers before a function type apply to 'this',
+	     so avoid adding the unqualified function type to
+	     the substitution list.  */
+	  *pret = d_function_type (di);
+	}
+else
+	*pret = cplus_demangle_type (di);
+if (!*pret)
+	return NULL;
+if ((*pret)->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
+	  || (*pret)->type == DEMANGLE_COMPONENT_REFERENCE_THIS)
+	{
+	  /* Move the ref-qualifier outside the cv-qualifiers so that
+	     they are printed in the right order.  */
+	  struct demangle_component *fn = d_left (*pret);
+	  d_left (*pret) = ret;
+	  ret = *pret;
+	  *pret = fn;
+	}
+if (! d_add_substitution (di, ret))
 	return NULL;
 return ret;
 }
 can_subst = 1;
+peek = d_peek_char (di);
 switch (peek)
 {
 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
 case 'h': case 'i': case 'j':           case 'l': case 'm': case 'n':
 case 'o':                               case 's': case 't':
 case 'T':
 ret = d_template_param (di);
 if (d_peek_char (di) == 'I')
 	{
-	  /* This is <template-template-param> <template-args>.  The
+	  /* This may be <template-template-param> <template-args>.
-	     <template-template-param> part is a substitution
+	     If this is the type for a conversion operator, we can
+	     have a <template-template-param> here only by following
+	     a derivation like this:
+	     <nested-name>
+	     -> <template-prefix> <template-args>
+	     -> <prefix> <template-unqualified-name> <template-args>
+	     -> <unqualified-name> <template-unqualified-name> <template-args>
+	     -> <source-name> <template-unqualified-name> <template-args>
+	     -> <source-name> <operator-name> <template-args>
+	     -> <source-name> cv <type> <template-args>
+	     -> <source-name> cv <template-template-param> <template-args> <template-args>
+	     where the <template-args> is followed by another.
+	     Otherwise, we must have a derivation like this:
+	     <nested-name>
+	     -> <template-prefix> <template-args>
+	     -> <prefix> <template-unqualified-name> <template-args>
+	     -> <unqualified-name> <template-unqualified-name> <template-args>
+	     -> <source-name> <template-unqualified-name> <template-args>
+	     -> <source-name> <operator-name> <template-args>
+	     -> <source-name> cv <type> <template-args>
+	     -> <source-name> cv <template-param> <template-args>
+	     where we need to leave the <template-args> to be processed
+	     by d_prefix (following the <template-prefix>).
+	     The <template-template-param> part is a substitution
 	     candidate.  */
-	  if (! d_add_substitution (di, ret))
+	  if (! di->is_conversion)
-	    return NULL;
+	    {
-	  ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
+	      if (! d_add_substitution (di, ret))
-			     d_template_args (di));
+		return NULL;
+	      ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
+				 d_template_args (di));
+	    }
+	  else
+	    {
+	      struct demangle_component *args;
+	      struct d_info_checkpoint checkpoint;
+	      d_checkpoint (di, &checkpoint);
+	      args = d_template_args (di);
+	      if (d_peek_char (di) == 'I')
+		{
+		  if (! d_add_substitution (di, ret))
+		    return NULL;
+		  ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
+				     args);
+		}
+	      else
+		d_backtrack (di, &checkpoint);
+	    }
 	}
 break;
 case 'S':
 /* If this is a special substitution, then it is the start of
 break;
 case 'U':
 d_advance (di, 1);
 ret = d_source_name (di);
+if (d_peek_char (di) == 'I')
+	ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
+			   d_template_args (di));
 ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL,
 			 cplus_demangle_type (di), ret);
 break;
 case 'D':
 	  /* decltype (expression) */
 	  ret = d_make_comp (di, DEMANGLE_COMPONENT_DECLTYPE,
 			     d_expression (di), NULL);
 	  if (ret && d_next_char (di) != 'E')
 	    ret = NULL;
+	  can_subst = 1;
 	  break;
 	case 'p':
 	  /* Pack expansion.  */
 	  ret = d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION,
 			     cplus_demangle_type (di), NULL);
+	  can_subst = 1;
 	  break;
+	case 'a':
+	  /* auto */
+	  ret = d_make_name (di, "auto", 4);
+	  break;
+	case 'c':
+	  /* decltype(auto) */
+	  ret = d_make_name (di, "decltype(auto)", 14);
+	  break;
 	case 'f':
 	  /* 32-bit decimal floating point */
 	  ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[26]);
 	  di->expansion += ret->u.s_builtin.type->len;
 	  break;
 	  ret->u.s_fixed.sat = (peek == 's');
 	  break;
 	case 'v':
 	  ret = d_vector_type (di);
+	  can_subst = 1;
 	  break;
 case 'n':
 /* decltype(nullptr) */
 	  ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[32]);
 }
 return ret;
 }
-/* <CV-qualifiers> ::= [r] [V] [K]  */
+/* <CV-qualifiers> ::= [r] [V] [K] [Dx] */
 static struct demangle_component **
 d_cv_qualifiers (struct d_info *di,
 struct demangle_component **pret, int member_fn)
 {
+struct demangle_component **pstart;
 char peek;
+pstart = pret;
 peek = d_peek_char (di);
-while (peek == 'r' || peek == 'V' || peek == 'K')
+while (next_is_type_qual (di))
 {
 enum demangle_component_type t;
+struct demangle_component *right = NULL;
 d_advance (di, 1);
 if (peek == 'r')
 	{
 	  t = (member_fn
 	  t = (member_fn
 	       ? DEMANGLE_COMPONENT_VOLATILE_THIS
 	       : DEMANGLE_COMPONENT_VOLATILE);
 	  di->expansion += sizeof "volatile";
 	}
-else
+else if (peek == 'K')
 	{
 	  t = (member_fn
 	       ? DEMANGLE_COMPONENT_CONST_THIS
 	       : DEMANGLE_COMPONENT_CONST);
 	  di->expansion += sizeof "const";
 	}
+else
-*pret = d_make_comp (di, t, NULL, NULL);
+	{
+	  peek = d_next_char (di);
+	  if (peek == 'x')
+	    {
+	      t = DEMANGLE_COMPONENT_TRANSACTION_SAFE;
+	      di->expansion += sizeof "transaction_safe";
+	    }
+	  else if (peek == 'o'
+		   || peek == 'O')
+	    {
+	      t = DEMANGLE_COMPONENT_NOEXCEPT;
+	      di->expansion += sizeof "noexcept";
+	      if (peek == 'O')
+		{
+		  right = d_expression (di);
+		  if (right == NULL)
+		    return NULL;
+		  if (! d_check_char (di, 'E'))
+		    return NULL;
+		}
+	    }
+	  else if (peek == 'w')
+	    {
+	      t = DEMANGLE_COMPONENT_THROW_SPEC;
+	      di->expansion += sizeof "throw";
+	      right = d_parmlist (di);
+	      if (right == NULL)
+		return NULL;
+	      if (! d_check_char (di, 'E'))
+		return NULL;
+	    }
+	  else
+	    return NULL;
+	}
+*pret = d_make_comp (di, t, NULL, right);
 if (*pret == NULL)
 	return NULL;
 pret = &d_left (*pret);
 peek = d_peek_char (di);
 }
+if (!member_fn && peek == 'F')
+{
+while (pstart != pret)
+	{
+	  switch ((*pstart)->type)
+	    {
+	    case DEMANGLE_COMPONENT_RESTRICT:
+	      (*pstart)->type = DEMANGLE_COMPONENT_RESTRICT_THIS;
+	      break;
+	    case DEMANGLE_COMPONENT_VOLATILE:
+	      (*pstart)->type = DEMANGLE_COMPONENT_VOLATILE_THIS;
+	      break;
+	    case DEMANGLE_COMPONENT_CONST:
+	      (*pstart)->type = DEMANGLE_COMPONENT_CONST_THIS;
+	      break;
+	    default:
+	      break;
+	    }
+	  pstart = &d_left (*pstart);
+	}
+}
 return pret;
 }
-/* <function-type> ::= F [Y] <bare-function-type> E  */
+/* <ref-qualifier> ::= R
+::= O */
+static struct demangle_component *
+d_ref_qualifier (struct d_info *di, struct demangle_component *sub)
+{
+struct demangle_component *ret = sub;
+char peek;
+peek = d_peek_char (di);
+if (peek == 'R' || peek == 'O')
+{
+enum demangle_component_type t;
+if (peek == 'R')
+	{
+	  t = DEMANGLE_COMPONENT_REFERENCE_THIS;
+	  di->expansion += sizeof "&";
+	}
+else
+	{
+	  t = DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS;
+	  di->expansion += sizeof "&&";
+	}
+d_advance (di, 1);
+ret = d_make_comp (di, t, ret, NULL);
+}
+return ret;
+}
+/* <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] [T] E  */
 static struct demangle_component *
 d_function_type (struct d_info *di)
 {
 struct demangle_component *ret;
 /* Function has C linkage.  We don't print this information.
 	 FIXME: We should print it in verbose mode.  */
 d_advance (di, 1);
 }
 ret = d_bare_function_type (di, 1);
+ret = d_ref_qualifier (di, ret);
 if (! d_check_char (di, 'E'))
 return NULL;
 return ret;
 }
 while (1)
 {
 struct demangle_component *type;
 char peek = d_peek_char (di);
-if (peek == '\0' || peek == 'E')
+if (peek == '\0' || peek == 'E' || peek == '.')
+	break;
+if ((peek == 'R' || peek == 'O')
+	  && d_peek_next_char (di) == 'E')
+	/* Function ref-qualifier, not a ref prefix for a parameter type.  */
 	break;
 type = cplus_demangle_type (di);
 if (type == NULL)
 	return NULL;
 *ptl = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, type, NULL);
 static struct demangle_component *
 d_pointer_to_member_type (struct d_info *di)
 {
 struct demangle_component *cl;
 struct demangle_component *mem;
-struct demangle_component **pmem;
 if (! d_check_char (di, 'M'))
 return NULL;
 cl = cplus_demangle_type (di);
+if (cl == NULL)
-/* The ABI specifies that any type can be a substitution source, and
-that M is followed by two types, and that when a CV-qualified
-type is seen both the base type and the CV-qualified types are
-substitution sources.  The ABI also specifies that for a pointer
-to a CV-qualified member function, the qualifiers are attached to
-the second type.  Given the grammar, a plain reading of the ABI
-suggests that both the CV-qualified member function and the
-non-qualified member function are substitution sources.  However,
-g++ does not work that way.  g++ treats only the CV-qualified
-member function as a substitution source.  FIXME.  So to work
-with g++, we need to pull off the CV-qualifiers here, in order to
-avoid calling add_substitution() in cplus_demangle_type().  But
-for a CV-qualified member which is not a function, g++ does
-follow the ABI, so we need to handle that case here by calling
-d_add_substitution ourselves.  */
-pmem = d_cv_qualifiers (di, &mem, 1);
-if (pmem == NULL)
 return NULL;
-*pmem = cplus_demangle_type (di);
-if (*pmem == NULL)
+/* The ABI says, "The type of a non-static member function is considered
+to be different, for the purposes of substitution, from the type of a
+namespace-scope or static member function whose type appears
+similar. The types of two non-static member functions are considered
+to be different, for the purposes of substitution, if the functions
+are members of different classes. In other words, for the purposes of
+substitution, the class of which the function is a member is
+considered part of the type of function."
+For a pointer to member function, this call to cplus_demangle_type
+will end up adding a (possibly qualified) non-member function type to
+the substitution table, which is not correct; however, the member
+function type will never be used in a substitution, so putting the
+wrong type in the substitution table is harmless.  */
+mem = cplus_demangle_type (di);
+if (mem == NULL)
 return NULL;
-if (pmem != &mem && (*pmem)->type != DEMANGLE_COMPONENT_FUNCTION_TYPE)
-{
-if (! d_add_substitution (di, mem))
-	return NULL;
-}
 return d_make_comp (di, DEMANGLE_COMPONENT_PTRMEM_TYPE, cl, mem);
 }
 /* <non-negative number> _ */
-static long
+static int
 d_compact_number (struct d_info *di)
 {
-long num;
+int num;
 if (d_peek_char (di) == '_')
 num = 0;
 else if (d_peek_char (di) == 'n')
 return -1;
 else
 num = d_number (di) + 1;
-if (! d_check_char (di, '_'))
+if (num < 0 || ! d_check_char (di, '_'))
 return -1;
 return num;
 }
 /* <template-param> ::= T_
 */
 static struct demangle_component *
 d_template_param (struct d_info *di)
 {
-long param;
+int param;
 if (! d_check_char (di, 'T'))
 return NULL;
 param = d_compact_number (di);
 if (param < 0)
 return NULL;
-++di->did_subs;
 return d_make_template_param (di, param);
 }
 /* <template-args> ::= I <template-arg>+ E  */
 static struct demangle_component *
 d_template_args (struct d_info *di)
+{
+if (d_peek_char (di) != 'I'
+&& d_peek_char (di) != 'J')
+return NULL;
+d_advance (di, 1);
+return d_template_args_1 (di);
+}
+/* <template-arg>* E  */
+static struct demangle_component *
+d_template_args_1 (struct d_info *di)
 {
 struct demangle_component *hold_last_name;
 struct demangle_component *al;
 struct demangle_component **pal;
 /* Preserve the last name we saw--don't let the template arguments
 clobber it, as that would give us the wrong name for a subsequent
 constructor or destructor.  */
 hold_last_name = di->last_name;
-if (! d_check_char (di, 'I'))
-return NULL;
 if (d_peek_char (di) == 'E')
 {
 /* An argument pack can be empty.  */
 d_advance (di, 1);
 case 'L':
 return d_expr_primary (di);
 case 'I':
+case 'J':
 /* An argument pack.  */
 return d_template_args (di);
 default:
 return cplus_demangle_type (di);
 }
 }
-/* Subroutine of <expression> ::= cl <expression>+ E */
+/* Parse a sequence of expressions until we hit the terminator
+character.  */
-static struct demangle_component *
-d_exprlist (struct d_info *di)
+static struct demangle_component *
+d_exprlist (struct d_info *di, char terminator)
 {
 struct demangle_component *list = NULL;
 struct demangle_component **p = &list;
-if (d_peek_char (di) == 'E')
+if (d_peek_char (di) == terminator)
 {
 d_advance (di, 1);
 return d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, NULL, NULL);
 }
 *p = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, arg, NULL);
 if (*p == NULL)
 	return NULL;
 p = &d_right (*p);
-if (d_peek_char (di) == 'E')
+if (d_peek_char (di) == terminator)
 	{
 	  d_advance (di, 1);
 	  break;
 	}
 }
 return list;
+}
+/* Returns nonzero iff OP is an operator for a C++ cast: const_cast,
+dynamic_cast, static_cast or reinterpret_cast.  */
+static int
+op_is_new_cast (struct demangle_component *op)
+{
+const char *code = op->u.s_operator.op->code;
+return (code[1] == 'c'
+	  && (code[0] == 's' || code[0] == 'd'
+	      || code[0] == 'c' || code[0] == 'r'));
 }
 /* <expression> ::= <(unary) operator-name> <expression>
 ::= <(binary) operator-name> <expression> <expression>
 ::= <(trinary) operator-name> <expression> <expression> <expression>
 ::= sr <type> <unqualified-name>
 ::= sr <type> <unqualified-name> <template-args>
 ::= <expr-primary>
 */
-static struct demangle_component *
+static inline struct demangle_component *
-d_expression (struct d_info *di)
+d_expression_1 (struct d_info *di)
 {
 char peek;
 peek = d_peek_char (di);
 if (peek == 'L')
 }
 else if (peek == 's' && d_peek_next_char (di) == 'p')
 {
 d_advance (di, 2);
 return d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION,
-			  d_expression (di), NULL);
+			  d_expression_1 (di), NULL);
 }
 else if (peek == 'f' && d_peek_next_char (di) == 'p')
 {
 /* Function parameter used in a late-specified return type.  */
 int index;
 d_advance (di, 2);
-index = d_compact_number (di);
+if (d_peek_char (di) == 'T')
-if (index < 0)
+	{
-	return NULL;
+	  /* 'this' parameter.  */
+	  d_advance (di, 1);
+	  index = 0;
+	}
+else
+	{
+	  index = d_compact_number (di);
+	  if (index == INT_MAX || index == -1)
+	    return NULL;
+	  index++;
+	}
 return d_make_function_param (di, index);
 }
 else if (IS_DIGIT (peek)
 	   || (peek == 'o' && d_peek_next_char (di) == 'n'))
 {
 	return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
 			    d_template_args (di));
 else
 	return name;
 }
+else if ((peek == 'i' || peek == 't')
+	   && d_peek_next_char (di) == 'l')
+{
+/* Brace-enclosed initializer list, untyped or typed.  */
+struct demangle_component *type = NULL;
+if (peek == 't')
+	type = cplus_demangle_type (di);
+if (!d_peek_next_char (di))
+	return NULL;
+d_advance (di, 2);
+return d_make_comp (di, DEMANGLE_COMPONENT_INITIALIZER_LIST,
+			  type, d_exprlist (di, 'E'));
+}
 else
 {
 struct demangle_component *op;
+const char *code = NULL;
 int args;
 op = d_operator_name (di);
 if (op == NULL)
 	return NULL;
 if (op->type == DEMANGLE_COMPONENT_OPERATOR)
-	di->expansion += op->u.s_operator.op->len - 2;
+	{
+	  code = op->u.s_operator.op->code;
-if (op->type == DEMANGLE_COMPONENT_OPERATOR
+	  di->expansion += op->u.s_operator.op->len - 2;
-	  && strcmp (op->u.s_operator.op->code, "st") == 0)
+	  if (strcmp (code, "st") == 0)
-	return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
+	    return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
-			    cplus_demangle_type (di));
+				cplus_demangle_type (di));
+	}
 switch (op->type)
 	{
 	default:
 	  return NULL;
 	  break;
 	}
 switch (args)
 	{
+	case 0:
+	  return d_make_comp (di, DEMANGLE_COMPONENT_NULLARY, op, NULL);
 	case 1:
 	  {
 	    struct demangle_component *operand;
+	    int suffix = 0;
+	    if (code && (code[0] == 'p' || code[0] == 'm')
+		&& code[1] == code[0])
+	      /* pp_ and mm_ are the prefix variants.  */
+	      suffix = !d_check_char (di, '_');
 	    if (op->type == DEMANGLE_COMPONENT_CAST
 		&& d_check_char (di, '_'))
-	      operand = d_exprlist (di);
+	      operand = d_exprlist (di, 'E');
+	    else if (code && !strcmp (code, "sP"))
+	      operand = d_template_args_1 (di);
 	    else
-	      operand = d_expression (di);
+	      operand = d_expression_1 (di);
-	    return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
-				operand);
+	    if (suffix)
+	      /* Indicate the suffix variant for d_print_comp.  */
+	      operand = d_make_comp (di, DEMANGLE_COMPONENT_BINARY_ARGS,
+				     operand, operand);
+	    return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op, operand);
 	  }
 	case 2:
 	  {
 	    struct demangle_component *left;
 	    struct demangle_component *right;
-	    const char *code = op->u.s_operator.op->code;
+	    if (code == NULL)
-	    left = d_expression (di);
+	      return NULL;
+	    if (op_is_new_cast (op))
+	      left = cplus_demangle_type (di);
+	    else if (code[0] == 'f')
+	      /* fold-expression.  */
+	      left = d_operator_name (di);
+	    else
+	      left = d_expression_1 (di);
 	    if (!strcmp (code, "cl"))
-	      right = d_exprlist (di);
+	      right = d_exprlist (di, 'E');
 	    else if (!strcmp (code, "dt") || !strcmp (code, "pt"))
 	      {
 		right = d_unqualified_name (di);
 		if (d_peek_char (di) == 'I')
 		  right = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE,
 				       right, d_template_args (di));
 	      }
 	    else
-	      right = d_expression (di);
+	      right = d_expression_1 (di);
 	    return d_make_comp (di, DEMANGLE_COMPONENT_BINARY, op,
 				d_make_comp (di,
 					     DEMANGLE_COMPONENT_BINARY_ARGS,
 					     left, right));
 	  }
 	case 3:
 	  {
 	    struct demangle_component *first;
 	    struct demangle_component *second;
+	    struct demangle_component *third;
-	    first = d_expression (di);
-	    second = d_expression (di);
+	    if (code == NULL)
+	      return NULL;
+	    else if (!strcmp (code, "qu"))
+	      {
+		/* ?: expression.  */
+		first = d_expression_1 (di);
+		second = d_expression_1 (di);
+		third = d_expression_1 (di);
+		if (third == NULL)
+		  return NULL;
+	      }
+	    else if (code[0] == 'f')
+	      {
+		/* fold-expression.  */
+		first = d_operator_name (di);
+		second = d_expression_1 (di);
+		third = d_expression_1 (di);
+		if (third == NULL)
+		  return NULL;
+	      }
+	    else if (code[0] == 'n')
+	      {
+		/* new-expression.  */
+		if (code[1] != 'w' && code[1] != 'a')
+		  return NULL;
+		first = d_exprlist (di, '_');
+		second = cplus_demangle_type (di);
+		if (d_peek_char (di) == 'E')
+		  {
+		    d_advance (di, 1);
+		    third = NULL;
+		  }
+		else if (d_peek_char (di) == 'p'
+			 && d_peek_next_char (di) == 'i')
+		  {
+		    /* Parenthesized initializer.  */
+		    d_advance (di, 2);
+		    third = d_exprlist (di, 'E');
+		  }
+		else if (d_peek_char (di) == 'i'
+			 && d_peek_next_char (di) == 'l')
+		  /* initializer-list.  */
+		  third = d_expression_1 (di);
+		else
+		  return NULL;
+	      }
+	    else
+	      return NULL;
 	    return d_make_comp (di, DEMANGLE_COMPONENT_TRINARY, op,
 				d_make_comp (di,
 					     DEMANGLE_COMPONENT_TRINARY_ARG1,
 					     first,
 					     d_make_comp (di,
 							  DEMANGLE_COMPONENT_TRINARY_ARG2,
-							  second,
+							  second, third)));
-							  d_expression (di))));
 	  }
 	default:
 	  return NULL;
 	}
 }
+}
+static struct demangle_component *
+d_expression (struct d_info *di)
+{
+struct demangle_component *ret;
+int was_expression = di->is_expression;
+di->is_expression = 1;
+ret = d_expression_1 (di);
+di->is_expression = was_expression;
+return ret;
 }
 /* <expr-primary> ::= L <type> <(value) number> E
 ::= L <type> <(value) float> E
 ::= L <mangled-name> E
 return ret;
 }
 /* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>]
 ::= Z <(function) encoding> E s [<discriminator>]
+::= Z <(function) encoding> E d [<parameter> number>] _ <entity name>
 */
 static struct demangle_component *
 d_local_name (struct d_info *di)
 {
 struct demangle_component *function;
+struct demangle_component *name;
 if (! d_check_char (di, 'Z'))
 return NULL;
 function = d_encoding (di, 0);
+if (!function)
+return NULL;
 if (! d_check_char (di, 'E'))
 return NULL;
 if (d_peek_char (di) == 's')
 {
 d_advance (di, 1);
 if (! d_discriminator (di))
 	return NULL;
-return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function,
+name = d_make_name (di, "string literal", sizeof "string literal" - 1);
-			  d_make_name (di, "string literal",
-				       sizeof "string literal" - 1));
 }
 else
 {
-struct demangle_component *name;
 int num = -1;
 if (d_peek_char (di) == 'd')
 	{
 	  /* Default argument scope: d <number> _.  */
 	  if (num < 0)
 	    return NULL;
 	}
 name = d_name (di);
-if (name)
-	switch (name->type)
+if (name
-	  {
+	  /* Lambdas and unnamed types have internal discriminators
-	    /* Lambdas and unnamed types have internal discriminators.  */
+	     and are not functions.  */
-	  case DEMANGLE_COMPONENT_LAMBDA:
+	  && name->type != DEMANGLE_COMPONENT_LAMBDA
-	  case DEMANGLE_COMPONENT_UNNAMED_TYPE:
+	  && name->type != DEMANGLE_COMPONENT_UNNAMED_TYPE)
-	    break;
+	{
-	  default:
+	  /* Read and ignore an optional discriminator.  */
-	    if (! d_discriminator (di))
+	  if (! d_discriminator (di))
-	      return NULL;
+	    return NULL;
-	  }
+	}
 if (num >= 0)
 	name = d_make_default_arg (di, num, name);
-return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function, name);
+}
-}
-}
+/* Elide the return type of the containing function so as to not
+confuse the user thinking it is the return type of whatever local
-/* <discriminator> ::= _ <(non-negative) number>
+function we might be containing.  */
+if (function->type == DEMANGLE_COMPONENT_TYPED_NAME
+&& d_right (function)->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
+d_left (d_right (function)) = NULL;
+return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function, name);
+}
+/* <discriminator> ::= _ <number>    # when number < 10
+::= __ <number> _ # when number >= 10
+<discriminator> ::= _ <number>    # when number >=10
+is also accepted to support gcc versions that wrongly mangled that way.
 We demangle the discriminator, but we don't print it out.  FIXME:
 We should print it out in verbose mode.  */
 static int
 d_discriminator (struct d_info *di)
 {
-long discrim;
+int discrim, num_underscores = 1;
 if (d_peek_char (di) != '_')
 return 1;
 d_advance (di, 1);
+if (d_peek_char (di) == '_')
+{
+++num_underscores;
+d_advance (di, 1);
+}
 discrim = d_number (di);
 if (discrim < 0)
 return 0;
+if (num_underscores > 1 && discrim >= 10)
+{
+if (d_peek_char (di) == '_')
+	d_advance (di, 1);
+else
+	return 0;
+}
 return 1;
 }
 /* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _ */
 static struct demangle_component *
 d_unnamed_type (struct d_info *di)
 {
 struct demangle_component *ret;
-long num;
+int num;
 if (! d_check_char (di, 'U'))
 return NULL;
 if (! d_check_char (di, 't'))
 return NULL;
 if (! d_add_substitution (di, ret))
 return NULL;
 return ret;
+}
+/* <clone-suffix> ::= [ . <clone-type-identifier> ] [ . <nonnegative number> ]*
+*/
+static struct demangle_component *
+d_clone_suffix (struct d_info *di, struct demangle_component *encoding)
+{
+const char *suffix = d_str (di);
+const char *pend = suffix;
+struct demangle_component *n;
+if (*pend == '.' && (IS_LOWER (pend[1]) || pend[1] == '_'))
+{
+pend += 2;
+while (IS_LOWER (*pend) || *pend == '_')
+	++pend;
+}
+while (*pend == '.' && IS_DIGIT (pend[1]))
+{
+pend += 2;
+while (IS_DIGIT (*pend))
+	++pend;
+}
+d_advance (di, pend - suffix);
+n = d_make_name (di, suffix, pend - suffix);
+return d_make_comp (di, DEMANGLE_COMPONENT_CLONE, encoding, n);
 }
 /* Add a new substitution.  */
 static int
 	}
 if (id >= (unsigned int) di->next_sub)
 	return NULL;
-++di->did_subs;
 return di->subs[id];
 }
 else
 {
 int verbose;
 	{
 	  if (c == p->code)
 	    {
 	      const char *s;
 	      int len;
+	      struct demangle_component *dc;
 	      if (p->set_last_name != NULL)
 		di->last_name = d_make_sub (di, p->set_last_name,
 					    p->set_last_name_len);
 	      if (verbose)
 		{
 		  s = p->simple_expansion;
 		  len = p->simple_len;
 		}
 	      di->expansion += len;
-	      return d_make_sub (di, s, len);
+	      dc = d_make_sub (di, s, len);
+	      if (d_peek_char (di) == 'B')
+		{
+		  /* If there are ABI tags on the abbreviation, it becomes
+		     a substitution candidate.  */
+		  dc = d_abi_tags (di, dc);
+		  if (! d_add_substitution (di, dc))
+		    return NULL;
+		}
+	      return dc;
 	    }
 	}
 return NULL;
 }
+}
+static void
+d_checkpoint (struct d_info *di, struct d_info_checkpoint *checkpoint)
+{
+checkpoint->n = di->n;
+checkpoint->next_comp = di->next_comp;
+checkpoint->next_sub = di->next_sub;
+checkpoint->expansion = di->expansion;
+}
+static void
+d_backtrack (struct d_info *di, struct d_info_checkpoint *checkpoint)
+{
+di->n = checkpoint->n;
+di->next_comp = checkpoint->next_comp;
+di->next_sub = checkpoint->next_sub;
+di->expansion = checkpoint->expansion;
 }
 /* Initialize a growable string.  */
 static void
 struct d_growable_string *dgs = (struct d_growable_string*) opaque;
 d_growable_string_append_buffer (dgs, s, l);
 }
+/* Walk the tree, counting the number of templates encountered, and
+the number of times a scope might be saved.  These counts will be
+used to allocate data structures for d_print_comp, so the logic
+here must mirror the logic d_print_comp will use.  It is not
+important that the resulting numbers are exact, so long as they
+are larger than the actual numbers encountered.  */
+static void
+d_count_templates_scopes (int *num_templates, int *num_scopes,
+			  const struct demangle_component *dc)
+{
+if (dc == NULL)
+return;
+switch (dc->type)
+{
+case DEMANGLE_COMPONENT_NAME:
+case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
+case DEMANGLE_COMPONENT_FUNCTION_PARAM:
+case DEMANGLE_COMPONENT_SUB_STD:
+case DEMANGLE_COMPONENT_BUILTIN_TYPE:
+case DEMANGLE_COMPONENT_OPERATOR:
+case DEMANGLE_COMPONENT_CHARACTER:
+case DEMANGLE_COMPONENT_NUMBER:
+case DEMANGLE_COMPONENT_UNNAMED_TYPE:
+break;
+case DEMANGLE_COMPONENT_TEMPLATE:
+(*num_templates)++;
+goto recurse_left_right;
+case DEMANGLE_COMPONENT_REFERENCE:
+case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
+if (d_left (dc)->type == DEMANGLE_COMPONENT_TEMPLATE_PARAM)
+	(*num_scopes)++;
+goto recurse_left_right;
+case DEMANGLE_COMPONENT_QUAL_NAME:
+case DEMANGLE_COMPONENT_LOCAL_NAME:
+case DEMANGLE_COMPONENT_TYPED_NAME:
+case DEMANGLE_COMPONENT_VTABLE:
+case DEMANGLE_COMPONENT_VTT:
+case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
+case DEMANGLE_COMPONENT_TYPEINFO:
+case DEMANGLE_COMPONENT_TYPEINFO_NAME:
+case DEMANGLE_COMPONENT_TYPEINFO_FN:
+case DEMANGLE_COMPONENT_THUNK:
+case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
+case DEMANGLE_COMPONENT_COVARIANT_THUNK:
+case DEMANGLE_COMPONENT_JAVA_CLASS:
+case DEMANGLE_COMPONENT_GUARD:
+case DEMANGLE_COMPONENT_TLS_INIT:
+case DEMANGLE_COMPONENT_TLS_WRAPPER:
+case DEMANGLE_COMPONENT_REFTEMP:
+case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
+case DEMANGLE_COMPONENT_RESTRICT:
+case DEMANGLE_COMPONENT_VOLATILE:
+case DEMANGLE_COMPONENT_CONST:
+case DEMANGLE_COMPONENT_RESTRICT_THIS:
+case DEMANGLE_COMPONENT_VOLATILE_THIS:
+case DEMANGLE_COMPONENT_CONST_THIS:
+case DEMANGLE_COMPONENT_REFERENCE_THIS:
+case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
+case DEMANGLE_COMPONENT_TRANSACTION_SAFE:
+case DEMANGLE_COMPONENT_NOEXCEPT:
+case DEMANGLE_COMPONENT_THROW_SPEC:
+case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
+case DEMANGLE_COMPONENT_POINTER:
+case DEMANGLE_COMPONENT_COMPLEX:
+case DEMANGLE_COMPONENT_IMAGINARY:
+case DEMANGLE_COMPONENT_VENDOR_TYPE:
+case DEMANGLE_COMPONENT_FUNCTION_TYPE:
+case DEMANGLE_COMPONENT_ARRAY_TYPE:
+case DEMANGLE_COMPONENT_PTRMEM_TYPE:
+case DEMANGLE_COMPONENT_VECTOR_TYPE:
+case DEMANGLE_COMPONENT_ARGLIST:
+case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
+case DEMANGLE_COMPONENT_INITIALIZER_LIST:
+case DEMANGLE_COMPONENT_CAST:
+case DEMANGLE_COMPONENT_CONVERSION:
+case DEMANGLE_COMPONENT_NULLARY:
+case DEMANGLE_COMPONENT_UNARY:
+case DEMANGLE_COMPONENT_BINARY:
+case DEMANGLE_COMPONENT_BINARY_ARGS:
+case DEMANGLE_COMPONENT_TRINARY:
+case DEMANGLE_COMPONENT_TRINARY_ARG1:
+case DEMANGLE_COMPONENT_TRINARY_ARG2:
+case DEMANGLE_COMPONENT_LITERAL:
+case DEMANGLE_COMPONENT_LITERAL_NEG:
+case DEMANGLE_COMPONENT_JAVA_RESOURCE:
+case DEMANGLE_COMPONENT_COMPOUND_NAME:
+case DEMANGLE_COMPONENT_DECLTYPE:
+case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
+case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
+case DEMANGLE_COMPONENT_PACK_EXPANSION:
+case DEMANGLE_COMPONENT_TAGGED_NAME:
+case DEMANGLE_COMPONENT_CLONE:
+recurse_left_right:
+d_count_templates_scopes (num_templates, num_scopes,
+				d_left (dc));
+d_count_templates_scopes (num_templates, num_scopes,
+				d_right (dc));
+break;
+case DEMANGLE_COMPONENT_CTOR:
+d_count_templates_scopes (num_templates, num_scopes,
+				dc->u.s_ctor.name);
+break;
+case DEMANGLE_COMPONENT_DTOR:
+d_count_templates_scopes (num_templates, num_scopes,
+				dc->u.s_dtor.name);
+break;
+case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
+d_count_templates_scopes (num_templates, num_scopes,
+				dc->u.s_extended_operator.name);
+break;
+case DEMANGLE_COMPONENT_FIXED_TYPE:
+d_count_templates_scopes (num_templates, num_scopes,
+dc->u.s_fixed.length);
+break;
+case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
+case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
+d_count_templates_scopes (num_templates, num_scopes,
+				d_left (dc));
+break;
+case DEMANGLE_COMPONENT_LAMBDA:
+case DEMANGLE_COMPONENT_DEFAULT_ARG:
+d_count_templates_scopes (num_templates, num_scopes,
+				dc->u.s_unary_num.sub);
+break;
+}
+}
 /* Initialize a print information structure.  */
 static void
-d_print_init (struct d_print_info *dpi, int options,
+d_print_init (struct d_print_info *dpi, demangle_callbackref callback,
-demangle_callbackref callback, void *opaque)
+	      void *opaque, const struct demangle_component *dc)
 {
-dpi->options = options;
 dpi->len = 0;
 dpi->last_char = '\0';
 dpi->templates = NULL;
 dpi->modifiers = NULL;
+dpi->pack_index = 0;
 dpi->flush_count = 0;
 dpi->callback = callback;
 dpi->opaque = opaque;
 dpi->demangle_failure = 0;
+dpi->recursion = 0;
+dpi->is_lambda_arg = 0;
+dpi->component_stack = NULL;
+dpi->saved_scopes = NULL;
+dpi->next_saved_scope = 0;
+dpi->num_saved_scopes = 0;
+dpi->copy_templates = NULL;
+dpi->next_copy_template = 0;
+dpi->num_copy_templates = 0;
+d_count_templates_scopes (&dpi->num_copy_templates,
+			    &dpi->num_saved_scopes, dc);
+dpi->num_copy_templates *= dpi->num_saved_scopes;
+dpi->current_template = NULL;
 }
 /* Indicate that an error occurred during printing, and test for error.  */
 static inline void
 {
 d_append_buffer (dpi, s, strlen (s));
 }
 static inline void
-d_append_num (struct d_print_info *dpi, long l)
+d_append_num (struct d_print_info *dpi, int l)
 {
 char buf[25];
-sprintf (buf,"%ld", l);
+sprintf (buf,"%d", l);
 d_append_string (dpi, buf);
 }
 static inline char
 d_last_char (struct d_print_info *dpi)
 allocation failure.  */
 CP_STATIC_IF_GLIBCPP_V3
 int
 cplus_demangle_print_callback (int options,
-const struct demangle_component *dc,
+struct demangle_component *dc,
 demangle_callbackref callback, void *opaque)
 {
 struct d_print_info dpi;
-d_print_init (&dpi, options, callback, opaque);
+d_print_init (&dpi, callback, opaque, dc);
-d_print_comp (&dpi, dc);
+{
+#ifdef CP_DYNAMIC_ARRAYS
+/* Avoid zero-length VLAs, which are prohibited by the C99 standard
+and flagged as errors by Address Sanitizer.  */
+__extension__ struct d_saved_scope scopes[(dpi.num_saved_scopes > 0)
+? dpi.num_saved_scopes : 1];
+__extension__ struct d_print_template temps[(dpi.num_copy_templates > 0)
+? dpi.num_copy_templates : 1];
+dpi.saved_scopes = scopes;
+dpi.copy_templates = temps;
+#else
+dpi.saved_scopes = alloca (dpi.num_saved_scopes
+			       * sizeof (*dpi.saved_scopes));
+dpi.copy_templates = alloca (dpi.num_copy_templates
+				 * sizeof (*dpi.copy_templates));
+#endif
+d_print_comp (&dpi, options, dc);
+}
 d_print_flush (&dpi);
 return ! d_print_saw_error (&dpi);
 }
 sets *PALC to 0 for a bad parse, or to 1 for a memory allocation
 failure.  */
 CP_STATIC_IF_GLIBCPP_V3
 char *
-cplus_demangle_print (int options, const struct demangle_component *dc,
+cplus_demangle_print (int options, struct demangle_component *dc,
 int estimate, size_t *palc)
 {
 struct d_growable_string dgs;
 d_growable_string_init (&dgs, estimate);
 *palc = dgs.allocation_failure ? 1 : dgs.alc;
 return dgs.buf;
 }
 /* Returns the I'th element of the template arglist ARGS, or NULL on
-failure.  */
+failure.  If I is negative, return the entire arglist.  */
 static struct demangle_component *
 d_index_template_argument (struct demangle_component *args, int i)
 {
 struct demangle_component *a;
+if (i < 0)
+/* Print the whole argument pack.  */
+return args;
 for (a = args;
 a != NULL;
 a = d_right (a))
 {
 case DEMANGLE_COMPONENT_PACK_EXPANSION:
 return NULL;
 case DEMANGLE_COMPONENT_LAMBDA:
 case DEMANGLE_COMPONENT_NAME:
+case DEMANGLE_COMPONENT_TAGGED_NAME:
 case DEMANGLE_COMPONENT_OPERATOR:
 case DEMANGLE_COMPONENT_BUILTIN_TYPE:
 case DEMANGLE_COMPONENT_SUB_STD:
 case DEMANGLE_COMPONENT_CHARACTER:
 case DEMANGLE_COMPONENT_FUNCTION_PARAM:
+case DEMANGLE_COMPONENT_UNNAMED_TYPE:
+case DEMANGLE_COMPONENT_FIXED_TYPE:
+case DEMANGLE_COMPONENT_DEFAULT_ARG:
+case DEMANGLE_COMPONENT_NUMBER:
 return NULL;
 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
 return d_find_pack (dpi, dc->u.s_extended_operator.name);
 case DEMANGLE_COMPONENT_CTOR:
 dc = d_right (dc);
 }
 return count;
 }
+/* Returns the number of template args in DC, expanding any pack expansions
+found there.  */
+static int
+d_args_length (struct d_print_info *dpi, const struct demangle_component *dc)
+{
+int count = 0;
+for (; dc && dc->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST;
+dc = d_right (dc))
+{
+struct demangle_component *elt = d_left (dc);
+if (elt == NULL)
+	break;
+if (elt->type == DEMANGLE_COMPONENT_PACK_EXPANSION)
+	{
+	  struct demangle_component *a = d_find_pack (dpi, d_left (elt));
+	  count += d_pack_length (a);
+	}
+else
+	++count;
+}
+return count;
+}
 /* DC is a component of a mangled expression.  Print it, wrapped in parens
 if needed.  */
 static void
-d_print_subexpr (struct d_print_info *dpi,
+d_print_subexpr (struct d_print_info *dpi, int options,
-		 const struct demangle_component *dc)
+		 struct demangle_component *dc)
 {
 int simple = 0;
 if (dc->type == DEMANGLE_COMPONENT_NAME
+|| dc->type == DEMANGLE_COMPONENT_QUAL_NAME
+|| dc->type == DEMANGLE_COMPONENT_INITIALIZER_LIST
 || dc->type == DEMANGLE_COMPONENT_FUNCTION_PARAM)
 simple = 1;
 if (!simple)
 d_append_char (dpi, '(');
-d_print_comp (dpi, dc);
+d_print_comp (dpi, options, dc);
 if (!simple)
 d_append_char (dpi, ')');
 }
+/* Save the current scope.  */
+static void
+d_save_scope (struct d_print_info *dpi,
+	      const struct demangle_component *container)
+{
+struct d_saved_scope *scope;
+struct d_print_template *src, **link;
+if (dpi->next_saved_scope >= dpi->num_saved_scopes)
+{
+d_print_error (dpi);
+return;
+}
+scope = &dpi->saved_scopes[dpi->next_saved_scope];
+dpi->next_saved_scope++;
+scope->container = container;
+link = &scope->templates;
+for (src = dpi->templates; src != NULL; src = src->next)
+{
+struct d_print_template *dst;
+if (dpi->next_copy_template >= dpi->num_copy_templates)
+	{
+	  d_print_error (dpi);
+	  return;
+	}
+dst = &dpi->copy_templates[dpi->next_copy_template];
+dpi->next_copy_template++;
+dst->template_decl = src->template_decl;
+*link = dst;
+link = &dst->next;
+}
+*link = NULL;
+}
+/* Attempt to locate a previously saved scope.  Returns NULL if no
+corresponding saved scope was found.  */
+static struct d_saved_scope *
+d_get_saved_scope (struct d_print_info *dpi,
+		   const struct demangle_component *container)
+{
+int i;
+for (i = 0; i < dpi->next_saved_scope; i++)
+if (dpi->saved_scopes[i].container == container)
+return &dpi->saved_scopes[i];
+return NULL;
+}
+/* If DC is a C++17 fold-expression, print it and return true; otherwise
+return false.  */
+static int
+d_maybe_print_fold_expression (struct d_print_info *dpi, int options,
+			       struct demangle_component *dc)
+{
+struct demangle_component *ops, *operator_, *op1, *op2;
+int save_idx;
+const char *fold_code = d_left (dc)->u.s_operator.op->code;
+if (fold_code[0] != 'f')
+return 0;
+ops = d_right (dc);
+operator_ = d_left (ops);
+op1 = d_right (ops);
+op2 = 0;
+if (op1->type == DEMANGLE_COMPONENT_TRINARY_ARG2)
+{
+op2 = d_right (op1);
+op1 = d_left (op1);
+}
+/* Print the whole pack.  */
+save_idx = dpi->pack_index;
+dpi->pack_index = -1;
+switch (fold_code[1])
+{
+/* Unary left fold, (... + X).  */
+case 'l':
+d_append_string (dpi, "(...");
+d_print_expr_op (dpi, options, operator_);
+d_print_subexpr (dpi, options, op1);
+d_append_char (dpi, ')');
+break;
+/* Unary right fold, (X + ...).  */
+case 'r':
+d_append_char (dpi, '(');
+d_print_subexpr (dpi, options, op1);
+d_print_expr_op (dpi, options, operator_);
+d_append_string (dpi, "...)");
+break;
+/* Binary left fold, (42 + ... + X).  */
+case 'L':
+/* Binary right fold, (X + ... + 42).  */
+case 'R':
+d_append_char (dpi, '(');
+d_print_subexpr (dpi, options, op1);
+d_print_expr_op (dpi, options, operator_);
+d_append_string (dpi, "...");
+d_print_expr_op (dpi, options, operator_);
+d_print_subexpr (dpi, options, op2);
+d_append_char (dpi, ')');
+break;
+}
+dpi->pack_index = save_idx;
+return 1;
+}
 /* Subroutine to handle components.  */
 static void
-d_print_comp (struct d_print_info *dpi,
+d_print_comp_inner (struct d_print_info *dpi, int options,
-const struct demangle_component *dc)
+		    struct demangle_component *dc)
 {
+/* Magic variable to let reference smashing skip over the next modifier
+without needing to modify *dc.  */
+struct demangle_component *mod_inner = NULL;
+/* Variable used to store the current templates while a previously
+captured scope is used.  */
+struct d_print_template *saved_templates;
+/* Nonzero if templates have been stored in the above variable.  */
+int need_template_restore = 0;
 if (dc == NULL)
 {
 d_print_error (dpi);
 return;
 }
 return;
 switch (dc->type)
 {
 case DEMANGLE_COMPONENT_NAME:
-if ((dpi->options & DMGL_JAVA) == 0)
+if ((options & DMGL_JAVA) == 0)
 	d_append_buffer (dpi, dc->u.s_name.s, dc->u.s_name.len);
 else
 	d_print_java_identifier (dpi, dc->u.s_name.s, dc->u.s_name.len);
 return;
+case DEMANGLE_COMPONENT_TAGGED_NAME:
+d_print_comp (dpi, options, d_left (dc));
+d_append_string (dpi, "[abi:");
+d_print_comp (dpi, options, d_right (dc));
+d_append_char (dpi, ']');
+return;
 case DEMANGLE_COMPONENT_QUAL_NAME:
 case DEMANGLE_COMPONENT_LOCAL_NAME:
-d_print_comp (dpi, d_left (dc));
+d_print_comp (dpi, options, d_left (dc));
-if ((dpi->options & DMGL_JAVA) == 0)
+if ((options & DMGL_JAVA) == 0)
 	d_append_string (dpi, "::");
 else
 	d_append_char (dpi, '.');
-d_print_comp (dpi, d_right (dc));
+{
+	struct demangle_component *local_name = d_right (dc);
+	if (local_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
+	  {
+	    d_append_string (dpi, "{default arg#");
+	    d_append_num (dpi, local_name->u.s_unary_num.num + 1);
+	    d_append_string (dpi, "}::");
+	    local_name = local_name->u.s_unary_num.sub;
+	  }
+	d_print_comp (dpi, options, local_name);
+}
 return;
 case DEMANGLE_COMPONENT_TYPED_NAME:
 {
 	struct d_print_mod *hold_modifiers;
 	    adpm[i].mod = typed_name;
 	    adpm[i].printed = 0;
 	    adpm[i].templates = dpi->templates;
 	    ++i;
-	    if (typed_name->type != DEMANGLE_COMPONENT_RESTRICT_THIS
+	    if (!is_fnqual_component_type (typed_name->type))
-		&& typed_name->type != DEMANGLE_COMPONENT_VOLATILE_THIS
-		&& typed_name->type != DEMANGLE_COMPONENT_CONST_THIS)
 	      break;
 	    typed_name = d_left (typed_name);
 	  }
 	if (typed_name == NULL)
 	  {
 	    d_print_error (dpi);
 	    return;
+	  }
+	/* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
+	   there may be CV-qualifiers on its right argument which
+	   really apply here; this happens when parsing a class that
+	   is local to a function.  */
+	if (typed_name->type == DEMANGLE_COMPONENT_LOCAL_NAME)
+	  {
+	    typed_name = d_right (typed_name);
+	    if (typed_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
+	      typed_name = typed_name->u.s_unary_num.sub;
+	    if (typed_name == NULL)
+	      {
+		d_print_error (dpi);
+		return;
+	      }
+	    while (is_fnqual_component_type (typed_name->type))
+	      {
+		if (i >= sizeof adpm / sizeof adpm[0])
+		  {
+		    d_print_error (dpi);
+		    return;
+		  }
+		adpm[i] = adpm[i - 1];
+		adpm[i].next = &adpm[i - 1];
+		dpi->modifiers = &adpm[i];
+		adpm[i - 1].mod = typed_name;
+		adpm[i - 1].printed = 0;
+		adpm[i - 1].templates = dpi->templates;
+		++i;
+		typed_name = d_left (typed_name);
+	      }
 	  }
 	/* If typed_name is a template, then it applies to the
 	   function type as well.  */
 	if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
 	    dpt.next = dpi->templates;
 	    dpi->templates = &dpt;
 	    dpt.template_decl = typed_name;
 	  }
-	/* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
+	d_print_comp (dpi, options, d_right (dc));
-	   there may be CV-qualifiers on its right argument which
-	   really apply here; this happens when parsing a class which
-	   is local to a function.  */
-	if (typed_name->type == DEMANGLE_COMPONENT_LOCAL_NAME)
-	  {
-	    struct demangle_component *local_name;
-	    local_name = d_right (typed_name);
-	    if (local_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
-	      local_name = local_name->u.s_unary_num.sub;
-	    while (local_name->type == DEMANGLE_COMPONENT_RESTRICT_THIS
-		   || local_name->type == DEMANGLE_COMPONENT_VOLATILE_THIS
-		   || local_name->type == DEMANGLE_COMPONENT_CONST_THIS)
-	      {
-		if (i >= sizeof adpm / sizeof adpm[0])
-		  {
-		    d_print_error (dpi);
-		    return;
-		  }
-		adpm[i] = adpm[i - 1];
-		adpm[i].next = &adpm[i - 1];
-		dpi->modifiers = &adpm[i];
-		adpm[i - 1].mod = local_name;
-		adpm[i - 1].printed = 0;
-		adpm[i - 1].templates = dpi->templates;
-		++i;
-		local_name = d_left (local_name);
-	      }
-	  }
-	d_print_comp (dpi, d_right (dc));
 	if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
 	  dpi->templates = dpt.next;
 	/* If the modifiers didn't get printed by the type, print them
 	  {
 	    --i;
 	    if (! adpm[i].printed)
 	      {
 		d_append_char (dpi, ' ');
-		d_print_mod (dpi, adpm[i].mod);
+		d_print_mod (dpi, options, adpm[i].mod);
 	      }
 	  }
 	dpi->modifiers = hold_modifiers;
 case DEMANGLE_COMPONENT_TEMPLATE:
 {
 	struct d_print_mod *hold_dpm;
 	struct demangle_component *dcl;
+	const struct demangle_component *hold_current;
+	/* This template may need to be referenced by a cast operator
+	   contained in its subtree.  */
+	hold_current = dpi->current_template;
+	dpi->current_template = dc;
 	/* Don't push modifiers into a template definition.  Doing so
 	   could give the wrong definition for a template argument.
 	   Instead, treat the template essentially as a name.  */
 	hold_dpm = dpi->modifiers;
 	dpi->modifiers = NULL;
 dcl = d_left (dc);
-if ((dpi->options & DMGL_JAVA) != 0
+if ((options & DMGL_JAVA) != 0
 && dcl->type == DEMANGLE_COMPONENT_NAME
 && dcl->u.s_name.len == 6
 && strncmp (dcl->u.s_name.s, "JArray", 6) == 0)
 {
 /* Special-case Java arrays, so that JArray<TYPE> appears
 instead as TYPE[].  */
-d_print_comp (dpi, d_right (dc));
+d_print_comp (dpi, options, d_right (dc));
 d_append_string (dpi, "[]");
 }
 else
 {
-	    d_print_comp (dpi, dcl);
+	    d_print_comp (dpi, options, dcl);
 	    if (d_last_char (dpi) == '<')
 	      d_append_char (dpi, ' ');
 	    d_append_char (dpi, '<');
-	    d_print_comp (dpi, d_right (dc));
+	    d_print_comp (dpi, options, d_right (dc));
 	    /* Avoid generating two consecutive '>' characters, to avoid
 	       the C++ syntactic ambiguity.  */
 	    if (d_last_char (dpi) == '>')
 	      d_append_char (dpi, ' ');
 	    d_append_char (dpi, '>');
 }
 	dpi->modifiers = hold_dpm;
+	dpi->current_template = hold_current;
 	return;
 }
 case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
-{
+if (dpi->is_lambda_arg)
-	struct d_print_template *hold_dpt;
+	{
-	struct demangle_component *a = d_lookup_template_argument (dpi, dc);
+	  /* Show the template parm index, as that's how g++ displays
+	     these, and future proofs us against potential
-	if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
+	     '[]<typename T> (T *a, T *b) {...}'.  */
-	  a = d_index_template_argument (a, dpi->pack_index);
+	  d_append_buffer (dpi, "auto:", 5);
+	  d_append_num (dpi, dc->u.s_number.number + 1);
-	if (a == NULL)
+	}
-	  {
+else
-	    d_print_error (dpi);
+	{
-	    return;
+	  struct d_print_template *hold_dpt;
-	  }
+	  struct demangle_component *a = d_lookup_template_argument (dpi, dc);
-	/* While processing this parameter, we need to pop the list of
+	  if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
-	   templates.  This is because the template parameter may
+	    a = d_index_template_argument (a, dpi->pack_index);
-	   itself be a reference to a parameter of an outer
-	   template.  */
+	  if (a == NULL)
+	    {
-	hold_dpt = dpi->templates;
+	      d_print_error (dpi);
-	dpi->templates = hold_dpt->next;
+	      return;
+	    }
-	d_print_comp (dpi, a);
+	  /* While processing this parameter, we need to pop the list
-	dpi->templates = hold_dpt;
+	     of templates.  This is because the template parameter may
+	     itself be a reference to a parameter of an outer
-	return;
+	     template.  */
-}
+	  hold_dpt = dpi->templates;
+	  dpi->templates = hold_dpt->next;
+	  d_print_comp (dpi, options, a);
+	  dpi->templates = hold_dpt;
+	}
+return;
 case DEMANGLE_COMPONENT_CTOR:
-d_print_comp (dpi, dc->u.s_ctor.name);
+d_print_comp (dpi, options, dc->u.s_ctor.name);
 return;
 case DEMANGLE_COMPONENT_DTOR:
 d_append_char (dpi, '~');
-d_print_comp (dpi, dc->u.s_dtor.name);
+d_print_comp (dpi, options, dc->u.s_dtor.name);
 return;
 case DEMANGLE_COMPONENT_VTABLE:
 d_append_string (dpi, "vtable for ");
-d_print_comp (dpi, d_left (dc));
+d_print_comp (dpi, options, d_left (dc));
 return;
 case DEMANGLE_COMPONENT_VTT:
 d_append_string (dpi, "VTT for ");
-d_print_comp (dpi, d_left (dc));
+d_print_comp (dpi, options, d_left (dc));
 return;
 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
 d_append_string (dpi, "construction vtable for ");
-d_print_comp (dpi, d_left (dc));
+d_print_comp (dpi, options, d_left (dc));
 d_append_string (dpi, "-in-");
-d_print_comp (dpi, d_right (dc));
+d_print_comp (dpi, options, d_right (dc));
 return;
 case DEMANGLE_COMPONENT_TYPEINFO:
 d_append_string (dpi, "typeinfo for ");
-d_print_comp (dpi, d_left (dc));
+d_print_comp (dpi, options, d_left (dc));
 return;
 case DEMANGLE_COMPONENT_TYPEINFO_NAME:
 d_append_string (dpi, "typeinfo name for ");
-d_print_comp (dpi, d_left (dc));
+d_print_comp (dpi, options, d_left (dc));
 return;
 case DEMANGLE_COMPONENT_TYPEINFO_FN:
 d_append_string (dpi, "typeinfo fn for ");
-d_print_comp (dpi, d_left (dc));
+d_print_comp (dpi, options, d_left (dc));
 return;
 case DEMANGLE_COMPONENT_THUNK:
 d_append_string (dpi, "non-virtual thunk to ");
-d_print_comp (dpi, d_left (dc));
+d_print_comp (dpi, options, d_left (dc));
 return;
 case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
 d_append_string (dpi, "virtual thunk to ");
-d_print_comp (dpi, d_left (dc));
+d_print_comp (dpi, options, d_left (dc));
 return;
 case DEMANGLE_COMPONENT_COVARIANT_THUNK:
 d_append_string (dpi, "covariant return thunk to ");
-d_print_comp (dpi, d_left (dc));
+d_print_comp (dpi, options, d_left (dc));
 return;
 case DEMANGLE_COMPONENT_JAVA_CLASS:
 d_append_string (dpi, "java Class for ");
-d_print_comp (dpi, d_left (dc));
+d_print_comp (dpi, options, d_left (dc));
 return;
 case DEMANGLE_COMPONENT_GUARD:
 d_append_string (dpi, "guard variable for ");
-d_print_comp (dpi, d_left (dc));
+d_print_comp (dpi, options, d_left (dc));
+return;
+case DEMANGLE_COMPONENT_TLS_INIT:
+d_append_string (dpi, "TLS init function for ");
+d_print_comp (dpi, options, d_left (dc));
+return;
+case DEMANGLE_COMPONENT_TLS_WRAPPER:
+d_append_string (dpi, "TLS wrapper function for ");
+d_print_comp (dpi, options, d_left (dc));
 return;
 case DEMANGLE_COMPONENT_REFTEMP:
-d_append_string (dpi, "reference temporary for ");
+d_append_string (dpi, "reference temporary #");
-d_print_comp (dpi, d_left (dc));
+d_print_comp (dpi, options, d_right (dc));
+d_append_string (dpi, " for ");
+d_print_comp (dpi, options, d_left (dc));
 return;
 case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
 d_append_string (dpi, "hidden alias for ");
-d_print_comp (dpi, d_left (dc));
+d_print_comp (dpi, options, d_left (dc));
+return;
+case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
+d_append_string (dpi, "transaction clone for ");
+d_print_comp (dpi, options, d_left (dc));
+return;
+case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
+d_append_string (dpi, "non-transaction clone for ");
+d_print_comp (dpi, options, d_left (dc));
 return;
 case DEMANGLE_COMPONENT_SUB_STD:
 d_append_buffer (dpi, dc->u.s_string.string, dc->u.s_string.len);
 return;
 		    && pdpm->mod->type != DEMANGLE_COMPONENT_VOLATILE
 		    && pdpm->mod->type != DEMANGLE_COMPONENT_CONST)
 		  break;
 		if (pdpm->mod->type == dc->type)
 		  {
-		    d_print_comp (dpi, d_left (dc));
+		    d_print_comp (dpi, options, d_left (dc));
 		    return;
 		  }
 	      }
 	  }
 }
+goto modifier;
+case DEMANGLE_COMPONENT_REFERENCE:
+case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
+{
+	/* Handle reference smashing: & + && = &.  */
+	struct demangle_component *sub = d_left (dc);
+	if (!dpi->is_lambda_arg
+	    && sub->type == DEMANGLE_COMPONENT_TEMPLATE_PARAM)
+	  {
+	    struct d_saved_scope *scope = d_get_saved_scope (dpi, sub);
+	    struct demangle_component *a;
+	    if (scope == NULL)
+	      {
+		/* This is the first time SUB has been traversed.
+		   We need to capture the current templates so
+		   they can be restored if SUB is reentered as a
+		   substitution.  */
+		d_save_scope (dpi, sub);
+		if (d_print_saw_error (dpi))
+		  return;
+	      }
+	    else
+	      {
+		const struct d_component_stack *dcse;
+		int found_self_or_parent = 0;
+		/* This traversal is reentering SUB as a substition.
+		   If we are not beneath SUB or DC in the tree then we
+		   need to restore SUB's template stack temporarily.  */
+		for (dcse = dpi->component_stack; dcse != NULL;
+		     dcse = dcse->parent)
+		  {
+		    if (dcse->dc == sub
+			|| (dcse->dc == dc
+			    && dcse != dpi->component_stack))
+		      {
+			found_self_or_parent = 1;
+			break;
+		      }
+		  }
+		if (!found_self_or_parent)
+		  {
+		    saved_templates = dpi->templates;
+		    dpi->templates = scope->templates;
+		    need_template_restore = 1;
+		  }
+	      }
+	    a = d_lookup_template_argument (dpi, sub);
+	    if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
+	      a = d_index_template_argument (a, dpi->pack_index);
+	    if (a == NULL)
+	      {
+		if (need_template_restore)
+		  dpi->templates = saved_templates;
+		d_print_error (dpi);
+		return;
+	      }
+	    sub = a;
+	  }
+	if (sub->type == DEMANGLE_COMPONENT_REFERENCE
+	    || sub->type == dc->type)
+	  dc = sub;
+	else if (sub->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE)
+	  mod_inner = d_left (sub);
+}
 /* Fall through.  */
-case DEMANGLE_COMPONENT_RESTRICT_THIS:
-case DEMANGLE_COMPONENT_VOLATILE_THIS:
-case DEMANGLE_COMPONENT_CONST_THIS:
 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
 case DEMANGLE_COMPONENT_POINTER:
-case DEMANGLE_COMPONENT_REFERENCE:
-case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
 case DEMANGLE_COMPONENT_COMPLEX:
 case DEMANGLE_COMPONENT_IMAGINARY:
+FNQUAL_COMPONENT_CASE:
+modifier:
 {
 	/* We keep a list of modifiers on the stack.  */
 	struct d_print_mod dpm;
 	dpm.next = dpi->modifiers;
 	dpi->modifiers = &dpm;
 	dpm.mod = dc;
 	dpm.printed = 0;
 	dpm.templates = dpi->templates;
-	d_print_comp (dpi, d_left (dc));
+	if (!mod_inner)
+	  mod_inner = d_left (dc);
+	d_print_comp (dpi, options, mod_inner);
 	/* If the modifier didn't get printed by the type, print it
 	   now.  */
 	if (! dpm.printed)
-	  d_print_mod (dpi, dc);
+	  d_print_mod (dpi, options, dc);
 	dpi->modifiers = dpm.next;
+	if (need_template_restore)
+	  dpi->templates = saved_templates;
 	return;
 }
 case DEMANGLE_COMPONENT_BUILTIN_TYPE:
-if ((dpi->options & DMGL_JAVA) == 0)
+if ((options & DMGL_JAVA) == 0)
 	d_append_buffer (dpi, dc->u.s_builtin.type->name,
 			 dc->u.s_builtin.type->len);
 else
 	d_append_buffer (dpi, dc->u.s_builtin.type->java_name,
 			 dc->u.s_builtin.type->java_len);
 return;
 case DEMANGLE_COMPONENT_VENDOR_TYPE:
-d_print_comp (dpi, d_left (dc));
+d_print_comp (dpi, options, d_left (dc));
 return;
 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
 {
-	if ((dpi->options & DMGL_RET_POSTFIX) != 0)
+	if ((options & DMGL_RET_POSTFIX) != 0)
-	  d_print_function_type (dpi, dc, dpi->modifiers);
+	  d_print_function_type (dpi,
+				 options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
+				 dc, dpi->modifiers);
 	/* Print return type if present */
-	if (d_left (dc) != NULL)
+	if (d_left (dc) != NULL && (options & DMGL_RET_POSTFIX) != 0)
+	  d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
+			d_left (dc));
+	else if (d_left (dc) != NULL && (options & DMGL_RET_DROP) == 0)
 	  {
 	    struct d_print_mod dpm;
 	    /* We must pass this type down as a modifier in order to
 	       print it in the right location.  */
 	    dpi->modifiers = &dpm;
 	    dpm.mod = dc;
 	    dpm.printed = 0;
 	    dpm.templates = dpi->templates;
-	    d_print_comp (dpi, d_left (dc));
+	    d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
+			  d_left (dc));
 	    dpi->modifiers = dpm.next;
 	    if (dpm.printed)
 	      return;
 	    /* In standard prefix notation, there is a space between the
 	       return type and the function signature.  */
-	    if ((dpi->options & DMGL_RET_POSTFIX) == 0)
+	    if ((options & DMGL_RET_POSTFIX) == 0)
 	      d_append_char (dpi, ' ');
 	  }
-	if ((dpi->options & DMGL_RET_POSTFIX) == 0)
+	if ((options & DMGL_RET_POSTFIX) == 0)
-	  d_print_function_type (dpi, dc, dpi->modifiers);
+	  d_print_function_type (dpi,
+				 options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
+				 dc, dpi->modifiers);
 	return;
 }
 case DEMANGLE_COMPONENT_ARRAY_TYPE:
 	      }
 	    pdpm = pdpm->next;
 	  }
-	d_print_comp (dpi, d_right (dc));
+	d_print_comp (dpi, options, d_right (dc));
 	dpi->modifiers = hold_modifiers;
 	if (adpm[0].printed)
 	  return;
 	while (i > 1)
 	  {
 	    --i;
-	    d_print_mod (dpi, adpm[i].mod);
+	    d_print_mod (dpi, options, adpm[i].mod);
 	  }
-	d_print_array_type (dpi, dc, dpi->modifiers);
+	d_print_array_type (dpi, options, dc, dpi->modifiers);
 	return;
 }
 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
 	dpi->modifiers = &dpm;
 	dpm.mod = dc;
 	dpm.printed = 0;
 	dpm.templates = dpi->templates;
-	d_print_comp (dpi, d_right (dc));
+	d_print_comp (dpi, options, d_right (dc));
 	/* If the modifier didn't get printed by the type, print it
 	   now.  */
 	if (! dpm.printed)
-	  d_print_mod (dpi, dc);
+	  d_print_mod (dpi, options, dc);
 	dpi->modifiers = dpm.next;
 	return;
 }
 	d_append_string (dpi, "_Sat ");
 /* Don't print "int _Accum".  */
 if (dc->u.s_fixed.length->u.s_builtin.type
 	  != &cplus_demangle_builtin_types['i'-'a'])
 	{
-	  d_print_comp (dpi, dc->u.s_fixed.length);
+	  d_print_comp (dpi, options, dc->u.s_fixed.length);
 	  d_append_char (dpi, ' ');
 	}
 if (dc->u.s_fixed.accum)
 	d_append_string (dpi, "_Accum");
 else
 return;
 case DEMANGLE_COMPONENT_ARGLIST:
 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
 if (d_left (dc) != NULL)
-	d_print_comp (dpi, d_left (dc));
+	d_print_comp (dpi, options, d_left (dc));
 if (d_right (dc) != NULL)
 	{
 	  size_t len;
 	  unsigned long int flush_count;
 	  /* Make sure ", " isn't flushed by d_append_string, otherwise
 	  if (dpi->len >= sizeof (dpi->buf) - 2)
 	    d_print_flush (dpi);
 	  d_append_string (dpi, ", ");
 	  len = dpi->len;
 	  flush_count = dpi->flush_count;
-	  d_print_comp (dpi, d_right (dc));
+	  d_print_comp (dpi, options, d_right (dc));
 	  /* If that didn't print anything (which can happen with empty
 	     template argument packs), remove the comma and space.  */
 	  if (dpi->flush_count == flush_count && dpi->len == len)
 	    dpi->len -= 2;
 	}
 return;
+case DEMANGLE_COMPONENT_INITIALIZER_LIST:
+{
+	struct demangle_component *type = d_left (dc);
+	struct demangle_component *list = d_right (dc);
+	if (type)
+	  d_print_comp (dpi, options, type);
+	d_append_char (dpi, '{');
+	d_print_comp (dpi, options, list);
+	d_append_char (dpi, '}');
+}
+return;
 case DEMANGLE_COMPONENT_OPERATOR:
 {
-	char c;
+	const struct demangle_operator_info *op = dc->u.s_operator.op;
+	int len = op->len;
 	d_append_string (dpi, "operator");
-	c = dc->u.s_operator.op->name[0];
+	/* Add a space before new/delete.  */
-	if (IS_LOWER (c))
+	if (IS_LOWER (op->name[0]))
 	  d_append_char (dpi, ' ');
-	d_append_buffer (dpi, dc->u.s_operator.op->name,
+	/* Omit a trailing space.  */
-			 dc->u.s_operator.op->len);
+	if (op->name[len-1] == ' ')
+	  --len;
+	d_append_buffer (dpi, op->name, len);
 	return;
 }
 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
 d_append_string (dpi, "operator ");
-d_print_comp (dpi, dc->u.s_extended_operator.name);
+d_print_comp (dpi, options, dc->u.s_extended_operator.name);
 return;
-case DEMANGLE_COMPONENT_CAST:
+case DEMANGLE_COMPONENT_CONVERSION:
 d_append_string (dpi, "operator ");
-d_print_cast (dpi, dc);
+d_print_conversion (dpi, options, dc);
+return;
+case DEMANGLE_COMPONENT_NULLARY:
+d_print_expr_op (dpi, options, d_left (dc));
 return;
 case DEMANGLE_COMPONENT_UNARY:
-if (d_left (dc)->type != DEMANGLE_COMPONENT_CAST)
+{
-	d_print_expr_op (dpi, d_left (dc));
+	struct demangle_component *op = d_left (dc);
-else
+	struct demangle_component *operand = d_right (dc);
-	{
+	const char *code = NULL;
-	  d_append_char (dpi, '(');
-	  d_print_cast (dpi, d_left (dc));
+	if (op->type == DEMANGLE_COMPONENT_OPERATOR)
-	  d_append_char (dpi, ')');
+	  {
-	}
+	    code = op->u.s_operator.op->code;
-d_print_subexpr (dpi, d_right (dc));
+	    if (!strcmp (code, "ad"))
+	      {
+		/* Don't print the argument list for the address of a
+		   function.  */
+		if (operand->type == DEMANGLE_COMPONENT_TYPED_NAME
+		    && d_left (operand)->type == DEMANGLE_COMPONENT_QUAL_NAME
+		    && d_right (operand)->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
+		  operand = d_left (operand);
+	      }
+	    if (operand->type == DEMANGLE_COMPONENT_BINARY_ARGS)
+	      {
+		/* This indicates a suffix operator.  */
+		operand = d_left (operand);
+		d_print_subexpr (dpi, options, operand);
+		d_print_expr_op (dpi, options, op);
+		return;
+	      }
+	  }
+	/* For sizeof..., just print the pack length.  */
+	if (code && !strcmp (code, "sZ"))
+	  {
+	    struct demangle_component *a = d_find_pack (dpi, operand);
+	    int len = d_pack_length (a);
+	    d_append_num (dpi, len);
+	    return;
+	  }
+	else if (code && !strcmp (code, "sP"))
+	  {
+	    int len = d_args_length (dpi, operand);
+	    d_append_num (dpi, len);
+	    return;
+	  }
+	if (op->type != DEMANGLE_COMPONENT_CAST)
+	  d_print_expr_op (dpi, options, op);
+	else
+	  {
+	    d_append_char (dpi, '(');
+	    d_print_cast (dpi, options, op);
+	    d_append_char (dpi, ')');
+	  }
+	if (code && !strcmp (code, "gs"))
+	  /* Avoid parens after '::'.  */
+	  d_print_comp (dpi, options, operand);
+	else if (code && !strcmp (code, "st"))
+	  /* Always print parens for sizeof (type).  */
+	  {
+	    d_append_char (dpi, '(');
+	    d_print_comp (dpi, options, operand);
+	    d_append_char (dpi, ')');
+	  }
+	else
+	  d_print_subexpr (dpi, options, operand);
+}
 return;
 case DEMANGLE_COMPONENT_BINARY:
 if (d_right (dc)->type != DEMANGLE_COMPONENT_BINARY_ARGS)
 	{
 	  d_print_error (dpi);
 	  return;
 	}
+if (op_is_new_cast (d_left (dc)))
+	{
+	  d_print_expr_op (dpi, options, d_left (dc));
+	  d_append_char (dpi, '<');
+	  d_print_comp (dpi, options, d_left (d_right (dc)));
+	  d_append_string (dpi, ">(");
+	  d_print_comp (dpi, options, d_right (d_right (dc)));
+	  d_append_char (dpi, ')');
+	  return;
+	}
+if (d_maybe_print_fold_expression (dpi, options, dc))
+	return;
 /* We wrap an expression which uses the greater-than operator in
 	 an extra layer of parens so that it does not get confused
 	 with the '>' which ends the template parameters.  */
 if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
 	  && d_left (dc)->u.s_operator.op->len == 1
 	  && d_left (dc)->u.s_operator.op->name[0] == '>')
 	d_append_char (dpi, '(');
-d_print_subexpr (dpi, d_left (d_right (dc)));
+if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") == 0
+&& d_left (d_right (dc))->type == DEMANGLE_COMPONENT_TYPED_NAME)
+	{
+	  /* Function call used in an expression should not have printed types
+	     of the function arguments.  Values of the function arguments still
+	     get printed below.  */
+	  const struct demangle_component *func = d_left (d_right (dc));
+	  if (d_right (func)->type != DEMANGLE_COMPONENT_FUNCTION_TYPE)
+	    d_print_error (dpi);
+	  d_print_subexpr (dpi, options, d_left (func));
+	}
+else
+	d_print_subexpr (dpi, options, d_left (d_right (dc)));
 if (strcmp (d_left (dc)->u.s_operator.op->code, "ix") == 0)
 	{
 	  d_append_char (dpi, '[');
-	  d_print_comp (dpi, d_right (d_right (dc)));
+	  d_print_comp (dpi, options, d_right (d_right (dc)));
 	  d_append_char (dpi, ']');
 	}
 else
 	{
 	  if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") != 0)
-	    d_print_expr_op (dpi, d_left (dc));
+	    d_print_expr_op (dpi, options, d_left (dc));
-	  d_print_subexpr (dpi, d_right (d_right (dc)));
+	  d_print_subexpr (dpi, options, d_right (d_right (dc)));
 	}
 if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
 	  && d_left (dc)->u.s_operator.op->len == 1
 	  && d_left (dc)->u.s_operator.op->name[0] == '>')
 	  || d_right (d_right (dc))->type != DEMANGLE_COMPONENT_TRINARY_ARG2)
 	{
 	  d_print_error (dpi);
 	  return;
 	}
-d_print_subexpr (dpi, d_left (d_right (dc)));
+if (d_maybe_print_fold_expression (dpi, options, dc))
-d_print_expr_op (dpi, d_left (dc));
+	return;
-d_print_subexpr (dpi, d_left (d_right (d_right (dc))));
+{
-d_append_string (dpi, " : ");
+	struct demangle_component *op = d_left (dc);
-d_print_subexpr (dpi, d_right (d_right (d_right (dc))));
+	struct demangle_component *first = d_left (d_right (dc));
+	struct demangle_component *second = d_left (d_right (d_right (dc)));
+	struct demangle_component *third = d_right (d_right (d_right (dc)));
+	if (!strcmp (op->u.s_operator.op->code, "qu"))
+	  {
+	    d_print_subexpr (dpi, options, first);
+	    d_print_expr_op (dpi, options, op);
+	    d_print_subexpr (dpi, options, second);
+	    d_append_string (dpi, " : ");
+	    d_print_subexpr (dpi, options, third);
+	  }
+	else
+	  {
+	    d_append_string (dpi, "new ");
+	    if (d_left (first) != NULL)
+	      {
+		d_print_subexpr (dpi, options, first);
+		d_append_char (dpi, ' ');
+	      }
+	    d_print_comp (dpi, options, second);
+	    if (third)
+	      d_print_subexpr (dpi, options, third);
+	  }
+}
 return;
 case DEMANGLE_COMPONENT_TRINARY_ARG1:
 case DEMANGLE_COMPONENT_TRINARY_ARG2:
 /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY.  */
 	      case D_PRINT_UNSIGNED_LONG_LONG:
 		if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME)
 		  {
 		    if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
 		      d_append_char (dpi, '-');
-		    d_print_comp (dpi, d_right (dc));
+		    d_print_comp (dpi, options, d_right (dc));
 		    switch (tp)
 		      {
 		      default:
 			break;
 		      case D_PRINT_UNSIGNED:
 		break;
 	      }
 	  }
 	d_append_char (dpi, '(');
-	d_print_comp (dpi, d_left (dc));
+	d_print_comp (dpi, options, d_left (dc));
 	d_append_char (dpi, ')');
 	if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
 	  d_append_char (dpi, '-');
 	if (tp == D_PRINT_FLOAT)
 	  d_append_char (dpi, '[');
-	d_print_comp (dpi, d_right (dc));
+	d_print_comp (dpi, options, d_right (dc));
 	if (tp == D_PRINT_FLOAT)
 	  d_append_char (dpi, ']');
 }
 return;
 d_append_num (dpi, dc->u.s_number.number);
 return;
 case DEMANGLE_COMPONENT_JAVA_RESOURCE:
 d_append_string (dpi, "java resource ");
-d_print_comp (dpi, d_left (dc));
+d_print_comp (dpi, options, d_left (dc));
 return;
 case DEMANGLE_COMPONENT_COMPOUND_NAME:
-d_print_comp (dpi, d_left (dc));
+d_print_comp (dpi, options, d_left (dc));
-d_print_comp (dpi, d_right (dc));
+d_print_comp (dpi, options, d_right (dc));
 return;
 case DEMANGLE_COMPONENT_CHARACTER:
 d_append_char (dpi, dc->u.s_character.character);
 return;
 case DEMANGLE_COMPONENT_DECLTYPE:
 d_append_string (dpi, "decltype (");
-d_print_comp (dpi, d_left (dc));
+d_print_comp (dpi, options, d_left (dc));
 d_append_char (dpi, ')');
 return;
 case DEMANGLE_COMPONENT_PACK_EXPANSION:
 {
 	if (a == NULL)
 	  {
 	    /* d_find_pack won't find anything if the only packs involved
 	       in this expansion are function parameter packs; in that
 	       case, just print the pattern and "...".  */
-	    d_print_subexpr (dpi, d_left (dc));
+	    d_print_subexpr (dpi, options, d_left (dc));
 	    d_append_string (dpi, "...");
 	    return;
 	  }
 	len = d_pack_length (a);
 	dc = d_left (dc);
 	for (i = 0; i < len; ++i)
 	  {
 	    dpi->pack_index = i;
-	    d_print_comp (dpi, dc);
+	    d_print_comp (dpi, options, dc);
 	    if (i < len-1)
 	      d_append_string (dpi, ", ");
 	  }
 }
 return;
 case DEMANGLE_COMPONENT_FUNCTION_PARAM:
-d_append_string (dpi, "{parm#");
+{
-d_append_num (dpi, dc->u.s_number.number + 1);
+	long num = dc->u.s_number.number;
-d_append_char (dpi, '}');
+	if (num == 0)
+	  d_append_string (dpi, "this");
+	else
+	  {
+	    d_append_string (dpi, "{parm#");
+	    d_append_num (dpi, num);
+	    d_append_char (dpi, '}');
+	  }
+}
 return;
 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
 d_append_string (dpi, "global constructors keyed to ");
-d_print_comp (dpi, dc->u.s_binary.left);
+d_print_comp (dpi, options, dc->u.s_binary.left);
 return;
 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
 d_append_string (dpi, "global destructors keyed to ");
-d_print_comp (dpi, dc->u.s_binary.left);
+d_print_comp (dpi, options, dc->u.s_binary.left);
 return;
 case DEMANGLE_COMPONENT_LAMBDA:
 d_append_string (dpi, "{lambda(");
-d_print_comp (dpi, dc->u.s_unary_num.sub);
+/* Generic lambda auto parms are mangled as the template type
+	 parm they are.  */
+dpi->is_lambda_arg++;
+d_print_comp (dpi, options, dc->u.s_unary_num.sub);
+dpi->is_lambda_arg--;
 d_append_string (dpi, ")#");
 d_append_num (dpi, dc->u.s_unary_num.num + 1);
 d_append_char (dpi, '}');
 return;
 d_append_string (dpi, "{unnamed type#");
 d_append_num (dpi, dc->u.s_number.number + 1);
 d_append_char (dpi, '}');
 return;
+case DEMANGLE_COMPONENT_CLONE:
+d_print_comp (dpi, options, d_left (dc));
+d_append_string (dpi, " [clone ");
+d_print_comp (dpi, options, d_right (dc));
+d_append_char (dpi, ']');
+return;
 default:
 d_print_error (dpi);
 return;
 }
+}
+static void
+d_print_comp (struct d_print_info *dpi, int options,
+	      struct demangle_component *dc)
+{
+struct d_component_stack self;
+if (dc == NULL || dc->d_printing > 1 || dpi->recursion > MAX_RECURSION_COUNT)
+{
+d_print_error (dpi);
+return;
+}
+dc->d_printing++;
+dpi->recursion++;
+self.dc = dc;
+self.parent = dpi->component_stack;
+dpi->component_stack = &self;
+d_print_comp_inner (dpi, options, dc);
+dpi->component_stack = self.parent;
+dc->d_printing--;
+dpi->recursion--;
 }
 /* Print a Java dentifier.  For Java we try to handle encoded extended
 Unicode characters.  The C++ ABI doesn't mention Unicode encoding,
 so we don't it for C++.  Characters are encoded as
 /* Print a list of modifiers.  SUFFIX is 1 if we are printing
 qualifiers on this after printing a function.  */
 static void
-d_print_mod_list (struct d_print_info *dpi,
+d_print_mod_list (struct d_print_info *dpi, int options,
 struct d_print_mod *mods, int suffix)
 {
 struct d_print_template *hold_dpt;
 if (mods == NULL || d_print_saw_error (dpi))
 return;
 if (mods->printed
 || (! suffix
-	  && (mods->mod->type == DEMANGLE_COMPONENT_RESTRICT_THIS
+	  && (is_fnqual_component_type (mods->mod->type))))
-	      || mods->mod->type == DEMANGLE_COMPONENT_VOLATILE_THIS
+{
-	      || mods->mod->type == DEMANGLE_COMPONENT_CONST_THIS)))
+d_print_mod_list (dpi, options, mods->next, suffix);
-{
-d_print_mod_list (dpi, mods->next, suffix);
 return;
 }
 mods->printed = 1;
 hold_dpt = dpi->templates;
 dpi->templates = mods->templates;
 if (mods->mod->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
 {
-d_print_function_type (dpi, mods->mod, mods->next);
+d_print_function_type (dpi, options, mods->mod, mods->next);
 dpi->templates = hold_dpt;
 return;
 }
 else if (mods->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
 {
-d_print_array_type (dpi, mods->mod, mods->next);
+d_print_array_type (dpi, options, mods->mod, mods->next);
 dpi->templates = hold_dpt;
 return;
 }
 else if (mods->mod->type == DEMANGLE_COMPONENT_LOCAL_NAME)
 {
 	 print it as usual, but don't let the left argument see any
 	 modifiers.  */
 hold_modifiers = dpi->modifiers;
 dpi->modifiers = NULL;
-d_print_comp (dpi, d_left (mods->mod));
+d_print_comp (dpi, options, d_left (mods->mod));
 dpi->modifiers = hold_modifiers;
-if ((dpi->options & DMGL_JAVA) == 0)
+if ((options & DMGL_JAVA) == 0)
 	d_append_string (dpi, "::");
 else
 	d_append_char (dpi, '.');
 dc = d_right (mods->mod);
 	  d_append_num (dpi, dc->u.s_unary_num.num + 1);
 	  d_append_string (dpi, "}::");
 	  dc = dc->u.s_unary_num.sub;
 	}
-while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS
+while (is_fnqual_component_type (dc->type))
-	     || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS
-	     || dc->type == DEMANGLE_COMPONENT_CONST_THIS)
 	dc = d_left (dc);
-d_print_comp (dpi, dc);
+d_print_comp (dpi, options, dc);
 dpi->templates = hold_dpt;
 return;
 }
-d_print_mod (dpi, mods->mod);
+d_print_mod (dpi, options, mods->mod);
 dpi->templates = hold_dpt;
-d_print_mod_list (dpi, mods->next, suffix);
+d_print_mod_list (dpi, options, mods->next, suffix);
 }
 /* Print a modifier.  */
 static void
-d_print_mod (struct d_print_info *dpi,
+d_print_mod (struct d_print_info *dpi, int options,
-const struct demangle_component *mod)
+struct demangle_component *mod)
 {
 switch (mod->type)
 {
 case DEMANGLE_COMPONENT_RESTRICT:
 case DEMANGLE_COMPONENT_RESTRICT_THIS:
 return;
 case DEMANGLE_COMPONENT_CONST:
 case DEMANGLE_COMPONENT_CONST_THIS:
 d_append_string (dpi, " const");
 return;
+case DEMANGLE_COMPONENT_TRANSACTION_SAFE:
+d_append_string (dpi, " transaction_safe");
+return;
+case DEMANGLE_COMPONENT_NOEXCEPT:
+d_append_string (dpi, " noexcept");
+if (d_right (mod))
+	{
+	  d_append_char (dpi, '(');
+	  d_print_comp (dpi, options, d_right (mod));
+	  d_append_char (dpi, ')');
+	}
+return;
+case DEMANGLE_COMPONENT_THROW_SPEC:
+d_append_string (dpi, " throw");
+if (d_right (mod))
+	{
+	  d_append_char (dpi, '(');
+	  d_print_comp (dpi, options, d_right (mod));
+	  d_append_char (dpi, ')');
+	}
+return;
 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
 d_append_char (dpi, ' ');
-d_print_comp (dpi, d_right (mod));
+d_print_comp (dpi, options, d_right (mod));
 return;
 case DEMANGLE_COMPONENT_POINTER:
 /* There is no pointer symbol in Java.  */
-if ((dpi->options & DMGL_JAVA) == 0)
+if ((options & DMGL_JAVA) == 0)
 	d_append_char (dpi, '*');
 return;
+case DEMANGLE_COMPONENT_REFERENCE_THIS:
+/* For the ref-qualifier, put a space before the &.  */
+d_append_char (dpi, ' ');
+/* FALLTHRU */
 case DEMANGLE_COMPONENT_REFERENCE:
 d_append_char (dpi, '&');
 return;
+case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
+d_append_char (dpi, ' ');
+/* FALLTHRU */
 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
 d_append_string (dpi, "&&");
 return;
 case DEMANGLE_COMPONENT_COMPLEX:
 d_append_string (dpi, "complex ");
 d_append_string (dpi, "imaginary ");
 return;
 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
 if (d_last_char (dpi) != '(')
 	d_append_char (dpi, ' ');
-d_print_comp (dpi, d_left (mod));
+d_print_comp (dpi, options, d_left (mod));
 d_append_string (dpi, "::*");
 return;
 case DEMANGLE_COMPONENT_TYPED_NAME:
-d_print_comp (dpi, d_left (mod));
+d_print_comp (dpi, options, d_left (mod));
 return;
 case DEMANGLE_COMPONENT_VECTOR_TYPE:
 d_append_string (dpi, " __vector(");
-d_print_comp (dpi, d_left (mod));
+d_print_comp (dpi, options, d_left (mod));
 d_append_char (dpi, ')');
 return;
 default:
 /* Otherwise, we have something that won't go back on the
 	 modifier stack, so we can just print it.  */
-d_print_comp (dpi, mod);
+d_print_comp (dpi, options, mod);
 return;
 }
 }
 /* Print a function type, except for the return type.  */
 static void
-d_print_function_type (struct d_print_info *dpi,
+d_print_function_type (struct d_print_info *dpi, int options,
-const struct demangle_component *dc,
+struct demangle_component *dc,
 struct d_print_mod *mods)
 {
 int need_paren;
 int need_space;
 struct d_print_mod *p;
 	case DEMANGLE_COMPONENT_IMAGINARY:
 	case DEMANGLE_COMPONENT_PTRMEM_TYPE:
 	  need_space = 1;
 	  need_paren = 1;
 	  break;
-	case DEMANGLE_COMPONENT_RESTRICT_THIS:
+	FNQUAL_COMPONENT_CASE:
-	case DEMANGLE_COMPONENT_VOLATILE_THIS:
-	case DEMANGLE_COMPONENT_CONST_THIS:
 	  break;
 	default:
 	  break;
 	}
 if (need_paren)
 }
 hold_modifiers = dpi->modifiers;
 dpi->modifiers = NULL;
-d_print_mod_list (dpi, mods, 0);
+d_print_mod_list (dpi, options, mods, 0);
 if (need_paren)
 d_append_char (dpi, ')');
 d_append_char (dpi, '(');
 if (d_right (dc) != NULL)
-d_print_comp (dpi, d_right (dc));
+d_print_comp (dpi, options, d_right (dc));
 d_append_char (dpi, ')');
-d_print_mod_list (dpi, mods, 1);
+d_print_mod_list (dpi, options, mods, 1);
 dpi->modifiers = hold_modifiers;
 }
 /* Print an array type, except for the element type.  */
 static void
-d_print_array_type (struct d_print_info *dpi,
+d_print_array_type (struct d_print_info *dpi, int options,
-const struct demangle_component *dc,
+struct demangle_component *dc,
 struct d_print_mod *mods)
 {
 int need_space;
 need_space = 1;
 	}
 if (need_paren)
 	d_append_string (dpi, " (");
-d_print_mod_list (dpi, mods, 0);
+d_print_mod_list (dpi, options, mods, 0);
 if (need_paren)
 	d_append_char (dpi, ')');
 }
 d_append_char (dpi, ' ');
 d_append_char (dpi, '[');
 if (d_left (dc) != NULL)
-d_print_comp (dpi, d_left (dc));
+d_print_comp (dpi, options, d_left (dc));
 d_append_char (dpi, ']');
 }
 /* Print an operator in an expression.  */
 static void
-d_print_expr_op (struct d_print_info *dpi,
+d_print_expr_op (struct d_print_info *dpi, int options,
-const struct demangle_component *dc)
+struct demangle_component *dc)
 {
 if (dc->type == DEMANGLE_COMPONENT_OPERATOR)
 d_append_buffer (dpi, dc->u.s_operator.op->name,
 		     dc->u.s_operator.op->len);
 else
-d_print_comp (dpi, dc);
+d_print_comp (dpi, options, dc);
 }
 /* Print a cast.  */
 static void
-d_print_cast (struct d_print_info *dpi,
+d_print_cast (struct d_print_info *dpi, int options,
-const struct demangle_component *dc)
+	      struct demangle_component *dc)
 {
-if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE)
+d_print_comp (dpi, options, d_left (dc));
-d_print_comp (dpi, d_left (dc));
+}
-else
-{
+/* Print a conversion operator.  */
-struct d_print_mod *hold_dpm;
-struct d_print_template dpt;
+static void
+d_print_conversion (struct d_print_info *dpi, int options,
-/* It appears that for a templated cast operator, we need to put
+		    struct demangle_component *dc)
-	 the template parameters in scope for the operator name, but
+{
-	 not for the parameters.  The effect is that we need to handle
+struct d_print_template dpt;
-	 the template printing here.  */
+/* For a conversion operator, we need the template parameters from
-hold_dpm = dpi->modifiers;
+the enclosing template in scope for processing the type.  */
-dpi->modifiers = NULL;
+if (dpi->current_template != NULL)
+{
 dpt.next = dpi->templates;
 dpi->templates = &dpt;
-dpt.template_decl = d_left (dc);
+dpt.template_decl = dpi->current_template;
+}
-d_print_comp (dpi, d_left (d_left (dc)));
+if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE)
-dpi->templates = dpt.next;
+{
+d_print_comp (dpi, options, d_left (dc));
+if (dpi->current_template != NULL)
+	dpi->templates = dpt.next;
+}
+else
+{
+d_print_comp (dpi, options, d_left (d_left (dc)));
+/* For a templated cast operator, we need to remove the template
+	 parameters from scope after printing the operator name,
+	 so we need to handle the template printing here.  */
+if (dpi->current_template != NULL)
+	dpi->templates = dpt.next;
 if (d_last_char (dpi) == '<')
 	d_append_char (dpi, ' ');
 d_append_char (dpi, '<');
-d_print_comp (dpi, d_right (d_left (dc)));
+d_print_comp (dpi, options, d_right (d_left (dc)));
 /* Avoid generating two consecutive '>' characters, to avoid
 	 the C++ syntactic ambiguity.  */
 if (d_last_char (dpi) == '>')
 	d_append_char (dpi, ' ');
 d_append_char (dpi, '>');
-dpi->modifiers = hold_dpm;
 }
 }
 /* Initialize the information structure we use to pass around
 information.  */
 /* Similarly, we can not need more substitutions than there are
 chars in the mangled string.  */
 di->num_subs = len;
 di->next_sub = 0;
-di->did_subs = 0;
 di->last_name = NULL;
 di->expansion = 0;
+di->is_expression = 0;
+di->is_conversion = 0;
 }
 /* Internal implementation for the demangler.  If MANGLED is a g++ v3 ABI
 mangled name, return strings in repeated callback giving the demangled
 name.  OPTIONS is the usual libiberty demangler options.  On success,
 			   : DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS),
 			  d_make_demangle_mangled_name (&di, d_str (&di)),
 			  NULL);
 	d_advance (&di, strlen (d_str (&di)));
 	break;
+default:
+	abort (); /* We have listed all the cases.  */
 }
 /* If DMGL_PARAMS is set, then if we didn't consume the entire
 mangled string, then we didn't successfully demangle it.  If
 DMGL_PARAMS is not set, we didn't look at the trailing
 ret = 0;
 while (dc != NULL)
 {
 	switch (dc->type)
 	  {
+	    /* These cannot appear on a constructor or destructor.  */
+	  case DEMANGLE_COMPONENT_RESTRICT_THIS:
+	  case DEMANGLE_COMPONENT_VOLATILE_THIS:
+	  case DEMANGLE_COMPONENT_CONST_THIS:
+	  case DEMANGLE_COMPONENT_REFERENCE_THIS:
+	  case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
 	  default:
 	    dc = NULL;
 	    break;
 	  case DEMANGLE_COMPONENT_TYPED_NAME:
 	  case DEMANGLE_COMPONENT_TEMPLATE:
-	  case DEMANGLE_COMPONENT_RESTRICT_THIS:
-	  case DEMANGLE_COMPONENT_VOLATILE_THIS:
-	  case DEMANGLE_COMPONENT_CONST_THIS:
 	    dc = d_left (dc);
 	    break;
 	  case DEMANGLE_COMPONENT_QUAL_NAME:
 	  case DEMANGLE_COMPONENT_LOCAL_NAME:
 	    dc = d_right (dc);

Mercurial > hg > CbC > CbC_gcc

comparison libiberty/cp-demangle.c @ 111:04ced10e8804