LCOV - code coverage report
Current view: top level - gcc/cp - pt.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 12054 12799 94.2 %
Date: 2020-03-28 11:57:23 Functions: 387 416 93.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Handle parameterized types (templates) for GNU -*- C++ -*-.
       2                 :            :    Copyright (C) 1992-2020 Free Software Foundation, Inc.
       3                 :            :    Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing.
       4                 :            :    Rewritten by Jason Merrill (jason@cygnus.com).
       5                 :            : 
       6                 :            : This file is part of GCC.
       7                 :            : 
       8                 :            : GCC is free software; you can redistribute it and/or modify
       9                 :            : it under the terms of the GNU General Public License as published by
      10                 :            : the Free Software Foundation; either version 3, or (at your option)
      11                 :            : any later version.
      12                 :            : 
      13                 :            : GCC is distributed in the hope that it will be useful,
      14                 :            : but WITHOUT ANY WARRANTY; without even the implied warranty of
      15                 :            : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      16                 :            : GNU General Public License for more details.
      17                 :            : 
      18                 :            : You should have received a copy of the GNU General Public License
      19                 :            : along with GCC; see the file COPYING3.  If not see
      20                 :            : <http://www.gnu.org/licenses/>.  */
      21                 :            : 
      22                 :            : /* Known bugs or deficiencies include:
      23                 :            : 
      24                 :            :      all methods must be provided in header files; can't use a source
      25                 :            :      file that contains only the method templates and "just win".  */
      26                 :            : 
      27                 :            : #include "config.h"
      28                 :            : #include "system.h"
      29                 :            : #include "coretypes.h"
      30                 :            : #include "cp-tree.h"
      31                 :            : #include "timevar.h"
      32                 :            : #include "stringpool.h"
      33                 :            : #include "varasm.h"
      34                 :            : #include "attribs.h"
      35                 :            : #include "stor-layout.h"
      36                 :            : #include "intl.h"
      37                 :            : #include "c-family/c-objc.h"
      38                 :            : #include "cp-objcp-common.h"
      39                 :            : #include "toplev.h"
      40                 :            : #include "tree-iterator.h"
      41                 :            : #include "type-utils.h"
      42                 :            : #include "gimplify.h"
      43                 :            : #include "gcc-rich-location.h"
      44                 :            : #include "selftest.h"
      45                 :            : #include "target.h"
      46                 :            : 
      47                 :            : /* The type of functions taking a tree, and some additional data, and
      48                 :            :    returning an int.  */
      49                 :            : typedef int (*tree_fn_t) (tree, void*);
      50                 :            : 
      51                 :            : /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
      52                 :            :    instantiations have been deferred, either because their definitions
      53                 :            :    were not yet available, or because we were putting off doing the work.  */
      54                 :            : struct GTY ((chain_next ("%h.next"))) pending_template
      55                 :            : {
      56                 :            :   struct pending_template *next;
      57                 :            :   struct tinst_level *tinst;
      58                 :            : };
      59                 :            : 
      60                 :            : static GTY(()) struct pending_template *pending_templates;
      61                 :            : static GTY(()) struct pending_template *last_pending_template;
      62                 :            : 
      63                 :            : int processing_template_parmlist;
      64                 :            : static int template_header_count;
      65                 :            : 
      66                 :            : static GTY(()) tree saved_trees;
      67                 :            : static vec<int> inline_parm_levels;
      68                 :            : 
      69                 :            : static GTY(()) struct tinst_level *current_tinst_level;
      70                 :            : 
      71                 :            : static GTY(()) vec<tree, va_gc> *saved_access_scope;
      72                 :            : 
      73                 :            : /* Live only within one (recursive) call to tsubst_expr.  We use
      74                 :            :    this to pass the statement expression node from the STMT_EXPR
      75                 :            :    to the EXPR_STMT that is its result.  */
      76                 :            : static tree cur_stmt_expr;
      77                 :            : 
      78                 :            : // -------------------------------------------------------------------------- //
      79                 :            : // Local Specialization Stack
      80                 :            : //
      81                 :            : // Implementation of the RAII helper for creating new local
      82                 :            : // specializations.
      83                 :    8254400 : local_specialization_stack::local_specialization_stack (lss_policy policy)
      84                 :    8254400 :   : saved (local_specializations)
      85                 :            : {
      86                 :    8254400 :   if (policy == lss_blank || !saved)
      87                 :    6645240 :     local_specializations = new hash_map<tree, tree>;
      88                 :            :   else
      89                 :    1609160 :     local_specializations = new hash_map<tree, tree>(*saved);
      90                 :    8254400 : }
      91                 :            : 
      92                 :   16503400 : local_specialization_stack::~local_specialization_stack ()
      93                 :            : {
      94                 :   16503400 :   delete local_specializations;
      95                 :    8251690 :   local_specializations = saved;
      96                 :    8251690 : }
      97                 :            : 
      98                 :            : /* True if we've recursed into fn_type_unification too many times.  */
      99                 :            : static bool excessive_deduction_depth;
     100                 :            : 
     101                 :            : struct GTY((for_user)) spec_entry
     102                 :            : {
     103                 :            :   tree tmpl;
     104                 :            :   tree args;
     105                 :            :   tree spec;
     106                 :            : };
     107                 :            : 
     108                 :            : struct spec_hasher : ggc_ptr_hash<spec_entry>
     109                 :            : {
     110                 :            :   static hashval_t hash (spec_entry *);
     111                 :            :   static bool equal (spec_entry *, spec_entry *);
     112                 :            : };
     113                 :            : 
     114                 :            : static GTY (()) hash_table<spec_hasher> *decl_specializations;
     115                 :            : 
     116                 :            : static GTY (()) hash_table<spec_hasher> *type_specializations;
     117                 :            : 
     118                 :            : /* Contains canonical template parameter types. The vector is indexed by
     119                 :            :    the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
     120                 :            :    TREE_LIST, whose TREE_VALUEs contain the canonical template
     121                 :            :    parameters of various types and levels.  */
     122                 :            : static GTY(()) vec<tree, va_gc> *canonical_template_parms;
     123                 :            : 
     124                 :            : #define UNIFY_ALLOW_NONE 0
     125                 :            : #define UNIFY_ALLOW_MORE_CV_QUAL 1
     126                 :            : #define UNIFY_ALLOW_LESS_CV_QUAL 2
     127                 :            : #define UNIFY_ALLOW_DERIVED 4
     128                 :            : #define UNIFY_ALLOW_INTEGER 8
     129                 :            : #define UNIFY_ALLOW_OUTER_LEVEL 16
     130                 :            : #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
     131                 :            : #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
     132                 :            : 
     133                 :            : enum template_base_result {
     134                 :            :   tbr_incomplete_type,
     135                 :            :   tbr_ambiguous_baseclass,
     136                 :            :   tbr_success
     137                 :            : };
     138                 :            : 
     139                 :            : static bool resolve_overloaded_unification (tree, tree, tree, tree,
     140                 :            :                                             unification_kind_t, int,
     141                 :            :                                             bool);
     142                 :            : static int try_one_overload (tree, tree, tree, tree, tree,
     143                 :            :                              unification_kind_t, int, bool, bool);
     144                 :            : static int unify (tree, tree, tree, tree, int, bool);
     145                 :            : static void add_pending_template (tree);
     146                 :            : static tree reopen_tinst_level (struct tinst_level *);
     147                 :            : static tree tsubst_initializer_list (tree, tree);
     148                 :            : static tree get_partial_spec_bindings (tree, tree, tree);
     149                 :            : static tree coerce_template_parms (tree, tree, tree, tsubst_flags_t,
     150                 :            :                                    bool, bool);
     151                 :            : static tree coerce_innermost_template_parms (tree, tree, tree, tsubst_flags_t,
     152                 :            :                                               bool, bool);
     153                 :            : static void tsubst_enum (tree, tree, tree);
     154                 :            : static tree add_to_template_args (tree, tree);
     155                 :            : static bool check_instantiated_args (tree, tree, tsubst_flags_t);
     156                 :            : static int check_non_deducible_conversion (tree, tree, int, int,
     157                 :            :                                            struct conversion **, bool);
     158                 :            : static int maybe_adjust_types_for_deduction (unification_kind_t, tree*, tree*,
     159                 :            :                                              tree);
     160                 :            : static int type_unification_real (tree, tree, tree, const tree *,
     161                 :            :                                   unsigned int, int, unification_kind_t,
     162                 :            :                                   vec<deferred_access_check, va_gc> **,
     163                 :            :                                   bool);
     164                 :            : static void note_template_header (int);
     165                 :            : static tree convert_nontype_argument_function (tree, tree, tsubst_flags_t);
     166                 :            : static tree convert_nontype_argument (tree, tree, tsubst_flags_t);
     167                 :            : static tree convert_template_argument (tree, tree, tree,
     168                 :            :                                        tsubst_flags_t, int, tree);
     169                 :            : static tree for_each_template_parm (tree, tree_fn_t, void*,
     170                 :            :                                     hash_set<tree> *, bool, tree_fn_t = NULL);
     171                 :            : static tree expand_template_argument_pack (tree);
     172                 :            : static tree build_template_parm_index (int, int, int, tree, tree);
     173                 :            : static bool inline_needs_template_parms (tree, bool);
     174                 :            : static void push_inline_template_parms_recursive (tree, int);
     175                 :            : static tree reduce_template_parm_level (tree, tree, int, tree, tsubst_flags_t);
     176                 :            : static int mark_template_parm (tree, void *);
     177                 :            : static int template_parm_this_level_p (tree, void *);
     178                 :            : static tree tsubst_friend_function (tree, tree);
     179                 :            : static tree tsubst_friend_class (tree, tree);
     180                 :            : static int can_complete_type_without_circularity (tree);
     181                 :            : static tree get_bindings (tree, tree, tree, bool);
     182                 :            : static int template_decl_level (tree);
     183                 :            : static int check_cv_quals_for_unify (int, tree, tree);
     184                 :            : static int unify_pack_expansion (tree, tree, tree,
     185                 :            :                                  tree, unification_kind_t, bool, bool);
     186                 :            : static tree copy_template_args (tree);
     187                 :            : static tree tsubst_template_parms (tree, tree, tsubst_flags_t);
     188                 :            : tree most_specialized_partial_spec (tree, tsubst_flags_t);
     189                 :            : static tree tsubst_aggr_type (tree, tree, tsubst_flags_t, tree, int);
     190                 :            : static tree tsubst_arg_types (tree, tree, tree, tsubst_flags_t, tree);
     191                 :            : static tree tsubst_function_type (tree, tree, tsubst_flags_t, tree);
     192                 :            : static bool check_specialization_scope (void);
     193                 :            : static tree process_partial_specialization (tree);
     194                 :            : static void set_current_access_from_decl (tree);
     195                 :            : static enum template_base_result get_template_base (tree, tree, tree, tree,
     196                 :            :                                                     bool , tree *);
     197                 :            : static tree try_class_unification (tree, tree, tree, tree, bool);
     198                 :            : static int coerce_template_template_parms (tree, tree, tsubst_flags_t,
     199                 :            :                                            tree, tree);
     200                 :            : static bool template_template_parm_bindings_ok_p (tree, tree);
     201                 :            : static void tsubst_default_arguments (tree, tsubst_flags_t);
     202                 :            : static tree for_each_template_parm_r (tree *, int *, void *);
     203                 :            : static tree copy_default_args_to_explicit_spec_1 (tree, tree);
     204                 :            : static void copy_default_args_to_explicit_spec (tree);
     205                 :            : static bool invalid_nontype_parm_type_p (tree, tsubst_flags_t);
     206                 :            : static bool dependent_template_arg_p (tree);
     207                 :            : static bool any_template_arguments_need_structural_equality_p (tree);
     208                 :            : static bool dependent_type_p_r (tree);
     209                 :            : static tree tsubst_copy (tree, tree, tsubst_flags_t, tree);
     210                 :            : static tree tsubst_decl (tree, tree, tsubst_flags_t);
     211                 :            : static void perform_typedefs_access_check (tree tmpl, tree targs);
     212                 :            : static void append_type_to_template_for_access_check_1 (tree, tree, tree,
     213                 :            :                                                         location_t);
     214                 :            : static tree listify (tree);
     215                 :            : static tree listify_autos (tree, tree);
     216                 :            : static tree tsubst_template_parm (tree, tree, tsubst_flags_t);
     217                 :            : static tree instantiate_alias_template (tree, tree, tsubst_flags_t);
     218                 :            : static bool complex_alias_template_p (const_tree tmpl);
     219                 :            : static tree get_underlying_template (tree);
     220                 :            : static tree tsubst_attributes (tree, tree, tsubst_flags_t, tree);
     221                 :            : static tree canonicalize_expr_argument (tree, tsubst_flags_t);
     222                 :            : static tree make_argument_pack (tree);
     223                 :            : static void register_parameter_specializations (tree, tree);
     224                 :            : static tree enclosing_instantiation_of (tree tctx);
     225                 :            : 
     226                 :            : /* Make the current scope suitable for access checking when we are
     227                 :            :    processing T.  T can be FUNCTION_DECL for instantiated function
     228                 :            :    template, VAR_DECL for static member variable, or TYPE_DECL for
     229                 :            :    alias template (needed by instantiate_decl).  */
     230                 :            : 
     231                 :            : void
     232                 :   28522800 : push_access_scope (tree t)
     233                 :            : {
     234                 :   28522800 :   gcc_assert (VAR_OR_FUNCTION_DECL_P (t)
     235                 :            :               || TREE_CODE (t) == TYPE_DECL);
     236                 :            : 
     237                 :   53461300 :   if (DECL_FRIEND_CONTEXT (t))
     238                 :      91330 :     push_nested_class (DECL_FRIEND_CONTEXT (t));
     239                 :   28477200 :   else if (DECL_CLASS_SCOPE_P (t))
     240                 :   11783200 :     push_nested_class (DECL_CONTEXT (t));
     241                 :            :   else
     242                 :   16693900 :     push_to_top_level ();
     243                 :            : 
     244                 :   28522800 :   if (TREE_CODE (t) == FUNCTION_DECL)
     245                 :            :     {
     246                 :   24621900 :       vec_safe_push (saved_access_scope, current_function_decl);
     247                 :   24621900 :       current_function_decl = t;
     248                 :            :     }
     249                 :   28522800 : }
     250                 :            : 
     251                 :            : /* Restore the scope set up by push_access_scope.  T is the node we
     252                 :            :    are processing.  */
     253                 :            : 
     254                 :            : void
     255                 :   28520100 : pop_access_scope (tree t)
     256                 :            : {
     257                 :   28520100 :   if (TREE_CODE (t) == FUNCTION_DECL)
     258                 :   24619200 :     current_function_decl = saved_access_scope->pop();
     259                 :            : 
     260                 :   81930300 :   if (DECL_FRIEND_CONTEXT (t) || DECL_CLASS_SCOPE_P (t))
     261                 :   11828000 :     pop_nested_class ();
     262                 :            :   else
     263                 :   16692100 :     pop_from_top_level ();
     264                 :   28520100 : }
     265                 :            : 
     266                 :            : /* Do any processing required when DECL (a member template
     267                 :            :    declaration) is finished.  Returns the TEMPLATE_DECL corresponding
     268                 :            :    to DECL, unless it is a specialization, in which case the DECL
     269                 :            :    itself is returned.  */
     270                 :            : 
     271                 :            : tree
     272                 :    1364630 : finish_member_template_decl (tree decl)
     273                 :            : {
     274                 :    1364630 :   if (decl == error_mark_node)
     275                 :            :     return error_mark_node;
     276                 :            : 
     277                 :    1364530 :   gcc_assert (DECL_P (decl));
     278                 :            : 
     279                 :    1364530 :   if (TREE_CODE (decl) == TYPE_DECL)
     280                 :            :     {
     281                 :     139846 :       tree type;
     282                 :            : 
     283                 :     139846 :       type = TREE_TYPE (decl);
     284                 :     139846 :       if (type == error_mark_node)
     285                 :            :         return error_mark_node;
     286                 :     279692 :       if (MAYBE_CLASS_TYPE_P (type)
     287                 :     139846 :           && CLASSTYPE_TEMPLATE_INFO (type)
     288                 :     279692 :           && !CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
     289                 :            :         {
     290                 :      80922 :           tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
     291                 :      80264 :           check_member_template (tmpl);
     292                 :      80264 :           return tmpl;
     293                 :            :         }
     294                 :            :       return NULL_TREE;
     295                 :            :     }
     296                 :    1224680 :   else if (TREE_CODE (decl) == FIELD_DECL)
     297                 :          8 :     error_at (DECL_SOURCE_LOCATION (decl),
     298                 :            :               "data member %qD cannot be a member template", decl);
     299                 :    1224670 :   else if (DECL_TEMPLATE_INFO (decl))
     300                 :            :     {
     301                 :    1224670 :       if (!DECL_TEMPLATE_SPECIALIZATION (decl))
     302                 :            :         {
     303                 :    1224670 :           check_member_template (DECL_TI_TEMPLATE (decl));
     304                 :    1224670 :           return DECL_TI_TEMPLATE (decl);
     305                 :            :         }
     306                 :            :       else
     307                 :            :         return decl;
     308                 :            :     }
     309                 :            :   else
     310                 :          0 :     error_at (DECL_SOURCE_LOCATION (decl),
     311                 :            :               "invalid member template declaration %qD", decl);
     312                 :            : 
     313                 :          8 :   return error_mark_node;
     314                 :            : }
     315                 :            : 
     316                 :            : /* Create a template info node.  */
     317                 :            : 
     318                 :            : tree
     319                 :   78594500 : build_template_info (tree template_decl, tree template_args)
     320                 :            : {
     321                 :   78594500 :   tree result = make_node (TEMPLATE_INFO);
     322                 :   78594500 :   TI_TEMPLATE (result) = template_decl;
     323                 :   78594500 :   TI_ARGS (result) = template_args;
     324                 :   78594500 :   return result;
     325                 :            : }
     326                 :            : 
     327                 :            : /* Return the template info node corresponding to T, whatever T is.  */
     328                 :            : 
     329                 :            : tree
     330                 :  586559000 : get_template_info (const_tree t)
     331                 :            : {
     332                 :  586559000 :   tree tinfo = NULL_TREE;
     333                 :            : 
     334                 :  586559000 :   if (!t || t == error_mark_node)
     335                 :            :     return NULL;
     336                 :            : 
     337                 :  586559000 :   if (TREE_CODE (t) == NAMESPACE_DECL
     338                 :  565378000 :       || TREE_CODE (t) == PARM_DECL)
     339                 :            :     return NULL;
     340                 :            : 
     341                 :  974313000 :   if (DECL_P (t) && DECL_LANG_SPECIFIC (t))
     342                 :  295418000 :     tinfo = DECL_TEMPLATE_INFO (t);
     343                 :            : 
     344                 :  678814000 :   if (!tinfo && DECL_IMPLICIT_TYPEDEF_P (t))
     345                 :  115042000 :     t = TREE_TYPE (t);
     346                 :            : 
     347                 :  819251000 :   if (OVERLOAD_TYPE_P (t))
     348                 :  529088000 :     tinfo = TYPE_TEMPLATE_INFO (t);
     349                 :  297704000 :   else if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
     350                 :         10 :     tinfo = TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t);
     351                 :            : 
     352                 :            :   return tinfo;
     353                 :            : }
     354                 :            : 
     355                 :            : /* Returns the template nesting level of the indicated class TYPE.
     356                 :            : 
     357                 :            :    For example, in:
     358                 :            :      template <class T>
     359                 :            :      struct A
     360                 :            :      {
     361                 :            :        template <class U>
     362                 :            :        struct B {};
     363                 :            :      };
     364                 :            : 
     365                 :            :    A<T>::B<U> has depth two, while A<T> has depth one.
     366                 :            :    Both A<T>::B<int> and A<int>::B<U> have depth one, if
     367                 :            :    they are instantiations, not specializations.
     368                 :            : 
     369                 :            :    This function is guaranteed to return 0 if passed NULL_TREE so
     370                 :            :    that, for example, `template_class_depth (current_class_type)' is
     371                 :            :    always safe.  */
     372                 :            : 
     373                 :            : int
     374                 :   37241200 : template_class_depth (tree type)
     375                 :            : {
     376                 :   37241200 :   int depth;
     377                 :            : 
     378                 :   85423400 :   for (depth = 0; type && TREE_CODE (type) != NAMESPACE_DECL; )
     379                 :            :     {
     380                 :   18022600 :       tree tinfo = get_template_info (type);
     381                 :            : 
     382                 :   16614700 :       if (tinfo && PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo))
     383                 :   34502700 :           && uses_template_parms (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo))))
     384                 :   10812800 :         ++depth;
     385                 :            : 
     386                 :   18022600 :       if (DECL_P (type))
     387                 :      15355 :         type = CP_DECL_CONTEXT (type);
     388                 :   35942600 :       else if (LAMBDA_TYPE_P (type) && LAMBDA_TYPE_EXTRA_SCOPE (type))
     389                 :   55263800 :         type = LAMBDA_TYPE_EXTRA_SCOPE (type);
     390                 :            :       else
     391                 :   73260700 :         type = CP_TYPE_CONTEXT (type);
     392                 :            :     }
     393                 :            : 
     394                 :   37241200 :   return depth;
     395                 :            : }
     396                 :            : 
     397                 :            : /* Return TRUE if NODE instantiates a template that has arguments of
     398                 :            :    its own, be it directly a primary template or indirectly through a
     399                 :            :    partial specializations.  */
     400                 :            : static bool
     401                 :   13793100 : instantiates_primary_template_p (tree node)
     402                 :            : {
     403                 :   13793100 :   tree tinfo = get_template_info (node);
     404                 :   13793100 :   if (!tinfo)
     405                 :            :     return false;
     406                 :            : 
     407                 :   13793100 :   tree tmpl = TI_TEMPLATE (tinfo);
     408                 :   13793100 :   if (PRIMARY_TEMPLATE_P (tmpl))
     409                 :            :     return true;
     410                 :            : 
     411                 :    9849190 :   if (!DECL_TEMPLATE_SPECIALIZATION (tmpl))
     412                 :            :     return false;
     413                 :            : 
     414                 :            :   /* So now we know we have a specialization, but it could be a full
     415                 :            :      or a partial specialization.  To tell which, compare the depth of
     416                 :            :      its template arguments with those of its context.  */
     417                 :            : 
     418                 :          4 :   tree ctxt = DECL_CONTEXT (tmpl);
     419                 :          4 :   tree ctinfo = get_template_info (ctxt);
     420                 :          4 :   if (!ctinfo)
     421                 :            :     return true;
     422                 :            : 
     423                 :          4 :   return (TMPL_ARGS_DEPTH (TI_ARGS (tinfo))
     424                 :          8 :           > TMPL_ARGS_DEPTH (TI_ARGS (ctinfo)));
     425                 :            : }
     426                 :            : 
     427                 :            : /* Subroutine of maybe_begin_member_template_processing.
     428                 :            :    Returns true if processing DECL needs us to push template parms.  */
     429                 :            : 
     430                 :            : static bool
     431                 :   11428600 : inline_needs_template_parms (tree decl, bool nsdmi)
     432                 :            : {
     433                 :   11428600 :   if (!decl || (!nsdmi && ! DECL_TEMPLATE_INFO (decl)))
     434                 :            :     return false;
     435                 :            : 
     436                 :    9037960 :   return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl)))
     437                 :    9037960 :           > (processing_template_decl + DECL_TEMPLATE_SPECIALIZATION (decl)));
     438                 :            : }
     439                 :            : 
     440                 :            : /* Subroutine of maybe_begin_member_template_processing.
     441                 :            :    Push the template parms in PARMS, starting from LEVELS steps into the
     442                 :            :    chain, and ending at the beginning, since template parms are listed
     443                 :            :    innermost first.  */
     444                 :            : 
     445                 :            : static void
     446                 :    2446910 : push_inline_template_parms_recursive (tree parmlist, int levels)
     447                 :            : {
     448                 :    2446910 :   tree parms = TREE_VALUE (parmlist);
     449                 :    2446910 :   int i;
     450                 :            : 
     451                 :    2446910 :   if (levels > 1)
     452                 :      18325 :     push_inline_template_parms_recursive (TREE_CHAIN (parmlist), levels - 1);
     453                 :            : 
     454                 :    2446910 :   ++processing_template_decl;
     455                 :    4893820 :   current_template_parms
     456                 :    2446910 :     = tree_cons (size_int (processing_template_decl),
     457                 :            :                  parms, current_template_parms);
     458                 :    2446910 :   TEMPLATE_PARMS_FOR_INLINE (current_template_parms) = 1;
     459                 :            : 
     460                 :    2446910 :   begin_scope (TREE_VEC_LENGTH (parms) ? sk_template_parms : sk_template_spec,
     461                 :            :                NULL);
     462                 :    6824980 :   for (i = 0; i < TREE_VEC_LENGTH (parms); ++i)
     463                 :            :     {
     464                 :    4378070 :       tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
     465                 :            : 
     466                 :    8756130 :       if (error_operand_p (parm))
     467                 :         27 :         continue;
     468                 :            : 
     469                 :    4378040 :       gcc_assert (DECL_P (parm));
     470                 :            : 
     471                 :    4378040 :       switch (TREE_CODE (parm))
     472                 :            :         {
     473                 :    3976530 :         case TYPE_DECL:
     474                 :    3976530 :         case TEMPLATE_DECL:
     475                 :    3976530 :           pushdecl (parm);
     476                 :    3976530 :           break;
     477                 :            : 
     478                 :     401509 :         case PARM_DECL:
     479                 :            :           /* Push the CONST_DECL.  */
     480                 :     401509 :           pushdecl (TEMPLATE_PARM_DECL (DECL_INITIAL (parm)));
     481                 :     401509 :           break;
     482                 :            : 
     483                 :          0 :         default:
     484                 :          0 :           gcc_unreachable ();
     485                 :            :         }
     486                 :            :     }
     487                 :    2446910 : }
     488                 :            : 
     489                 :            : /* Restore the template parameter context for a member template, a
     490                 :            :    friend template defined in a class definition, or a non-template
     491                 :            :    member of template class.  */
     492                 :            : 
     493                 :            : void
     494                 :   11428600 : maybe_begin_member_template_processing (tree decl)
     495                 :            : {
     496                 :   11428600 :   tree parms;
     497                 :   11428600 :   int levels = 0;
     498                 :   11428600 :   bool nsdmi = TREE_CODE (decl) == FIELD_DECL;
     499                 :            : 
     500                 :   11428600 :   if (nsdmi)
     501                 :            :     {
     502                 :      33859 :       tree ctx = DECL_CONTEXT (decl);
     503                 :      33965 :       decl = (CLASSTYPE_TEMPLATE_INFO (ctx)
     504                 :            :               /* Disregard full specializations (c++/60999).  */
     505                 :      24151 :               && uses_template_parms (ctx)
     506                 :      58007 :               ? CLASSTYPE_TI_TEMPLATE (ctx) : NULL_TREE);
     507                 :            :     }
     508                 :            : 
     509                 :   11428600 :   if (inline_needs_template_parms (decl, nsdmi))
     510                 :            :     {
     511                 :    2428580 :       parms = DECL_TEMPLATE_PARMS (most_general_template (decl));
     512                 :    2428580 :       levels = TMPL_PARMS_DEPTH (parms) - processing_template_decl;
     513                 :            : 
     514                 :    2428580 :       if (DECL_TEMPLATE_SPECIALIZATION (decl))
     515                 :            :         {
     516                 :          0 :           --levels;
     517                 :          0 :           parms = TREE_CHAIN (parms);
     518                 :            :         }
     519                 :            : 
     520                 :    2428580 :       push_inline_template_parms_recursive (parms, levels);
     521                 :            :     }
     522                 :            : 
     523                 :            :   /* Remember how many levels of template parameters we pushed so that
     524                 :            :      we can pop them later.  */
     525                 :   11428600 :   inline_parm_levels.safe_push (levels);
     526                 :   11428600 : }
     527                 :            : 
     528                 :            : /* Undo the effects of maybe_begin_member_template_processing.  */
     529                 :            : 
     530                 :            : void
     531                 :   11428600 : maybe_end_member_template_processing (void)
     532                 :            : {
     533                 :   11428600 :   int i;
     534                 :   11428600 :   int last;
     535                 :            : 
     536                 :   11428600 :   if (inline_parm_levels.length () == 0)
     537                 :            :     return;
     538                 :            : 
     539                 :   11428600 :   last = inline_parm_levels.pop ();
     540                 :   13875500 :   for (i = 0; i < last; ++i)
     541                 :            :     {
     542                 :    2446910 :       --processing_template_decl;
     543                 :    2446910 :       current_template_parms = TREE_CHAIN (current_template_parms);
     544                 :    2446910 :       poplevel (0, 0, 0);
     545                 :            :     }
     546                 :            : }
     547                 :            : 
     548                 :            : /* Return a new template argument vector which contains all of ARGS,
     549                 :            :    but has as its innermost set of arguments the EXTRA_ARGS.  */
     550                 :            : 
     551                 :            : static tree
     552                 :   31041100 : add_to_template_args (tree args, tree extra_args)
     553                 :            : {
     554                 :   31041100 :   tree new_args;
     555                 :   31041100 :   int extra_depth;
     556                 :   31041100 :   int i;
     557                 :   31041100 :   int j;
     558                 :            : 
     559                 :   31041100 :   if (args == NULL_TREE || extra_args == error_mark_node)
     560                 :            :     return extra_args;
     561                 :            : 
     562                 :   15648200 :   extra_depth = TMPL_ARGS_DEPTH (extra_args);
     563                 :    7824100 :   new_args = make_tree_vec (TMPL_ARGS_DEPTH (args) + extra_depth);
     564                 :            : 
     565                 :   15792100 :   for (i = 1; i <= TMPL_ARGS_DEPTH (args); ++i)
     566                 :    7838530 :     SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (args, i));
     567                 :            : 
     568                 :   15648200 :   for (j = 1; j <= extra_depth; ++j, ++i)
     569                 :   15648200 :     SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (extra_args, j));
     570                 :            : 
     571                 :            :   return new_args;
     572                 :            : }
     573                 :            : 
     574                 :            : /* Like add_to_template_args, but only the outermost ARGS are added to
     575                 :            :    the EXTRA_ARGS.  In particular, all but TMPL_ARGS_DEPTH
     576                 :            :    (EXTRA_ARGS) levels are added.  This function is used to combine
     577                 :            :    the template arguments from a partial instantiation with the
     578                 :            :    template arguments used to attain the full instantiation from the
     579                 :            :    partial instantiation.  */
     580                 :            : 
     581                 :            : tree
     582                 :  208690000 : add_outermost_template_args (tree args, tree extra_args)
     583                 :            : {
     584                 :  208690000 :   tree new_args;
     585                 :            : 
     586                 :            :   /* If there are more levels of EXTRA_ARGS than there are ARGS,
     587                 :            :      something very fishy is going on.  */
     588                 :  834674000 :   gcc_assert (TMPL_ARGS_DEPTH (args) >= TMPL_ARGS_DEPTH (extra_args));
     589                 :            : 
     590                 :            :   /* If *all* the new arguments will be the EXTRA_ARGS, just return
     591                 :            :      them.  */
     592                 :  834674000 :   if (TMPL_ARGS_DEPTH (args) == TMPL_ARGS_DEPTH (extra_args))
     593                 :            :     return extra_args;
     594                 :            : 
     595                 :            :   /* For the moment, we make ARGS look like it contains fewer levels.  */
     596                 :   20351500 :   TREE_VEC_LENGTH (args) -= TMPL_ARGS_DEPTH (extra_args);
     597                 :            : 
     598                 :    7751000 :   new_args = add_to_template_args (args, extra_args);
     599                 :            : 
     600                 :            :   /* Now, we restore ARGS to its full dimensions.  */
     601                 :   20351500 :   TREE_VEC_LENGTH (args) += TMPL_ARGS_DEPTH (extra_args);
     602                 :            : 
     603                 :    7751000 :   return new_args;
     604                 :            : }
     605                 :            : 
     606                 :            : /* Return the N levels of innermost template arguments from the ARGS.  */
     607                 :            : 
     608                 :            : tree
     609                 :  890706000 : get_innermost_template_args (tree args, int n)
     610                 :            : {
     611                 :  890706000 :   tree new_args;
     612                 :  890706000 :   int extra_levels;
     613                 :  890706000 :   int i;
     614                 :            : 
     615                 :  890706000 :   gcc_assert (n >= 0);
     616                 :            : 
     617                 :            :   /* If N is 1, just return the innermost set of template arguments.  */
     618                 :  890706000 :   if (n == 1)
     619                 : 1781290000 :     return TMPL_ARGS_LEVEL (args, TMPL_ARGS_DEPTH (args));
     620                 :            : 
     621                 :            :   /* If we're not removing anything, just return the arguments we were
     622                 :            :      given.  */
     623                 :       1472 :   extra_levels = TMPL_ARGS_DEPTH (args) - n;
     624                 :        736 :   gcc_assert (extra_levels >= 0);
     625                 :        736 :   if (extra_levels == 0)
     626                 :            :     return args;
     627                 :            : 
     628                 :            :   /* Make a new set of arguments, not containing the outer arguments.  */
     629                 :          2 :   new_args = make_tree_vec (n);
     630                 :          6 :   for (i = 1; i <= n; ++i)
     631                 :          8 :     SET_TMPL_ARGS_LEVEL (new_args, i,
     632                 :            :                          TMPL_ARGS_LEVEL (args, i + extra_levels));
     633                 :            : 
     634                 :            :   return new_args;
     635                 :            : }
     636                 :            : 
     637                 :            : /* The inverse of get_innermost_template_args: Return all but the innermost
     638                 :            :    EXTRA_LEVELS levels of template arguments from the ARGS.  */
     639                 :            : 
     640                 :            : static tree
     641                 :      77601 : strip_innermost_template_args (tree args, int extra_levels)
     642                 :            : {
     643                 :      77601 :   tree new_args;
     644                 :     155202 :   int n = TMPL_ARGS_DEPTH (args) - extra_levels;
     645                 :      77601 :   int i;
     646                 :            : 
     647                 :      77601 :   gcc_assert (n >= 0);
     648                 :            : 
     649                 :            :   /* If N is 1, just return the outermost set of template arguments.  */
     650                 :      77601 :   if (n == 1)
     651                 :     155154 :     return TMPL_ARGS_LEVEL (args, 1);
     652                 :            : 
     653                 :            :   /* If we're not removing anything, just return the arguments we were
     654                 :            :      given.  */
     655                 :         24 :   gcc_assert (extra_levels >= 0);
     656                 :         24 :   if (extra_levels == 0)
     657                 :            :     return args;
     658                 :            : 
     659                 :            :   /* Make a new set of arguments, not containing the inner arguments.  */
     660                 :         24 :   new_args = make_tree_vec (n);
     661                 :         96 :   for (i = 1; i <= n; ++i)
     662                 :        144 :     SET_TMPL_ARGS_LEVEL (new_args, i,
     663                 :            :                          TMPL_ARGS_LEVEL (args, i));
     664                 :            : 
     665                 :            :   return new_args;
     666                 :            : }
     667                 :            : 
     668                 :            : /* We've got a template header coming up; push to a new level for storing
     669                 :            :    the parms.  */
     670                 :            : 
     671                 :            : void
     672                 :    7577710 : begin_template_parm_list (void)
     673                 :            : {
     674                 :            :   /* We use a non-tag-transparent scope here, which causes pushtag to
     675                 :            :      put tags in this scope, rather than in the enclosing class or
     676                 :            :      namespace scope.  This is the right thing, since we want
     677                 :            :      TEMPLATE_DECLS, and not TYPE_DECLS for template classes.  For a
     678                 :            :      global template class, push_template_decl handles putting the
     679                 :            :      TEMPLATE_DECL into top-level scope.  For a nested template class,
     680                 :            :      e.g.:
     681                 :            : 
     682                 :            :        template <class T> struct S1 {
     683                 :            :          template <class T> struct S2 {};
     684                 :            :        };
     685                 :            : 
     686                 :            :      pushtag contains special code to insert the TEMPLATE_DECL for S2
     687                 :            :      at the right scope.  */
     688                 :    7577710 :   begin_scope (sk_template_parms, NULL);
     689                 :    7577710 :   ++processing_template_decl;
     690                 :    7577710 :   ++processing_template_parmlist;
     691                 :    7577710 :   note_template_header (0);
     692                 :            : 
     693                 :            :   /* Add a dummy parameter level while we process the parameter list.  */
     694                 :   15155400 :   current_template_parms
     695                 :    7577710 :     = tree_cons (size_int (processing_template_decl),
     696                 :            :                  make_tree_vec (0),
     697                 :            :                  current_template_parms);
     698                 :    7577710 : }
     699                 :            : 
     700                 :            : /* This routine is called when a specialization is declared.  If it is
     701                 :            :    invalid to declare a specialization here, an error is reported and
     702                 :            :    false is returned, otherwise this routine will return true.  */
     703                 :            : 
     704                 :            : static bool
     705                 :     721932 : check_specialization_scope (void)
     706                 :            : {
     707                 :     721932 :   tree scope = current_scope ();
     708                 :            : 
     709                 :            :   /* [temp.expl.spec]
     710                 :            : 
     711                 :            :      An explicit specialization shall be declared in the namespace of
     712                 :            :      which the template is a member, or, for member templates, in the
     713                 :            :      namespace of which the enclosing class or enclosing class
     714                 :            :      template is a member.  An explicit specialization of a member
     715                 :            :      function, member class or static data member of a class template
     716                 :            :      shall be declared in the namespace of which the class template
     717                 :            :      is a member.  */
     718                 :     721932 :   if (scope && TREE_CODE (scope) != NAMESPACE_DECL)
     719                 :            :     {
     720                 :         32 :       error ("explicit specialization in non-namespace scope %qD", scope);
     721                 :         32 :       return false;
     722                 :            :     }
     723                 :            : 
     724                 :            :   /* [temp.expl.spec]
     725                 :            : 
     726                 :            :      In an explicit specialization declaration for a member of a class
     727                 :            :      template or a member template that appears in namespace scope,
     728                 :            :      the member template and some of its enclosing class templates may
     729                 :            :      remain unspecialized, except that the declaration shall not
     730                 :            :      explicitly specialize a class member template if its enclosing
     731                 :            :      class templates are not explicitly specialized as well.  */
     732                 :     721900 :   if (current_template_parms)
     733                 :            :     {
     734                 :          8 :       error ("enclosing class templates are not explicitly specialized");
     735                 :          8 :       return false;
     736                 :            :     }
     737                 :            : 
     738                 :            :   return true;
     739                 :            : }
     740                 :            : 
     741                 :            : /* We've just seen template <>.  */
     742                 :            : 
     743                 :            : bool
     744                 :     721932 : begin_specialization (void)
     745                 :            : {
     746                 :     721932 :   begin_scope (sk_template_spec, NULL);
     747                 :     721932 :   note_template_header (1);
     748                 :    1443860 :   return check_specialization_scope ();
     749                 :            : }
     750                 :            : 
     751                 :            : /* Called at then end of processing a declaration preceded by
     752                 :            :    template<>.  */
     753                 :            : 
     754                 :            : void
     755                 :     721932 : end_specialization (void)
     756                 :            : {
     757                 :     721932 :   finish_scope ();
     758                 :     721932 :   reset_specialization ();
     759                 :     721932 : }
     760                 :            : 
     761                 :            : /* Any template <>'s that we have seen thus far are not referring to a
     762                 :            :    function specialization.  */
     763                 :            : 
     764                 :            : void
     765                 :   16028900 : reset_specialization (void)
     766                 :            : {
     767                 :   16028900 :   processing_specialization = 0;
     768                 :   16028900 :   template_header_count = 0;
     769                 :   16028900 : }
     770                 :            : 
     771                 :            : /* We've just seen a template header.  If SPECIALIZATION is nonzero,
     772                 :            :    it was of the form template <>.  */
     773                 :            : 
     774                 :            : static void
     775                 :    8299640 : note_template_header (int specialization)
     776                 :            : {
     777                 :    8299640 :   processing_specialization = specialization;
     778                 :    8299640 :   template_header_count++;
     779                 :          0 : }
     780                 :            : 
     781                 :            : /* We're beginning an explicit instantiation.  */
     782                 :            : 
     783                 :            : void
     784                 :     195306 : begin_explicit_instantiation (void)
     785                 :            : {
     786                 :     195306 :   gcc_assert (!processing_explicit_instantiation);
     787                 :     195306 :   processing_explicit_instantiation = true;
     788                 :     195306 : }
     789                 :            : 
     790                 :            : 
     791                 :            : void
     792                 :     195302 : end_explicit_instantiation (void)
     793                 :            : {
     794                 :     195302 :   gcc_assert (processing_explicit_instantiation);
     795                 :     195302 :   processing_explicit_instantiation = false;
     796                 :     195302 : }
     797                 :            : 
     798                 :            : /* An explicit specialization or partial specialization of TMPL is being
     799                 :            :    declared.  Check that the namespace in which the specialization is
     800                 :            :    occurring is permissible.  Returns false iff it is invalid to
     801                 :            :    specialize TMPL in the current namespace.  */
     802                 :            : 
     803                 :            : static bool
     804                 :    1717270 : check_specialization_namespace (tree tmpl)
     805                 :            : {
     806                 :    1717270 :   tree tpl_ns = decl_namespace_context (tmpl);
     807                 :            : 
     808                 :            :   /* [tmpl.expl.spec]
     809                 :            : 
     810                 :            :      An explicit specialization shall be declared in a namespace enclosing the
     811                 :            :      specialized template. An explicit specialization whose declarator-id is
     812                 :            :      not qualified shall be declared in the nearest enclosing namespace of the
     813                 :            :      template, or, if the namespace is inline (7.3.1), any namespace from its
     814                 :            :      enclosing namespace set.  */
     815                 :    1717270 :   if (current_scope() != DECL_CONTEXT (tmpl)
     816                 :    1717270 :       && !at_namespace_scope_p ())
     817                 :            :     {
     818                 :         21 :       error ("specialization of %qD must appear at namespace scope", tmpl);
     819                 :         21 :       return false;
     820                 :            :     }
     821                 :            : 
     822                 :    1717250 :   if (is_nested_namespace (current_namespace, tpl_ns, cxx_dialect < cxx11))
     823                 :            :     /* Same or enclosing namespace.  */
     824                 :            :     return true;
     825                 :            :   else
     826                 :            :     {
     827                 :         13 :       auto_diagnostic_group d;
     828                 :         13 :       if (permerror (input_location,
     829                 :            :                      "specialization of %qD in different namespace", tmpl))
     830                 :          9 :         inform (DECL_SOURCE_LOCATION (tmpl),
     831                 :            :                 "  from definition of %q#D", tmpl);
     832                 :         13 :       return false;
     833                 :            :     }
     834                 :            : }
     835                 :            : 
     836                 :            : /* SPEC is an explicit instantiation.  Check that it is valid to
     837                 :            :    perform this explicit instantiation in the current namespace.  */
     838                 :            : 
     839                 :            : static void
     840                 :     193747 : check_explicit_instantiation_namespace (tree spec)
     841                 :            : {
     842                 :     193747 :   tree ns;
     843                 :            : 
     844                 :            :   /* DR 275: An explicit instantiation shall appear in an enclosing
     845                 :            :      namespace of its template.  */
     846                 :     193747 :   ns = decl_namespace_context (spec);
     847                 :     193747 :   if (!is_nested_namespace (current_namespace, ns))
     848                 :          8 :     permerror (input_location, "explicit instantiation of %qD in namespace %qD "
     849                 :            :                "(which does not enclose namespace %qD)",
     850                 :            :                spec, current_namespace, ns);
     851                 :     193747 : }
     852                 :            : 
     853                 :            : /* Returns the type of a template specialization only if that
     854                 :            :    specialization needs to be defined. Otherwise (e.g., if the type has
     855                 :            :    already been defined), the function returns NULL_TREE.  */
     856                 :            : 
     857                 :            : static tree
     858                 :    4900730 : maybe_new_partial_specialization (tree type)
     859                 :            : {
     860                 :            :   /* An implicit instantiation of an incomplete type implies
     861                 :            :      the definition of a new class template.
     862                 :            : 
     863                 :            :         template<typename T>
     864                 :            :           struct S;
     865                 :            : 
     866                 :            :         template<typename T>
     867                 :            :           struct S<T*>;
     868                 :            : 
     869                 :            :      Here, S<T*> is an implicit instantiation of S whose type
     870                 :            :      is incomplete.  */
     871                 :    4900730 :   if (CLASSTYPE_IMPLICIT_INSTANTIATION (type) && !COMPLETE_TYPE_P (type))
     872                 :            :     return type;
     873                 :            : 
     874                 :            :   /* It can also be the case that TYPE is a completed specialization.
     875                 :            :      Continuing the previous example, suppose we also declare:
     876                 :            : 
     877                 :            :         template<typename T>
     878                 :            :           requires Integral<T>
     879                 :            :             struct S<T*>;
     880                 :            : 
     881                 :            :      Here, S<T*> refers to the specialization S<T*> defined
     882                 :            :      above. However, we need to differentiate definitions because
     883                 :            :      we intend to define a new partial specialization. In this case,
     884                 :            :      we rely on the fact that the constraints are different for
     885                 :            :      this declaration than that above.
     886                 :            : 
     887                 :            :      Note that we also get here for injected class names and
     888                 :            :      late-parsed template definitions. We must ensure that we
     889                 :            :      do not create new type declarations for those cases.  */
     890                 :    3257480 :   if (flag_concepts && CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
     891                 :            :     {
     892                 :     812434 :       tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
     893                 :     812434 :       tree args = CLASSTYPE_TI_ARGS (type);
     894                 :            : 
     895                 :            :       /* If there are no template parameters, this cannot be a new
     896                 :            :          partial template specialization?  */
     897                 :     811706 :       if (!current_template_parms)
     898                 :            :         return NULL_TREE;
     899                 :            : 
     900                 :            :       /* The injected-class-name is not a new partial specialization.  */
     901                 :     515180 :       if (DECL_SELF_REFERENCE_P (TYPE_NAME (type)))
     902                 :            :         return NULL_TREE;
     903                 :            : 
     904                 :            :       /* If the constraints are not the same as those of the primary
     905                 :            :          then, we can probably create a new specialization.  */
     906                 :     515179 :       tree type_constr = current_template_constraints ();
     907                 :            : 
     908                 :     515179 :       if (type == TREE_TYPE (tmpl))
     909                 :            :         {
     910                 :         18 :           tree main_constr = get_constraints (tmpl);
     911                 :         18 :           if (equivalent_constraints (type_constr, main_constr))
     912                 :            :             return NULL_TREE;
     913                 :            :         }
     914                 :            : 
     915                 :            :       /* Also, if there's a pre-existing specialization with matching
     916                 :            :          constraints, then this also isn't new.  */
     917                 :     515161 :       tree specs = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
     918                 :     531072 :       while (specs)
     919                 :            :         {
     920                 :     523612 :           tree spec_tmpl = TREE_VALUE (specs);
     921                 :     523612 :           tree spec_args = TREE_PURPOSE (specs);
     922                 :     523612 :           tree spec_constr = get_constraints (spec_tmpl);
     923                 :     523612 :           if (comp_template_args (args, spec_args)
     924                 :     523612 :               && equivalent_constraints (type_constr, spec_constr))
     925                 :            :             return NULL_TREE;
     926                 :      15911 :           specs = TREE_CHAIN (specs);
     927                 :            :         }
     928                 :            : 
     929                 :            :       /* Create a new type node (and corresponding type decl)
     930                 :            :          for the newly declared specialization.  */
     931                 :       7460 :       tree t = make_class_type (TREE_CODE (type));
     932                 :       7460 :       CLASSTYPE_DECLARED_CLASS (t) = CLASSTYPE_DECLARED_CLASS (type);
     933                 :      22380 :       SET_TYPE_TEMPLATE_INFO (t, build_template_info (tmpl, args));
     934                 :            : 
     935                 :            :       /* We only need a separate type node for storing the definition of this
     936                 :            :          partial specialization; uses of S<T*> are unconstrained, so all are
     937                 :            :          equivalent.  So keep TYPE_CANONICAL the same.  */
     938                 :       7460 :       TYPE_CANONICAL (t) = TYPE_CANONICAL (type);
     939                 :            : 
     940                 :            :       /* Build the corresponding type decl.  */
     941                 :       7460 :       tree d = create_implicit_typedef (DECL_NAME (tmpl), t);
     942                 :       7460 :       DECL_CONTEXT (d) = TYPE_CONTEXT (t);
     943                 :       7460 :       DECL_SOURCE_LOCATION (d) = input_location;
     944                 :       7460 :       TREE_PRIVATE (d) = (current_access_specifier == access_private_node);
     945                 :       7460 :       TREE_PROTECTED (d) = (current_access_specifier == access_protected_node);
     946                 :            : 
     947                 :       7460 :       return t;
     948                 :            :     }
     949                 :            : 
     950                 :            :   return NULL_TREE;
     951                 :            : }
     952                 :            : 
     953                 :            : /* The TYPE is being declared.  If it is a template type, that means it
     954                 :            :    is a partial specialization.  Do appropriate error-checking.  */
     955                 :            : 
     956                 :            : tree
     957                 :   10010500 : maybe_process_partial_specialization (tree type)
     958                 :            : {
     959                 :   10010500 :   tree context;
     960                 :            : 
     961                 :   10010500 :   if (type == error_mark_node)
     962                 :            :     return error_mark_node;
     963                 :            : 
     964                 :            :   /* A lambda that appears in specialization context is not itself a
     965                 :            :      specialization.  */
     966                 :   19934500 :   if (CLASS_TYPE_P (type) && CLASSTYPE_LAMBDA_EXPR (type))
     967                 :            :     return type;
     968                 :            : 
     969                 :    9966750 :   if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
     970                 :            :     {
     971                 :          4 :       error ("name of class shadows template template parameter %qD",
     972                 :          4 :              TYPE_NAME (type));
     973                 :          4 :       return error_mark_node;
     974                 :            :     }
     975                 :            : 
     976                 :    9966740 :   context = TYPE_CONTEXT (type);
     977                 :            : 
     978                 :    9966740 :   if (TYPE_ALIAS_P (type))
     979                 :            :     {
     980                 :          6 :       tree tinfo = TYPE_ALIAS_TEMPLATE_INFO (type);
     981                 :            : 
     982                 :         12 :       if (tinfo && DECL_ALIAS_TEMPLATE_P (TI_TEMPLATE (tinfo)))
     983                 :          6 :         error ("specialization of alias template %qD",
     984                 :          6 :                TI_TEMPLATE (tinfo));
     985                 :            :       else
     986                 :          0 :         error ("explicit specialization of non-template %qT", type);
     987                 :          6 :       return error_mark_node;
     988                 :            :     }
     989                 :    9966740 :   else if (CLASS_TYPE_P (type) && CLASSTYPE_USE_TEMPLATE (type))
     990                 :            :     {
     991                 :            :       /* This is for ordinary explicit specialization and partial
     992                 :            :          specialization of a template class such as:
     993                 :            : 
     994                 :            :            template <> class C<int>;
     995                 :            : 
     996                 :            :          or:
     997                 :            : 
     998                 :            :            template <class T> class C<T*>;
     999                 :            : 
    1000                 :            :          Make sure that `C<int>' and `C<T*>' are implicit instantiations.  */
    1001                 :            : 
    1002                 :    4900730 :       if (tree t = maybe_new_partial_specialization (type))
    1003                 :            :         {
    1004                 :    1651410 :           if (!check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (t))
    1005                 :    1650710 :               && !at_namespace_scope_p ())
    1006                 :         21 :             return error_mark_node;
    1007                 :    1650690 :           SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (t);
    1008                 :    1650690 :           DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (t)) = input_location;
    1009                 :    1650690 :           if (processing_template_decl)
    1010                 :            :             {
    1011                 :    1006420 :               tree decl = push_template_decl (TYPE_MAIN_DECL (t));
    1012                 :    1006420 :               if (decl == error_mark_node)
    1013                 :            :                 return error_mark_node;
    1014                 :    1006350 :               return TREE_TYPE (decl);
    1015                 :            :             }
    1016                 :            :         }
    1017                 :    3250020 :       else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type))
    1018                 :          0 :         error ("specialization of %qT after instantiation", type);
    1019                 :       4926 :       else if (errorcount && !processing_specialization
    1020                 :       3746 :                 && CLASSTYPE_TEMPLATE_SPECIALIZATION (type)
    1021                 :    3253770 :                && !uses_template_parms (CLASSTYPE_TI_ARGS (type)))
    1022                 :            :         /* Trying to define a specialization either without a template<> header
    1023                 :            :            or in an inappropriate place.  We've already given an error, so just
    1024                 :            :            bail now so we don't actually define the specialization.  */
    1025                 :       1169 :         return error_mark_node;
    1026                 :            :     }
    1027                 :    4979580 :   else if (CLASS_TYPE_P (type)
    1028                 :    4979580 :            && !CLASSTYPE_USE_TEMPLATE (type)
    1029                 :    4979580 :            && CLASSTYPE_TEMPLATE_INFO (type)
    1030                 :    3735230 :            && context && CLASS_TYPE_P (context)
    1031                 :    5278470 :            && CLASSTYPE_TEMPLATE_INFO (context))
    1032                 :            :     {
    1033                 :            :       /* This is for an explicit specialization of member class
    1034                 :            :          template according to [temp.expl.spec/18]:
    1035                 :            : 
    1036                 :            :            template <> template <class U> class C<int>::D;
    1037                 :            : 
    1038                 :            :          The context `C<int>' must be an implicit instantiation.
    1039                 :            :          Otherwise this is just a member class template declared
    1040                 :            :          earlier like:
    1041                 :            : 
    1042                 :            :            template <> class C<int> { template <class U> class D; };
    1043                 :            :            template <> template <class U> class C<int>::D;
    1044                 :            : 
    1045                 :            :          In the first case, `C<int>::D' is a specialization of `C<T>::D'
    1046                 :            :          while in the second case, `C<int>::D' is a primary template
    1047                 :            :          and `C<T>::D' may not exist.  */
    1048                 :            : 
    1049                 :     181945 :       if (CLASSTYPE_IMPLICIT_INSTANTIATION (context)
    1050                 :     181945 :           && !COMPLETE_TYPE_P (type))
    1051                 :            :         {
    1052                 :         34 :           tree t;
    1053                 :         34 :           tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
    1054                 :            : 
    1055                 :         34 :           if (current_namespace
    1056                 :         34 :               != decl_namespace_context (tmpl))
    1057                 :            :             {
    1058                 :          0 :               if (permerror (input_location,
    1059                 :            :                              "specialization of %qD in different namespace",
    1060                 :            :                              type))
    1061                 :          0 :                 inform (DECL_SOURCE_LOCATION (tmpl),
    1062                 :            :                         "from definition of %q#D", tmpl);
    1063                 :            :             }
    1064                 :            : 
    1065                 :            :           /* Check for invalid specialization after instantiation:
    1066                 :            : 
    1067                 :            :                template <> template <> class C<int>::D<int>;
    1068                 :            :                template <> template <class U> class C<int>::D;  */
    1069                 :            : 
    1070                 :         49 :           for (t = DECL_TEMPLATE_INSTANTIATIONS (tmpl);
    1071                 :         49 :                t; t = TREE_CHAIN (t))
    1072                 :            :             {
    1073                 :         15 :               tree inst = TREE_VALUE (t);
    1074                 :         15 :               if (CLASSTYPE_TEMPLATE_SPECIALIZATION (inst)
    1075                 :         15 :                   || !COMPLETE_OR_OPEN_TYPE_P (inst))
    1076                 :            :                 {
    1077                 :            :                   /* We already have a full specialization of this partial
    1078                 :            :                      instantiation, or a full specialization has been
    1079                 :            :                      looked up but not instantiated.  Reassign it to the
    1080                 :            :                      new member specialization template.  */
    1081                 :         11 :                   spec_entry elt;
    1082                 :         11 :                   spec_entry *entry;
    1083                 :            : 
    1084                 :         11 :                   elt.tmpl = most_general_template (tmpl);
    1085                 :         11 :                   elt.args = CLASSTYPE_TI_ARGS (inst);
    1086                 :         11 :                   elt.spec = inst;
    1087                 :            : 
    1088                 :         11 :                   type_specializations->remove_elt (&elt);
    1089                 :            : 
    1090                 :         11 :                   elt.tmpl = tmpl;
    1091                 :         11 :                   CLASSTYPE_TI_ARGS (inst)
    1092                 :         11 :                     = elt.args = INNERMOST_TEMPLATE_ARGS (elt.args);
    1093                 :            : 
    1094                 :         11 :                   spec_entry **slot
    1095                 :         11 :                     = type_specializations->find_slot (&elt, INSERT);
    1096                 :         11 :                   entry = ggc_alloc<spec_entry> ();
    1097                 :         11 :                   *entry = elt;
    1098                 :         11 :                   *slot = entry;
    1099                 :            :                 }
    1100                 :            :               else
    1101                 :            :                 /* But if we've had an implicit instantiation, that's a
    1102                 :            :                    problem ([temp.expl.spec]/6).  */
    1103                 :          4 :                 error ("specialization %qT after instantiation %qT",
    1104                 :            :                        type, inst);
    1105                 :            :             }
    1106                 :            : 
    1107                 :            :           /* Mark TYPE as a specialization.  And as a result, we only
    1108                 :            :              have one level of template argument for the innermost
    1109                 :            :              class template.  */
    1110                 :         34 :           SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
    1111                 :         34 :           DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)) = input_location;
    1112                 :         68 :           CLASSTYPE_TI_ARGS (type)
    1113                 :         34 :             = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
    1114                 :            :         }
    1115                 :            :     }
    1116                 :    4884060 :   else if (processing_specialization)
    1117                 :            :     {
    1118                 :            :        /* Someday C++0x may allow for enum template specialization.  */
    1119                 :         18 :       if (cxx_dialect > cxx98 && TREE_CODE (type) == ENUMERAL_TYPE
    1120                 :         44 :           && CLASS_TYPE_P (context) && CLASSTYPE_USE_TEMPLATE (context))
    1121                 :          9 :         pedwarn (input_location, OPT_Wpedantic, "template specialization "
    1122                 :            :                  "of %qD not allowed by ISO C++", type);
    1123                 :            :       else
    1124                 :            :         {
    1125                 :         11 :           error ("explicit specialization of non-template %qT", type);
    1126                 :         11 :           return error_mark_node;
    1127                 :            :         }
    1128                 :            :     }
    1129                 :            : 
    1130                 :            :   return type;
    1131                 :            : }
    1132                 :            : 
    1133                 :            : /* Returns nonzero if we can optimize the retrieval of specializations
    1134                 :            :    for TMPL, a TEMPLATE_DECL.  In particular, for such a template, we
    1135                 :            :    do not use DECL_TEMPLATE_SPECIALIZATIONS at all.  */
    1136                 :            : 
    1137                 :            : static inline bool
    1138                 :  165755000 : optimize_specialization_lookup_p (tree tmpl)
    1139                 :            : {
    1140                 :  165755000 :   return (DECL_FUNCTION_TEMPLATE_P (tmpl)
    1141                 :   66789800 :           && DECL_CLASS_SCOPE_P (tmpl)
    1142                 :            :           /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
    1143                 :            :              parameter.  */
    1144                 :   48068900 :           && CLASS_TYPE_P (DECL_CONTEXT (tmpl))
    1145                 :            :           /* The optimized lookup depends on the fact that the
    1146                 :            :              template arguments for the member function template apply
    1147                 :            :              purely to the containing class, which is not true if the
    1148                 :            :              containing class is an explicit or partial
    1149                 :            :              specialization.  */
    1150                 :   48068900 :           && !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl))
    1151                 :   41021500 :           && !DECL_MEMBER_TEMPLATE_P (tmpl)
    1152                 :   27098300 :           && !DECL_CONV_FN_P (tmpl)
    1153                 :            :           /* It is possible to have a template that is not a member
    1154                 :            :              template and is not a member of a template class:
    1155                 :            : 
    1156                 :            :              template <typename T>
    1157                 :            :              struct S { friend A::f(); };
    1158                 :            : 
    1159                 :            :              Here, the friend function is a template, but the context does
    1160                 :            :              not have template information.  The optimized lookup relies
    1161                 :            :              on having ARGS be the template arguments for both the class
    1162                 :            :              and the function template.  */
    1163                 :  192737000 :           && !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl)));
    1164                 :            : }
    1165                 :            : 
    1166                 :            : /* Make sure ARGS doesn't use any inappropriate typedefs; we should have
    1167                 :            :    gone through coerce_template_parms by now.  */
    1168                 :            : 
    1169                 :            : static void
    1170                 :  122637000 : verify_unstripped_args_1 (tree inner)
    1171                 :            : {
    1172                 :  367019000 :   for (int i = 0; i < TREE_VEC_LENGTH (inner); ++i)
    1173                 :            :     {
    1174                 :  244382000 :       tree arg = TREE_VEC_ELT (inner, i);
    1175                 :  244382000 :       if (TREE_CODE (arg) == TEMPLATE_DECL)
    1176                 :            :         /* OK */;
    1177                 :  243343000 :       else if (TYPE_P (arg))
    1178                 :  229254000 :         gcc_assert (strip_typedefs (arg, NULL) == arg);
    1179                 :   14089000 :       else if (ARGUMENT_PACK_P (arg))
    1180                 :      25761 :         verify_unstripped_args_1 (ARGUMENT_PACK_ARGS (arg));
    1181                 :   14063300 :       else if (strip_typedefs (TREE_TYPE (arg), NULL) != TREE_TYPE (arg))
    1182                 :            :         /* Allow typedefs on the type of a non-type argument, since a
    1183                 :            :            parameter can have them.  */;
    1184                 :            :       else
    1185                 :   14063100 :         gcc_assert (strip_typedefs_expr (arg, NULL) == arg);
    1186                 :            :     }
    1187                 :  122637000 : }
    1188                 :            : 
    1189                 :            : static void
    1190                 :  131416000 : verify_unstripped_args (tree args)
    1191                 :            : {
    1192                 :  131416000 :   ++processing_template_decl;
    1193                 :  131416000 :   if (!any_dependent_template_arguments_p (args))
    1194                 :  122611000 :     verify_unstripped_args_1 (INNERMOST_TEMPLATE_ARGS (args));
    1195                 :  131416000 :   --processing_template_decl;
    1196                 :  131416000 : }
    1197                 :            : 
    1198                 :            : /* Retrieve the specialization (in the sense of [temp.spec] - a
    1199                 :            :    specialization is either an instantiation or an explicit
    1200                 :            :    specialization) of TMPL for the given template ARGS.  If there is
    1201                 :            :    no such specialization, return NULL_TREE.  The ARGS are a vector of
    1202                 :            :    arguments, or a vector of vectors of arguments, in the case of
    1203                 :            :    templates with more than one level of parameters.
    1204                 :            : 
    1205                 :            :    If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
    1206                 :            :    then we search for a partial specialization matching ARGS.  This
    1207                 :            :    parameter is ignored if TMPL is not a class template.
    1208                 :            : 
    1209                 :            :    We can also look up a FIELD_DECL, if it is a lambda capture pack; the
    1210                 :            :    result is a NONTYPE_ARGUMENT_PACK.  */
    1211                 :            : 
    1212                 :            : static tree
    1213                 :  131416000 : retrieve_specialization (tree tmpl, tree args, hashval_t hash)
    1214                 :            : {
    1215                 :  131416000 :   if (tmpl == NULL_TREE)
    1216                 :            :     return NULL_TREE;
    1217                 :            : 
    1218                 :  131416000 :   if (args == error_mark_node)
    1219                 :            :     return NULL_TREE;
    1220                 :            : 
    1221                 :  131416000 :   gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL
    1222                 :            :               || TREE_CODE (tmpl) == FIELD_DECL);
    1223                 :            : 
    1224                 :            :   /* There should be as many levels of arguments as there are
    1225                 :            :      levels of parameters.  */
    1226                 :  262833000 :   gcc_assert (TMPL_ARGS_DEPTH (args)
    1227                 :            :               == (TREE_CODE (tmpl) == TEMPLATE_DECL
    1228                 :            :                   ? TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl))
    1229                 :            :                   : template_class_depth (DECL_CONTEXT (tmpl))));
    1230                 :            : 
    1231                 :  131416000 :   if (flag_checking)
    1232                 :  131416000 :     verify_unstripped_args (args);
    1233                 :            : 
    1234                 :            :   /* Lambda functions in templates aren't instantiated normally, but through
    1235                 :            :      tsubst_lambda_expr.  */
    1236                 :  131416000 :   if (lambda_fn_in_template_p (tmpl))
    1237                 :            :     return NULL_TREE;
    1238                 :            : 
    1239                 :  131416000 :   if (optimize_specialization_lookup_p (tmpl))
    1240                 :            :     {
    1241                 :            :       /* The template arguments actually apply to the containing
    1242                 :            :          class.  Find the class specialization with those
    1243                 :            :          arguments.  */
    1244                 :   19958100 :       tree class_template = CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl));
    1245                 :   19957600 :       tree class_specialization
    1246                 :   19957600 :         = retrieve_specialization (class_template, args, 0);
    1247                 :   19957600 :       if (!class_specialization)
    1248                 :            :         return NULL_TREE;
    1249                 :            : 
    1250                 :            :       /* Find the instance of TMPL.  */
    1251                 :   19957600 :       tree fns = get_class_binding (class_specialization, DECL_NAME (tmpl));
    1252                 :   59627800 :       for (ovl_iterator iter (fns); iter; ++iter)
    1253                 :            :         {
    1254                 :   25830300 :           tree fn = *iter;
    1255                 :   25830300 :           if (tree ti = get_template_info (fn))
    1256                 :   25048900 :             if (TI_TEMPLATE (ti) == tmpl
    1257                 :            :                 /* using-declarations can bring in a different
    1258                 :            :                    instantiation of tmpl as a member of a different
    1259                 :            :                    instantiation of tmpl's class.  We don't want those
    1260                 :            :                    here.  */
    1261                 :   31044100 :                 && DECL_CONTEXT (fn) == class_specialization)
    1262                 :    5995230 :               return fn;
    1263                 :            :         }
    1264                 :   13962400 :       return NULL_TREE;
    1265                 :            :     }
    1266                 :            :   else
    1267                 :            :     {
    1268                 :  111459000 :       spec_entry *found;
    1269                 :  111459000 :       spec_entry elt;
    1270                 :  111459000 :       hash_table<spec_hasher> *specializations;
    1271                 :            : 
    1272                 :  111459000 :       elt.tmpl = tmpl;
    1273                 :  111459000 :       elt.args = args;
    1274                 :  111459000 :       elt.spec = NULL_TREE;
    1275                 :            : 
    1276                 :  111459000 :       if (DECL_CLASS_TEMPLATE_P (tmpl))
    1277                 :   20223400 :         specializations = type_specializations;
    1278                 :            :       else
    1279                 :   91235200 :         specializations = decl_specializations;
    1280                 :            : 
    1281                 :  111459000 :       if (hash == 0)
    1282                 :   71296100 :         hash = spec_hasher::hash (&elt);
    1283                 :  111459000 :       found = specializations->find_with_hash (&elt, hash);
    1284                 :  111459000 :       if (found)
    1285                 :   60684300 :         return found->spec;
    1286                 :            :     }
    1287                 :            : 
    1288                 :   50774300 :   return NULL_TREE;
    1289                 :            : }
    1290                 :            : 
    1291                 :            : /* Like retrieve_specialization, but for local declarations.  */
    1292                 :            : 
    1293                 :            : tree
    1294                 :   24689800 : retrieve_local_specialization (tree tmpl)
    1295                 :            : {
    1296                 :   24689800 :   if (local_specializations == NULL)
    1297                 :            :     return NULL_TREE;
    1298                 :            : 
    1299                 :   24139800 :   tree *slot = local_specializations->get (tmpl);
    1300                 :   21786800 :   return slot ? *slot : NULL_TREE;
    1301                 :            : }
    1302                 :            : 
    1303                 :            : /* Returns nonzero iff DECL is a specialization of TMPL.  */
    1304                 :            : 
    1305                 :            : int
    1306                 :     183961 : is_specialization_of (tree decl, tree tmpl)
    1307                 :            : {
    1308                 :     183961 :   tree t;
    1309                 :            : 
    1310                 :     183961 :   if (TREE_CODE (decl) == FUNCTION_DECL)
    1311                 :            :     {
    1312                 :      38015 :       for (t = decl;
    1313                 :      75446 :            t != NULL_TREE;
    1314                 :      38015 :            t = DECL_TEMPLATE_INFO (t) ? DECL_TI_TEMPLATE (t) : NULL_TREE)
    1315                 :      75446 :         if (t == tmpl)
    1316                 :            :           return 1;
    1317                 :            :     }
    1318                 :            :   else
    1319                 :            :     {
    1320                 :     146255 :       gcc_assert (TREE_CODE (decl) == TYPE_DECL);
    1321                 :            : 
    1322                 :     295656 :       for (t = TREE_TYPE (decl);
    1323                 :     286301 :            t != NULL_TREE;
    1324                 :     289447 :            t = CLASSTYPE_USE_TEMPLATE (t)
    1325                 :     289447 :              ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t)) : NULL_TREE)
    1326                 :     286301 :         if (same_type_ignoring_top_level_qualifiers_p (t, TREE_TYPE (tmpl)))
    1327                 :            :           return 1;
    1328                 :            :     }
    1329                 :            : 
    1330                 :            :   return 0;
    1331                 :            : }
    1332                 :            : 
    1333                 :            : /* Returns nonzero iff DECL is a specialization of friend declaration
    1334                 :            :    FRIEND_DECL according to [temp.friend].  */
    1335                 :            : 
    1336                 :            : bool
    1337                 :     195397 : is_specialization_of_friend (tree decl, tree friend_decl)
    1338                 :            : {
    1339                 :     195397 :   bool need_template = true;
    1340                 :     195397 :   int template_depth;
    1341                 :            : 
    1342                 :     195397 :   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
    1343                 :            :               || TREE_CODE (decl) == TYPE_DECL);
    1344                 :            : 
    1345                 :            :   /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
    1346                 :            :      of a template class, we want to check if DECL is a specialization
    1347                 :            :      if this.  */
    1348                 :     195397 :   if (TREE_CODE (friend_decl) == FUNCTION_DECL
    1349                 :      11735 :       && DECL_TEMPLATE_INFO (friend_decl)
    1350                 :     195536 :       && !DECL_USE_TEMPLATE (friend_decl))
    1351                 :            :     {
    1352                 :            :       /* We want a TEMPLATE_DECL for `is_specialization_of'.  */
    1353                 :        111 :       friend_decl = DECL_TI_TEMPLATE (friend_decl);
    1354                 :        111 :       need_template = false;
    1355                 :            :     }
    1356                 :     195286 :   else if (TREE_CODE (friend_decl) == TEMPLATE_DECL
    1357                 :     195286 :            && !PRIMARY_TEMPLATE_P (friend_decl))
    1358                 :            :     need_template = false;
    1359                 :            : 
    1360                 :            :   /* There is nothing to do if this is not a template friend.  */
    1361                 :     195397 :   if (TREE_CODE (friend_decl) != TEMPLATE_DECL)
    1362                 :            :     return false;
    1363                 :            : 
    1364                 :     183773 :   if (is_specialization_of (decl, friend_decl))
    1365                 :            :     return true;
    1366                 :            : 
    1367                 :            :   /* [temp.friend/6]
    1368                 :            :      A member of a class template may be declared to be a friend of a
    1369                 :            :      non-template class.  In this case, the corresponding member of
    1370                 :            :      every specialization of the class template is a friend of the
    1371                 :            :      class granting friendship.
    1372                 :            : 
    1373                 :            :      For example, given a template friend declaration
    1374                 :            : 
    1375                 :            :        template <class T> friend void A<T>::f();
    1376                 :            : 
    1377                 :            :      the member function below is considered a friend
    1378                 :            : 
    1379                 :            :        template <> struct A<int> {
    1380                 :            :          void f();
    1381                 :            :        };
    1382                 :            : 
    1383                 :            :      For this type of template friend, TEMPLATE_DEPTH below will be
    1384                 :            :      nonzero.  To determine if DECL is a friend of FRIEND, we first
    1385                 :            :      check if the enclosing class is a specialization of another.  */
    1386                 :            : 
    1387                 :       9626 :   template_depth = template_class_depth (CP_DECL_CONTEXT (friend_decl));
    1388                 :       9626 :   if (template_depth
    1389                 :        196 :       && DECL_CLASS_SCOPE_P (decl)
    1390                 :       9814 :       && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl)),
    1391                 :        188 :                                CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend_decl))))
    1392                 :            :     {
    1393                 :            :       /* Next, we check the members themselves.  In order to handle
    1394                 :            :          a few tricky cases, such as when FRIEND_DECL's are
    1395                 :            : 
    1396                 :            :            template <class T> friend void A<T>::g(T t);
    1397                 :            :            template <class T> template <T t> friend void A<T>::h();
    1398                 :            : 
    1399                 :            :          and DECL's are
    1400                 :            : 
    1401                 :            :            void A<int>::g(int);
    1402                 :            :            template <int> void A<int>::h();
    1403                 :            : 
    1404                 :            :          we need to figure out ARGS, the template arguments from
    1405                 :            :          the context of DECL.  This is required for template substitution
    1406                 :            :          of `T' in the function parameter of `g' and template parameter
    1407                 :            :          of `h' in the above examples.  Here ARGS corresponds to `int'.  */
    1408                 :            : 
    1409                 :        184 :       tree context = DECL_CONTEXT (decl);
    1410                 :        184 :       tree args = NULL_TREE;
    1411                 :        184 :       int current_depth = 0;
    1412                 :            : 
    1413                 :        368 :       while (current_depth < template_depth)
    1414                 :            :         {
    1415                 :        184 :           if (CLASSTYPE_TEMPLATE_INFO (context))
    1416                 :            :             {
    1417                 :        184 :               if (current_depth == 0)
    1418                 :        368 :                 args = TYPE_TI_ARGS (context);
    1419                 :            :               else
    1420                 :          0 :                 args = add_to_template_args (TYPE_TI_ARGS (context), args);
    1421                 :        184 :               current_depth++;
    1422                 :            :             }
    1423                 :        184 :           context = TYPE_CONTEXT (context);
    1424                 :            :         }
    1425                 :            : 
    1426                 :        184 :       if (TREE_CODE (decl) == FUNCTION_DECL)
    1427                 :            :         {
    1428                 :         96 :           bool is_template;
    1429                 :         96 :           tree friend_type;
    1430                 :         96 :           tree decl_type;
    1431                 :         96 :           tree friend_args_type;
    1432                 :         96 :           tree decl_args_type;
    1433                 :            : 
    1434                 :            :           /* Make sure that both DECL and FRIEND_DECL are templates or
    1435                 :            :              non-templates.  */
    1436                 :         96 :           is_template = DECL_TEMPLATE_INFO (decl)
    1437                 :         96 :                         && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl));
    1438                 :         96 :           if (need_template ^ is_template)
    1439                 :            :             return false;
    1440                 :         72 :           else if (is_template)
    1441                 :            :             {
    1442                 :            :               /* If both are templates, check template parameter list.  */
    1443                 :         36 :               tree friend_parms
    1444                 :         36 :                 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl),
    1445                 :            :                                          args, tf_none);
    1446                 :         36 :               if (!comp_template_parms
    1447                 :         36 :                      (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl)),
    1448                 :            :                       friend_parms))
    1449                 :            :                 return false;
    1450                 :            : 
    1451                 :         24 :               decl_type = TREE_TYPE (DECL_TI_TEMPLATE (decl));
    1452                 :            :             }
    1453                 :            :           else
    1454                 :         36 :             decl_type = TREE_TYPE (decl);
    1455                 :            : 
    1456                 :         60 :           friend_type = tsubst_function_type (TREE_TYPE (friend_decl), args,
    1457                 :            :                                               tf_none, NULL_TREE);
    1458                 :         60 :           if (friend_type == error_mark_node)
    1459                 :            :             return false;
    1460                 :            : 
    1461                 :            :           /* Check if return types match.  */
    1462                 :         60 :           if (!same_type_p (TREE_TYPE (decl_type), TREE_TYPE (friend_type)))
    1463                 :            :             return false;
    1464                 :            : 
    1465                 :            :           /* Check if function parameter types match, ignoring the
    1466                 :            :              `this' parameter.  */
    1467                 :         52 :           friend_args_type = TYPE_ARG_TYPES (friend_type);
    1468                 :         52 :           decl_args_type = TYPE_ARG_TYPES (decl_type);
    1469                 :         52 :           if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend_decl))
    1470                 :         52 :             friend_args_type = TREE_CHAIN (friend_args_type);
    1471                 :         52 :           if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
    1472                 :         52 :             decl_args_type = TREE_CHAIN (decl_args_type);
    1473                 :            : 
    1474                 :         52 :           return compparms (decl_args_type, friend_args_type);
    1475                 :            :         }
    1476                 :            :       else
    1477                 :            :         {
    1478                 :            :           /* DECL is a TYPE_DECL */
    1479                 :         88 :           bool is_template;
    1480                 :         88 :           tree decl_type = TREE_TYPE (decl);
    1481                 :            : 
    1482                 :            :           /* Make sure that both DECL and FRIEND_DECL are templates or
    1483                 :            :              non-templates.  */
    1484                 :         88 :           is_template
    1485                 :         88 :             = CLASSTYPE_TEMPLATE_INFO (decl_type)
    1486                 :        168 :               && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type));
    1487                 :            : 
    1488                 :         88 :           if (need_template ^ is_template)
    1489                 :            :             return false;
    1490                 :         88 :           else if (is_template)
    1491                 :            :             {
    1492                 :         68 :               tree friend_parms;
    1493                 :            :               /* If both are templates, check the name of the two
    1494                 :            :                  TEMPLATE_DECL's first because is_friend didn't.  */
    1495                 :         68 :               if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type))
    1496                 :         68 :                   != DECL_NAME (friend_decl))
    1497                 :            :                 return false;
    1498                 :            : 
    1499                 :            :               /* Now check template parameter list.  */
    1500                 :         64 :               friend_parms
    1501                 :         64 :                 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl),
    1502                 :            :                                          args, tf_none);
    1503                 :         64 :               return comp_template_parms
    1504                 :         64 :                 (DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type)),
    1505                 :         64 :                  friend_parms);
    1506                 :            :             }
    1507                 :            :           else
    1508                 :         20 :             return (DECL_NAME (decl)
    1509                 :         20 :                     == DECL_NAME (friend_decl));
    1510                 :            :         }
    1511                 :            :     }
    1512                 :            :   return false;
    1513                 :            : }
    1514                 :            : 
    1515                 :            : /* Register the specialization SPEC as a specialization of TMPL with
    1516                 :            :    the indicated ARGS.  IS_FRIEND indicates whether the specialization
    1517                 :            :    is actually just a friend declaration.  ATTRLIST is the list of
    1518                 :            :    attributes that the specialization is declared with or NULL when
    1519                 :            :    it isn't.  Returns SPEC, or an equivalent prior declaration, if
    1520                 :            :    available.
    1521                 :            : 
    1522                 :            :    We also store instantiations of field packs in the hash table, even
    1523                 :            :    though they are not themselves templates, to make lookup easier.  */
    1524                 :            : 
    1525                 :            : static tree
    1526                 :   36254700 : register_specialization (tree spec, tree tmpl, tree args, bool is_friend,
    1527                 :            :                          hashval_t hash)
    1528                 :            : {
    1529                 :   36254700 :   tree fn;
    1530                 :   36254700 :   spec_entry **slot = NULL;
    1531                 :   36254700 :   spec_entry elt;
    1532                 :            : 
    1533                 :   36254700 :   gcc_assert ((TREE_CODE (tmpl) == TEMPLATE_DECL && DECL_P (spec))
    1534                 :            :               || (TREE_CODE (tmpl) == FIELD_DECL
    1535                 :            :                   && TREE_CODE (spec) == NONTYPE_ARGUMENT_PACK));
    1536                 :            : 
    1537                 :   36254700 :   if (TREE_CODE (spec) == FUNCTION_DECL
    1538                 :   36254700 :       && uses_template_parms (DECL_TI_ARGS (spec)))
    1539                 :            :     /* This is the FUNCTION_DECL for a partial instantiation.  Don't
    1540                 :            :        register it; we want the corresponding TEMPLATE_DECL instead.
    1541                 :            :        We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
    1542                 :            :        the more obvious `uses_template_parms (spec)' to avoid problems
    1543                 :            :        with default function arguments.  In particular, given
    1544                 :            :        something like this:
    1545                 :            : 
    1546                 :            :           template <class T> void f(T t1, T t = T())
    1547                 :            : 
    1548                 :            :        the default argument expression is not substituted for in an
    1549                 :            :        instantiation unless and until it is actually needed.  */
    1550                 :            :     return spec;
    1551                 :            : 
    1552                 :   34338900 :   if (optimize_specialization_lookup_p (tmpl))
    1553                 :            :     /* We don't put these specializations in the hash table, but we might
    1554                 :            :        want to give an error about a mismatch.  */
    1555                 :    7023620 :     fn = retrieve_specialization (tmpl, args, 0);
    1556                 :            :   else
    1557                 :            :     {
    1558                 :   27315200 :       elt.tmpl = tmpl;
    1559                 :   27315200 :       elt.args = args;
    1560                 :   27315200 :       elt.spec = spec;
    1561                 :            : 
    1562                 :   27315200 :       if (hash == 0)
    1563                 :      25197 :         hash = spec_hasher::hash (&elt);
    1564                 :            : 
    1565                 :   27315200 :       slot =
    1566                 :   27315200 :         decl_specializations->find_slot_with_hash (&elt, hash, INSERT);
    1567                 :   27315200 :       if (*slot)
    1568                 :      15480 :         fn = ((spec_entry *) *slot)->spec;
    1569                 :            :       else
    1570                 :            :         fn = NULL_TREE;
    1571                 :            :     }
    1572                 :            : 
    1573                 :            :   /* We can sometimes try to re-register a specialization that we've
    1574                 :            :      already got.  In particular, regenerate_decl_from_template calls
    1575                 :            :      duplicate_decls which will update the specialization list.  But,
    1576                 :            :      we'll still get called again here anyhow.  It's more convenient
    1577                 :            :      to simply allow this than to try to prevent it.  */
    1578                 :   34338900 :   if (fn == spec)
    1579                 :            :     return spec;
    1580                 :   34395300 :   else if (fn && DECL_TEMPLATE_SPECIALIZATION (spec))
    1581                 :            :     {
    1582                 :      57118 :       if (DECL_TEMPLATE_INSTANTIATION (fn))
    1583                 :            :         {
    1584                 :     113740 :           if (DECL_ODR_USED (fn)
    1585                 :      56870 :               || DECL_EXPLICIT_INSTANTIATION (fn))
    1586                 :            :             {
    1587                 :          8 :               error ("specialization of %qD after instantiation",
    1588                 :            :                      fn);
    1589                 :          8 :               return error_mark_node;
    1590                 :            :             }
    1591                 :            :           else
    1592                 :            :             {
    1593                 :      56862 :               tree clone;
    1594                 :            :               /* This situation should occur only if the first
    1595                 :            :                  specialization is an implicit instantiation, the
    1596                 :            :                  second is an explicit specialization, and the
    1597                 :            :                  implicit instantiation has not yet been used.  That
    1598                 :            :                  situation can occur if we have implicitly
    1599                 :            :                  instantiated a member function and then specialized
    1600                 :            :                  it later.
    1601                 :            : 
    1602                 :            :                  We can also wind up here if a friend declaration that
    1603                 :            :                  looked like an instantiation turns out to be a
    1604                 :            :                  specialization:
    1605                 :            : 
    1606                 :            :                    template <class T> void foo(T);
    1607                 :            :                    class S { friend void foo<>(int) };
    1608                 :            :                    template <> void foo(int);
    1609                 :            : 
    1610                 :            :                  We transform the existing DECL in place so that any
    1611                 :            :                  pointers to it become pointers to the updated
    1612                 :            :                  declaration.
    1613                 :            : 
    1614                 :            :                  If there was a definition for the template, but not
    1615                 :            :                  for the specialization, we want this to look as if
    1616                 :            :                  there were no definition, and vice versa.  */
    1617                 :      56862 :               DECL_INITIAL (fn) = NULL_TREE;
    1618                 :      56862 :               duplicate_decls (spec, fn, is_friend);
    1619                 :            :               /* The call to duplicate_decls will have applied
    1620                 :            :                  [temp.expl.spec]:
    1621                 :            : 
    1622                 :            :                    An explicit specialization of a function template
    1623                 :            :                    is inline only if it is explicitly declared to be,
    1624                 :            :                    and independently of whether its function template
    1625                 :            :                    is.
    1626                 :            : 
    1627                 :            :                 to the primary function; now copy the inline bits to
    1628                 :            :                 the various clones.  */
    1629                 :     143893 :               FOR_EACH_CLONE (clone, fn)
    1630                 :            :                 {
    1631                 :      12929 :                   DECL_DECLARED_INLINE_P (clone)
    1632                 :      12929 :                     = DECL_DECLARED_INLINE_P (fn);
    1633                 :      12929 :                   DECL_SOURCE_LOCATION (clone)
    1634                 :      12929 :                     = DECL_SOURCE_LOCATION (fn);
    1635                 :      12929 :                   DECL_DELETED_FN (clone)
    1636                 :      38787 :                     = DECL_DELETED_FN (fn);
    1637                 :            :                 }
    1638                 :      56862 :               check_specialization_namespace (tmpl);
    1639                 :            : 
    1640                 :      56862 :               return fn;
    1641                 :            :             }
    1642                 :            :         }
    1643                 :        248 :       else if (DECL_TEMPLATE_SPECIALIZATION (fn))
    1644                 :            :         {
    1645                 :        248 :           tree dd = duplicate_decls (spec, fn, is_friend);
    1646                 :        248 :           if (dd == error_mark_node)
    1647                 :            :             /* We've already complained in duplicate_decls.  */
    1648                 :            :             return error_mark_node;
    1649                 :            : 
    1650                 :        226 :           if (dd == NULL_TREE && DECL_INITIAL (spec))
    1651                 :            :             /* Dup decl failed, but this is a new definition. Set the
    1652                 :            :                line number so any errors match this new
    1653                 :            :                definition.  */
    1654                 :          0 :             DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (spec);
    1655                 :            : 
    1656                 :        226 :           return fn;
    1657                 :            :         }
    1658                 :            :     }
    1659                 :   34281000 :   else if (fn)
    1660                 :         53 :     return duplicate_decls (spec, fn, is_friend);
    1661                 :            : 
    1662                 :            :   /* A specialization must be declared in the same namespace as the
    1663                 :            :      template it is specializing.  */
    1664                 :   34280900 :   if (DECL_P (spec) && DECL_TEMPLATE_SPECIALIZATION (spec)
    1665                 :   34290700 :       && !check_specialization_namespace (tmpl))
    1666                 :          0 :     DECL_CONTEXT (spec) = DECL_CONTEXT (tmpl);
    1667                 :            : 
    1668                 :   34280900 :   if (slot != NULL /* !optimize_specialization_lookup_p (tmpl) */)
    1669                 :            :     {
    1670                 :   27299800 :       spec_entry *entry = ggc_alloc<spec_entry> ();
    1671                 :   27299800 :       gcc_assert (tmpl && args && spec);
    1672                 :   27299800 :       *entry = elt;
    1673                 :   27299800 :       *slot = entry;
    1674                 :    5317810 :       if ((TREE_CODE (spec) == FUNCTION_DECL && DECL_NAMESPACE_SCOPE_P (spec)
    1675                 :    3083440 :            && PRIMARY_TEMPLATE_P (tmpl)
    1676                 :    2966060 :            && DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (tmpl)) == NULL_TREE)
    1677                 :   31925800 :           || variable_template_p (tmpl))
    1678                 :            :         /* If TMPL is a forward declaration of a template function, keep a list
    1679                 :            :            of all specializations in case we need to reassign them to a friend
    1680                 :            :            template later in tsubst_friend_function.
    1681                 :            : 
    1682                 :            :            Also keep a list of all variable template instantiations so that
    1683                 :            :            process_partial_specialization can check whether a later partial
    1684                 :            :            specialization would have used it.  */
    1685                 :    1856250 :         DECL_TEMPLATE_INSTANTIATIONS (tmpl)
    1686                 :     928127 :           = tree_cons (args, spec, DECL_TEMPLATE_INSTANTIATIONS (tmpl));
    1687                 :            :     }
    1688                 :            : 
    1689                 :            :   return spec;
    1690                 :            : }
    1691                 :            : 
    1692                 :            : /* Returns true iff two spec_entry nodes are equivalent.  */
    1693                 :            : 
    1694                 :            : int comparing_specializations;
    1695                 :            : 
    1696                 :            : bool
    1697                 :  590875000 : spec_hasher::equal (spec_entry *e1, spec_entry *e2)
    1698                 :            : {
    1699                 :  590875000 :   int equal;
    1700                 :            : 
    1701                 :  590875000 :   ++comparing_specializations;
    1702                 :  780467000 :   equal = (e1->tmpl == e2->tmpl
    1703                 :  590875000 :            && comp_template_args (e1->args, e2->args));
    1704                 :  189592000 :   if (equal && flag_concepts
    1705                 :            :       /* tmpl could be a FIELD_DECL for a capture pack.  */
    1706                 :   53739100 :       && TREE_CODE (e1->tmpl) == TEMPLATE_DECL
    1707                 :   53739100 :       && VAR_P (DECL_TEMPLATE_RESULT (e1->tmpl))
    1708                 :    2774910 :       && uses_template_parms (e1->args))
    1709                 :            :     {
    1710                 :            :       /* Partial specializations of a variable template can be distinguished by
    1711                 :            :          constraints.  */
    1712                 :         14 :       tree c1 = e1->spec ? get_constraints (e1->spec) : NULL_TREE;
    1713                 :         14 :       tree c2 = e2->spec ? get_constraints (e2->spec) : NULL_TREE;
    1714                 :         14 :       equal = equivalent_constraints (c1, c2);
    1715                 :            :     }
    1716                 :  590875000 :   --comparing_specializations;
    1717                 :            : 
    1718                 :  590875000 :   return equal;
    1719                 :            : }
    1720                 :            : 
    1721                 :            : /* Returns a hash for a template TMPL and template arguments ARGS.  */
    1722                 :            : 
    1723                 :            : static hashval_t
    1724                 :  297292000 : hash_tmpl_and_args (tree tmpl, tree args)
    1725                 :            : {
    1726                 :  297292000 :   hashval_t val = iterative_hash_object (DECL_UID (tmpl), 0);
    1727                 :  297292000 :   return iterative_hash_template_arg (args, val);
    1728                 :            : }
    1729                 :            : 
    1730                 :            : /* Returns a hash for a spec_entry node based on the TMPL and ARGS members,
    1731                 :            :    ignoring SPEC.  */
    1732                 :            : 
    1733                 :            : hashval_t
    1734                 :  258709000 : spec_hasher::hash (spec_entry *e)
    1735                 :            : {
    1736                 :  258709000 :   return hash_tmpl_and_args (e->tmpl, e->args);
    1737                 :            : }
    1738                 :            : 
    1739                 :            : /* Recursively calculate a hash value for a template argument ARG, for use
    1740                 :            :    in the hash tables of template specializations.  */
    1741                 :            : 
    1742                 :            : hashval_t
    1743                 : 1434590000 : iterative_hash_template_arg (tree arg, hashval_t val)
    1744                 :            : {
    1745                 : 1434590000 :   unsigned HOST_WIDE_INT i;
    1746                 : 1434590000 :   enum tree_code code;
    1747                 : 1434590000 :   char tclass;
    1748                 :            : 
    1749                 : 1434590000 :   if (arg == NULL_TREE)
    1750                 :    5010180 :     return iterative_hash_object (arg, val);
    1751                 :            : 
    1752                 : 1429580000 :   if (!TYPE_P (arg))
    1753                 :  568601000 :     STRIP_NOPS (arg);
    1754                 :            : 
    1755                 : 1429580000 :   if (TREE_CODE (arg) == ARGUMENT_PACK_SELECT)
    1756                 :          0 :     gcc_unreachable ();
    1757                 :            : 
    1758                 : 1429580000 :   code = TREE_CODE (arg);
    1759                 : 1429580000 :   tclass = TREE_CODE_CLASS (code);
    1760                 :            : 
    1761                 : 1429580000 :   val = iterative_hash_object (code, val);
    1762                 :            : 
    1763                 : 1429580000 :   switch (code)
    1764                 :            :     {
    1765                 :            :     case ERROR_MARK:
    1766                 :            :       return val;
    1767                 :            : 
    1768                 :   19330800 :     case IDENTIFIER_NODE:
    1769                 :   19330800 :       return iterative_hash_object (IDENTIFIER_HASH_VALUE (arg), val);
    1770                 :            : 
    1771                 :  460542000 :     case TREE_VEC:
    1772                 :  460542000 :       {
    1773                 :  460542000 :         int i, len = TREE_VEC_LENGTH (arg);
    1774                 : 1311410000 :         for (i = 0; i < len; ++i)
    1775                 :  850872000 :           val = iterative_hash_template_arg (TREE_VEC_ELT (arg, i), val);
    1776                 :            :         return val;
    1777                 :            :       }
    1778                 :            : 
    1779                 :    4058590 :     case TYPE_PACK_EXPANSION:
    1780                 :    4058590 :     case EXPR_PACK_EXPANSION:
    1781                 :    4058590 :       val = iterative_hash_template_arg (PACK_EXPANSION_PATTERN (arg), val);
    1782                 :    4058590 :       return iterative_hash_template_arg (PACK_EXPANSION_EXTRA_ARGS (arg), val);
    1783                 :            : 
    1784                 :   42031000 :     case TYPE_ARGUMENT_PACK:
    1785                 :   42031000 :     case NONTYPE_ARGUMENT_PACK:
    1786                 :   42031000 :       return iterative_hash_template_arg (ARGUMENT_PACK_ARGS (arg), val);
    1787                 :            : 
    1788                 :     807234 :     case TREE_LIST:
    1789                 :     807234 :       for (; arg; arg = TREE_CHAIN (arg))
    1790                 :     403621 :         val = iterative_hash_template_arg (TREE_VALUE (arg), val);
    1791                 :            :       return val;
    1792                 :            : 
    1793                 :         45 :     case OVERLOAD:
    1794                 :        135 :       for (lkp_iterator iter (arg); iter; ++iter)
    1795                 :         45 :         val = iterative_hash_template_arg (*iter, val);
    1796                 :         45 :       return val;
    1797                 :            : 
    1798                 :     540247 :     case CONSTRUCTOR:
    1799                 :     540247 :       {
    1800                 :     540247 :         tree field, value;
    1801                 :     540247 :         iterative_hash_template_arg (TREE_TYPE (arg), val);
    1802                 :     553709 :         FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg), i, field, value)
    1803                 :            :           {
    1804                 :       4887 :             val = iterative_hash_template_arg (field, val);
    1805                 :       4887 :             val = iterative_hash_template_arg (value, val);
    1806                 :            :           }
    1807                 :            :         return val;
    1808                 :            :       }
    1809                 :            : 
    1810                 :      68715 :     case PARM_DECL:
    1811                 :      68715 :       if (!DECL_ARTIFICIAL (arg))
    1812                 :            :         {
    1813                 :      67991 :           val = iterative_hash_object (DECL_PARM_INDEX (arg), val);
    1814                 :      67991 :           val = iterative_hash_object (DECL_PARM_LEVEL (arg), val);
    1815                 :            :         }
    1816                 :      68715 :       return iterative_hash_template_arg (TREE_TYPE (arg), val);
    1817                 :            : 
    1818                 :      30256 :     case TARGET_EXPR:
    1819                 :      30256 :       return iterative_hash_template_arg (TARGET_EXPR_INITIAL (arg), val);
    1820                 :            : 
    1821                 :       3143 :     case PTRMEM_CST:
    1822                 :       5127 :       val = iterative_hash_template_arg (PTRMEM_CST_CLASS (arg), val);
    1823                 :       3143 :       return iterative_hash_template_arg (PTRMEM_CST_MEMBER (arg), val);
    1824                 :            : 
    1825                 :    2796860 :     case TEMPLATE_PARM_INDEX:
    1826                 :    2796860 :       val = iterative_hash_template_arg
    1827                 :    2796860 :         (TREE_TYPE (TEMPLATE_PARM_DECL (arg)), val);
    1828                 :    2796860 :       val = iterative_hash_object (TEMPLATE_PARM_LEVEL (arg), val);
    1829                 :    2796860 :       return iterative_hash_object (TEMPLATE_PARM_IDX (arg), val);
    1830                 :            : 
    1831                 :    1174120 :     case TRAIT_EXPR:
    1832                 :    1174120 :       val = iterative_hash_object (TRAIT_EXPR_KIND (arg), val);
    1833                 :    1174120 :       val = iterative_hash_template_arg (TRAIT_EXPR_TYPE1 (arg), val);
    1834                 :    1174120 :       return iterative_hash_template_arg (TRAIT_EXPR_TYPE2 (arg), val);
    1835                 :            : 
    1836                 :     600992 :     case BASELINK:
    1837                 :     600992 :       val = iterative_hash_template_arg (BINFO_TYPE (BASELINK_BINFO (arg)),
    1838                 :            :                                          val);
    1839                 :     600992 :       return iterative_hash_template_arg (DECL_NAME (get_first_fn (arg)),
    1840                 :     600992 :                                           val);
    1841                 :            : 
    1842                 :      15514 :     case MODOP_EXPR:
    1843                 :      15514 :       val = iterative_hash_template_arg (TREE_OPERAND (arg, 0), val);
    1844                 :      15514 :       code = TREE_CODE (TREE_OPERAND (arg, 1));
    1845                 :      15514 :       val = iterative_hash_object (code, val);
    1846                 :      15514 :       return iterative_hash_template_arg (TREE_OPERAND (arg, 2), val);
    1847                 :            : 
    1848                 :          4 :     case LAMBDA_EXPR:
    1849                 :            :       /* [temp.over.link] Two lambda-expressions are never considered
    1850                 :            :          equivalent.
    1851                 :            : 
    1852                 :            :          So just hash the closure type.  */
    1853                 :          4 :       return iterative_hash_template_arg (TREE_TYPE (arg), val);
    1854                 :            : 
    1855                 :     416581 :     case CAST_EXPR:
    1856                 :     416581 :     case IMPLICIT_CONV_EXPR:
    1857                 :     416581 :     case STATIC_CAST_EXPR:
    1858                 :     416581 :     case REINTERPRET_CAST_EXPR:
    1859                 :     416581 :     case CONST_CAST_EXPR:
    1860                 :     416581 :     case DYNAMIC_CAST_EXPR:
    1861                 :     416581 :     case NEW_EXPR:
    1862                 :     416581 :       val = iterative_hash_template_arg (TREE_TYPE (arg), val);
    1863                 :            :       /* Now hash operands as usual.  */
    1864                 :     416581 :       break;
    1865                 :            : 
    1866                 :   15731800 :     case CALL_EXPR:
    1867                 :   15731800 :       {
    1868                 :   15731800 :         tree fn = CALL_EXPR_FN (arg);
    1869                 :   15731800 :         if (tree name = dependent_name (fn))
    1870                 :            :           {
    1871                 :   13736600 :             if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
    1872                 :    7655080 :               val = iterative_hash_template_arg (TREE_OPERAND (fn, 1), val);
    1873                 :            :             fn = name;
    1874                 :            :           }
    1875                 :   15731800 :         val = iterative_hash_template_arg (fn, val);
    1876                 :   15731800 :         call_expr_arg_iterator ai;
    1877                 :   22599700 :         for (tree x = first_call_expr_arg (arg, &ai); x;
    1878                 :    6867880 :              x = next_call_expr_arg (&ai))
    1879                 :    6867880 :           val = iterative_hash_template_arg (x, val);
    1880                 :   15731800 :         return val;
    1881                 :            :       }
    1882                 :            : 
    1883                 :            :     default:
    1884                 :            :       break;
    1885                 :            :     }
    1886                 :            : 
    1887                 :  882248000 :   switch (tclass)
    1888                 :            :     {
    1889                 :  815444000 :     case tcc_type:
    1890                 :  815444000 :       if (tree ats = alias_template_specialization_p (arg, nt_transparent))
    1891                 :            :         {
    1892                 :            :           // We want an alias specialization that survived strip_typedefs
    1893                 :            :           // to hash differently from its TYPE_CANONICAL, to avoid hash
    1894                 :            :           // collisions that compare as different in template_args_equal.
    1895                 :            :           // These could be dependent specializations that strip_typedefs
    1896                 :            :           // left alone, or untouched specializations because
    1897                 :            :           // coerce_template_parms returns the unconverted template
    1898                 :            :           // arguments if it sees incomplete argument packs.
    1899                 :     984368 :           tree ti = TYPE_ALIAS_TEMPLATE_INFO (ats);
    1900                 :     984368 :           return hash_tmpl_and_args (TI_TEMPLATE (ti), TI_ARGS (ti));
    1901                 :            :         }
    1902                 :  814460000 :       if (TYPE_CANONICAL (arg))
    1903                 :  736571000 :         return iterative_hash_object (TYPE_HASH (TYPE_CANONICAL (arg)),
    1904                 :            :                                       val);
    1905                 :   77888200 :       else if (TREE_CODE (arg) == DECLTYPE_TYPE)
    1906                 :    6468900 :         return iterative_hash_template_arg (DECLTYPE_TYPE_EXPR (arg), val);
    1907                 :            :       /* Otherwise just compare the types during lookup.  */
    1908                 :            :       return val;
    1909                 :            : 
    1910                 :   57035500 :     case tcc_declaration:
    1911                 :   57035500 :     case tcc_constant:
    1912                 :   57035500 :       return iterative_hash_expr (arg, val);
    1913                 :            : 
    1914                 :    9768400 :     default:
    1915                 :    9768400 :       gcc_assert (IS_EXPR_CODE_CLASS (tclass));
    1916                 :    9768400 :       {
    1917                 :    9768400 :         unsigned n = cp_tree_operand_length (arg);
    1918                 :   27313800 :         for (i = 0; i < n; ++i)
    1919                 :   17545400 :           val = iterative_hash_template_arg (TREE_OPERAND (arg, i), val);
    1920                 :            :         return val;
    1921                 :            :       }
    1922                 :            :     }
    1923                 :            :   gcc_unreachable ();
    1924                 :            :   return 0;
    1925                 :            : }
    1926                 :            : 
    1927                 :            : /* Unregister the specialization SPEC as a specialization of TMPL.
    1928                 :            :    Replace it with NEW_SPEC, if NEW_SPEC is non-NULL.  Returns true
    1929                 :            :    if the SPEC was listed as a specialization of TMPL.
    1930                 :            : 
    1931                 :            :    Note that SPEC has been ggc_freed, so we can't look inside it.  */
    1932                 :            : 
    1933                 :            : bool
    1934                 :      57200 : reregister_specialization (tree spec, tree tinfo, tree new_spec)
    1935                 :            : {
    1936                 :      57200 :   spec_entry *entry;
    1937                 :      57200 :   spec_entry elt;
    1938                 :            : 
    1939                 :      57200 :   elt.tmpl = most_general_template (TI_TEMPLATE (tinfo));
    1940                 :      57200 :   elt.args = TI_ARGS (tinfo);
    1941                 :      57200 :   elt.spec = NULL_TREE;
    1942                 :            : 
    1943                 :      57200 :   entry = decl_specializations->find (&elt);
    1944                 :      57200 :   if (entry != NULL)
    1945                 :            :     {
    1946                 :      14756 :       gcc_assert (entry->spec == spec || entry->spec == new_spec);
    1947                 :      14756 :       gcc_assert (new_spec != NULL_TREE);
    1948                 :      14756 :       entry->spec = new_spec;
    1949                 :      14756 :       return 1;
    1950                 :            :     }
    1951                 :            : 
    1952                 :            :   return 0;
    1953                 :            : }
    1954                 :            : 
    1955                 :            : /* Like register_specialization, but for local declarations.  We are
    1956                 :            :    registering SPEC, an instantiation of TMPL.  */
    1957                 :            : 
    1958                 :            : void
    1959                 :   16180400 : register_local_specialization (tree spec, tree tmpl)
    1960                 :            : {
    1961                 :   16180400 :   gcc_assert (tmpl != spec);
    1962                 :   16180400 :   local_specializations->put (tmpl, spec);
    1963                 :   16180400 : }
    1964                 :            : 
    1965                 :            : /* TYPE is a class type.  Returns true if TYPE is an explicitly
    1966                 :            :    specialized class.  */
    1967                 :            : 
    1968                 :            : bool
    1969                 :    1158860 : explicit_class_specialization_p (tree type)
    1970                 :            : {
    1971                 :    1158860 :   if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
    1972                 :            :     return false;
    1973                 :      62179 :   return !uses_template_parms (CLASSTYPE_TI_ARGS (type));
    1974                 :            : }
    1975                 :            : 
    1976                 :            : /* Print the list of functions at FNS, going through all the overloads
    1977                 :            :    for each element of the list.  Alternatively, FNS cannot be a
    1978                 :            :    TREE_LIST, in which case it will be printed together with all the
    1979                 :            :    overloads.
    1980                 :            : 
    1981                 :            :    MORE and *STR should respectively be FALSE and NULL when the function
    1982                 :            :    is called from the outside.  They are used internally on recursive
    1983                 :            :    calls.  print_candidates manages the two parameters and leaves NULL
    1984                 :            :    in *STR when it ends.  */
    1985                 :            : 
    1986                 :            : static void
    1987                 :        797 : print_candidates_1 (tree fns, char **str, bool more = false)
    1988                 :            : {
    1989                 :        797 :   if (TREE_CODE (fns) == TREE_LIST)
    1990                 :        422 :     for (; fns; fns = TREE_CHAIN (fns))
    1991                 :        714 :       print_candidates_1 (TREE_VALUE (fns), str, more || TREE_CHAIN (fns));
    1992                 :            :   else
    1993                 :       2305 :     for (lkp_iterator iter (fns); iter;)
    1994                 :            :       {
    1995                 :        987 :         tree cand = *iter;
    1996                 :        987 :         ++iter;
    1997                 :            : 
    1998                 :        987 :         const char *pfx = *str;
    1999                 :        987 :         if (!pfx)
    2000                 :            :           {
    2001                 :        513 :             if (more || iter)
    2002                 :        272 :               pfx = _("candidates are:");
    2003                 :            :             else
    2004                 :        241 :               pfx = _("candidate is:");
    2005                 :        513 :             *str = get_spaces (pfx);
    2006                 :            :           }
    2007                 :        987 :         inform (DECL_SOURCE_LOCATION (cand), "%s %#qD", pfx, cand);
    2008                 :            :       }
    2009                 :        797 : }
    2010                 :            : 
    2011                 :            : /* Print the list of candidate FNS in an error message.  FNS can also
    2012                 :            :    be a TREE_LIST of non-functions in the case of an ambiguous lookup.  */
    2013                 :            : 
    2014                 :            : void
    2015                 :        513 : print_candidates (tree fns)
    2016                 :            : {
    2017                 :        513 :   char *str = NULL;
    2018                 :        513 :   print_candidates_1 (fns, &str);
    2019                 :        513 :   free (str);
    2020                 :        513 : }
    2021                 :            : 
    2022                 :            : /* Get a (possibly) constrained template declaration for the
    2023                 :            :    purpose of ordering candidates.  */
    2024                 :            : static tree
    2025                 :         16 : get_template_for_ordering (tree list)
    2026                 :            : {
    2027                 :         16 :   gcc_assert (TREE_CODE (list) == TREE_LIST);
    2028                 :         16 :   tree f = TREE_VALUE (list);
    2029                 :         16 :   if (tree ti = DECL_TEMPLATE_INFO (f))
    2030                 :         16 :     return TI_TEMPLATE (ti);
    2031                 :            :   return f;
    2032                 :            : }
    2033                 :            : 
    2034                 :            : /* Among candidates having the same signature, return the
    2035                 :            :    most constrained or NULL_TREE if there is no best candidate.
    2036                 :            :    If the signatures of candidates vary (e.g., template
    2037                 :            :    specialization vs. member function), then there can be no
    2038                 :            :    most constrained.
    2039                 :            : 
    2040                 :            :    Note that we don't compare constraints on the functions
    2041                 :            :    themselves, but rather those of their templates. */
    2042                 :            : static tree
    2043                 :          4 : most_constrained_function (tree candidates)
    2044                 :            : {
    2045                 :            :   // Try to find the best candidate in a first pass.
    2046                 :          4 :   tree champ = candidates;
    2047                 :          8 :   for (tree c = TREE_CHAIN (champ); c; c = TREE_CHAIN (c))
    2048                 :            :     {
    2049                 :          4 :       int winner = more_constrained (get_template_for_ordering (champ),
    2050                 :            :                                      get_template_for_ordering (c));
    2051                 :          4 :       if (winner == -1)
    2052                 :            :         champ = c; // The candidate is more constrained
    2053                 :          0 :       else if (winner == 0)
    2054                 :            :         return NULL_TREE; // Neither is more constrained
    2055                 :            :     }
    2056                 :            : 
    2057                 :            :   // Verify that the champ is better than previous candidates.
    2058                 :          8 :   for (tree c = candidates; c != champ; c = TREE_CHAIN (c)) {
    2059                 :          4 :     if (!more_constrained (get_template_for_ordering (champ),
    2060                 :            :                            get_template_for_ordering (c)))
    2061                 :            :       return NULL_TREE;
    2062                 :            :   }
    2063                 :            : 
    2064                 :            :   return champ;
    2065                 :            : }
    2066                 :            : 
    2067                 :            : 
    2068                 :            : /* Returns the template (one of the functions given by TEMPLATE_ID)
    2069                 :            :    which can be specialized to match the indicated DECL with the
    2070                 :            :    explicit template args given in TEMPLATE_ID.  The DECL may be
    2071                 :            :    NULL_TREE if none is available.  In that case, the functions in
    2072                 :            :    TEMPLATE_ID are non-members.
    2073                 :            : 
    2074                 :            :    If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
    2075                 :            :    specialization of a member template.
    2076                 :            : 
    2077                 :            :    The TEMPLATE_COUNT is the number of references to qualifying
    2078                 :            :    template classes that appeared in the name of the function. See
    2079                 :            :    check_explicit_specialization for a more accurate description.
    2080                 :            : 
    2081                 :            :    TSK indicates what kind of template declaration (if any) is being
    2082                 :            :    declared.  TSK_TEMPLATE indicates that the declaration given by
    2083                 :            :    DECL, though a FUNCTION_DECL, has template parameters, and is
    2084                 :            :    therefore a template function.
    2085                 :            : 
    2086                 :            :    The template args (those explicitly specified and those deduced)
    2087                 :            :    are output in a newly created vector *TARGS_OUT.
    2088                 :            : 
    2089                 :            :    If it is impossible to determine the result, an error message is
    2090                 :            :    issued.  The error_mark_node is returned to indicate failure.  */
    2091                 :            : 
    2092                 :            : static tree
    2093                 :     206197 : determine_specialization (tree template_id,
    2094                 :            :                           tree decl,
    2095                 :            :                           tree* targs_out,
    2096                 :            :                           int need_member_template,
    2097                 :            :                           int template_count,
    2098                 :            :                           tmpl_spec_kind tsk)
    2099                 :            : {
    2100                 :     206197 :   tree fns;
    2101                 :     206197 :   tree targs;
    2102                 :     206197 :   tree explicit_targs;
    2103                 :     206197 :   tree candidates = NULL_TREE;
    2104                 :            : 
    2105                 :            :   /* A TREE_LIST of templates of which DECL may be a specialization.
    2106                 :            :      The TREE_VALUE of each node is a TEMPLATE_DECL.  The
    2107                 :            :      corresponding TREE_PURPOSE is the set of template arguments that,
    2108                 :            :      when used to instantiate the template, would produce a function
    2109                 :            :      with the signature of DECL.  */
    2110                 :     206197 :   tree templates = NULL_TREE;
    2111                 :     206197 :   int header_count;
    2112                 :     206197 :   cp_binding_level *b;
    2113                 :            : 
    2114                 :     206197 :   *targs_out = NULL_TREE;
    2115                 :            : 
    2116                 :     206197 :   if (template_id == error_mark_node || decl == error_mark_node)
    2117                 :            :     return error_mark_node;
    2118                 :            : 
    2119                 :            :   /* We shouldn't be specializing a member template of an
    2120                 :            :      unspecialized class template; we already gave an error in
    2121                 :            :      check_specialization_scope, now avoid crashing.  */
    2122                 :     206193 :   if (!VAR_P (decl)
    2123                 :     278007 :       && template_count && DECL_CLASS_SCOPE_P (decl)
    2124                 :     284563 :       && template_class_depth (DECL_CONTEXT (decl)) > 0)
    2125                 :            :     {
    2126                 :          4 :       gcc_assert (errorcount);
    2127                 :          4 :       return error_mark_node;
    2128                 :            :     }
    2129                 :            : 
    2130                 :     206189 :   fns = TREE_OPERAND (template_id, 0);
    2131                 :     206189 :   explicit_targs = TREE_OPERAND (template_id, 1);
    2132                 :            : 
    2133                 :     206189 :   if (fns == error_mark_node)
    2134                 :            :     return error_mark_node;
    2135                 :            : 
    2136                 :            :   /* Check for baselinks.  */
    2137                 :     206189 :   if (BASELINK_P (fns))
    2138                 :          0 :     fns = BASELINK_FUNCTIONS (fns);
    2139                 :            : 
    2140                 :     206189 :   if (TREE_CODE (decl) == FUNCTION_DECL && !is_overloaded_fn (fns))
    2141                 :            :     {
    2142                 :          8 :       error_at (DECL_SOURCE_LOCATION (decl),
    2143                 :            :                 "%qD is not a function template", fns);
    2144                 :          8 :       return error_mark_node;
    2145                 :            :     }
    2146                 :     206181 :   else if (VAR_P (decl) && !variable_template_p (fns))
    2147                 :            :     {
    2148                 :          4 :       error ("%qD is not a variable template", fns);
    2149                 :          4 :       return error_mark_node;
    2150                 :            :     }
    2151                 :            : 
    2152                 :            :   /* Count the number of template headers specified for this
    2153                 :            :      specialization.  */
    2154                 :     206177 :   header_count = 0;
    2155                 :     206177 :   for (b = current_binding_level;
    2156                 :     274705 :        b->kind == sk_template_parms;
    2157                 :      68528 :        b = b->level_chain)
    2158                 :      68528 :     ++header_count;
    2159                 :            : 
    2160                 :     206177 :   tree orig_fns = fns;
    2161                 :            : 
    2162                 :     206177 :   if (variable_template_p (fns))
    2163                 :            :     {
    2164                 :       9710 :       tree parms = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (fns));
    2165                 :       9710 :       targs = coerce_template_parms (parms, explicit_targs, fns,
    2166                 :            :                                      tf_warning_or_error,
    2167                 :            :                                      /*req_all*/true, /*use_defarg*/true);
    2168                 :       9710 :       if (targs != error_mark_node)
    2169                 :       9710 :         templates = tree_cons (targs, fns, templates);
    2170                 :            :     }
    2171                 :     930579 :   else for (lkp_iterator iter (fns); iter; ++iter)
    2172                 :            :     {
    2173                 :     537645 :       tree fn = *iter;
    2174                 :            : 
    2175                 :     537645 :       if (TREE_CODE (fn) == TEMPLATE_DECL)
    2176                 :            :         {
    2177                 :     484016 :           tree decl_arg_types;
    2178                 :     484016 :           tree fn_arg_types;
    2179                 :     484016 :           tree insttype;
    2180                 :            : 
    2181                 :            :           /* In case of explicit specialization, we need to check if
    2182                 :            :              the number of template headers appearing in the specialization
    2183                 :            :              is correct. This is usually done in check_explicit_specialization,
    2184                 :            :              but the check done there cannot be exhaustive when specializing
    2185                 :            :              member functions. Consider the following code:
    2186                 :            : 
    2187                 :            :              template <> void A<int>::f(int);
    2188                 :            :              template <> template <> void A<int>::f(int);
    2189                 :            : 
    2190                 :            :              Assuming that A<int> is not itself an explicit specialization
    2191                 :            :              already, the first line specializes "f" which is a non-template
    2192                 :            :              member function, whilst the second line specializes "f" which
    2193                 :            :              is a template member function. So both lines are syntactically
    2194                 :            :              correct, and check_explicit_specialization does not reject
    2195                 :            :              them.
    2196                 :            : 
    2197                 :            :              Here, we can do better, as we are matching the specialization
    2198                 :            :              against the declarations. We count the number of template
    2199                 :            :              headers, and we check if they match TEMPLATE_COUNT + 1
    2200                 :            :              (TEMPLATE_COUNT is the number of qualifying template classes,
    2201                 :            :              plus there must be another header for the member template
    2202                 :            :              itself).
    2203                 :            : 
    2204                 :            :              Notice that if header_count is zero, this is not a
    2205                 :            :              specialization but rather a template instantiation, so there
    2206                 :            :              is no check we can perform here.  */
    2207                 :     484016 :           if (header_count && header_count != template_count + 1)
    2208                 :          8 :             continue;
    2209                 :            : 
    2210                 :            :           /* Check that the number of template arguments at the
    2211                 :            :              innermost level for DECL is the same as for FN.  */
    2212                 :     484008 :           if (current_binding_level->kind == sk_template_parms
    2213                 :     484008 :               && !current_binding_level->explicit_spec_p
    2214                 :     484008 :               && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn))
    2215                 :        765 :                   != TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
    2216                 :            :                                       (current_template_parms))))
    2217                 :          4 :             continue;
    2218                 :            : 
    2219                 :            :           /* DECL might be a specialization of FN.  */
    2220                 :     484004 :           decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
    2221                 :     484004 :           fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
    2222                 :            : 
    2223                 :            :           /* For a non-static member function, we need to make sure
    2224                 :            :              that the const qualification is the same.  Since
    2225                 :            :              get_bindings does not try to merge the "this" parameter,
    2226                 :            :              we must do the comparison explicitly.  */
    2227                 :     484004 :           if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
    2228                 :            :             {
    2229                 :      35247 :               if (!same_type_p (TREE_VALUE (fn_arg_types),
    2230                 :            :                                 TREE_VALUE (decl_arg_types)))
    2231                 :          8 :                 continue;
    2232                 :            : 
    2233                 :            :               /* And the ref-qualification.  */
    2234                 :      70478 :               if (type_memfn_rqual (TREE_TYPE (decl))
    2235                 :      35239 :                   != type_memfn_rqual (TREE_TYPE (fn)))
    2236                 :          6 :                 continue;
    2237                 :            :             }
    2238                 :            : 
    2239                 :            :           /* Skip the "this" parameter and, for constructors of
    2240                 :            :              classes with virtual bases, the VTT parameter.  A
    2241                 :            :              full specialization of a constructor will have a VTT
    2242                 :            :              parameter, but a template never will.  */
    2243                 :     483990 :           decl_arg_types
    2244                 :     483990 :             = skip_artificial_parms_for (decl, decl_arg_types);
    2245                 :     483990 :           fn_arg_types
    2246                 :     483990 :             = skip_artificial_parms_for (fn, fn_arg_types);
    2247                 :            : 
    2248                 :            :           /* Function templates cannot be specializations; there are
    2249                 :            :              no partial specializations of functions.  Therefore, if
    2250                 :            :              the type of DECL does not match FN, there is no
    2251                 :            :              match.
    2252                 :            : 
    2253                 :            :              Note that it should never be the case that we have both
    2254                 :            :              candidates added here, and for regular member functions
    2255                 :            :              below. */
    2256                 :     483990 :           if (tsk == tsk_template)
    2257                 :            :             {
    2258                 :        761 :               if (compparms (fn_arg_types, decl_arg_types))
    2259                 :        757 :                 candidates = tree_cons (NULL_TREE, fn, candidates);
    2260                 :        761 :               continue;
    2261                 :            :             }
    2262                 :            : 
    2263                 :            :           /* See whether this function might be a specialization of this
    2264                 :            :              template.  Suppress access control because we might be trying
    2265                 :            :              to make this specialization a friend, and we have already done
    2266                 :            :              access control for the declaration of the specialization.  */
    2267                 :     483229 :           push_deferring_access_checks (dk_no_check);
    2268                 :     483229 :           targs = get_bindings (fn, decl, explicit_targs, /*check_ret=*/true);
    2269                 :     483229 :           pop_deferring_access_checks ();
    2270                 :            : 
    2271                 :     483229 :           if (!targs)
    2272                 :            :             /* We cannot deduce template arguments that when used to
    2273                 :            :                specialize TMPL will produce DECL.  */
    2274                 :     326697 :             continue;
    2275                 :            : 
    2276                 :     156532 :           if (uses_template_parms (targs))
    2277                 :            :             /* We deduced something involving 'auto', which isn't a valid
    2278                 :            :                template argument.  */
    2279                 :          3 :             continue;
    2280                 :            : 
    2281                 :            :           /* Remove, from the set of candidates, all those functions
    2282                 :            :              whose constraints are not satisfied. */
    2283                 :     156529 :           if (flag_concepts && !constraints_satisfied_p (fn, targs))
    2284                 :          7 :             continue;
    2285                 :            : 
    2286                 :            :           // Then, try to form the new function type.
    2287                 :     156522 :           insttype = tsubst (TREE_TYPE (fn), targs, tf_fndecl_type, NULL_TREE);
    2288                 :     156522 :           if (insttype == error_mark_node)
    2289                 :          0 :             continue;
    2290                 :     156522 :           fn_arg_types
    2291                 :     156522 :             = skip_artificial_parms_for (fn, TYPE_ARG_TYPES (insttype));
    2292                 :     156522 :           if (!compparms (fn_arg_types, decl_arg_types))
    2293                 :         12 :             continue;
    2294                 :            : 
    2295                 :            :           /* Save this template, and the arguments deduced.  */
    2296                 :     156510 :           templates = tree_cons (targs, fn, templates);
    2297                 :            :         }
    2298                 :      53629 :       else if (need_member_template)
    2299                 :            :         /* FN is an ordinary member function, and we need a
    2300                 :            :            specialization of a member template.  */
    2301                 :            :         ;
    2302                 :      53569 :       else if (TREE_CODE (fn) != FUNCTION_DECL)
    2303                 :            :         /* We can get IDENTIFIER_NODEs here in certain erroneous
    2304                 :            :            cases.  */
    2305                 :            :         ;
    2306                 :      53569 :       else if (!DECL_FUNCTION_MEMBER_P (fn))
    2307                 :            :         /* This is just an ordinary non-member function.  Nothing can
    2308                 :            :            be a specialization of that.  */
    2309                 :            :         ;
    2310                 :      53321 :       else if (DECL_ARTIFICIAL (fn))
    2311                 :            :         /* Cannot specialize functions that are created implicitly.  */
    2312                 :            :         ;
    2313                 :            :       else
    2314                 :            :         {
    2315                 :      53170 :           tree decl_arg_types;
    2316                 :            : 
    2317                 :            :           /* This is an ordinary member function.  However, since
    2318                 :            :              we're here, we can assume its enclosing class is a
    2319                 :            :              template class.  For example,
    2320                 :            : 
    2321                 :            :                template <typename T> struct S { void f(); };
    2322                 :            :                template <> void S<int>::f() {}
    2323                 :            : 
    2324                 :            :              Here, S<int>::f is a non-template, but S<int> is a
    2325                 :            :              template class.  If FN has the same type as DECL, we
    2326                 :            :              might be in business.  */
    2327                 :            : 
    2328                 :      53170 :           if (!DECL_TEMPLATE_INFO (fn))
    2329                 :            :             /* Its enclosing class is an explicit specialization
    2330                 :            :                of a template class.  This is not a candidate.  */
    2331                 :          8 :             continue;
    2332                 :            : 
    2333                 :      53162 :           if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
    2334                 :            :                             TREE_TYPE (TREE_TYPE (fn))))
    2335                 :            :             /* The return types differ.  */
    2336                 :        290 :             continue;
    2337                 :            : 
    2338                 :            :           /* Adjust the type of DECL in case FN is a static member.  */
    2339                 :      52872 :           decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
    2340                 :     105744 :           if (DECL_STATIC_FUNCTION_P (fn)
    2341                 :      52872 :               && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
    2342                 :         90 :             decl_arg_types = TREE_CHAIN (decl_arg_types);
    2343                 :            : 
    2344                 :     105634 :           if (!compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
    2345                 :            :                          decl_arg_types))
    2346                 :      10132 :             continue;
    2347                 :            : 
    2348                 :      42740 :           if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
    2349                 :     128040 :               && (type_memfn_rqual (TREE_TYPE (decl))
    2350                 :      42650 :                   != type_memfn_rqual (TREE_TYPE (fn))))
    2351                 :          6 :             continue;
    2352                 :            : 
    2353                 :            :           // If the deduced arguments do not satisfy the constraints,
    2354                 :            :           // this is not a candidate.
    2355                 :      42734 :           if (flag_concepts && !constraints_satisfied_p (fn))
    2356                 :          7 :             continue;
    2357                 :            : 
    2358                 :            :           // Add the candidate.
    2359                 :      42727 :           candidates = tree_cons (NULL_TREE, fn, candidates);
    2360                 :            :         }
    2361                 :            :     }
    2362                 :            : 
    2363                 :     368659 :   if (templates && TREE_CHAIN (templates))
    2364                 :            :     {
    2365                 :            :       /* We have:
    2366                 :            : 
    2367                 :            :            [temp.expl.spec]
    2368                 :            : 
    2369                 :            :            It is possible for a specialization with a given function
    2370                 :            :            signature to be instantiated from more than one function
    2371                 :            :            template.  In such cases, explicit specification of the
    2372                 :            :            template arguments must be used to uniquely identify the
    2373                 :            :            function template specialization being specialized.
    2374                 :            : 
    2375                 :            :          Note that here, there's no suggestion that we're supposed to
    2376                 :            :          determine which of the candidate templates is most
    2377                 :            :          specialized.  However, we, also have:
    2378                 :            : 
    2379                 :            :            [temp.func.order]
    2380                 :            : 
    2381                 :            :            Partial ordering of overloaded function template
    2382                 :            :            declarations is used in the following contexts to select
    2383                 :            :            the function template to which a function template
    2384                 :            :            specialization refers:
    2385                 :            : 
    2386                 :            :            -- when an explicit specialization refers to a function
    2387                 :            :               template.
    2388                 :            : 
    2389                 :            :          So, we do use the partial ordering rules, at least for now.
    2390                 :            :          This extension can only serve to make invalid programs valid,
    2391                 :            :          so it's safe.  And, there is strong anecdotal evidence that
    2392                 :            :          the committee intended the partial ordering rules to apply;
    2393                 :            :          the EDG front end has that behavior, and John Spicer claims
    2394                 :            :          that the committee simply forgot to delete the wording in
    2395                 :            :          [temp.expl.spec].  */
    2396                 :       1896 :       tree tmpl = most_specialized_instantiation (templates);
    2397                 :       1896 :       if (tmpl != error_mark_node)
    2398                 :            :         {
    2399                 :       1892 :           templates = tmpl;
    2400                 :       1892 :           TREE_CHAIN (templates) = NULL_TREE;
    2401                 :            :         }
    2402                 :            :     }
    2403                 :            : 
    2404                 :            :   // Concepts allows multiple declarations of member functions
    2405                 :            :   // with the same signature. Like above, we need to rely on
    2406                 :            :   // on the partial ordering of those candidates to determine which
    2407                 :            :   // is the best.
    2408                 :     210595 :   if (flag_concepts && candidates && TREE_CHAIN (candidates))
    2409                 :            :     {
    2410                 :          4 :       if (tree cand = most_constrained_function (candidates))
    2411                 :            :         {
    2412                 :          4 :           candidates = cand;
    2413                 :          4 :           TREE_CHAIN (cand) = NULL_TREE;
    2414                 :            :         }
    2415                 :            :     }
    2416                 :            : 
    2417                 :     206177 :   if (templates == NULL_TREE && candidates == NULL_TREE)
    2418                 :            :     {
    2419                 :        215 :       error ("template-id %qD for %q+D does not match any template "
    2420                 :            :              "declaration", template_id, decl);
    2421                 :        215 :       if (header_count && header_count != template_count + 1)
    2422                 :          5 :         inform (DECL_SOURCE_LOCATION (decl),
    2423                 :            :                 "saw %d %<template<>%>, need %d for "
    2424                 :            :                 "specializing a member function template",
    2425                 :            :                 header_count, template_count + 1);
    2426                 :            :       else
    2427                 :        210 :         print_candidates (orig_fns);
    2428                 :        215 :       return error_mark_node;
    2429                 :            :     }
    2430                 :     162482 :   else if ((templates && TREE_CHAIN (templates))
    2431                 :     249438 :            || (candidates && TREE_CHAIN (candidates))
    2432                 :     411920 :            || (templates && candidates))
    2433                 :            :     {
    2434                 :          4 :       error ("ambiguous template specialization %qD for %q+D",
    2435                 :            :              template_id, decl);
    2436                 :          4 :       candidates = chainon (candidates, templates);
    2437                 :          4 :       print_candidates (candidates);
    2438                 :          4 :       return error_mark_node;
    2439                 :            :     }
    2440                 :            : 
    2441                 :            :   /* We have one, and exactly one, match.  */
    2442                 :     205958 :   if (candidates)
    2443                 :            :     {
    2444                 :      43480 :       tree fn = TREE_VALUE (candidates);
    2445                 :      43480 :       *targs_out = copy_node (DECL_TI_ARGS (fn));
    2446                 :            : 
    2447                 :            :       /* Propagate the candidate's constraints to the declaration.  */
    2448                 :      43480 :       set_constraints (decl, get_constraints (fn));
    2449                 :            : 
    2450                 :            :       /* DECL is a re-declaration or partial instantiation of a template
    2451                 :            :          function.  */
    2452                 :      43480 :       if (TREE_CODE (fn) == TEMPLATE_DECL)
    2453                 :            :         return fn;
    2454                 :            :       /* It was a specialization of an ordinary member function in a
    2455                 :            :          template class.  */
    2456                 :      42723 :       return DECL_TI_TEMPLATE (fn);
    2457                 :            :     }
    2458                 :            : 
    2459                 :            :   /* It was a specialization of a template.  */
    2460                 :     162478 :   targs = DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates)));
    2461                 :     324956 :   if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs))
    2462                 :            :     {
    2463                 :      37596 :       *targs_out = copy_node (targs);
    2464                 :      37596 :       SET_TMPL_ARGS_LEVEL (*targs_out,
    2465                 :            :                            TMPL_ARGS_DEPTH (*targs_out),
    2466                 :            :                            TREE_PURPOSE (templates));
    2467                 :            :     }
    2468                 :            :   else
    2469                 :     124882 :     *targs_out = TREE_PURPOSE (templates);
    2470                 :     162478 :   return TREE_VALUE (templates);
    2471                 :            : }
    2472                 :            : 
    2473                 :            : /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
    2474                 :            :    but with the default argument values filled in from those in the
    2475                 :            :    TMPL_TYPES.  */
    2476                 :            : 
    2477                 :            : static tree
    2478                 :      12594 : copy_default_args_to_explicit_spec_1 (tree spec_types,
    2479                 :            :                                       tree tmpl_types)
    2480                 :            : {
    2481                 :      12594 :   tree new_spec_types;
    2482                 :            : 
    2483                 :      12594 :   if (!spec_types)
    2484                 :            :     return NULL_TREE;
    2485                 :            : 
    2486                 :      12594 :   if (spec_types == void_list_node)
    2487                 :            :     return void_list_node;
    2488                 :            : 
    2489                 :            :   /* Substitute into the rest of the list.  */
    2490                 :       7303 :   new_spec_types =
    2491                 :       7303 :     copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types),
    2492                 :       7303 :                                           TREE_CHAIN (tmpl_types));
    2493                 :            : 
    2494                 :            :   /* Add the default argument for this parameter.  */
    2495                 :      14606 :   return hash_tree_cons (TREE_PURPOSE (tmpl_types),
    2496                 :       7303 :                          TREE_VALUE (spec_types),
    2497                 :       7303 :                          new_spec_types);
    2498                 :            : }
    2499                 :            : 
    2500                 :            : /* DECL is an explicit specialization.  Replicate default arguments
    2501                 :            :    from the template it specializes.  (That way, code like:
    2502                 :            : 
    2503                 :            :      template <class T> void f(T = 3);
    2504                 :            :      template <> void f(double);
    2505                 :            :      void g () { f (); }
    2506                 :            : 
    2507                 :            :    works, as required.)  An alternative approach would be to look up
    2508                 :            :    the correct default arguments at the call-site, but this approach
    2509                 :            :    is consistent with how implicit instantiations are handled.  */
    2510                 :            : 
    2511                 :            : static void
    2512                 :      57155 : copy_default_args_to_explicit_spec (tree decl)
    2513                 :            : {
    2514                 :      57155 :   tree tmpl;
    2515                 :      57155 :   tree spec_types;
    2516                 :      57155 :   tree tmpl_types;
    2517                 :      57155 :   tree new_spec_types;
    2518                 :      57155 :   tree old_type;
    2519                 :      57155 :   tree new_type;
    2520                 :      57155 :   tree t;
    2521                 :      57155 :   tree object_type = NULL_TREE;
    2522                 :      57155 :   tree in_charge = NULL_TREE;
    2523                 :      57155 :   tree vtt = NULL_TREE;
    2524                 :            : 
    2525                 :            :   /* See if there's anything we need to do.  */
    2526                 :      57155 :   tmpl = DECL_TI_TEMPLATE (decl);
    2527                 :      57155 :   tmpl_types = TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl)));
    2528                 :     239607 :   for (t = tmpl_types; t; t = TREE_CHAIN (t))
    2529                 :     187743 :     if (TREE_PURPOSE (t))
    2530                 :            :       break;
    2531                 :      57155 :   if (!t)
    2532                 :            :     return;
    2533                 :            : 
    2534                 :       5291 :   old_type = TREE_TYPE (decl);
    2535                 :       5291 :   spec_types = TYPE_ARG_TYPES (old_type);
    2536                 :            : 
    2537                 :       5291 :   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
    2538                 :            :     {
    2539                 :            :       /* Remove the this pointer, but remember the object's type for
    2540                 :            :          CV quals.  */
    2541                 :       5291 :       object_type = TREE_TYPE (TREE_VALUE (spec_types));
    2542                 :       5291 :       spec_types = TREE_CHAIN (spec_types);
    2543                 :       5291 :       tmpl_types = TREE_CHAIN (tmpl_types);
    2544                 :            : 
    2545                 :      10582 :       if (DECL_HAS_IN_CHARGE_PARM_P (decl))
    2546                 :            :         {
    2547                 :            :           /* DECL may contain more parameters than TMPL due to the extra
    2548                 :            :              in-charge parameter in constructors and destructors.  */
    2549                 :          0 :           in_charge = spec_types;
    2550                 :          0 :           spec_types = TREE_CHAIN (spec_types);
    2551                 :            :         }
    2552                 :       5291 :       if (DECL_HAS_VTT_PARM_P (decl))
    2553                 :            :         {
    2554                 :          0 :           vtt = spec_types;
    2555                 :          0 :           spec_types = TREE_CHAIN (spec_types);
    2556                 :            :         }
    2557                 :            :     }
    2558                 :            : 
    2559                 :            :   /* Compute the merged default arguments.  */
    2560                 :       5291 :   new_spec_types =
    2561                 :       5291 :     copy_default_args_to_explicit_spec_1 (spec_types, tmpl_types);
    2562                 :            : 
    2563                 :            :   /* Compute the new FUNCTION_TYPE.  */
    2564                 :       5291 :   if (object_type)
    2565                 :            :     {
    2566                 :       5291 :       if (vtt)
    2567                 :          0 :         new_spec_types = hash_tree_cons (TREE_PURPOSE (vtt),
    2568                 :          0 :                                          TREE_VALUE (vtt),
    2569                 :            :                                          new_spec_types);
    2570                 :            : 
    2571                 :       5291 :       if (in_charge)
    2572                 :            :         /* Put the in-charge parameter back.  */
    2573                 :          0 :         new_spec_types = hash_tree_cons (TREE_PURPOSE (in_charge),
    2574                 :          0 :                                          TREE_VALUE (in_charge),
    2575                 :            :                                          new_spec_types);
    2576                 :            : 
    2577                 :       5291 :       new_type = build_method_type_directly (object_type,
    2578                 :       5291 :                                              TREE_TYPE (old_type),
    2579                 :            :                                              new_spec_types);
    2580                 :            :     }
    2581                 :            :   else
    2582                 :          0 :     new_type = build_function_type (TREE_TYPE (old_type),
    2583                 :            :                                     new_spec_types);
    2584                 :       5291 :   new_type = cp_build_type_attribute_variant (new_type,
    2585                 :       5291 :                                               TYPE_ATTRIBUTES (old_type));
    2586                 :       5291 :   new_type = cxx_copy_lang_qualifiers (new_type, old_type);
    2587                 :            : 
    2588                 :       5291 :   TREE_TYPE (decl) = new_type;
    2589                 :            : }
    2590                 :            : 
    2591                 :            : /* Return the number of template headers we expect to see for a definition
    2592                 :            :    or specialization of CTYPE or one of its non-template members.  */
    2593                 :            : 
    2594                 :            : int
    2595                 :    1506080 : num_template_headers_for_class (tree ctype)
    2596                 :            : {
    2597                 :    1506080 :   int num_templates = 0;
    2598                 :            : 
    2599                 :    3917670 :   while (ctype && CLASS_TYPE_P (ctype))
    2600                 :            :     {
    2601                 :            :       /* You're supposed to have one `template <...>' for every
    2602                 :            :          template class, but you don't need one for a full
    2603                 :            :          specialization.  For example:
    2604                 :            : 
    2605                 :            :          template <class T> struct S{};
    2606                 :            :          template <> struct S<int> { void f(); };
    2607                 :            :          void S<int>::f () {}
    2608                 :            : 
    2609                 :            :          is correct; there shouldn't be a `template <>' for the
    2610                 :            :          definition of `S<int>::f'.  */
    2611                 :    1265780 :       if (!CLASSTYPE_TEMPLATE_INFO (ctype))
    2612                 :            :         /* If CTYPE does not have template information of any
    2613                 :            :            kind,  then it is not a template, nor is it nested
    2614                 :            :            within a template.  */
    2615                 :            :         break;
    2616                 :    1158860 :       if (explicit_class_specialization_p (ctype))
    2617                 :            :         break;
    2618                 :    1145810 :       if (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (ctype)))
    2619                 :    1135140 :         ++num_templates;
    2620                 :            : 
    2621                 :    1145810 :       ctype = TYPE_CONTEXT (ctype);
    2622                 :            :     }
    2623                 :            : 
    2624                 :    1506080 :   return num_templates;
    2625                 :            : }
    2626                 :            : 
    2627                 :            : /* Do a simple sanity check on the template headers that precede the
    2628                 :            :    variable declaration DECL.  */
    2629                 :            : 
    2630                 :            : void
    2631                 :     323756 : check_template_variable (tree decl)
    2632                 :            : {
    2633                 :     323756 :   tree ctx = CP_DECL_CONTEXT (decl);
    2634                 :     323756 :   int wanted = num_template_headers_for_class (ctx);
    2635                 :     647508 :   if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)
    2636                 :     647496 :       && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl)))
    2637                 :            :     {
    2638                 :     253194 :       if (cxx_dialect < cxx14)
    2639                 :          7 :         pedwarn (DECL_SOURCE_LOCATION (decl), 0,
    2640                 :            :                  "variable templates only available with "
    2641                 :            :                  "%<-std=c++14%> or %<-std=gnu++14%>");
    2642                 :            : 
    2643                 :            :       // Namespace-scope variable templates should have a template header.
    2644                 :     253194 :       ++wanted;
    2645                 :            :     }
    2646                 :     323756 :   if (template_header_count > wanted)
    2647                 :            :     {
    2648                 :         32 :       auto_diagnostic_group d;
    2649                 :         16 :       bool warned = pedwarn (DECL_SOURCE_LOCATION (decl), 0,
    2650                 :            :                              "too many template headers for %qD "
    2651                 :            :                              "(should be %d)",
    2652                 :            :                              decl, wanted);
    2653                 :         28 :       if (warned && CLASS_TYPE_P (ctx)
    2654                 :         28 :           && CLASSTYPE_TEMPLATE_SPECIALIZATION (ctx))
    2655                 :          4 :         inform (DECL_SOURCE_LOCATION (decl),
    2656                 :            :                 "members of an explicitly specialized class are defined "
    2657                 :            :                 "without a template header");
    2658                 :            :     }
    2659                 :     323756 : }
    2660                 :            : 
    2661                 :            : /* An explicit specialization whose declarator-id or class-head-name is not
    2662                 :            :    qualified shall be declared in the nearest enclosing namespace of the
    2663                 :            :    template, or, if the namespace is inline (7.3.1), any namespace from its
    2664                 :            :    enclosing namespace set.
    2665                 :            : 
    2666                 :            :    If the name declared in the explicit instantiation is an unqualified name,
    2667                 :            :    the explicit instantiation shall appear in the namespace where its template
    2668                 :            :    is declared or, if that namespace is inline (7.3.1), any namespace from its
    2669                 :            :    enclosing namespace set.  */
    2670                 :            : 
    2671                 :            : void
    2672                 :    1843940 : check_unqualified_spec_or_inst (tree t, location_t loc)
    2673                 :            : {
    2674                 :    1843940 :   tree tmpl = most_general_template (t);
    2675                 :    3687890 :   if (DECL_NAMESPACE_SCOPE_P (tmpl)
    2676                 :    3637470 :       && !is_nested_namespace (current_namespace,
    2677                 :    1793520 :                                CP_DECL_CONTEXT (tmpl), true))
    2678                 :            :     {
    2679                 :         21 :       if (processing_specialization)
    2680                 :          8 :         permerror (loc, "explicit specialization of %qD outside its "
    2681                 :            :                    "namespace must use a nested-name-specifier", tmpl);
    2682                 :         13 :       else if (processing_explicit_instantiation
    2683                 :         13 :                && cxx_dialect >= cxx11)
    2684                 :            :         /* This was allowed in C++98, so only pedwarn.  */
    2685                 :         11 :         pedwarn (loc, OPT_Wpedantic, "explicit instantiation of %qD "
    2686                 :            :                  "outside its namespace must use a nested-name-"
    2687                 :            :                  "specifier", tmpl);
    2688                 :            :     }
    2689                 :    1843940 : }
    2690                 :            : 
    2691                 :            : /* Warn for a template specialization SPEC that is missing some of a set
    2692                 :            :    of function or type attributes that the template TEMPL is declared with.
    2693                 :            :    ATTRLIST is a list of additional attributes that SPEC should be taken
    2694                 :            :    to ultimately be declared with.  */
    2695                 :            : 
    2696                 :            : static void
    2697                 :      59610 : warn_spec_missing_attributes (tree tmpl, tree spec, tree attrlist)
    2698                 :            : {
    2699                 :      59610 :   if (DECL_FUNCTION_TEMPLATE_P (tmpl))
    2700                 :      59610 :     tmpl = DECL_TEMPLATE_RESULT (tmpl);
    2701                 :            : 
    2702                 :            :   /* Avoid warning if the difference between the primary and
    2703                 :            :      the specialization is not in one of the attributes below.  */
    2704                 :      59610 :   const char* const blacklist[] = {
    2705                 :            :     "alloc_align", "alloc_size", "assume_aligned", "format",
    2706                 :            :     "format_arg", "malloc", "nonnull", NULL
    2707                 :            :   };
    2708                 :            : 
    2709                 :            :   /* Put together a list of the black listed attributes that the primary
    2710                 :            :      template is declared with that the specialization is not, in case
    2711                 :            :      it's not apparent from the most recent declaration of the primary.  */
    2712                 :      59646 :   pretty_printer str;
    2713                 :      59610 :   unsigned nattrs = decls_mismatched_attributes (tmpl, spec, attrlist,
    2714                 :            :                                                  blacklist, &str);
    2715                 :            : 
    2716                 :      59610 :   if (!nattrs)
    2717                 :      59574 :     return;
    2718                 :            : 
    2719                 :         72 :   auto_diagnostic_group d;
    2720                 :         36 :   if (warning_at (DECL_SOURCE_LOCATION (spec), OPT_Wmissing_attributes,
    2721                 :            :                   "explicit specialization %q#D may be missing attributes",
    2722                 :            :                   spec))
    2723                 :         72 :     inform (DECL_SOURCE_LOCATION (tmpl),
    2724                 :            :             nattrs > 1
    2725                 :            :             ? G_("missing primary template attributes %s")
    2726                 :            :             : G_("missing primary template attribute %s"),
    2727                 :            :             pp_formatted_text (&str));
    2728                 :            : }
    2729                 :            : 
    2730                 :            : /* Check to see if the function just declared, as indicated in
    2731                 :            :    DECLARATOR, and in DECL, is a specialization of a function
    2732                 :            :    template.  We may also discover that the declaration is an explicit
    2733                 :            :    instantiation at this point.
    2734                 :            : 
    2735                 :            :    Returns DECL, or an equivalent declaration that should be used
    2736                 :            :    instead if all goes well.  Issues an error message if something is
    2737                 :            :    amiss.  Returns error_mark_node if the error is not easily
    2738                 :            :    recoverable.
    2739                 :            : 
    2740                 :            :    FLAGS is a bitmask consisting of the following flags:
    2741                 :            : 
    2742                 :            :    2: The function has a definition.
    2743                 :            :    4: The function is a friend.
    2744                 :            : 
    2745                 :            :    The TEMPLATE_COUNT is the number of references to qualifying
    2746                 :            :    template classes that appeared in the name of the function.  For
    2747                 :            :    example, in
    2748                 :            : 
    2749                 :            :      template <class T> struct S { void f(); };
    2750                 :            :      void S<int>::f();
    2751                 :            : 
    2752                 :            :    the TEMPLATE_COUNT would be 1.  However, explicitly specialized
    2753                 :            :    classes are not counted in the TEMPLATE_COUNT, so that in
    2754                 :            : 
    2755                 :            :      template <class T> struct S {};
    2756                 :            :      template <> struct S<int> { void f(); }
    2757                 :            :      template <> void S<int>::f();
    2758                 :            : 
    2759                 :            :    the TEMPLATE_COUNT would be 0.  (Note that this declaration is
    2760                 :            :    invalid; there should be no template <>.)
    2761                 :            : 
    2762                 :            :    If the function is a specialization, it is marked as such via
    2763                 :            :    DECL_TEMPLATE_SPECIALIZATION.  Furthermore, its DECL_TEMPLATE_INFO
    2764                 :            :    is set up correctly, and it is added to the list of specializations
    2765                 :            :    for that template.  */
    2766                 :            : 
    2767                 :            : tree
    2768                 :   18474400 : check_explicit_specialization (tree declarator,
    2769                 :            :                                tree decl,
    2770                 :            :                                int template_count,
    2771                 :            :                                int flags,
    2772                 :            :                                tree attrlist)
    2773                 :            : {
    2774                 :   18474400 :   int have_def = flags & 2;
    2775                 :   18474400 :   int is_friend = flags & 4;
    2776                 :   18474400 :   bool is_concept = flags & 8;
    2777                 :   18474400 :   int specialization = 0;
    2778                 :   18474400 :   int explicit_instantiation = 0;
    2779                 :   18474400 :   int member_specialization = 0;
    2780                 :   18474400 :   tree ctype = DECL_CLASS_CONTEXT (decl);
    2781                 :   18474400 :   tree dname = DECL_NAME (decl);
    2782                 :   18474400 :   tmpl_spec_kind tsk;
    2783                 :            : 
    2784                 :   18474400 :   if (is_friend)
    2785                 :            :     {
    2786                 :      67668 :       if (!processing_specialization)
    2787                 :            :         tsk = tsk_none;
    2788                 :            :       else
    2789                 :            :         tsk = tsk_excessive_parms;
    2790                 :            :     }
    2791                 :            :   else
    2792                 :   18406800 :     tsk = current_tmpl_spec_kind (template_count);
    2793                 :            : 
    2794                 :   18406800 :   switch (tsk)
    2795                 :            :     {
    2796                 :   14782400 :     case tsk_none:
    2797                 :   14782400 :       if (processing_specialization && !VAR_P (decl))
    2798                 :            :         {
    2799                 :      42457 :           specialization = 1;
    2800                 :      42457 :           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
    2801                 :            :         }
    2802                 :   14740000 :       else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
    2803                 :            :         {
    2804                 :         73 :           if (is_friend)
    2805                 :            :             /* This could be something like:
    2806                 :            : 
    2807                 :            :                template <class T> void f(T);
    2808                 :            :                class S { friend void f<>(int); }  */
    2809                 :            :             specialization = 1;
    2810                 :            :           else
    2811                 :            :             {
    2812                 :            :               /* This case handles bogus declarations like template <>
    2813                 :            :                  template <class T> void f<int>(); */
    2814                 :            : 
    2815                 :         16 :               error_at (cp_expr_loc_or_input_loc (declarator),
    2816                 :            :                         "template-id %qE in declaration of primary template",
    2817                 :            :                         declarator);
    2818                 :         16 :               return decl;
    2819                 :            :             }
    2820                 :            :         }
    2821                 :            :       break;
    2822                 :            : 
    2823                 :          0 :     case tsk_invalid_member_spec:
    2824                 :            :       /* The error has already been reported in
    2825                 :            :          check_specialization_scope.  */
    2826                 :          0 :       return error_mark_node;
    2827                 :            : 
    2828                 :          0 :     case tsk_invalid_expl_inst:
    2829                 :          0 :       error ("template parameter list used in explicit instantiation");
    2830                 :            : 
    2831                 :            :       /* Fall through.  */
    2832                 :            : 
    2833                 :     135395 :     case tsk_expl_inst:
    2834                 :     135395 :       if (have_def)
    2835                 :          0 :         error ("definition provided for explicit instantiation");
    2836                 :            : 
    2837                 :            :       explicit_instantiation = 1;
    2838                 :            :       break;
    2839                 :            : 
    2840                 :          0 :     case tsk_excessive_parms:
    2841                 :          0 :     case tsk_insufficient_parms:
    2842                 :          0 :       if (tsk == tsk_excessive_parms)
    2843                 :          0 :         error ("too many template parameter lists in declaration of %qD",
    2844                 :            :                decl);
    2845                 :          0 :       else if (template_header_count)
    2846                 :          0 :         error("too few template parameter lists in declaration of %qD", decl);
    2847                 :            :       else
    2848                 :          0 :         error("explicit specialization of %qD must be introduced by "
    2849                 :            :               "%<template <>%>", decl);
    2850                 :            : 
    2851                 :            :       /* Fall through.  */
    2852                 :      17189 :     case tsk_expl_spec:
    2853                 :      17189 :       if (is_concept)
    2854                 :          0 :         error ("explicit specialization declared %<concept%>");
    2855                 :            : 
    2856                 :      17189 :       if (VAR_P (decl) && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
    2857                 :            :         /* In cases like template<> constexpr bool v = true;
    2858                 :            :            We'll give an error in check_template_variable.  */
    2859                 :            :         break;
    2860                 :            : 
    2861                 :      17173 :       SET_DECL_TEMPLATE_SPECIALIZATION (decl);
    2862                 :      17173 :       if (ctype)
    2863                 :            :         member_specialization = 1;
    2864                 :            :       else
    2865                 :      16936 :         specialization = 1;
    2866                 :            :       break;
    2867                 :            : 
    2868                 :    3539440 :     case tsk_template:
    2869                 :    3539440 :       if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
    2870                 :            :         {
    2871                 :            :           /* This case handles bogus declarations like template <>
    2872                 :            :              template <class T> void f<int>(); */
    2873                 :            : 
    2874                 :       7280 :           if (!uses_template_parms (TREE_OPERAND (declarator, 1)))
    2875                 :         18 :             error_at (cp_expr_loc_or_input_loc (declarator),
    2876                 :            :                       "template-id %qE in declaration of primary template",
    2877                 :            :                       declarator);
    2878                 :       7271 :           else if (variable_template_p (TREE_OPERAND (declarator, 0)))
    2879                 :            :             {
    2880                 :            :               /* Partial specialization of variable template.  */
    2881                 :       7254 :               SET_DECL_TEMPLATE_SPECIALIZATION (decl);
    2882                 :       7254 :               specialization = 1;
    2883                 :       7254 :               goto ok;
    2884                 :            :             }
    2885                 :         17 :           else if (cxx_dialect < cxx14)
    2886                 :          8 :             error_at (cp_expr_loc_or_input_loc (declarator),
    2887                 :            :                       "non-type partial specialization %qE "
    2888                 :            :                       "is not allowed", declarator);
    2889                 :            :           else
    2890                 :         26 :             error_at (cp_expr_loc_or_input_loc (declarator),
    2891                 :            :                       "non-class, non-variable partial specialization %qE "
    2892                 :            :                       "is not allowed", declarator);
    2893                 :         26 :           return decl;
    2894                 :       7254 :         ok:;
    2895                 :            :         }
    2896                 :            : 
    2897                 :    4830340 :       if (ctype && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype))
    2898                 :            :         /* This is a specialization of a member template, without
    2899                 :            :            specialization the containing class.  Something like:
    2900                 :            : 
    2901                 :            :              template <class T> struct S {
    2902                 :            :                template <class U> void f (U);
    2903                 :            :              };
    2904                 :            :              template <> template <class U> void S<int>::f(U) {}
    2905                 :            : 
    2906                 :            :            That's a specialization -- but of the entire template.  */
    2907                 :            :         specialization = 1;
    2908                 :            :       break;
    2909                 :            : 
    2910                 :          0 :     default:
    2911                 :          0 :       gcc_unreachable ();
    2912                 :            :     }
    2913                 :            : 
    2914                 :   18474400 :   if ((specialization || member_specialization)
    2915                 :            :       /* This doesn't apply to variable templates.  */
    2916                 :   18542100 :       && FUNC_OR_METHOD_TYPE_P (TREE_TYPE (decl)))
    2917                 :            :     {
    2918                 :     101450 :       tree t = TYPE_ARG_TYPES (TREE_TYPE (decl));
    2919                 :     259858 :       for (; t; t = TREE_CHAIN (t))
    2920                 :     201865 :         if (TREE_PURPOSE (t))
    2921                 :            :           {
    2922                 :          4 :             permerror (input_location,
    2923                 :            :                        "default argument specified in explicit specialization");
    2924                 :          4 :             break;
    2925                 :            :           }
    2926                 :            :     }
    2927                 :            : 
    2928                 :   18474400 :   if (specialization || member_specialization || explicit_instantiation)
    2929                 :            :     {
    2930                 :     203107 :       tree tmpl = NULL_TREE;
    2931                 :     203107 :       tree targs = NULL_TREE;
    2932                 :     203107 :       bool was_template_id = (TREE_CODE (declarator) == TEMPLATE_ID_EXPR);
    2933                 :            : 
    2934                 :            :       /* Make sure that the declarator is a TEMPLATE_ID_EXPR.  */
    2935                 :     203107 :       if (!was_template_id)
    2936                 :            :         {
    2937                 :     150286 :           tree fns;
    2938                 :            : 
    2939                 :     150286 :           gcc_assert (identifier_p (declarator));
    2940                 :     150286 :           if (ctype)
    2941                 :            :             fns = dname;
    2942                 :            :           else
    2943                 :            :             {
    2944                 :            :               /* If there is no class context, the explicit instantiation
    2945                 :            :                  must be at namespace scope.  */
    2946                 :     143772 :               gcc_assert (DECL_NAMESPACE_SCOPE_P (decl));
    2947                 :            : 
    2948                 :            :               /* Find the namespace binding, using the declaration
    2949                 :            :                  context.  */
    2950                 :      71886 :               fns = lookup_qualified_name (CP_DECL_CONTEXT (decl), dname,
    2951                 :            :                                            false, true);
    2952                 :      71886 :               if (fns == error_mark_node)
    2953                 :            :                 /* If lookup fails, look for a friend declaration so we can
    2954                 :            :                    give a better diagnostic.  */
    2955                 :         23 :                 fns = lookup_qualified_name (CP_DECL_CONTEXT (decl), dname,
    2956                 :            :                                              /*type*/false, /*complain*/true,
    2957                 :            :                                              /*hidden*/true);
    2958                 :            : 
    2959                 :      71886 :               if (fns == error_mark_node || !is_overloaded_fn (fns))
    2960                 :            :                 {
    2961                 :         23 :                   error ("%qD is not a template function", dname);
    2962                 :         23 :                   fns = error_mark_node;
    2963                 :            :                 }
    2964                 :            :             }
    2965                 :            : 
    2966                 :     150286 :           declarator = lookup_template_function (fns, NULL_TREE);
    2967                 :            :         }
    2968                 :            : 
    2969                 :     203107 :       if (declarator == error_mark_node)
    2970                 :     136243 :         return error_mark_node;
    2971                 :            : 
    2972                 :     281742 :       if (ctype != NULL_TREE && TYPE_BEING_DEFINED (ctype))
    2973                 :            :         {
    2974                 :          0 :           if (!explicit_instantiation)
    2975                 :            :             /* A specialization in class scope.  This is invalid,
    2976                 :            :                but the error will already have been flagged by
    2977                 :            :                check_specialization_scope.  */
    2978                 :            :             return error_mark_node;
    2979                 :            :           else
    2980                 :            :             {
    2981                 :            :               /* It's not valid to write an explicit instantiation in
    2982                 :            :                  class scope, e.g.:
    2983                 :            : 
    2984                 :            :                    class C { template void f(); }
    2985                 :            : 
    2986                 :            :                    This case is caught by the parser.  However, on
    2987                 :            :                    something like:
    2988                 :            : 
    2989                 :            :                    template class C { void f(); };
    2990                 :            : 
    2991                 :            :                    (which is invalid) we can get here.  The error will be
    2992                 :            :                    issued later.  */
    2993                 :          0 :               ;
    2994                 :            :             }
    2995                 :            : 
    2996                 :          0 :           return decl;
    2997                 :            :         }
    2998                 :     203084 :       else if (ctype != NULL_TREE
    2999                 :     203084 :                && (identifier_p (TREE_OPERAND (declarator, 0))))
    3000                 :            :         {
    3001                 :            :           // We'll match variable templates in start_decl.
    3002                 :      78400 :           if (VAR_P (decl))
    3003                 :            :             return decl;
    3004                 :            : 
    3005                 :            :           /* Find the list of functions in ctype that have the same
    3006                 :            :              name as the declared function.  */
    3007                 :      78347 :           tree name = TREE_OPERAND (declarator, 0);
    3008                 :            : 
    3009                 :      78347 :           if (constructor_name_p (name, ctype))
    3010                 :            :             {
    3011                 :          0 :               if (DECL_CONSTRUCTOR_P (decl)
    3012                 :          0 :                   ? !TYPE_HAS_USER_CONSTRUCTOR (ctype)
    3013                 :          0 :                   : !CLASSTYPE_DESTRUCTOR (ctype))
    3014                 :            :                 {
    3015                 :            :                   /* From [temp.expl.spec]:
    3016                 :            : 
    3017                 :            :                      If such an explicit specialization for the member
    3018                 :            :                      of a class template names an implicitly-declared
    3019                 :            :                      special member function (clause _special_), the
    3020                 :            :                      program is ill-formed.
    3021                 :            : 
    3022                 :            :                      Similar language is found in [temp.explicit].  */
    3023                 :          0 :                   error ("specialization of implicitly-declared special member function");
    3024                 :          0 :                   return error_mark_node;
    3025                 :            :                 }
    3026                 :            : 
    3027                 :          0 :               name = DECL_NAME (decl);
    3028                 :            :             }
    3029                 :            : 
    3030                 :            :           /* For a type-conversion operator, We might be looking for
    3031                 :            :              `operator int' which will be a specialization of
    3032                 :            :              `operator T'.  Grab all the conversion operators, and
    3033                 :            :              then select from them.  */
    3034                 :      78347 :           tree fns = get_class_binding (ctype, IDENTIFIER_CONV_OP_P (name)
    3035                 :            :                                         ? conv_op_identifier : name);
    3036                 :            : 
    3037                 :      78347 :           if (fns == NULL_TREE)
    3038                 :            :             {
    3039                 :          0 :               error ("no member function %qD declared in %qT", name, ctype);
    3040                 :          0 :               return error_mark_node;
    3041                 :            :             }
    3042                 :            :           else
    3043                 :      78347 :             TREE_OPERAND (declarator, 0) = fns;
    3044                 :            :         }
    3045                 :            : 
    3046                 :            :       /* Figure out what exactly is being specialized at this point.
    3047                 :            :          Note that for an explicit instantiation, even one for a
    3048                 :            :          member function, we cannot tell a priori whether the
    3049                 :            :          instantiation is for a member template, or just a member
    3050                 :            :          function of a template class.  Even if a member template is
    3051                 :            :          being instantiated, the member template arguments may be
    3052                 :            :          elided if they can be deduced from the rest of the
    3053                 :            :          declaration.  */
    3054                 :     203031 :       tmpl = determine_specialization (declarator, decl,
    3055                 :            :                                        &targs,
    3056                 :            :                                        member_specialization,
    3057                 :            :                                        template_count,
    3058                 :            :                                        tsk);
    3059                 :            : 
    3060                 :     203031 :       if (!tmpl || tmpl == error_mark_node)
    3061                 :            :         /* We couldn't figure out what this declaration was
    3062                 :            :            specializing.  */
    3063                 :        230 :         return error_mark_node;
    3064                 :            :       else
    3065                 :            :         {
    3066                 :     202801 :           if (TREE_CODE (decl) == FUNCTION_DECL
    3067                 :     202801 :               && DECL_HIDDEN_FRIEND_P (tmpl))
    3068                 :            :             {
    3069                 :         24 :               auto_diagnostic_group d;
    3070                 :         12 :               if (pedwarn (DECL_SOURCE_LOCATION (decl), 0,
    3071                 :            :                            "friend declaration %qD is not visible to "
    3072                 :            :                            "explicit specialization", tmpl))
    3073                 :         12 :                 inform (DECL_SOURCE_LOCATION (tmpl),
    3074                 :            :                         "friend declaration here");
    3075                 :            :             }
    3076                 :     202789 :           else if (!ctype && !is_friend
    3077                 :     326990 :                    && CP_DECL_CONTEXT (decl) == current_namespace)
    3078                 :     124146 :             check_unqualified_spec_or_inst (tmpl, DECL_SOURCE_LOCATION (decl));
    3079                 :            : 
    3080                 :     202801 :           tree gen_tmpl = most_general_template (tmpl);
    3081                 :            : 
    3082                 :     202801 :           if (explicit_instantiation)
    3083                 :            :             {
    3084                 :            :               /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
    3085                 :            :                  is done by do_decl_instantiation later.  */
    3086                 :            : 
    3087                 :     135180 :               int arg_depth = TMPL_ARGS_DEPTH (targs);
    3088                 :     135180 :               int parm_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
    3089                 :            : 
    3090                 :     135180 :               if (arg_depth > parm_depth)
    3091                 :            :                 {
    3092                 :            :                   /* If TMPL is not the most general template (for
    3093                 :            :                      example, if TMPL is a friend template that is
    3094                 :            :                      injected into namespace scope), then there will
    3095                 :            :                      be too many levels of TARGS.  Remove some of them
    3096                 :            :                      here.  */
    3097                 :      36570 :                   int i;
    3098                 :      36570 :                   tree new_targs;
    3099                 :            : 
    3100                 :      36570 :                   new_targs = make_tree_vec (parm_depth);
    3101                 :      73140 :                   for (i = arg_depth - parm_depth; i < arg_depth; ++i)
    3102                 :      36570 :                     TREE_VEC_ELT (new_targs, i - (arg_depth - parm_depth))
    3103                 :      73140 :                       = TREE_VEC_ELT (targs, i);
    3104                 :      36570 :                   targs = new_targs;
    3105                 :            :                 }
    3106                 :            : 
    3107                 :     135180 :               return instantiate_template (tmpl, targs, tf_error);
    3108                 :            :             }
    3109                 :            : 
    3110                 :            :           /* If we thought that the DECL was a member function, but it
    3111                 :            :              turns out to be specializing a static member function,
    3112                 :            :              make DECL a static member function as well.  */
    3113                 :      67621 :           if (DECL_FUNCTION_TEMPLATE_P (tmpl)
    3114                 :      57912 :               && DECL_STATIC_FUNCTION_P (tmpl)
    3115                 :      68391 :               && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
    3116                 :        758 :             revert_static_member_fn (decl);
    3117                 :            : 
    3118                 :            :           /* If this is a specialization of a member template of a
    3119                 :            :              template class, we want to return the TEMPLATE_DECL, not
    3120                 :            :              the specialization of it.  */
    3121                 :      67621 :           if (tsk == tsk_template && !was_template_id)
    3122                 :            :             {
    3123                 :        757 :               tree result = DECL_TEMPLATE_RESULT (tmpl);
    3124                 :        757 :               SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
    3125                 :        757 :               DECL_INITIAL (result) = NULL_TREE;
    3126                 :        757 :               if (have_def)
    3127                 :            :                 {
    3128                 :        744 :                   tree parm;
    3129                 :        744 :                   DECL_SOURCE_LOCATION (tmpl) = DECL_SOURCE_LOCATION (decl);
    3130                 :        744 :                   DECL_SOURCE_LOCATION (result)
    3131                 :        744 :                     = DECL_SOURCE_LOCATION (decl);
    3132                 :            :                   /* We want to use the argument list specified in the
    3133                 :            :                      definition, not in the original declaration.  */
    3134                 :        744 :                   DECL_ARGUMENTS (result) = DECL_ARGUMENTS (decl);
    3135                 :       1544 :                   for (parm = DECL_ARGUMENTS (result); parm;
    3136                 :        800 :                        parm = DECL_CHAIN (parm))
    3137                 :        800 :                     DECL_CONTEXT (parm) = result;
    3138                 :            :                 }
    3139                 :        757 :               return register_specialization (tmpl, gen_tmpl, targs,
    3140                 :        757 :                                               is_friend, 0);
    3141                 :            :             }
    3142                 :            : 
    3143                 :            :           /* Set up the DECL_TEMPLATE_INFO for DECL.  */
    3144                 :      66864 :           DECL_TEMPLATE_INFO (decl) = build_template_info (tmpl, targs);
    3145                 :            : 
    3146                 :      66864 :           if (was_template_id)
    3147                 :      10437 :             TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (decl)) = true;
    3148                 :            : 
    3149                 :            :           /* Inherit default function arguments from the template
    3150                 :            :              DECL is specializing.  */
    3151                 :      66864 :           if (DECL_FUNCTION_TEMPLATE_P (tmpl))
    3152                 :      57155 :             copy_default_args_to_explicit_spec (decl);
    3153                 :            : 
    3154                 :            :           /* This specialization has the same protection as the
    3155                 :            :              template it specializes.  */
    3156                 :      66864 :           TREE_PRIVATE (decl) = TREE_PRIVATE (gen_tmpl);
    3157                 :      66864 :           TREE_PROTECTED (decl) = TREE_PROTECTED (gen_tmpl);
    3158                 :            : 
    3159                 :            :           /* 7.1.1-1 [dcl.stc]
    3160                 :            : 
    3161                 :            :              A storage-class-specifier shall not be specified in an
    3162                 :            :              explicit specialization...
    3163                 :            : 
    3164                 :            :              The parser rejects these, so unless action is taken here,
    3165                 :            :              explicit function specializations will always appear with
    3166                 :            :              global linkage.
    3167                 :            : 
    3168                 :            :              The action recommended by the C++ CWG in response to C++
    3169                 :            :              defect report 605 is to make the storage class and linkage
    3170                 :            :              of the explicit specialization match the templated function:
    3171                 :            : 
    3172                 :            :              http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
    3173                 :            :            */
    3174                 :      66864 :           if (tsk == tsk_expl_spec && DECL_FUNCTION_TEMPLATE_P (gen_tmpl))
    3175                 :            :             {
    3176                 :      14650 :               tree tmpl_func = DECL_TEMPLATE_RESULT (gen_tmpl);
    3177                 :      14650 :               gcc_assert (TREE_CODE (tmpl_func) == FUNCTION_DECL);
    3178                 :            : 
    3179                 :            :               /* A concept cannot be specialized.  */
    3180                 :      14650 :               if (DECL_DECLARED_CONCEPT_P (tmpl_func))
    3181                 :            :                 {
    3182                 :          0 :                   error ("explicit specialization of function concept %qD",
    3183                 :            :                          gen_tmpl);
    3184                 :          0 :                   return error_mark_node;
    3185                 :            :                 }
    3186                 :            : 
    3187                 :            :               /* This specialization has the same linkage and visibility as
    3188                 :            :                  the function template it specializes.  */
    3189                 :      14650 :               TREE_PUBLIC (decl) = TREE_PUBLIC (tmpl_func);
    3190                 :      14650 :               if (! TREE_PUBLIC (decl))
    3191                 :            :                 {
    3192                 :         24 :                   DECL_INTERFACE_KNOWN (decl) = 1;
    3193                 :         24 :                   DECL_NOT_REALLY_EXTERN (decl) = 1;
    3194                 :            :                 }
    3195                 :      43950 :               DECL_THIS_STATIC (decl) = DECL_THIS_STATIC (tmpl_func);
    3196                 :      14650 :               if (DECL_VISIBILITY_SPECIFIED (tmpl_func))
    3197                 :            :                 {
    3198                 :         44 :                   DECL_VISIBILITY_SPECIFIED (decl) = 1;
    3199                 :         44 :                   DECL_VISIBILITY (decl) = DECL_VISIBILITY (tmpl_func);
    3200                 :            :                 }
    3201                 :            :             }
    3202                 :            : 
    3203                 :            :           /* If DECL is a friend declaration, declared using an
    3204                 :            :              unqualified name, the namespace associated with DECL may
    3205                 :            :              have been set incorrectly.  For example, in:
    3206                 :            : 
    3207                 :            :                template <typename T> void f(T);
    3208                 :            :                namespace N {
    3209                 :            :                  struct S { friend void f<int>(int); }
    3210                 :            :                }
    3211                 :            : 
    3212                 :            :              we will have set the DECL_CONTEXT for the friend
    3213                 :            :              declaration to N, rather than to the global namespace.  */
    3214                 :     133728 :           if (DECL_NAMESPACE_SCOPE_P (decl))
    3215                 :      24174 :             DECL_CONTEXT (decl) = DECL_CONTEXT (tmpl);
    3216                 :            : 
    3217                 :      66864 :           if (is_friend && !have_def)
    3218                 :            :             /* This is not really a declaration of a specialization.
    3219                 :            :                It's just the name of an instantiation.  But, it's not
    3220                 :            :                a request for an instantiation, either.  */
    3221                 :         53 :             SET_DECL_IMPLICIT_INSTANTIATION (decl);
    3222                 :      66811 :           else if (TREE_CODE (decl) == FUNCTION_DECL)
    3223                 :            :             /* A specialization is not necessarily COMDAT.  */
    3224                 :      57102 :             DECL_COMDAT (decl) = (TREE_PUBLIC (decl)
    3225                 :      57102 :                                   && DECL_DECLARED_INLINE_P (decl));
    3226                 :       9709 :           else if (VAR_P (decl))
    3227                 :       9709 :             DECL_COMDAT (decl) = false;
    3228                 :            : 
    3229                 :            :           /* If this is a full specialization, register it so that we can find
    3230                 :            :              it again.  Partial specializations will be registered in
    3231                 :            :              process_partial_specialization.  */
    3232                 :      66864 :           if (!processing_template_decl)
    3233                 :            :             {
    3234                 :      59610 :               warn_spec_missing_attributes (gen_tmpl, decl, attrlist);
    3235                 :            : 
    3236                 :      59610 :               decl = register_specialization (decl, gen_tmpl, targs,
    3237                 :            :                                               is_friend, 0);
    3238                 :            :             }
    3239                 :            : 
    3240                 :            : 
    3241                 :            :           /* A 'structor should already have clones.  */
    3242                 :     128349 :           gcc_assert (decl == error_mark_node
    3243                 :            :                       || variable_template_p (tmpl)
    3244                 :            :                       || !(DECL_CONSTRUCTOR_P (decl)
    3245                 :            :                            || DECL_DESTRUCTOR_P (decl))
    3246                 :            :                       || DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl)));
    3247                 :            :         }
    3248                 :            :     }
    3249                 :            : 
    3250                 :            :   return decl;
    3251                 :            : }
    3252                 :            : 
    3253                 :            : /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
    3254                 :            :    parameters.  These are represented in the same format used for
    3255                 :            :    DECL_TEMPLATE_PARMS.  */
    3256                 :            : 
    3257                 :            : int
    3258                 :   13460800 : comp_template_parms (const_tree parms1, const_tree parms2)
    3259                 :            : {
    3260                 :   13460800 :   const_tree p1;
    3261                 :   13460800 :   const_tree p2;
    3262                 :            : 
    3263                 :   13460800 :   if (parms1 == parms2)
    3264                 :            :     return 1;
    3265                 :            : 
    3266                 :    4067280 :   for (p1 = parms1, p2 = parms2;
    3267                 :   17527000 :        p1 != NULL_TREE && p2 != NULL_TREE;
    3268                 :    4067280 :        p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2))
    3269                 :            :     {
    3270                 :   13897600 :       tree t1 = TREE_VALUE (p1);
    3271                 :   13897600 :       tree t2 = TREE_VALUE (p2);
    3272                 :   13897600 :       int i;
    3273                 :            : 
    3274                 :   13897600 :       gcc_assert (TREE_CODE (t1) == TREE_VEC);
    3275                 :   13897600 :       gcc_assert (TREE_CODE (t2) == TREE_VEC);
    3276                 :            : 
    3277                 :   13897600 :       if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2))
    3278                 :            :         return 0;
    3279                 :            : 
    3280                 :   16914800 :       for (i = 0; i < TREE_VEC_LENGTH (t2); ++i)
    3281                 :            :         {
    3282                 :   12847600 :           tree parm1 = TREE_VALUE (TREE_VEC_ELT (t1, i));
    3283                 :   12847600 :           tree parm2 = TREE_VALUE (TREE_VEC_ELT (t2, i));
    3284                 :            : 
    3285                 :            :           /* If either of the template parameters are invalid, assume
    3286                 :            :              they match for the sake of error recovery. */
    3287                 :   38542700 :           if (error_operand_p (parm1) || error_operand_p (parm2))
    3288                 :            :             return 1;
    3289                 :            : 
    3290                 :   12847600 :           if (TREE_CODE (parm1) != TREE_CODE (parm2))
    3291                 :            :             return 0;
    3292                 :            : 
    3293                 :   12434100 :           if (TREE_CODE (parm1) == TEMPLATE_TYPE_PARM
    3294                 :   12434100 :               && (TEMPLATE_TYPE_PARAMETER_PACK (parm1)
    3295                 :          0 :                   == TEMPLATE_TYPE_PARAMETER_PACK (parm2)))
    3296                 :          0 :             continue;
    3297                 :   12434100 :           else if (!same_type_p (TREE_TYPE (parm1), TREE_TYPE (parm2)))
    3298                 :            :             return 0;
    3299                 :            :         }
    3300                 :            :     }
    3301                 :            : 
    3302                 :    3629320 :   if ((p1 != NULL_TREE) != (p2 != NULL_TREE))
    3303                 :            :     /* One set of parameters has more parameters lists than the
    3304                 :            :        other.  */
    3305                 :          0 :     return 0;
    3306                 :            : 
    3307                 :            :   return 1;
    3308                 :            : }
    3309                 :            : 
    3310                 :            : /* Returns true if two template parameters are declared with
    3311                 :            :    equivalent constraints.  */
    3312                 :            : 
    3313                 :            : static bool
    3314                 :    1486650 : template_parameter_constraints_equivalent_p (const_tree parm1, const_tree parm2)
    3315                 :            : {
    3316                 :    1486650 :   tree req1 = TREE_TYPE (parm1);
    3317                 :    1486650 :   tree req2 = TREE_TYPE (parm2);
    3318                 :    1486650 :   if (!req1 != !req2)
    3319                 :            :     return false;
    3320                 :    1469820 :   if (req1)
    3321                 :      15166 :     return cp_tree_equal (req1, req2);
    3322                 :            :   return true;
    3323                 :            : }
    3324                 :            : 
    3325                 :            : /* Returns true when two template parameters are equivalent.  */
    3326                 :            : 
    3327                 :            : static bool
    3328                 :    1225240 : template_parameters_equivalent_p (const_tree parm1, const_tree parm2)
    3329                 :            : {
    3330                 :    1225240 :   tree decl1 = TREE_VALUE (parm1);
    3331                 :    1225240 :   tree decl2 = TREE_VALUE (parm2);
    3332                 :            : 
    3333                 :            :   /* If either of the template parameters are invalid, assume
    3334                 :            :      they match for the sake of error recovery. */
    3335                 :    3675710 :   if (error_operand_p (decl1) || error_operand_p (decl2))
    3336                 :            :     return true;
    3337                 :            : 
    3338                 :            :   /* ... they declare parameters of the same kind.  */
    3339                 :    1225240 :   if (TREE_CODE (decl1) != TREE_CODE (decl2))
    3340                 :            :     return false;
    3341                 :            : 
    3342                 :            :   /* ... one parameter was introduced by a parameter declaration, then
    3343                 :            :      both are. This case arises as a result of eagerly rewriting declarations
    3344                 :            :      during parsing.  */
    3345                 :    1174620 :   if (DECL_VIRTUAL_P (decl1) != DECL_VIRTUAL_P (decl2))
    3346                 :            :     return false;
    3347                 :            : 
    3348                 :            :   /* ... if either declares a pack, they both do.  */
    3349                 :    1174620 :   if (template_parameter_pack_p (decl1) != template_parameter_pack_p (decl2))
    3350                 :            :     return false;
    3351                 :            : 
    3352                 :    1136370 :   if (TREE_CODE (decl1) == PARM_DECL)
    3353                 :            :     {
    3354                 :            :       /* ... if they declare non-type parameters, the types are equivalent.  */
    3355                 :      33553 :       if (!same_type_p (TREE_TYPE (decl1), TREE_TYPE (decl2)))
    3356                 :            :         return false;
    3357                 :            :     }
    3358                 :    1102820 :   else if (TREE_CODE (decl2) == TEMPLATE_DECL)
    3359                 :            :     {
    3360                 :            :       /* ... if they declare template template parameters, their template
    3361                 :            :          parameter lists are equivalent.  */
    3362                 :        713 :       if (!template_heads_equivalent_p (decl1, decl2))
    3363                 :            :         return false;
    3364                 :            :     }
    3365                 :            : 
    3366                 :            :   /* ... if they are declared with a qualified-concept name, they both
    3367                 :            :      are, and those names are equivalent.  */
    3368                 :    1135750 :   return template_parameter_constraints_equivalent_p (parm1, parm2);
    3369                 :            : }
    3370                 :            : 
    3371                 :            : /* Returns true if two template parameters lists are equivalent.
    3372                 :            :    Two template parameter lists are equivalent if they have the
    3373                 :            :    same length and their corresponding parameters are equivalent.
    3374                 :            : 
    3375                 :            :    PARMS1 and PARMS2 are TREE_LISTs containing TREE_VECs: the
    3376                 :            :    data structure returned by DECL_TEMPLATE_PARMS.
    3377                 :            : 
    3378                 :            :    This is generally the same implementation as comp_template_parms
    3379                 :            :    except that it also the concept names and arguments used to
    3380                 :            :    introduce parameters.  */
    3381                 :            : 
    3382                 :            : static bool
    3383                 :    1283940 : template_parameter_lists_equivalent_p (const_tree parms1, const_tree parms2)
    3384                 :            : {
    3385                 :    1283940 :   if (parms1 == parms2)
    3386                 :            :     return true;
    3387                 :            : 
    3388                 :            :   const_tree p1 = parms1;
    3389                 :            :   const_tree p2 = parms2;
    3390                 :    1807180 :   while (p1 != NULL_TREE && p2 != NULL_TREE)
    3391                 :            :     {
    3392                 :    1284640 :       tree list1 = TREE_VALUE (p1);
    3393                 :    1284640 :       tree list2 = TREE_VALUE (p2);
    3394                 :            : 
    3395                 :    1284640 :       if (TREE_VEC_LENGTH (list1) != TREE_VEC_LENGTH (list2))
    3396                 :            :         return 0;
    3397                 :            : 
    3398                 :    1748480 :       for (int i = 0; i < TREE_VEC_LENGTH (list2); ++i)
    3399                 :            :         {
    3400                 :    1225240 :           tree parm1 = TREE_VEC_ELT (list1, i);
    3401                 :    1225240 :           tree parm2 = TREE_VEC_ELT (list2, i);
    3402                 :    1225240 :           if (!template_parameters_equivalent_p (parm1, parm2))
    3403                 :            :             return false;
    3404                 :            :         }
    3405                 :            : 
    3406                 :     523241 :       p1 = TREE_CHAIN (p1);
    3407                 :     523241 :       p2 = TREE_CHAIN (p2);
    3408                 :            :     }
    3409                 :            : 
    3410                 :     522539 :   if ((p1 != NULL_TREE) != (p2 != NULL_TREE))
    3411                 :          0 :     return false;
    3412                 :            : 
    3413                 :            :   return true;
    3414                 :            : }
    3415                 :            : 
    3416                 :            : /* Return true if the requires-clause of the template parameter lists are
    3417                 :            :    equivalent and false otherwise.  */
    3418                 :            : static bool
    3419                 :     522539 : template_requirements_equivalent_p (const_tree parms1, const_tree parms2)
    3420                 :            : {
    3421                 :     522539 :   tree req1 = TEMPLATE_PARMS_CONSTRAINTS (parms1);
    3422                 :     522539 :   tree req2 = TEMPLATE_PARMS_CONSTRAINTS (parms2);
    3423                 :     522539 :   if ((req1 != NULL_TREE) != (req2 != NULL_TREE))
    3424                 :            :     return false;
    3425                 :     522491 :   if (!cp_tree_equal (req1, req2))
    3426                 :       5522 :     return false;
    3427                 :            :   return true;
    3428                 :            : }
    3429                 :            : 
    3430                 :            : /* Returns true if two template heads are equivalent. 17.6.6.1p6:
    3431                 :            :    Two template heads are equivalent if their template parameter
    3432                 :            :    lists are equivalent and their requires clauses are equivalent.
    3433                 :            : 
    3434                 :            :    In pre-C++20, this is equivalent to calling comp_template_parms
    3435                 :            :    for the template parameters of TMPL1 and TMPL2.  */
    3436                 :            : 
    3437                 :            : bool
    3438                 :    6380520 : template_heads_equivalent_p (const_tree tmpl1, const_tree tmpl2)
    3439                 :            : {
    3440                 :    6380520 :   tree parms1 = DECL_TEMPLATE_PARMS (tmpl1);
    3441                 :    6380520 :   tree parms2 = DECL_TEMPLATE_PARMS (tmpl2);
    3442                 :            : 
    3443                 :            :   /* Don't change the matching rules for pre-C++20.  */
    3444                 :    6380520 :   if (cxx_dialect < cxx2a)
    3445                 :    5096590 :     return comp_template_parms (parms1, parms2);
    3446                 :            : 
    3447                 :            :   /* ... have the same number of template parameters, and their
    3448                 :            :      corresponding parameters are equivalent.  */
    3449                 :    1283940 :   if (!template_parameter_lists_equivalent_p (parms1, parms2))
    3450                 :            :     return false;
    3451                 :            : 
    3452                 :            :   /* ... if either has a requires-clause, they both do and their
    3453                 :            :      corresponding constraint-expressions are equivalent.  */
    3454                 :     522539 :   return template_requirements_equivalent_p (parms1, parms2);
    3455                 :            : }
    3456                 :            : 
    3457                 :            : /* Determine whether PARM is a parameter pack.  */
    3458                 :            : 
    3459                 :            : bool
    3460                 : 1173860000 : template_parameter_pack_p (const_tree parm)
    3461                 :            : {
    3462                 :            :   /* Determine if we have a non-type template parameter pack.  */
    3463                 : 1173860000 :   if (TREE_CODE (parm) == PARM_DECL)
    3464                 :  129384000 :     return (DECL_TEMPLATE_PARM_P (parm)
    3465                 :  129384000 :             && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)));
    3466                 : 1044480000 :   if (TREE_CODE (parm) == TEMPLATE_PARM_INDEX)
    3467                 :      95477 :     return TEMPLATE_PARM_PARAMETER_PACK (parm);
    3468                 :            : 
    3469                 :            :   /* If this is a list of template parameters, we could get a
    3470                 :            :      TYPE_DECL or a TEMPLATE_DECL.  */
    3471                 : 1044380000 :   if (TREE_CODE (parm) == TYPE_DECL || TREE_CODE (parm) == TEMPLATE_DECL)
    3472                 : 1007200000 :     parm = TREE_TYPE (parm);
    3473                 :            : 
    3474                 :            :   /* Otherwise it must be a type template parameter.  */
    3475                 : 1044380000 :   return ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
    3476                 : 1044380000 :            || TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM)
    3477                 : 1044380000 :           && TEMPLATE_TYPE_PARAMETER_PACK (parm));
    3478                 :            : }
    3479                 :            : 
    3480                 :            : /* Determine if T is a function parameter pack.  */
    3481                 :            : 
    3482                 :            : bool
    3483                 :     901809 : function_parameter_pack_p (const_tree t)
    3484                 :            : {
    3485                 :     901809 :   if (t && TREE_CODE (t) == PARM_DECL)
    3486                 :    1803620 :     return DECL_PACK_P (t);
    3487                 :            :   return false;
    3488                 :            : }
    3489                 :            : 
    3490                 :            : /* Return the function template declaration of PRIMARY_FUNC_TMPL_INST.
    3491                 :            :    PRIMARY_FUNC_TMPL_INST is a primary function template instantiation.  */
    3492                 :            : 
    3493                 :            : tree
    3494                 :    1133680 : get_function_template_decl (const_tree primary_func_tmpl_inst)
    3495                 :            : {
    3496                 :    1133680 :   if (! primary_func_tmpl_inst
    3497                 :    1133680 :       || TREE_CODE (primary_func_tmpl_inst) != FUNCTION_DECL
    3498                 :    2267360 :       || ! primary_template_specialization_p (primary_func_tmpl_inst))
    3499                 :     841399 :     return NULL;
    3500                 :            : 
    3501                 :     292283 :   return DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (primary_func_tmpl_inst));
    3502                 :            : }
    3503                 :            : 
    3504                 :            : /* Return true iff the function parameter PARAM_DECL was expanded
    3505                 :            :    from the function parameter pack PACK.  */
    3506                 :            : 
    3507                 :            : bool
    3508                 :     238263 : function_parameter_expanded_from_pack_p (tree param_decl, tree pack)
    3509                 :            : {
    3510                 :     238263 :   if (DECL_ARTIFICIAL (param_decl)
    3511                 :     238263 :       || !function_parameter_pack_p (pack))
    3512                 :          0 :     return false;
    3513                 :            : 
    3514                 :            :   /* The parameter pack and its pack arguments have the same
    3515                 :            :      DECL_PARM_INDEX.  */
    3516                 :     238263 :   return DECL_PARM_INDEX (pack) == DECL_PARM_INDEX (param_decl);
    3517                 :            : }
    3518                 :            : 
    3519                 :            : /* Determine whether ARGS describes a variadic template args list,
    3520                 :            :    i.e., one that is terminated by a template argument pack.  */
    3521                 :            : 
    3522                 :            : static bool
    3523                 :          0 : template_args_variadic_p (tree args)
    3524                 :            : {
    3525                 :          0 :   int nargs;
    3526                 :          0 :   tree last_parm;
    3527                 :            : 
    3528                 :          0 :   if (args == NULL_TREE)
    3529                 :            :     return false;
    3530                 :            : 
    3531                 :          0 :   args = INNERMOST_TEMPLATE_ARGS (args);
    3532                 :          0 :   nargs = TREE_VEC_LENGTH (args);
    3533                 :            : 
    3534                 :          0 :   if (nargs == 0)
    3535                 :            :     return false;
    3536                 :            : 
    3537                 :          0 :   last_parm = TREE_VEC_ELT (args, nargs - 1);
    3538                 :            : 
    3539                 :          0 :   return ARGUMENT_PACK_P (last_parm);
    3540                 :            : }
    3541                 :            : 
    3542                 :            : /* Generate a new name for the parameter pack name NAME (an
    3543                 :            :    IDENTIFIER_NODE) that incorporates its */
    3544                 :            : 
    3545                 :            : static tree
    3546                 :     328964 : make_ith_pack_parameter_name (tree name, int i)
    3547                 :            : {
    3548                 :            :   /* Munge the name to include the parameter index.  */
    3549                 :            : #define NUMBUF_LEN 128
    3550                 :     328964 :   char numbuf[NUMBUF_LEN];
    3551                 :     328964 :   char* newname;
    3552                 :     328964 :   int newname_len;
    3553                 :            : 
    3554                 :     328964 :   if (name == NULL_TREE)
    3555                 :            :     return name;
    3556                 :     327226 :   snprintf (numbuf, NUMBUF_LEN, "%i", i);
    3557                 :     327226 :   newname_len = IDENTIFIER_LENGTH (name)
    3558                 :     327226 :                 + strlen (numbuf) + 2;
    3559                 :     327226 :   newname = (char*)alloca (newname_len);
    3560                 :     327226 :   snprintf (newname, newname_len,
    3561                 :     327226 :             "%s#%i", IDENTIFIER_POINTER (name), i);
    3562                 :     327226 :   return get_identifier (newname);
    3563                 :            : }
    3564                 :            : 
    3565                 :            : /* Return true if T is a primary function, class or alias template
    3566                 :            :    specialization, not including the template pattern.  */
    3567                 :            : 
    3568                 :            : bool
    3569                 :   44514600 : primary_template_specialization_p (const_tree t)
    3570                 :            : {
    3571                 :   44514600 :   if (!t)
    3572                 :            :     return false;
    3573                 :            : 
    3574                 :   44514600 :   if (TREE_CODE (t) == FUNCTION_DECL || VAR_P (t))
    3575                 :    9341170 :     return (DECL_LANG_SPECIFIC (t)
    3576                 :    9341110 :             && DECL_USE_TEMPLATE (t)
    3577                 :    8343310 :             && DECL_TEMPLATE_INFO (t)
    3578                 :   17684500 :             && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t)));
    3579                 :   70346900 :   else if (CLASS_TYPE_P (t) && !TYPE_DECL_ALIAS_P (TYPE_NAME (t)))
    3580                 :   35173400 :     return (CLASSTYPE_TEMPLATE_INFO (t)
    3581                 :   35173400 :             && CLASSTYPE_USE_TEMPLATE (t)
    3582                 :   70346900 :             && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)));
    3583                 :          0 :   else if (alias_template_specialization_p (t, nt_transparent))
    3584                 :          0 :     return true;
    3585                 :            :   return false;
    3586                 :            : }
    3587                 :            : 
    3588                 :            : /* Return true if PARM is a template template parameter.  */
    3589                 :            : 
    3590                 :            : bool
    3591                 :   18166300 : template_template_parameter_p (const_tree parm)
    3592                 :            : {
    3593                 :   18205400 :   return DECL_TEMPLATE_TEMPLATE_PARM_P (parm);
    3594                 :            : }
    3595                 :            : 
    3596                 :            : /* Return true iff PARM is a DECL representing a type template
    3597                 :            :    parameter.  */
    3598                 :            : 
    3599                 :            : bool
    3600                 :  402187000 : template_type_parameter_p (const_tree parm)
    3601                 :            : {
    3602                 :  402187000 :   return (parm
    3603                 :  402187000 :           && (TREE_CODE (parm) == TYPE_DECL
    3604                 :  402187000 :               || TREE_CODE (parm) == TEMPLATE_DECL)
    3605                 :  614455000 :           && DECL_TEMPLATE_PARM_P (parm));
    3606                 :            : }
    3607                 :            : 
    3608                 :            : /* Return the template parameters of T if T is a
    3609                 :            :    primary template instantiation, NULL otherwise.  */
    3610                 :            : 
    3611                 :            : tree
    3612                 :   44540200 : get_primary_template_innermost_parameters (const_tree t)
    3613                 :            : {
    3614                 :   44540200 :   tree parms = NULL, template_info = NULL;
    3615                 :            : 
    3616                 :   44540200 :   if ((template_info = get_template_info (t))
    3617                 :   44540200 :       && primary_template_specialization_p (t))
    3618                 :   35647900 :     parms = INNERMOST_TEMPLATE_PARMS
    3619                 :            :         (DECL_TEMPLATE_PARMS (TI_TEMPLATE (template_info)));
    3620                 :            : 
    3621                 :   44540200 :   return parms;
    3622                 :            : }
    3623                 :            : 
    3624                 :            : /* Return the template parameters of the LEVELth level from the full list
    3625                 :            :    of template parameters PARMS.  */
    3626                 :            : 
    3627                 :            : tree
    3628                 :          0 : get_template_parms_at_level (tree parms, int level)
    3629                 :            : {
    3630                 :          0 :   tree p;
    3631                 :          0 :   if (!parms
    3632                 :          0 :       || TREE_CODE (parms) != TREE_LIST
    3633                 :          0 :       || level > TMPL_PARMS_DEPTH (parms))
    3634                 :            :     return NULL_TREE;
    3635                 :            : 
    3636                 :          0 :   for (p = parms; p; p = TREE_CHAIN (p))
    3637                 :          0 :     if (TMPL_PARMS_DEPTH (p) == level)
    3638                 :          0 :       return p;
    3639                 :            : 
    3640                 :            :   return NULL_TREE;
    3641                 :            : }
    3642                 :            : 
    3643                 :            : /* Returns the template arguments of T if T is a template instantiation,
    3644                 :            :    NULL otherwise.  */
    3645                 :            : 
    3646                 :            : tree
    3647                 :   26193900 : get_template_innermost_arguments (const_tree t)
    3648                 :            : {
    3649                 :   26193900 :   tree args = NULL, template_info = NULL;
    3650                 :            : 
    3651                 :   26193900 :   if ((template_info = get_template_info (t))
    3652                 :   52387800 :       && TI_ARGS (template_info))
    3653                 :   26193900 :     args = INNERMOST_TEMPLATE_ARGS (TI_ARGS (template_info));
    3654                 :            : 
    3655                 :   26193900 :   return args;
    3656                 :            : }
    3657                 :            : 
    3658                 :            : /* Return the argument pack elements of T if T is a template argument pack,
    3659                 :            :    NULL otherwise.  */
    3660                 :            : 
    3661                 :            : tree
    3662                 :   43243900 : get_template_argument_pack_elems (const_tree t)
    3663                 :            : {
    3664                 :   43243900 :   if (TREE_CODE (t) != TYPE_ARGUMENT_PACK
    3665                 :   43243900 :       && TREE_CODE (t) != NONTYPE_ARGUMENT_PACK)
    3666                 :            :     return NULL;
    3667                 :            : 
    3668                 :   10890800 :   return ARGUMENT_PACK_ARGS (t);
    3669                 :            : }
    3670                 :            : 
    3671                 :            : /* In an ARGUMENT_PACK_SELECT, the actual underlying argument that the
    3672                 :            :    ARGUMENT_PACK_SELECT represents. */
    3673                 :            : 
    3674                 :            : static tree
    3675                 :    1240950 : argument_pack_select_arg (tree t)
    3676                 :            : {
    3677                 :    1240950 :   tree args = ARGUMENT_PACK_ARGS (ARGUMENT_PACK_SELECT_FROM_PACK (t));
    3678                 :    1240950 :   tree arg = TREE_VEC_ELT (args, ARGUMENT_PACK_SELECT_INDEX (t));
    3679                 :            : 
    3680                 :            :   /* If the selected argument is an expansion E, that most likely means we were
    3681                 :            :      called from gen_elem_of_pack_expansion_instantiation during the
    3682                 :            :      substituting of an argument pack (of which the Ith element is a pack
    3683                 :            :      expansion, where I is ARGUMENT_PACK_SELECT_INDEX) into a pack expansion.
    3684                 :            :      In this case, the Ith element resulting from this substituting is going to
    3685                 :            :      be a pack expansion, which pattern is the pattern of E.  Let's return the
    3686                 :            :      pattern of E, and gen_elem_of_pack_expansion_instantiation will build the
    3687                 :            :      resulting pack expansion from it.  */
    3688                 :    1240950 :   if (PACK_EXPANSION_P (arg))
    3689                 :            :     {
    3690                 :            :       /* Make sure we aren't throwing away arg info.  */
    3691                 :      11938 :       gcc_assert (!PACK_EXPANSION_EXTRA_ARGS (arg));
    3692                 :      11938 :       arg = PACK_EXPANSION_PATTERN (arg);
    3693                 :            :     }
    3694                 :            : 
    3695                 :    1240950 :   return arg;
    3696                 :            : }
    3697                 :            : 
    3698                 :            : 
    3699                 :            : /* True iff FN is a function representing a built-in variadic parameter
    3700                 :            :    pack.  */
    3701                 :            : 
    3702                 :            : bool
    3703                 :   33624100 : builtin_pack_fn_p (tree fn)
    3704                 :            : {
    3705                 :   33624100 :   if (!fn
    3706                 :   33621200 :       || TREE_CODE (fn) != FUNCTION_DECL
    3707                 :   51980000 :       || !DECL_IS_BUILTIN (fn))
    3708                 :   32648700 :     return false;
    3709                 :            : 
    3710                 :     975445 :   if (id_equal (DECL_NAME (fn), "__integer_pack"))
    3711                 :      20484 :     return true;
    3712                 :            : 
    3713                 :            :   return false;
    3714                 :            : }
    3715                 :            : 
    3716                 :            : /* True iff CALL is a call to a function representing a built-in variadic
    3717                 :            :    parameter pack.  */
    3718                 :            : 
    3719                 :            : static bool
    3720                 :   33435100 : builtin_pack_call_p (tree call)
    3721                 :            : {
    3722                 :   33435100 :   if (TREE_CODE (call) != CALL_EXPR)
    3723                 :            :     return false;
    3724                 :   13715700 :   return builtin_pack_fn_p (CALL_EXPR_FN (call));
    3725                 :            : }
    3726                 :            : 
    3727                 :            : /* Return a TREE_VEC for the expansion of __integer_pack(HI).  */
    3728                 :            : 
    3729                 :            : static tree
    3730                 :       6132 : expand_integer_pack (tree call, tree args, tsubst_flags_t complain,
    3731                 :            :                      tree in_decl)
    3732                 :            : {
    3733                 :       6132 :   tree ohi = CALL_EXPR_ARG (call, 0);
    3734                 :       6132 :   tree hi = tsubst_copy_and_build (ohi, args, complain, in_decl,
    3735                 :            :                                    false/*fn*/, true/*int_cst*/);
    3736                 :            : 
    3737                 :       6132 :   if (value_dependent_expression_p (hi))
    3738                 :            :     {
    3739                 :       4871 :       if (hi != ohi)
    3740                 :            :         {
    3741                 :       4871 :           call = copy_node (call);
    3742                 :       4871 :           CALL_EXPR_ARG (call, 0) = hi;
    3743                 :            :         }
    3744                 :       4871 :       tree ex = make_pack_expansion (call, complain);
    3745                 :       4871 :       tree vec = make_tree_vec (1);
    3746                 :       4871 :       TREE_VEC_ELT (vec, 0) = ex;
    3747                 :       4871 :       return vec;
    3748                 :            :     }
    3749                 :            :   else
    3750                 :            :     {
    3751                 :       1261 :       hi = cxx_constant_value (hi);
    3752                 :       1261 :       int len = valid_constant_size_p (hi) ? tree_to_shwi (hi) : -1;
    3753                 :            : 
    3754                 :            :       /* Calculate the largest value of len that won't make the size of the vec
    3755                 :            :          overflow an int.  The compiler will exceed resource limits long before
    3756                 :            :          this, but it seems a decent place to diagnose.  */
    3757                 :       1261 :       int max = ((INT_MAX - sizeof (tree_vec)) / sizeof (tree)) + 1;
    3758                 :            : 
    3759                 :       1261 :       if (len < 0 || len > max)
    3760                 :            :         {
    3761                 :          9 :           if ((complain & tf_error)
    3762                 :          9 :               && hi != error_mark_node)
    3763                 :          9 :             error ("argument to %<__integer_pack%> must be between 0 and %d",
    3764                 :            :                    max);
    3765                 :          9 :           return error_mark_node;
    3766                 :            :         }
    3767                 :            : 
    3768                 :       1252 :       tree vec = make_tree_vec (len);
    3769                 :            : 
    3770                 :       3911 :       for (int i = 0; i < len; ++i)
    3771                 :       2659 :         TREE_VEC_ELT (vec, i) = size_int (i);
    3772                 :            : 
    3773                 :            :       return vec;
    3774                 :            :     }
    3775                 :            : }
    3776                 :            : 
    3777                 :            : /* Return a TREE_VEC for the expansion of built-in template parameter pack
    3778                 :            :    CALL.  */
    3779                 :            : 
    3780                 :            : static tree
    3781                 :       6132 : expand_builtin_pack_call (tree call, tree args, tsubst_flags_t complain,
    3782                 :            :                           tree in_decl)
    3783                 :            : {
    3784                 :       6132 :   if (!builtin_pack_call_p (call))
    3785                 :            :     return NULL_TREE;
    3786                 :            : 
    3787                 :       6132 :   tree fn = CALL_EXPR_FN (call);
    3788                 :            : 
    3789                 :       6132 :   if (id_equal (DECL_NAME (fn), "__integer_pack"))
    3790                 :       6132 :     return expand_integer_pack (call, args, complain, in_decl);
    3791                 :            : 
    3792                 :            :   return NULL_TREE;
    3793                 :            : }
    3794                 :            : 
    3795                 :            : /* Structure used to track the progress of find_parameter_packs_r.  */
    3796                 :            : struct find_parameter_pack_data
    3797                 :            : {
    3798                 :            :   /* TREE_LIST that will contain all of the parameter packs found by
    3799                 :            :      the traversal.  */
    3800                 :            :   tree* parameter_packs;
    3801                 :            : 
    3802                 :            :   /* Set of AST nodes that have been visited by the traversal.  */
    3803                 :            :   hash_set<tree> *visited;
    3804                 :            : 
    3805                 :            :   /* True iff we're making a type pack expansion.  */
    3806                 :            :   bool type_pack_expansion_p;
    3807                 :            : };
    3808                 :            : 
    3809                 :            : /* Identifies all of the argument packs that occur in a template
    3810                 :            :    argument and appends them to the TREE_LIST inside DATA, which is a
    3811                 :            :    find_parameter_pack_data structure. This is a subroutine of
    3812                 :            :    make_pack_expansion and uses_parameter_packs.  */
    3813                 :            : static tree
    3814                 :  432629000 : find_parameter_packs_r (tree *tp, int *walk_subtrees, void* data)
    3815                 :            : {
    3816                 :  432629000 :   tree t = *tp;
    3817                 :  432629000 :   struct find_parameter_pack_data* ppd =
    3818                 :            :     (struct find_parameter_pack_data*)data;
    3819                 :  432629000 :   bool parameter_pack_p = false;
    3820                 :            : 
    3821                 :            :   /* Don't look through typedefs; we are interested in whether a
    3822                 :            :      parameter pack is actually written in the expression/type we're
    3823                 :            :      looking at, not the target type.  */
    3824                 :  432629000 :   if (TYPE_P (t) && typedef_variant_p (t))
    3825                 :            :     {
    3826                 :            :       /* But do look at arguments for an alias template.  */
    3827                 :   11961200 :       if (tree tinfo = TYPE_ALIAS_TEMPLATE_INFO (t))
    3828                 :    8977640 :         cp_walk_tree (&TI_ARGS (tinfo),
    3829                 :            :                       &find_parameter_packs_r,
    3830                 :            :                       ppd, ppd->visited);
    3831                 :   11961200 :       *walk_subtrees = 0;
    3832                 :   11961200 :       return NULL_TREE;
    3833                 :            :     }
    3834                 :            : 
    3835                 :            :   /* Identify whether this is a parameter pack or not.  */
    3836                 :  420668000 :   switch (TREE_CODE (t))
    3837                 :            :     {
    3838                 :    4151850 :     case TEMPLATE_PARM_INDEX:
    3839                 :    4151850 :       if (TEMPLATE_PARM_PARAMETER_PACK (t))
    3840                 :            :         parameter_pack_p = true;
    3841                 :            :       break;
    3842                 :            : 
    3843                 :   79909200 :     case TEMPLATE_TYPE_PARM:
    3844                 :   79909200 :       t = TYPE_MAIN_VARIANT (t);
    3845                 :            :       /* FALLTHRU */
    3846                 :   80191500 :     case TEMPLATE_TEMPLATE_PARM:
    3847                 :            :       /* If the placeholder appears in the decl-specifier-seq of a function
    3848                 :            :          parameter pack (14.6.3), or the type-specifier-seq of a type-id that
    3849                 :            :          is a pack expansion, the invented template parameter is a template
    3850                 :            :          parameter pack.  */
    3851                 :   80191500 :       if (ppd->type_pack_expansion_p && is_auto (t))
    3852                 :        299 :         TEMPLATE_TYPE_PARAMETER_PACK (t) = true;
    3853                 :   80473800 :       if (TEMPLATE_TYPE_PARAMETER_PACK (t))
    3854                 :            :         parameter_pack_p = true;
    3855                 :            :       break;
    3856                 :            : 
    3857                 :   23272500 :     case FIELD_DECL:
    3858                 :   23272500 :     case PARM_DECL:
    3859                 :   46545100 :       if (DECL_PACK_P (t))
    3860                 :            :         {
    3861                 :            :           /* We don't want to walk into the type of a PARM_DECL,
    3862                 :            :              because we don't want to see the type parameter pack.  */
    3863                 :     163675 :           *walk_subtrees = 0;
    3864                 :     163675 :           parameter_pack_p = true;
    3865                 :            :         }
    3866                 :            :       break;
    3867                 :            : 
    3868                 :    8083560 :     case VAR_DECL:
    3869                 :   16167100 :       if (DECL_PACK_P (t))
    3870                 :            :         {
    3871                 :            :           /* We don't want to walk into the type of a variadic capture proxy,
    3872                 :            :              because we don't want to see the type parameter pack.  */
    3873                 :        319 :           *walk_subtrees = 0;
    3874                 :        319 :           parameter_pack_p = true;
    3875                 :            :         }
    3876                 :    8083240 :       else if (variable_template_specialization_p (t))
    3877                 :            :         {
    3878                 :          5 :           cp_walk_tree (&DECL_TI_ARGS (t),
    3879                 :            :                         find_parameter_packs_r,
    3880                 :            :                         ppd, ppd->visited);
    3881                 :          5 :           *walk_subtrees = 0;
    3882                 :            :         }
    3883                 :            :       break;
    3884                 :            : 
    3885                 :   13703400 :     case CALL_EXPR:
    3886                 :   13703400 :       if (builtin_pack_call_p (t))
    3887                 :            :         parameter_pack_p = true;
    3888                 :            :       break;
    3889                 :            : 
    3890                 :            :     case BASES:
    3891                 :            :       parameter_pack_p = true;
    3892                 :            :       break;
    3893                 :            :     default:
    3894                 :            :       /* Not a parameter pack.  */
    3895                 :            :       break;
    3896                 :            :     }
    3897                 :            : 
    3898                 :     163999 :   if (parameter_pack_p)
    3899                 :            :     {
    3900                 :            :       /* Add this parameter pack to the list.  */
    3901                 :    5264810 :       *ppd->parameter_packs = tree_cons (NULL_TREE, t, *ppd->parameter_packs);
    3902                 :            :     }
    3903                 :            : 
    3904                 :  420668000 :   if (TYPE_P (t))
    3905                 :  154210000 :     cp_walk_tree (&TYPE_CONTEXT (t),
    3906                 :            :                   &find_parameter_packs_r, ppd, ppd->visited);
    3907                 :            : 
    3908                 :            :   /* This switch statement will return immediately if we don't find a
    3909                 :            :      parameter pack.  ??? Should some of these be in cp_walk_subtrees?  */
    3910                 :  420668000 :   switch (TREE_CODE (t))
    3911                 :            :     {
    3912                 :      59579 :     case BOUND_TEMPLATE_TEMPLATE_PARM:
    3913                 :            :       /* Check the template itself.  */
    3914                 :     178737 :       cp_walk_tree (&TREE_TYPE (TYPE_TI_TEMPLATE (t)),
    3915                 :            :                     &find_parameter_packs_r, ppd, ppd->visited);
    3916                 :      59579 :       return NULL_TREE;
    3917                 :            : 
    3918                 :      18478 :     case DECL_EXPR:
    3919                 :      18478 :       {
    3920                 :      18478 :         tree decl = DECL_EXPR_DECL (t);
    3921                 :            :         /* Ignore the declaration of a capture proxy for a parameter pack.  */
    3922                 :      18478 :         if (is_capture_proxy (decl))
    3923                 :      12744 :           *walk_subtrees = 0;
    3924                 :      18478 :         if (is_typedef_decl (decl))
    3925                 :            :           /* Since we stop at typedefs above, we need to look through them at
    3926                 :            :              the point of the DECL_EXPR.  */
    3927                 :       1093 :           cp_walk_tree (&DECL_ORIGINAL_TYPE (decl),
    3928                 :            :                         &find_parameter_packs_r, ppd, ppd->visited);
    3929                 :            :         return NULL_TREE;
    3930                 :            :       }
    3931                 :            : 
    3932                 :    9963750 :     case TEMPLATE_DECL:
    3933                 :   19927500 :       if (!DECL_TEMPLATE_TEMPLATE_PARM_P (t))
    3934                 :            :         return NULL_TREE;
    3935                 :         84 :       cp_walk_tree (&TREE_TYPE (t),
    3936                 :            :                     &find_parameter_packs_r, ppd, ppd->visited);
    3937                 :         84 :       return NULL_TREE;
    3938                 :            : 
    3939                 :    4224930 :     case TYPENAME_TYPE:
    3940                 :    4224930 :       cp_walk_tree (&TYPENAME_TYPE_FULLNAME (t), &find_parameter_packs_r,
    3941                 :            :                    ppd, ppd->visited);
    3942                 :    4224930 :       *walk_subtrees = 0;
    3943                 :    4224930 :       return NULL_TREE;
    3944                 :            : 
    3945                 :    2150440 :     case TYPE_PACK_EXPANSION:
    3946                 :    2150440 :     case EXPR_PACK_EXPANSION:
    3947                 :    2150440 :       *walk_subtrees = 0;
    3948                 :    2150440 :       return NULL_TREE;
    3949                 :            : 
    3950                 :    2098720 :     case INTEGER_TYPE:
    3951                 :    2098720 :       cp_walk_tree (&TYPE_MAX_VALUE (t), &find_parameter_packs_r,
    3952                 :            :                     ppd, ppd->visited);
    3953                 :    2098720 :       *walk_subtrees = 0;
    3954                 :    2098720 :       return NULL_TREE;
    3955                 :            : 
    3956                 :   11836800 :     case IDENTIFIER_NODE:
    3957                 :   11836800 :       cp_walk_tree (&TREE_TYPE (t), &find_parameter_packs_r, ppd,
    3958                 :            :                     ppd->visited);
    3959                 :   11836800 :       *walk_subtrees = 0;
    3960                 :   11836800 :       return NULL_TREE;
    3961                 :            : 
    3962                 :      14672 :     case LAMBDA_EXPR:
    3963                 :      14672 :       {
    3964                 :            :         /* Look at explicit captures.  */
    3965                 :      27416 :         for (tree cap = LAMBDA_EXPR_CAPTURE_LIST (t);
    3966                 :      27416 :              cap; cap = TREE_CHAIN (cap))
    3967                 :      12744 :           cp_walk_tree (&TREE_VALUE (cap), &find_parameter_packs_r, ppd,
    3968                 :            :                         ppd->visited);
    3969                 :            :         /* Since we defer implicit capture, look in the parms and body.  */
    3970                 :      14672 :         tree fn = lambda_function (t);
    3971                 :      14672 :         cp_walk_tree (&TREE_TYPE (fn), &find_parameter_packs_r, ppd,
    3972                 :            :                       ppd->visited);
    3973                 :      14672 :         cp_walk_tree (&DECL_SAVED_TREE (fn), &find_parameter_packs_r, ppd,
    3974                 :            :                       ppd->visited);
    3975                 :      14672 :         *walk_subtrees = 0;
    3976                 :      14672 :         return NULL_TREE;
    3977                 :            :       }
    3978                 :            : 
    3979                 :     747802 :     case DECLTYPE_TYPE:
    3980                 :     747802 :       {
    3981                 :            :         /* When traversing a DECLTYPE_TYPE_EXPR, we need to set
    3982                 :            :            type_pack_expansion_p to false so that any placeholders
    3983                 :            :            within the expression don't get marked as parameter packs.  */
    3984                 :     747802 :         bool type_pack_expansion_p = ppd->type_pack_expansion_p;
    3985                 :     747802 :         ppd->type_pack_expansion_p = false;
    3986                 :     747802 :         cp_walk_tree (&DECLTYPE_TYPE_EXPR (t), &find_parameter_packs_r,
    3987                 :            :                       ppd, ppd->visited);
    3988                 :     747802 :         ppd->type_pack_expansion_p = type_pack_expansion_p;
    3989                 :     747802 :         *walk_subtrees = 0;
    3990                 :     747802 :         return NULL_TREE;
    3991                 :            :       }
    3992                 :            : 
    3993                 :       7196 :     case IF_STMT:
    3994                 :       7196 :       cp_walk_tree (&IF_COND (t), &find_parameter_packs_r,
    3995                 :            :                     ppd, ppd->visited);
    3996                 :       7196 :       cp_walk_tree (&THEN_CLAUSE (t), &find_parameter_packs_r,
    3997                 :            :                     ppd, ppd->visited);
    3998                 :       7196 :       cp_walk_tree (&ELSE_CLAUSE (t), &find_parameter_packs_r,
    3999                 :            :                     ppd, ppd->visited);
    4000                 :            :       /* Don't walk into IF_STMT_EXTRA_ARGS.  */
    4001                 :       7196 :       *walk_subtrees = 0;
    4002                 :       7196 :       return NULL_TREE;
    4003                 :            : 
    4004                 :            :     default:
    4005                 :            :       return NULL_TREE;
    4006                 :            :     }
    4007                 :            : 
    4008                 :            :   return NULL_TREE;
    4009                 :            : }
    4010                 :            : 
    4011                 :            : /* Determines if the expression or type T uses any parameter packs.  */
    4012                 :            : tree
    4013                 :    1272460 : uses_parameter_packs (tree t)
    4014                 :            : {
    4015                 :    1272460 :   tree parameter_packs = NULL_TREE;
    4016                 :    1272460 :   struct find_parameter_pack_data ppd;
    4017                 :    1272460 :   ppd.parameter_packs = &parameter_packs;
    4018                 :    1272460 :   ppd.visited = new hash_set<tree>;
    4019                 :    1272460 :   ppd.type_pack_expansion_p = false;
    4020                 :    1272460 :   cp_walk_tree (&t, &find_parameter_packs_r, &ppd, ppd.visited);
    4021                 :    2544920 :   delete ppd.visited;
    4022                 :    1272460 :   return parameter_packs;
    4023                 :            : }
    4024                 :            : 
    4025                 :            : /* Turn ARG, which may be an expression, type, or a TREE_LIST
    4026                 :            :    representation a base-class initializer into a parameter pack
    4027                 :            :    expansion. If all goes well, the resulting node will be an
    4028                 :            :    EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
    4029                 :            :    respectively.  */
    4030                 :            : tree
    4031                 :    5004940 : make_pack_expansion (tree arg, tsubst_flags_t complain)
    4032                 :            : {
    4033                 :    5004940 :   tree result;
    4034                 :    5004940 :   tree parameter_packs = NULL_TREE;
    4035                 :    5004940 :   bool for_types = false;
    4036                 :    5004940 :   struct find_parameter_pack_data ppd;
    4037                 :            : 
    4038                 :    5004940 :   if (!arg || arg == error_mark_node)
    4039                 :            :     return arg;
    4040                 :            : 
    4041                 :    5004930 :   if (TREE_CODE (arg) == TREE_LIST && TREE_PURPOSE (arg))
    4042                 :            :     {
    4043                 :            :       /* A TREE_LIST with a non-null TREE_PURPOSE is for a base
    4044                 :            :          class initializer.  In this case, the TREE_PURPOSE will be a
    4045                 :            :          _TYPE node (representing the base class expansion we're
    4046                 :            :          initializing) and the TREE_VALUE will be a TREE_LIST
    4047                 :            :          containing the initialization arguments. 
    4048                 :            : 
    4049                 :            :          The resulting expansion looks somewhat different from most
    4050                 :            :          expansions. Rather than returning just one _EXPANSION, we
    4051                 :            :          return a TREE_LIST whose TREE_PURPOSE is a
    4052                 :            :          TYPE_PACK_EXPANSION containing the bases that will be
    4053                 :            :          initialized.  The TREE_VALUE will be identical to the
    4054                 :            :          original TREE_VALUE, which is a list of arguments that will
    4055                 :            :          be passed to each base.  We do not introduce any new pack
    4056                 :            :          expansion nodes into the TREE_VALUE (although it is possible
    4057                 :            :          that some already exist), because the TREE_PURPOSE and
    4058                 :            :          TREE_VALUE all need to be expanded together with the same
    4059                 :            :          _EXPANSION node.  Note that the TYPE_PACK_EXPANSION in the
    4060                 :            :          resulting TREE_PURPOSE will mention the parameter packs in
    4061                 :            :          both the bases and the arguments to the bases.  */
    4062                 :         25 :       tree purpose;
    4063                 :         25 :       tree value;
    4064                 :         25 :       tree parameter_packs = NULL_TREE;
    4065                 :            : 
    4066                 :            :       /* Determine which parameter packs will be used by the base
    4067                 :            :          class expansion.  */
    4068                 :         25 :       ppd.visited = new hash_set<tree>;
    4069                 :         25 :       ppd.parameter_packs = &parameter_packs;
    4070                 :         25 :       ppd.type_pack_expansion_p = false;
    4071                 :         25 :       gcc_assert (TYPE_P (TREE_PURPOSE (arg)));
    4072                 :         25 :       cp_walk_tree (&TREE_PURPOSE (arg), &find_parameter_packs_r,
    4073                 :            :                     &ppd, ppd.visited);
    4074                 :            : 
    4075                 :         25 :       if (parameter_packs == NULL_TREE)
    4076                 :            :         {
    4077                 :          0 :           if (complain & tf_error)
    4078                 :          0 :             error ("base initializer expansion %qT contains no parameter packs",
    4079                 :            :                    arg);
    4080                 :          0 :           delete ppd.visited;
    4081                 :          0 :           return error_mark_node;
    4082                 :            :         }
    4083                 :            : 
    4084                 :         25 :       if (TREE_VALUE (arg) != void_type_node)
    4085                 :            :         {
    4086                 :            :           /* Collect the sets of parameter packs used in each of the
    4087                 :            :              initialization arguments.  */
    4088                 :         41 :           for (value = TREE_VALUE (arg); value; value = TREE_CHAIN (value))
    4089                 :            :             {
    4090                 :            :               /* Determine which parameter packs will be expanded in this
    4091                 :            :                  argument.  */
    4092                 :         22 :               cp_walk_tree (&TREE_VALUE (value), &find_parameter_packs_r, 
    4093                 :            :                             &ppd, ppd.visited);
    4094                 :            :             }
    4095                 :            :         }
    4096                 :            : 
    4097                 :         50 :       delete ppd.visited;
    4098                 :            : 
    4099                 :            :       /* Create the pack expansion type for the base type.  */
    4100                 :         25 :       purpose = cxx_make_type (TYPE_PACK_EXPANSION);
    4101                 :         25 :       SET_PACK_EXPANSION_PATTERN (purpose, TREE_PURPOSE (arg));
    4102                 :         50 :       PACK_EXPANSION_PARAMETER_PACKS (purpose) = parameter_packs;
    4103                 :         25 :       PACK_EXPANSION_LOCAL_P (purpose) = at_function_scope_p ();
    4104                 :            : 
    4105                 :            :       /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
    4106                 :            :          they will rarely be compared to anything.  */
    4107                 :         25 :       SET_TYPE_STRUCTURAL_EQUALITY (purpose);
    4108                 :            : 
    4109                 :         25 :       return tree_cons (purpose, TREE_VALUE (arg), NULL_TREE);
    4110                 :            :     }
    4111                 :            : 
    4112                 :    5004900 :   if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
    4113                 :    4589090 :     for_types = true;
    4114                 :            : 
    4115                 :            :   /* Build the PACK_EXPANSION_* node.  */
    4116                 :   10009800 :   result = for_types
    4117                 :    4589090 :      ? cxx_make_type (TYPE_PACK_EXPANSION)
    4118                 :     415815 :      : make_node (EXPR_PACK_EXPANSION);
    4119                 :    5004900 :   SET_PACK_EXPANSION_PATTERN (result, arg);
    4120                 :    5004900 :   if (TREE_CODE (result) == EXPR_PACK_EXPANSION)
    4121                 :            :     {
    4122                 :            :       /* Propagate type and const-expression information.  */
    4123                 :     415815 :       TREE_TYPE (result) = TREE_TYPE (arg);
    4124                 :     415815 :       TREE_CONSTANT (result) = TREE_CONSTANT (arg);
    4125                 :            :       /* Mark this read now, since the expansion might be length 0.  */
    4126                 :     415815 :       mark_exp_read (arg);
    4127                 :            :     }
    4128                 :            :   else
    4129                 :            :     /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
    4130                 :            :        they will rarely be compared to anything.  */
    4131                 :    4589090 :     SET_TYPE_STRUCTURAL_EQUALITY (result);
    4132                 :            : 
    4133                 :            :   /* Determine which parameter packs will be expanded.  */
    4134                 :    5004900 :   ppd.parameter_packs = &parameter_packs;
    4135                 :    5004900 :   ppd.visited = new hash_set<tree>;
    4136                 :    5004900 :   ppd.type_pack_expansion_p = TYPE_P (arg);
    4137                 :    5004900 :   cp_walk_tree (&arg, &find_parameter_packs_r, &ppd, ppd.visited);
    4138                 :   10009800 :   delete ppd.visited;
    4139                 :            : 
    4140                 :            :   /* Make sure we found some parameter packs.  */
    4141                 :    5004900 :   if (parameter_packs == NULL_TREE)
    4142                 :            :     {
    4143                 :         27 :       if (complain & tf_error)
    4144                 :            :         {
    4145                 :         21 :           if (TYPE_P (arg))
    4146                 :          3 :             error ("expansion pattern %qT contains no parameter packs", arg);
    4147                 :            :           else
    4148                 :         18 :             error ("expansion pattern %qE contains no parameter packs", arg);
    4149                 :            :         }
    4150                 :         27 :       return error_mark_node;
    4151                 :            :     }
    4152                 :    9593960 :   PACK_EXPANSION_PARAMETER_PACKS (result) = parameter_packs;
    4153                 :            : 
    4154                 :    5004880 :   PACK_EXPANSION_LOCAL_P (result) = at_function_scope_p ();
    4155                 :            : 
    4156                 :    5004880 :   return result;
    4157                 :            : }
    4158                 :            : 
    4159                 :            : /* Checks T for any "bare" parameter packs, which have not yet been
    4160                 :            :    expanded, and issues an error if any are found. This operation can
    4161                 :            :    only be done on full expressions or types (e.g., an expression
    4162                 :            :    statement, "if" condition, etc.), because we could have expressions like:
    4163                 :            : 
    4164                 :            :      foo(f(g(h(args)))...)
    4165                 :            : 
    4166                 :            :    where "args" is a parameter pack. check_for_bare_parameter_packs
    4167                 :            :    should not be called for the subexpressions args, h(args),
    4168                 :            :    g(h(args)), or f(g(h(args))), because we would produce erroneous
    4169                 :            :    error messages.
    4170                 :            : 
    4171                 :            :    Returns TRUE and emits an error if there were bare parameter packs,
    4172                 :            :    returns FALSE otherwise.  */
    4173                 :            : bool
    4174                 :  124687000 : check_for_bare_parameter_packs (tree t, location_t loc /* = UNKNOWN_LOCATION */)
    4175                 :            : {
    4176                 :  124687000 :   tree parameter_packs = NULL_TREE;
    4177                 :  124687000 :   struct find_parameter_pack_data ppd;
    4178                 :            : 
    4179                 :  124687000 :   if (!processing_template_decl || !t || t == error_mark_node)
    4180                 :            :     return false;
    4181                 :            : 
    4182                 :            :   /* A lambda might use a parameter pack from the containing context.  */
    4183                 :   53738000 :   if (current_class_type && LAMBDA_TYPE_P (current_class_type)
    4184                 :   72431000 :       && CLASSTYPE_TEMPLATE_INFO (current_class_type))
    4185                 :            :     return false;
    4186                 :            : 
    4187                 :   72177900 :   if (TREE_CODE (t) == TYPE_DECL)
    4188                 :          0 :     t = TREE_TYPE (t);
    4189                 :            : 
    4190                 :   72177900 :   ppd.parameter_packs = &parameter_packs;
    4191                 :   72177900 :   ppd.visited = new hash_set<tree>;
    4192                 :   72177900 :   ppd.type_pack_expansion_p = false;
    4193                 :   72177900 :   cp_walk_tree (&t, &find_parameter_packs_r, &ppd, ppd.visited);
    4194                 :  144356000 :   delete ppd.visited;
    4195                 :            : 
    4196                 :   72177900 :   if (parameter_packs)
    4197                 :            :     {
    4198                 :        234 :       if (loc == UNKNOWN_LOCATION)
    4199                 :        228 :         loc = cp_expr_loc_or_input_loc (t);
    4200                 :        234 :       error_at (loc, "parameter packs not expanded with %<...%>:");
    4201                 :        468 :       while (parameter_packs)
    4202                 :            :         {
    4203                 :        234 :           tree pack = TREE_VALUE (parameter_packs);
    4204                 :        234 :           tree name = NULL_TREE;
    4205                 :            : 
    4206                 :        234 :           if (TREE_CODE (pack) == TEMPLATE_TYPE_PARM
    4207                 :        234 :               || TREE_CODE (pack) == TEMPLATE_TEMPLATE_PARM)
    4208                 :        192 :             name = TYPE_NAME (pack);
    4209                 :         42 :           else if (TREE_CODE (pack) == TEMPLATE_PARM_INDEX)
    4210                 :         21 :             name = DECL_NAME (TEMPLATE_PARM_DECL (pack));
    4211                 :         21 :           else if (TREE_CODE (pack) == CALL_EXPR)
    4212                 :          3 :             name = DECL_NAME (CALL_EXPR_FN (pack));
    4213                 :            :           else
    4214                 :         18 :             name = DECL_NAME (pack);
    4215                 :            : 
    4216                 :        234 :           if (name)
    4217                 :        234 :             inform (loc, "        %qD", name);
    4218                 :            :           else
    4219                 :          0 :             inform (loc, "        %s", "<anonymous>");
    4220                 :            : 
    4221                 :        234 :           parameter_packs = TREE_CHAIN (parameter_packs);
    4222                 :            :         }
    4223                 :            : 
    4224                 :            :       return true;
    4225                 :            :     }
    4226                 :            : 
    4227                 :            :   return false;
    4228                 :            : }
    4229                 :            : 
    4230                 :            : /* Expand any parameter packs that occur in the template arguments in
    4231                 :            :    ARGS.  */
    4232                 :            : tree
    4233                 :  203683000 : expand_template_argument_pack (tree args)
    4234                 :            : {
    4235                 :  203683000 :   if (args == error_mark_node)
    4236                 :            :     return error_mark_node;
    4237                 :            : 
    4238                 :  203683000 :   tree result_args = NULL_TREE;
    4239                 :  407308000 :   int in_arg, out_arg = 0, nargs = args ? TREE_VEC_LENGTH (args) : 0;
    4240                 :  203683000 :   int num_result_args = -1;
    4241                 :  203683000 :   int non_default_args_count = -1;
    4242                 :            : 
    4243                 :            :   /* First, determine if we need to expand anything, and the number of
    4244                 :            :      slots we'll need.  */
    4245                 :  576861000 :   for (in_arg = 0; in_arg < nargs; ++in_arg)
    4246                 :            :     {
    4247                 :  373179000 :       tree arg = TREE_VEC_ELT (args, in_arg);
    4248                 :  373179000 :       if (arg == NULL_TREE)
    4249                 :            :         return args;
    4250                 :  373178000 :       if (ARGUMENT_PACK_P (arg))
    4251                 :            :         {
    4252                 :   50249300 :           int num_packed = TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg));
    4253                 :   25163800 :           if (num_result_args < 0)
    4254                 :   25163800 :             num_result_args = in_arg + num_packed;
    4255                 :            :           else
    4256                 :          0 :             num_result_args += num_packed;
    4257                 :            :         }
    4258                 :            :       else
    4259                 :            :         {
    4260                 :  348014000 :           if (num_result_args >= 0)
    4261                 :          0 :             num_result_args++;
    4262                 :            :         }
    4263                 :            :     }
    4264                 :            : 
    4265                 :            :   /* If no expansion is necessary, we're done.  */
    4266                 :  203682000 :   if (num_result_args < 0)
    4267                 :            :     return args;
    4268                 :            : 
    4269                 :            :   /* Expand arguments.  */
    4270                 :   25163800 :   result_args = make_tree_vec (num_result_args);
    4271                 :   25163800 :   if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (args))
    4272                 :   25162600 :     non_default_args_count =
    4273                 :   25162600 :       GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args);
    4274                 :   69711600 :   for (in_arg = 0; in_arg < nargs; ++in_arg)
    4275                 :            :     {
    4276                 :   44547900 :       tree arg = TREE_VEC_ELT (args, in_arg);
    4277                 :   44547900 :       if (ARGUMENT_PACK_P (arg))
    4278                 :            :         {
    4279                 :   50249300 :           tree packed = ARGUMENT_PACK_ARGS (arg);
    4280                 :   25163800 :           int i, num_packed = TREE_VEC_LENGTH (packed);
    4281                 :   68623800 :           for (i = 0; i < num_packed; ++i, ++out_arg)
    4282                 :   43460100 :             TREE_VEC_ELT (result_args, out_arg) = TREE_VEC_ELT(packed, i);
    4283                 :   25163800 :           if (non_default_args_count > 0)
    4284                 :   25162600 :             non_default_args_count += num_packed - 1;
    4285                 :            :         }
    4286                 :            :       else
    4287                 :            :         {
    4288                 :   19384100 :           TREE_VEC_ELT (result_args, out_arg) = arg;
    4289                 :   19384100 :           ++out_arg;
    4290                 :            :         }
    4291                 :            :     }
    4292                 :   25163800 :   if (non_default_args_count >= 0)
    4293                 :   25162600 :     SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (result_args, non_default_args_count);
    4294                 :            :   return result_args;
    4295                 :            : }
    4296                 :            : 
    4297                 :            : /* Checks if DECL shadows a template parameter.
    4298                 :            : 
    4299                 :            :    [temp.local]: A template-parameter shall not be redeclared within its
    4300                 :            :    scope (including nested scopes).
    4301                 :            : 
    4302                 :            :    Emits an error and returns TRUE if the DECL shadows a parameter,
    4303                 :            :    returns FALSE otherwise.  */
    4304                 :            : 
    4305                 :            : bool
    4306                 :  314490000 : check_template_shadow (tree decl)
    4307                 :            : {
    4308                 :  314490000 :   tree olddecl;
    4309                 :            : 
    4310                 :            :   /* If we're not in a template, we can't possibly shadow a template
    4311                 :            :      parameter.  */
    4312                 :  314490000 :   if (!current_template_parms)
    4313                 :            :     return true;
    4314                 :            : 
    4315                 :            :   /* Figure out what we're shadowing.  */
    4316                 :   59432600 :   decl = OVL_FIRST (decl);
    4317                 :   59432600 :   olddecl = innermost_non_namespace_value (DECL_NAME (decl));
    4318                 :            : 
    4319                 :            :   /* If there's no previous binding for this name, we're not shadowing
    4320                 :            :      anything, let alone a template parameter.  */
    4321                 :   59432600 :   if (!olddecl)
    4322                 :            :     return true;
    4323                 :            : 
    4324                 :            :   /* If we're not shadowing a template parameter, we're done.  Note
    4325                 :            :      that OLDDECL might be an OVERLOAD (or perhaps even an
    4326                 :            :      ERROR_MARK), so we can't just blithely assume it to be a _DECL
    4327                 :            :      node.  */
    4328                 :    6153050 :   if (!DECL_P (olddecl) || !DECL_TEMPLATE_PARM_P (olddecl))
    4329                 :            :     return true;
    4330                 :            : 
    4331                 :            :   /* We check for decl != olddecl to avoid bogus errors for using a
    4332                 :            :      name inside a class.  We check TPFI to avoid duplicate errors for
    4333                 :            :      inline member templates.  */
    4334                 :        192 :   if (decl == olddecl
    4335                 :        384 :       || (DECL_TEMPLATE_PARM_P (decl)
    4336                 :        184 :           && TEMPLATE_PARMS_FOR_INLINE (current_template_parms)))
    4337                 :            :     return true;
    4338                 :            : 
    4339                 :            :   /* Don't complain about the injected class name, as we've already
    4340                 :            :      complained about the class itself.  */
    4341                 :        148 :   if (DECL_SELF_REFERENCE_P (decl))
    4342                 :            :     return false;
    4343                 :            : 
    4344                 :        140 :   if (DECL_TEMPLATE_PARM_P (decl))
    4345                 :         48 :     error ("declaration of template parameter %q+D shadows "
    4346                 :            :            "template parameter", decl);
    4347                 :            :   else
    4348                 :         92 :     error ("declaration of %q+#D shadows template parameter", decl);
    4349                 :        140 :   inform (DECL_SOURCE_LOCATION (olddecl),
    4350                 :            :           "template parameter %qD declared here", olddecl);
    4351                 :        140 :   return false;
    4352                 :            : }
    4353                 :            : 
    4354                 :            : /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
    4355                 :            :    ORIG_LEVEL, DECL, and TYPE.  */
    4356                 :            : 
    4357                 :            : static tree
    4358                 :   17313200 : build_template_parm_index (int index,
    4359                 :            :                            int level,
    4360                 :            :                            int orig_level,
    4361                 :            :                            tree decl,
    4362                 :            :                            tree type)
    4363                 :            : {
    4364                 :   17313200 :   tree t = make_node (TEMPLATE_PARM_INDEX);
    4365                 :   17313200 :   TEMPLATE_PARM_IDX (t) = index;
    4366                 :   17313200 :   TEMPLATE_PARM_LEVEL (t) = level;
    4367                 :   17313200 :   TEMPLATE_PARM_ORIG_LEVEL (t) = orig_level;
    4368                 :   17313200 :   TEMPLATE_PARM_DECL (t) = decl;
    4369                 :   17313200 :   TREE_TYPE (t) = type;
    4370                 :   17313200 :   TREE_CONSTANT (t) = TREE_CONSTANT (decl);
    4371                 :   17313200 :   TREE_READONLY (t) = TREE_READONLY (decl);
    4372                 :            : 
    4373                 :   17313200 :   return t;
    4374                 :            : }
    4375                 :            : 
    4376                 :            : /* Find the canonical type parameter for the given template type
    4377                 :            :    parameter.  Returns the canonical type parameter, which may be TYPE
    4378                 :            :    if no such parameter existed.  */
    4379                 :            : 
    4380                 :            : static tree
    4381                 :   15128700 : canonical_type_parameter (tree type)
    4382                 :            : {
    4383                 :   15128700 :   tree list;
    4384                 :   15184400 :   int idx = TEMPLATE_TYPE_IDX (type);
    4385                 :   15128700 :   if (!canonical_template_parms)
    4386                 :      26777 :     vec_alloc (canonical_template_parms, idx + 1);
    4387                 :            : 
    4388                 :   15128700 :   if (canonical_template_parms->length () <= (unsigned) idx)
    4389                 :      62959 :     vec_safe_grow_cleared (canonical_template_parms, idx + 1);
    4390                 :            : 
    4391                 :   15128700 :   list = (*canonical_template_parms)[idx];
    4392                 :  446134000 :   while (list && !comptypes (type, TREE_VALUE (list), COMPARE_STRUCTURAL))
    4393                 :  208052000 :     list = TREE_CHAIN (list);
    4394                 :            : 
    4395                 :   15128700 :   if (list)
    4396                 :   14902600 :     return TREE_VALUE (list);
    4397                 :            :   else
    4398                 :            :     {
    4399                 :     452336 :       (*canonical_template_parms)[idx]
    4400                 :     226168 :         = tree_cons (NULL_TREE, type, (*canonical_template_parms)[idx]);
    4401                 :     226168 :       return type;
    4402                 :            :     }
    4403                 :            : }
    4404                 :            : 
    4405                 :            : /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
    4406                 :            :    TEMPLATE_PARM_LEVEL has been decreased by LEVELS.  If such a
    4407                 :            :    TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
    4408                 :            :    new one is created.  */
    4409                 :            : 
    4410                 :            : static tree
    4411                 :    3302480 : reduce_template_parm_level (tree index, tree type, int levels, tree args,
    4412                 :            :                             tsubst_flags_t complain)
    4413                 :            : {
    4414                 :    3302480 :   if (TEMPLATE_PARM_DESCENDANTS (index) == NULL_TREE
    4415                 :    1606300 :       || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index))
    4416                 :    1606300 :           != TEMPLATE_PARM_LEVEL (index) - levels)
    4417                 :    4907830 :       || !same_type_p (type, TREE_TYPE (TEMPLATE_PARM_DESCENDANTS (index))))
    4418                 :            :     {
    4419                 :    2620160 :       tree orig_decl = TEMPLATE_PARM_DECL (index);
    4420                 :            : 
    4421                 :    2620160 :       tree decl = build_decl (DECL_SOURCE_LOCATION (orig_decl),
    4422                 :    2620160 :                               TREE_CODE (orig_decl), DECL_NAME (orig_decl),
    4423                 :            :                               type);
    4424                 :    2620160 :       TREE_CONSTANT (decl) = TREE_CONSTANT (orig_decl);
    4425                 :    2620160 :       TREE_READONLY (decl) = TREE_READONLY (orig_decl);
    4426                 :    2620160 :       DECL_ARTIFICIAL (decl) = 1;
    4427                 :    2620160 :       SET_DECL_TEMPLATE_PARM_P (decl);
    4428                 :            : 
    4429                 :    2620160 :       tree tpi = build_template_parm_index (TEMPLATE_PARM_IDX (index),
    4430                 :    2620160 :                                             TEMPLATE_PARM_LEVEL (index) - levels,
    4431                 :    2620160 :                                             TEMPLATE_PARM_ORIG_LEVEL (index),
    4432                 :            :                                             decl, type);
    4433                 :    2620160 :       TEMPLATE_PARM_DESCENDANTS (index) = tpi;
    4434                 :    5240320 :       TEMPLATE_PARM_PARAMETER_PACK (tpi)
    4435                 :    2620160 :         = TEMPLATE_PARM_PARAMETER_PACK (index);
    4436                 :            : 
    4437                 :            :         /* Template template parameters need this.  */
    4438                 :    2620160 :       tree inner = decl;
    4439                 :    2620160 :       if (TREE_CODE (decl) == TEMPLATE_DECL)
    4440                 :            :         {
    4441                 :      37422 :           inner = build_decl (DECL_SOURCE_LOCATION (decl),
    4442                 :      37422 :                               TYPE_DECL, DECL_NAME (decl), type);
    4443                 :      37422 :           DECL_TEMPLATE_RESULT (decl) = inner;
    4444                 :      37422 :           DECL_ARTIFICIAL (inner) = true;
    4445                 :      74844 :           DECL_TEMPLATE_PARMS (decl) = tsubst_template_parms
    4446                 :      37422 :             (DECL_TEMPLATE_PARMS (orig_decl), args, complain);
    4447                 :            :         }
    4448                 :            : 
    4449                 :            :       /* Attach the TPI to the decl.  */
    4450                 :    2620160 :       if (TREE_CODE (inner) == TYPE_DECL)
    4451                 :    2497020 :         TEMPLATE_TYPE_PARM_INDEX (type) = tpi;
    4452                 :            :       else
    4453                 :     168712 :         DECL_INITIAL (decl) = tpi;
    4454                 :            :     }
    4455                 :            : 
    4456                 :    3302480 :   return TEMPLATE_PARM_DESCENDANTS (index);
    4457                 :            : }
    4458                 :            : 
    4459                 :            : /* Process information from new template parameter PARM and append it
    4460                 :            :    to the LIST being built.  This new parameter is a non-type
    4461                 :            :    parameter iff IS_NON_TYPE is true. This new parameter is a
    4462                 :            :    parameter pack iff IS_PARAMETER_PACK is true.  The location of PARM
    4463                 :            :    is in PARM_LOC.  */
    4464                 :            : 
    4465                 :            : tree
    4466                 :   14079700 : process_template_parm (tree list, location_t parm_loc, tree parm,
    4467                 :            :                        bool is_non_type, bool is_parameter_pack)
    4468                 :            : {
    4469                 :   14079700 :   tree decl = 0;
    4470                 :   14079700 :   int idx = 0;
    4471                 :            : 
    4472                 :   14079700 :   gcc_assert (TREE_CODE (parm) == TREE_LIST);
    4473                 :   14079700 :   tree defval = TREE_PURPOSE (parm);
    4474                 :   14079700 :   tree constr = TREE_TYPE (parm);
    4475                 :            : 
    4476                 :   14079700 :   if (list)
    4477                 :            :     {
    4478                 :    6493000 :       tree p = tree_last (list);
    4479                 :            : 
    4480                 :   12986000 :       if (p && TREE_VALUE (p) != error_mark_node)
    4481                 :            :         {
    4482                 :    6492980 :           p = TREE_VALUE (p);
    4483                 :    6492980 :           if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
    4484                 :    6018060 :             idx = TEMPLATE_TYPE_IDX (TREE_TYPE (p));
    4485                 :            :           else
    4486                 :     513750 :             idx = TEMPLATE_PARM_IDX (DECL_INITIAL (p));
    4487                 :            :         }
    4488                 :            : 
    4489                 :    6493000 :       ++idx;
    4490                 :            :     }
    4491                 :            : 
    4492                 :   14079700 :   if (is_non_type)
    4493                 :            :     {
    4494                 :    1166800 :       parm = TREE_VALUE (parm);
    4495                 :            : 
    4496                 :    1166800 :       SET_DECL_TEMPLATE_PARM_P (parm);
    4497                 :            : 
    4498                 :    1166800 :       if (TREE_TYPE (parm) != error_mark_node)
    4499                 :            :         {
    4500                 :            :           /* [temp.param]
    4501                 :            : 
    4502                 :            :              The top-level cv-qualifiers on the template-parameter are
    4503                 :            :              ignored when determining its type.  */
    4504                 :    1166730 :           TREE_TYPE (parm) = TYPE_MAIN_VARIANT (TREE_TYPE (parm));
    4505                 :    1166730 :           if (invalid_nontype_parm_type_p (TREE_TYPE (parm), 1))
    4506                 :        132 :             TREE_TYPE (parm) = error_mark_node;
    4507                 :    1166600 :           else if (uses_parameter_packs (TREE_TYPE (parm))
    4508                 :         45 :                    && !is_parameter_pack
    4509                 :            :                    /* If we're in a nested template parameter list, the template
    4510                 :            :                       template parameter could be a parameter pack.  */
    4511                 :    1166610 :                    && processing_template_parmlist == 1)
    4512                 :            :             {
    4513                 :            :               /* This template parameter is not a parameter pack, but it
    4514                 :            :                  should be. Complain about "bare" parameter packs.  */
    4515                 :         12 :               check_for_bare_parameter_packs (TREE_TYPE (parm));
    4516                 :            : 
    4517                 :            :               /* Recover by calling this a parameter pack.  */
    4518                 :         12 :               is_parameter_pack = true;
    4519                 :            :             }
    4520                 :            :         }
    4521                 :            : 
    4522                 :            :       /* A template parameter is not modifiable.  */
    4523                 :    1166800 :       TREE_CONSTANT (parm) = 1;
    4524                 :    1166800 :       TREE_READONLY (parm) = 1;
    4525                 :    1166800 :       decl = build_decl (parm_loc,
    4526                 :    1166800 :                          CONST_DECL, DECL_NAME (parm), TREE_TYPE (parm));
    4527                 :    1166800 :       TREE_CONSTANT (decl) = 1;
    4528                 :    1166800 :       TREE_READONLY (decl) = 1;
    4529                 :    1166800 :       DECL_INITIAL (parm) = DECL_INITIAL (decl)
    4530                 :    1166800 :         = build_template_parm_index (idx, processing_template_decl,
    4531                 :            :                                      processing_template_decl,
    4532                 :    1166800 :                                      decl, TREE_TYPE (parm));
    4533                 :            : 
    4534                 :    1166800 :       TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm))
    4535                 :    1166800 :         = is_parameter_pack;
    4536                 :            :     }
    4537                 :            :   else
    4538                 :            :     {
    4539                 :   12912900 :       tree t;
    4540                 :   12912900 :       parm = TREE_VALUE (TREE_VALUE (parm));
    4541                 :            : 
    4542                 :   12912900 :       if (parm && TREE_CODE (parm) == TEMPLATE_DECL)
    4543                 :            :         {
    4544                 :      55643 :           t = cxx_make_type (TEMPLATE_TEMPLATE_PARM);
    4545                 :            :           /* This is for distinguishing between real templates and template
    4546                 :            :              template parameters */
    4547                 :      55643 :           TREE_TYPE (parm) = t;
    4548                 :      55643 :           TREE_TYPE (DECL_TEMPLATE_RESULT (parm)) = t;
    4549                 :      55643 :           decl = parm;
    4550                 :            :         }
    4551                 :            :       else
    4552                 :            :         {
    4553                 :   12857200 :           t = cxx_make_type (TEMPLATE_TYPE_PARM);
    4554                 :            :           /* parm is either IDENTIFIER_NODE or NULL_TREE.  */
    4555                 :   12857200 :           decl = build_decl (parm_loc,
    4556                 :            :                              TYPE_DECL, parm, t);
    4557                 :            :         }
    4558                 :            : 
    4559                 :   12912900 :       TYPE_NAME (t) = decl;
    4560                 :   12912900 :       TYPE_STUB_DECL (t) = decl;
    4561                 :   12912900 :       parm = decl;
    4562                 :   25825700 :       TEMPLATE_TYPE_PARM_INDEX (t)
    4563                 :   12912900 :         = build_template_parm_index (idx, processing_template_decl,
    4564                 :            :                                      processing_template_decl,
    4565                 :   12912900 :                                      decl, TREE_TYPE (parm));
    4566                 :   12968500 :       TEMPLATE_TYPE_PARAMETER_PACK (t) = is_parameter_pack;
    4567                 :   12912900 :       TYPE_CANONICAL (t) = canonical_type_parameter (t);
    4568                 :            :     }
    4569                 :   14079700 :   DECL_ARTIFICIAL (decl) = 1;
    4570                 :   14079700 :   SET_DECL_TEMPLATE_PARM_P (decl);
    4571                 :            : 
    4572                 :            :   /* Build requirements for the type/template parameter.
    4573                 :            :      This must be done after SET_DECL_TEMPLATE_PARM_P or
    4574                 :            :      process_template_parm could fail. */
    4575                 :   14079700 :   tree reqs = finish_shorthand_constraint (parm, constr);
    4576                 :            : 
    4577                 :   14079700 :   decl = pushdecl (decl);
    4578                 :   14079700 :   if (!is_non_type)
    4579                 :   12912900 :     parm = decl;
    4580                 :            : 
    4581                 :            :   /* Build the parameter node linking the parameter declaration,
    4582                 :            :      its default argument (if any), and its constraints (if any). */
    4583                 :   14079700 :   parm = build_tree_list (defval, parm);
    4584                 :   14079700 :   TEMPLATE_PARM_CONSTRAINTS (parm) = reqs;
    4585                 :            : 
    4586                 :   14079700 :   return chainon (list, parm);
    4587                 :            : }
    4588                 :            : 
    4589                 :            : /* The end of a template parameter list has been reached.  Process the
    4590                 :            :    tree list into a parameter vector, converting each parameter into a more
    4591                 :            :    useful form.  Type parameters are saved as IDENTIFIER_NODEs, and others
    4592                 :            :    as PARM_DECLs.  */
    4593                 :            : 
    4594                 :            : tree
    4595                 :    7577700 : end_template_parm_list (tree parms)
    4596                 :            : {
    4597                 :    7577700 :   int nparms;
    4598                 :    7577700 :   tree parm, next;
    4599                 :    7577700 :   tree saved_parmlist = make_tree_vec (list_length (parms));
    4600                 :            : 
    4601                 :            :   /* Pop the dummy parameter level and add the real one.  */
    4602                 :    7577700 :   current_template_parms = TREE_CHAIN (current_template_parms);
    4603                 :            : 
    4604                 :   15155400 :   current_template_parms
    4605                 :    7577700 :     = tree_cons (size_int (processing_template_decl),
    4606                 :            :                  saved_parmlist, current_template_parms);
    4607                 :            : 
    4608                 :   21647600 :   for (parm = parms, nparms = 0; parm; parm = next, nparms++)
    4609                 :            :     {
    4610                 :   14069900 :       next = TREE_CHAIN (parm);
    4611                 :   14069900 :       TREE_VEC_ELT (saved_parmlist, nparms) = parm;
    4612                 :   14069900 :       TREE_CHAIN (parm) = NULL_TREE;
    4613                 :            :     }
    4614                 :            : 
    4615                 :    7577700 :   --processing_template_parmlist;
    4616                 :            : 
    4617                 :    7577700 :   return saved_parmlist;
    4618                 :            : }
    4619                 :            : 
    4620                 :            : // Explicitly indicate the end of the template parameter list. We assume
    4621                 :            : // that the current template parameters have been constructed and/or
    4622                 :            : // managed explicitly, as when creating new template template parameters
    4623                 :            : // from a shorthand constraint.
    4624                 :            : void
    4625                 :          7 : end_template_parm_list ()
    4626                 :            : {
    4627                 :          7 :   --processing_template_parmlist;
    4628                 :          7 : }
    4629                 :            : 
    4630                 :            : /* end_template_decl is called after a template declaration is seen.  */
    4631                 :            : 
    4632                 :            : void
    4633                 :    7586780 : end_template_decl (void)
    4634                 :            : {
    4635                 :    7586780 :   reset_specialization ();
    4636                 :            : 
    4637                 :    7586780 :   if (! processing_template_decl)
    4638                 :            :     return;
    4639                 :            : 
    4640                 :            :   /* This matches the pushlevel in begin_template_parm_list.  */
    4641                 :    7586780 :   finish_scope ();
    4642                 :            : 
    4643                 :    7586780 :   --processing_template_decl;
    4644                 :    7586780 :   current_template_parms = TREE_CHAIN (current_template_parms);
    4645                 :            : }
    4646                 :            : 
    4647                 :            : /* Takes a TREE_LIST representing a template parameter and convert it
    4648                 :            :    into an argument suitable to be passed to the type substitution
    4649                 :            :    functions.  Note that If the TREE_LIST contains an error_mark
    4650                 :            :    node, the returned argument is error_mark_node.  */
    4651                 :            : 
    4652                 :            : tree
    4653                 :   50093200 : template_parm_to_arg (tree t)
    4654                 :            : {
    4655                 :            : 
    4656                 :   50093200 :   if (t == NULL_TREE
    4657                 :   50093200 :       || TREE_CODE (t) != TREE_LIST)
    4658                 :            :     return t;
    4659                 :            : 
    4660                 :   50093200 :   if (error_operand_p (TREE_VALUE (t)))
    4661                 :            :     return error_mark_node;
    4662                 :            : 
    4663                 :   50092700 :   t = TREE_VALUE (t);
    4664                 :            : 
    4665                 :   50092700 :   if (TREE_CODE (t) == TYPE_DECL
    4666                 :    4241050 :       || TREE_CODE (t) == TEMPLATE_DECL)
    4667                 :            :     {
    4668                 :   46068500 :       t = TREE_TYPE (t);
    4669                 :            : 
    4670                 :   46285500 :       if (TEMPLATE_TYPE_PARAMETER_PACK (t))
    4671                 :            :         {
    4672                 :            :           /* Turn this argument into a TYPE_ARGUMENT_PACK
    4673                 :            :              with a single element, which expands T.  */
    4674                 :    1697430 :           tree vec = make_tree_vec (1);
    4675                 :    1697430 :           if (CHECKING_P)
    4676                 :    1697430 :             SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (vec, TREE_VEC_LENGTH (vec));
    4677                 :            : 
    4678                 :    1697430 :           TREE_VEC_ELT (vec, 0) = make_pack_expansion (t);
    4679                 :            : 
    4680                 :    1697430 :           t = cxx_make_type (TYPE_ARGUMENT_PACK);
    4681                 :    1697430 :           SET_ARGUMENT_PACK_ARGS (t, vec);
    4682                 :            :         }
    4683                 :            :     }
    4684                 :            :   else
    4685                 :            :     {
    4686                 :    4024140 :       t = DECL_INITIAL (t);
    4687                 :            : 
    4688                 :    4024140 :       if (TEMPLATE_PARM_PARAMETER_PACK (t))
    4689                 :            :         {
    4690                 :            :           /* Turn this argument into a NONTYPE_ARGUMENT_PACK
    4691                 :            :              with a single element, which expands T.  */
    4692                 :      72204 :           tree vec = make_tree_vec (1);
    4693                 :      72204 :           if (CHECKING_P)
    4694                 :      72204 :             SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (vec, TREE_VEC_LENGTH (vec));
    4695                 :            : 
    4696                 :      72204 :           t = convert_from_reference (t);
    4697                 :      72204 :           TREE_VEC_ELT (vec, 0) = make_pack_expansion (t);
    4698                 :            : 
    4699                 :      72204 :           t  = make_node (NONTYPE_ARGUMENT_PACK);
    4700                 :      72204 :           SET_ARGUMENT_PACK_ARGS (t, vec);
    4701                 :            :         }
    4702                 :            :       else
    4703                 :    3951930 :         t = convert_from_reference (t);
    4704                 :            :     }
    4705                 :            :   return t;
    4706                 :            : }
    4707                 :            : 
    4708                 :            : /* Given a single level of template parameters (a TREE_VEC), return it
    4709                 :            :    as a set of template arguments.  */
    4710                 :            : 
    4711                 :            : tree
    4712                 :   24330000 : template_parms_level_to_args (tree parms)
    4713                 :            : {
    4714                 :   24330000 :   tree a = copy_node (parms);
    4715                 :   24330000 :   TREE_TYPE (a) = NULL_TREE;
    4716                 :   74259700 :   for (int i = TREE_VEC_LENGTH (a) - 1; i >= 0; --i)
    4717                 :   49929600 :     TREE_VEC_ELT (a, i) = template_parm_to_arg (TREE_VEC_ELT (a, i));
    4718                 :            : 
    4719                 :   24330000 :   if (CHECKING_P)
    4720                 :   24330000 :     SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (a, TREE_VEC_LENGTH (a));
    4721                 :            : 
    4722                 :   24330000 :   return a;
    4723                 :            : }
    4724                 :            : 
    4725                 :            : /* Given a set of template parameters, return them as a set of template
    4726                 :            :    arguments.  The template parameters are represented as a TREE_VEC, in
    4727                 :            :    the form documented in cp-tree.h for template arguments.  */
    4728                 :            : 
    4729                 :            : tree
    4730                 :   21480400 : template_parms_to_args (tree parms)
    4731                 :            : {
    4732                 :   21480400 :   tree header;
    4733                 :   21480400 :   tree args = NULL_TREE;
    4734                 :   21480400 :   int length = TMPL_PARMS_DEPTH (parms);
    4735                 :   21480400 :   int l = length;
    4736                 :            : 
    4737                 :            :   /* If there is only one level of template parameters, we do not
    4738                 :            :      create a TREE_VEC of TREE_VECs.  Instead, we return a single
    4739                 :            :      TREE_VEC containing the arguments.  */
    4740                 :   21480400 :   if (length > 1)
    4741                 :    2447150 :     args = make_tree_vec (length);
    4742                 :            : 
    4743                 :   45421100 :   for (header = parms; header; header = TREE_CHAIN (header))
    4744                 :            :     {
    4745                 :   23940700 :       tree a = template_parms_level_to_args (TREE_VALUE (header));
    4746                 :            : 
    4747                 :   23940700 :       if (length > 1)
    4748                 :    4907520 :         TREE_VEC_ELT (args, --l) = a;
    4749                 :            :       else
    4750                 :            :         args = a;
    4751                 :            :     }
    4752                 :            : 
    4753                 :   21480400 :   return args;
    4754                 :            : }
    4755                 :            : 
    4756                 :            : /* Within the declaration of a template, return the currently active
    4757                 :            :    template parameters as an argument TREE_VEC.  */
    4758                 :            : 
    4759                 :            : static tree
    4760                 :   21241900 : current_template_args (void)
    4761                 :            : {
    4762                 :          0 :   return template_parms_to_args (current_template_parms);
    4763                 :            : }
    4764                 :            : 
    4765                 :            : /* Return the fully generic arguments for of TMPL, i.e. what
    4766                 :            :    current_template_args would be while parsing it.  */
    4767                 :            : 
    4768                 :            : tree
    4769                 :    2640840 : generic_targs_for (tree tmpl)
    4770                 :            : {
    4771                 :    2640840 :   if (tmpl == NULL_TREE)
    4772                 :            :     return NULL_TREE;
    4773                 :    1251590 :   if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl)
    4774                 :    2503180 :       || DECL_TEMPLATE_SPECIALIZATION (tmpl))
    4775                 :            :     /* DECL_TEMPLATE_RESULT doesn't have the arguments we want.  For a template
    4776                 :            :        template parameter, it has no TEMPLATE_INFO; for a partial
    4777                 :            :        specialization, it has the arguments for the primary template, and we
    4778                 :            :        want the arguments for the partial specialization.  */;
    4779                 :    1114610 :   else if (tree result = DECL_TEMPLATE_RESULT (tmpl))
    4780                 :    1114610 :     if (tree ti = get_template_info (result))
    4781                 :    1044450 :       return TI_ARGS (ti);
    4782                 :     207139 :   return template_parms_to_args (DECL_TEMPLATE_PARMS (tmpl));
    4783                 :            : }
    4784                 :            : 
    4785                 :            : /* Update the declared TYPE by doing any lookups which were thought to be
    4786                 :            :    dependent, but are not now that we know the SCOPE of the declarator.  */
    4787                 :            : 
    4788                 :            : tree
    4789                 :   14693100 : maybe_update_decl_type (tree orig_type, tree scope)
    4790                 :            : {
    4791                 :   14693100 :   tree type = orig_type;
    4792                 :            : 
    4793                 :   14693100 :   if (type == NULL_TREE)
    4794                 :            :     return type;
    4795                 :            : 
    4796                 :   13966900 :   if (TREE_CODE (orig_type) == TYPE_DECL)
    4797                 :    6436580 :     type = TREE_TYPE (type);
    4798                 :            : 
    4799                 :     507408 :   if (scope && TYPE_P (scope) && dependent_type_p (scope)
    4800                 :     420703 :       && dependent_type_p (type)
    4801                 :            :       /* Don't bother building up the args in this case.  */
    4802                 :   14191300 :       && TREE_CODE (type) != TEMPLATE_TYPE_PARM)
    4803                 :            :     {
    4804                 :            :       /* tsubst in the args corresponding to the template parameters,
    4805                 :            :          including auto if present.  Most things will be unchanged, but
    4806                 :            :          make_typename_type and tsubst_qualified_id will resolve
    4807                 :            :          TYPENAME_TYPEs and SCOPE_REFs that were previously dependent.  */
    4808                 :     158735 :       tree args = current_template_args ();
    4809                 :     158735 :       tree auto_node = type_uses_auto (type);
    4810                 :     158735 :       tree pushed;
    4811                 :     158735 :       if (auto_node)
    4812                 :            :         {
    4813                 :          0 :           tree auto_vec = make_tree_vec (1);
    4814                 :          0 :           TREE_VEC_ELT (auto_vec, 0) = auto_node;
    4815                 :          0 :           args = add_to_template_args (args, auto_vec);
    4816                 :            :         }
    4817                 :     158735 :       pushed = push_scope (scope);
    4818                 :     158735 :       type = tsubst (type, args, tf_warning_or_error, NULL_TREE);
    4819                 :     158735 :       if (pushed)
    4820                 :     158731 :         pop_scope (scope);
    4821                 :            :     }
    4822                 :            : 
    4823                 :   13966900 :   if (type == error_mark_node)
    4824                 :            :     return orig_type;
    4825                 :            : 
    4826                 :   13966400 :   if (TREE_CODE (orig_type) == TYPE_DECL)
    4827                 :            :     {
    4828                 :    6436540 :       if (same_type_p (type, TREE_TYPE (orig_type)))
    4829                 :            :         type = orig_type;
    4830                 :            :       else
    4831                 :       4456 :         type = TYPE_NAME (type);
    4832                 :            :     }
    4833                 :            :   return type;
    4834                 :            : }
    4835                 :            : 
    4836                 :            : /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
    4837                 :            :    template PARMS and constraints, CONSTR.  If MEMBER_TEMPLATE_P is true,
    4838                 :            :    the new  template is a member template. */
    4839                 :            : 
    4840                 :            : static tree
    4841                 :   17829500 : build_template_decl (tree decl, tree parms, bool member_template_p)
    4842                 :            : {
    4843                 :   17829500 :   tree tmpl = build_lang_decl (TEMPLATE_DECL, DECL_NAME (decl), NULL_TREE);
    4844                 :   17829500 :   SET_DECL_LANGUAGE (tmpl, DECL_LANGUAGE (decl));
    4845                 :   17829500 :   DECL_TEMPLATE_PARMS (tmpl) = parms;
    4846                 :   17829500 :   DECL_CONTEXT (tmpl) = DECL_CONTEXT (decl);
    4847                 :   17829500 :   DECL_SOURCE_LOCATION (tmpl) = DECL_SOURCE_LOCATION (decl);
    4848                 :   17829500 :   DECL_MEMBER_TEMPLATE_P (tmpl) = member_template_p;
    4849                 :            : 
    4850                 :   17829500 :   return tmpl;
    4851                 :            : }
    4852                 :            : 
    4853                 :            : struct template_parm_data
    4854                 :            : {
    4855                 :            :   /* The level of the template parameters we are currently
    4856                 :            :      processing.  */
    4857                 :            :   int level;
    4858                 :            : 
    4859                 :            :   /* The index of the specialization argument we are currently
    4860                 :            :      processing.  */
    4861                 :            :   int current_arg;
    4862                 :            : 
    4863                 :            :   /* An array whose size is the number of template parameters.  The
    4864                 :            :      elements are nonzero if the parameter has been used in any one
    4865                 :            :      of the arguments processed so far.  */
    4866                 :            :   int* parms;
    4867                 :            : 
    4868                 :            :   /* An array whose size is the number of template arguments.  The
    4869                 :            :      elements are nonzero if the argument makes use of template
    4870                 :            :      parameters of this level.  */
    4871                 :            :   int* arg_uses_template_parms;
    4872                 :            : };
    4873                 :            : 
    4874                 :            : /* Subroutine of push_template_decl used to see if each template
    4875                 :            :    parameter in a partial specialization is used in the explicit
    4876                 :            :    argument list.  If T is of the LEVEL given in DATA (which is
    4877                 :            :    treated as a template_parm_data*), then DATA->PARMS is marked
    4878                 :            :    appropriately.  */
    4879                 :            : 
    4880                 :            : static int
    4881                 :    1798090 : mark_template_parm (tree t, void* data)
    4882                 :            : {
    4883                 :    1798090 :   int level;
    4884                 :    1798090 :   int idx;
    4885                 :    1798090 :   struct template_parm_data* tpd = (struct template_parm_data*) data;
    4886                 :            : 
    4887                 :    1798090 :   template_parm_level_and_index (t, &level, &idx);
    4888                 :            : 
    4889                 :    1798090 :   if (level == tpd->level)
    4890                 :            :     {
    4891                 :    1794430 :       tpd->parms[idx] = 1;
    4892                 :    1794430 :       tpd->arg_uses_template_parms[tpd->current_arg] = 1;
    4893                 :            :     }
    4894                 :            : 
    4895                 :            :   /* In C++17 the type of a non-type argument is a deduced context.  */
    4896                 :    1798090 :   if (cxx_dialect >= cxx17
    4897                 :    1075790 :       && TREE_CODE (t) == TEMPLATE_PARM_INDEX)
    4898                 :      78034 :     for_each_template_parm (TREE_TYPE (t),
    4899                 :            :                             &mark_template_parm,
    4900                 :            :                             data,
    4901                 :            :                             NULL,
    4902                 :            :                             /*include_nondeduced_p=*/false);
    4903                 :            : 
    4904                 :            :   /* Return zero so that for_each_template_parm will continue the
    4905                 :            :      traversal of the tree; we want to mark *every* template parm.  */
    4906                 :    1798090 :   return 0;
    4907                 :            : }
    4908                 :            : 
    4909                 :            : /* Process the partial specialization DECL.  */
    4910                 :            : 
    4911                 :            : static tree
    4912                 :    1013640 : process_partial_specialization (tree decl)
    4913                 :            : {
    4914                 :    1013640 :   tree type = TREE_TYPE (decl);
    4915                 :    1013640 :   tree tinfo = get_template_info (decl);
    4916                 :    1013640 :   tree maintmpl = TI_TEMPLATE (tinfo);
    4917                 :    1013640 :   tree specargs = TI_ARGS (tinfo);
    4918                 :    1013640 :   tree inner_args = INNERMOST_TEMPLATE_ARGS (specargs);
    4919                 :    1013640 :   tree main_inner_parms = DECL_INNERMOST_TEMPLATE_PARMS (maintmpl);
    4920                 :    1013640 :   tree inner_parms;
    4921                 :    1013640 :   tree inst;
    4922                 :    1013640 :   int nargs = TREE_VEC_LENGTH (inner_args);
    4923                 :    1013640 :   int ntparms;
    4924                 :    1013640 :   int  i;
    4925                 :    1013640 :   bool did_error_intro = false;
    4926                 :    1013640 :   struct template_parm_data tpd;
    4927                 :    1013640 :   struct template_parm_data tpd2;
    4928                 :            : 
    4929                 :    1013640 :   gcc_assert (current_template_parms);
    4930                 :            : 
    4931                 :            :   /* A concept cannot be specialized.  */
    4932                 :    1013640 :   if (flag_concepts && variable_concept_p (maintmpl))
    4933                 :            :     {
    4934                 :          1 :       error ("specialization of variable concept %q#D", maintmpl);
    4935                 :          1 :       return error_mark_node;
    4936                 :            :     }
    4937                 :            : 
    4938                 :    1013640 :   inner_parms = INNERMOST_TEMPLATE_PARMS (current_template_parms);
    4939                 :    1013640 :   ntparms = TREE_VEC_LENGTH (inner_parms);
    4940                 :            : 
    4941                 :            :   /* We check that each of the template parameters given in the
    4942                 :            :      partial specialization is used in the argument list to the
    4943                 :            :      specialization.  For example:
    4944                 :            : 
    4945                 :            :        template <class T> struct S;
    4946                 :            :        template <class T> struct S<T*>;
    4947                 :            : 
    4948                 :            :      The second declaration is OK because `T*' uses the template
    4949                 :            :      parameter T, whereas
    4950                 :            : 
    4951                 :            :        template <class T> struct S<int>;
    4952                 :            : 
    4953                 :            :      is no good.  Even trickier is:
    4954                 :            : 
    4955                 :            :        template <class T>
    4956                 :            :        struct S1
    4957                 :            :        {
    4958                 :            :           template <class U>
    4959                 :            :           struct S2;
    4960                 :            :           template <class U>
    4961                 :            :           struct S2<T>;
    4962                 :            :        };
    4963                 :            : 
    4964                 :            :      The S2<T> declaration is actually invalid; it is a
    4965                 :            :      full-specialization.  Of course,
    4966                 :            : 
    4967                 :            :           template <class U>
    4968                 :            :           struct S2<T (*)(U)>;
    4969                 :            : 
    4970                 :            :      or some such would have been OK.  */
    4971                 :    1013640 :   tpd.level = TMPL_PARMS_DEPTH (current_template_parms);
    4972                 :    1013640 :   tpd.parms = XALLOCAVEC (int, ntparms);
    4973                 :    1013640 :   memset (tpd.parms, 0, sizeof (int) * ntparms);
    4974                 :            : 
    4975                 :    1013640 :   tpd.arg_uses_template_parms = XALLOCAVEC (int, nargs);
    4976                 :    1013640 :   memset (tpd.arg_uses_template_parms, 0, sizeof (int) * nargs);
    4977                 :    3096940 :   for (i = 0; i < nargs; ++i)
    4978                 :            :     {
    4979                 :    2083300 :       tpd.current_arg = i;
    4980                 :    2083300 :       for_each_template_parm (TREE_VEC_ELT (inner_args, i),
    4981                 :            :                               &mark_template_parm,
    4982                 :            :                               &tpd,
    4983                 :            :                               NULL,
    4984                 :            :                               /*include_nondeduced_p=*/false);
    4985                 :            :     }
    4986                 :    2703580 :   for (i = 0; i < ntparms; ++i)
    4987                 :    1689940 :     if (tpd.parms[i] == 0)
    4988                 :            :       {
    4989                 :            :         /* One of the template parms was not used in a deduced context in the
    4990                 :            :            specialization.  */
    4991                 :         40 :         if (!did_error_intro)
    4992                 :            :           {
    4993                 :         40 :             error ("template parameters not deducible in "
    4994                 :            :                    "partial specialization:");
    4995                 :         40 :             did_error_intro = true;
    4996                 :            :           }
    4997                 :            : 
    4998                 :         80 :         inform (input_location, "        %qD",
    4999                 :         40 :                 TREE_VALUE (TREE_VEC_ELT (inner_parms, i)));
    5000                 :            :       }
    5001                 :            : 
    5002                 :    1013640 :   if (did_error_intro)
    5003                 :         40 :     return error_mark_node;
    5004                 :            : 
    5005                 :            :   /* [temp.class.spec]
    5006                 :            : 
    5007                 :            :      The argument list of the specialization shall not be identical to
    5008                 :            :      the implicit argument list of the primary template.  */
    5009                 :    1013600 :   tree main_args
    5010                 :    1013600 :     = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (maintmpl)));
    5011                 :    1013600 :   if (comp_template_args (inner_args, INNERMOST_TEMPLATE_ARGS (main_args))
    5012                 :    1013600 :       && (!flag_concepts
    5013                 :      12465 :           || !strictly_subsumes (current_template_constraints (),
    5014                 :            :                                  inner_args, maintmpl)))
    5015                 :            :     {
    5016                 :         16 :       if (!flag_concepts)
    5017                 :          9 :         error ("partial specialization %q+D does not specialize "
    5018                 :            :                "any template arguments; to define the primary template, "
    5019                 :            :                "remove the template argument list", decl);
    5020                 :            :       else
    5021                 :          7 :         error ("partial specialization %q+D does not specialize any "
    5022                 :            :                "template arguments and is not more constrained than "
    5023                 :            :                "the primary template; to define the primary template, "
    5024                 :            :                "remove the template argument list", decl);
    5025                 :         16 :       inform (DECL_SOURCE_LOCATION (maintmpl), "primary template here");
    5026                 :            :     }
    5027                 :            : 
    5028                 :            :   /* A partial specialization that replaces multiple parameters of the
    5029                 :            :      primary template with a pack expansion is less specialized for those
    5030                 :            :      parameters.  */
    5031                 :    1013600 :   if (nargs < DECL_NTPARMS (maintmpl))
    5032                 :            :     {
    5033                 :          3 :       error ("partial specialization is not more specialized than the "
    5034                 :            :              "primary template because it replaces multiple parameters "
    5035                 :            :              "with a pack expansion");
    5036                 :          3 :       inform (DECL_SOURCE_LOCATION (maintmpl), "primary template here");
    5037                 :            :       /* Avoid crash in process_partial_specialization.  */
    5038                 :          3 :       return decl;
    5039                 :            :     }
    5040                 :            : 
    5041                 :    1013600 :   else if (nargs > DECL_NTPARMS (maintmpl))
    5042                 :            :     {
    5043                 :          5 :       error ("too many arguments for partial specialization %qT", type);
    5044                 :          5 :       inform (DECL_SOURCE_LOCATION (maintmpl), "primary template here");
    5045                 :            :       /* Avoid crash below.  */
    5046                 :          5 :       return decl;
    5047                 :            :     }
    5048                 :            : 
    5049                 :            :   /* If we aren't in a dependent class, we can actually try deduction.  */
    5050                 :    1013590 :   else if (tpd.level == 1
    5051                 :            :            /* FIXME we should be able to handle a partial specialization of a
    5052                 :            :               partial instantiation, but currently we can't (c++/41727).  */
    5053                 :    1988710 :            && TMPL_ARGS_DEPTH (specargs) == 1
    5054                 :    2007940 :            && !get_partial_spec_bindings (maintmpl, maintmpl, specargs))
    5055                 :            :     {
    5056                 :         18 :       auto_diagnostic_group d;
    5057                 :          9 :       if (permerror (input_location, "partial specialization %qD is not "
    5058                 :            :                      "more specialized than", decl))
    5059                 :          9 :         inform (DECL_SOURCE_LOCATION (maintmpl), "primary template %qD",
    5060                 :            :                 maintmpl);
    5061                 :            :     }
    5062                 :            : 
    5063                 :            :   /* [temp.class.spec]
    5064                 :            : 
    5065                 :            :      A partially specialized non-type argument expression shall not
    5066                 :            :      involve template parameters of the partial specialization except
    5067                 :            :      when the argument expression is a simple identifier.
    5068                 :            : 
    5069                 :            :      The type of a template parameter corresponding to a specialized
    5070                 :            :      non-type argument shall not be dependent on a parameter of the
    5071                 :            :      specialization.
    5072                 :            : 
    5073                 :            :      Also, we verify that pack expansions only occur at the
    5074                 :            :      end of the argument list.  */
    5075                 :    1013590 :   tpd2.parms = 0;
    5076                 :    3096830 :   for (i = 0; i < nargs; ++i)
    5077                 :            :     {
    5078                 :    2083230 :       tree parm = TREE_VALUE (TREE_VEC_ELT (main_inner_parms, i));
    5079                 :    2083230 :       tree arg = TREE_VEC_ELT (inner_args, i);
    5080                 :    2083230 :       tree packed_args = NULL_TREE;
    5081                 :    2083230 :       int j, len = 1;
    5082                 :            : 
    5083                 :    2083230 :       if (ARGUMENT_PACK_P (arg))
    5084                 :            :         {
    5085                 :            :           /* Extract the arguments from the argument pack. We'll be
    5086                 :            :              iterating over these in the following loop.  */
    5087                 :     232950 :           packed_args = ARGUMENT_PACK_ARGS (arg);
    5088                 :     119452 :           len = TREE_VEC_LENGTH (packed_args);
    5089                 :            :         }
    5090                 :            : 
    5091                 :    4234580 :       for (j = 0; j < len; j++)
    5092                 :            :         {
    5093                 :    2151350 :           if (packed_args)
    5094                 :            :             /* Get the Jth argument in the parameter pack.  */
    5095                 :     187567 :             arg = TREE_VEC_ELT (packed_args, j);
    5096                 :            : 
    5097                 :    2151350 :           if (PACK_EXPANSION_P (arg))
    5098                 :            :             {
    5099                 :            :               /* Pack expansions must come at the end of the
    5100                 :            :                  argument list.  */
    5101                 :      60817 :               if ((packed_args && j < len - 1)
    5102                 :      60805 :                   || (!packed_args && i < nargs - 1))
    5103                 :            :                 {
    5104                 :         12 :                   if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
    5105                 :          6 :                     error ("parameter pack argument %qE must be at the "
    5106                 :            :                            "end of the template argument list", arg);
    5107                 :            :                   else
    5108                 :          6 :                     error ("parameter pack argument %qT must be at the "
    5109                 :            :                            "end of the template argument list", arg);
    5110                 :            :                 }
    5111                 :            :             }
    5112                 :            : 
    5113                 :    2151350 :           if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
    5114                 :            :             /* We only care about the pattern.  */
    5115                 :       3576 :             arg = PACK_EXPANSION_PATTERN (arg);
    5116                 :            : 
    5117                 :    2151350 :           if (/* These first two lines are the `non-type' bit.  */
    5118                 :    2151350 :               !TYPE_P (arg)
    5119                 :     641089 :               && TREE_CODE (arg) != TEMPLATE_DECL
    5120                 :            :               /* This next two lines are the `argument expression is not just a
    5121                 :            :                  simple identifier' condition and also the `specialized
    5122                 :            :                  non-type argument' bit.  */
    5123                 :     639646 :               && TREE_CODE (arg) != TEMPLATE_PARM_INDEX
    5124                 :    2702040 :               && !((REFERENCE_REF_P (arg)
    5125                 :     550665 :                     || TREE_CODE (arg) == VIEW_CONVERT_EXPR)
    5126                 :         30 :                    && TREE_CODE (TREE_OPERAND (arg, 0)) == TEMPLATE_PARM_INDEX))
    5127                 :            :             {
    5128                 :     545400 :               if ((!packed_args && tpd.arg_uses_template_parms[i])
    5129                 :    1096030 :                   || (packed_args && uses_template_parms (arg)))
    5130                 :         70 :                 error_at (cp_expr_loc_or_input_loc (arg),
    5131                 :            :                           "template argument %qE involves template "
    5132                 :            :                           "parameter(s)", arg);
    5133                 :            :               else 
    5134                 :            :                 {
    5135                 :            :                   /* Look at the corresponding template parameter,
    5136                 :            :                      marking which template parameters its type depends
    5137                 :            :                      upon.  */
    5138                 :     550630 :                   tree type = TREE_TYPE (parm);
    5139                 :            : 
    5140                 :     550630 :                   if (!tpd2.parms)
    5141                 :            :                     {
    5142                 :            :                       /* We haven't yet initialized TPD2.  Do so now.  */
    5143                 :     402645 :                       tpd2.arg_uses_template_parms = XALLOCAVEC (int, nargs);
    5144                 :            :                       /* The number of parameters here is the number in the
    5145                 :            :                          main template, which, as checked in the assertion
    5146                 :            :                          above, is NARGS.  */
    5147                 :     402645 :                       tpd2.parms = XALLOCAVEC (int, nargs);
    5148                 :     402645 :                       tpd2.level = 
    5149                 :     402645 :                         TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl));
    5150                 :            :                     }
    5151                 :            : 
    5152                 :            :                   /* Mark the template parameters.  But this time, we're
    5153                 :            :                      looking for the template parameters of the main
    5154                 :            :                      template, not in the specialization.  */
    5155                 :     550630 :                   tpd2.current_arg = i;
    5156                 :     550630 :                   tpd2.arg_uses_template_parms[i] = 0;
    5157                 :     550630 :                   memset (tpd2.parms, 0, sizeof (int) * nargs);
    5158                 :     550630 :                   for_each_template_parm (type,
    5159                 :            :                                           &mark_template_parm,
    5160                 :            :                                           &tpd2,
    5161                 :            :                                           NULL,
    5162                 :            :                                           /*include_nondeduced_p=*/false);
    5163                 :            : 
    5164                 :     550630 :                   if (tpd2.arg_uses_template_parms [i])
    5165                 :            :                     {
    5166                 :            :                       /* The type depended on some template parameters.
    5167                 :            :                          If they are fully specialized in the
    5168                 :            :                          specialization, that's OK.  */
    5169                 :            :                       int j;
    5170                 :            :                       int count = 0;
    5171                 :         28 :                       for (j = 0; j < nargs; ++j)
    5172                 :         21 :                         if (tpd2.parms[j] != 0
    5173                 :          7 :                             && tpd.arg_uses_template_parms [j])
    5174                 :          0 :                           ++count;
    5175                 :          7 :                       if (count != 0)
    5176                 :          0 :                         error_n (input_location, count,
    5177                 :            :                                  "type %qT of template argument %qE depends "
    5178                 :            :                                  "on a template parameter",
    5179                 :            :                                  "type %qT of template argument %qE depends "
    5180                 :            :                                  "on template parameters",
    5181                 :            :                                  type,
    5182                 :            :                                  arg);
    5183                 :            :                     }
    5184                 :            :                 }
    5185                 :            :             }
    5186                 :            :         }
    5187                 :            :     }
    5188                 :            : 
    5189                 :            :   /* We should only get here once.  */
    5190                 :    1013590 :   if (TREE_CODE (decl) == TYPE_DECL)
    5191                 :    1006340 :     gcc_assert (!COMPLETE_TYPE_P (type));
    5192                 :            : 
    5193                 :            :   // Build the template decl.
    5194                 :    1013590 :   tree tmpl = build_template_decl (decl, current_template_parms,
    5195                 :    1013590 :                                    DECL_MEMBER_TEMPLATE_P (maintmpl));
    5196                 :    1013590 :   TREE_TYPE (tmpl) = type;
    5197                 :    1013590 :   DECL_TEMPLATE_RESULT (tmpl) = decl;
    5198                 :    1013590 :   SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
    5199                 :    1013590 :   DECL_TEMPLATE_INFO (tmpl) = build_template_info (maintmpl, specargs);
    5200                 :    1013590 :   DECL_PRIMARY_TEMPLATE (tmpl) = maintmpl;
    5201                 :            : 
    5202                 :            :   /* Give template template parms a DECL_CONTEXT of the template
    5203                 :            :      for which they are a parameter.  */
    5204                 :    2703470 :   for (i = 0; i < ntparms; ++i)
    5205                 :            :     {
    5206                 :    1689880 :       tree parm = TREE_VALUE (TREE_VEC_ELT (inner_parms, i));
    5207                 :    1689880 :       if (TREE_CODE (parm) == TEMPLATE_DECL)
    5208                 :      17780 :         DECL_CONTEXT (parm) = tmpl;
    5209                 :            :     }
    5210                 :            : 
    5211                 :    1013590 :   if (VAR_P (decl))
    5212                 :            :     /* We didn't register this in check_explicit_specialization so we could
    5213                 :            :        wait until the constraints were set.  */
    5214                 :       7253 :     decl = register_specialization (decl, maintmpl, specargs, false, 0);
    5215                 :            :   else
    5216                 :    1006340 :     associate_classtype_constraints (type);
    5217                 :            : 
    5218                 :    2027190 :   DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)
    5219                 :    2027190 :     = tree_cons (specargs, tmpl,
    5220                 :    1013590 :                  DECL_TEMPLATE_SPECIALIZATIONS (maintmpl));
    5221                 :    1013590 :   TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)) = type;
    5222                 :            : 
    5223                 :    7760550 :   for (inst = DECL_TEMPLATE_INSTANTIATIONS (maintmpl); inst;
    5224                 :    3373480 :        inst = TREE_CHAIN (inst))
    5225                 :            :     {
    5226                 :    3373480 :       tree instance = TREE_VALUE (inst);
    5227                 :    3373480 :       if (TYPE_P (instance)
    5228                 :    6732260 :           ? (COMPLETE_TYPE_P (instance)
    5229                 :    3358780 :              && CLASSTYPE_IMPLICIT_INSTANTIATION (instance))
    5230                 :      14703 :           : DECL_TEMPLATE_INSTANTIATION (instance))
    5231                 :            :         {
    5232                 :       2974 :           tree spec = most_specialized_partial_spec (instance, tf_none);
    5233                 :       2974 :           tree inst_decl = (DECL_P (instance)
    5234                 :       5945 :                             ? instance : TYPE_NAME (instance));
    5235                 :       2974 :           if (!spec)
    5236                 :            :             /* OK */;
    5237                 :        831 :           else if (spec == error_mark_node)
    5238                 :          4 :             permerror (input_location,
    5239                 :            :                        "declaration of %qD ambiguates earlier template "
    5240                 :            :                        "instantiation for %qD", decl, inst_decl);
    5241                 :        827 :           else if (TREE_VALUE (spec) == tmpl)
    5242                 :          7 :             permerror (input_location,
    5243                 :            :                        "partial specialization of %qD after instantiation "
    5244                 :            :                        "of %qD", decl, inst_decl);
    5245                 :            :         }
    5246                 :            :     }
    5247                 :            : 
    5248                 :            :   return decl;
    5249                 :            : }
    5250                 :            : 
    5251                 :            : /* PARM is a template parameter of some form; return the corresponding
    5252                 :            :    TEMPLATE_PARM_INDEX.  */
    5253                 :            : 
    5254                 :            : static tree
    5255                 :   98681600 : get_template_parm_index (tree parm)
    5256                 :            : {
    5257                 :   98681600 :   if (TREE_CODE (parm) == PARM_DECL
    5258                 :   98681600 :       || TREE_CODE (parm) == CONST_DECL)
    5259                 :   43679300 :     parm = DECL_INITIAL (parm);
    5260                 :   55002300 :   else if (TREE_CODE (parm) == TYPE_DECL
    5261                 :     797335 :            || TREE_CODE (parm) == TEMPLATE_DECL)
    5262                 :   54205800 :     parm = TREE_TYPE (parm);
    5263                 :   98681600 :   if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
    5264                 :   98681600 :       || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM
    5265                 :   43759300 :       || TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM)
    5266                 :   54951500 :     parm = TEMPLATE_TYPE_PARM_INDEX (parm);
    5267                 :   98681600 :   gcc_assert (TREE_CODE (parm) == TEMPLATE_PARM_INDEX);
    5268                 :   98681600 :   return parm;
    5269                 :            : }
    5270                 :            : 
    5271                 :            : /* Subroutine of fixed_parameter_pack_p below.  Look for any template
    5272                 :            :    parameter packs used by the template parameter PARM.  */
    5273                 :            : 
    5274                 :            : static void
    5275                 :        791 : fixed_parameter_pack_p_1 (tree parm, struct find_parameter_pack_data *ppd)
    5276                 :            : {
    5277                 :            :   /* A type parm can't refer to another parm.  */
    5278                 :        791 :   if (TREE_CODE (parm) == TYPE_DECL || parm == error_mark_node)
    5279                 :            :     return;
    5280                 :        779 :   else if (TREE_CODE (parm) == PARM_DECL)
    5281                 :            :     {
    5282                 :        716 :       cp_walk_tree (&TREE_TYPE (parm), &find_parameter_packs_r,
    5283                 :            :                     ppd, ppd->visited);
    5284                 :        716 :       return;
    5285                 :            :     }
    5286                 :            : 
    5287                 :         63 :   gcc_assert (TREE_CODE (parm) == TEMPLATE_DECL);
    5288                 :            : 
    5289                 :         63 :   tree vec = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (parm));
    5290                 :        126 :   for (int i = 0; i < TREE_VEC_LENGTH (vec); ++i)
    5291                 :            :     {
    5292                 :         63 :       tree p = TREE_VALUE (TREE_VEC_ELT (vec, i));
    5293                 :         63 :       if (template_parameter_pack_p (p))
    5294                 :            :         /* Any packs in the type are expanded by this parameter.  */;
    5295                 :            :       else
    5296                 :         21 :         fixed_parameter_pack_p_1 (p, ppd);
    5297                 :            :     }
    5298                 :            : }
    5299                 :            : 
    5300                 :            : /* PARM is a template parameter pack.  Return any parameter packs used in
    5301                 :            :    its type or the type of any of its template parameters.  If there are
    5302                 :            :    any such packs, it will be instantiated into a fixed template parameter
    5303                 :            :    list by partial instantiation rather than be fully deduced.  */
    5304                 :            : 
    5305                 :            : tree
    5306                 :   54448500 : fixed_parameter_pack_p (tree parm)
    5307                 :            : {
    5308                 :            :   /* This can only be true in a member template.  */
    5309                 :   54448500 :   if (TEMPLATE_PARM_ORIG_LEVEL (get_template_parm_index (parm)) < 2)
    5310                 :            :     return NULL_TREE;
    5311                 :            :   /* This can only be true for a parameter pack.  */
    5312                 :    1246370 :   if (!template_parameter_pack_p (parm))
    5313                 :            :     return NULL_TREE;
    5314                 :            :   /* A type parm can't refer to another parm.  */
    5315                 :    1246370 :   if (TREE_CODE (parm) == TYPE_DECL)
    5316                 :            :     return NULL_TREE;
    5317                 :            : 
    5318                 :        770 :   tree parameter_packs = NULL_TREE;
    5319                 :        770 :   struct find_parameter_pack_data ppd;
    5320                 :        770 :   ppd.parameter_packs = &parameter_packs;
    5321                 :        770 :   ppd.visited = new hash_set<tree>;
    5322                 :        770 :   ppd.type_pack_expansion_p = false;
    5323                 :            : 
    5324                 :        770 :   fixed_parameter_pack_p_1 (parm, &ppd);
    5325                 :            : 
    5326                 :       1540 :   delete ppd.visited;
    5327                 :        770 :   return parameter_packs;
    5328                 :            : }
    5329                 :            : 
    5330                 :            : /* Check that a template declaration's use of default arguments and
    5331                 :            :    parameter packs is not invalid.  Here, PARMS are the template
    5332                 :            :    parameters.  IS_PRIMARY is true if DECL is the thing declared by
    5333                 :            :    a primary template.  IS_PARTIAL is true if DECL is a partial
    5334                 :            :    specialization.
    5335                 :            : 
    5336                 :            :    IS_FRIEND_DECL is nonzero if DECL is either a non-defining friend
    5337                 :            :    function template declaration or a friend class template
    5338                 :            :    declaration.  In the function case, 1 indicates a declaration, 2
    5339                 :            :    indicates a redeclaration.  When IS_FRIEND_DECL=2, no errors are
    5340                 :            :    emitted for extraneous default arguments.
    5341                 :            : 
    5342                 :            :    Returns TRUE if there were no errors found, FALSE otherwise. */
    5343                 :            : 
    5344                 :            : bool
    5345                 :   21912700 : check_default_tmpl_args (tree decl, tree parms, bool is_primary,
    5346                 :            :                          bool is_partial, int is_friend_decl)
    5347                 :            : {
    5348                 :   21912700 :   const char *msg;
    5349                 :   21912700 :   int last_level_to_check;
    5350                 :   21912700 :   tree parm_level;
    5351                 :   21912700 :   bool no_errors = true;
    5352                 :            : 
    5353                 :            :   /* [temp.param]
    5354                 :            : 
    5355                 :            :      A default template-argument shall not be specified in a
    5356                 :            :      function template declaration or a function template definition, nor
    5357                 :            :      in the template-parameter-list of the definition of a member of a
    5358                 :            :      class template.  */
    5359                 :            : 
    5360                 :   21912700 :   if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL
    5361                 :   21912700 :       || (TREE_CODE (decl) == FUNCTION_DECL && DECL_LOCAL_FUNCTION_P (decl)))
    5362                 :            :     /* You can't have a function template declaration in a local
    5363                 :            :        scope, nor you can you define a member of a class template in a
    5364                 :            :        local scope.  */
    5365                 :            :     return true;
    5366                 :            : 
    5367                 :   18964800 :   if ((TREE_CODE (decl) == TYPE_DECL
    5368                 :    7720130 :        && TREE_TYPE (decl)
    5369                 :    7664490 :        && LAMBDA_TYPE_P (TREE_TYPE (decl)))
    5370                 :   26675600 :       || (TREE_CODE (decl) == FUNCTION_DECL
    5371                 :   11466000 :           && LAMBDA_FUNCTION_P (decl)))
    5372                 :            :     /* A lambda doesn't have an explicit declaration; don't complain
    5373                 :            :        about the parms of the enclosing class.  */
    5374                 :            :     return true;
    5375                 :            : 
    5376                 :   18928900 :   if (current_class_type
    5377                 :   13637600 :       && !TYPE_BEING_DEFINED (current_class_type)
    5378                 :    4082270 :       && DECL_LANG_SPECIFIC (decl)
    5379                 :    4079700 :       && DECL_DECLARES_FUNCTION_P (decl)
    5380                 :            :       /* If this is either a friend defined in the scope of the class
    5381                 :            :          or a member function.  */
    5382                 :    5028890 :       && (DECL_FUNCTION_MEMBER_P (decl)
    5383                 :    4010210 :           ? same_type_p (DECL_CONTEXT (decl), current_class_type)
    5384                 :         20 :           : DECL_FRIEND_CONTEXT (decl)
    5385                 :          0 :           ? same_type_p (DECL_FRIEND_CONTEXT (decl), current_class_type)
    5386                 :            :           : false)
    5387                 :            :       /* And, if it was a member function, it really was defined in
    5388                 :            :          the scope of the class.  */
    5389                 :   27458700 :       && (!DECL_FUNCTION_MEMBER_P (decl)
    5390                 :    4010210 :           || DECL_INITIALIZED_IN_CLASS_P (decl)))
    5391                 :            :     /* We already checked these parameters when the template was
    5392                 :            :        declared, so there's no need to do it again now.  This function
    5393                 :            :        was defined in class scope, but we're processing its body now
    5394                 :            :        that the class is complete.  */
    5395                 :            :     return true;
    5396                 :            : 
    5397                 :            :   /* Core issue 226 (C++0x only): the following only applies to class
    5398                 :            :      templates.  */
    5399                 :   15315900 :   if (is_primary
    5400                 :    6839810 :       && ((cxx_dialect == cxx98) || TREE_CODE (decl) != FUNCTION_DECL))
    5401                 :            :     {
    5402                 :            :       /* [temp.param]
    5403                 :            : 
    5404                 :            :          If a template-parameter has a default template-argument, all
    5405                 :            :          subsequent template-parameters shall have a default
    5406                 :            :          template-argument supplied.  */
    5407                 :    7555500 :       for (parm_level = parms; parm_level; parm_level = TREE_CHAIN (parm_level))
    5408                 :            :         {
    5409                 :    3892750 :           tree inner_parms = TREE_VALUE (parm_level);
    5410                 :    3892750 :           int ntparms = TREE_VEC_LENGTH (inner_parms);
    5411                 :    3892750 :           int seen_def_arg_p = 0;
    5412                 :    3892750 :           int i;
    5413                 :            : 
    5414                 :   10159200 :           for (i = 0; i < ntparms; ++i)
    5415                 :            :             {
    5416                 :    6266450 :               tree parm = TREE_VEC_ELT (inner_parms, i);
    5417                 :            : 
    5418                 :    6266450 :               if (parm == error_mark_node)
    5419                 :          0 :                 continue;
    5420                 :            : 
    5421                 :    6266450 :               if (TREE_PURPOSE (parm))
    5422                 :            :                 seen_def_arg_p = 1;
    5423                 :    5668000 :               else if (seen_def_arg_p
    5424                 :    5668000 :                        && !template_parameter_pack_p (TREE_VALUE (parm)))
    5425                 :            :                 {
    5426                 :         24 :                   error ("no default argument for %qD", TREE_VALUE (parm));
    5427                 :            :                   /* For better subsequent error-recovery, we indicate that
    5428                 :            :                      there should have been a default argument.  */
    5429                 :         24 :                   TREE_PURPOSE (parm) = error_mark_node;
    5430                 :         24 :                   no_errors = false;
    5431                 :            :                 }
    5432                 :    5667970 :               else if (!is_partial
    5433                 :    5667970 :                        && !is_friend_decl
    5434                 :            :                        /* Don't complain about an enclosing partial
    5435                 :            :                           specialization.  */
    5436                 :    3869910 :                        && parm_level == parms
    5437                 :    3653850 :                        && TREE_CODE (decl) == TYPE_DECL
    5438                 :    3000610 :                        && i < ntparms - 1
    5439                 :    1253940 :                        && template_parameter_pack_p (TREE_VALUE (parm))
    5440                 :            :                        /* A fixed parameter pack will be partially
    5441                 :            :                           instantiated into a fixed length list.  */
    5442                 :    5668000 :                        && !fixed_parameter_pack_p (TREE_VALUE (parm)))
    5443                 :            :                 {
    5444                 :            :                   /* A primary class template can only have one
    5445                 :            :                      parameter pack, at the end of the template
    5446                 :            :                      parameter list.  */
    5447                 :            : 
    5448                 :         18 :                   error ("parameter pack %q+D must be at the end of the"
    5449                 :         18 :                          " template parameter list", TREE_VALUE (parm));
    5450                 :            : 
    5451                 :         18 :                   TREE_VALUE (TREE_VEC_ELT (inner_parms, i))
    5452                 :         18 :                     = error_mark_node;
    5453                 :         18 :                   no_errors = false;
    5454                 :            :                 }
    5455                 :            :             }
    5456                 :            :         }
    5457                 :            :     }
    5458                 :            : 
    5459                 :   15315900 :   if (((cxx_dialect == cxx98) && TREE_CODE (decl) != TYPE_DECL)
    5460                 :            :       || is_partial
    5461                 :   15003800 :       || !is_primary
    5462                 :    5714600 :       || is_friend_decl)
    5463                 :            :     /* For an ordinary class template, default template arguments are
    5464                 :            :        allowed at the innermost level, e.g.:
    5465                 :            :          template <class T = int>
    5466                 :            :          struct S {};
    5467                 :            :        but, in a partial specialization, they're not allowed even
    5468                 :            :        there, as we have in [temp.class.spec]:
    5469                 :            : 
    5470                 :            :          The template parameter list of a specialization shall not
    5471                 :            :          contain default template argument values.
    5472                 :            : 
    5473                 :            :        So, for a partial specialization, or for a function template
    5474                 :            :        (in C++98/C++03), we look at all of them.  */
    5475                 :            :     ;
    5476                 :            :   else
    5477                 :            :     /* But, for a primary class template that is not a partial
    5478                 :            :        specialization we look at all template parameters except the
    5479                 :            :        innermost ones.  */
    5480                 :    5629570 :     parms = TREE_CHAIN (parms);
    5481                 :            : 
    5482                 :            :   /* Figure out what error message to issue.  */
    5483                 :   15315900 :   if (is_friend_decl == 2)
    5484                 :            :     msg = G_("default template arguments may not be used in function template "
    5485                 :            :              "friend re-declaration");
    5486                 :   15293900 :   else if (is_friend_decl)
    5487                 :            :     msg = G_("default template arguments may not be used in template "
    5488                 :            :              "friend declarations");
    5489                 :   15230900 :   else if (TREE_CODE (decl) == FUNCTION_DECL && (cxx_dialect == cxx98))
    5490                 :            :     msg = G_("default template arguments may not be used in function templates "
    5491                 :            :              "without %<-std=c++11%> or %<-std=gnu++11%>");
    5492                 :   14927800 :   else if (is_partial)
    5493                 :            :     msg = G_("default template arguments may not be used in "
    5494                 :            :              "partial specializations");
    5495                 :   13994700 :   else if (current_class_type && CLASSTYPE_IS_TEMPLATE (current_class_type))
    5496                 :            :     msg = G_("default argument for template parameter for class enclosing %qD");
    5497                 :            :   else
    5498                 :            :     /* Per [temp.param]/9, "A default template-argument shall not be
    5499                 :            :        specified in the template-parameter-lists of the definition of
    5500                 :            :        a member of a class template that appears outside of the member's
    5501                 :            :        class.", thus if we aren't handling a member of a class template
    5502                 :            :        there is no need to examine the parameters.  */
    5503                 :            :     return true;
    5504                 :            : 
    5505                 :    7992920 :   if (current_class_type && TYPE_BEING_DEFINED (current_class_type))
    5506                 :            :     /* If we're inside a class definition, there's no need to
    5507                 :            :        examine the parameters to the class itself.  On the one
    5508                 :            :        hand, they will be checked when the class is defined, and,
    5509                 :            :        on the other, default arguments are valid in things like:
    5510                 :            :          template <class T = double>
    5511                 :            :          struct S { template <class U> void f(U); };
    5512                 :            :        Here the default argument for `S' has no bearing on the
    5513                 :            :        declaration of `f'.  */
    5514                 :    6499070 :     last_level_to_check = template_class_depth (current_class_type) + 1;
    5515                 :            :   else
    5516                 :            :     /* Check everything.  */
    5517                 :            :     last_level_to_check = 0;
    5518                 :            : 
    5519                 :    9700880 :   for (parm_level = parms;
    5520                 :   17842300 :        parm_level && TMPL_PARMS_DEPTH (parm_level) >= last_level_to_check;
    5521                 :    1707960 :        parm_level = TREE_CHAIN (parm_level))
    5522                 :            :     {
    5523                 :    1707960 :       tree inner_parms = TREE_VALUE (parm_level);
    5524                 :    1707960 :       int i;
    5525                 :    1707960 :       int ntparms;
    5526                 :            : 
    5527                 :    1707960 :       ntparms = TREE_VEC_LENGTH (inner_parms);
    5528                 :    5267410 :       for (i = 0; i < ntparms; ++i)
    5529                 :            :         {
    5530                 :    3559450 :           if (TREE_VEC_ELT (inner_parms, i) == error_mark_node)
    5531                 :          0 :             continue;
    5532                 :            : 
    5533                 :    3559450 :           if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)))
    5534                 :            :             {
    5535                 :         34 :               if (msg)
    5536                 :            :                 {
    5537                 :         34 :                   no_errors = false;
    5538                 :         34 :                   if (is_friend_decl == 2)
    5539                 :            :                     return no_errors;
    5540                 :            : 
    5541                 :         31 :                   error (msg, decl);
    5542                 :         31 :                   msg = 0;
    5543                 :            :                 }
    5544                 :            : 
    5545                 :            :               /* Clear out the default argument so that we are not
    5546                 :            :                  confused later.  */
    5547                 :         31 :               TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)) = NULL_TREE;
    5548                 :            :             }
    5549                 :            :         }
    5550                 :            : 
    5551                 :            :       /* At this point, if we're still interested in issuing messages,
    5552                 :            :          they must apply to classes surrounding the object declared.  */
    5553                 :    1707960 :       if (msg)
    5554                 :    1707930 :         msg = G_("default argument for template parameter for class "
    5555                 :            :                  "enclosing %qD");
    5556                 :            :     }
    5557                 :            : 
    5558                 :            :   return no_errors;
    5559                 :            : }
    5560                 :            : 
    5561                 :            : /* Worker for push_template_decl_real, called via
    5562                 :            :    for_each_template_parm.  DATA is really an int, indicating the
    5563                 :            :    level of the parameters we are interested in.  If T is a template
    5564                 :            :    parameter of that level, return nonzero.  */
    5565                 :            : 
    5566                 :            : static int
    5567                 :        329 : template_parm_this_level_p (tree t, void* data)
    5568                 :            : {
    5569                 :        329 :   int this_level = *(int *)data;
    5570                 :        329 :   int level;
    5571                 :            : 
    5572                 :        329 :   if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
    5573                 :         35 :     level = TEMPLATE_PARM_LEVEL (t);
    5574                 :            :   else
    5575                 :        302 :     level = TEMPLATE_TYPE_LEVEL (t);
    5576                 :        329 :   return level == this_level;
    5577                 :            : }
    5578                 :            : 
    5579                 :            : /* Worker for uses_outer_template_parms, called via for_each_template_parm.
    5580                 :            :    DATA is really an int, indicating the innermost outer level of parameters.
    5581                 :            :    If T is a template parameter of that level or further out, return
    5582                 :            :    nonzero.  */
    5583                 :            : 
    5584                 :            : static int
    5585                 :     454132 : template_parm_outer_level (tree t, void *data)
    5586                 :            : {
    5587                 :     454132 :   int this_level = *(int *)data;
    5588                 :     454132 :   int level;
    5589                 :            : 
    5590                 :     454132 :   if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
    5591                 :      17313 :     level = TEMPLATE_PARM_LEVEL (t);
    5592                 :            :   else
    5593                 :     437745 :     level = TEMPLATE_TYPE_LEVEL (t);
    5594                 :     454132 :   return level <= this_level;
    5595                 :            : }
    5596                 :            : 
    5597                 :            : /* Creates a TEMPLATE_DECL for the indicated DECL using the template
    5598                 :            :    parameters given by current_template_args, or reuses a
    5599                 :            :    previously existing one, if appropriate.  Returns the DECL, or an
    5600                 :            :    equivalent one, if it is replaced via a call to duplicate_decls.
    5601                 :            : 
    5602                 :            :    If IS_FRIEND is true, DECL is a friend declaration.  */
    5603                 :            : 
    5604                 :            : tree
    5605                 :   22085600 : push_template_decl_real (tree decl, bool is_friend)
    5606                 :            : {
    5607                 :   22085600 :   tree tmpl;
    5608                 :   22085600 :   tree args;
    5609                 :   22085600 :   tree info;
    5610                 :   22085600 :   tree ctx;
    5611                 :   22085600 :   bool is_primary;
    5612                 :   22085600 :   bool is_partial;
    5613                 :   22085600 :   int new_template_p = 0;
    5614                 :            :   /* True if the template is a member template, in the sense of
    5615                 :            :      [temp.mem].  */
    5616                 :   22085600 :   bool member_template_p = false;
    5617                 :            : 
    5618                 :   22085600 :   if (decl == error_mark_node || !current_template_parms)
    5619                 :            :     return error_mark_node;
    5620                 :            : 
    5621                 :            :   /* See if this is a partial specialization.  */
    5622                 :    8198460 :   is_partial = ((DECL_IMPLICIT_TYPEDEF_P (decl)
    5623                 :    2884680 :                  && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE
    5624                 :    2824780 :                  && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)))
    5625                 :   29277700 :                 || (VAR_P (decl)
    5626                 :    2912770 :                     && DECL_LANG_SPECIFIC (decl)
    5627                 :     501944 :                     && DECL_TEMPLATE_SPECIALIZATION (decl)
    5628                 :       7268 :                     && TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (decl))));
    5629                 :            : 
    5630                 :   22085600 :   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_FRIEND_P (decl))
    5631                 :            :     is_friend = true;
    5632                 :            : 
    5633                 :   21792200 :   if (is_friend)
    5634                 :            :     /* For a friend, we want the context of the friend, not
    5635                 :            :        the type of which it is a friend.  */
    5636                 :     313523 :     ctx = CP_DECL_CONTEXT (decl);
    5637                 :   21772100 :   else if (CP_DECL_CONTEXT (decl)
    5638                 :   21772100 :            && TREE_CODE (CP_DECL_CONTEXT (decl)) != NAMESPACE_DECL)
    5639                 :            :     /* In the case of a virtual function, we want the class in which
    5640                 :            :        it is defined.  */
    5641                 :   16547200 :     ctx = CP_DECL_CONTEXT (decl);
    5642                 :            :   else
    5643                 :            :     /* Otherwise, if we're currently defining some class, the DECL
    5644                 :            :        is assumed to be a member of the class.  */
    5645                 :    5224900 :     ctx = current_scope ();
    5646                 :            : 
    5647                 :   22085600 :   if (ctx && TREE_CODE (ctx) == NAMESPACE_DECL)
    5648                 :    5537830 :     ctx = NULL_TREE;
    5649                 :            : 
    5650                 :   22085600 :   if (!DECL_CONTEXT (decl))
    5651                 :       7797 :     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
    5652                 :            : 
    5653                 :            :   /* See if this is a primary template.  */
    5654                 :   22085600 :   if (is_friend && ctx
    5655                 :   22085600 :       && uses_template_parms_level (ctx, processing_template_decl))
    5656                 :            :     /* A friend template that specifies a class context, i.e.
    5657                 :            :          template <typename T> friend void A<T>::f();
    5658                 :            :        is not primary.  */
    5659                 :            :     is_primary = false;
    5660                 :   22085500 :   else if (TREE_CODE (decl) == TYPE_DECL
    5661                 :   30284000 :            && LAMBDA_TYPE_P (TREE_TYPE (decl)))
    5662                 :            :     is_primary = false;
    5663                 :            :   else
    5664                 :   22067700 :     is_primary = template_parm_scope_p ();
    5665                 :            : 
    5666                 :   22067700 :   if (is_primary)
    5667                 :            :     {
    5668                 :    6819080 :       warning (OPT_Wtemplates, "template %qD declared", decl);
    5669                 :            : 
    5670                 :    6819080 :       if (DECL_CLASS_SCOPE_P (decl))
    5671                 :            :         member_template_p = true;
    5672                 :    6819080 :       if (TREE_CODE (decl) == TYPE_DECL
    5673                 :    6819080 :           && IDENTIFIER_ANON_P (DECL_NAME (decl)))
    5674                 :            :         {
    5675                 :          8 :           error ("template class without a name");
    5676                 :          8 :           return error_mark_node;
    5677                 :            :         }
    5678                 :    6819080 :       else if (TREE_CODE (decl) == FUNCTION_DECL)
    5679                 :            :         {
    5680                 :    3323500 :           if (member_template_p)
    5681                 :            :             {
    5682                 :    1241600 :               if (DECL_OVERRIDE_P (decl) || DECL_FINAL_P (decl))
    5683                 :          6 :                 error ("member template %qD may not have virt-specifiers", decl);
    5684                 :            :             }
    5685                 :    6646990 :           if (DECL_DESTRUCTOR_P (decl))
    5686                 :            :             {
    5687                 :            :               /* [temp.mem]
    5688                 :            : 
    5689                 :            :                  A destructor shall not be a member template.  */
    5690                 :          8 :               error_at (DECL_SOURCE_LOCATION (decl),
    5691                 :            :                         "destructor %qD declared as member template", decl);
    5692                 :          8 :               return error_mark_node;
    5693                 :            :             }
    5694                 :    3323490 :           if (IDENTIFIER_NEWDEL_OP_P (DECL_NAME (decl))
    5695                 :    3323520 :               && (!prototype_p (TREE_TYPE (decl))
    5696                 :         28 :                   || TYPE_ARG_TYPES (TREE_TYPE (decl)) == void_list_node
    5697                 :         28 :                   || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
    5698                 :         28 :                   || (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
    5699                 :            :                       == void_list_node)))
    5700                 :            :             {
    5701                 :            :               /* [basic.stc.dynamic.allocation]
    5702                 :            : 
    5703                 :            :                  An allocation function can be a function
    5704                 :            :                  template. ... Template allocation functions shall
    5705                 :            :                  have two or more parameters.  */
    5706                 :         12 :               error ("invalid template declaration of %qD", decl);
    5707                 :         12 :               return error_mark_node;
    5708                 :            :             }
    5709                 :            :         }
    5710                 :    3153740 :       else if (DECL_IMPLICIT_TYPEDEF_P (decl)
    5711                 :    6245300 :                && CLASS_TYPE_P (TREE_TYPE (decl)))
    5712                 :            :         {
    5713                 :            :           /* Class template, set TEMPLATE_TYPE_PARM_FOR_CLASS.  */
    5714                 :    2749710 :           tree parms = INNERMOST_TEMPLATE_PARMS (current_template_parms);
    5715                 :    7354620 :           for (int i = 0; i < TREE_VEC_LENGTH (parms); ++i)
    5716                 :            :             {
    5717                 :    4604900 :               tree t = TREE_VALUE (TREE_VEC_ELT (parms, i));
    5718                 :    4604900 :               if (TREE_CODE (t) == TYPE_DECL)
    5719                 :    4009490 :                 t = TREE_TYPE (t);
    5720                 :    4604900 :               if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
    5721                 :    4009490 :                 TEMPLATE_TYPE_PARM_FOR_CLASS (t) = true;
    5722                 :            :             }
    5723                 :            :         }
    5724                 :     745866 :       else if (TREE_CODE (decl) == TYPE_DECL
    5725                 :     745866 :                && TYPE_DECL_ALIAS_P (decl))
    5726                 :            :         /* alias-declaration */
    5727                 :     404021 :         gcc_assert (!DECL_ARTIFICIAL (decl));
    5728                 :     341845 :       else if (VAR_P (decl))
    5729                 :            :         /* C++14 variable template. */;
    5730                 :      91126 :       else if (TREE_CODE (decl) == CONCEPT_DECL)
    5731                 :            :         /* C++2a concept definitions.  */;
    5732                 :            :       else
    5733                 :            :         {
    5734                 :          7 :           error ("template declaration of %q#D", decl);
    5735                 :          7 :           return error_mark_node;
    5736                 :            :         }
    5737                 :            :     }
    5738                 :            : 
    5739                 :            :   /* Check to see that the rules regarding the use of default
    5740                 :            :      arguments are not being violated.  We check args for a friend
    5741                 :            :      functions when we know whether it's a definition, introducing
    5742                 :            :      declaration or re-declaration.  */
    5743                 :   22085600 :   if (!is_friend || TREE_CODE (decl) != FUNCTION_DECL)
    5744                 :   21792200 :     check_default_tmpl_args (decl, current_template_parms,
    5745                 :            :                              is_primary, is_partial, is_friend);
    5746                 :            : 
    5747                 :            :   /* Ensure that there are no parameter packs in the type of this
    5748                 :            :      declaration that have not been expanded.  */
    5749                 :   22085600 :   if (TREE_CODE (decl) == FUNCTION_DECL)
    5750                 :            :     {
    5751                 :            :       /* Check each of the arguments individually to see if there are
    5752                 :            :          any bare parameter packs.  */
    5753                 :   10883200 :       tree type = TREE_TYPE (decl);
    5754                 :   10883200 :       tree arg = DECL_ARGUMENTS (decl);
    5755                 :   18280200 :       tree argtype = TYPE_ARG_TYPES (type);
    5756                 :            : 
    5757                 :   34685700 :       while (arg && argtype)
    5758                 :            :         {
    5759                 :   23802400 :           if (!DECL_PACK_P (arg)
    5760                 :   47357600 :               && check_for_bare_parameter_packs (TREE_TYPE (arg)))
    5761                 :            :             {
    5762                 :            :             /* This is a PARM_DECL that contains unexpanded parameter
    5763                 :            :                packs. We have already complained about this in the
    5764                 :            :                check_for_bare_parameter_packs call, so just replace
    5765                 :            :                these types with ERROR_MARK_NODE.  */
    5766                 :         42 :               TREE_TYPE (arg) = error_mark_node;
    5767                 :         42 :               TREE_VALUE (argtype) = error_mark_node;
    5768                 :            :             }
    5769                 :            : 
    5770                 :   23802400 :           arg = DECL_CHAIN (arg);
    5771                 :   23802400 :           argtype = TREE_CHAIN (argtype);
    5772                 :            :         }
    5773                 :            : 
    5774                 :            :       /* Check for bare parameter packs in the return type and the
    5775                 :            :          exception specifiers.  */
    5776                 :   10883200 :       if (check_for_bare_parameter_packs (TREE_TYPE (type)))
    5777                 :            :         /* Errors were already issued, set return type to int
    5778                 :            :            as the frontend doesn't expect error_mark_node as
    5779                 :            :            the return type.  */
    5780                 :          3 :         TREE_TYPE (type) = integer_type_node;
    5781                 :   18280200 :       if (check_for_bare_parameter_packs (TYPE_RAISES_EXCEPTIONS (type)))
    5782                 :          0 :         TYPE_RAISES_EXCEPTIONS (type) = NULL_TREE;
    5783                 :            :     }
    5784                 :   22404700 :   else if (check_for_bare_parameter_packs (is_typedef_decl (decl)
    5785                 :    5313710 :                                            ? DECL_ORIGINAL_TYPE (decl)
    5786                 :    5888620 :                                            : TREE_TYPE (decl)))
    5787                 :            :     {
    5788                 :         61 :       TREE_TYPE (decl) = error_mark_node;
    5789                 :         61 :       return error_mark_node;
    5790                 :            :     }
    5791                 :            : 
    5792                 :   22085500 :   if (is_partial)
    5793                 :    1013640 :     return process_partial_specialization (decl);
    5794                 :            : 
    5795                 :   21071900 :   args = current_template_args ();
    5796                 :            : 
    5797                 :   21071900 :   if (!ctx
    5798                 :   16487600 :       || TREE_CODE (ctx) == FUNCTION_DECL
    5799                 :   27079000 :       || (CLASS_TYPE_P (ctx) && TYPE_BEING_DEFINED (ctx))
    5800                 :    4082420 :       || (TREE_CODE (decl) == TYPE_DECL
    5801                 :       2641 :           && LAMBDA_TYPE_P (TREE_TYPE (decl)))
    5802                 :   25154200 :       || (is_friend && !DECL_TEMPLATE_INFO (decl)))
    5803                 :            :     {
    5804                 :   16989600 :       if (DECL_LANG_SPECIFIC (decl)
    5805                 :   11912900 :           && DECL_TEMPLATE_INFO (decl)
    5806                 :   17176700 :           && DECL_TI_TEMPLATE (decl))
    5807                 :     187043 :         tmpl = DECL_TI_TEMPLATE (decl);
    5808                 :            :       /* If DECL is a TYPE_DECL for a class-template, then there won't
    5809                 :            :          be DECL_LANG_SPECIFIC.  The information equivalent to
    5810                 :            :          DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead.  */
    5811                 :    7189440 :       else if (DECL_IMPLICIT_TYPEDEF_P (decl)
    5812                 :    1875680 :                && TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
    5813                 :   16805400 :                && TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
    5814                 :            :         {
    5815                 :            :           /* Since a template declaration already existed for this
    5816                 :            :              class-type, we must be redeclaring it here.  Make sure
    5817                 :            :              that the redeclaration is valid.  */
    5818                 :       2838 :           redeclare_class_template (TREE_TYPE (decl),
    5819                 :            :                                     current_template_parms,
    5820                 :            :                                     current_template_constraints ());
    5821                 :            :           /* We don't need to create a new TEMPLATE_DECL; just use the
    5822                 :            :              one we already had.  */
    5823                 :       5676 :           tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
    5824                 :            :         }
    5825                 :            :       else
    5826                 :            :         {
    5827                 :   16799700 :           tmpl = build_template_decl (decl, current_template_parms,
    5828                 :            :                                       member_template_p);
    5829                 :   16799700 :           new_template_p = 1;
    5830                 :            : 
    5831                 :   16799700 :           if (DECL_LANG_SPECIFIC (decl)
    5832                 :   16799700 :               && DECL_TEMPLATE_SPECIALIZATION (decl))
    5833                 :            :             {
    5834                 :            :               /* A specialization of a member template of a template
    5835                 :            :                  class.  */
    5836                 :          0 :               SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
    5837                 :          0 :               DECL_TEMPLATE_INFO (tmpl) = DECL_TEMPLATE_INFO (decl);
    5838                 :          0 :               DECL_TEMPLATE_INFO (decl) = NULL_TREE;
    5839                 :            :             }
    5840                 :            :         }
    5841                 :            :     }
    5842                 :            :   else
    5843                 :            :     {
    5844                 :    4082240 :       tree a, t, current, parms;
    5845                 :    4082240 :       int i;
    5846                 :    4082240 :       tree tinfo = get_template_info (decl);
    5847                 :            : 
    5848                 :    4082240 :       if (!tinfo)
    5849                 :            :         {
    5850                 :         19 :           error ("template definition of non-template %q#D", decl);
    5851                 :         19 :           return error_mark_node;
    5852                 :            :         }
    5853                 :            : 
    5854                 :    4082230 :       tmpl = TI_TEMPLATE (tinfo);
    5855                 :            : 
    5856                 :    4082230 :       if (DECL_FUNCTION_TEMPLATE_P (tmpl)
    5857                 :    4010210 :           && DECL_TEMPLATE_INFO (decl) && DECL_TI_ARGS (decl)
    5858                 :    4010210 :           && DECL_TEMPLATE_SPECIALIZATION (decl)
    5859                 :    4082250 :           && DECL_MEMBER_TEMPLATE_P (tmpl))
    5860                 :            :         {
    5861                 :         13 :           tree new_tmpl;
    5862                 :            : 
    5863                 :            :           /* The declaration is a specialization of a member
    5864                 :            :              template, declared outside the class.  Therefore, the
    5865                 :            :              innermost template arguments will be NULL, so we
    5866                 :            :              replace them with the arguments determined by the
    5867                 :            :              earlier call to check_explicit_specialization.  */
    5868                 :         13 :           args = DECL_TI_ARGS (decl);
    5869                 :            : 
    5870                 :         13 :           new_tmpl
    5871                 :         13 :             = build_template_decl (decl, current_template_parms,
    5872                 :            :                                    member_template_p);
    5873                 :         13 :           DECL_TEMPLATE_RESULT (new_tmpl) = decl;
    5874                 :         13 :           TREE_TYPE (new_tmpl) = TREE_TYPE (decl);
    5875                 :         13 :           DECL_TI_TEMPLATE (decl) = new_tmpl;
    5876                 :         13 :           SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl);
    5877                 :         13 :           DECL_TEMPLATE_INFO (new_tmpl)
    5878                 :         13 :             = build_template_info (tmpl, args);
    5879                 :            : 
    5880                 :         13 :           register_specialization (new_tmpl,
    5881                 :            :                                    most_general_template (tmpl),
    5882                 :            :                                    args,
    5883                 :            :                                    is_friend, 0);
    5884                 :         13 :           return decl;
    5885                 :            :         }
    5886                 :            : 
    5887                 :            :       /* Make sure the template headers we got make sense.  */
    5888                 :            : 
    5889                 :    4082210 :       parms = DECL_TEMPLATE_PARMS (tmpl);
    5890                 :    4082210 :       i = TMPL_PARMS_DEPTH (parms);
    5891                 :   11465100 :       if (TMPL_ARGS_DEPTH (args) != i)
    5892                 :            :         {
    5893                 :          4 :           error ("expected %d levels of template parms for %q#D, got %d",
    5894                 :          8 :                  i, decl, TMPL_ARGS_DEPTH (args));
    5895                 :          4 :           DECL_INTERFACE_KNOWN (decl) = 1;
    5896                 :          4 :           return error_mark_node;
    5897                 :            :         }
    5898                 :            :       else
    5899                 :    8948630 :         for (current = decl; i > 0; --i, parms = TREE_CHAIN (parms))
    5900                 :            :           {
    5901                 :    9732880 :             a = TMPL_ARGS_LEVEL (args, i);
    5902                 :    4866440 :             t = INNERMOST_TEMPLATE_PARMS (parms);
    5903                 :            : 
    5904                 :    4866440 :             if (TREE_VEC_LENGTH (t) != TREE_VEC_LENGTH (a))
    5905                 :            :               {
    5906                 :         20 :                 if (current == decl)
    5907                 :         20 :                   error ("got %d template parameters for %q#D",
    5908                 :         20 :                          TREE_VEC_LENGTH (a), decl);
    5909                 :            :                 else
    5910                 :          0 :                   error ("got %d template parameters for %q#T",
    5911                 :          0 :                          TREE_VEC_LENGTH (a), current);
    5912                 :         20 :                 error ("  but %d required", TREE_VEC_LENGTH (t));
    5913                 :            :                 /* Avoid crash in import_export_decl.  */
    5914                 :         20 :                 DECL_INTERFACE_KNOWN (decl) = 1;
    5915                 :         20 :                 return error_mark_node;
    5916                 :            :               }
    5917                 :            : 
    5918                 :    4866420 :             if (current == decl)
    5919                 :            :               current = ctx;
    5920                 :     784231 :             else if (current == NULL_TREE)
    5921                 :            :               /* Can happen in erroneous input.  */
    5922                 :            :               break;
    5923                 :            :             else
    5924                 :     784231 :               current = get_containing_scope (current);
    5925                 :            :           }
    5926                 :            : 
    5927                 :            :       /* Check that the parms are used in the appropriate qualifying scopes
    5928                 :            :          in the declarator.  */
    5929                 :    8164380 :       if (!comp_template_args
    5930                 :    4082190 :           (TI_ARGS (tinfo),
    5931                 :    4082190 :            TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl)))))
    5932                 :            :         {
    5933                 :          4 :           error ("template arguments to %qD do not match original "
    5934                 :          4 :                  "template %qD", decl, DECL_TEMPLATE_RESULT (tmpl));
    5935                 :          4 :           if (!uses_template_parms (TI_ARGS (tinfo)))
    5936                 :          4 :             inform (input_location, "use %<template<>%> for"
    5937                 :            :                     " an explicit specialization");
    5938                 :            :           /* Avoid crash in import_export_decl.  */
    5939                 :          4 :           DECL_INTERFACE_KNOWN (decl) = 1;
    5940                 :          4 :           return error_mark_node;
    5941                 :            :         }
    5942                 :            :     }
    5943                 :            : 
    5944                 :   21071800 :   DECL_TEMPLATE_RESULT (tmpl) = decl;
    5945                 :   21071800 :   TREE_TYPE (tmpl) = TREE_TYPE (decl);
    5946                 :            : 
    5947                 :            :   /* Push template declarations for global functions and types.  Note
    5948                 :            :      that we do not try to push a global template friend declared in a
    5949                 :            :      template class; such a thing may well depend on the template
    5950                 :            :      parameters of the class.  */
    5951                 :   21071800 :   if (new_template_p && !ctx
    5952                 :   21071800 :       && !(is_friend && template_class_depth (current_class_type) > 0))
    5953                 :            :     {
    5954                 :    4284120 :       tmpl = pushdecl_namespace_level (tmpl, is_friend);
    5955                 :    4284120 :       if (tmpl == error_mark_node)
    5956                 :            :         return error_mark_node;
    5957                 :            : 
    5958                 :            :       /* Hide template friend classes that haven't been declared yet.  */
    5959                 :    4284070 :       if (is_friend && TREE_CODE (decl) == TYPE_DECL)
    5960                 :            :         {
    5961                 :       4476 :           DECL_ANTICIPATED (tmpl) = 1;
    5962                 :       4476 :           DECL_FRIEND_P (tmpl) = 1;
    5963                 :            :         }
    5964                 :            :     }
    5965                 :            : 
    5966                 :   21071800 :   if (is_primary)
    5967                 :            :     {
    5968                 :    5805330 :       tree parms = DECL_TEMPLATE_PARMS (tmpl);
    5969                 :            : 
    5970                 :    5805330 :       DECL_PRIMARY_TEMPLATE (tmpl) = tmpl;
    5971                 :            : 
    5972                 :            :       /* Give template template parms a DECL_CONTEXT of the template
    5973                 :            :          for which they are a parameter.  */
    5974                 :    5805330 :       parms = INNERMOST_TEMPLATE_PARMS (parms);
    5975                 :   16278000 :       for (int i = TREE_VEC_LENGTH (parms) - 1; i >= 0; --i)
    5976                 :            :         {
    5977                 :   10472700 :           tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
    5978                 :   10472700 :           if (TREE_CODE (parm) == TEMPLATE_DECL)
    5979                 :      33702 :             DECL_CONTEXT (parm) = tmpl;
    5980                 :            :         }
    5981                 :            : 
    5982                 :    5805330 :       if (TREE_CODE (decl) == TYPE_DECL
    5983                 :    5805330 :           && TYPE_DECL_ALIAS_P (decl))
    5984                 :            :         {
    5985                 :     404015 :           if (tree constr
    5986                 :     404015 :               = TEMPLATE_PARMS_CONSTRAINTS (DECL_TEMPLATE_PARMS (tmpl)))
    5987                 :            :             {
    5988                 :            :               /* ??? Why don't we do this here for all templates?  */
    5989                 :       7320 :               constr = build_constraints (constr, NULL_TREE);
    5990                 :       7320 :               set_constraints (decl, constr);
    5991                 :            :             }
    5992                 :     404015 :           if (complex_alias_template_p (tmpl))
    5993                 :      23206 :             TEMPLATE_DECL_COMPLEX_ALIAS_P (tmpl) = true;
    5994                 :            :         }
    5995                 :            :     }
    5996                 :            : 
    5997                 :            :   /* The DECL_TI_ARGS of DECL contains full set of arguments referring
    5998                 :            :      back to its most general template.  If TMPL is a specialization,
    5999                 :            :      ARGS may only have the innermost set of arguments.  Add the missing
    6000                 :            :      argument levels if necessary.  */
    6001                 :   21071800 :   if (DECL_TEMPLATE_INFO (tmpl))
    6002                 :       6962 :     args = add_outermost_template_args (DECL_TI_ARGS (tmpl), args);
    6003                 :            : 
    6004                 :   21071800 :   info = build_template_info (tmpl, args);
    6005                 :            : 
    6006                 :   28263700 :   if (DECL_IMPLICIT_TYPEDEF_P (decl))
    6007                 :    1878210 :     SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl), info);
    6008                 :            :   else
    6009                 :            :     {
    6010                 :   19193600 :       if (is_primary)
    6011                 :    4062050 :         retrofit_lang_decl (decl);
    6012                 :   19193600 :       if (DECL_LANG_SPECIFIC (decl))
    6013                 :   16266600 :         DECL_TEMPLATE_INFO (decl) = info;
    6014                 :            :     }
    6015                 :            : 
    6016                 :   21071800 :   if (flag_implicit_templates
    6017                 :   20310300 :       && !is_friend
    6018                 :   20003100 :       && TREE_PUBLIC (decl)
    6019                 :   10634100 :       && VAR_OR_FUNCTION_DECL_P (decl))
    6020                 :            :     /* Set DECL_COMDAT on template instantiations; if we force
    6021                 :            :        them to be emitted by explicit instantiation,
    6022                 :            :        mark_needed will tell cgraph to do the right thing.  */
    6023                 :   10629000 :     DECL_COMDAT (decl) = true;
    6024                 :            : 
    6025                 :   21071800 :   return DECL_TEMPLATE_RESULT (tmpl);
    6026                 :            : }
    6027                 :            : 
    6028                 :            : tree
    6029                 :   20083900 : push_template_decl (tree decl)
    6030                 :            : {
    6031                 :   20083900 :   return push_template_decl_real (decl, false);
    6032                 :            : }
    6033                 :            : 
    6034                 :            : /* FN is an inheriting constructor that inherits from the constructor
    6035                 :            :    template INHERITED; turn FN into a constructor template with a matching
    6036                 :            :    template header.  */
    6037                 :            : 
    6038                 :            : tree
    6039                 :      11946 : add_inherited_template_parms (tree fn, tree inherited)
    6040                 :            : {
    6041                 :      11946 :   tree inner_parms
    6042                 :      11946 :     = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (inherited));
    6043                 :      11946 :   inner_parms = copy_node (inner_parms);
    6044                 :      11946 :   tree parms
    6045                 :      11946 :     = tree_cons (size_int (processing_template_decl + 1),
    6046                 :            :                  inner_parms, current_template_parms);
    6047                 :      11946 :   tree tmpl = build_template_decl (fn, parms, /*member*/true);
    6048                 :      11946 :   tree args = template_parms_to_args (parms);
    6049                 :      11946 :   DECL_TEMPLATE_INFO (fn) = build_template_info (tmpl, args);
    6050                 :      11946 :   TREE_TYPE (tmpl) = TREE_TYPE (fn);
    6051                 :      11946 :   DECL_TEMPLATE_RESULT (tmpl) = fn;
    6052                 :      11946 :   DECL_ARTIFICIAL (tmpl) = true;
    6053                 :      11946 :   DECL_PRIMARY_TEMPLATE (tmpl) = tmpl;
    6054                 :      11946 :   return tmpl;
    6055                 :            : }
    6056                 :            : 
    6057                 :            : /* Called when a class template TYPE is redeclared with the indicated
    6058                 :            :    template PARMS, e.g.:
    6059                 :            : 
    6060                 :            :      template <class T> struct S;
    6061                 :            :      template <class T> struct S {};  */
    6062                 :            : 
    6063                 :            : bool
    6064                 :     237851 : redeclare_class_template (tree type, tree parms, tree cons)
    6065                 :            : {
    6066                 :     237851 :   tree tmpl;
    6067                 :     237851 :   tree tmpl_parms;
    6068                 :     237851 :   int i;
    6069                 :            : 
    6070                 :     475702 :   if (!TYPE_TEMPLATE_INFO (type))
    6071                 :            :     {
    6072                 :          0 :       error ("%qT is not a template type", type);
    6073                 :          0 :       return false;
    6074                 :            :     }
    6075                 :            : 
    6076                 :     237851 :   tmpl = TYPE_TI_TEMPLATE (type);
    6077                 :     237851 :   if (!PRIMARY_TEMPLATE_P (tmpl))
    6078                 :            :     /* The type is nested in some template class.  Nothing to worry
    6079                 :            :        about here; there are no new template parameters for the nested
    6080                 :            :        type.  */
    6081                 :            :     return true;
    6082                 :            : 
    6083                 :     237851 :   if (!parms)
    6084                 :            :     {
    6085                 :          4 :       error ("template specifiers not specified in declaration of %qD",
    6086                 :            :              tmpl);
    6087                 :          4 :       return false;
    6088                 :            :     }
    6089                 :            : 
    6090                 :     237847 :   parms = INNERMOST_TEMPLATE_PARMS (parms);
    6091                 :     237847 :   tmpl_parms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl);
    6092                 :            : 
    6093                 :     237847 :   if (TREE_VEC_LENGTH (parms) != TREE_VEC_LENGTH (tmpl_parms))
    6094                 :            :     {
    6095                 :         24 :       error_n (input_location, TREE_VEC_LENGTH (parms),
    6096                 :            :                "redeclared with %d template parameter",
    6097                 :            :                "redeclared with %d template parameters",
    6098                 :         24 :                TREE_VEC_LENGTH (parms));
    6099                 :         24 :       inform_n (DECL_SOURCE_LOCATION (tmpl), TREE_VEC_LENGTH (tmpl_parms),
    6100                 :            :                 "previous declaration %qD used %d template parameter",
    6101                 :            :                 "previous declaration %qD used %d template parameters",
    6102                 :         24 :                 tmpl, TREE_VEC_LENGTH (tmpl_parms));
    6103                 :         24 :       return false;
    6104                 :            :     }
    6105                 :            : 
    6106                 :     588720 :   for (i = 0; i < TREE_VEC_LENGTH (tmpl_parms); ++i)
    6107                 :            :     {
    6108                 :     350940 :       tree tmpl_parm;
    6109                 :     350940 :       tree parm;
    6110                 :     350940 :       tree tmpl_default;
    6111                 :     350940 :       tree parm_default;
    6112                 :            : 
    6113                 :     350940 :       if (TREE_VEC_ELT (tmpl_parms, i) == error_mark_node
    6114                 :     350940 :           || TREE_VEC_ELT (parms, i) == error_mark_node)
    6115                 :          0 :         continue;
    6116                 :            : 
    6117                 :     350940 :       tmpl_parm = TREE_VALUE (TREE_VEC_ELT (tmpl_parms, i));
    6118                 :     701875 :       if (error_operand_p (tmpl_parm))
    6119                 :            :         return false;
    6120                 :            : 
    6121                 :     350931 :       parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
    6122                 :     350931 :       tmpl_default = TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i));
    6123                 :     350931 :       parm_default = TREE_PURPOSE (TREE_VEC_ELT (parms, i));
    6124                 :            : 
    6125                 :            :       /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
    6126                 :            :          TEMPLATE_DECL.  */
    6127                 :     350931 :       if (TREE_CODE (tmpl_parm) != TREE_CODE (parm)
    6128                 :     350919 :           || (TREE_CODE (tmpl_parm) != TYPE_DECL
    6129                 :      28403 :               && !same_type_p (TREE_TYPE (tmpl_parm), TREE_TYPE (parm)))
    6130                 :     350908 :           || (TREE_CODE (tmpl_parm) != PARM_DECL
    6131                 :     646859 :               && (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (tmpl_parm))
    6132                 :     323734 :                   != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm))))
    6133                 :     701836 :           || (TREE_CODE (tmpl_parm) == PARM_DECL
    6134                 :      55566 :               && (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (tmpl_parm))
    6135                 :      27783 :                   != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)))))
    6136                 :            :         {
    6137                 :         29 :           auto_diagnostic_group d;
    6138                 :         29 :           error ("template parameter %q+#D", tmpl_parm);
    6139                 :         29 :           inform (input_location, "redeclared here as %q#D", parm);
    6140                 :         29 :           return false;
    6141                 :            :         }
    6142                 :            : 
    6143                 :            :       /* The parameters can be declared to introduce different
    6144                 :            :          constraints.  */
    6145                 :     350902 :       tree p1 = TREE_VEC_ELT (tmpl_parms, i);
    6146                 :     350902 :       tree p2 = TREE_VEC_ELT (parms, i);
    6147                 :     350902 :       if (!template_parameter_constraints_equivalent_p (p1, p2))
    6148                 :            :         {
    6149                 :          1 :           auto_diagnostic_group d;
    6150                 :          1 :           error ("declaration of template parameter %q+#D with different "
    6151                 :            :                  "constraints", parm);
    6152                 :          1 :           inform (DECL_SOURCE_LOCATION (tmpl_parm),
    6153                 :            :                   "original declaration appeared here");
    6154                 :          1 :           return false;
    6155                 :            :         }
    6156                 :            : 
    6157                 :     350901 :       if (tmpl_default != NULL_TREE && parm_default != NULL_TREE)
    6158                 :            :         {
    6159                 :            :           /* We have in [temp.param]:
    6160                 :            : 
    6161                 :            :              A template-parameter may not be given default arguments
    6162                 :            :              by two different declarations in the same scope.  */
    6163                 :          4 :           auto_diagnostic_group d;
    6164                 :          4 :           error_at (input_location, "redefinition of default argument for %q#D", parm);
    6165                 :          4 :           inform (DECL_SOURCE_LOCATION (tmpl_parm),
    6166                 :            :                   "original definition appeared here");
    6167                 :          4 :           return false;
    6168                 :            :         }
    6169                 :            : 
    6170                 :     350897 :       if (parm_default != NULL_TREE)
    6171                 :            :         /* Update the previous template parameters (which are the ones
    6172                 :            :            that will really count) with the new default value.  */
    6173                 :       6792 :         TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i)) = parm_default;
    6174                 :     344105 :       else if (tmpl_default != NULL_TREE)
    6175                 :            :         /* Update the new parameters, too; they'll be used as the
    6176                 :            :            parameters for any members.  */
    6177                 :     112315 :         TREE_PURPOSE (TREE_VEC_ELT (parms, i)) = tmpl_default;
    6178                 :            : 
    6179                 :            :       /* Give each template template parm in this redeclaration a
    6180                 :            :          DECL_CONTEXT of the template for which they are a parameter.  */
    6181                 :     350897 :       if (TREE_CODE (parm) == TEMPLATE_DECL)
    6182                 :            :         {
    6183                 :        609 :           gcc_assert (DECL_CONTEXT (parm) == NULL_TREE);
    6184                 :        609 :           DECL_CONTEXT (parm) = tmpl;
    6185                 :            :         }
    6186                 :            : 
    6187                 :     350897 :       if (TREE_CODE (parm) == TYPE_DECL)
    6188                 :     322508 :         TEMPLATE_TYPE_PARM_FOR_CLASS (TREE_TYPE (parm)) = true;
    6189                 :            :     }
    6190                 :            : 
    6191                 :     237780 :   tree ci = get_constraints (tmpl);
    6192                 :     237825 :   tree req1 = ci ? CI_TEMPLATE_REQS (ci) : NULL_TREE;
    6193                 :     237825 :   tree req2 = cons ? CI_TEMPLATE_REQS (cons) : NULL_TREE;
    6194                 :            : 
    6195                 :            :   /* Two classes with different constraints declare different entities.  */
    6196                 :     237780 :   if (!cp_tree_equal (req1, req2))
    6197                 :            :     {
    6198                 :          1 :       auto_diagnostic_group d;
    6199                 :          1 :       error_at (input_location, "redeclaration %q#D with different "
    6200                 :            :                                 "constraints", tmpl);
    6201                 :          1 :       inform (DECL_SOURCE_LOCATION (tmpl),
    6202                 :            :               "original declaration appeared here");
    6203                 :          1 :       return false;
    6204                 :            :     }
    6205                 :            : 
    6206                 :            :     return true;
    6207                 :            : }
    6208                 :            : 
    6209                 :            : /* The actual substitution part of instantiate_non_dependent_expr_sfinae,
    6210                 :            :    to be used when the caller has already checked
    6211                 :            :    (processing_template_decl
    6212                 :            :     && !instantiation_dependent_expression_p (expr)
    6213                 :            :     && potential_constant_expression (expr))
    6214                 :            :    and cleared processing_template_decl.  */
    6215                 :            : 
    6216                 :            : tree
    6217                 :   13137000 : instantiate_non_dependent_expr_internal (tree expr, tsubst_flags_t complain)
    6218                 :            : {
    6219                 :   13137000 :   return tsubst_copy_and_build (expr,
    6220                 :            :                                 /*args=*/NULL_TREE,
    6221                 :            :                                 complain,
    6222                 :            :                                 /*in_decl=*/NULL_TREE,
    6223                 :            :                                 /*function_p=*/false,
    6224                 :   13137000 :                                 /*integral_constant_expression_p=*/true);
    6225                 :            : }
    6226                 :            : 
    6227                 :            : /* Simplify EXPR if it is a non-dependent expression.  Returns the
    6228                 :            :    (possibly simplified) expression.  */
    6229                 :            : 
    6230                 :            : tree
    6231                 :   11209200 : instantiate_non_dependent_expr_sfinae (tree expr, tsubst_flags_t complain)
    6232                 :            : {
    6233                 :   11209200 :   if (expr == NULL_TREE)
    6234                 :            :     return NULL_TREE;
    6235                 :            : 
    6236                 :            :   /* If we're in a template, but EXPR isn't value dependent, simplify
    6237                 :            :      it.  We're supposed to treat:
    6238                 :            : 
    6239                 :            :        template <typename T> void f(T[1 + 1]);
    6240                 :            :        template <typename T> void f(T[2]);
    6241                 :            : 
    6242                 :            :      as two declarations of the same function, for example.  */
    6243                 :   11209200 :   if (processing_template_decl
    6244                 :   11209200 :       && is_nondependent_constant_expression (expr))
    6245                 :            :     {
    6246                 :    2910710 :       processing_template_decl_sentinel s;
    6247                 :    2910710 :       expr = instantiate_non_dependent_expr_internal (expr, complain);
    6248                 :            :     }
    6249                 :            :   return expr;
    6250                 :            : }
    6251                 :            : 
    6252                 :            : tree
    6253                 :    2308630 : instantiate_non_dependent_expr (tree expr)
    6254                 :            : {
    6255                 :    2308630 :   return instantiate_non_dependent_expr_sfinae (expr, tf_error);
    6256                 :            : }
    6257                 :            : 
    6258                 :            : /* Like instantiate_non_dependent_expr, but return NULL_TREE rather than
    6259                 :            :    an uninstantiated expression.  */
    6260                 :            : 
    6261                 :            : tree
    6262                 :   17566200 : instantiate_non_dependent_or_null (tree expr)
    6263                 :            : {
    6264                 :   17566200 :   if (expr == NULL_TREE)
    6265                 :            :     return NULL_TREE;
    6266                 :   16990400 :   if (processing_template_decl)
    6267                 :            :     {
    6268                 :       3209 :       if (!is_nondependent_constant_expression (expr))
    6269                 :            :         expr = NULL_TREE;
    6270                 :            :       else
    6271                 :            :         {
    6272                 :       2713 :           processing_template_decl_sentinel s;
    6273                 :       2713 :           expr = instantiate_non_dependent_expr_internal (expr, tf_error);
    6274                 :            :         }
    6275                 :            :     }
    6276                 :            :   return expr;
    6277                 :            : }
    6278                 :            : 
    6279                 :            : /* True iff T is a specialization of a variable template.  */
    6280                 :            : 
    6281                 :            : bool
    6282                 :    8083240 : variable_template_specialization_p (tree t)
    6283                 :            : {
    6284                 :   16166500 :   if (!VAR_P (t) || !DECL_LANG_SPECIFIC (t) || !DECL_TEMPLATE_INFO (t))
    6285                 :            :     return false;
    6286                 :     378068 :   tree tmpl = DECL_TI_TEMPLATE (t);
    6287                 :     378068 :   return variable_template_p (tmpl);
    6288                 :            : }
    6289                 :            : 
    6290                 :            : /* Return TRUE iff T is a type alias, a TEMPLATE_DECL for an alias
    6291                 :            :    template declaration, or a TYPE_DECL for an alias declaration.  */
    6292                 :            : 
    6293                 :            : bool
    6294                 :   11534000 : alias_type_or_template_p (tree t)
    6295                 :            : {
    6296                 :   11534000 :   if (t == NULL_TREE)
    6297                 :            :     return false;
    6298                 :          0 :   return ((TREE_CODE (t) == TYPE_DECL && TYPE_DECL_ALIAS_P (t))
    6299                 :   11534000 :           || (TYPE_P (t)
    6300                 :   11534000 :               && TYPE_NAME (t)
    6301                 :   11534000 :               && TYPE_DECL_ALIAS_P (TYPE_NAME (t)))
    6302                 :   22762000 :           || DECL_ALIAS_TEMPLATE_P (t));
    6303                 :            : }
    6304                 :            : 
    6305                 :            : /* If T is a specialization of an alias template, return it; otherwise return
    6306                 :            :    NULL_TREE.  If TRANSPARENT_TYPEDEFS is true, look through other aliases.  */
    6307                 :            : 
    6308                 :            : tree
    6309                 :  864626000 : alias_template_specialization_p (const_tree t,
    6310                 :            :                                  bool transparent_typedefs)
    6311                 :            : {
    6312                 :  864626000 :   if (!TYPE_P (t))
    6313                 :            :     return NULL_TREE;
    6314                 :            : 
    6315                 :            :   /* It's an alias template specialization if it's an alias and its
    6316                 :            :      TYPE_NAME is a specialization of a primary template.  */
    6317                 :  864626000 :   if (typedef_variant_p (t))
    6318                 :            :     {
    6319                 :   50063900 :       if (tree tinfo = TYPE_ALIAS_TEMPLATE_INFO (t))
    6320                 :   43671400 :         if (PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo)))
    6321                 :            :           return CONST_CAST_TREE (t);
    6322                 :   37149900 :       if (transparent_typedefs)
    6323                 :      17564 :         return alias_template_specialization_p (DECL_ORIGINAL_TYPE
    6324                 :            :                                                 (TYPE_NAME (t)),
    6325                 :      17564 :                                                 transparent_typedefs);
    6326                 :            :     }
    6327                 :            : 
    6328                 :            :   return NULL_TREE;
    6329                 :            : }
    6330                 :            : 
    6331                 :            : /* An alias template is complex from a SFINAE perspective if a template-id
    6332                 :            :    using that alias can be ill-formed when the expansion is not, as with
    6333                 :            :    the void_t template.  We determine this by checking whether the
    6334                 :            :    expansion for the alias template uses all its template parameters.  */
    6335                 :            : 
    6336                 :            : struct uses_all_template_parms_data
    6337                 :            : {
    6338                 :            :   int level;
    6339                 :            :   bool *seen;
    6340                 :            : };
    6341                 :            : 
    6342                 :            : static int
    6343                 :     707483 : uses_all_template_parms_r (tree t, void *data_)
    6344                 :            : {
    6345                 :     707483 :   struct uses_all_template_parms_data &data
    6346                 :            :     = *(struct uses_all_template_parms_data*)data_;
    6347                 :     707483 :   tree idx = get_template_parm_index (t);
    6348                 :            : 
    6349                 :     707483 :   if (TEMPLATE_PARM_LEVEL (idx) == data.level)
    6350                 :     602246 :     data.seen[TEMPLATE_PARM_IDX (idx)] = true;
    6351                 :     707483 :   return 0;
    6352                 :            : }
    6353                 :            : 
    6354                 :            : static bool
    6355                 :     404015 : complex_alias_template_p (const_tree tmpl)
    6356                 :            : {
    6357                 :            :   /* A renaming alias isn't complex.  */
    6358                 :     404015 :   if (get_underlying_template (CONST_CAST_TREE (tmpl)) != tmpl)
    6359                 :            :     return false;
    6360                 :            : 
    6361                 :            :   /* Any other constrained alias is complex.  */
    6362                 :     389812 :   if (get_constraints (tmpl))
    6363                 :            :     return true;
    6364                 :            : 
    6365                 :     382492 :   struct uses_all_template_parms_data data;
    6366                 :     382492 :   tree pat = DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl));
    6367                 :     382492 :   tree parms = DECL_TEMPLATE_PARMS (tmpl);
    6368                 :     382492 :   data.level = TMPL_PARMS_DEPTH (parms);
    6369                 :     382492 :   int len = TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS (parms));
    6370                 :     382492 :   data.seen = XALLOCAVEC (bool, len);
    6371                 :     937194 :   for (int i = 0; i < len; ++i)
    6372                 :     554702 :     data.seen[i] = false;
    6373                 :            : 
    6374                 :     382492 :   for_each_template_parm (pat, uses_all_template_parms_r, &data, NULL, true);
    6375                 :     907333 :   for (int i = 0; i < len; ++i)
    6376                 :     540727 :     if (!data.seen[i])
    6377                 :            :       return true;
    6378                 :            :   return false;
    6379                 :            : }
    6380                 :            : 
    6381                 :            : /* If T is a specialization of a complex alias template with dependent
    6382                 :            :    template-arguments, return it; otherwise return NULL_TREE.  If T is a
    6383                 :            :    typedef to such a specialization, return the specialization.  */
    6384                 :            : 
    6385                 :            : tree
    6386                 :  151992000 : dependent_alias_template_spec_p (const_tree t, bool transparent_typedefs)
    6387                 :            : {
    6388                 :  151992000 :   if (!TYPE_P (t) || !typedef_variant_p (t))
    6389                 :  122677000 :     return NULL_TREE;
    6390                 :            : 
    6391                 :   29314800 :   tree tinfo = TYPE_ALIAS_TEMPLATE_INFO (t);
    6392                 :   28266500 :   if (tinfo
    6393                 :   27998500 :       && TEMPLATE_DECL_COMPLEX_ALIAS_P (TI_TEMPLATE (tinfo))
    6394                 :   30533300 :       && (any_dependent_template_arguments_p
    6395                 :    2266790 :           (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo)))))
    6396                 :            :     return CONST_CAST_TREE (t);
    6397                 :            : 
    6398                 :   28300500 :   if (transparent_typedefs)
    6399                 :            :     {
    6400                 :    1294920 :       tree utype = DECL_ORIGINAL_TYPE (TYPE_NAME (t));
    6401                 :    1294920 :       return dependent_alias_template_spec_p (utype, transparent_typedefs);
    6402                 :            :     }
    6403                 :            : 
    6404                 :            :   return NULL_TREE;
    6405                 :            : }
    6406                 :            : 
    6407                 :            : /* Return the number of innermost template parameters in TMPL.  */
    6408                 :            : 
    6409                 :            : static int
    6410                 :     426382 : num_innermost_template_parms (const_tree tmpl)
    6411                 :            : {
    6412                 :     426382 :   tree parms = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl));
    6413                 :     426382 :   return TREE_VEC_LENGTH (parms);
    6414                 :            : }
    6415                 :            : 
    6416                 :            : /* Return either TMPL or another template that it is equivalent to under DR
    6417                 :            :    1286: An alias that just changes the name of a template is equivalent to
    6418                 :            :    the other template.  */
    6419                 :            : 
    6420                 :            : static tree
    6421                 :    2113990 : get_underlying_template (tree tmpl)
    6422                 :            : {
    6423                 :    2113990 :   gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
    6424                 :    2129100 :   while (DECL_ALIAS_TEMPLATE_P (tmpl))
    6425                 :            :     {
    6426                 :            :       /* Determine if the alias is equivalent to an underlying template.  */
    6427                 :     664498 :       tree orig_type = DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl));
    6428                 :            :       /* The underlying type may have been ill-formed. Don't proceed.  */
    6429                 :     664498 :       if (!orig_type)
    6430                 :            :         break;
    6431                 :     877816 :       tree tinfo = TYPE_TEMPLATE_INFO_MAYBE_ALIAS (orig_type);
    6432                 :     213323 :       if (!tinfo)
    6433                 :            :         break;
    6434                 :            : 
    6435                 :     213235 :       tree underlying = TI_TEMPLATE (tinfo);
    6436                 :     213235 :       if (!PRIMARY_TEMPLATE_P (underlying)
    6437                 :     426426 :           || (num_innermost_template_parms (tmpl)
    6438                 :     213191 :               != num_innermost_template_parms (underlying)))
    6439                 :            :         break;
    6440                 :            : 
    6441                 :      81549 :       tree alias_args = INNERMOST_TEMPLATE_ARGS (generic_targs_for (tmpl));
    6442                 :      81549 :       if (!comp_template_args (TI_ARGS (tinfo), alias_args))
    6443                 :            :         break;
    6444                 :            : 
    6445                 :            :       /* If TMPL adds or changes any constraints, it isn't equivalent.  I think
    6446                 :            :          it's appropriate to treat a less-constrained alias as equivalent.  */
    6447                 :      15113 :       if (!at_least_as_constrained (underlying, tmpl))
    6448                 :            :         break;
    6449                 :            : 
    6450                 :            :       /* Alias is equivalent.  Strip it and repeat.  */
    6451                 :            :       tmpl = underlying;
    6452                 :            :     }
    6453                 :            : 
    6454                 :    2113990 :   return tmpl;
    6455                 :            : }
    6456                 :            : 
    6457                 :            : /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
    6458                 :            :    must be a reference-to-function or a pointer-to-function type, as specified
    6459                 :            :    in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
    6460                 :            :    and check that the resulting function has external linkage.  */
    6461                 :            : 
    6462                 :            : static tree
    6463                 :       1723 : convert_nontype_argument_function (tree type, tree expr,
    6464                 :            :                                    tsubst_flags_t complain)
    6465                 :            : {
    6466                 :       1723 :   tree fns = expr;
    6467                 :       1723 :   tree fn, fn_no_ptr;
    6468                 :       1723 :   linkage_kind linkage;
    6469                 :            : 
    6470                 :       1723 :   fn = instantiate_type (type, fns, tf_none);
    6471                 :       1723 :   if (fn == error_mark_node)
    6472                 :            :     return error_mark_node;
    6473                 :            : 
    6474                 :       1715 :   if (value_dependent_expression_p (fn))
    6475                 :         24 :     goto accept;
    6476                 :            : 
    6477                 :       1691 :   fn_no_ptr = strip_fnptr_conv (fn);
    6478                 :       1691 :   if (TREE_CODE (fn_no_ptr) == ADDR_EXPR)
    6479                 :       1397 :     fn_no_ptr = TREE_OPERAND (fn_no_ptr, 0);
    6480                 :       1691 :   if (BASELINK_P (fn_no_ptr))
    6481                 :        112 :     fn_no_ptr = BASELINK_FUNCTIONS (fn_no_ptr);
    6482                 :            : 
    6483                 :            :   /* [temp.arg.nontype]/1
    6484                 :            : 
    6485                 :            :      A template-argument for a non-type, non-template template-parameter
    6486                 :            :      shall be one of:
    6487                 :            :      [...]
    6488                 :            :      -- the address of an object or function with external [C++11: or
    6489                 :            :         internal] linkage.  */
    6490                 :            : 
    6491                 :       1691 :   STRIP_ANY_LOCATION_WRAPPER (fn_no_ptr);
    6492                 :       1691 :   if (TREE_CODE (fn_no_ptr) != FUNCTION_DECL)
    6493                 :            :     {
    6494                 :         35 :       if (complain & tf_error)
    6495                 :            :         {
    6496                 :         20 :           location_t loc = cp_expr_loc_or_input_loc (expr);
    6497                 :         20 :           error_at (loc, "%qE is not a valid template argument for type %qT",
    6498                 :            :                     expr, type);
    6499                 :         20 :           if (TYPE_PTR_P (type))
    6500                 :         14 :             inform (loc, "it must be the address of a function "
    6501                 :            :                     "with external linkage");
    6502                 :            :           else
    6503                 :          6 :             inform (loc, "it must be the name of a function with "
    6504                 :            :                     "external linkage");
    6505                 :            :         }
    6506                 :         35 :       return NULL_TREE;
    6507                 :            :     }
    6508                 :            : 
    6509                 :       1656 :   linkage = decl_linkage (fn_no_ptr);
    6510                 :       1656 :   if (cxx_dialect >= cxx11 ? linkage == lk_none : linkage != lk_external)
    6511                 :            :     {
    6512                 :         11 :       if (complain & tf_error)
    6513                 :            :         {
    6514                 :          5 :           location_t loc = cp_expr_loc_or_input_loc (expr);
    6515                 :          5 :           if (cxx_dialect >= cxx11)
    6516                 :          3 :             error_at (loc, "%qE is not a valid template argument for type "
    6517                 :            :                       "%qT because %qD has no linkage",
    6518                 :            :                       expr, type, fn_no_ptr);
    6519                 :            :           else
    6520                 :          2 :             error_at (loc, "%qE is not a valid template argument for type "
    6521                 :            :                       "%qT because %qD does not have external linkage",
    6522                 :            :                       expr, type, fn_no_ptr);
    6523                 :            :         }
    6524                 :         11 :       return NULL_TREE;
    6525                 :            :     }
    6526                 :            : 
    6527                 :       1645 :  accept:
    6528                 :       1669 :   if (TYPE_REF_P (type))
    6529                 :            :     {
    6530                 :        271 :       if (REFERENCE_REF_P (fn))
    6531                 :         12 :         fn = TREE_OPERAND (fn, 0);
    6532                 :            :       else
    6533                 :        259 :         fn = build_address (fn);
    6534                 :            :     }
    6535                 :       1669 :   if (!same_type_ignoring_top_level_qualifiers_p (type, TREE_TYPE (fn)))
    6536                 :        259 :     fn = build_nop (type, fn);
    6537                 :            : 
    6538                 :            :   return fn;
    6539                 :            : }
    6540                 :            : 
    6541                 :            : /* Subroutine of convert_nontype_argument.
    6542                 :            :    Check if EXPR of type TYPE is a valid pointer-to-member constant.
    6543                 :            :    Emit an error otherwise.  */
    6544                 :            : 
    6545                 :            : static bool
    6546                 :       2073 : check_valid_ptrmem_cst_expr (tree type, tree expr,
    6547                 :            :                              tsubst_flags_t complain)
    6548                 :            : {
    6549                 :       2073 :   tree orig_expr = expr;
    6550                 :       2073 :   STRIP_NOPS (expr);
    6551                 :       2073 :   if (null_ptr_cst_p (expr))
    6552                 :            :     return true;
    6553                 :       2072 :   if (TREE_CODE (expr) == PTRMEM_CST
    6554                 :       4694 :       && same_type_p (TYPE_PTRMEM_CLASS_TYPE (type),
    6555                 :            :                       PTRMEM_CST_CLASS (expr)))
    6556                 :            :     return true;
    6557                 :        169 :   if (cxx_dialect >= cxx11 && null_member_pointer_value_p (expr))
    6558                 :            :     return true;
    6559                 :         58 :   if (processing_template_decl
    6560                 :          0 :       && TREE_CODE (expr) == ADDR_EXPR
    6561                 :         58 :       && TREE_CODE (TREE_OPERAND (expr, 0)) == OFFSET_REF)
    6562                 :            :     return true;
    6563                 :         58 :   if (complain & tf_error)
    6564                 :            :     {
    6565                 :         28 :       location_t loc = cp_expr_loc_or_input_loc (orig_expr);
    6566                 :         28 :       error_at (loc, "%qE is not a valid template argument for type %qT",
    6567                 :            :                 orig_expr, type);
    6568                 :         28 :       if (TREE_CODE (expr) != PTRMEM_CST)
    6569                 :         14 :         inform (loc, "it must be a pointer-to-member of the form %<&X::Y%>");
    6570                 :            :       else
    6571                 :         20 :         inform (loc, "because it is a member of %qT", PTRMEM_CST_CLASS (expr));
    6572                 :            :     }
    6573                 :            :   return false;
    6574                 :            : }
    6575                 :            : 
    6576                 :            : /* Returns TRUE iff the address of OP is value-dependent.
    6577                 :            : 
    6578                 :            :    14.6.2.4 [temp.dep.temp]:
    6579                 :            :    A non-integral non-type template-argument is dependent if its type is
    6580                 :            :    dependent or it has either of the following forms
    6581                 :            :      qualified-id
    6582                 :            :      & qualified-id
    6583                 :            :    and contains a nested-name-specifier which specifies a class-name that
    6584                 :            :    names a dependent type.
    6585                 :            : 
    6586                 :            :    We generalize this to just say that the address of a member of a
    6587                 :            :    dependent class is value-dependent; the above doesn't cover the
    6588                 :            :    address of a static data member named with an unqualified-id.  */
    6589                 :            : 
    6590                 :            : static bool
    6591                 :      96855 : has_value_dependent_address (tree op)
    6592                 :            : {
    6593                 :      96855 :   STRIP_ANY_LOCATION_WRAPPER (op);
    6594                 :            : 
    6595                 :            :   /* We could use get_inner_reference here, but there's no need;
    6596                 :            :      this is only relevant for template non-type arguments, which
    6597                 :            :      can only be expressed as &id-expression.  */
    6598                 :      96855 :   if (DECL_P (op))
    6599                 :            :     {
    6600                 :      44227 :       tree ctx = CP_DECL_CONTEXT (op);
    6601                 :      44227 :       if (TYPE_P (ctx) && dependent_type_p (ctx))
    6602                 :        454 :         return true;
    6603                 :            :     }
    6604                 :            : 
    6605                 :            :   return false;
    6606                 :            : }
    6607                 :            : 
    6608                 :            : /* The next set of functions are used for providing helpful explanatory
    6609                 :            :    diagnostics for failed overload resolution.  Their messages should be
    6610                 :            :    indented by two spaces for consistency with the messages in
    6611                 :            :    call.c  */
    6612                 :            : 
    6613                 :            : static int
    6614                 :   45958300 : unify_success (bool /*explain_p*/)
    6615                 :            : {
    6616                 :   45958300 :   return 0;
    6617                 :            : }
    6618                 :            : 
    6619                 :            : /* Other failure functions should call this one, to provide a single function
    6620                 :            :    for setting a breakpoint on.  */
    6621                 :            : 
    6622                 :            : static int
    6623                 :   21022600 : unify_invalid (bool /*explain_p*/)
    6624                 :            : {
    6625                 :   21022600 :   return 1;
    6626                 :            : }
    6627                 :            : 
    6628                 :            : static int
    6629                 :     467158 : unify_parameter_deduction_failure (bool explain_p, tree parm)
    6630                 :            : {
    6631                 :          0 :   if (explain_p)
    6632                 :        172 :     inform (input_location,
    6633                 :            :             "  couldn%'t deduce template parameter %qD", parm);
    6634                 :   34533400 :   return unify_invalid (explain_p);
    6635                 :            : }
    6636                 :            : 
    6637                 :            : static int
    6638                 :    1596800 : unify_cv_qual_mismatch (bool explain_p, tree parm, tree arg)
    6639                 :            : {
    6640                 :          0 :   if (explain_p)
    6641                 :        109 :     inform (input_location,
    6642                 :            :             "  types %qT and %qT have incompatible cv-qualifiers",
    6643                 :            :             parm, arg);
    6644                 :  115180000 :   return unify_invalid (explain_p);
    6645                 :            : }
    6646                 :            : 
    6647                 :            : static int
    6648                 :    9151840 : unify_type_mismatch (bool explain_p, tree parm, tree arg)
    6649                 :            : {
    6650                 :          0 :   if (explain_p)
    6651                 :        146 :     inform (input_location, "  mismatched types %qT and %qT", parm, arg);
    6652                 :  132942000 :   return unify_invalid (explain_p);
    6653                 :            : }
    6654                 :            : 
    6655                 :            : static int
    6656                 :     221883 : unify_parameter_pack_mismatch (bool explain_p, tree parm, tree arg)
    6657                 :            : {
    6658                 :          0 :   if (explain_p)
    6659                 :          0 :     inform (input_location,
    6660                 :            :             "  template parameter %qD is not a parameter pack, but "
    6661                 :            :             "argument %qD is",
    6662                 :            :             parm, arg);
    6663                 :  115180000 :   return unify_invalid (explain_p);
    6664                 :            : }
    6665                 :            : 
    6666                 :            : static int
    6667                 :          0 : unify_ptrmem_cst_mismatch (bool explain_p, tree parm, tree arg)
    6668                 :            : {
    6669                 :          0 :   if (explain_p)
    6670                 :          0 :     inform (input_location,
    6671                 :            :             "  template argument %qE does not match "
    6672                 :            :             "pointer-to-member constant %qE",
    6673                 :            :             arg, parm);
    6674                 :  115180000 :   return unify_invalid (explain_p);
    6675                 :            : }
    6676                 :            : 
    6677                 :            : static int
    6678                 :          7 : unify_expression_unequal (bool explain_p, tree parm, tree arg)
    6679                 :            : {
    6680                 :          0 :   if (explain_p)
    6681                 :          0 :     inform (input_location, "  %qE is not equivalent to %qE", parm, arg);
    6682                 :  115180000 :   return unify_invalid (explain_p);
    6683                 :            : }
    6684                 :            : 
    6685                 :            : static int
    6686                 :          6 : unify_parameter_pack_inconsistent (bool explain_p, tree old_arg, tree new_arg)
    6687                 :            : {
    6688                 :          0 :   if (explain_p)
    6689                 :          0 :     inform (input_location,
    6690                 :            :             "  inconsistent parameter pack deduction with %qT and %qT",
    6691                 :            :             old_arg, new_arg);
    6692                 :          6 :   return unify_invalid (explain_p);
    6693                 :            : }
    6694                 :            : 
    6695                 :            : static int
    6696                 :     221929 : unify_inconsistency (bool explain_p, tree parm, tree first, tree second)
    6697                 :            : {
    6698                 :     221929 :   if (explain_p)
    6699                 :            :     {
    6700                 :         76 :       if (TYPE_P (parm))
    6701                 :         68 :         inform (input_location,
    6702                 :            :                 "  deduced conflicting types for parameter %qT (%qT and %qT)",
    6703                 :            :                 parm, first, second);
    6704                 :            :       else
    6705                 :          8 :         inform (input_location,
    6706                 :            :                 "  deduced conflicting values for non-type parameter "
    6707                 :            :                 "%qE (%qE and %qE)", parm, first, second);
    6708                 :            :     }
    6709                 :     221929 :   return unify_invalid (explain_p);
    6710                 :            : }
    6711                 :            : 
    6712                 :            : static int
    6713                 :         37 : unify_vla_arg (bool explain_p, tree arg)
    6714                 :            : {
    6715                 :          0 :   if (explain_p)
    6716                 :         12 :     inform (input_location,
    6717                 :            :             "  variable-sized array type %qT is not "
    6718                 :            :             "a valid template argument",
    6719                 :            :             arg);
    6720                 :  115189000 :   return unify_invalid (explain_p);
    6721                 :            : }
    6722                 :            : 
    6723                 :            : static int
    6724                 :          8 : unify_method_type_error (bool explain_p, tree arg)
    6725                 :            : {
    6726                 :          0 :   if (explain_p)
    6727                 :          0 :     inform (input_location,
    6728                 :            :             "  member function type %qT is not a valid template argument",
    6729                 :            :             arg);
    6730                 :  115180000 :   return unify_invalid (explain_p);
    6731                 :            : }
    6732                 :            : 
    6733                 :            : static int
    6734                 :    9994780 : unify_arity (bool explain_p, int have, int wanted, bool least_p = false)
    6735                 :            : {
    6736                 :    9994780 :   if (explain_p)
    6737                 :            :     {
    6738                 :        243 :       if (least_p)
    6739                 :         33 :         inform_n (input_location, wanted,
    6740                 :            :                   "  candidate expects at least %d argument, %d provided",
    6741                 :            :                   "  candidate expects at least %d arguments, %d provided",
    6742                 :            :                   wanted, have);
    6743                 :            :       else
    6744                 :        210 :         inform_n (input_location, wanted,
    6745                 :            :                   "  candidate expects %d argument, %d provided",
    6746                 :            :                   "  candidate expects %d arguments, %d provided",
    6747                 :            :                   wanted, have);
    6748                 :            :     }
    6749                 :    9994780 :   return unify_invalid (explain_p);
    6750                 :            : }
    6751                 :            : 
    6752                 :            : static int
    6753                 :     473816 : unify_too_many_arguments (bool explain_p, int have, int wanted)
    6754                 :            : {
    6755                 :          0 :   return unify_arity (explain_p, have, wanted);
    6756                 :            : }
    6757                 :            : 
    6758                 :            : static int
    6759                 :    6069620 : unify_too_few_arguments (bool explain_p, int have, int wanted,
    6760                 :            :                          bool least_p = false)
    6761                 :            : {
    6762                 :          0 :   return unify_arity (explain_p, have, wanted, least_p);
    6763                 :            : }
    6764                 :            : 
    6765                 :            : static int
    6766                 :     681953 : unify_arg_conversion (bool explain_p, tree to_type,
    6767                 :            :                       tree from_type, tree arg)
    6768                 :            : {
    6769                 :     681953 :   if (explain_p)
    6770                 :        108 :     inform (cp_expr_loc_or_input_loc (arg),
    6771                 :            :             "  cannot convert %qE (type %qT) to type %qT",
    6772                 :            :             arg, from_type, to_type);
    6773                 :     681953 :   return unify_invalid (explain_p);
    6774                 :            : }
    6775                 :            : 
    6776                 :            : static int
    6777                 :   10112100 : unify_no_common_base (bool explain_p, enum template_base_result r,
    6778                 :            :                       tree parm, tree arg)
    6779                 :            : {
    6780                 :   10112100 :   if (explain_p)
    6781                 :        737 :     switch (r)
    6782                 :            :       {
    6783                 :          4 :       case tbr_ambiguous_baseclass:
    6784                 :          4 :         inform (input_location, "  %qT is an ambiguous base class of %qT",
    6785                 :            :                 parm, arg);
    6786                 :          4 :         break;
    6787                 :        733 :       default:
    6788                 :        733 :         inform (input_location, "  %qT is not derived from %qT", arg, parm);
    6789                 :        733 :         break;
    6790                 :            :       }
    6791                 :   10112100 :   return unify_invalid (explain_p);
    6792                 :            : }
    6793                 :            : 
    6794                 :            : static int
    6795                 :         32 : unify_inconsistent_template_template_parameters (bool explain_p)
    6796                 :            : {
    6797                 :          0 :   if (explain_p)
    6798                 :         13 :     inform (input_location,
    6799                 :            :             "  template parameters of a template template argument are "
    6800                 :            :             "inconsistent with other deduced template arguments");
    6801                 :         32 :   return unify_invalid (explain_p);
    6802                 :            : }
    6803                 :            : 
    6804                 :            : static int
    6805                 :         26 : unify_template_deduction_failure (bool explain_p, tree parm, tree arg)
    6806                 :            : {
    6807                 :          0 :   if (explain_p)
    6808                 :          0 :     inform (input_location,
    6809                 :            :             "  cannot deduce a template for %qT from non-template type %qT",
    6810                 :            :             parm, arg);
    6811                 :  115180000 :   return unify_invalid (explain_p);
    6812                 :            : }
    6813                 :            : 
    6814                 :            : static int
    6815                 :    1706580 : unify_template_argument_mismatch (bool explain_p, tree parm, tree arg)
    6816                 :            : {
    6817                 :          0 :   if (explain_p)
    6818                 :          4 :     inform (input_location,
    6819                 :            :             "  template argument %qE does not match %qE", arg, parm);
    6820                 :  156724000 :   return unify_invalid (explain_p);
    6821                 :            : }
    6822                 :            : 
    6823                 :            : /* True if T is a C++20 template parameter object to store the argument for a
    6824                 :            :    template parameter of class type.  */
    6825                 :            : 
    6826                 :            : bool
    6827                 :  142354000 : template_parm_object_p (const_tree t)
    6828                 :            : {
    6829                 :      14031 :   return (TREE_CODE (t) == VAR_DECL && DECL_ARTIFICIAL (t) && DECL_NAME (t)
    6830                 :  142356000 :           && !strncmp (IDENTIFIER_POINTER (DECL_NAME (t)), "_ZTA", 4));
    6831                 :            : }
    6832                 :            : 
    6833                 :            : /* Subroutine of convert_nontype_argument, to check whether EXPR, as an
    6834                 :            :    argument for TYPE, points to an unsuitable object.  */
    6835                 :            : 
    6836                 :            : static bool
    6837                 :       4414 : invalid_tparm_referent_p (tree type, tree expr, tsubst_flags_t complain)
    6838                 :            : {
    6839                 :       4418 :   switch (TREE_CODE (expr))
    6840                 :            :     {
    6841                 :          4 :     CASE_CONVERT:
    6842                 :          4 :       return invalid_tparm_referent_p (type, TREE_OPERAND (expr, 0),
    6843                 :          4 :                                        complain);
    6844                 :            : 
    6845                 :          0 :     case TARGET_EXPR:
    6846                 :          0 :       return invalid_tparm_referent_p (type, TARGET_EXPR_INITIAL (expr),
    6847                 :          0 :                                        complain);
    6848                 :            : 
    6849                 :            :     case CONSTRUCTOR:
    6850                 :            :       {
    6851                 :            :         unsigned i; tree elt;
    6852                 :       5115 :         FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expr), i, elt)
    6853                 :       1527 :           if (invalid_tparm_referent_p (TREE_TYPE (elt), elt, complain))
    6854                 :            :             return true;
    6855                 :            :       }
    6856                 :            :       break;
    6857                 :            : 
    6858                 :       2251 :     case ADDR_EXPR:
    6859                 :       2251 :       {
    6860                 :       2251 :         tree decl = TREE_OPERAND (expr, 0);
    6861                 :            : 
    6862                 :       2251 :         if (!VAR_P (decl))
    6863                 :            :           {
    6864                 :         18 :             if (complain & tf_error)
    6865                 :         28 :               error_at (cp_expr_loc_or_input_loc (expr),
    6866                 :            :                         "%qE is not a valid template argument of type %qT "
    6867                 :            :                         "because %qE is not a variable", expr, type, decl);
    6868                 :         18 :             return true;
    6869                 :            :           }
    6870                 :       2233 :         else if (cxx_dialect < cxx11 && !DECL_EXTERNAL_LINKAGE_P (decl))
    6871                 :            :           {
    6872                 :          2 :             if (complain & tf_error)
    6873                 :          4 :               error_at (cp_expr_loc_or_input_loc (expr),
    6874                 :            :                         "%qE is not a valid template argument of type %qT "
    6875                 :            :                         "in C++98 because %qD does not have external linkage",
    6876                 :            :                         expr, type, decl);
    6877                 :          2 :             return true;
    6878                 :            :           }
    6879                 :       2231 :         else if ((cxx_dialect >= cxx11 && cxx_dialect < cxx17)
    6880                 :       2231 :                  && decl_linkage (decl) == lk_none)
    6881                 :            :           {
    6882                 :          3 :             if (complain & tf_error)
    6883                 :          6 :               error_at (cp_expr_loc_or_input_loc (expr),
    6884                 :            :                         "%qE is not a valid template argument of type %qT "
    6885                 :            :                         "because %qD has no linkage", expr, type, decl);
    6886                 :          3 :             return true;
    6887                 :            :           }
    6888                 :            :         /* C++17: For a non-type template-parameter of reference or pointer
    6889                 :            :            type, the value of the constant expression shall not refer to (or
    6890                 :            :            for a pointer type, shall not be the address of):
    6891                 :            :            * a subobject (4.5),
    6892                 :            :            * a temporary object (15.2),
    6893                 :            :            * a string literal (5.13.5),
    6894                 :            :            * the result of a typeid expression (8.2.8), or
    6895                 :            :            * a predefined __func__ variable (11.4.1).  */
    6896                 :       2228 :         else if (DECL_ARTIFICIAL (decl))
    6897                 :            :           {
    6898                 :          3 :             if (complain & tf_error)
    6899                 :          3 :               error ("the address of %qD is not a valid template argument",
    6900                 :            :                      decl);
    6901                 :          3 :             return true;
    6902                 :            :           }
    6903                 :       4450 :         else if (!same_type_ignoring_top_level_qualifiers_p
    6904                 :       2225 :                  (strip_array_types (TREE_TYPE (type)),
    6905                 :       2225 :                   strip_array_types (TREE_TYPE (decl))))
    6906                 :            :           {
    6907                 :          9 :             if (complain & tf_error)
    6908                 :          6 :               error ("the address of the %qT subobject of %qD is not a "
    6909                 :          6 :                      "valid template argument", TREE_TYPE (type), decl);
    6910                 :          9 :             return true;
    6911                 :            :           }
    6912                 :       2525 :         else if (!TREE_STATIC (decl) && !DECL_EXTERNAL (decl))
    6913                 :            :           {
    6914                 :          2 :             if (complain & tf_error)
    6915                 :          2 :               error ("the address of %qD is not a valid template argument "
    6916                 :            :                      "because it does not have static storage duration",
    6917                 :            :                      decl);
    6918                 :          2 :             return true;
    6919                 :            :           }
    6920                 :            :       }
    6921                 :            :       break;
    6922                 :            : 
    6923                 :       1000 :     default:
    6924                 :       1000 :       if (!INDIRECT_TYPE_P (type))
    6925                 :            :         /* We're only concerned about pointers and references here.  */;
    6926                 :         19 :       else if (cxx_dialect >= cxx11 && integer_zerop (expr))
    6927                 :            :         /* Null pointer values are OK in C++11.  */;
    6928                 :            :       else
    6929                 :            :         {
    6930                 :         11 :           if (VAR_P (expr))
    6931                 :            :             {
    6932                 :          8 :               if (complain & tf_error)
    6933                 :          8 :                 error ("%qD is not a valid template argument "
    6934                 :            :                        "because %qD is a variable, not the address of "
    6935                 :            :                        "a variable", expr, expr);
    6936                 :          8 :               return true;
    6937                 :            :             }
    6938                 :            :           else
    6939                 :            :             {
    6940                 :          3 :               if (complain & tf_error)
    6941                 :          1 :                 error ("%qE is not a valid template argument for %qT "
    6942                 :            :                        "because it is not the address of a variable",
    6943                 :            :                        expr, type);
    6944                 :          3 :               return true;
    6945                 :            :             }
    6946                 :            :         }
    6947                 :            :     }
    6948                 :            :   return false;
    6949                 :            : 
    6950                 :            : }
    6951                 :            : 
    6952                 :            : /* Return a VAR_DECL for the C++20 template parameter object corresponding to
    6953                 :            :    template argument EXPR.  */
    6954                 :            : 
    6955                 :            : static tree
    6956                 :        625 : get_template_parm_object (tree expr, tsubst_flags_t complain)
    6957                 :            : {
    6958                 :        625 :   if (TREE_CODE (expr) == TARGET_EXPR)
    6959                 :        625 :     expr = TARGET_EXPR_INITIAL (expr);
    6960                 :            : 
    6961                 :        625 :   if (!TREE_CONSTANT (expr))
    6962                 :            :     {
    6963                 :          0 :       if ((complain & tf_error)
    6964                 :          0 :           && require_rvalue_constant_expression (expr))
    6965                 :          0 :         cxx_constant_value (expr);
    6966                 :          0 :       return error_mark_node;
    6967                 :            :     }
    6968                 :        625 :   if (invalid_tparm_referent_p (TREE_TYPE (expr), expr, complain))
    6969                 :          0 :     return error_mark_node;
    6970                 :            : 
    6971                 :        625 :   tree name = mangle_template_parm_object (expr);
    6972                 :        625 :   tree decl = get_global_binding (name);
    6973                 :        625 :   if (decl)
    6974                 :            :     return decl;
    6975                 :            : 
    6976                 :         95 :   tree type = cp_build_qualified_type (TREE_TYPE (expr), TYPE_QUAL_CONST);
    6977                 :         95 :   decl = create_temporary_var (type);
    6978                 :         95 :   TREE_STATIC (decl) = true;
    6979                 :        190 :   DECL_DECLARED_CONSTEXPR_P (decl) = true;
    6980                 :         95 :   TREE_READONLY (decl) = true;
    6981                 :         95 :   DECL_NAME (decl) = name;
    6982                 :         95 :   SET_DECL_ASSEMBLER_NAME (decl, name);
    6983                 :         95 :   DECL_CONTEXT (decl) = global_namespace;
    6984                 :         95 :   comdat_linkage (decl);
    6985                 :         95 :   pushdecl_top_level_and_finish (decl, expr);
    6986                 :         95 :   return decl;
    6987                 :            : }
    6988                 :            : 
    6989                 :            : /* Attempt to convert the non-type template parameter EXPR to the
    6990                 :            :    indicated TYPE.  If the conversion is successful, return the
    6991                 :            :    converted value.  If the conversion is unsuccessful, return
    6992                 :            :    NULL_TREE if we issued an error message, or error_mark_node if we
    6993                 :            :    did not.  We issue error messages for out-and-out bad template
    6994                 :            :    parameters, but not simply because the conversion failed, since we
    6995                 :            :    might be just trying to do argument deduction.  Both TYPE and EXPR
    6996                 :            :    must be non-dependent.
    6997                 :            : 
    6998                 :            :    The conversion follows the special rules described in
    6999                 :            :    [temp.arg.nontype], and it is much more strict than an implicit
    7000                 :            :    conversion.
    7001                 :            : 
    7002                 :            :    This function is called twice for each template argument (see
    7003                 :            :    lookup_template_class for a more accurate description of this
    7004                 :            :    problem). This means that we need to handle expressions which
    7005                 :            :    are not valid in a C++ source, but can be created from the
    7006                 :            :    first call (for instance, casts to perform conversions). These
    7007                 :            :    hacks can go away after we fix the double coercion problem.  */
    7008                 :            : 
    7009                 :            : static tree
    7010                 :   40521700 : convert_nontype_argument (tree type, tree expr, tsubst_flags_t complain)
    7011                 :            : {
    7012                 :   40521700 :   tree expr_type;
    7013                 :   40521700 :   location_t loc = cp_expr_loc_or_input_loc (expr);
    7014                 :            : 
    7015                 :            :   /* Detect immediately string literals as invalid non-type argument.
    7016                 :            :      This special-case is not needed for correctness (we would easily
    7017                 :            :      catch this later), but only to provide better diagnostic for this
    7018                 :            :      common user mistake. As suggested by DR 100, we do not mention
    7019                 :            :      linkage issues in the diagnostic as this is not the point.  */
    7020                 :   40521700 :   if (TREE_CODE (expr) == STRING_CST && !CLASS_TYPE_P (type))
    7021                 :            :     {
    7022                 :          6 :       if (complain & tf_error)
    7023                 :          6 :         error ("%qE is not a valid template argument for type %qT "
    7024                 :            :                "because string literals can never be used in this context",
    7025                 :            :                expr, type);
    7026                 :          6 :       return NULL_TREE;
    7027                 :            :     }
    7028                 :            : 
    7029                 :            :   /* Add the ADDR_EXPR now for the benefit of
    7030                 :            :      value_dependent_expression_p.  */
    7031                 :       3294 :   if (TYPE_PTROBV_P (type)
    7032                 :   40523500 :       && TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE)
    7033                 :            :     {
    7034                 :         99 :       expr = decay_conversion (expr, complain);
    7035                 :         99 :       if (expr == error_mark_node)
    7036                 :            :         return error_mark_node;
    7037                 :            :     }
    7038                 :            : 
    7039                 :            :   /* If we are in a template, EXPR may be non-dependent, but still
    7040                 :            :      have a syntactic, rather than semantic, form.  For example, EXPR
    7041                 :            :      might be a SCOPE_REF, rather than the VAR_DECL to which the
    7042                 :            :      SCOPE_REF refers.  Preserving the qualifying scope is necessary
    7043                 :            :      so that access checking can be performed when the template is
    7044                 :            :      instantiated -- but here we need the resolved form so that we can
    7045                 :            :      convert the argument.  */
    7046                 :   40521700 :   bool non_dep = false;
    7047                 :        986 :   if (TYPE_REF_OBJ_P (type)
    7048                 :   40522400 :       && has_value_dependent_address (expr))
    7049                 :            :     /* If we want the address and it's value-dependent, don't fold.  */;
    7050                 :   40521700 :   else if (processing_template_decl
    7051                 :   40521700 :            && is_nondependent_constant_expression (expr))
    7052                 :            :     non_dep = true;
    7053                 :   81043400 :   if (error_operand_p (expr))
    7054                 :            :     return error_mark_node;
    7055                 :   40521700 :   expr_type = TREE_TYPE (expr);
    7056                 :            : 
    7057                 :            :   /* If the argument is non-dependent, perform any conversions in
    7058                 :            :      non-dependent context as well.  */
    7059                 :   40521700 :   processing_template_decl_sentinel s (non_dep);
    7060                 :   40521700 :   if (non_dep)
    7061                 :    5035840 :     expr = instantiate_non_dependent_expr_internal (expr, complain);
    7062                 :            : 
    7063                 :   40521700 :   const bool val_dep_p = value_dependent_expression_p (expr);
    7064                 :   40521700 :   if (val_dep_p)
    7065                 :    2079580 :     expr = canonicalize_expr_argument (expr, complain);
    7066                 :            : 
    7067                 :            :   /* 14.3.2/5: The null pointer{,-to-member} conversion is applied
    7068                 :            :      to a non-type argument of "nullptr".  */
    7069                 :   40521700 :   if (NULLPTR_TYPE_P (expr_type) && TYPE_PTR_OR_PTRMEM_P (type))
    7070                 :         38 :     expr = fold_simple (convert (type, expr));
    7071                 :            : 
    7072                 :            :   /* In C++11, integral or enumeration non-type template arguments can be
    7073                 :            :      arbitrary constant expressions.  Pointer and pointer to
    7074                 :            :      member arguments can be general constant expressions that evaluate
    7075                 :            :      to a null value, but otherwise still need to be of a specific form.  */
    7076                 :   40521700 :   if (cxx_dialect >= cxx11)
    7077                 :            :     {
    7078                 :   40437500 :       if (TREE_CODE (expr) == PTRMEM_CST && TYPE_PTRMEM_P (type))
    7079                 :            :         /* A PTRMEM_CST is already constant, and a valid template
    7080                 :            :            argument for a parameter of pointer to member type, we just want
    7081                 :            :            to leave it in that form rather than lower it to a
    7082                 :            :            CONSTRUCTOR.  */;
    7083                 :   40436000 :       else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type)
    7084                 :       4659 :                || cxx_dialect >= cxx17)
    7085                 :            :         {
    7086                 :            :           /* C++17: A template-argument for a non-type template-parameter shall
    7087                 :            :              be a converted constant expression (8.20) of the type of the
    7088                 :            :              template-parameter.  */
    7089                 :   40434500 :           expr = build_converted_constant_expr (type, expr, complain);
    7090                 :   40434500 :           if (expr == error_mark_node)
    7091                 :            :             /* Make sure we return NULL_TREE only if we have really issued
    7092                 :            :                an error, as described above.  */
    7093                 :        237 :             return (complain & tf_error) ? NULL_TREE : error_mark_node;
    7094                 :   40434300 :           else if (TREE_CODE (expr) == IMPLICIT_CONV_EXPR)
    7095                 :            :             {
    7096                 :         15 :               IMPLICIT_CONV_EXPR_NONTYPE_ARG (expr) = true;
    7097                 :         15 :               return expr;
    7098                 :            :             }
    7099                 :   40434300 :           expr = maybe_constant_value (expr, NULL_TREE,
    7100                 :            :                                        /*manifestly_const_eval=*/true);
    7101                 :   40434300 :           expr = convert_from_reference (expr);
    7102                 :            :         }
    7103                 :       1472 :       else if (TYPE_PTR_OR_PTRMEM_P (type))
    7104                 :            :         {
    7105                 :       1119 :           tree folded = maybe_constant_value (expr, NULL_TREE,
    7106                 :            :                                               /*manifestly_const_eval=*/true);
    7107                 :       1235 :           if (TYPE_PTR_P (type) ? integer_zerop (folded)
    7108                 :        116 :               : null_member_pointer_value_p (folded))
    7109                 :         53 :             expr = folded;
    7110                 :            :         }
    7111                 :            :     }
    7112                 :            : 
    7113                 :   40521500 :   if (TYPE_REF_P (type))
    7114                 :        974 :     expr = mark_lvalue_use (expr);
    7115                 :            :   else
    7116                 :   40520500 :     expr = mark_rvalue_use (expr);
    7117                 :            : 
    7118                 :            :   /* HACK: Due to double coercion, we can get a
    7119                 :            :      NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
    7120                 :            :      which is the tree that we built on the first call (see
    7121                 :            :      below when coercing to reference to object or to reference to
    7122                 :            :      function). We just strip everything and get to the arg.
    7123                 :            :      See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
    7124                 :            :      for examples.  */
    7125                 :   40522800 :   if (TYPE_REF_OBJ_P (type) || TYPE_REFFN_P (type))
    7126                 :            :     {
    7127                 :        974 :       tree probe_type, probe = expr;
    7128                 :        974 :       if (REFERENCE_REF_P (probe))
    7129                 :        868 :         probe = TREE_OPERAND (probe, 0);
    7130                 :        974 :       probe_type = TREE_TYPE (probe);
    7131                 :        974 :       if (TREE_CODE (probe) == NOP_EXPR)
    7132                 :            :         {
    7133                 :            :           /* ??? Maybe we could use convert_from_reference here, but we
    7134                 :            :              would need to relax its constraints because the NOP_EXPR
    7135                 :            :              could actually change the type to something more cv-qualified,
    7136                 :            :              and this is not folded by convert_from_reference.  */
    7137                 :        818 :           tree addr = TREE_OPERAND (probe, 0);
    7138                 :        818 :           if (TYPE_REF_P (probe_type)
    7139                 :        818 :               && TREE_CODE (addr) == ADDR_EXPR
    7140                 :        818 :               && TYPE_PTR_P (TREE_TYPE (addr))
    7141                 :       1636 :               && (same_type_ignoring_top_level_qualifiers_p
    7142                 :        818 :                   (TREE_TYPE (probe_type),
    7143                 :        818 :                    TREE_TYPE (TREE_TYPE (addr)))))
    7144                 :            :             {
    7145                 :        806 :               expr = TREE_OPERAND (addr, 0);
    7146                 :        806 :               expr_type = TREE_TYPE (probe_type);
    7147                 :            :             }
    7148                 :            :         }
    7149                 :            :     }
    7150                 :            : 
    7151                 :            :   /* [temp.arg.nontype]/5, bullet 1
    7152                 :            : 
    7153                 :            :      For a non-type template-parameter of integral or enumeration type,
    7154                 :            :      integral promotions (_conv.prom_) and integral conversions
    7155                 :            :      (_conv.integral_) are applied.  */
    7156                 :   40521500 :   if (INTEGRAL_OR_ENUMERATION_TYPE_P (type))
    7157                 :            :     {
    7158                 :   40514400 :       if (cxx_dialect < cxx11)
    7159                 :            :         {
    7160                 :      83177 :           tree t = build_converted_constant_expr (type, expr, complain);
    7161                 :      83177 :           t = maybe_constant_value (t);
    7162                 :      83177 :           if (t != error_mark_node)
    7163                 :      83168 :             expr = t;
    7164                 :            :         }
    7165                 :            : 
    7166                 :   40514400 :       if (!same_type_ignoring_top_level_qualifiers_p (type, TREE_TYPE (expr)))
    7167                 :          9 :         return error_mark_node;
    7168                 :            : 
    7169                 :            :       /* Notice that there are constant expressions like '4 % 0' which
    7170                 :            :          do not fold into integer constants.  */
    7171                 :   40514400 :       if (TREE_CODE (expr) != INTEGER_CST && !val_dep_p)
    7172                 :            :         {
    7173                 :        106 :           if (complain & tf_error)
    7174                 :            :             {
    7175                 :         72 :               int errs = errorcount, warns = warningcount + werrorcount;
    7176                 :         72 :               if (!require_potential_constant_expression (expr))
    7177                 :         23 :                 expr = error_mark_node;
    7178                 :            :               else
    7179                 :         49 :                 expr = cxx_constant_value (expr);
    7180                 :         72 :               if (errorcount > errs || warningcount + werrorcount > warns)
    7181                 :         51 :                 inform (loc, "in template argument for type %qT", type);
    7182                 :         72 :               if (expr == error_mark_node)
    7183                 :            :                 return NULL_TREE;
    7184                 :            :               /* else cxx_constant_value complained but gave us
    7185                 :            :                  a real constant, so go ahead.  */
    7186                 :         10 :               if (TREE_CODE (expr) != INTEGER_CST)
    7187                 :            :                 {
    7188                 :            :                   /* Some assemble time constant expressions like
    7189                 :            :                      (intptr_t)&&lab1 - (intptr_t)&&lab2 or
    7190                 :            :                      4 + (intptr_t)&&var satisfy reduced_constant_expression_p
    7191                 :            :                      as we can emit them into .rodata initializers of
    7192                 :            :                      variables, yet they can't fold into an INTEGER_CST at
    7193                 :            :                      compile time.  Refuse them here.  */
    7194                 :          6 :                   gcc_checking_assert (reduced_constant_expression_p (expr));
    7195                 :          6 :                   error_at (loc, "template argument %qE for type %qT not "
    7196                 :            :                                  "a constant integer", expr, type);
    7197                 :          6 :                   return NULL_TREE;
    7198                 :            :                 }
    7199                 :            :             }
    7200                 :            :           else
    7201                 :            :             return NULL_TREE;
    7202                 :            :         }
    7203                 :            : 
    7204                 :            :       /* Avoid typedef problems.  */
    7205                 :   40514300 :       if (TREE_TYPE (expr) != type)
    7206                 :      23410 :         expr = fold_convert (type, expr);
    7207                 :            :     }
    7208                 :            :   /* [temp.arg.nontype]/5, bullet 2
    7209                 :            : 
    7210                 :            :      For a non-type template-parameter of type pointer to object,
    7211                 :            :      qualification conversions (_conv.qual_) and the array-to-pointer
    7212                 :            :      conversion (_conv.array_) are applied.  */
    7213                 :      10292 :   else if (TYPE_PTROBV_P (type))
    7214                 :            :     {
    7215                 :       1776 :       tree decayed = expr;
    7216                 :            : 
    7217                 :            :       /* Look through any NOP_EXPRs around an ADDR_EXPR, whether they come from
    7218                 :            :          decay_conversion or an explicit cast.  If it's a problematic cast,
    7219                 :            :          we'll complain about it below.  */
    7220                 :       1776 :       if (TREE_CODE (expr) == NOP_EXPR)
    7221                 :            :         {
    7222                 :        474 :           tree probe = expr;
    7223                 :        474 :           STRIP_NOPS (probe);
    7224                 :        474 :           if (TREE_CODE (probe) == ADDR_EXPR
    7225                 :        946 :               && TYPE_PTR_P (TREE_TYPE (probe)))
    7226                 :            :             {
    7227                 :            :               expr = probe;
    7228                 :       1776 :               expr_type = TREE_TYPE (expr);
    7229                 :            :             }
    7230                 :            :         }
    7231                 :            : 
    7232                 :            :       /* [temp.arg.nontype]/1  (TC1 version, DR 49):
    7233                 :            : 
    7234                 :            :          A template-argument for a non-type, non-template template-parameter
    7235                 :            :          shall be one of: [...]
    7236                 :            : 
    7237                 :            :          -- the name of a non-type template-parameter;
    7238                 :            :          -- the address of an object or function with external linkage, [...]
    7239                 :            :             expressed as "& id-expression" where the & is optional if the name
    7240                 :            :             refers to a function or array, or if the corresponding
    7241                 :            :             template-parameter is a reference.
    7242                 :            : 
    7243                 :            :         Here, we do not care about functions, as they are invalid anyway
    7244                 :            :         for a parameter of type pointer-to-object.  */
    7245                 :            : 
    7246                 :       1776 :       if (val_dep_p)
    7247                 :            :         /* Non-type template parameters are OK.  */
    7248                 :            :         ;
    7249                 :       1693 :       else if (cxx_dialect >= cxx11 && integer_zerop (expr))
    7250                 :            :         /* Null pointer values are OK in C++11.  */;
    7251                 :       1662 :       else if (TREE_CODE (expr) != ADDR_EXPR
    7252                 :         54 :                && !INDIRECT_TYPE_P (expr_type))
    7253                 :            :         /* Other values, like integer constants, might be valid
    7254                 :            :            non-type arguments of some other type.  */
    7255                 :         43 :         return error_mark_node;
    7256                 :       1619 :       else if (invalid_tparm_referent_p (type, expr, complain))
    7257                 :            :         return NULL_TREE;
    7258                 :            : 
    7259                 :       1686 :       expr = decayed;
    7260                 :            : 
    7261                 :       1686 :       expr = perform_qualification_conversions (type, expr);
    7262                 :       1686 :       if (expr == error_mark_node)
    7263                 :            :         return error_mark_node;
    7264                 :            :     }
    7265                 :            :   /* [temp.arg.nontype]/5, bullet 3
    7266                 :            : 
    7267                 :            :      For a non-type template-parameter of type reference to object, no
    7268                 :            :      conversions apply. The type referred to by the reference may be more
    7269                 :            :      cv-qualified than the (otherwise identical) type of the
    7270                 :            :      template-argument. The template-parameter is bound directly to the
    7271                 :            :      template-argument, which must be an lvalue.  */
    7272                 :       6258 :   else if (TYPE_REF_OBJ_P (type))
    7273                 :            :     {
    7274                 :        691 :       if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type),
    7275                 :            :                                                       expr_type))
    7276                 :          0 :         return error_mark_node;
    7277                 :            : 
    7278                 :        691 :       if (!at_least_as_qualified_p (TREE_TYPE (type), expr_type))
    7279                 :            :         {
    7280                 :          4 :           if (complain & tf_error)
    7281                 :          2 :             error ("%qE is not a valid template argument for type %qT "
    7282                 :            :                    "because of conflicts in cv-qualification", expr, type);
    7283                 :          4 :           return NULL_TREE;
    7284                 :            :         }
    7285                 :            : 
    7286                 :        687 :       if (!lvalue_p (expr))
    7287                 :            :         {
    7288                 :          6 :           if (complain & tf_error)
    7289                 :          6 :             error ("%qE is not a valid template argument for type %qT "
    7290                 :            :                    "because it is not an lvalue", expr, type);
    7291                 :          6 :           return NULL_TREE;
    7292                 :            :         }
    7293                 :            : 
    7294                 :            :       /* [temp.arg.nontype]/1
    7295                 :            : 
    7296                 :            :          A template-argument for a non-type, non-template template-parameter
    7297                 :            :          shall be one of: [...]
    7298                 :            : 
    7299                 :            :          -- the address of an object or function with external linkage.  */
    7300                 :        681 :       if (INDIRECT_REF_P (expr)
    7301                 :        681 :           && TYPE_REF_OBJ_P (TREE_TYPE (TREE_OPERAND (expr, 0))))
    7302                 :            :         {
    7303                 :         38 :           expr = TREE_OPERAND (expr, 0);
    7304                 :         38 :           if (DECL_P (expr))
    7305                 :            :             {
    7306                 :          4 :               if (complain & tf_error)
    7307                 :          4 :                 error ("%q#D is not a valid template argument for type %qT "
    7308                 :            :                        "because a reference variable does not have a constant "
    7309                 :            :                        "address", expr, type);
    7310                 :          4 :               return NULL_TREE;
    7311                 :            :             }
    7312                 :            :         }
    7313                 :            : 
    7314                 :        677 :       if (TYPE_REF_OBJ_P (TREE_TYPE (expr)) && val_dep_p)
    7315                 :            :         /* OK, dependent reference.  We don't want to ask whether a DECL is
    7316                 :            :            itself value-dependent, since what we want here is its address.  */;
    7317                 :            :       else
    7318                 :            :         {
    7319                 :        643 :           expr = build_address (expr);
    7320                 :            : 
    7321                 :        643 :           if (invalid_tparm_referent_p (type, expr, complain))
    7322                 :            :             return NULL_TREE;
    7323                 :            :         }
    7324                 :            : 
    7325                 :        676 :       if (!same_type_p (type, TREE_TYPE (expr)))
    7326                 :        642 :         expr = build_nop (type, expr);
    7327                 :            :     }
    7328                 :            :   /* [temp.arg.nontype]/5, bullet 4
    7329                 :            : 
    7330                 :            :      For a non-type template-parameter of type pointer to function, only
    7331                 :            :      the function-to-pointer conversion (_conv.func_) is applied. If the
    7332                 :            :      template-argument represents a set of overloaded functions (or a
    7333                 :            :      pointer to such), the matching function is selected from the set
    7334                 :            :      (_over.over_).  */
    7335                 :       6049 :   else if (TYPE_PTRFN_P (type))
    7336                 :            :     {
    7337                 :            :       /* If the argument is a template-id, we might not have enough
    7338                 :            :          context information to decay the pointer.  */
    7339                 :       1456 :       if (!type_unknown_p (expr_type))
    7340                 :            :         {
    7341                 :       1187 :           expr = decay_conversion (expr, complain);
    7342                 :       1187 :           if (expr == error_mark_node)
    7343                 :            :             return error_mark_node;
    7344                 :            :         }
    7345                 :            : 
    7346                 :       1448 :       if (cxx_dialect >= cxx11 && integer_zerop (expr))
    7347                 :            :         /* Null pointer values are OK in C++11.  */
    7348                 :          8 :         return perform_qualification_conversions (type, expr);
    7349                 :            : 
    7350                 :       1440 :       expr = convert_nontype_argument_function (type, expr, complain);
    7351                 :       1440 :       if (!expr || expr == error_mark_node)
    7352                 :            :         return expr;
    7353                 :            :     }
    7354                 :            :   /* [temp.arg.nontype]/5, bullet 5
    7355                 :            : 
    7356                 :            :      For a non-type template-parameter of type reference to function, no
    7357                 :            :      conversions apply. If the template-argument represents a set of
    7358                 :            :      overloaded functions, the matching function is selected from the set
    7359                 :            :      (_over.over_).  */
    7360                 :       3420 :   else if (TYPE_REFFN_P (type))
    7361                 :            :     {
    7362                 :        283 :       if (TREE_CODE (expr) == ADDR_EXPR)
    7363                 :            :         {
    7364                 :          0 :           if (complain & tf_error)
    7365                 :            :             {
    7366                 :          0 :               error ("%qE is not a valid template argument for type %qT "
    7367                 :            :                      "because it is a pointer", expr, type);
    7368                 :          0 :               inform (input_location, "try using %qE instead",
    7369                 :          0 :                       TREE_OPERAND (expr, 0));
    7370                 :            :             }
    7371                 :          0 :           return NULL_TREE;
    7372                 :            :         }
    7373                 :            : 
    7374                 :        283 :       expr = convert_nontype_argument_function (type, expr, complain);
    7375                 :        283 :       if (!expr || expr == error_mark_node)
    7376                 :            :         return expr;
    7377                 :            :     }
    7378                 :            :   /* [temp.arg.nontype]/5, bullet 6
    7379                 :            : 
    7380                 :            :      For a non-type template-parameter of type pointer to member function,
    7381                 :            :      no conversions apply. If the template-argument represents a set of
    7382                 :            :      overloaded member functions, the matching member function is selected
    7383                 :            :      from the set (_over.over_).  */
    7384                 :       2854 :   else if (TYPE_PTRMEMFUNC_P (type))
    7385                 :            :     {
    7386                 :       1505 :       expr = instantiate_type (type, expr, tf_none);
    7387                 :       1505 :       if (expr == error_mark_node)
    7388                 :            :         return error_mark_node;
    7389                 :            : 
    7390                 :            :       /* [temp.arg.nontype] bullet 1 says the pointer to member
    7391                 :            :          expression must be a pointer-to-member constant.  */
    7392                 :       1461 :       if (!val_dep_p
    7393                 :       1461 :           && !check_valid_ptrmem_cst_expr (type, expr, complain))
    7394                 :            :         return NULL_TREE;
    7395                 :            : 
    7396                 :            :       /* Repeated conversion can't deal with a conversion that turns PTRMEM_CST
    7397                 :            :          into a CONSTRUCTOR, so build up a new PTRMEM_CST instead.  */
    7398                 :       1434 :       if (fnptr_conv_p (type, TREE_TYPE (expr)))
    7399                 :          2 :         expr = make_ptrmem_cst (type, PTRMEM_CST_MEMBER (expr));
    7400                 :            :     }
    7401                 :            :   /* [temp.arg.nontype]/5, bullet 7
    7402                 :            : 
    7403                 :            :      For a non-type template-parameter of type pointer to data member,
    7404                 :            :      qualification conversions (_conv.qual_) are applied.  */
    7405                 :       1349 :   else if (TYPE_PTRDATAMEM_P (type))
    7406                 :            :     {
    7407                 :            :       /* [temp.arg.nontype] bullet 1 says the pointer to member
    7408                 :            :          expression must be a pointer-to-member constant.  */
    7409                 :        670 :       if (!val_dep_p
    7410                 :        670 :           && !check_valid_ptrmem_cst_expr (type, expr, complain))
    7411                 :            :         return NULL_TREE;
    7412                 :            : 
    7413                 :        639 :       expr = perform_qualification_conversions (type, expr);
    7414                 :        639 :       if (expr == error_mark_node)
    7415                 :            :         return expr;
    7416                 :            :     }
    7417                 :        679 :   else if (NULLPTR_TYPE_P (type))
    7418                 :            :     {
    7419                 :         42 :       if (!NULLPTR_TYPE_P (TREE_TYPE (expr)))
    7420                 :            :         {
    7421                 :          0 :           if (complain & tf_error)
    7422                 :          0 :             error ("%qE is not a valid template argument for type %qT "
    7423                 :          0 :                    "because it is of type %qT", expr, type, TREE_TYPE (expr));
    7424                 :          0 :           return NULL_TREE;
    7425                 :            :         }
    7426                 :            :       return expr;
    7427                 :            :     }
    7428                 :       1274 :   else if (CLASS_TYPE_P (type))
    7429                 :            :     {
    7430                 :            :       /* Replace the argument with a reference to the corresponding template
    7431                 :            :          parameter object.  */
    7432                 :        637 :       if (!val_dep_p)
    7433                 :        625 :         expr = get_template_parm_object (expr, complain);
    7434                 :        637 :       if (expr == error_mark_node)
    7435                 :            :         return NULL_TREE;
    7436                 :            :     }
    7437                 :            :   /* A template non-type parameter must be one of the above.  */
    7438                 :            :   else
    7439                 :          0 :     gcc_unreachable ();
    7440                 :            : 
    7441                 :            :   /* Sanity check: did we actually convert the argument to the
    7442                 :            :      right type?  */
    7443                 :   40521000 :   gcc_assert (same_type_ignoring_top_level_qualifiers_p
    7444                 :            :               (type, TREE_TYPE (expr)));
    7445                 :   40521000 :   return convert_from_reference (expr);
    7446                 :            : }
    7447                 :            : 
    7448                 :            : /* Subroutine of coerce_template_template_parms, which returns 1 if
    7449                 :            :    PARM_PARM and ARG_PARM match using the rule for the template
    7450                 :            :    parameters of template template parameters. Both PARM and ARG are
    7451                 :            :    template parameters; the rest of the arguments are the same as for
    7452                 :            :    coerce_template_template_parms.
    7453                 :            :  */
    7454                 :            : static int
    7455                 :    2023820 : coerce_template_template_parm (tree parm,
    7456                 :            :                               tree arg,
    7457                 :            :                               tsubst_flags_t complain,
    7458                 :            :                               tree in_decl,
    7459                 :            :                               tree outer_args)
    7460                 :            : {
    7461                 :    4047630 :   if (arg == NULL_TREE || error_operand_p (arg)
    7462                 :    6071430 :       || parm == NULL_TREE || error_operand_p (parm))
    7463                 :            :     return 0;
    7464                 :            : 
    7465                 :    2023810 :   if (TREE_CODE (arg) != TREE_CODE (parm))
    7466                 :            :     return 0;
    7467                 :            : 
    7468                 :    2023590 :   switch (TREE_CODE (parm))
    7469                 :            :     {
    7470                 :         68 :     case TEMPLATE_DECL:
    7471                 :            :       /* We encounter instantiations of templates like
    7472                 :            :          template <template <template <class> class> class TT>
    7473                 :            :          class C;  */
    7474                 :         68 :       {
    7475                 :         68 :         tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
    7476                 :         68 :         tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
    7477                 :            : 
    7478                 :         68 :         if (!coerce_template_template_parms
    7479                 :         68 :             (parmparm, argparm, complain, in_decl, outer_args))
    7480                 :            :           return 0;
    7481                 :            :       }
    7482                 :            :       /* Fall through.  */
    7483                 :            : 
    7484                 :    2014690 :     case TYPE_DECL:
    7485                 :    2014760 :       if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (arg))
    7486                 :    2032460 :           && !TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm)))
    7487                 :            :         /* Argument is a parameter pack but parameter is not.  */
    7488                 :            :         return 0;
    7489                 :            :       break;
    7490                 :            : 
    7491                 :       8903 :     case PARM_DECL:
    7492                 :            :       /* The tsubst call is used to handle cases such as
    7493                 :            : 
    7494                 :            :            template <int> class C {};
    7495                 :            :            template <class T, template <T> class TT> class D {};
    7496                 :            :            D<int, C> d;
    7497                 :            : 
    7498                 :            :          i.e. the parameter list of TT depends on earlier parameters.  */
    7499                 :       8903 :       if (!uses_template_parms (TREE_TYPE (arg)))
    7500                 :            :         {
    7501                 :       8851 :           tree t = tsubst (TREE_TYPE (parm), outer_args, complain, in_decl);
    7502                 :       8851 :           if (!uses_template_parms (t)
    7503                 :      17690 :               && !same_type_p (t, TREE_TYPE (arg)))
    7504                 :            :             return 0;
    7505                 :            :         }
    7506                 :            : 
    7507                 :       8871 :       if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (arg))
    7508                 :       8893 :           && !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)))
    7509                 :            :         /* Argument is a parameter pack but parameter is not.  */
    7510                 :            :         return 0;
    7511                 :            : 
    7512                 :            :       break;
    7513                 :            : 
    7514                 :          0 :     default:
    7515                 :          0 :       gcc_unreachable ();
    7516                 :            :     }
    7517                 :            : 
    7518                 :            :   return 1;
    7519                 :            : }
    7520                 :            : 
    7521                 :            : /* Coerce template argument list ARGLIST for use with template
    7522                 :            :    template-parameter TEMPL.  */
    7523                 :            : 
    7524                 :            : static tree
    7525                 :      39715 : coerce_template_args_for_ttp (tree templ, tree arglist,
    7526                 :            :                               tsubst_flags_t complain)
    7527                 :            : {
    7528                 :            :   /* Consider an example where a template template parameter declared as
    7529                 :            : 
    7530                 :            :      template <class T, class U = std::allocator<T> > class TT
    7531                 :            : 
    7532                 :            :      The template parameter level of T and U are one level larger than
    7533                 :            :      of TT.  To proper process the default argument of U, say when an
    7534                 :            :      instantiation `TT<int>' is seen, we need to build the full
    7535                 :            :      arguments containing {int} as the innermost level.  Outer levels,
    7536                 :            :      available when not appearing as default template argument, can be
    7537                 :            :      obtained from the arguments of the enclosing template.
    7538                 :            : 
    7539                 :            :      Suppose that TT is later substituted with std::vector.  The above
    7540                 :            :      instantiation is `TT<int, std::allocator<T> >' with TT at
    7541                 :            :      level 1, and T at level 2, while the template arguments at level 1
    7542                 :            :      becomes {std::vector} and the inner level 2 is {int}.  */
    7543                 :            : 
    7544                 :      39715 :   tree outer = DECL_CONTEXT (templ);
    7545                 :      39715 :   if (outer)
    7546                 :      25581 :     outer = generic_targs_for (outer);
    7547                 :      14134 :   else if (current_template_parms)
    7548                 :            :     {
    7549                 :            :       /* This is an argument of the current template, so we haven't set
    7550                 :            :          DECL_CONTEXT yet.  */
    7551                 :            :       tree relevant_template_parms;
    7552                 :            : 
    7553                 :            :       /* Parameter levels that are greater than the level of the given
    7554                 :            :          template template parm are irrelevant.  */
    7555                 :            :       relevant_template_parms = current_template_parms;
    7556                 :      14120 :       while (TMPL_PARMS_DEPTH (relevant_template_parms)
    7557                 :      42360 :              != TEMPLATE_TYPE_LEVEL (TREE_TYPE (templ)))
    7558                 :          0 :         relevant_template_parms = TREE_CHAIN (relevant_template_parms);
    7559                 :            : 
    7560                 :      14120 :       outer = template_parms_to_args (relevant_template_parms);
    7561                 :            :     }
    7562                 :            : 
    7563                 :      39715 :   if (outer)
    7564                 :      39701 :     arglist = add_to_template_args (outer, arglist);
    7565                 :            : 
    7566                 :      39715 :   tree parmlist = DECL_INNERMOST_TEMPLATE_PARMS (templ);
    7567                 :      39715 :   return coerce_template_parms (parmlist, arglist, templ,
    7568                 :            :                                 complain,
    7569                 :            :                                 /*require_all_args=*/true,
    7570                 :      39715 :                                 /*use_default_args=*/true);
    7571                 :            : }
    7572                 :            : 
    7573                 :            : /* A cache of template template parameters with match-all default
    7574                 :            :    arguments.  */
    7575                 :            : static GTY((deletable)) hash_map<tree,tree> *defaulted_ttp_cache;
    7576                 :            : 
    7577                 :            : /* T is a bound template template-parameter.  Copy its arguments into default
    7578                 :            :    arguments of the template template-parameter's template parameters.  */
    7579                 :            : 
    7580                 :            : static tree
    7581                 :         36 : add_defaults_to_ttp (tree otmpl)
    7582                 :            : {
    7583                 :         36 :   if (tree *c = hash_map_safe_get (defaulted_ttp_cache, otmpl))
    7584                 :         18 :     return *c;
    7585                 :            : 
    7586                 :         18 :   tree ntmpl = copy_node (otmpl);
    7587                 :            : 
    7588                 :         18 :   tree ntype = copy_node (TREE_TYPE (otmpl));
    7589                 :         18 :   TYPE_STUB_DECL (ntype) = TYPE_NAME (ntype) = ntmpl;
    7590                 :         18 :   TYPE_MAIN_VARIANT (ntype) = ntype;
    7591                 :         18 :   TYPE_POINTER_TO (ntype) = TYPE_REFERENCE_TO (ntype) = NULL_TREE;
    7592                 :         18 :   TYPE_NAME (ntype) = ntmpl;
    7593                 :         18 :   SET_TYPE_STRUCTURAL_EQUALITY (ntype);
    7594                 :            : 
    7595                 :         36 :   tree idx = TEMPLATE_TYPE_PARM_INDEX (ntype)
    7596                 :         36 :     = copy_node (TEMPLATE_TYPE_PARM_INDEX (ntype));
    7597                 :         18 :   TEMPLATE_PARM_DECL (idx) = ntmpl;
    7598                 :         18 :   TREE_TYPE (ntmpl) = TREE_TYPE (idx) = ntype;
    7599                 :            : 
    7600                 :         18 :   tree oparms = DECL_TEMPLATE_PARMS (otmpl);
    7601                 :         18 :   tree parms = DECL_TEMPLATE_PARMS (ntmpl) = copy_node (oparms);
    7602                 :         18 :   TREE_CHAIN (parms) = TREE_CHAIN (oparms);
    7603                 :         18 :   tree vec = TREE_VALUE (parms) = copy_node (TREE_VALUE (parms));
    7604                 :         44 :   for (int i = 0; i < TREE_VEC_LENGTH (vec); ++i)
    7605                 :            :     {
    7606                 :         26 :       tree o = TREE_VEC_ELT (vec, i);
    7607                 :         26 :       if (!template_parameter_pack_p (TREE_VALUE (o)))
    7608                 :            :         {
    7609                 :         22 :           tree n = TREE_VEC_ELT (vec, i) = copy_node (o);
    7610                 :         22 :           TREE_PURPOSE (n) = any_targ_node;
    7611                 :            :         }
    7612                 :            :     }
    7613                 :            : 
    7614                 :         18 :   hash_map_safe_put<hm_ggc> (defaulted_ttp_cache, otmpl, ntmpl);
    7615                 :         18 :   return ntmpl;
    7616                 :            : }
    7617                 :            : 
    7618                 :            : /* ARG is a bound potential template template-argument, and PARGS is a list
    7619                 :            :    of arguments for the corresponding template template-parameter.  Adjust
    7620                 :            :    PARGS as appropriate for application to ARG's template, and if ARG is a
    7621                 :            :    BOUND_TEMPLATE_TEMPLATE_PARM, possibly adjust it to add default template
    7622                 :            :    arguments to the template template parameter.  */
    7623                 :            : 
    7624                 :            : static tree
    7625                 :       1198 : coerce_ttp_args_for_tta (tree& arg, tree pargs, tsubst_flags_t complain)
    7626                 :            : {
    7627                 :       1198 :   ++processing_template_decl;
    7628                 :       1198 :   tree arg_tmpl = TYPE_TI_TEMPLATE (arg);
    7629                 :       2396 :   if (DECL_TEMPLATE_TEMPLATE_PARM_P (arg_tmpl))
    7630                 :            :     {
    7631                 :            :       /* When comparing two template template-parameters in partial ordering,
    7632                 :            :          rewrite the one currently being used as an argument to have default
    7633                 :            :          arguments for all parameters.  */
    7634                 :         36 :       arg_tmpl = add_defaults_to_ttp (arg_tmpl);
    7635                 :         36 :       pargs = coerce_template_args_for_ttp (arg_tmpl, pargs, complain);
    7636                 :         36 :       if (pargs != error_mark_node)
    7637                 :         32 :         arg = bind_template_template_parm (TREE_TYPE (arg_tmpl),
    7638                 :         64 :                                            TYPE_TI_ARGS (arg));
    7639                 :            :     }
    7640                 :            :   else
    7641                 :            :     {
    7642                 :       1162 :       tree aparms
    7643                 :       1162 :         = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (arg_tmpl));
    7644                 :       1162 :       pargs = coerce_template_parms (aparms, pargs, arg_tmpl, complain,
    7645                 :            :                                        /*require_all*/true,
    7646                 :            :                                        /*use_default*/true);
    7647                 :            :     }
    7648                 :       1198 :   --processing_template_decl;
    7649                 :       1198 :   return pargs;
    7650                 :            : }
    7651                 :            : 
    7652                 :            : /* Subroutine of unify for the case when PARM is a
    7653                 :            :    BOUND_TEMPLATE_TEMPLATE_PARM.  */
    7654                 :            : 
    7655                 :            : static int
    7656                 :       1663 : unify_bound_ttp_args (tree tparms, tree targs, tree parm, tree& arg,
    7657                 :            :                       bool explain_p)
    7658                 :            : {
    7659                 :       3326 :   tree parmvec = TYPE_TI_ARGS (parm);
    7660                 :       3326 :   tree argvec = INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg));
    7661                 :            : 
    7662                 :            :   /* The template template parm might be variadic and the argument
    7663                 :            :      not, so flatten both argument lists.  */
    7664                 :       1663 :   parmvec = expand_template_argument_pack (parmvec);
    7665                 :       1663 :   argvec = expand_template_argument_pack (argvec);
    7666                 :            : 
    7667                 :       1663 :   if (flag_new_ttp)
    7668                 :            :     {
    7669                 :            :       /* In keeping with P0522R0, adjust P's template arguments
    7670                 :            :          to apply to A's template; then flatten it again.  */
    7671                 :       1198 :       tree nparmvec = coerce_ttp_args_for_tta (arg, parmvec, tf_none);
    7672                 :       1198 :       nparmvec = expand_template_argument_pack (nparmvec);
    7673                 :            : 
    7674                 :       1198 :       if (unify (tparms, targs, nparmvec, argvec,
    7675                 :            :                  UNIFY_ALLOW_NONE, explain_p))
    7676                 :            :         return 1;
    7677                 :            : 
    7678                 :            :       /* If the P0522 adjustment eliminated a pack expansion, deduce
    7679                 :            :          empty packs.  */
    7680                 :       1157 :       if (flag_new_ttp
    7681                 :       1157 :           && TREE_VEC_LENGTH (nparmvec) < TREE_VEC_LENGTH (parmvec)
    7682                 :       1157 :           && unify_pack_expansion (tparms, targs, parmvec, argvec,
    7683                 :            :                                    DEDUCE_EXACT, /*sub*/true, explain_p))
    7684                 :          0 :         return 1;
    7685                 :            :     }
    7686                 :            :   else
    7687                 :            :     {
    7688                 :            :       /* Deduce arguments T, i from TT<T> or TT<i>.
    7689                 :            :          We check each element of PARMVEC and ARGVEC individually
    7690                 :            :          rather than the whole TREE_VEC since they can have
    7691                 :            :          different number of elements, which is allowed under N2555.  */
    7692                 :            : 
    7693                 :        465 :       int len = TREE_VEC_LENGTH (parmvec);
    7694                 :            : 
    7695                 :            :       /* Check if the parameters end in a pack, making them
    7696                 :            :          variadic.  */
    7697                 :        465 :       int parm_variadic_p = 0;
    7698                 :        465 :       if (len > 0
    7699                 :        465 :           && PACK_EXPANSION_P (TREE_VEC_ELT (parmvec, len - 1)))
    7700                 :            :         parm_variadic_p = 1;
    7701                 :            : 
    7702                 :        949 :       for (int i = 0; i < len - parm_variadic_p; ++i)
    7703                 :            :         /* If the template argument list of P contains a pack
    7704                 :            :            expansion that is not the last template argument, the
    7705                 :            :            entire template argument list is a non-deduced
    7706                 :            :            context.  */
    7707                 :        486 :         if (PACK_EXPANSION_P (TREE_VEC_ELT (parmvec, i)))
    7708                 :       1663 :           return unify_success (explain_p);
    7709                 :            : 
    7710                 :        463 :       if (TREE_VEC_LENGTH (argvec) < len - parm_variadic_p)
    7711                 :          4 :         return unify_too_few_arguments (explain_p,
    7712                 :          4 :                                         TREE_VEC_LENGTH (argvec), len);
    7713                 :            : 
    7714                 :        919 :       for (int i = 0; i < len - parm_variadic_p; ++i)
    7715                 :        476 :         if (unify (tparms, targs,
    7716                 :        476 :                    TREE_VEC_ELT (parmvec, i),
    7717                 :        476 :                    TREE_VEC_ELT (argvec, i),
    7718                 :            :                    UNIFY_ALLOW_NONE, explain_p))
    7719                 :            :           return 1;
    7720                 :            : 
    7721                 :        443 :       if (parm_variadic_p
    7722                 :        443 :           && unify_pack_expansion (tparms, targs,
    7723                 :            :                                    parmvec, argvec,
    7724                 :            :                                    DEDUCE_EXACT,
    7725                 :            :                                    /*subr=*/true, explain_p))
    7726                 :          4 :         return 1;
    7727                 :            :     }
    7728                 :            : 
    7729                 :            :   return 0;
    7730                 :            : }
    7731                 :            : 
    7732                 :            : /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
    7733                 :            :    template template parameters.  Both PARM_PARMS and ARG_PARMS are
    7734                 :            :    vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
    7735                 :            :    or PARM_DECL.
    7736                 :            : 
    7737                 :            :    Consider the example:
    7738                 :            :      template <class T> class A;
    7739                 :            :      template<template <class U> class TT> class B;
    7740                 :            : 
    7741                 :            :    For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
    7742                 :            :    the parameters to A, and OUTER_ARGS contains A.  */
    7743                 :            : 
    7744                 :            : static int
    7745                 :    1030770 : coerce_template_template_parms (tree parm_parms,
    7746                 :            :                                 tree arg_parms,
    7747                 :            :                                 tsubst_flags_t complain,
    7748                 :            :                                 tree in_decl,
    7749                 :            :                                 tree outer_args)
    7750                 :            : {
    7751                 :    1030770 :   int nparms, nargs, i;
    7752                 :    1030770 :   tree parm, arg;
    7753                 :    1030770 :   int variadic_p = 0;
    7754                 :            : 
    7755                 :    1030770 :   gcc_assert (TREE_CODE (parm_parms) == TREE_VEC);
    7756                 :    1030770 :   gcc_assert (TREE_CODE (arg_parms) == TREE_VEC);
    7757                 :            : 
    7758                 :    1030770 :   nparms = TREE_VEC_LENGTH (parm_parms);
    7759                 :    1030770 :   nargs = TREE_VEC_LENGTH (arg_parms);
    7760                 :            : 
    7761                 :    1030770 :   if (flag_new_ttp)
    7762                 :            :     {
    7763                 :            :       /* P0522R0: A template template-parameter P is at least as specialized as
    7764                 :            :          a template template-argument A if, given the following rewrite to two
    7765                 :            :          function templates, the function template corresponding to P is at
    7766                 :            :          least as specialized as the function template corresponding to A
    7767                 :            :          according to the partial ordering rules for function templates
    7768                 :            :          ([temp.func.order]). Given an invented class template X with the
    7769                 :            :          template parameter list of A (including default arguments):
    7770                 :            : 
    7771                 :            :          * Each of the two function templates has the same template parameters,
    7772                 :            :          respectively, as P or A.
    7773                 :            : 
    7774                 :            :          * Each function template has a single function parameter whose type is
    7775                 :            :          a specialization of X with template arguments corresponding to the
    7776                 :            :          template parameters from the respective function template where, for
    7777                 :            :          each template parameter PP in the template parameter list of the
    7778                 :            :          function template, a corresponding template argument AA is formed. If
    7779                 :            :          PP declares a parameter pack, then AA is the pack expansion
    7780                 :            :          PP... ([temp.variadic]); otherwise, AA is the id-expression PP.
    7781                 :            : 
    7782                 :            :          If the rewrite produces an invalid type, then P is not at least as
    7783                 :            :          specialized as A.  */
    7784                 :