Import libiberty from gcc

	PR 29200
include/
	* ansidecl.h,
	* demangle.h: Import from gcc.
libiberty/
	* cp-demangle.c,
	* testsuite/demangle-expected: Import from gcc.

diff --git a/include/ansidecl.h b/include/ansidecl.h
index 46fe3ffabd9ec3093385027513cdcbcb331ad395..056a03ebb6e8cd98dce573a8864ec5bbfd61144f 100644 (file)
--- a/include/ansidecl.h
+++ b/include/ansidecl.h
@@ -321,47 +321,6 @@ So instead we use the macro below and test it against specific values.  */
 #define CONSTEXPR
 #endif
 
-/* C++11 adds the ability to add "override" after an implementation of a
-   virtual function in a subclass, to:
-     (A) document that this is an override of a virtual function
-     (B) allow the compiler to issue a warning if it isn't (e.g. a mismatch
-         of the type signature).
-
-   Similarly, it allows us to add a "final" to indicate that no subclass
-   may subsequently override the vfunc.
-
-   Provide OVERRIDE and FINAL as macros, allowing us to get these benefits
-   when compiling with C++11 support, but without requiring C++11.
-
-   For gcc, use "-std=c++11" to enable C++11 support; gcc 6 onwards enables
-   this by default (actually GNU++14).  */
-
-#if defined __cplusplus
-# if __cplusplus >= 201103
-   /* C++11 claims to be available: use it.  Final/override were only
-      implemented in 4.7, though.  */
-#  if GCC_VERSION < 4007
-#   define OVERRIDE
-#   define FINAL
-#  else
-#   define OVERRIDE override
-#   define FINAL final
-#  endif
-# elif GCC_VERSION >= 4007
-   /* G++ 4.7 supports __final in C++98.  */
-#  define OVERRIDE
-#  define FINAL __final
-# else
-   /* No C++11 support; leave the macros empty.  */
-#  define OVERRIDE
-#  define FINAL
-# endif
-#else
-  /* No C++11 support; leave the macros empty.  */
-# define OVERRIDE
-# define FINAL
-#endif
-
 /* A macro to disable the copy constructor and assignment operator.
    When building with C++11 and above, the methods are explicitly
    deleted, causing a compile-time error if something tries to copy.

diff --git a/include/demangle.h b/include/demangle.h
index 402308f769f1376f8ee80a7bf9d56aa52154ff1e..e2aa4a971ffe0a2ce73b0f6d987d985748fd5c6f 100644 (file)
--- a/include/demangle.h
+++ b/include/demangle.h
@@ -449,7 +449,14 @@ enum demangle_component_type
   /* A cloned function.  */
   DEMANGLE_COMPONENT_CLONE,
   DEMANGLE_COMPONENT_NOEXCEPT,
-  DEMANGLE_COMPONENT_THROW_SPEC
+  DEMANGLE_COMPONENT_THROW_SPEC,
+
+  DEMANGLE_COMPONENT_STRUCTURED_BINDING,
+
+  DEMANGLE_COMPONENT_MODULE_NAME,
+  DEMANGLE_COMPONENT_MODULE_PARTITION,
+  DEMANGLE_COMPONENT_MODULE_ENTITY,
+  DEMANGLE_COMPONENT_MODULE_INIT,
 };
 
 /* Types which are only used internally.  */

diff --git a/libiberty/cp-demangle.c b/libiberty/cp-demangle.c
index 6dff7d28fcf2e6bda72c07c6783d3f373c005bb3..d06d80d1feeb183dd8b6657a9315b93674bf0fe6 100644 (file)
--- a/libiberty/cp-demangle.c
+++ b/libiberty/cp-demangle.c
@@ -425,13 +425,16 @@ is_ctor_dtor_or_conversion (struct demangle_component *);
 
 static struct demangle_component *d_encoding (struct d_info *, int);
 
-static struct demangle_component *d_name (struct d_info *);
+static struct demangle_component *d_name (struct d_info *, int substable);
 
 static struct demangle_component *d_nested_name (struct d_info *);
 
+static int d_maybe_module_name (struct d_info *, struct demangle_component **);
+
 static struct demangle_component *d_prefix (struct d_info *, int);
 
-static struct demangle_component *d_unqualified_name (struct d_info *);
+static struct demangle_component *d_unqualified_name (struct d_info *,
+       struct demangle_component *scope, struct demangle_component *module);
 
 static struct demangle_component *d_source_name (struct d_info *);
 
@@ -462,7 +465,7 @@ static struct demangle_component *
 d_bare_function_type (struct d_info *, int);
 
 static struct demangle_component *
-d_class_enum_type (struct d_info *);
+d_class_enum_type (struct d_info *, int);
 
 static struct demangle_component *d_array_type (struct d_info *);
 
@@ -983,6 +986,7 @@ d_make_comp (struct d_info *di, enum demangle_component_type type,
     case DEMANGLE_COMPONENT_COMPOUND_NAME:
     case DEMANGLE_COMPONENT_VECTOR_TYPE:
     case DEMANGLE_COMPONENT_CLONE:
+    case DEMANGLE_COMPONENT_MODULE_ENTITY:
       if (left == NULL || right == NULL)
        return NULL;
       break;
@@ -1020,6 +1024,8 @@ d_make_comp (struct d_info *di, enum demangle_component_type type,
     case DEMANGLE_COMPONENT_NULLARY:
     case DEMANGLE_COMPONENT_TRINARY_ARG2:
     case DEMANGLE_COMPONENT_TPARM_OBJ:
+    case DEMANGLE_COMPONENT_STRUCTURED_BINDING:
+    case DEMANGLE_COMPONENT_MODULE_INIT:
       if (left == NULL)
        return NULL;
       break;
@@ -1028,6 +1034,8 @@ d_make_comp (struct d_info *di, enum demangle_component_type type,
         empty.  */
     case DEMANGLE_COMPONENT_ARRAY_TYPE:
     case DEMANGLE_COMPONENT_INITIALIZER_LIST:
+    case DEMANGLE_COMPONENT_MODULE_NAME:
+    case DEMANGLE_COMPONENT_MODULE_PARTITION:
       if (right == NULL)
        return NULL;
       break;
@@ -1322,7 +1330,7 @@ d_encoding (struct d_info *di, int top_level)
     dc = d_special_name (di);
   else
     {
-      dc = d_name (di);
+      dc = d_name (di, 0);
 
       if (!dc)
        /* Failed already.  */;
@@ -1416,80 +1424,74 @@ d_abi_tags (struct d_info *di, struct demangle_component *dc)
 */
 
 static struct demangle_component *
-d_name (struct d_info *di)
+d_name (struct d_info *di, int substable)
 {
   char peek = d_peek_char (di);
-  struct demangle_component *dc;
+  struct demangle_component *dc = NULL;
+  struct demangle_component *module = NULL;
+  int subst = 0;
 
   switch (peek)
     {
     case 'N':
-      return d_nested_name (di);
+      dc = d_nested_name (di);
+      break;
 
     case 'Z':
-      return d_local_name (di);
+      dc = d_local_name (di);
+      break;
 
     case 'U':
-      return d_unqualified_name (di);
+      dc = d_unqualified_name (di, NULL, NULL);
+      break;
 
     case 'S':
       {
-       int subst;
-
-       if (d_peek_next_char (di) != 't')
-         {
-           dc = d_substitution (di, 0);
-           subst = 1;
-         }
-       else
+       if (d_peek_next_char (di) == 't')
          {
            d_advance (di, 2);
-           dc = d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME,
-                             d_make_name (di, "std", 3),
-                             d_unqualified_name (di));
+           dc = d_make_name (di, "std", 3);
            di->expansion += 3;
-           subst = 0;
          }
 
-       if (d_peek_char (di) != 'I')
-         {
-           /* The grammar does not permit this case to occur if we
-              called d_substitution() above (i.e., subst == 1).  We
-              don't bother to check.  */
-         }
-       else
+       if (d_peek_char (di) == 'S')
          {
-           /* This is <template-args>, which means that we just saw
-              <unscoped-template-name>, which is a substitution
-              candidate if we didn't just get it from a
-              substitution.  */
-           if (! subst)
+           module = d_substitution (di, 0);
+           if (!module)
+             return NULL;
+           if (!(module->type == DEMANGLE_COMPONENT_MODULE_NAME
+                 || module->type == DEMANGLE_COMPONENT_MODULE_PARTITION))
              {
-               if (! d_add_substitution (di, dc))
+               if (dc)
                  return NULL;
+               subst = 1;
+               dc = module;
+               module = NULL;
              }
-           dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
-                             d_template_args (di));
          }
-
-       return dc;
       }
+      /* FALLTHROUGH */
 
     case 'L':
     default:
-      dc = d_unqualified_name (di);
+      if (!subst)
+       dc = d_unqualified_name (di, dc, module);
       if (d_peek_char (di) == 'I')
        {
          /* This is <template-args>, which means that we just saw
             <unscoped-template-name>, which is a substitution
             candidate.  */
-         if (! d_add_substitution (di, dc))
+         if (!subst && !d_add_substitution (di, dc))
            return NULL;
          dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
                            d_template_args (di));
+         subst = 0;
        }
-      return dc;
+      break;
     }
+  if (substable && !subst && !d_add_substitution (di, dc))
+    return NULL;
+  return dc;
 }
 
 /* <nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
@@ -1545,54 +1547,42 @@ d_nested_name (struct d_info *di)
    if not (in an unresolved-name).  */
 
 static struct demangle_component *
-d_prefix (struct d_info *di, int subst)
+d_prefix (struct d_info *di, int substable)
 {
   struct demangle_component *ret = NULL;
 
-  while (1)
+  for (;;)
     {
-      char peek;
-      enum demangle_component_type comb_type;
-      struct demangle_component *dc;
-
-      peek = d_peek_char (di);
-      if (peek == '\0')
-       return NULL;
+      char peek = d_peek_char (di);
 
       /* 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 (peek == 'D')
+      if (peek == 'D'
+         && (d_peek_next_char (di) == 'T'
+             || d_peek_next_char (di) == 't'))
        {
-         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);
+         /* Decltype.  */
+         if (ret)
+           return NULL;
+         ret = cplus_demangle_type (di);
        }
-      else if (IS_DIGIT (peek)
-         || IS_LOWER (peek)
-         || peek == 'C'
-         || peek == 'U'
-         || peek == 'L')
-       dc = d_unqualified_name (di);
-      else if (peek == 'S')
-       dc = d_substitution (di, 1);
       else if (peek == 'I')
        {
          if (ret == NULL)
            return NULL;
-         comb_type = DEMANGLE_COMPONENT_TEMPLATE;
-         dc = d_template_args (di);
+         struct demangle_component *dc = d_template_args (di);
+         if (!dc)
+           return NULL;
+         ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret, dc);
        }
       else if (peek == 'T')
-       dc = d_template_param (di);
-      else if (peek == 'E')
-       return ret;
+       {
+         if (ret)
+           return NULL;
+         ret = d_template_param (di);
+       }
       else if (peek == 'M')
        {
          /* Initializer scope for a lambda.  We don't need to represent
@@ -1601,38 +1591,80 @@ d_prefix (struct d_info *di, int subst)
          if (ret == NULL)
            return NULL;
          d_advance (di, 1);
-         continue;
        }
       else
+       {
+         struct demangle_component *module = NULL;
+         if (peek == 'S')
+           {
+             module = d_substitution (di, 1);
+             if (!module)
+               return NULL;
+             if (!(module->type == DEMANGLE_COMPONENT_MODULE_NAME
+                   || module->type == DEMANGLE_COMPONENT_MODULE_PARTITION))
+               {
+                 if (ret)
+                   return NULL;
+                 ret = module;
+                 continue;
+               }
+           }
+         ret = d_unqualified_name (di, ret, module);
+       }
+
+      if (!ret)
+       break;
+
+      if (d_peek_char (di) == 'E')
+       break;
+
+      if (substable && !d_add_substitution (di, ret))
        return NULL;
+    }
 
-      if (ret == NULL)
-       ret = dc;
-      else
-       ret = d_make_comp (di, comb_type, ret, dc);
+  return ret;
+}
 
-      if (peek != 'S' && d_peek_char (di) != 'E' && subst)
+static int
+d_maybe_module_name (struct d_info *di, struct demangle_component **name)
+{
+  while (d_peek_char (di) == 'W')
+    {
+      d_advance (di, 1);
+      enum demangle_component_type code = DEMANGLE_COMPONENT_MODULE_NAME;
+      if (d_peek_char (di) == 'P')
        {
-         if (! d_add_substitution (di, ret))
-           return NULL;
+         code = DEMANGLE_COMPONENT_MODULE_PARTITION;
+         d_advance (di, 1);
        }
+
+      *name = d_make_comp (di, code, *name, d_source_name (di));
+      if (!*name)
+       return 0;
+      if (!d_add_substitution (di, *name))
+       return 0;
     }
+  return 1;
 }
 
-/* <unqualified-name> ::= <operator-name>
-                      ::= <ctor-dtor-name>
-                      ::= <source-name>
-                     ::= <local-source-name> 
-
-    <local-source-name>        ::= L <source-name> <discriminator>
+/* <unqualified-name> ::= [<module-name>] <operator-name> [<abi-tags>]
+                      ::= [<module-name>] <ctor-dtor-name> [<abi-tags>]
+                      ::= [<module-name>] <source-name> [<abi-tags>]
+                     ::= [<module-name>] <local-source-name>  [<abi-tags>]
+                      ::= [<module-name>] DC <source-name>+ E [<abi-tags>]
+    <local-source-name>        ::= L <source-name> <discriminator> [<abi-tags>]
 */
 
 static struct demangle_component *
-d_unqualified_name (struct d_info *di)
+d_unqualified_name (struct d_info *di, struct demangle_component *scope,
+                   struct demangle_component *module)
 {
   struct demangle_component *ret;
   char peek;
 
+  if (!d_maybe_module_name (di, &module))
+    return NULL;
+
   peek = d_peek_char (di);
   if (IS_DIGIT (peek))
     ret = d_source_name (di);
@@ -1655,6 +1687,28 @@ d_unqualified_name (struct d_info *di)
                               d_source_name (di));
        }
     }
+  else if (peek == 'D' && d_peek_next_char (di) == 'C')
+    {
+      // structured binding
+      d_advance (di, 2);
+      struct demangle_component *prev = NULL;
+      do
+       {
+         struct demangle_component *next = 
+           d_make_comp (di, DEMANGLE_COMPONENT_STRUCTURED_BINDING,
+                        d_source_name (di), NULL);
+         if (prev)
+           d_right (prev) = next;
+         else
+           ret = next;
+         prev = next;
+       }
+      while (prev && d_peek_char (di) != 'E');
+      if (prev)
+       d_advance (di, 1);
+      else
+       ret = NULL;
+    }
   else if (peek == 'C' || peek == 'D')
     ret = d_ctor_dtor_name (di);
   else if (peek == 'L')
@@ -1684,8 +1738,13 @@ d_unqualified_name (struct d_info *di)
   else
     return NULL;
 
+  if (module)
+    ret = d_make_comp (di, DEMANGLE_COMPONENT_MODULE_ENTITY, ret, module);
   if (d_peek_char (di) == 'B')
     ret = d_abi_tags (di, ret);
+  if (scope)
+    ret = d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, scope, ret);
+
   return ret;
 }
 
@@ -2126,11 +2185,11 @@ d_special_name (struct d_info *di)
 
        case 'H':
          return d_make_comp (di, DEMANGLE_COMPONENT_TLS_INIT,
-                             d_name (di), NULL);
+                             d_name (di, 0), NULL);
 
        case 'W':
          return d_make_comp (di, DEMANGLE_COMPONENT_TLS_WRAPPER,
-                             d_name (di), NULL);
+                             d_name (di, 0), NULL);
 
        case 'A':
          return d_make_comp (di, DEMANGLE_COMPONENT_TPARM_OBJ,
@@ -2146,11 +2205,11 @@ d_special_name (struct d_info *di)
        {
        case 'V':
          return d_make_comp (di, DEMANGLE_COMPONENT_GUARD,
-                             d_name (di), NULL);
+                             d_name (di, 0), NULL);
 
        case 'R':
          {
-           struct demangle_component *name = d_name (di);
+           struct demangle_component *name = d_name (di, 0);
            return d_make_comp (di, DEMANGLE_COMPONENT_REFTEMP, name,
                                d_number_component (di));
          }
@@ -2159,6 +2218,14 @@ d_special_name (struct d_info *di)
          return d_make_comp (di, DEMANGLE_COMPONENT_HIDDEN_ALIAS,
                              d_encoding (di, 0), NULL);
 
+       case 'I':
+         {
+           struct demangle_component *module = NULL;
+           if (!d_maybe_module_name (di, &module) || !module)
+             return NULL;
+           return d_make_comp (di, DEMANGLE_COMPONENT_MODULE_INIT,
+                               module, NULL);
+         }
        case 'T':
          switch (d_next_char (di))
            {
@@ -2481,13 +2548,6 @@ cplus_demangle_type (struct d_info *di)
       ret = d_function_type (di);
       break;
 
-    case '0': case '1': case '2': case '3': case '4':
-    case '5': case '6': case '7': case '8': case '9':
-    case 'N':
-    case 'Z':
-      ret = d_class_enum_type (di);
-      break;
-
     case 'A':
       ret = d_array_type (di);
       break;
@@ -2558,39 +2618,6 @@ cplus_demangle_type (struct d_info *di)
        }
       break;
 
-    case 'S':
-      /* If this is a special substitution, then it is the start of
-        <class-enum-type>.  */
-      {
-       char peek_next;
-
-       peek_next = d_peek_next_char (di);
-       if (IS_DIGIT (peek_next)
-           || peek_next == '_'
-           || IS_UPPER (peek_next))
-         {
-           ret = d_substitution (di, 0);
-           /* The substituted name may have been a template name and
-              may be followed by tepmlate args.  */
-           if (d_peek_char (di) == 'I')
-             ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
-                                d_template_args (di));
-           else
-             can_subst = 0;
-         }
-       else
-         {
-           ret = d_class_enum_type (di);
-           /* If the substitution was a complete type, then it is not
-              a new substitution candidate.  However, if the
-              substitution was followed by template arguments, then
-              the whole thing is a substitution candidate.  */
-           if (ret != NULL && ret->type == DEMANGLE_COMPONENT_SUB_STD)
-             can_subst = 0;
-         }
-      }
-      break;
-
     case 'O':
       d_advance (di, 1);
       ret = d_make_comp (di, DEMANGLE_COMPONENT_RVALUE_REFERENCE,
@@ -2731,7 +2758,7 @@ cplus_demangle_type (struct d_info *di)
       break;
 
     default:
-      return NULL;
+      return d_class_enum_type (di, 1);
     }
 
   if (can_subst)
@@ -3004,9 +3031,9 @@ d_bare_function_type (struct d_info *di, int has_return_type)
 /* <class-enum-type> ::= <name>  */
 
 static struct demangle_component *
-d_class_enum_type (struct d_info *di)
+d_class_enum_type (struct d_info *di, int substable)
 {
-  return d_name (di);
+  return d_name (di, substable);
 }
 
 /* <array-type> ::= A <(positive dimension) number> _ <(element) type>
@@ -3335,11 +3362,11 @@ d_unresolved_name (struct d_info *di)
     }
   else
     type = cplus_demangle_type (di);
-  name = d_unqualified_name (di);
+  name = d_unqualified_name (di, type, NULL);
   if (d_peek_char (di) == 'I')
     name = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
                        d_template_args (di));
-  return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type, name);
+  return name;
 }
 
 /* <expression> ::= <(unary) operator-name> <expression>
@@ -3408,7 +3435,7 @@ d_expression_1 (struct d_info *di)
        /* operator-function-id, i.e. operator+(t).  */
        d_advance (di, 2);
 
-      name = d_unqualified_name (di);
+      name = d_unqualified_name (di, NULL, NULL);
       if (name == NULL)
        return NULL;
       if (d_peek_char (di) == 'I')
@@ -3516,7 +3543,7 @@ d_expression_1 (struct d_info *di)
              /* fold-expression.  */
              left = d_operator_name (di);
            else if (!strcmp (code, "di"))
-             left = d_unqualified_name (di);
+             left = d_unqualified_name (di, NULL, NULL);
            else
              left = d_expression_1 (di);
            if (!strcmp (code, "cl"))
@@ -3534,7 +3561,7 @@ d_expression_1 (struct d_info *di)
                       d_unqualified_name rather than d_expression_1 here for
                       old mangled names that didn't add 'on' before operator
                       names.  */
-                   right = d_unqualified_name (di);
+                   right = d_unqualified_name (di, NULL, NULL);
                    if (d_peek_char (di) == 'I')
                      right = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE,
                                           right, d_template_args (di));
@@ -3744,7 +3771,7 @@ d_local_name (struct d_info *di)
            return NULL;
        }
 
-      name = d_name (di);
+      name = d_name (di, 0);
 
       if (name
          /* Lambdas and unnamed types have internal discriminators
@@ -4179,6 +4206,10 @@ d_count_templates_scopes (struct d_print_info *dpi,
     case DEMANGLE_COMPONENT_CHARACTER:
     case DEMANGLE_COMPONENT_NUMBER:
     case DEMANGLE_COMPONENT_UNNAMED_TYPE:
+    case DEMANGLE_COMPONENT_STRUCTURED_BINDING:
+    case DEMANGLE_COMPONENT_MODULE_NAME:
+    case DEMANGLE_COMPONENT_MODULE_PARTITION:
+    case DEMANGLE_COMPONENT_MODULE_INIT:
       break;
 
     case DEMANGLE_COMPONENT_TEMPLATE:
@@ -4284,6 +4315,7 @@ d_count_templates_scopes (struct d_print_info *dpi,
 
     case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
     case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
+    case DEMANGLE_COMPONENT_MODULE_ENTITY:
       d_count_templates_scopes (dpi, d_left (dc));
       break;
 
@@ -4850,6 +4882,38 @@ d_print_comp_inner (struct d_print_info *dpi, int options,
       d_append_char (dpi, ']');
       return;
 
+    case DEMANGLE_COMPONENT_STRUCTURED_BINDING:
+      d_append_char (dpi, '[');
+      for (;;)
+       {
+         d_print_comp (dpi, options, d_left (dc));
+         dc = d_right (dc);
+         if (!dc)
+           break;
+         d_append_string (dpi, ", ");
+       }
+      d_append_char (dpi, ']');
+      return;
+
+    case DEMANGLE_COMPONENT_MODULE_ENTITY:
+      d_print_comp (dpi, options, d_left (dc));
+      d_append_char (dpi, '@');
+      d_print_comp (dpi, options, d_right (dc));
+      return;
+
+    case DEMANGLE_COMPONENT_MODULE_NAME:
+    case DEMANGLE_COMPONENT_MODULE_PARTITION:
+      {
+       if (d_left (dc))
+         d_print_comp (dpi, options, d_left (dc));
+       char c = dc->type == DEMANGLE_COMPONENT_MODULE_PARTITION
+         ? ':' : d_left (dc) ? '.' : 0;
+       if (c)
+         d_append_char (dpi, c);
+       d_print_comp (dpi, options, d_right (dc));
+      }
+      return;
+
     case DEMANGLE_COMPONENT_QUAL_NAME:
     case DEMANGLE_COMPONENT_LOCAL_NAME:
       d_print_comp (dpi, options, d_left (dc));
@@ -5081,6 +5145,11 @@ d_print_comp_inner (struct d_print_info *dpi, int options,
       d_print_comp (dpi, options, dc->u.s_dtor.name);
       return;
 
+    case DEMANGLE_COMPONENT_MODULE_INIT:
+      d_append_string (dpi, "initializer for module ");
+      d_print_comp (dpi, options, d_left (dc));
+      return;
+
     case DEMANGLE_COMPONENT_VTABLE:
       d_append_string (dpi, "vtable for ");
       d_print_comp (dpi, options, d_left (dc));

diff --git a/libiberty/testsuite/demangle-expected b/libiberty/testsuite/demangle-expected
index de54ad73cc8ee3d36f3b52b3bbdeeaf77d694852..351af349219eba699b6c919448c531dfcb743cde 100644 (file)
--- a/libiberty/testsuite/demangle-expected
+++ b/libiberty/testsuite/demangle-expected
@@ -1493,3 +1493,80 @@ decltype ({parm#1}.A::x) f<A>(A)
 
 _Z2f6IP1AEDtptfp_gssr1A1BE1xET_
 decltype ({parm#1}->(::A::B::x)) f6<A*>(A*)
+
+# Structured Bindings
+_ZDC1a1bE
+[a, b]
+
+_ZNStDC1aEE
+std::[a]
+
+_ZN3NMSDC1aEE
+NMS::[a]
+
+# Modules
+_ZN5Outer5InnerW3FOO2FnERNS0_1XE
+Outer::Inner::Fn@FOO(Outer::Inner::X&)
+
+_ZN5OuterW3FOO5Inner2FnERNS1_1XE
+Outer::Inner@FOO::Fn(Outer::Inner@FOO::X&)
+
+_ZN4Quux4TotoW3FooW3Bar3BazEPNS0_S2_5PlughE
+Quux::Toto::Baz@Foo.Bar(Quux::Toto::Plugh@Foo.Bar*)
+
+_ZW6Module1fNS_1a1bENS0_1cE
+f@Module(a@Module::b, a@Module::c)
+
+_ZN3BobW3FOOW3BAR3BarEPS1_1APNS_S1_1BE
+Bob::Bar@FOO.BAR(A@FOO.BAR*, Bob::B@FOO.BAR*)
+
+_ZW3FOOW3BAR3FooPS0_1APN3BobS0_1BE
+Foo@FOO.BAR(A@FOO.BAR*, Bob::B@FOO.BAR*)
+
+_ZN3BobW3FOOW3BAZ3FooEPS0_W3BAR1APNS_S2_1BE
+Bob::Foo@FOO.BAZ(A@FOO.BAR*, Bob::B@FOO.BAR*)
+
+_ZW3FOOW3BAZ3BarPS_W3BAR1APN3BobS1_1BE
+Bar@FOO.BAZ(A@FOO.BAR*, Bob::B@FOO.BAR*)
+
+_ZNW3FOO3TPLIS_3OneE1MEPS1_
+TPL@FOO<One@FOO>::M(One@FOO*)
+
+_ZNW3FOO3TPLIS_3OneE1NIS_3TwoEEvPS1_PT_
+void TPL@FOO<One@FOO>::N<Two@FOO>(One@FOO*, Two@FOO*)
+
+_ZN3NMSW3FOO3TPLINS_S0_3OneEE1MEPS2_
+NMS::TPL@FOO<NMS::One@FOO>::M(NMS::One@FOO*)
+
+_ZN3NMSW3FOO3TPLINS_S0_3OneEE1NINS_S0_3TwoEEEvPS2_PT_
+void NMS::TPL@FOO<NMS::One@FOO>::N<NMS::Two@FOO>(NMS::One@FOO*, NMS::Two@FOO*)
+
+_ZNStW3STD9allocatorIiE1MEPi
+std::allocator@STD<int>::M(int*)
+
+_ZNStW3STD9allocatorIiE1NIfEEPT_Pi
+float* std::allocator@STD<int>::N<float>(int*)
+
+_ZNStW3STD9allocatorI4PoohE1MEPS1_
+std::allocator@STD<Pooh>::M(Pooh*)
+
+_ZNStW3STD9allocatorI4PoohE1NI6PigletEEPT_PS1_
+Piglet* std::allocator@STD<Pooh>::N<Piglet>(Pooh*)
+
+_ZW3FooDC1a1bE
+[a, b]@Foo
+
+_ZN1NW3FooDC1a1bEE
+N::[a, b]@Foo
+
+_ZN3NMSW3MOD3FooB3ABIEv
+NMS::Foo@MOD[abi:ABI]()
+
+_ZGIW3Foo
+initializer for module Foo
+
+_ZGIW3FooW3Bar
+initializer for module Foo.Bar
+
+_ZGIW3FooWP3BarW3Baz
+initializer for module Foo:Bar.Baz