Branch data Line data Source code
1 : : /* Handle parameterized types (templates) for GNU -*- C++ -*-.
2 : : Copyright (C) 1992-2024 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 : : Fixed by: C++20 modules. */
28 : :
29 : : #include "config.h"
30 : : #define INCLUDE_ALGORITHM // for std::equal
31 : : #include "system.h"
32 : : #include "coretypes.h"
33 : : #include "cp-tree.h"
34 : : #include "timevar.h"
35 : : #include "stringpool.h"
36 : : #include "varasm.h"
37 : : #include "attribs.h"
38 : : #include "stor-layout.h"
39 : : #include "intl.h"
40 : : #include "c-family/c-objc.h"
41 : : #include "cp-objcp-common.h"
42 : : #include "toplev.h"
43 : : #include "tree-iterator.h"
44 : : #include "type-utils.h"
45 : : #include "gimplify.h"
46 : : #include "gcc-rich-location.h"
47 : : #include "selftest.h"
48 : : #include "target.h"
49 : : #include "builtins.h"
50 : : #include "omp-general.h"
51 : :
52 : : /* The type of functions taking a tree, and some additional data, and
53 : : returning an int. */
54 : : typedef int (*tree_fn_t) (tree, void*);
55 : :
56 : : /* The PENDING_TEMPLATES is a list of templates whose instantiations
57 : : have been deferred, either because their definitions were not yet
58 : : available, or because we were putting off doing the work. */
59 : : struct GTY ((chain_next ("%h.next"))) pending_template
60 : : {
61 : : struct pending_template *next;
62 : : struct tinst_level *tinst;
63 : : };
64 : :
65 : : static GTY(()) struct pending_template *pending_templates;
66 : : static GTY(()) struct pending_template *last_pending_template;
67 : :
68 : : int processing_template_parmlist;
69 : : static int template_header_count;
70 : :
71 : : static vec<int> inline_parm_levels;
72 : :
73 : : static GTY(()) struct tinst_level *current_tinst_level;
74 : :
75 : : static GTY(()) vec<tree, va_gc> *saved_access_scope;
76 : :
77 : : /* Live only within one (recursive) call to tsubst_expr. We use
78 : : this to pass the statement expression node from the STMT_EXPR
79 : : to the EXPR_STMT that is its result. */
80 : : static tree cur_stmt_expr;
81 : :
82 : : // -------------------------------------------------------------------------- //
83 : : // Local Specialization Stack
84 : : //
85 : : // Implementation of the RAII helper for creating new local
86 : : // specializations.
87 : 37039903 : local_specialization_stack::local_specialization_stack (lss_policy policy)
88 : 37039903 : : saved (local_specializations)
89 : : {
90 : 37039903 : if (policy == lss_nop)
91 : : ;
92 : 19960892 : else if (policy == lss_blank || !saved)
93 : 18434492 : local_specializations = new hash_map<tree, tree>;
94 : : else
95 : 1526400 : local_specializations = new hash_map<tree, tree>(*saved);
96 : 37039903 : }
97 : :
98 : 37037194 : local_specialization_stack::~local_specialization_stack ()
99 : : {
100 : 37037194 : if (local_specializations != saved)
101 : : {
102 : 39916366 : delete local_specializations;
103 : 19958183 : local_specializations = saved;
104 : : }
105 : 37037194 : }
106 : :
107 : : /* True if we've recursed into fn_type_unification too many times. */
108 : : static bool excessive_deduction_depth;
109 : :
110 : : struct spec_hasher : ggc_ptr_hash<spec_entry>
111 : : {
112 : : static hashval_t hash (tree, tree);
113 : : static hashval_t hash (spec_entry *);
114 : : static bool equal (spec_entry *, spec_entry *);
115 : : };
116 : :
117 : : /* The general template is not in these tables. */
118 : : typedef hash_table<spec_hasher> spec_hash_table;
119 : : static GTY (()) spec_hash_table *decl_specializations;
120 : : static GTY (()) spec_hash_table *type_specializations;
121 : :
122 : : /* Contains canonical template parameter types. The vector is indexed by
123 : : the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
124 : : TREE_LIST, whose TREE_VALUEs contain the canonical template
125 : : parameters of various types and levels. */
126 : : static GTY(()) vec<tree, va_gc> *canonical_template_parms;
127 : :
128 : : #define UNIFY_ALLOW_NONE 0
129 : : #define UNIFY_ALLOW_MORE_CV_QUAL 1
130 : : #define UNIFY_ALLOW_LESS_CV_QUAL 2
131 : : #define UNIFY_ALLOW_DERIVED 4
132 : : #define UNIFY_ALLOW_INTEGER 8
133 : : #define UNIFY_ALLOW_OUTER_LEVEL 16
134 : : #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
135 : : #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
136 : :
137 : : enum template_base_result {
138 : : tbr_incomplete_type,
139 : : tbr_ambiguous_baseclass,
140 : : tbr_success
141 : : };
142 : :
143 : : static bool resolve_overloaded_unification (tree, tree, tree, tree,
144 : : unification_kind_t, int,
145 : : bool);
146 : : static int try_one_overload (tree, tree, tree, tree, tree,
147 : : unification_kind_t, int, bool, bool);
148 : : static int unify (tree, tree, tree, tree, int, bool);
149 : : static void add_pending_template (tree);
150 : : static tree reopen_tinst_level (struct tinst_level *);
151 : : static tree tsubst_initializer_list (tree, tree);
152 : : static tree get_partial_spec_bindings (tree, tree, tree);
153 : : static void tsubst_enum (tree, tree, tree);
154 : : static bool check_instantiated_args (tree, tree, tsubst_flags_t);
155 : : static int check_non_deducible_conversion (tree, tree, unification_kind_t, int,
156 : : struct conversion **, bool, bool);
157 : : static int maybe_adjust_types_for_deduction (tree, unification_kind_t,
158 : : tree*, tree*, tree);
159 : : static int type_unification_real (tree, tree, tree, const tree *,
160 : : unsigned int, int, unification_kind_t,
161 : : vec<deferred_access_check, va_gc> **,
162 : : bool);
163 : : static void note_template_header (int);
164 : : static tree convert_nontype_argument_function (tree, tree, tsubst_flags_t);
165 : : static tree convert_nontype_argument (tree, tree, tsubst_flags_t);
166 : : static tree convert_template_argument (tree, tree, tree,
167 : : tsubst_flags_t, int, tree);
168 : : static tree for_each_template_parm (tree, tree_fn_t, void*,
169 : : hash_set<tree> *, bool, tree_fn_t = NULL);
170 : : static tree expand_template_argument_pack (tree);
171 : : static tree build_template_parm_index (int, int, int, tree, tree);
172 : : static bool inline_needs_template_parms (tree, bool);
173 : : static void push_inline_template_parms_recursive (tree, int);
174 : : static tree reduce_template_parm_level (tree, tree, int, tree, tsubst_flags_t);
175 : : static int mark_template_parm (tree, void *);
176 : : static int template_parm_this_level_p (tree, void *);
177 : : static tree tsubst_friend_function (tree, tree);
178 : : static tree tsubst_friend_class (tree, tree);
179 : : static int can_complete_type_without_circularity (tree);
180 : : static tree get_bindings (tree, tree, tree, bool);
181 : : static int template_decl_level (tree);
182 : : static int check_cv_quals_for_unify (int, tree, tree);
183 : : static int unify_pack_expansion (tree, tree, tree,
184 : : tree, unification_kind_t, bool, bool);
185 : : static tree copy_template_args (tree);
186 : : static tree tsubst_template_parms (tree, tree, tsubst_flags_t);
187 : : static void tsubst_each_template_parm_constraints (tree, tree, tsubst_flags_t);
188 : : static tree tsubst_arg_types (tree, tree, tree, tsubst_flags_t, tree);
189 : : static tree tsubst_function_type (tree, tree, tsubst_flags_t, tree);
190 : : static bool check_specialization_scope (void);
191 : : static tree process_partial_specialization (tree);
192 : : static enum template_base_result get_template_base (tree, tree, tree, tree,
193 : : bool , tree *);
194 : : static tree try_class_unification (tree, tree, tree, tree, bool);
195 : : static bool class_nttp_const_wrapper_p (tree t);
196 : : static int coerce_template_template_parms (tree, tree, tsubst_flags_t,
197 : : tree, tree);
198 : : static bool template_template_parm_bindings_ok_p (tree, tree);
199 : : static void tsubst_default_arguments (tree, tsubst_flags_t);
200 : : static tree for_each_template_parm_r (tree *, int *, void *);
201 : : static tree copy_default_args_to_explicit_spec_1 (tree, tree);
202 : : static void copy_default_args_to_explicit_spec (tree);
203 : : static bool invalid_nontype_parm_type_p (tree, tsubst_flags_t);
204 : : static bool dependent_template_arg_p (tree);
205 : : static bool dependent_type_p_r (tree);
206 : : static tree tsubst_stmt (tree, tree, tsubst_flags_t, tree);
207 : : static tree tsubst_decl (tree, tree, tsubst_flags_t, bool = true);
208 : : static tree tsubst_scope (tree, tree, tsubst_flags_t, tree);
209 : : static tree tsubst_name (tree, tree, tsubst_flags_t, tree);
210 : : static void perform_instantiation_time_access_checks (tree, tree);
211 : : static tree listify (tree);
212 : : static tree listify_autos (tree, tree);
213 : : static tree tsubst_template_parm (tree, tree, tsubst_flags_t);
214 : : static tree instantiate_alias_template (tree, tree, tsubst_flags_t);
215 : : static tree get_underlying_template (tree);
216 : : static tree tsubst_attributes (tree, tree, tsubst_flags_t, tree);
217 : : static tree canonicalize_expr_argument (tree, tsubst_flags_t);
218 : : static tree make_argument_pack (tree);
219 : : static tree enclosing_instantiation_of (tree tctx);
220 : : static void instantiate_body (tree pattern, tree args, tree d, bool nested);
221 : : static tree maybe_dependent_member_ref (tree, tree, tsubst_flags_t, tree);
222 : : static void mark_template_arguments_used (tree, tree);
223 : : static bool uses_outer_template_parms (tree);
224 : : static tree alias_ctad_tweaks (tree, tree);
225 : : static tree inherited_ctad_tweaks (tree, tree, tsubst_flags_t);
226 : : static tree deduction_guides_for (tree, bool&, tsubst_flags_t);
227 : :
228 : : /* Make the current scope suitable for access checking when we are
229 : : processing T. T can be FUNCTION_DECL for instantiated function
230 : : template, VAR_DECL for static member variable, or TYPE_DECL for
231 : : for a class or alias template (needed by instantiate_decl). */
232 : :
233 : : void
234 : 144447042 : push_access_scope (tree t)
235 : : {
236 : 144447042 : gcc_assert (VAR_OR_FUNCTION_DECL_P (t)
237 : : || TREE_CODE (t) == TYPE_DECL);
238 : :
239 : 245226414 : if (DECL_FRIEND_CONTEXT (t))
240 : 424199 : push_nested_class (DECL_FRIEND_CONTEXT (t));
241 : 35380415 : else if (DECL_IMPLICIT_TYPEDEF_P (t)
242 : 152359637 : && CLASS_TYPE_P (TREE_TYPE (t)))
243 : 8336794 : push_nested_class (TREE_TYPE (t));
244 : 135686049 : else if (DECL_CLASS_SCOPE_P (t))
245 : 36057346 : push_nested_class (DECL_CONTEXT (t));
246 : 99628703 : else if (deduction_guide_p (t) && DECL_ARTIFICIAL (t))
247 : : /* An artificial deduction guide should have the same access as
248 : : the constructor. */
249 : 36825 : push_nested_class (TREE_TYPE (TREE_TYPE (t)));
250 : : else
251 : 99591878 : push_to_top_level ();
252 : :
253 : 144447042 : if (TREE_CODE (t) == FUNCTION_DECL)
254 : : {
255 : 101025718 : vec_safe_push (saved_access_scope, current_function_decl);
256 : 101025718 : current_function_decl = t;
257 : : }
258 : 144447042 : }
259 : :
260 : : /* Restore the scope set up by push_access_scope. T is the node we
261 : : are processing. */
262 : :
263 : : void
264 : 144444342 : pop_access_scope (tree t)
265 : : {
266 : 144444342 : if (TREE_CODE (t) == FUNCTION_DECL)
267 : 101023018 : current_function_decl = saved_access_scope->pop();
268 : :
269 : 245221014 : if (DECL_FRIEND_CONTEXT (t)
270 : 144020143 : || (DECL_IMPLICIT_TYPEDEF_P (t)
271 : 8336794 : && CLASS_TYPE_P (TREE_TYPE (t)))
272 : 135683349 : || DECL_CLASS_SCOPE_P (t)
273 : 192397164 : || (deduction_guide_p (t) && DECL_ARTIFICIAL (t)))
274 : 44855164 : pop_nested_class ();
275 : : else
276 : 99589178 : pop_from_top_level ();
277 : 144444342 : }
278 : :
279 : : /* Do any processing required when DECL (a member template
280 : : declaration) is finished. Returns the TEMPLATE_DECL corresponding
281 : : to DECL, unless it is a specialization, in which case the DECL
282 : : itself is returned. */
283 : :
284 : : tree
285 : 17383672 : finish_member_template_decl (tree decl)
286 : : {
287 : 17383672 : if (decl == error_mark_node)
288 : : return error_mark_node;
289 : :
290 : 17383596 : gcc_assert (DECL_P (decl));
291 : :
292 : 17383596 : if (TREE_CODE (decl) == TYPE_DECL)
293 : : {
294 : 1159555 : tree type;
295 : :
296 : 1159555 : type = TREE_TYPE (decl);
297 : 1159555 : if (type == error_mark_node)
298 : : return error_mark_node;
299 : 1159555 : if (MAYBE_CLASS_TYPE_P (type)
300 : 1159555 : && CLASSTYPE_TEMPLATE_INFO (type)
301 : 1159555 : && !CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
302 : : {
303 : 659227 : tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
304 : 659227 : check_member_template (tmpl);
305 : 659227 : return tmpl;
306 : : }
307 : : return NULL_TREE;
308 : : }
309 : 16224041 : else if (TREE_CODE (decl) == FIELD_DECL)
310 : 3 : error_at (DECL_SOURCE_LOCATION (decl),
311 : : "data member %qD cannot be a member template", decl);
312 : 16224038 : else if (DECL_TEMPLATE_INFO (decl))
313 : : {
314 : 16224038 : if (!DECL_TEMPLATE_SPECIALIZATION (decl))
315 : : {
316 : 16161794 : check_member_template (DECL_TI_TEMPLATE (decl));
317 : 16161794 : return DECL_TI_TEMPLATE (decl);
318 : : }
319 : : else
320 : : return NULL_TREE;
321 : : }
322 : : else
323 : 0 : error_at (DECL_SOURCE_LOCATION (decl),
324 : : "invalid member template declaration %qD", decl);
325 : :
326 : 3 : return error_mark_node;
327 : : }
328 : :
329 : : /* Create a template info node. */
330 : :
331 : : tree
332 : 540616091 : build_template_info (tree template_decl, tree template_args)
333 : : {
334 : 540616091 : tree result = make_node (TEMPLATE_INFO);
335 : 540616091 : TI_TEMPLATE (result) = template_decl;
336 : 540616091 : TI_ARGS (result) = template_args;
337 : 540616091 : return result;
338 : : }
339 : :
340 : : /* DECL_TEMPLATE_INFO, if applicable, or NULL_TREE. */
341 : :
342 : : static tree
343 : 1818160229 : decl_template_info (const_tree decl)
344 : : {
345 : : /* This needs to match template_info_decl_check. */
346 : 1818160229 : if (DECL_LANG_SPECIFIC (decl))
347 : 1435482606 : switch (TREE_CODE (decl))
348 : : {
349 : 1295743788 : case FUNCTION_DECL:
350 : 1295743788 : if (DECL_THUNK_P (decl))
351 : : break;
352 : 1435469879 : gcc_fallthrough ();
353 : 1435469879 : case VAR_DECL:
354 : 1435469879 : case FIELD_DECL:
355 : 1435469879 : case TYPE_DECL:
356 : 1435469879 : case CONCEPT_DECL:
357 : 1435469879 : case TEMPLATE_DECL:
358 : 1435469879 : return DECL_TEMPLATE_INFO (decl);
359 : :
360 : : default:
361 : : break;
362 : : }
363 : : return NULL_TREE;
364 : : }
365 : :
366 : : /* Return the template info node corresponding to T, whatever T is. */
367 : :
368 : : tree
369 : 2466616236 : get_template_info (const_tree t)
370 : : {
371 : 2466616236 : tree tinfo = NULL_TREE;
372 : :
373 : 2466616236 : if (!t || t == error_mark_node)
374 : : return NULL;
375 : :
376 : 2466616234 : if (TREE_CODE (t) == NAMESPACE_DECL
377 : 2391708295 : || TREE_CODE (t) == PARM_DECL)
378 : : return NULL;
379 : :
380 : 2383405000 : if (DECL_P (t))
381 : 1818160229 : tinfo = decl_template_info (t);
382 : :
383 : 2383405000 : if (!tinfo && DECL_IMPLICIT_TYPEDEF_P (t))
384 : 380748159 : t = TREE_TYPE (t);
385 : :
386 : 2383405000 : if (OVERLOAD_TYPE_P (t))
387 : 928667295 : tinfo = TYPE_TEMPLATE_INFO (t);
388 : 1454737705 : else if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
389 : 11 : tinfo = TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t);
390 : :
391 : : return tinfo;
392 : : }
393 : :
394 : : /* Returns the template nesting level of the indicated class TYPE.
395 : :
396 : : For example, in:
397 : : template <class T>
398 : : struct A
399 : : {
400 : : template <class U>
401 : : struct B {};
402 : : };
403 : :
404 : : A<T>::B<U> has depth two, while A<T> has depth one.
405 : : Both A<T>::B<int> and A<int>::B<U> have depth one, if
406 : : they are instantiations, not specializations.
407 : :
408 : : This function is guaranteed to return 0 if passed NULL_TREE so
409 : : that, for example, `template_class_depth (current_class_type)' is
410 : : always safe. */
411 : :
412 : : int
413 : 505191791 : template_class_depth (tree type)
414 : : {
415 : 505191791 : int depth;
416 : :
417 : 698227415 : for (depth = 0; type && TREE_CODE (type) != NAMESPACE_DECL; )
418 : : {
419 : 193035624 : tree tinfo = get_template_info (type);
420 : :
421 : 193035624 : if (tinfo
422 : 174214113 : && TREE_CODE (TI_TEMPLATE (tinfo)) == TEMPLATE_DECL
423 : 174214113 : && PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo))
424 : 364398573 : && uses_template_parms (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo))))
425 : 142228157 : ++depth;
426 : :
427 : 193035624 : if (DECL_P (type))
428 : : {
429 : 838924 : if (tree fctx = DECL_FRIEND_CONTEXT (type))
430 : : type = fctx;
431 : : else
432 : 402107 : type = CP_DECL_CONTEXT (type);
433 : : }
434 : 384677328 : else if (LAMBDA_TYPE_P (type) && LAMBDA_TYPE_EXTRA_SCOPE (type))
435 : 327729 : type = LAMBDA_TYPE_EXTRA_SCOPE (type);
436 : : else
437 : 192286184 : type = CP_TYPE_CONTEXT (type);
438 : : }
439 : :
440 : 505191791 : return depth;
441 : : }
442 : :
443 : : /* Return TRUE if NODE instantiates a template that has arguments of
444 : : its own, be it directly a primary template or indirectly through a
445 : : partial specializations. */
446 : : static bool
447 : 105713161 : instantiates_primary_template_p (tree node)
448 : : {
449 : 105713161 : tree tinfo = get_template_info (node);
450 : 105713161 : if (!tinfo)
451 : : return false;
452 : :
453 : 105702067 : tree tmpl = TI_TEMPLATE (tinfo);
454 : 105702067 : if (PRIMARY_TEMPLATE_P (tmpl))
455 : : return true;
456 : :
457 : 95047396 : if (!DECL_TEMPLATE_SPECIALIZATION (tmpl))
458 : : return false;
459 : :
460 : : /* So now we know we have a specialization, but it could be a full
461 : : or a partial specialization. To tell which, compare the depth of
462 : : its template arguments with those of its context. */
463 : :
464 : 0 : tree ctxt = DECL_CONTEXT (tmpl);
465 : 0 : tree ctinfo = get_template_info (ctxt);
466 : 0 : if (!ctinfo)
467 : : return true;
468 : :
469 : 0 : return (TMPL_ARGS_DEPTH (TI_ARGS (tinfo))
470 : 0 : > TMPL_ARGS_DEPTH (TI_ARGS (ctinfo)));
471 : : }
472 : :
473 : : /* Subroutine of maybe_begin_member_template_processing.
474 : : Returns true if processing DECL needs us to push template parms. */
475 : :
476 : : static bool
477 : 153036199 : inline_needs_template_parms (tree decl, bool nsdmi)
478 : : {
479 : 153036199 : if (!decl || (!nsdmi && ! DECL_TEMPLATE_INFO (decl)))
480 : : return false;
481 : :
482 : 129008364 : return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl)))
483 : 129008364 : > (current_template_depth + DECL_TEMPLATE_SPECIALIZATION (decl)));
484 : : }
485 : :
486 : : /* Subroutine of maybe_begin_member_template_processing.
487 : : Push the template parms in PARMS, starting from LEVELS steps into the
488 : : chain, and ending at the beginning, since template parms are listed
489 : : innermost first. */
490 : :
491 : : static void
492 : 34092865 : push_inline_template_parms_recursive (tree parmlist, int levels)
493 : : {
494 : 34092865 : tree parms = TREE_VALUE (parmlist);
495 : 34092865 : int i;
496 : :
497 : 34092865 : if (levels > 1)
498 : 410742 : push_inline_template_parms_recursive (TREE_CHAIN (parmlist), levels - 1);
499 : :
500 : 34092865 : ++processing_template_decl;
501 : 68185730 : current_template_parms
502 : 34092865 : = tree_cons (size_int (current_template_depth + 1),
503 : : parms, current_template_parms);
504 : 68185730 : TEMPLATE_PARMS_CONSTRAINTS (current_template_parms)
505 : 34092865 : = TEMPLATE_PARMS_CONSTRAINTS (parmlist);
506 : 34092865 : TEMPLATE_PARMS_FOR_INLINE (current_template_parms) = 1;
507 : :
508 : 34092865 : begin_scope (TREE_VEC_LENGTH (parms) ? sk_template_parms : sk_template_spec,
509 : : NULL);
510 : 91487007 : for (i = 0; i < TREE_VEC_LENGTH (parms); ++i)
511 : : {
512 : 57394142 : tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
513 : :
514 : 57394142 : if (error_operand_p (parm))
515 : 37 : continue;
516 : :
517 : 57394105 : gcc_assert (DECL_P (parm));
518 : :
519 : 57394105 : switch (TREE_CODE (parm))
520 : : {
521 : 53004003 : case TYPE_DECL:
522 : 53004003 : case TEMPLATE_DECL:
523 : 53004003 : pushdecl (parm);
524 : 53004003 : break;
525 : :
526 : 4390102 : case PARM_DECL:
527 : : /* Push the CONST_DECL. */
528 : 4390102 : pushdecl (TEMPLATE_PARM_DECL (DECL_INITIAL (parm)));
529 : 4390102 : break;
530 : :
531 : 0 : default:
532 : 0 : gcc_unreachable ();
533 : : }
534 : : }
535 : 34092865 : }
536 : :
537 : : /* Restore the template parameter context for a member template, a
538 : : friend template defined in a class definition, or a non-template
539 : : member of template class. */
540 : :
541 : : void
542 : 153036199 : maybe_begin_member_template_processing (tree decl)
543 : : {
544 : 153036199 : tree parms;
545 : 153036199 : int levels = 0;
546 : 153036199 : bool nsdmi = TREE_CODE (decl) == FIELD_DECL;
547 : :
548 : 153036199 : if (nsdmi)
549 : : {
550 : 891071 : tree ctx = DECL_CONTEXT (decl);
551 : 891071 : decl = (CLASSTYPE_TEMPLATE_INFO (ctx)
552 : : /* Disregard full specializations (c++/60999). */
553 : 542788 : && uses_template_parms (ctx)
554 : 1431614 : ? CLASSTYPE_TI_TEMPLATE (ctx) : NULL_TREE);
555 : : }
556 : :
557 : 153036199 : if (inline_needs_template_parms (decl, nsdmi))
558 : : {
559 : 33682123 : parms = DECL_TEMPLATE_PARMS (most_general_template (decl));
560 : 33682123 : levels = TMPL_PARMS_DEPTH (parms) - current_template_depth;
561 : :
562 : 33682123 : if (DECL_TEMPLATE_SPECIALIZATION (decl))
563 : : {
564 : 0 : --levels;
565 : 0 : parms = TREE_CHAIN (parms);
566 : : }
567 : :
568 : 33682123 : push_inline_template_parms_recursive (parms, levels);
569 : : }
570 : :
571 : : /* Remember how many levels of template parameters we pushed so that
572 : : we can pop them later. */
573 : 153036199 : inline_parm_levels.safe_push (levels);
574 : 153036199 : }
575 : :
576 : : /* Undo the effects of maybe_begin_member_template_processing. */
577 : :
578 : : void
579 : 153036547 : maybe_end_member_template_processing (void)
580 : : {
581 : 153036547 : int i;
582 : 153036547 : int last;
583 : :
584 : 153036547 : if (inline_parm_levels.length () == 0)
585 : : return;
586 : :
587 : 153036199 : last = inline_parm_levels.pop ();
588 : 187129064 : for (i = 0; i < last; ++i)
589 : : {
590 : 34092865 : --processing_template_decl;
591 : 34092865 : current_template_parms = TREE_CHAIN (current_template_parms);
592 : 34092865 : poplevel (0, 0, 0);
593 : : }
594 : : }
595 : :
596 : : /* Return a new template argument vector which contains all of ARGS,
597 : : but has as its innermost set of arguments the EXTRA_ARGS. */
598 : :
599 : : tree
600 : 123386703 : add_to_template_args (tree args, tree extra_args)
601 : : {
602 : 123386703 : tree new_args;
603 : 123386703 : int extra_depth;
604 : 123386703 : int i;
605 : 123386703 : int j;
606 : :
607 : 123386703 : if (args == NULL_TREE || extra_args == error_mark_node)
608 : : return extra_args;
609 : :
610 : 76813126 : extra_depth = TMPL_ARGS_DEPTH (extra_args);
611 : 38406563 : new_args = make_tree_vec (TMPL_ARGS_DEPTH (args) + extra_depth);
612 : :
613 : 122212221 : for (i = 1; i <= TMPL_ARGS_DEPTH (args); ++i)
614 : 38579121 : SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (args, i));
615 : :
616 : 76813138 : for (j = 1; j <= extra_depth; ++j, ++i)
617 : 76813150 : SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (extra_args, j));
618 : :
619 : : return new_args;
620 : : }
621 : :
622 : : /* Like add_to_template_args, but only the outermost ARGS are added to
623 : : the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
624 : : (EXTRA_ARGS) levels are added. This function is used to combine
625 : : the template arguments from a partial instantiation with the
626 : : template arguments used to attain the full instantiation from the
627 : : partial instantiation.
628 : :
629 : : If ARGS is a TEMPLATE_DECL, use its parameters as args. */
630 : :
631 : : tree
632 : 720084852 : add_outermost_template_args (tree args, tree extra_args)
633 : : {
634 : 720084852 : tree new_args;
635 : :
636 : 720084852 : if (!args)
637 : : return extra_args;
638 : 720084852 : if (TREE_CODE (args) == TEMPLATE_DECL)
639 : : {
640 : 118922439 : tree ti = get_template_info (DECL_TEMPLATE_RESULT (args));
641 : 118922439 : args = TI_ARGS (ti);
642 : : }
643 : :
644 : : /* If there are more levels of EXTRA_ARGS than there are ARGS,
645 : : something very fishy is going on. */
646 : 2958182644 : gcc_assert (TMPL_ARGS_DEPTH (args) >= TMPL_ARGS_DEPTH (extra_args));
647 : :
648 : : /* If *all* the new arguments will be the EXTRA_ARGS, just return
649 : : them. */
650 : 3559345057 : if (TMPL_ARGS_DEPTH (args) == TMPL_ARGS_DEPTH (extra_args))
651 : : return extra_args;
652 : :
653 : : /* For the moment, we make ARGS look like it contains fewer levels. */
654 : 104269075 : TREE_VEC_LENGTH (args) -= TMPL_ARGS_DEPTH (extra_args);
655 : :
656 : 34890699 : new_args = add_to_template_args (args, extra_args);
657 : :
658 : : /* Now, we restore ARGS to its full dimensions. */
659 : 104269075 : TREE_VEC_LENGTH (args) += TMPL_ARGS_DEPTH (extra_args);
660 : :
661 : 34890699 : return new_args;
662 : : }
663 : :
664 : : /* Return the N levels of innermost template arguments from the ARGS. */
665 : :
666 : : tree
667 : 3972514360 : get_innermost_template_args (tree args, int n)
668 : : {
669 : 3972514360 : tree new_args;
670 : 3972514360 : int extra_levels;
671 : 3972514360 : int i;
672 : :
673 : 3972514360 : gcc_assert (n >= 0);
674 : :
675 : : /* If N is 1, just return the innermost set of template arguments. */
676 : 3972514360 : if (n == 1)
677 : 7944892710 : return TMPL_ARGS_LEVEL (args, TMPL_ARGS_DEPTH (args));
678 : :
679 : : /* If we're not removing anything, just return the arguments we were
680 : : given. */
681 : 136010 : extra_levels = TMPL_ARGS_DEPTH (args) - n;
682 : 68005 : gcc_assert (extra_levels >= 0);
683 : 68005 : if (extra_levels == 0)
684 : : return args;
685 : :
686 : : /* Make a new set of arguments, not containing the outer arguments. */
687 : 18 : new_args = make_tree_vec (n);
688 : 72 : for (i = 1; i <= n; ++i)
689 : 72 : SET_TMPL_ARGS_LEVEL (new_args, i,
690 : : TMPL_ARGS_LEVEL (args, i + extra_levels));
691 : :
692 : : return new_args;
693 : : }
694 : :
695 : : /* The inverse of get_innermost_template_args: Return all but the innermost
696 : : EXTRA_LEVELS levels of template arguments from the ARGS. */
697 : :
698 : : static tree
699 : 177689 : strip_innermost_template_args (tree args, int extra_levels)
700 : : {
701 : 177689 : tree new_args;
702 : 355378 : int n = TMPL_ARGS_DEPTH (args) - extra_levels;
703 : 177689 : int i;
704 : :
705 : 177689 : gcc_assert (n >= 0);
706 : :
707 : : /* If N is 1, just return the outermost set of template arguments. */
708 : 177689 : if (n == 1)
709 : 354462 : return TMPL_ARGS_LEVEL (args, 1);
710 : :
711 : : /* If we're not removing anything, just return the arguments we were
712 : : given. */
713 : 458 : gcc_assert (extra_levels >= 0);
714 : 458 : if (extra_levels == 0)
715 : : return args;
716 : :
717 : : /* Make a new set of arguments, not containing the inner arguments. */
718 : 458 : new_args = make_tree_vec (n);
719 : 1832 : for (i = 1; i <= n; ++i)
720 : 1832 : SET_TMPL_ARGS_LEVEL (new_args, i,
721 : : TMPL_ARGS_LEVEL (args, i));
722 : :
723 : : return new_args;
724 : : }
725 : :
726 : : /* We've got a template header coming up; push to a new level for storing
727 : : the parms. */
728 : :
729 : : void
730 : 77189934 : begin_template_parm_list (void)
731 : : {
732 : : /* We use a non-tag-transparent scope here, which causes pushtag to
733 : : put tags in this scope, rather than in the enclosing class or
734 : : namespace scope. This is the right thing, since we want
735 : : TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
736 : : global template class, push_template_decl handles putting the
737 : : TEMPLATE_DECL into top-level scope. For a nested template class,
738 : : e.g.:
739 : :
740 : : template <class T> struct S1 {
741 : : template <class T> struct S2 {};
742 : : };
743 : :
744 : : pushtag contains special code to insert the TEMPLATE_DECL for S2
745 : : at the right scope. */
746 : 77189934 : begin_scope (sk_template_parms, NULL);
747 : 77189934 : ++processing_template_decl;
748 : 77189934 : ++processing_template_parmlist;
749 : 77189934 : note_template_header (0);
750 : :
751 : : /* Add a dummy parameter level while we process the parameter list. */
752 : 154379868 : current_template_parms
753 : 77189934 : = tree_cons (size_int (current_template_depth + 1),
754 : : make_tree_vec (0),
755 : : current_template_parms);
756 : 77189934 : }
757 : :
758 : : /* This routine is called when a specialization is declared. If it is
759 : : invalid to declare a specialization here, an error is reported and
760 : : false is returned, otherwise this routine will return true. */
761 : :
762 : : static bool
763 : 4938656 : check_specialization_scope (void)
764 : : {
765 : 4938656 : tree scope = current_scope ();
766 : :
767 : : /* [temp.expl.spec]
768 : :
769 : : An explicit specialization shall be declared in the namespace of
770 : : which the template is a member, or, for member templates, in the
771 : : namespace of which the enclosing class or enclosing class
772 : : template is a member. An explicit specialization of a member
773 : : function, member class or static data member of a class template
774 : : shall be declared in the namespace of which the class template
775 : : is a member. */
776 : 4938656 : if (scope && TREE_CODE (scope) != NAMESPACE_DECL)
777 : : {
778 : 24 : error ("explicit specialization in non-namespace scope %qD", scope);
779 : 24 : return false;
780 : : }
781 : :
782 : : /* [temp.expl.spec]
783 : :
784 : : In an explicit specialization declaration for a member of a class
785 : : template or a member template that appears in namespace scope,
786 : : the member template and some of its enclosing class templates may
787 : : remain unspecialized, except that the declaration shall not
788 : : explicitly specialize a class member template if its enclosing
789 : : class templates are not explicitly specialized as well. */
790 : 4938632 : if (current_template_parms)
791 : : {
792 : 6 : error ("enclosing class templates are not explicitly specialized");
793 : 6 : return false;
794 : : }
795 : :
796 : : return true;
797 : : }
798 : :
799 : : /* We've just seen template <>. */
800 : :
801 : : bool
802 : 4938656 : begin_specialization (void)
803 : : {
804 : 4938656 : begin_scope (sk_template_spec, NULL);
805 : 4938656 : note_template_header (1);
806 : 9877312 : return check_specialization_scope ();
807 : : }
808 : :
809 : : /* Called at then end of processing a declaration preceded by
810 : : template<>. */
811 : :
812 : : void
813 : 4938656 : end_specialization (void)
814 : : {
815 : 4938656 : finish_scope ();
816 : 4938656 : reset_specialization ();
817 : 4938656 : }
818 : :
819 : : /* Any template <>'s that we have seen thus far are not referring to a
820 : : function specialization. */
821 : :
822 : : void
823 : 144450306 : reset_specialization (void)
824 : : {
825 : 144450306 : processing_specialization = 0;
826 : 144450306 : template_header_count = 0;
827 : 144450306 : }
828 : :
829 : : /* We've just seen a template header. If SPECIALIZATION is nonzero,
830 : : it was of the form template <>. */
831 : :
832 : : static void
833 : 82128590 : note_template_header (int specialization)
834 : : {
835 : 82128590 : processing_specialization = specialization;
836 : 82128590 : template_header_count++;
837 : 0 : }
838 : :
839 : : /* We're beginning an explicit instantiation. */
840 : :
841 : : void
842 : 2791273 : begin_explicit_instantiation (void)
843 : : {
844 : 2791273 : gcc_assert (!processing_explicit_instantiation);
845 : 2791273 : processing_explicit_instantiation = true;
846 : 2791273 : }
847 : :
848 : :
849 : : void
850 : 2791270 : end_explicit_instantiation (void)
851 : : {
852 : 2791270 : gcc_assert (processing_explicit_instantiation);
853 : 2791270 : processing_explicit_instantiation = false;
854 : 2791270 : }
855 : :
856 : : /* An explicit specialization or partial specialization of TMPL is being
857 : : declared. Check that the namespace in which the specialization is
858 : : occurring is permissible. Returns false iff it is invalid to
859 : : specialize TMPL in the current namespace. */
860 : :
861 : : static bool
862 : 11699771 : check_specialization_namespace (tree tmpl)
863 : : {
864 : 11699771 : tree tpl_ns = decl_namespace_context (tmpl);
865 : :
866 : : /* [tmpl.expl.spec]
867 : :
868 : : An explicit specialization shall be declared in a namespace enclosing the
869 : : specialized template. An explicit specialization whose declarator-id is
870 : : not qualified shall be declared in the nearest enclosing namespace of the
871 : : template, or, if the namespace is inline (7.3.1), any namespace from its
872 : : enclosing namespace set. */
873 : 11699771 : if (current_scope() != DECL_CONTEXT (tmpl)
874 : 11699771 : && !at_namespace_scope_p ())
875 : : {
876 : 12 : error ("specialization of %qD must appear at namespace scope", tmpl);
877 : 12 : return false;
878 : : }
879 : :
880 : 11699759 : if (is_nested_namespace (current_namespace, tpl_ns, cxx_dialect < cxx11))
881 : : /* Same or enclosing namespace. */
882 : : return true;
883 : : else
884 : : {
885 : 14 : auto_diagnostic_group d;
886 : 14 : if (permerror (input_location,
887 : : "specialization of %qD in different namespace", tmpl))
888 : 11 : inform (DECL_SOURCE_LOCATION (tmpl),
889 : : " from definition of %q#D", tmpl);
890 : 14 : return false;
891 : 14 : }
892 : : }
893 : :
894 : : /* SPEC is an explicit instantiation. Check that it is valid to
895 : : perform this explicit instantiation in the current namespace. */
896 : :
897 : : static void
898 : 2826233 : check_explicit_instantiation_namespace (tree spec)
899 : : {
900 : 2826233 : tree ns;
901 : :
902 : : /* DR 275: An explicit instantiation shall appear in an enclosing
903 : : namespace of its template. */
904 : 2826233 : ns = decl_namespace_context (spec);
905 : 2826233 : if (!is_nested_namespace (current_namespace, ns))
906 : 6 : permerror (input_location, "explicit instantiation of %qD in namespace %qD "
907 : : "(which does not enclose namespace %qD)",
908 : : spec, current_namespace, ns);
909 : 2826233 : }
910 : :
911 : : /* Returns true if TYPE is a new partial specialization that needs to be
912 : : set up. This may also modify TYPE to point to the correct (new or
913 : : existing) constrained partial specialization. */
914 : :
915 : : static bool
916 : 30627021 : maybe_new_partial_specialization (tree& type)
917 : : {
918 : : /* An implicit instantiation of an incomplete type implies
919 : : the definition of a new class template.
920 : :
921 : : template<typename T>
922 : : struct S;
923 : :
924 : : template<typename T>
925 : : struct S<T*>;
926 : :
927 : : Here, S<T*> is an implicit instantiation of S whose type
928 : : is incomplete. */
929 : 30627021 : if (CLASSTYPE_IMPLICIT_INSTANTIATION (type) && !COMPLETE_TYPE_P (type))
930 : : return true;
931 : :
932 : : /* It can also be the case that TYPE is a completed specialization.
933 : : Continuing the previous example, suppose we also declare:
934 : :
935 : : template<typename T>
936 : : requires Integral<T>
937 : : struct S<T*>;
938 : :
939 : : Here, S<T*> refers to the specialization S<T*> defined
940 : : above. However, we need to differentiate definitions because
941 : : we intend to define a new partial specialization. In this case,
942 : : we rely on the fact that the constraints are different for
943 : : this declaration than that above.
944 : :
945 : : Note that we also get here for injected class names and
946 : : late-parsed template definitions. We must ensure that we
947 : : do not create new type declarations for those cases. */
948 : 20401118 : if (flag_concepts && CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
949 : : {
950 : 5145785 : tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
951 : 5145785 : tree args = CLASSTYPE_TI_ARGS (type);
952 : :
953 : : /* If there are no template parameters, this cannot be a new
954 : : partial template specialization? */
955 : 5145785 : if (!current_template_parms)
956 : : return false;
957 : :
958 : : /* The injected-class-name is not a new partial specialization. */
959 : 3305014 : if (DECL_SELF_REFERENCE_P (TYPE_NAME (type)))
960 : : return false;
961 : :
962 : : /* If the constraints are not the same as those of the primary
963 : : then, we can probably create a new specialization. */
964 : 3305014 : tree type_constr = current_template_constraints ();
965 : :
966 : 3305014 : if (type == TREE_TYPE (tmpl))
967 : : {
968 : 18 : tree main_constr = get_constraints (tmpl);
969 : 18 : if (equivalent_constraints (type_constr, main_constr))
970 : : return false;
971 : : }
972 : :
973 : : /* Also, if there's a pre-existing specialization with matching
974 : : constraints, then this also isn't new. */
975 : 3304996 : tree specs = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
976 : 3479838 : while (specs)
977 : : {
978 : 3433289 : tree spec_tmpl = TREE_VALUE (specs);
979 : 3433289 : tree spec_args = TREE_PURPOSE (specs);
980 : 3433289 : tree spec_constr = get_constraints (spec_tmpl);
981 : 3433289 : if (comp_template_args (args, spec_args)
982 : 3433289 : && equivalent_constraints (type_constr, spec_constr))
983 : : {
984 : 3258447 : type = TREE_TYPE (spec_tmpl);
985 : 3258447 : return false;
986 : : }
987 : 174842 : specs = TREE_CHAIN (specs);
988 : : }
989 : :
990 : : /* Create a new type node (and corresponding type decl)
991 : : for the newly declared specialization. */
992 : 46549 : tree t = make_class_type (TREE_CODE (type));
993 : 46549 : CLASSTYPE_DECLARED_CLASS (t) = CLASSTYPE_DECLARED_CLASS (type);
994 : 46549 : SET_TYPE_TEMPLATE_INFO (t, build_template_info (tmpl, args));
995 : 46549 : TYPE_CONTEXT (t) = TYPE_CONTEXT (type);
996 : :
997 : : /* We only need a separate type node for storing the definition of this
998 : : partial specialization; uses of S<T*> are unconstrained, so all are
999 : : equivalent. So keep TYPE_CANONICAL the same. */
1000 : 46549 : TYPE_CANONICAL (t) = TYPE_CANONICAL (type);
1001 : :
1002 : : /* Build the corresponding type decl. */
1003 : 46549 : tree d = create_implicit_typedef (DECL_NAME (tmpl), t);
1004 : 46549 : DECL_CONTEXT (d) = TYPE_CONTEXT (t);
1005 : 46549 : DECL_SOURCE_LOCATION (d) = input_location;
1006 : 46549 : TREE_PUBLIC (d) = TREE_PUBLIC (DECL_TEMPLATE_RESULT (tmpl));
1007 : :
1008 : 46549 : set_instantiating_module (d);
1009 : 46549 : DECL_MODULE_EXPORT_P (d) = DECL_MODULE_EXPORT_P (tmpl);
1010 : :
1011 : 46549 : type = t;
1012 : 46549 : return true;
1013 : : }
1014 : :
1015 : : return false;
1016 : : }
1017 : :
1018 : : /* The TYPE is being declared. If it is a template type, that means it
1019 : : is a partial specialization. Do appropriate error-checking. */
1020 : :
1021 : : tree
1022 : 62009858 : maybe_process_partial_specialization (tree type)
1023 : : {
1024 : 62009858 : tree context;
1025 : :
1026 : 62009858 : if (type == error_mark_node)
1027 : : return error_mark_node;
1028 : :
1029 : : /* A lambda that appears in specialization context is not itself a
1030 : : specialization. */
1031 : 62009805 : if (CLASS_TYPE_P (type) && CLASSTYPE_LAMBDA_EXPR (type))
1032 : : return type;
1033 : :
1034 : : /* An injected-class-name is not a specialization. */
1035 : 61270748 : if (DECL_SELF_REFERENCE_P (TYPE_NAME (type)))
1036 : : return type;
1037 : :
1038 : 61270742 : if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
1039 : : {
1040 : 3 : error ("name of class shadows template template parameter %qD",
1041 : 3 : TYPE_NAME (type));
1042 : 3 : return error_mark_node;
1043 : : }
1044 : :
1045 : 61270739 : context = TYPE_CONTEXT (type);
1046 : :
1047 : 61270739 : if (TYPE_ALIAS_P (type))
1048 : : {
1049 : 6 : tree tinfo = TYPE_ALIAS_TEMPLATE_INFO (type);
1050 : :
1051 : 12 : if (tinfo && DECL_ALIAS_TEMPLATE_P (TI_TEMPLATE (tinfo)))
1052 : 6 : error ("specialization of alias template %qD",
1053 : 6 : TI_TEMPLATE (tinfo));
1054 : : else
1055 : 0 : error ("explicit specialization of non-template %qT", type);
1056 : 6 : return error_mark_node;
1057 : : }
1058 : 61270733 : else if (CLASS_TYPE_P (type) && CLASSTYPE_USE_TEMPLATE (type))
1059 : : {
1060 : : /* This is for ordinary explicit specialization and partial
1061 : : specialization of a template class such as:
1062 : :
1063 : : template <> class C<int>;
1064 : :
1065 : : or:
1066 : :
1067 : : template <class T> class C<T*>;
1068 : :
1069 : : Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
1070 : :
1071 : 30627021 : if (maybe_new_partial_specialization (type))
1072 : : {
1073 : 10272452 : if (!check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (type))
1074 : 10272452 : && !at_namespace_scope_p ())
1075 : 12 : return error_mark_node;
1076 : 10272440 : SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
1077 : 10272440 : DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)) = input_location;
1078 : 10272440 : if (processing_template_decl)
1079 : : {
1080 : 6362789 : tree decl = push_template_decl (TYPE_MAIN_DECL (type));
1081 : 6362789 : if (decl == error_mark_node)
1082 : : return error_mark_node;
1083 : 6362706 : return TREE_TYPE (decl);
1084 : : }
1085 : : }
1086 : 20354569 : else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type))
1087 : 0 : error ("specialization of %qT after instantiation", type);
1088 : 5290 : else if (errorcount && !processing_specialization
1089 : 4073 : && CLASSTYPE_TEMPLATE_SPECIALIZATION (type)
1090 : 20358642 : && !uses_template_parms (CLASSTYPE_TI_ARGS (type)))
1091 : : /* Trying to define a specialization either without a template<> header
1092 : : or in an inappropriate place. We've already given an error, so just
1093 : : bail now so we don't actually define the specialization. */
1094 : 1202 : return error_mark_node;
1095 : : }
1096 : 29902743 : else if (CLASS_TYPE_P (type)
1097 : 29902743 : && !CLASSTYPE_USE_TEMPLATE (type)
1098 : 29902743 : && CLASSTYPE_TEMPLATE_INFO (type)
1099 : 21121336 : && context && CLASS_TYPE_P (context)
1100 : 32796150 : && CLASSTYPE_TEMPLATE_INFO (context))
1101 : : {
1102 : : /* This is for an explicit specialization of member class
1103 : : template according to [temp.expl.spec/18]:
1104 : :
1105 : : template <> template <class U> class C<int>::D;
1106 : :
1107 : : The context `C<int>' must be an implicit instantiation.
1108 : : Otherwise this is just a member class template declared
1109 : : earlier like:
1110 : :
1111 : : template <> class C<int> { template <class U> class D; };
1112 : : template <> template <class U> class C<int>::D;
1113 : :
1114 : : In the first case, `C<int>::D' is a specialization of `C<T>::D'
1115 : : while in the second case, `C<int>::D' is a primary template
1116 : : and `C<T>::D' may not exist. */
1117 : :
1118 : 1666680 : if (CLASSTYPE_IMPLICIT_INSTANTIATION (context)
1119 : 1666680 : && !COMPLETE_TYPE_P (type))
1120 : : {
1121 : 32 : tree t;
1122 : 32 : tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
1123 : :
1124 : 32 : if (current_namespace
1125 : 32 : != decl_namespace_context (tmpl))
1126 : : {
1127 : 0 : auto_diagnostic_group d;
1128 : 0 : if (permerror (input_location,
1129 : : "specialization of %qD in different namespace",
1130 : : type))
1131 : 0 : inform (DECL_SOURCE_LOCATION (tmpl),
1132 : : "from definition of %q#D", tmpl);
1133 : 0 : }
1134 : :
1135 : : /* Check for invalid specialization after instantiation:
1136 : :
1137 : : template <> template <> class C<int>::D<int>;
1138 : : template <> template <class U> class C<int>::D; */
1139 : :
1140 : 32 : for (t = DECL_TEMPLATE_INSTANTIATIONS (tmpl);
1141 : 43 : t; t = TREE_CHAIN (t))
1142 : : {
1143 : 11 : tree inst = TREE_VALUE (t);
1144 : 11 : if (CLASSTYPE_TEMPLATE_SPECIALIZATION (inst)
1145 : 11 : || !COMPLETE_OR_OPEN_TYPE_P (inst))
1146 : : {
1147 : : /* We already have a full specialization of this partial
1148 : : instantiation, or a full specialization has been
1149 : : looked up but not instantiated. Reassign it to the
1150 : : new member specialization template. */
1151 : 8 : spec_entry elt;
1152 : 8 : spec_entry *entry;
1153 : :
1154 : 8 : elt.tmpl = most_general_template (tmpl);
1155 : 8 : elt.args = CLASSTYPE_TI_ARGS (inst);
1156 : 8 : elt.spec = inst;
1157 : :
1158 : 8 : type_specializations->remove_elt (&elt);
1159 : :
1160 : 8 : elt.tmpl = tmpl;
1161 : 8 : CLASSTYPE_TI_ARGS (inst)
1162 : 8 : = elt.args = INNERMOST_TEMPLATE_ARGS (elt.args);
1163 : :
1164 : 8 : spec_entry **slot
1165 : 8 : = type_specializations->find_slot (&elt, INSERT);
1166 : 8 : entry = ggc_alloc<spec_entry> ();
1167 : 8 : *entry = elt;
1168 : 8 : *slot = entry;
1169 : : }
1170 : : else
1171 : : /* But if we've had an implicit instantiation, that's a
1172 : : problem ([temp.expl.spec]/6). */
1173 : 3 : error ("specialization %qT after instantiation %qT",
1174 : : type, inst);
1175 : : }
1176 : :
1177 : : /* Make sure that the specialization is valid. */
1178 : 32 : if (!redeclare_class_template (type, current_template_parms,
1179 : : current_template_constraints ()))
1180 : 6 : return error_mark_node;
1181 : :
1182 : : /* Mark TYPE as a specialization. And as a result, we only
1183 : : have one level of template argument for the innermost
1184 : : class template. */
1185 : 26 : SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
1186 : 26 : DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)) = input_location;
1187 : 26 : CLASSTYPE_TI_ARGS (type)
1188 : 52 : = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
1189 : : }
1190 : : }
1191 : 28977032 : else if (processing_specialization)
1192 : : {
1193 : : /* Someday C++0x may allow for enum template specialization. */
1194 : 18 : if (cxx_dialect > cxx98 && TREE_CODE (type) == ENUMERAL_TYPE
1195 : 37 : && CLASS_TYPE_P (context) && CLASSTYPE_USE_TEMPLATE (context))
1196 : 9 : pedwarn (input_location, OPT_Wpedantic, "template specialization "
1197 : : "of %qD not allowed by ISO C++", type);
1198 : : else
1199 : : {
1200 : 12 : error ("explicit specialization of non-template %qT", type);
1201 : 12 : return error_mark_node;
1202 : : }
1203 : : }
1204 : :
1205 : 54906712 : return type;
1206 : : }
1207 : :
1208 : : /* Make sure ARGS doesn't use any inappropriate typedefs; we should have
1209 : : gone through coerce_template_parms by now. */
1210 : :
1211 : : static void
1212 : 480274657 : verify_unstripped_args_1 (tree inner)
1213 : : {
1214 : 1562700162 : for (int i = 0; i < TREE_VEC_LENGTH (inner); ++i)
1215 : : {
1216 : 1082425505 : tree arg = TREE_VEC_ELT (inner, i);
1217 : 1082425505 : if (TREE_CODE (arg) == TEMPLATE_DECL)
1218 : : /* OK */;
1219 : 1081719655 : else if (TYPE_P (arg))
1220 : 1005108907 : gcc_assert (strip_typedefs (arg, NULL) == arg);
1221 : 76610748 : else if (ARGUMENT_PACK_P (arg))
1222 : 1717308 : verify_unstripped_args_1 (ARGUMENT_PACK_ARGS (arg));
1223 : 74893440 : else if (strip_typedefs (TREE_TYPE (arg), NULL) != TREE_TYPE (arg))
1224 : : /* Allow typedefs on the type of a non-type argument, since a
1225 : : parameter can have them. */;
1226 : : else
1227 : 74893280 : gcc_assert (strip_typedefs_expr (arg, NULL) == arg);
1228 : : }
1229 : 480274657 : }
1230 : :
1231 : : static void
1232 : 537174238 : verify_unstripped_args (tree args)
1233 : : {
1234 : 537174238 : ++processing_template_decl;
1235 : 537174238 : if (!any_dependent_template_arguments_p (args))
1236 : 478557349 : verify_unstripped_args_1 (INNERMOST_TEMPLATE_ARGS (args));
1237 : 537174238 : --processing_template_decl;
1238 : 537174238 : }
1239 : :
1240 : : /* Retrieve the specialization (in the sense of [temp.spec] - a
1241 : : specialization is either an instantiation or an explicit
1242 : : specialization) of TMPL for the given template ARGS. If there is
1243 : : no such specialization, return NULL_TREE. The ARGS are a vector of
1244 : : arguments, or a vector of vectors of arguments, in the case of
1245 : : templates with more than one level of parameters.
1246 : :
1247 : : If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
1248 : : then we search for a partial specialization matching ARGS. This
1249 : : parameter is ignored if TMPL is not a class template.
1250 : :
1251 : : We can also look up a FIELD_DECL, if it is a lambda capture pack; the
1252 : : result is a NONTYPE_ARGUMENT_PACK. */
1253 : :
1254 : : static tree
1255 : 537174238 : retrieve_specialization (tree tmpl, tree args, hashval_t hash)
1256 : : {
1257 : 537174238 : if (tmpl == NULL_TREE)
1258 : : return NULL_TREE;
1259 : :
1260 : 537174238 : if (args == error_mark_node)
1261 : : return NULL_TREE;
1262 : :
1263 : 537174238 : gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL
1264 : : || TREE_CODE (tmpl) == FIELD_DECL);
1265 : :
1266 : : /* There should be as many levels of arguments as there are
1267 : : levels of parameters. */
1268 : 1074348476 : gcc_assert (TMPL_ARGS_DEPTH (args)
1269 : : == (TREE_CODE (tmpl) == TEMPLATE_DECL
1270 : : ? TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl))
1271 : : : template_class_depth (DECL_CONTEXT (tmpl))));
1272 : :
1273 : 537174238 : if (flag_checking)
1274 : 537174238 : verify_unstripped_args (args);
1275 : :
1276 : : /* Lambda functions in templates aren't instantiated normally, but through
1277 : : tsubst_lambda_expr. */
1278 : 537174238 : if (lambda_fn_in_template_p (tmpl))
1279 : : return NULL_TREE;
1280 : :
1281 : 537174238 : spec_entry elt;
1282 : 537174238 : elt.tmpl = tmpl;
1283 : 537174238 : elt.args = args;
1284 : 537174238 : elt.spec = NULL_TREE;
1285 : :
1286 : 537174238 : spec_hash_table *specializations;
1287 : 537174238 : if (DECL_CLASS_TEMPLATE_P (tmpl))
1288 : 1521666 : specializations = type_specializations;
1289 : : else
1290 : 535652572 : specializations = decl_specializations;
1291 : :
1292 : 537174238 : if (hash == 0)
1293 : 190276459 : hash = spec_hasher::hash (&elt);
1294 : 537174238 : if (spec_entry *found = specializations->find_with_hash (&elt, hash))
1295 : 264979696 : return found->spec;
1296 : :
1297 : : return NULL_TREE;
1298 : : }
1299 : :
1300 : : /* Like retrieve_specialization, but for local declarations. */
1301 : :
1302 : : tree
1303 : 148958101 : retrieve_local_specialization (tree tmpl)
1304 : : {
1305 : 148958101 : if (local_specializations == NULL)
1306 : : return NULL_TREE;
1307 : :
1308 : 145493024 : tree *slot = local_specializations->get (tmpl);
1309 : 145493024 : return slot ? *slot : NULL_TREE;
1310 : : }
1311 : :
1312 : : /* Returns nonzero iff DECL is a specialization of TMPL. */
1313 : :
1314 : : int
1315 : 1155298 : is_specialization_of (tree decl, tree tmpl)
1316 : : {
1317 : 1155298 : tree t;
1318 : :
1319 : 1155298 : if (TREE_CODE (decl) == FUNCTION_DECL)
1320 : : {
1321 : 446601 : for (t = decl;
1322 : 876857 : t != NULL_TREE;
1323 : 446601 : t = DECL_TEMPLATE_INFO (t) ? DECL_TI_TEMPLATE (t) : NULL_TREE)
1324 : 601309 : if (t == tmpl)
1325 : : return 1;
1326 : : }
1327 : : else
1328 : : {
1329 : 725042 : gcc_assert (TREE_CODE (decl) == TYPE_DECL);
1330 : :
1331 : 725042 : for (t = TREE_TYPE (decl);
1332 : 1656430 : t != NULL_TREE;
1333 : 931388 : t = CLASSTYPE_USE_TEMPLATE (t)
1334 : 931388 : ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t)) : NULL_TREE)
1335 : 1395319 : if (same_type_ignoring_top_level_qualifiers_p (t, TREE_TYPE (tmpl)))
1336 : : return 1;
1337 : : }
1338 : :
1339 : : return 0;
1340 : : }
1341 : :
1342 : : /* Returns nonzero iff DECL is a specialization of friend declaration
1343 : : FRIEND_DECL according to [temp.friend]. */
1344 : :
1345 : : bool
1346 : 1276253 : is_specialization_of_friend (tree decl, tree friend_decl)
1347 : : {
1348 : 1276253 : bool need_template = true;
1349 : 1276253 : int template_depth;
1350 : :
1351 : 1276253 : gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
1352 : : || TREE_CODE (decl) == TYPE_DECL);
1353 : :
1354 : : /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
1355 : : of a template class, we want to check if DECL is a specialization
1356 : : if this. */
1357 : 1276253 : if (TREE_CODE (friend_decl) == FUNCTION_DECL
1358 : 121150 : && DECL_CLASS_SCOPE_P (friend_decl)
1359 : 56 : && DECL_TEMPLATE_INFO (friend_decl)
1360 : 1276307 : && !DECL_USE_TEMPLATE (friend_decl))
1361 : : {
1362 : : /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1363 : 54 : friend_decl = DECL_TI_TEMPLATE (friend_decl);
1364 : 54 : need_template = false;
1365 : : }
1366 : 1276199 : else if (TREE_CODE (friend_decl) == TEMPLATE_DECL
1367 : 1276199 : && !PRIMARY_TEMPLATE_P (friend_decl))
1368 : : need_template = false;
1369 : :
1370 : : /* There is nothing to do if this is not a template friend. */
1371 : 1276253 : if (TREE_CODE (friend_decl) != TEMPLATE_DECL)
1372 : : return false;
1373 : :
1374 : 1155157 : if (is_specialization_of (decl, friend_decl))
1375 : : return true;
1376 : :
1377 : : /* [temp.friend/6]
1378 : : A member of a class template may be declared to be a friend of a
1379 : : non-template class. In this case, the corresponding member of
1380 : : every specialization of the class template is a friend of the
1381 : : class granting friendship.
1382 : :
1383 : : For example, given a template friend declaration
1384 : :
1385 : : template <class T> friend void A<T>::f();
1386 : :
1387 : : the member function below is considered a friend
1388 : :
1389 : : template <> struct A<int> {
1390 : : void f();
1391 : : };
1392 : :
1393 : : For this type of template friend, TEMPLATE_DEPTH below will be
1394 : : nonzero. To determine if DECL is a friend of FRIEND, we first
1395 : : check if the enclosing class is a specialization of another. */
1396 : :
1397 : 536656 : template_depth = template_class_depth (CP_DECL_CONTEXT (friend_decl));
1398 : 536656 : if (template_depth
1399 : 147 : && DECL_CLASS_SCOPE_P (decl)
1400 : 536797 : && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl)),
1401 : 141 : CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend_decl))))
1402 : : {
1403 : : /* Next, we check the members themselves. In order to handle
1404 : : a few tricky cases, such as when FRIEND_DECL's are
1405 : :
1406 : : template <class T> friend void A<T>::g(T t);
1407 : : template <class T> template <T t> friend void A<T>::h();
1408 : :
1409 : : and DECL's are
1410 : :
1411 : : void A<int>::g(int);
1412 : : template <int> void A<int>::h();
1413 : :
1414 : : we need to figure out ARGS, the template arguments from
1415 : : the context of DECL. This is required for template substitution
1416 : : of `T' in the function parameter of `g' and template parameter
1417 : : of `h' in the above examples. Here ARGS corresponds to `int'. */
1418 : :
1419 : 138 : tree context = DECL_CONTEXT (decl);
1420 : 138 : tree args = NULL_TREE;
1421 : 138 : int current_depth = 0;
1422 : :
1423 : 276 : while (current_depth < template_depth)
1424 : : {
1425 : 138 : if (CLASSTYPE_TEMPLATE_INFO (context))
1426 : : {
1427 : 138 : if (current_depth == 0)
1428 : 276 : args = TYPE_TI_ARGS (context);
1429 : : else
1430 : 0 : args = add_to_template_args (TYPE_TI_ARGS (context), args);
1431 : 138 : current_depth++;
1432 : : }
1433 : 138 : context = TYPE_CONTEXT (context);
1434 : : }
1435 : :
1436 : 138 : if (TREE_CODE (decl) == FUNCTION_DECL)
1437 : : {
1438 : 72 : bool is_template;
1439 : 72 : tree friend_type;
1440 : 72 : tree decl_type;
1441 : 72 : tree friend_args_type;
1442 : 72 : tree decl_args_type;
1443 : :
1444 : : /* Make sure that both DECL and FRIEND_DECL are templates or
1445 : : non-templates. */
1446 : 72 : is_template = DECL_TEMPLATE_INFO (decl)
1447 : 72 : && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl));
1448 : 72 : if (need_template ^ is_template)
1449 : : return false;
1450 : 54 : else if (is_template)
1451 : : {
1452 : : /* If both are templates, check template parameter list. */
1453 : 27 : tree friend_parms
1454 : 27 : = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl),
1455 : : args, tf_none);
1456 : 27 : if (!comp_template_parms
1457 : 27 : (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl)),
1458 : : friend_parms))
1459 : : return false;
1460 : :
1461 : 18 : decl_type = TREE_TYPE (DECL_TI_TEMPLATE (decl));
1462 : : }
1463 : : else
1464 : 27 : decl_type = TREE_TYPE (decl);
1465 : :
1466 : 45 : friend_type = tsubst_function_type (TREE_TYPE (friend_decl), args,
1467 : : tf_none, NULL_TREE);
1468 : 45 : if (friend_type == error_mark_node)
1469 : : return false;
1470 : :
1471 : : /* Check if return types match. */
1472 : 45 : if (!same_type_p (TREE_TYPE (decl_type), TREE_TYPE (friend_type)))
1473 : : return false;
1474 : :
1475 : : /* Check if function parameter types match, ignoring the
1476 : : `this' parameter. */
1477 : 39 : friend_args_type = TYPE_ARG_TYPES (friend_type);
1478 : 39 : decl_args_type = TYPE_ARG_TYPES (decl_type);
1479 : 39 : if (DECL_IOBJ_MEMBER_FUNCTION_P (friend_decl))
1480 : 39 : friend_args_type = TREE_CHAIN (friend_args_type);
1481 : 39 : if (DECL_IOBJ_MEMBER_FUNCTION_P (decl))
1482 : 39 : decl_args_type = TREE_CHAIN (decl_args_type);
1483 : :
1484 : 39 : return compparms (decl_args_type, friend_args_type);
1485 : : }
1486 : : else
1487 : : {
1488 : : /* DECL is a TYPE_DECL */
1489 : 66 : bool is_template;
1490 : 66 : tree decl_type = TREE_TYPE (decl);
1491 : :
1492 : : /* Make sure that both DECL and FRIEND_DECL are templates or
1493 : : non-templates. */
1494 : 66 : is_template
1495 : 66 : = CLASSTYPE_TEMPLATE_INFO (decl_type)
1496 : 66 : && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type));
1497 : :
1498 : 66 : if (need_template ^ is_template)
1499 : : return false;
1500 : 66 : else if (is_template)
1501 : : {
1502 : 51 : tree friend_parms;
1503 : : /* If both are templates, check the name of the two
1504 : : TEMPLATE_DECL's first because is_friend didn't. */
1505 : 51 : if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type))
1506 : 51 : != DECL_NAME (friend_decl))
1507 : : return false;
1508 : :
1509 : : /* Now check template parameter list. */
1510 : 48 : friend_parms
1511 : 48 : = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl),
1512 : : args, tf_none);
1513 : 48 : return comp_template_parms
1514 : 48 : (DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type)),
1515 : 48 : friend_parms);
1516 : : }
1517 : : else
1518 : 15 : return (DECL_NAME (decl)
1519 : 15 : == DECL_NAME (friend_decl));
1520 : : }
1521 : : }
1522 : : return false;
1523 : : }
1524 : :
1525 : : /* Register the specialization SPEC as a specialization of TMPL with
1526 : : the indicated ARGS. IS_FRIEND indicates whether the specialization
1527 : : is actually just a friend declaration. ATTRLIST is the list of
1528 : : attributes that the specialization is declared with or NULL when
1529 : : it isn't. Returns SPEC, or an equivalent prior declaration, if
1530 : : available.
1531 : :
1532 : : We also store instantiations of field packs in the hash table, even
1533 : : though they are not themselves templates, to make lookup easier. */
1534 : :
1535 : : static tree
1536 : 201724042 : register_specialization (tree spec, tree tmpl, tree args, bool is_friend,
1537 : : hashval_t hash)
1538 : : {
1539 : 201724042 : tree fn;
1540 : :
1541 : 201724042 : gcc_assert ((TREE_CODE (tmpl) == TEMPLATE_DECL && DECL_P (spec))
1542 : : || (TREE_CODE (tmpl) == FIELD_DECL
1543 : : && TREE_CODE (spec) == NONTYPE_ARGUMENT_PACK));
1544 : :
1545 : 201724042 : spec_entry elt;
1546 : 201724042 : elt.tmpl = tmpl;
1547 : 201724042 : elt.args = args;
1548 : 201724042 : elt.spec = spec;
1549 : :
1550 : 201724042 : if (hash == 0)
1551 : 1428846 : hash = spec_hasher::hash (&elt);
1552 : :
1553 : 201724042 : spec_entry **slot = decl_specializations->find_slot_with_hash (&elt, hash, INSERT);
1554 : 201724042 : if (*slot)
1555 : 565317 : fn = (*slot)->spec;
1556 : : else
1557 : : fn = NULL_TREE;
1558 : :
1559 : : /* We can sometimes try to re-register a specialization that we've
1560 : : already got. In particular, regenerate_decl_from_template calls
1561 : : duplicate_decls which will update the specialization list. But,
1562 : : we'll still get called again here anyhow. It's more convenient
1563 : : to simply allow this than to try to prevent it. */
1564 : 201724042 : if (fn == spec)
1565 : : return spec;
1566 : 201722845 : else if (fn && DECL_TEMPLATE_SPECIALIZATION (spec))
1567 : : {
1568 : 564054 : if (DECL_TEMPLATE_INSTANTIATION (fn))
1569 : : {
1570 : 563810 : if (DECL_ODR_USED (fn)
1571 : 563810 : || DECL_EXPLICIT_INSTANTIATION (fn))
1572 : : {
1573 : 8 : error ("specialization of %qD after instantiation",
1574 : : fn);
1575 : 8 : return error_mark_node;
1576 : : }
1577 : : else
1578 : : {
1579 : 563802 : tree clone;
1580 : : /* This situation should occur only if the first
1581 : : specialization is an implicit instantiation, the
1582 : : second is an explicit specialization, and the
1583 : : implicit instantiation has not yet been used. That
1584 : : situation can occur if we have implicitly
1585 : : instantiated a member function and then specialized
1586 : : it later.
1587 : :
1588 : : We can also wind up here if a friend declaration that
1589 : : looked like an instantiation turns out to be a
1590 : : specialization:
1591 : :
1592 : : template <class T> void foo(T);
1593 : : class S { friend void foo<>(int) };
1594 : : template <> void foo(int);
1595 : :
1596 : : We transform the existing DECL in place so that any
1597 : : pointers to it become pointers to the updated
1598 : : declaration.
1599 : :
1600 : : If there was a definition for the template, but not
1601 : : for the specialization, we want this to look as if
1602 : : there were no definition, and vice versa. */
1603 : 563802 : DECL_INITIAL (fn) = NULL_TREE;
1604 : 563802 : duplicate_decls (spec, fn, /*hiding=*/is_friend);
1605 : :
1606 : : /* The call to duplicate_decls will have applied
1607 : : [temp.expl.spec]:
1608 : :
1609 : : An explicit specialization of a function template
1610 : : is inline only if it is explicitly declared to be,
1611 : : and independently of whether its function template
1612 : : is.
1613 : :
1614 : : to the primary function; now copy the inline bits to
1615 : : the various clones. */
1616 : 755311 : FOR_EACH_CLONE (clone, fn)
1617 : : {
1618 : 191509 : DECL_DECLARED_INLINE_P (clone)
1619 : 191509 : = DECL_DECLARED_INLINE_P (fn);
1620 : 383018 : DECL_SOURCE_LOCATION (clone)
1621 : 191509 : = DECL_SOURCE_LOCATION (fn);
1622 : 191509 : DECL_DELETED_FN (clone)
1623 : 383018 : = DECL_DELETED_FN (fn);
1624 : : }
1625 : 563802 : check_specialization_namespace (tmpl);
1626 : :
1627 : 563802 : return fn;
1628 : : }
1629 : : }
1630 : 244 : else if (DECL_TEMPLATE_SPECIALIZATION (fn))
1631 : : {
1632 : 244 : tree dd = duplicate_decls (spec, fn, /*hiding=*/is_friend);
1633 : 244 : if (dd == error_mark_node)
1634 : : /* We've already complained in duplicate_decls. */
1635 : : return error_mark_node;
1636 : :
1637 : 223 : if (dd == NULL_TREE && DECL_INITIAL (spec))
1638 : : /* Dup decl failed, but this is a new definition. Set the
1639 : : line number so any errors match this new
1640 : : definition. */
1641 : 0 : DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (spec);
1642 : :
1643 : 223 : return fn;
1644 : : }
1645 : : }
1646 : 201158791 : else if (fn)
1647 : 66 : return duplicate_decls (spec, fn, /*hiding=*/is_friend);
1648 : :
1649 : : /* A specialization must be declared in the same namespace as the
1650 : : template it is specializing. */
1651 : 201158725 : if (DECL_P (spec) && DECL_TEMPLATE_SPECIALIZATION (spec)
1652 : 202022242 : && !check_specialization_namespace (tmpl))
1653 : 0 : DECL_CONTEXT (spec) = DECL_CONTEXT (tmpl);
1654 : :
1655 : 201158725 : spec_entry *entry = ggc_alloc<spec_entry> ();
1656 : 201158725 : gcc_assert (tmpl && args && spec);
1657 : 201158725 : *entry = elt;
1658 : 201158725 : *slot = entry;
1659 : 92887470 : if ((TREE_CODE (spec) == FUNCTION_DECL && DECL_NAMESPACE_SCOPE_P (spec)
1660 : 17042815 : && PRIMARY_TEMPLATE_P (tmpl)
1661 : 16383089 : && DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (tmpl)) == NULL_TREE)
1662 : 287454234 : || variable_template_p (tmpl))
1663 : : /* If TMPL is a forward declaration of a template function, keep a list
1664 : : of all specializations in case we need to reassign them to a friend
1665 : : template later in tsubst_friend_function.
1666 : :
1667 : : Also keep a list of all variable template instantiations so that
1668 : : process_partial_specialization can check whether a later partial
1669 : : specialization would have used it. */
1670 : 21496094 : DECL_TEMPLATE_INSTANTIATIONS (tmpl)
1671 : 21496094 : = tree_cons (args, spec, DECL_TEMPLATE_INSTANTIATIONS (tmpl));
1672 : :
1673 : : return spec;
1674 : : }
1675 : :
1676 : : /* Restricts tree and type comparisons. */
1677 : : int comparing_specializations;
1678 : : int comparing_dependent_aliases;
1679 : :
1680 : : /* Whether we are comparing template arguments during partial ordering
1681 : : (and therefore want the comparison to look through dependent alias
1682 : : template specializations). */
1683 : :
1684 : : static int comparing_for_partial_ordering;
1685 : :
1686 : : /* Returns true iff two spec_entry nodes are equivalent. */
1687 : :
1688 : : bool
1689 : 8849628441 : spec_hasher::equal (spec_entry *e1, spec_entry *e2)
1690 : : {
1691 : 8849628441 : int equal;
1692 : :
1693 : 8849628441 : ++comparing_specializations;
1694 : 8849628441 : ++comparing_dependent_aliases;
1695 : 8849628441 : ++processing_template_decl;
1696 : 9438544423 : equal = (e1->tmpl == e2->tmpl
1697 : 8849628441 : && comp_template_args (e1->args, e2->args));
1698 : 588915982 : if (equal && flag_concepts
1699 : : /* tmpl could be a FIELD_DECL for a capture pack. */
1700 : 222323589 : && TREE_CODE (e1->tmpl) == TEMPLATE_DECL
1701 : 222323589 : && VAR_P (DECL_TEMPLATE_RESULT (e1->tmpl))
1702 : 7248411 : && uses_template_parms (e1->args))
1703 : : {
1704 : : /* Partial specializations of a variable template can be distinguished by
1705 : : constraints. */
1706 : 321 : tree c1 = e1->spec ? get_constraints (e1->spec) : NULL_TREE;
1707 : 321 : tree c2 = e2->spec ? get_constraints (e2->spec) : NULL_TREE;
1708 : 321 : equal = equivalent_constraints (c1, c2);
1709 : : }
1710 : 8849628441 : --processing_template_decl;
1711 : 8849628441 : --comparing_dependent_aliases;
1712 : 8849628441 : --comparing_specializations;
1713 : :
1714 : 8849628441 : return equal;
1715 : : }
1716 : :
1717 : : /* Returns a hash for a template TMPL and template arguments ARGS. */
1718 : :
1719 : : static hashval_t
1720 : 8016041029 : hash_tmpl_and_args (tree tmpl, tree args)
1721 : : {
1722 : 8016041029 : hashval_t val = iterative_hash_object (DECL_UID (tmpl), 0);
1723 : 8016041029 : return iterative_hash_template_arg (args, val);
1724 : : }
1725 : :
1726 : : hashval_t
1727 : 7939126695 : spec_hasher::hash (tree tmpl, tree args)
1728 : : {
1729 : 7939126695 : ++comparing_specializations;
1730 : 7939126695 : hashval_t val = hash_tmpl_and_args (tmpl, args);
1731 : 7939126695 : --comparing_specializations;
1732 : 7939126695 : return val;
1733 : : }
1734 : :
1735 : : /* Returns a hash for a spec_entry node based on the TMPL and ARGS members,
1736 : : ignoring SPEC. */
1737 : :
1738 : : hashval_t
1739 : 7624934663 : spec_hasher::hash (spec_entry *e)
1740 : : {
1741 : 7624934663 : return spec_hasher::hash (e->tmpl, e->args);
1742 : : }
1743 : :
1744 : : /* Recursively calculate a hash value for a template argument ARG, for use
1745 : : in the hash tables of template specializations. We must be
1746 : : careful to (at least) skip the same entities template_args_equal
1747 : : does. */
1748 : :
1749 : : hashval_t
1750 : 39227179908 : iterative_hash_template_arg (tree arg, hashval_t val)
1751 : : {
1752 : 39227179908 : if (arg == NULL_TREE)
1753 : 1163995375 : return iterative_hash_object (arg, val);
1754 : :
1755 : 38063184533 : if (!TYPE_P (arg))
1756 : : /* Strip nop-like things, but not the same as STRIP_NOPS. */
1757 : 16718329441 : while (CONVERT_EXPR_P (arg)
1758 : : || TREE_CODE (arg) == NON_LVALUE_EXPR
1759 : 16718329441 : || class_nttp_const_wrapper_p (arg))
1760 : 9115443 : arg = TREE_OPERAND (arg, 0);
1761 : :
1762 : 38063184533 : enum tree_code code = TREE_CODE (arg);
1763 : :
1764 : 38063184533 : val = iterative_hash_object (code, val);
1765 : :
1766 : 38063184533 : switch (code)
1767 : : {
1768 : 0 : case ARGUMENT_PACK_SELECT:
1769 : : /* Getting here with an ARGUMENT_PACK_SELECT means we're probably
1770 : : preserving it in a hash table, which is bad because it will change
1771 : : meaning when gen_elem_of_pack_expansion_instantiation changes the
1772 : : ARGUMENT_PACK_SELECT_INDEX. */
1773 : 0 : gcc_unreachable ();
1774 : :
1775 : : case ERROR_MARK:
1776 : : return val;
1777 : :
1778 : 1515650490 : case IDENTIFIER_NODE:
1779 : 1515650490 : return iterative_hash_object (IDENTIFIER_HASH_VALUE (arg), val);
1780 : :
1781 : 10918174298 : case TREE_VEC:
1782 : 31123279341 : for (tree elt : tree_vec_range (arg))
1783 : 20205105043 : val = iterative_hash_template_arg (elt, val);
1784 : 10918174298 : return val;
1785 : :
1786 : 490214507 : case TYPE_PACK_EXPANSION:
1787 : 490214507 : case EXPR_PACK_EXPANSION:
1788 : 490214507 : val = iterative_hash_template_arg (PACK_EXPANSION_PATTERN (arg), val);
1789 : 490214507 : return iterative_hash_template_arg (PACK_EXPANSION_EXTRA_ARGS (arg), val);
1790 : :
1791 : 1181334205 : case TYPE_ARGUMENT_PACK:
1792 : 1181334205 : case NONTYPE_ARGUMENT_PACK:
1793 : 1181334205 : return iterative_hash_template_arg (ARGUMENT_PACK_ARGS (arg), val);
1794 : :
1795 : : case TREE_LIST:
1796 : 77571750 : for (; arg; arg = TREE_CHAIN (arg))
1797 : 38785878 : val = iterative_hash_template_arg (TREE_VALUE (arg), val);
1798 : : return val;
1799 : :
1800 : 352 : case OVERLOAD:
1801 : 716 : for (lkp_iterator iter (arg); iter; ++iter)
1802 : 364 : val = iterative_hash_template_arg (*iter, val);
1803 : 352 : return val;
1804 : :
1805 : 9804109 : case CONSTRUCTOR:
1806 : 9804109 : {
1807 : 9804109 : iterative_hash_template_arg (TREE_TYPE (arg), val);
1808 : 10501074 : for (auto &e: CONSTRUCTOR_ELTS (arg))
1809 : : {
1810 : 266841 : val = iterative_hash_template_arg (e.index, val);
1811 : 266841 : val = iterative_hash_template_arg (e.value, val);
1812 : : }
1813 : : return val;
1814 : : }
1815 : :
1816 : 18697709 : case PARM_DECL:
1817 : 18697709 : if (!DECL_ARTIFICIAL (arg))
1818 : : {
1819 : 18663847 : val = iterative_hash_object (DECL_PARM_INDEX (arg), val);
1820 : 18663847 : val = iterative_hash_object (DECL_PARM_LEVEL (arg), val);
1821 : : }
1822 : 18697709 : return iterative_hash_template_arg (TREE_TYPE (arg), val);
1823 : :
1824 : 375796581 : case TEMPLATE_DECL:
1825 : 375796581 : if (DECL_TEMPLATE_TEMPLATE_PARM_P (arg))
1826 : 15333215 : return iterative_hash_template_arg (TREE_TYPE (arg), val);
1827 : : break;
1828 : :
1829 : 0 : case TARGET_EXPR:
1830 : 0 : return iterative_hash_template_arg (TARGET_EXPR_INITIAL (arg), val);
1831 : :
1832 : 20689 : case PTRMEM_CST:
1833 : 20689 : val = iterative_hash_template_arg (PTRMEM_CST_CLASS (arg), val);
1834 : 20689 : return iterative_hash_template_arg (PTRMEM_CST_MEMBER (arg), val);
1835 : :
1836 : 161722887 : case TEMPLATE_PARM_INDEX:
1837 : 161722887 : val = iterative_hash_template_arg
1838 : 161722887 : (TREE_TYPE (TEMPLATE_PARM_DECL (arg)), val);
1839 : 161722887 : val = iterative_hash_object (TEMPLATE_PARM_LEVEL (arg), val);
1840 : 161722887 : return iterative_hash_object (TEMPLATE_PARM_IDX (arg), val);
1841 : :
1842 : 137620480 : case TRAIT_EXPR:
1843 : 137620480 : val = iterative_hash_object (TRAIT_EXPR_KIND (arg), val);
1844 : 137620480 : val = iterative_hash_template_arg (TRAIT_EXPR_TYPE1 (arg), val);
1845 : 137620480 : return iterative_hash_template_arg (TRAIT_EXPR_TYPE2 (arg), val);
1846 : :
1847 : 87103959 : case BASELINK:
1848 : 87103959 : val = iterative_hash_template_arg (BINFO_TYPE (BASELINK_BINFO (arg)),
1849 : : val);
1850 : 87103959 : return iterative_hash_template_arg (DECL_NAME (get_first_fn (arg)),
1851 : 87103959 : val);
1852 : :
1853 : 631 : case MODOP_EXPR:
1854 : 631 : val = iterative_hash_template_arg (TREE_OPERAND (arg, 0), val);
1855 : 631 : code = TREE_CODE (TREE_OPERAND (arg, 1));
1856 : 631 : val = iterative_hash_object (code, val);
1857 : 631 : return iterative_hash_template_arg (TREE_OPERAND (arg, 2), val);
1858 : :
1859 : 174 : case LAMBDA_EXPR:
1860 : : /* [temp.over.link] Two lambda-expressions are never considered
1861 : : equivalent.
1862 : :
1863 : : So just hash the closure type. */
1864 : 174 : return iterative_hash_template_arg (TREE_TYPE (arg), val);
1865 : :
1866 : 385169918 : case CAST_EXPR:
1867 : 385169918 : case IMPLICIT_CONV_EXPR:
1868 : 385169918 : case STATIC_CAST_EXPR:
1869 : 385169918 : case REINTERPRET_CAST_EXPR:
1870 : 385169918 : case CONST_CAST_EXPR:
1871 : 385169918 : case DYNAMIC_CAST_EXPR:
1872 : 385169918 : case NEW_EXPR:
1873 : 385169918 : val = iterative_hash_template_arg (TREE_TYPE (arg), val);
1874 : : /* Now hash operands as usual. */
1875 : 385169918 : break;
1876 : :
1877 : 432400845 : case CALL_EXPR:
1878 : 432400845 : {
1879 : 432400845 : tree fn = CALL_EXPR_FN (arg);
1880 : 432400845 : if (tree name = call_expr_dependent_name (arg))
1881 : : {
1882 : 231071893 : if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
1883 : 164111876 : val = iterative_hash_template_arg (TREE_OPERAND (fn, 1), val);
1884 : : fn = name;
1885 : : }
1886 : 432400845 : val = iterative_hash_template_arg (fn, val);
1887 : 432400845 : call_expr_arg_iterator ai;
1888 : 774218200 : for (tree x = first_call_expr_arg (arg, &ai); x;
1889 : 341817355 : x = next_call_expr_arg (&ai))
1890 : 341817355 : val = iterative_hash_template_arg (x, val);
1891 : 432400845 : return val;
1892 : : }
1893 : :
1894 : : default:
1895 : : break;
1896 : : }
1897 : :
1898 : 23056320091 : char tclass = TREE_CODE_CLASS (code);
1899 : 23056320091 : switch (tclass)
1900 : : {
1901 : 19797003494 : case tcc_type:
1902 : 19797003494 : if (tree ats = alias_template_specialization_p (arg, nt_transparent))
1903 : : {
1904 : : // We want an alias specialization that survived strip_typedefs
1905 : : // to hash differently from its TYPE_CANONICAL, to avoid hash
1906 : : // collisions that compare as different in template_args_equal.
1907 : : // These could be dependent specializations that strip_typedefs
1908 : : // left alone, or untouched specializations because
1909 : : // coerce_template_parms returns the unconverted template
1910 : : // arguments if it sees incomplete argument packs.
1911 : 76914334 : tree ti = TYPE_ALIAS_TEMPLATE_INFO (ats);
1912 : 76914334 : return hash_tmpl_and_args (TI_TEMPLATE (ti), TI_ARGS (ti));
1913 : : }
1914 : :
1915 : 19720089160 : switch (code)
1916 : : {
1917 : 147405466 : case DECLTYPE_TYPE:
1918 : 147405466 : val = iterative_hash_template_arg (DECLTYPE_TYPE_EXPR (arg), val);
1919 : 147405466 : break;
1920 : :
1921 : 482535914 : case TYPENAME_TYPE:
1922 : 482535914 : if (comparing_specializations)
1923 : : {
1924 : : /* Hash the components that are relevant to TYPENAME_TYPE
1925 : : equivalence as determined by structural_comptypes. We
1926 : : can only coherently do this when comparing_specializations
1927 : : is set, because otherwise structural_comptypes tries
1928 : : resolving TYPENAME_TYPE via the current instantiation. */
1929 : 469499129 : tree context = TYPE_MAIN_VARIANT (TYPE_CONTEXT (arg));
1930 : 469499129 : tree fullname = TYPENAME_TYPE_FULLNAME (arg);
1931 : 469499129 : val = iterative_hash_template_arg (context, val);
1932 : 469499129 : val = iterative_hash_template_arg (fullname, val);
1933 : : }
1934 : : break;
1935 : :
1936 : 19090147780 : default:
1937 : 19090147780 : if (tree canonical = TYPE_CANONICAL (arg))
1938 : 18817114363 : val = iterative_hash_object (TYPE_HASH (canonical), val);
1939 : 273033417 : else if (tree ti = TYPE_TEMPLATE_INFO (arg))
1940 : : {
1941 : 15604867 : val = iterative_hash_template_arg (TI_TEMPLATE (ti), val);
1942 : 15604867 : val = iterative_hash_template_arg (TI_ARGS (ti), val);
1943 : : }
1944 : : break;
1945 : : }
1946 : :
1947 : : return val;
1948 : :
1949 : 1615780478 : case tcc_declaration:
1950 : 1615780478 : case tcc_constant:
1951 : 1615780478 : return iterative_hash_expr (arg, val);
1952 : :
1953 : 1643536119 : default:
1954 : 1643536119 : gcc_assert (IS_EXPR_CODE_CLASS (tclass));
1955 : 4413601225 : for (int i = 0, n = cp_tree_operand_length (arg); i < n; ++i)
1956 : 2770065106 : val = iterative_hash_template_arg (TREE_OPERAND (arg, i), val);
1957 : : return val;
1958 : : }
1959 : : }
1960 : :
1961 : : /* Unregister the specialization SPEC as a specialization of TMPL.
1962 : : Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1963 : : if the SPEC was listed as a specialization of TMPL.
1964 : :
1965 : : Note that SPEC has been ggc_freed, so we can't look inside it. */
1966 : :
1967 : : bool
1968 : 575437 : reregister_specialization (tree spec, tree tinfo, tree new_spec)
1969 : : {
1970 : 575437 : spec_entry *entry;
1971 : 575437 : spec_entry elt;
1972 : :
1973 : 575437 : elt.tmpl = most_general_template (TI_TEMPLATE (tinfo));
1974 : 575437 : elt.args = TI_ARGS (tinfo);
1975 : 575437 : elt.spec = NULL_TREE;
1976 : :
1977 : 575437 : entry = decl_specializations->find (&elt);
1978 : 575437 : if (entry != NULL)
1979 : : {
1980 : 575437 : gcc_assert (entry->spec == spec || entry->spec == new_spec);
1981 : 575437 : gcc_assert (new_spec != NULL_TREE);
1982 : 575437 : entry->spec = new_spec;
1983 : 575437 : return 1;
1984 : : }
1985 : :
1986 : : return 0;
1987 : : }
1988 : :
1989 : : /* Like register_specialization, but for local declarations. We are
1990 : : registering SPEC, an instantiation of TMPL. */
1991 : :
1992 : : void
1993 : 54637887 : register_local_specialization (tree spec, tree tmpl)
1994 : : {
1995 : 54637887 : gcc_assert (tmpl != spec);
1996 : 54637887 : local_specializations->put (tmpl, spec);
1997 : 54637887 : }
1998 : :
1999 : : /* Registers T as a specialization of itself. This is used to preserve
2000 : : the references to already-parsed parameters when instantiating
2001 : : postconditions. */
2002 : :
2003 : : void
2004 : 54 : register_local_identity (tree t)
2005 : : {
2006 : 54 : local_specializations->put (t, t);
2007 : 54 : }
2008 : :
2009 : : /* TYPE is a class type. Returns true if TYPE is an explicitly
2010 : : specialized class. */
2011 : :
2012 : : bool
2013 : 17886167 : explicit_class_specialization_p (tree type)
2014 : : {
2015 : 17886167 : if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
2016 : : return false;
2017 : 484913 : return !uses_template_parms (CLASSTYPE_TI_ARGS (type));
2018 : : }
2019 : :
2020 : : /* Print the list of functions at FNS, going through all the overloads
2021 : : for each element of the list. Alternatively, FNS cannot be a
2022 : : TREE_LIST, in which case it will be printed together with all the
2023 : : overloads.
2024 : :
2025 : : MORE and *STR should respectively be FALSE and NULL when the function
2026 : : is called from the outside. They are used internally on recursive
2027 : : calls. print_candidates manages the two parameters and leaves NULL
2028 : : in *STR when it ends. */
2029 : :
2030 : : static void
2031 : 1248 : print_candidates_1 (tree fns, char **str, bool more = false)
2032 : : {
2033 : 1248 : if (TREE_CODE (fns) == TREE_LIST)
2034 : 876 : for (; fns; fns = TREE_CHAIN (fns))
2035 : 900 : print_candidates_1 (TREE_VALUE (fns), str, more || TREE_CHAIN (fns));
2036 : : else
2037 : 2297 : for (lkp_iterator iter (fns); iter;)
2038 : : {
2039 : 1333 : tree cand = *iter;
2040 : 1333 : ++iter;
2041 : :
2042 : 1333 : const char *pfx = *str;
2043 : 1333 : if (!pfx)
2044 : : {
2045 : 656 : if (more || iter)
2046 : 422 : pfx = _("candidates are:");
2047 : : else
2048 : 234 : pfx = _("candidate is:");
2049 : 656 : *str = get_spaces (pfx);
2050 : : }
2051 : 1333 : inform (DECL_SOURCE_LOCATION (cand), "%s %#qD", pfx, cand);
2052 : : }
2053 : 1248 : }
2054 : :
2055 : : /* Print the list of candidate FNS in an error message. FNS can also
2056 : : be a TREE_LIST of non-functions in the case of an ambiguous lookup. */
2057 : :
2058 : : void
2059 : 656 : print_candidates (tree fns)
2060 : : {
2061 : 656 : char *str = NULL;
2062 : 656 : print_candidates_1 (fns, &str);
2063 : 656 : free (str);
2064 : 656 : }
2065 : :
2066 : : /* Get a (possibly) constrained template declaration for the
2067 : : purpose of ordering candidates. */
2068 : : static tree
2069 : 48 : get_template_for_ordering (tree list)
2070 : : {
2071 : 48 : gcc_assert (TREE_CODE (list) == TREE_LIST);
2072 : 48 : tree f = TREE_VALUE (list);
2073 : 48 : if (tree ti = DECL_TEMPLATE_INFO (f))
2074 : 48 : return TI_TEMPLATE (ti);
2075 : : return f;
2076 : : }
2077 : :
2078 : : /* Among candidates having the same signature, return the
2079 : : most constrained or NULL_TREE if there is no best candidate.
2080 : : If the signatures of candidates vary (e.g., template
2081 : : specialization vs. member function), then there can be no
2082 : : most constrained.
2083 : :
2084 : : Note that we don't compare constraints on the functions
2085 : : themselves, but rather those of their templates. */
2086 : : static tree
2087 : 12 : most_constrained_function (tree candidates)
2088 : : {
2089 : : // Try to find the best candidate in a first pass.
2090 : 12 : tree champ = candidates;
2091 : 24 : for (tree c = TREE_CHAIN (champ); c; c = TREE_CHAIN (c))
2092 : : {
2093 : 12 : int winner = more_constrained (get_template_for_ordering (champ),
2094 : : get_template_for_ordering (c));
2095 : 12 : if (winner == -1)
2096 : : champ = c; // The candidate is more constrained
2097 : 0 : else if (winner == 0)
2098 : : return NULL_TREE; // Neither is more constrained
2099 : : }
2100 : :
2101 : : // Verify that the champ is better than previous candidates.
2102 : 24 : for (tree c = candidates; c != champ; c = TREE_CHAIN (c)) {
2103 : 12 : if (!more_constrained (get_template_for_ordering (champ),
2104 : : get_template_for_ordering (c)))
2105 : : return NULL_TREE;
2106 : : }
2107 : :
2108 : : return champ;
2109 : : }
2110 : :
2111 : :
2112 : : /* Returns the template (one of the functions given by TEMPLATE_ID)
2113 : : which can be specialized to match the indicated DECL with the
2114 : : explicit template args given in TEMPLATE_ID. The DECL may be
2115 : : NULL_TREE if none is available. In that case, the functions in
2116 : : TEMPLATE_ID are non-members.
2117 : :
2118 : : If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
2119 : : specialization of a member template.
2120 : :
2121 : : The TEMPLATE_COUNT is the number of references to qualifying
2122 : : template classes that appeared in the name of the function. See
2123 : : check_explicit_specialization for a more accurate description.
2124 : :
2125 : : TSK indicates what kind of template declaration (if any) is being
2126 : : declared. TSK_TEMPLATE indicates that the declaration given by
2127 : : DECL, though a FUNCTION_DECL, has template parameters, and is
2128 : : therefore a template function.
2129 : :
2130 : : The template args (those explicitly specified and those deduced)
2131 : : are output in a newly created vector *TARGS_OUT.
2132 : :
2133 : : If it is impossible to determine the result, an error message is
2134 : : issued. The error_mark_node is returned to indicate failure. */
2135 : :
2136 : : static tree
2137 : 3436883 : determine_specialization (tree template_id,
2138 : : tree decl,
2139 : : tree* targs_out,
2140 : : int need_member_template,
2141 : : int template_count,
2142 : : tmpl_spec_kind tsk)
2143 : : {
2144 : 3436883 : tree fns;
2145 : 3436883 : tree targs;
2146 : 3436883 : tree explicit_targs;
2147 : 3436883 : tree candidates = NULL_TREE;
2148 : :
2149 : : /* A TREE_LIST of templates of which DECL may be a specialization.
2150 : : The TREE_VALUE of each node is a TEMPLATE_DECL. The
2151 : : corresponding TREE_PURPOSE is the set of template arguments that,
2152 : : when used to instantiate the template, would produce a function
2153 : : with the signature of DECL. */
2154 : 3436883 : tree templates = NULL_TREE;
2155 : 3436883 : int header_count;
2156 : 3436883 : cp_binding_level *b;
2157 : :
2158 : 3436883 : *targs_out = NULL_TREE;
2159 : :
2160 : 3436883 : if (template_id == error_mark_node || decl == error_mark_node)
2161 : : return error_mark_node;
2162 : :
2163 : : /* We shouldn't be specializing a member template of an
2164 : : unspecialized class template; we already gave an error in
2165 : : check_specialization_scope, now avoid crashing. */
2166 : 3436880 : if (!VAR_P (decl)
2167 : 2573296 : && template_count && DECL_CLASS_SCOPE_P (decl)
2168 : 4318079 : && template_class_depth (DECL_CONTEXT (decl)) > 0)
2169 : : {
2170 : 3 : gcc_assert (errorcount);
2171 : 3 : return error_mark_node;
2172 : : }
2173 : :
2174 : 3436877 : fns = TREE_OPERAND (template_id, 0);
2175 : 3436877 : explicit_targs = TREE_OPERAND (template_id, 1);
2176 : :
2177 : 3436877 : if (fns == error_mark_node)
2178 : : return error_mark_node;
2179 : :
2180 : : /* Check for baselinks. */
2181 : 3436877 : if (BASELINK_P (fns))
2182 : 0 : fns = BASELINK_FUNCTIONS (fns);
2183 : :
2184 : 3436877 : if (TREE_CODE (decl) == FUNCTION_DECL && !is_overloaded_fn (fns))
2185 : : {
2186 : 10 : error_at (DECL_SOURCE_LOCATION (decl),
2187 : : "%qD is not a function template", fns);
2188 : 10 : return error_mark_node;
2189 : : }
2190 : 3436867 : else if (VAR_P (decl) && !variable_template_p (fns))
2191 : : {
2192 : 3 : error ("%qD is not a variable template", fns);
2193 : 3 : return error_mark_node;
2194 : : }
2195 : :
2196 : : /* Count the number of template headers specified for this
2197 : : specialization. */
2198 : 3436864 : header_count = 0;
2199 : 3436864 : for (b = current_binding_level;
2200 : 4867033 : b->kind == sk_template_parms;
2201 : 1430169 : b = b->level_chain)
2202 : 1430169 : ++header_count;
2203 : :
2204 : 3436864 : tree orig_fns = fns;
2205 : 3436864 : bool header_mismatch = false;
2206 : :
2207 : 3436864 : if (variable_template_p (fns))
2208 : : {
2209 : 863581 : tree parms = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (fns));
2210 : 863581 : targs = coerce_template_parms (parms, explicit_targs, fns,
2211 : : tf_warning_or_error);
2212 : 863581 : if (targs != error_mark_node
2213 : 863581 : && constraints_satisfied_p (fns, targs))
2214 : 863572 : templates = tree_cons (targs, fns, templates);
2215 : : }
2216 : 14771438 : else for (lkp_iterator iter (fns); iter; ++iter)
2217 : : {
2218 : 12198155 : tree fn = *iter;
2219 : :
2220 : 12198155 : if (TREE_CODE (fn) == TEMPLATE_DECL)
2221 : : {
2222 : 11601500 : tree decl_arg_types;
2223 : 11601500 : tree fn_arg_types;
2224 : :
2225 : : /* In case of explicit specialization, we need to check if
2226 : : the number of template headers appearing in the specialization
2227 : : is correct. This is usually done in check_explicit_specialization,
2228 : : but the check done there cannot be exhaustive when specializing
2229 : : member functions. Consider the following code:
2230 : :
2231 : : template <> void A<int>::f(int);
2232 : : template <> template <> void A<int>::f(int);
2233 : :
2234 : : Assuming that A<int> is not itself an explicit specialization
2235 : : already, the first line specializes "f" which is a non-template
2236 : : member function, whilst the second line specializes "f" which
2237 : : is a template member function. So both lines are syntactically
2238 : : correct, and check_explicit_specialization does not reject
2239 : : them.
2240 : :
2241 : : Here, we can do better, as we are matching the specialization
2242 : : against the declarations. We count the number of template
2243 : : headers, and we check if they match TEMPLATE_COUNT + 1
2244 : : (TEMPLATE_COUNT is the number of qualifying template classes,
2245 : : plus there must be another header for the member template
2246 : : itself).
2247 : :
2248 : : Notice that if header_count is zero, this is not a
2249 : : specialization but rather a template instantiation, so there
2250 : : is no check we can perform here. */
2251 : 11601500 : if (header_count && header_count != template_count + 1)
2252 : : {
2253 : 6 : header_mismatch = true;
2254 : 6 : continue;
2255 : : }
2256 : :
2257 : : /* Check that the number of template arguments at the
2258 : : innermost level for DECL is the same as for FN. */
2259 : 11601494 : if (current_binding_level->kind == sk_template_parms
2260 : 11601494 : && !current_binding_level->explicit_spec_p
2261 : 11601494 : && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn))
2262 : 1231 : != TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
2263 : : (current_template_parms))))
2264 : 3 : continue;
2265 : :
2266 : : /* DECL might be a specialization of FN. */
2267 : 11601491 : decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
2268 : 11601491 : fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
2269 : :
2270 : : /* For a non-static member function, we need to make sure
2271 : : that the const qualification is the same. Since
2272 : : get_bindings does not try to merge the "this" parameter,
2273 : : we must do the comparison explicitly. */
2274 : 11601491 : if (DECL_IOBJ_MEMBER_FUNCTION_P (fn))
2275 : : {
2276 : 403730 : if (!same_type_p (TREE_VALUE (fn_arg_types),
2277 : : TREE_VALUE (decl_arg_types)))
2278 : 54 : continue;
2279 : :
2280 : : /* And the ref-qualification. */
2281 : 807352 : if (type_memfn_rqual (TREE_TYPE (decl))
2282 : 403676 : != type_memfn_rqual (TREE_TYPE (fn)))
2283 : 38 : continue;
2284 : : }
2285 : :
2286 : : /* Skip the "this" parameter and, for constructors of
2287 : : classes with virtual bases, the VTT parameter. A
2288 : : full specialization of a constructor will have a VTT
2289 : : parameter, but a template never will. */
2290 : 11601399 : decl_arg_types
2291 : 11601399 : = skip_artificial_parms_for (decl, decl_arg_types);
2292 : 11601399 : fn_arg_types
2293 : 11601399 : = skip_artificial_parms_for (fn, fn_arg_types);
2294 : :
2295 : : /* Function templates cannot be specializations; there are
2296 : : no partial specializations of functions. Therefore, if
2297 : : the type of DECL does not match FN, there is no
2298 : : match.
2299 : :
2300 : : Note that it should never be the case that we have both
2301 : : candidates added here, and for regular member functions
2302 : : below. */
2303 : 11601399 : if (tsk == tsk_template)
2304 : : {
2305 : 1228 : if (!comp_template_parms (DECL_TEMPLATE_PARMS (fn),
2306 : 1228 : current_template_parms))
2307 : 0 : continue;
2308 : 1228 : if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
2309 : : TREE_TYPE (TREE_TYPE (fn))))
2310 : 0 : continue;
2311 : 1228 : if (!compparms (fn_arg_types, decl_arg_types))
2312 : 3 : continue;
2313 : :
2314 : 1225 : tree freq = get_constraints (fn);
2315 : 1225 : tree dreq = get_constraints (decl);
2316 : 1225 : if (!freq != !dreq)
2317 : 0 : continue;
2318 : 1225 : if (freq)
2319 : : {
2320 : : /* C++20 CA104: Substitute directly into the
2321 : : constraint-expression. */
2322 : 38 : tree fargs = DECL_TI_ARGS (fn);
2323 : 38 : tsubst_flags_t complain = tf_none;
2324 : 38 : freq = tsubst_constraint_info (freq, fargs, complain, fn);
2325 : 38 : if (!cp_tree_equal (freq, dreq))
2326 : 28 : continue;
2327 : : }
2328 : :
2329 : 1197 : candidates = tree_cons (NULL_TREE, fn, candidates);
2330 : 1197 : continue;
2331 : 1197 : }
2332 : :
2333 : : /* See whether this function might be a specialization of this
2334 : : template. Suppress access control because we might be trying
2335 : : to make this specialization a friend, and we have already done
2336 : : access control for the declaration of the specialization. */
2337 : 11600171 : push_deferring_access_checks (dk_no_check);
2338 : 11600171 : targs = get_bindings (fn, decl, explicit_targs, /*check_ret=*/true);
2339 : 11600171 : pop_deferring_access_checks ();
2340 : :
2341 : 11600171 : if (!targs)
2342 : : /* We cannot deduce template arguments that when used to
2343 : : specialize TMPL will produce DECL. */
2344 : 9462524 : continue;
2345 : :
2346 : 2137647 : if (uses_template_parms (targs))
2347 : : /* We deduced something involving 'auto', which isn't a valid
2348 : : template argument. */
2349 : 3 : continue;
2350 : :
2351 : : /* Save this template, and the arguments deduced. */
2352 : 2137644 : templates = tree_cons (targs, fn, templates);
2353 : : }
2354 : 596655 : else if (need_member_template)
2355 : : /* FN is an ordinary member function, and we need a
2356 : : specialization of a member template. */
2357 : : ;
2358 : 596609 : else if (TREE_CODE (fn) != FUNCTION_DECL)
2359 : : /* We can get IDENTIFIER_NODEs here in certain erroneous
2360 : : cases. */
2361 : : ;
2362 : 596609 : else if (!DECL_FUNCTION_MEMBER_P (fn))
2363 : : /* This is just an ordinary non-member function. Nothing can
2364 : : be a specialization of that. */
2365 : : ;
2366 : 585784 : else if (DECL_ARTIFICIAL (fn))
2367 : : /* Cannot specialize functions that are created implicitly. */
2368 : : ;
2369 : : else
2370 : : {
2371 : 585647 : tree decl_arg_types;
2372 : :
2373 : : /* This is an ordinary member function. However, since
2374 : : we're here, we can assume its enclosing class is a
2375 : : template class. For example,
2376 : :
2377 : : template <typename T> struct S { void f(); };
2378 : : template <> void S<int>::f() {}
2379 : :
2380 : : Here, S<int>::f is a non-template, but S<int> is a
2381 : : template class. If FN has the same type as DECL, we
2382 : : might be in business. */
2383 : :
2384 : 585647 : if (!DECL_TEMPLATE_INFO (fn))
2385 : : /* Its enclosing class is an explicit specialization
2386 : : of a template class. This is not a candidate. */
2387 : 6 : continue;
2388 : :
2389 : 585641 : if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
2390 : : TREE_TYPE (TREE_TYPE (fn))))
2391 : : /* The return types differ. */
2392 : 1506 : continue;
2393 : :
2394 : : /* Adjust the type of DECL in case FN is a static member. */
2395 : 584135 : decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
2396 : 584135 : if (DECL_STATIC_FUNCTION_P (fn)
2397 : 584135 : && DECL_IOBJ_MEMBER_FUNCTION_P (decl))
2398 : 181 : decl_arg_types = TREE_CHAIN (decl_arg_types);
2399 : :
2400 : 584135 : if (!compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
2401 : : decl_arg_types))
2402 : 107230 : continue;
2403 : :
2404 : 476905 : if (DECL_IOBJ_MEMBER_FUNCTION_P (fn)
2405 : 953640 : && (type_memfn_rqual (TREE_TYPE (decl))
2406 : 476735 : != type_memfn_rqual (TREE_TYPE (fn))))
2407 : 6 : continue;
2408 : :
2409 : : // If the deduced arguments do not satisfy the constraints,
2410 : : // this is not a candidate.
2411 : 476899 : if (flag_concepts && !constraints_satisfied_p (fn))
2412 : 21 : continue;
2413 : :
2414 : : // Add the candidate.
2415 : 476878 : candidates = tree_cons (NULL_TREE, fn, candidates);
2416 : : }
2417 : : }
2418 : :
2419 : 3436864 : if (templates && TREE_CHAIN (templates))
2420 : : {
2421 : : /* We have:
2422 : :
2423 : : [temp.expl.spec]
2424 : :
2425 : : It is possible for a specialization with a given function
2426 : : signature to be instantiated from more than one function
2427 : : template. In such cases, explicit specification of the
2428 : : template arguments must be used to uniquely identify the
2429 : : function template specialization being specialized.
2430 : :
2431 : : Note that here, there's no suggestion that we're supposed to
2432 : : determine which of the candidate templates is most
2433 : : specialized. However, we, also have:
2434 : :
2435 : : [temp.func.order]
2436 : :
2437 : : Partial ordering of overloaded function template
2438 : : declarations is used in the following contexts to select
2439 : : the function template to which a function template
2440 : : specialization refers:
2441 : :
2442 : : -- when an explicit specialization refers to a function
2443 : : template.
2444 : :
2445 : : So, we do use the partial ordering rules, at least for now.
2446 : : This extension can only serve to make invalid programs valid,
2447 : : so it's safe. And, there is strong anecdotal evidence that
2448 : : the committee intended the partial ordering rules to apply;
2449 : : the EDG front end has that behavior, and John Spicer claims
2450 : : that the committee simply forgot to delete the wording in
2451 : : [temp.expl.spec]. */
2452 : 21343 : tree tmpl = most_specialized_instantiation (templates);
2453 : 21343 : if (tmpl != error_mark_node)
2454 : : {
2455 : 21340 : templates = tmpl;
2456 : 21340 : TREE_CHAIN (templates) = NULL_TREE;
2457 : : }
2458 : : }
2459 : :
2460 : : // Concepts allows multiple declarations of member functions
2461 : : // with the same signature. Like above, we need to rely on
2462 : : // on the partial ordering of those candidates to determine which
2463 : : // is the best.
2464 : 3436864 : if (flag_concepts && candidates && TREE_CHAIN (candidates))
2465 : : {
2466 : 12 : if (tree cand = most_constrained_function (candidates))
2467 : : {
2468 : 12 : candidates = cand;
2469 : 12 : TREE_CHAIN (cand) = NULL_TREE;
2470 : : }
2471 : : }
2472 : :
2473 : 3436864 : if (templates == NULL_TREE && candidates == NULL_TREE)
2474 : : {
2475 : 219 : auto_diagnostic_group d;
2476 : 219 : error ("template-id %qD for %q+D does not match any template "
2477 : : "declaration", template_id, decl);
2478 : 219 : if (header_mismatch)
2479 : 3 : inform (DECL_SOURCE_LOCATION (decl),
2480 : : "saw %d %<template<>%>, need %d for "
2481 : : "specializing a member function template",
2482 : : header_count, template_count + 1);
2483 : 219 : print_candidates (orig_fns);
2484 : 219 : return error_mark_node;
2485 : 219 : }
2486 : 2958582 : else if ((templates && TREE_CHAIN (templates))
2487 : 3436642 : || (candidates && TREE_CHAIN (candidates))
2488 : 6873287 : || (templates && candidates))
2489 : : {
2490 : 3 : auto_diagnostic_group d;
2491 : 3 : error ("ambiguous template specialization %qD for %q+D",
2492 : : template_id, decl);
2493 : 3 : candidates = chainon (candidates, templates);
2494 : 3 : print_candidates (candidates);
2495 : 3 : return error_mark_node;
2496 : 3 : }
2497 : :
2498 : : /* We have one, and exactly one, match. */
2499 : 3436642 : if (candidates)
2500 : : {
2501 : 478063 : tree fn = TREE_VALUE (candidates);
2502 : 478063 : *targs_out = copy_node (DECL_TI_ARGS (fn));
2503 : :
2504 : : /* Propagate the candidate's constraints to the declaration. */
2505 : 478063 : if (tsk != tsk_template)
2506 : 476866 : set_constraints (decl, get_constraints (fn));
2507 : :
2508 : : /* DECL is a re-declaration or partial instantiation of a template
2509 : : function. */
2510 : 478063 : if (TREE_CODE (fn) == TEMPLATE_DECL)
2511 : : return fn;
2512 : : /* It was a specialization of an ordinary member function in a
2513 : : template class. */
2514 : 476866 : return DECL_TI_TEMPLATE (fn);
2515 : : }
2516 : :
2517 : : /* It was a specialization of a template. */
2518 : 2958579 : tree tmpl = TREE_VALUE (templates);
2519 : 2958579 : *targs_out = add_outermost_template_args (tmpl, TREE_PURPOSE (templates));
2520 : :
2521 : : /* Propagate the template's constraints to the declaration. */
2522 : 2958579 : if (tsk != tsk_template)
2523 : 2380093 : set_constraints (decl, get_constraints (tmpl));
2524 : :
2525 : : return tmpl;
2526 : : }
2527 : :
2528 : : /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
2529 : : but with the default argument values filled in from those in the
2530 : : TMPL_TYPES. */
2531 : :
2532 : : static tree
2533 : 209869 : copy_default_args_to_explicit_spec_1 (tree spec_types,
2534 : : tree tmpl_types)
2535 : : {
2536 : 209869 : tree new_spec_types;
2537 : :
2538 : 209869 : if (!spec_types)
2539 : : return NULL_TREE;
2540 : :
2541 : 209869 : if (spec_types == void_list_node)
2542 : : return void_list_node;
2543 : :
2544 : : /* Substitute into the rest of the list. */
2545 : 125554 : new_spec_types =
2546 : 125554 : copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types),
2547 : 125554 : TREE_CHAIN (tmpl_types));
2548 : :
2549 : : /* Add the default argument for this parameter. */
2550 : 251108 : return hash_tree_cons (TREE_PURPOSE (tmpl_types),
2551 : 125554 : TREE_VALUE (spec_types),
2552 : 125554 : new_spec_types);
2553 : : }
2554 : :
2555 : : /* DECL is an explicit specialization. Replicate default arguments
2556 : : from the template it specializes. (That way, code like:
2557 : :
2558 : : template <class T> void f(T = 3);
2559 : : template <> void f(double);
2560 : : void g () { f (); }
2561 : :
2562 : : works, as required.) An alternative approach would be to look up
2563 : : the correct default arguments at the call-site, but this approach
2564 : : is consistent with how implicit instantiations are handled. */
2565 : :
2566 : : static void
2567 : 564084 : copy_default_args_to_explicit_spec (tree decl)
2568 : : {
2569 : 564084 : tree tmpl;
2570 : 564084 : tree spec_types;
2571 : 564084 : tree tmpl_types;
2572 : 564084 : tree new_spec_types;
2573 : 564084 : tree old_type;
2574 : 564084 : tree new_type;
2575 : 564084 : tree t;
2576 : 564084 : tree object_type = NULL_TREE;
2577 : 564084 : tree in_charge = NULL_TREE;
2578 : 564084 : tree vtt = NULL_TREE;
2579 : :
2580 : : /* See if there's anything we need to do. */
2581 : 564084 : tmpl = DECL_TI_TEMPLATE (decl);
2582 : 564084 : tmpl_types = TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl)));
2583 : 2288455 : for (t = tmpl_types; t; t = TREE_CHAIN (t))
2584 : 1808686 : if (TREE_PURPOSE (t))
2585 : : break;
2586 : 564084 : if (!t)
2587 : : return;
2588 : :
2589 : 84315 : old_type = TREE_TYPE (decl);
2590 : 84315 : spec_types = TYPE_ARG_TYPES (old_type);
2591 : :
2592 : 84315 : if (DECL_IOBJ_MEMBER_FUNCTION_P (decl))
2593 : : {
2594 : : /* Remove the this pointer, but remember the object's type for
2595 : : CV quals. */
2596 : 84315 : object_type = TREE_TYPE (TREE_VALUE (spec_types));
2597 : 84315 : spec_types = TREE_CHAIN (spec_types);
2598 : 84315 : tmpl_types = TREE_CHAIN (tmpl_types);
2599 : :
2600 : 84315 : if (DECL_HAS_IN_CHARGE_PARM_P (decl))
2601 : : {
2602 : : /* DECL may contain more parameters than TMPL due to the extra
2603 : : in-charge parameter in constructors and destructors. */
2604 : 0 : in_charge = spec_types;
2605 : 0 : spec_types = TREE_CHAIN (spec_types);
2606 : : }
2607 : 84315 : if (DECL_HAS_VTT_PARM_P (decl))
2608 : : {
2609 : 0 : vtt = spec_types;
2610 : 0 : spec_types = TREE_CHAIN (spec_types);
2611 : : }
2612 : : }
2613 : :
2614 : : /* Compute the merged default arguments. */
2615 : 84315 : new_spec_types =
2616 : 84315 : copy_default_args_to_explicit_spec_1 (spec_types, tmpl_types);
2617 : :
2618 : : /* Compute the new FUNCTION_TYPE. */
2619 : 84315 : if (object_type)
2620 : : {
2621 : 84315 : if (vtt)
2622 : 0 : new_spec_types = hash_tree_cons (TREE_PURPOSE (vtt),
2623 : 0 : TREE_VALUE (vtt),
2624 : : new_spec_types);
2625 : :
2626 : 84315 : if (in_charge)
2627 : : /* Put the in-charge parameter back. */
2628 : 0 : new_spec_types = hash_tree_cons (TREE_PURPOSE (in_charge),
2629 : 0 : TREE_VALUE (in_charge),
2630 : : new_spec_types);
2631 : :
2632 : 84315 : new_type = build_method_type_directly (object_type,
2633 : 84315 : TREE_TYPE (old_type),
2634 : : new_spec_types);
2635 : : }
2636 : : else
2637 : 0 : new_type = build_function_type (TREE_TYPE (old_type),
2638 : : new_spec_types);
2639 : 84315 : new_type = cp_build_type_attribute_variant (new_type,
2640 : 84315 : TYPE_ATTRIBUTES (old_type));
2641 : 84315 : new_type = cxx_copy_lang_qualifiers (new_type, old_type);
2642 : :
2643 : 84315 : TREE_TYPE (decl) = new_type;
2644 : : }
2645 : :
2646 : : /* Return the number of template headers we expect to see for a definition
2647 : : or specialization of CTYPE or one of its non-template members. */
2648 : :
2649 : : int
2650 : 29527641 : num_template_headers_for_class (tree ctype)
2651 : : {
2652 : 29527641 : int num_templates = 0;
2653 : :
2654 : 47247707 : while (ctype && CLASS_TYPE_P (ctype))
2655 : : {
2656 : : /* You're supposed to have one `template <...>' for every
2657 : : template class, but you don't need one for a full
2658 : : specialization. For example:
2659 : :
2660 : : template <class T> struct S{};
2661 : : template <> struct S<int> { void f(); };
2662 : : void S<int>::f () {}
2663 : :
2664 : : is correct; there shouldn't be a `template <>' for the
2665 : : definition of `S<int>::f'. */
2666 : 24029068 : if (!CLASSTYPE_TEMPLATE_INFO (ctype))
2667 : : /* If CTYPE does not have template information of any
2668 : : kind, then it is not a template, nor is it nested
2669 : : within a template. */
2670 : : break;
2671 : 17886167 : if (explicit_class_specialization_p (ctype))
2672 : : break;
2673 : 17720066 : if (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (ctype)))
2674 : 17397486 : ++num_templates;
2675 : :
2676 : 17720066 : ctype = TYPE_CONTEXT (ctype);
2677 : : }
2678 : :
2679 : 29527641 : return num_templates;
2680 : : }
2681 : :
2682 : : /* Do a simple sanity check on the template headers that precede the
2683 : : variable declaration DECL. */
2684 : :
2685 : : void
2686 : 3053672 : check_template_variable (tree decl)
2687 : : {
2688 : 3053672 : tree ctx = CP_DECL_CONTEXT (decl);
2689 : 3053672 : int wanted = num_template_headers_for_class (ctx);
2690 : 6107341 : if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)
2691 : 6107332 : && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl)))
2692 : : {
2693 : 2722068 : if (cxx_dialect < cxx14)
2694 : 2904 : pedwarn (DECL_SOURCE_LOCATION (decl), OPT_Wc__14_extensions,
2695 : : "variable templates only available with "
2696 : : "%<-std=c++14%> or %<-std=gnu++14%>");
2697 : :
2698 : : // Namespace-scope variable templates should have a template header.
2699 : 2722068 : ++wanted;
2700 : : }
2701 : 3053672 : if (template_header_count > wanted)
2702 : : {
2703 : 12 : auto_diagnostic_group d;
2704 : 12 : bool warned = pedwarn (DECL_SOURCE_LOCATION (decl), 0,
2705 : : "too many template headers for %qD "
2706 : : "(should be %d)",
2707 : : decl, wanted);
2708 : 12 : if (warned && CLASS_TYPE_P (ctx)
2709 : 21 : && CLASSTYPE_TEMPLATE_SPECIALIZATION (ctx))
2710 : 3 : inform (DECL_SOURCE_LOCATION (decl),
2711 : : "members of an explicitly specialized class are defined "
2712 : : "without a template header");
2713 : 12 : }
2714 : 3053672 : }
2715 : :
2716 : : /* An explicit specialization whose declarator-id or class-head-name is not
2717 : : qualified shall be declared in the nearest enclosing namespace of the
2718 : : template, or, if the namespace is inline (7.3.1), any namespace from its
2719 : : enclosing namespace set.
2720 : :
2721 : : If the name declared in the explicit instantiation is an unqualified name,
2722 : : the explicit instantiation shall appear in the namespace where its template
2723 : : is declared or, if that namespace is inline (7.3.1), any namespace from its
2724 : : enclosing namespace set. */
2725 : :
2726 : : void
2727 : 13580310 : check_unqualified_spec_or_inst (tree t, location_t loc)
2728 : : {
2729 : 13580310 : tree tmpl = most_general_template (t);
2730 : 27160620 : if (DECL_NAMESPACE_SCOPE_P (tmpl)
2731 : 26660265 : && !is_nested_namespace (current_namespace,
2732 : 13079955 : CP_DECL_CONTEXT (tmpl), true))
2733 : : {
2734 : 17 : if (processing_specialization)
2735 : 6 : permerror (loc, "explicit specialization of %qD outside its "
2736 : : "namespace must use a nested-name-specifier", tmpl);
2737 : 11 : else if (processing_explicit_instantiation
2738 : 11 : && cxx_dialect >= cxx11)
2739 : : /* This was allowed in C++98, so only pedwarn. */
2740 : 9 : pedwarn (loc, OPT_Wpedantic, "explicit instantiation of %qD "
2741 : : "outside its namespace must use a nested-name-"
2742 : : "specifier", tmpl);
2743 : : }
2744 : 13580310 : }
2745 : :
2746 : : /* Warn for a template specialization SPEC that is missing some of a set
2747 : : of function or type attributes that the template TEMPL is declared with.
2748 : : ATTRLIST is a list of additional attributes that SPEC should be taken
2749 : : to ultimately be declared with. */
2750 : :
2751 : : static void
2752 : 849133 : warn_spec_missing_attributes (tree tmpl, tree spec, tree attrlist)
2753 : : {
2754 : 849133 : if (DECL_FUNCTION_TEMPLATE_P (tmpl))
2755 : : tmpl = DECL_TEMPLATE_RESULT (tmpl);
2756 : :
2757 : : /* Avoid warning if the difference between the primary and
2758 : : the specialization is not in one of the attributes below. */
2759 : 849133 : const char* const blacklist[] = {
2760 : : "alloc_align", "alloc_size", "assume_aligned", "format",
2761 : : "format_arg", "malloc", "nonnull", NULL
2762 : : };
2763 : :
2764 : : /* Put together a list of the black listed attributes that the primary
2765 : : template is declared with that the specialization is not, in case
2766 : : it's not apparent from the most recent declaration of the primary. */
2767 : 849133 : pretty_printer str;
2768 : 849133 : unsigned nattrs = decls_mismatched_attributes (tmpl, spec, attrlist,
2769 : : blacklist, &str);
2770 : :
2771 : 849133 : if (!nattrs)
2772 : 849106 : return;
2773 : :
2774 : 27 : auto_diagnostic_group d;
2775 : 27 : if (warning_at (DECL_SOURCE_LOCATION (spec), OPT_Wmissing_attributes,
2776 : : "explicit specialization %q#D may be missing attributes",
2777 : : spec))
2778 : 51 : inform (DECL_SOURCE_LOCATION (tmpl),
2779 : : nattrs > 1
2780 : : ? G_("missing primary template attributes %s")
2781 : : : G_("missing primary template attribute %s"),
2782 : : pp_formatted_text (&str));
2783 : 849133 : }
2784 : :
2785 : : /* Check to see if the function just declared, as indicated in
2786 : : DECLARATOR, and in DECL, is a specialization of a function
2787 : : template. We may also discover that the declaration is an explicit
2788 : : instantiation at this point.
2789 : :
2790 : : Returns DECL, or an equivalent declaration that should be used
2791 : : instead if all goes well. Issues an error message if something is
2792 : : amiss. Returns error_mark_node if the error is not easily
2793 : : recoverable.
2794 : :
2795 : : FLAGS is a bitmask consisting of the following flags:
2796 : :
2797 : : 2: The function has a definition.
2798 : : 4: The function is a friend.
2799 : :
2800 : : The TEMPLATE_COUNT is the number of references to qualifying
2801 : : template classes that appeared in the name of the function. For
2802 : : example, in
2803 : :
2804 : : template <class T> struct S { void f(); };
2805 : : void S<int>::f();
2806 : :
2807 : : the TEMPLATE_COUNT would be 1. However, explicitly specialized
2808 : : classes are not counted in the TEMPLATE_COUNT, so that in
2809 : :
2810 : : template <class T> struct S {};
2811 : : template <> struct S<int> { void f(); }
2812 : : template <> void S<int>::f();
2813 : :
2814 : : the TEMPLATE_COUNT would be 0. (Note that this declaration is
2815 : : invalid; there should be no template <>.)
2816 : :
2817 : : If the function is a specialization, it is marked as such via
2818 : : DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2819 : : is set up correctly, and it is added to the list of specializations
2820 : : for that template. */
2821 : :
2822 : : tree
2823 : 212207522 : check_explicit_specialization (tree declarator,
2824 : : tree decl,
2825 : : int template_count,
2826 : : int flags,
2827 : : tree attrlist)
2828 : : {
2829 : 212207522 : int have_def = flags & 2;
2830 : 212207522 : int is_friend = flags & 4;
2831 : 212207522 : bool is_concept = flags & 8;
2832 : 212207522 : int specialization = 0;
2833 : 212207522 : int explicit_instantiation = 0;
2834 : 212207522 : int member_specialization = 0;
2835 : 212207522 : tree ctype = DECL_CLASS_CONTEXT (decl);
2836 : 212207522 : tree dname = DECL_NAME (decl);
2837 : 212207522 : tmpl_spec_kind tsk;
2838 : :
2839 : 212207522 : if (is_friend)
2840 : : {
2841 : 67 : if (!processing_specialization)
2842 : : tsk = tsk_none;
2843 : : else
2844 : : tsk = tsk_excessive_parms;
2845 : : }
2846 : : else
2847 : 212207455 : tsk = current_tmpl_spec_kind (template_count);
2848 : :
2849 : 212207455 : switch (tsk)
2850 : : {
2851 : 163945292 : case tsk_none:
2852 : 163945292 : if (processing_specialization && !VAR_P (decl))
2853 : : {
2854 : 471770 : specialization = 1;
2855 : 471770 : SET_DECL_TEMPLATE_SPECIALIZATION (decl);
2856 : : }
2857 : 163473522 : else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
2858 : 163473522 : || (DECL_LANG_SPECIFIC (decl)
2859 : 114334796 : && DECL_IMPLICIT_INSTANTIATION (decl)))
2860 : : {
2861 : 79 : if (is_friend)
2862 : : /* This could be something like:
2863 : :
2864 : : template <class T> void f(T);
2865 : : class S { friend void f<>(int); } */
2866 : : specialization = 1;
2867 : : else
2868 : : {
2869 : : /* This case handles bogus declarations like template <>
2870 : : template <class T> void f<int>(); */
2871 : :
2872 : 12 : error_at (cp_expr_loc_or_input_loc (declarator),
2873 : : "template-id %qE in declaration of primary template",
2874 : : declarator);
2875 : 12 : return decl;
2876 : : }
2877 : : }
2878 : : break;
2879 : :
2880 : 0 : case tsk_invalid_member_spec:
2881 : : /* The error has already been reported in
2882 : : check_specialization_scope. */
2883 : 0 : return error_mark_node;
2884 : :
2885 : 0 : case tsk_invalid_expl_inst:
2886 : 0 : error ("template parameter list used in explicit instantiation");
2887 : :
2888 : : /* Fall through. */
2889 : :
2890 : 1983767 : case tsk_expl_inst:
2891 : 1983767 : if (have_def)
2892 : 0 : error ("definition provided for explicit instantiation");
2893 : :
2894 : : explicit_instantiation = 1;
2895 : : break;
2896 : :
2897 : 0 : case tsk_excessive_parms:
2898 : 0 : case tsk_insufficient_parms:
2899 : 0 : if (tsk == tsk_excessive_parms)
2900 : 0 : error ("too many template parameter lists in declaration of %qD",
2901 : : decl);
2902 : 0 : else if (template_header_count)
2903 : 0 : error("too few template parameter lists in declaration of %qD", decl);
2904 : : else
2905 : 0 : error("explicit specialization of %qD must be introduced by "
2906 : : "%<template <>%>", decl);
2907 : :
2908 : : /* Fall through. */
2909 : 377397 : case tsk_expl_spec:
2910 : 377397 : if (is_concept)
2911 : 0 : error ("explicit specialization declared %<concept%>");
2912 : :
2913 : 377397 : if (VAR_P (decl) && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
2914 : : /* In cases like template<> constexpr bool v = true;
2915 : : We'll give an error in check_template_variable. */
2916 : : break;
2917 : :
2918 : 377385 : SET_DECL_TEMPLATE_SPECIALIZATION (decl);
2919 : 377385 : if (ctype)
2920 : : member_specialization = 1;
2921 : : else
2922 : 377178 : specialization = 1;
2923 : : break;
2924 : :
2925 : 45901066 : case tsk_template:
2926 : 45901066 : if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
2927 : : {
2928 : : /* This case handles bogus declarations like template <>
2929 : : template <class T> void f<int>(); */
2930 : :
2931 : 578512 : if (!uses_template_parms (TREE_OPERAND (declarator, 1)))
2932 : 14 : error_at (cp_expr_loc_or_input_loc (declarator),
2933 : : "template-id %qE in declaration of primary template",
2934 : : declarator);
2935 : 578501 : else if (variable_template_p (TREE_OPERAND (declarator, 0)))
2936 : : {
2937 : : /* Partial specialization of variable template. */
2938 : 578486 : SET_DECL_TEMPLATE_SPECIALIZATION (decl);
2939 : 578486 : specialization = 1;
2940 : 578486 : goto ok;
2941 : : }
2942 : 15 : else if (cxx_dialect < cxx14)
2943 : 5 : error_at (cp_expr_loc_or_input_loc (declarator),
2944 : : "non-type partial specialization %qE "
2945 : : "is not allowed", declarator);
2946 : : else
2947 : 16 : error_at (cp_expr_loc_or_input_loc (declarator),
2948 : : "non-class, non-variable partial specialization %qE "
2949 : : "is not allowed", declarator);
2950 : 26 : return decl;
2951 : 578486 : ok:;
2952 : : }
2953 : :
2954 : 45901040 : if (ctype && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype))
2955 : : /* This is a specialization of a member template, without
2956 : : specialization the containing class. Something like:
2957 : :
2958 : : template <class T> struct S {
2959 : : template <class U> void f (U);
2960 : : };
2961 : : template <> template <class U> void S<int>::f(U) {}
2962 : :
2963 : : That's a specialization -- but of the entire template. */
2964 : : specialization = 1;
2965 : : break;
2966 : :
2967 : 0 : default:
2968 : 0 : gcc_unreachable ();
2969 : : }
2970 : :
2971 : 212207484 : if ((specialization || member_specialization)
2972 : : /* This doesn't apply to variable templates. */
2973 : 212207484 : && FUNC_OR_METHOD_TYPE_P (TREE_TYPE (decl)))
2974 : : {
2975 : 565370 : tree t = TYPE_ARG_TYPES (TREE_TYPE (decl));
2976 : 2503540 : for (; t; t = TREE_CHAIN (t))
2977 : 1938173 : if (TREE_PURPOSE (t))
2978 : : {
2979 : 3 : permerror (input_location,
2980 : : "default argument specified in explicit specialization");
2981 : 3 : break;
2982 : : }
2983 : : }
2984 : :
2985 : 212207484 : if (specialization || member_specialization || explicit_instantiation)
2986 : : {
2987 : 3412687 : tree tmpl = NULL_TREE;
2988 : 3412687 : tree targs = NULL_TREE;
2989 : 3412687 : bool was_template_id = (TREE_CODE (declarator) == TEMPLATE_ID_EXPR);
2990 : 3412687 : bool found_hidden = false;
2991 : :
2992 : : /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2993 : 3412687 : if (!was_template_id)
2994 : : {
2995 : 1696116 : tree fns;
2996 : :
2997 : 1696116 : gcc_assert (identifier_p (declarator));
2998 : 1696116 : if (ctype)
2999 : : fns = dname;
3000 : : else
3001 : : {
3002 : : /* If there is no class context, the explicit instantiation
3003 : : must be at namespace scope. */
3004 : 814905 : gcc_assert (DECL_NAMESPACE_SCOPE_P (decl));
3005 : :
3006 : : /* Find the namespace binding, using the declaration
3007 : : context. */
3008 : 814905 : fns = lookup_qualified_name (CP_DECL_CONTEXT (decl), dname,
3009 : : LOOK_want::NORMAL, true);
3010 : 814905 : if (fns == error_mark_node)
3011 : : {
3012 : : /* If lookup fails, look for a friend declaration so we can
3013 : : give a better diagnostic. */
3014 : 22 : fns = (lookup_qualified_name
3015 : 22 : (CP_DECL_CONTEXT (decl), dname,
3016 : : LOOK_want::NORMAL | LOOK_want::HIDDEN_FRIEND,
3017 : : /*complain*/true));
3018 : 22 : found_hidden = true;
3019 : : }
3020 : :
3021 : 814905 : if (fns == error_mark_node || !is_overloaded_fn (fns))
3022 : : {
3023 : 22 : error ("%qD is not a template function", dname);
3024 : 22 : fns = error_mark_node;
3025 : : }
3026 : : }
3027 : :
3028 : 1696116 : declarator = lookup_template_function (fns, NULL_TREE);
3029 : : }
3030 : :
3031 : 3412687 : if (declarator == error_mark_node)
3032 : 1985068 : return error_mark_node;
3033 : :
3034 : 3412665 : if (ctype != NULL_TREE && TYPE_BEING_DEFINED (ctype))
3035 : : {
3036 : 0 : if (!explicit_instantiation)
3037 : : /* A specialization in class scope. This is invalid,
3038 : : but the error will already have been flagged by
3039 : : check_specialization_scope. */
3040 : : return error_mark_node;
3041 : : else
3042 : : {
3043 : : /* It's not valid to write an explicit instantiation in
3044 : : class scope, e.g.:
3045 : :
3046 : : class C { template void f(); }
3047 : :
3048 : : This case is caught by the parser. However, on
3049 : : something like:
3050 : :
3051 : : template class C { void f(); };
3052 : :
3053 : : (which is invalid) we can get here. The error will be
3054 : : issued later. */
3055 : 0 : ;
3056 : : }
3057 : :
3058 : 0 : return decl;
3059 : : }
3060 : 3412665 : else if (ctype != NULL_TREE
3061 : 3412665 : && (identifier_p (TREE_OPERAND (declarator, 0))))
3062 : : {
3063 : : // We'll match variable templates in start_decl.
3064 : 881211 : if (VAR_P (decl))
3065 : : return decl;
3066 : :
3067 : : /* Find the list of functions in ctype that have the same
3068 : : name as the declared function. */
3069 : 881166 : tree name = TREE_OPERAND (declarator, 0);
3070 : :
3071 : 881166 : if (constructor_name_p (name, ctype))
3072 : : {
3073 : 0 : if (DECL_CONSTRUCTOR_P (decl)
3074 : 0 : ? !TYPE_HAS_USER_CONSTRUCTOR (ctype)
3075 : 0 : : !CLASSTYPE_DESTRUCTOR (ctype))
3076 : : {
3077 : : /* From [temp.expl.spec]:
3078 : :
3079 : : If such an explicit specialization for the member
3080 : : of a class template names an implicitly-declared
3081 : : special member function (clause _special_), the
3082 : : program is ill-formed.
3083 : :
3084 : : Similar language is found in [temp.explicit]. */
3085 : 0 : error ("specialization of implicitly-declared special member function");
3086 : 0 : return error_mark_node;
3087 : : }
3088 : :
3089 : 0 : name = DECL_NAME (decl);
3090 : : }
3091 : :
3092 : : /* For a type-conversion operator, We might be looking for
3093 : : `operator int' which will be a specialization of
3094 : : `operator T'. Grab all the conversion operators, and
3095 : : then select from them. */
3096 : 881166 : tree fns = get_class_binding (ctype, IDENTIFIER_CONV_OP_P (name)
3097 : : ? conv_op_identifier : name);
3098 : :
3099 : 881166 : if (fns == NULL_TREE)
3100 : : {
3101 : 0 : error ("no member function %qD declared in %qT", name, ctype);
3102 : 0 : return error_mark_node;
3103 : : }
3104 : : else
3105 : 881166 : TREE_OPERAND (declarator, 0) = fns;
3106 : : }
3107 : :
3108 : : /* Figure out what exactly is being specialized at this point.
3109 : : Note that for an explicit instantiation, even one for a
3110 : : member function, we cannot tell a priori whether the
3111 : : instantiation is for a member template, or just a member
3112 : : function of a template class. Even if a member template is
3113 : : being instantiated, the member template arguments may be
3114 : : elided if they can be deduced from the rest of the
3115 : : declaration. */
3116 : 3412620 : tmpl = determine_specialization (declarator, decl,
3117 : : &targs,
3118 : : member_specialization,
3119 : : template_count,
3120 : : tsk);
3121 : :
3122 : 3412620 : if (!tmpl || tmpl == error_mark_node)
3123 : : /* We couldn't figure out what this declaration was
3124 : : specializing. */
3125 : 232 : return error_mark_node;
3126 : : else
3127 : : {
3128 : 3412388 : if (found_hidden && TREE_CODE (decl) == FUNCTION_DECL)
3129 : : {
3130 : 9 : auto_diagnostic_group d;
3131 : 9 : if (pedwarn (DECL_SOURCE_LOCATION (decl), 0,
3132 : : "friend declaration %qD is not visible to "
3133 : : "explicit specialization", tmpl))
3134 : 9 : inform (DECL_SOURCE_LOCATION (tmpl),
3135 : : "friend declaration here");
3136 : 9 : }
3137 : :
3138 : 3412388 : if (!ctype && !is_friend
3139 : 3412388 : && CP_DECL_CONTEXT (decl) == current_namespace)
3140 : 2466105 : check_unqualified_spec_or_inst (tmpl, DECL_SOURCE_LOCATION (decl));
3141 : :
3142 : 3412388 : tree gen_tmpl = most_general_template (tmpl);
3143 : :
3144 : 3412388 : if (explicit_instantiation)
3145 : : {
3146 : : /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
3147 : : is done by do_decl_instantiation later. */
3148 : :
3149 : 1983572 : int arg_depth = TMPL_ARGS_DEPTH (targs);
3150 : 1983572 : int parm_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
3151 : :
3152 : 1983572 : if (arg_depth > parm_depth)
3153 : : {
3154 : : /* If TMPL is not the most general template (for
3155 : : example, if TMPL is a friend template that is
3156 : : injected into namespace scope), then there will
3157 : : be too many levels of TARGS. Remove some of them
3158 : : here. */
3159 : 403022 : int i;
3160 : 403022 : tree new_targs;
3161 : :
3162 : 403022 : new_targs = make_tree_vec (parm_depth);
3163 : 806044 : for (i = arg_depth - parm_depth; i < arg_depth; ++i)
3164 : 806044 : TREE_VEC_ELT (new_targs, i - (arg_depth - parm_depth))
3165 : 403022 : = TREE_VEC_ELT (targs, i);
3166 : 403022 : targs = new_targs;
3167 : : }
3168 : :
3169 : 1983572 : return instantiate_template (tmpl, targs, tf_error);
3170 : : }
3171 : :
3172 : : /* If we thought that the DECL was a member function, but it
3173 : : turns out to be specializing a static member function,
3174 : : make DECL a static member function as well. */
3175 : 1428816 : if (DECL_FUNCTION_TEMPLATE_P (tmpl)
3176 : 565281 : && DECL_STATIC_FUNCTION_P (tmpl)
3177 : 1430099 : && DECL_IOBJ_MEMBER_FUNCTION_P (decl))
3178 : 1274 : revert_static_member_fn (decl);
3179 : :
3180 : : /* If this is a specialization of a member template of a
3181 : : template class, we want to return the TEMPLATE_DECL, not
3182 : : the specialization of it. */
3183 : 1428816 : if (tsk == tsk_template && !was_template_id)
3184 : : {
3185 : 1197 : tree result = DECL_TEMPLATE_RESULT (tmpl);
3186 : 1197 : SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
3187 : 1197 : DECL_INITIAL (result) = NULL_TREE;
3188 : 1197 : if (have_def)
3189 : : {
3190 : 1185 : tree parm;
3191 : 1185 : DECL_SOURCE_LOCATION (tmpl) = DECL_SOURCE_LOCATION (decl);
3192 : 2370 : DECL_SOURCE_LOCATION (result)
3193 : 1185 : = DECL_SOURCE_LOCATION (decl);
3194 : : /* We want to use the argument list specified in the
3195 : : definition, not in the original declaration. */
3196 : 1185 : DECL_ARGUMENTS (result) = DECL_ARGUMENTS (decl);
3197 : 2443 : for (parm = DECL_ARGUMENTS (result); parm;
3198 : 1258 : parm = DECL_CHAIN (parm))
3199 : 1258 : DECL_CONTEXT (parm) = result;
3200 : : }
3201 : 1197 : decl = register_specialization (tmpl, gen_tmpl, targs,
3202 : : is_friend, 0);
3203 : 1197 : remove_contract_attributes (result);
3204 : 1197 : return decl;
3205 : : }
3206 : :
3207 : : /* Set up the DECL_TEMPLATE_INFO for DECL. */
3208 : 1427619 : DECL_TEMPLATE_INFO (decl) = build_template_info (tmpl, targs);
3209 : :
3210 : 1427619 : if (was_template_id)
3211 : 864235 : TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (decl)) = true;
3212 : :
3213 : : /* Inherit default function arguments from the template
3214 : : DECL is specializing. */
3215 : 1427619 : if (DECL_FUNCTION_TEMPLATE_P (tmpl))
3216 : 564084 : copy_default_args_to_explicit_spec (decl);
3217 : :
3218 : : /* This specialization has the same protection as the
3219 : : template it specializes. */
3220 : 1427619 : TREE_PRIVATE (decl) = TREE_PRIVATE (gen_tmpl);
3221 : 1427619 : TREE_PROTECTED (decl) = TREE_PROTECTED (gen_tmpl);
3222 : :
3223 : : /* 7.1.1-1 [dcl.stc]
3224 : :
3225 : : A storage-class-specifier shall not be specified in an
3226 : : explicit specialization...
3227 : :
3228 : : The parser rejects these, so unless action is taken here,
3229 : : explicit function specializations will always appear with
3230 : : global linkage.
3231 : :
3232 : : The action recommended by the C++ CWG in response to C++
3233 : : defect report 605 is to make the storage class and linkage
3234 : : of the explicit specialization match the templated function:
3235 : :
3236 : : http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
3237 : : */
3238 : 1427619 : if (tsk == tsk_expl_spec && DECL_FUNCTION_TEMPLATE_P (gen_tmpl))
3239 : : {
3240 : 92266 : tree tmpl_func = DECL_TEMPLATE_RESULT (gen_tmpl);
3241 : 92266 : gcc_assert (TREE_CODE (tmpl_func) == FUNCTION_DECL);
3242 : :
3243 : : /* This specialization has the same linkage and visibility as
3244 : : the function template it specializes. */
3245 : 92266 : TREE_PUBLIC (decl) = TREE_PUBLIC (tmpl_func);
3246 : 92266 : if (! TREE_PUBLIC (decl))
3247 : : {
3248 : 34 : DECL_INTERFACE_KNOWN (decl) = 1;
3249 : 34 : DECL_NOT_REALLY_EXTERN (decl) = 1;
3250 : : }
3251 : 92266 : DECL_THIS_STATIC (decl) = DECL_THIS_STATIC (tmpl_func);
3252 : 92266 : if (DECL_VISIBILITY_SPECIFIED (tmpl_func))
3253 : : {
3254 : 39 : DECL_VISIBILITY_SPECIFIED (decl) = 1;
3255 : 39 : DECL_VISIBILITY (decl) = DECL_VISIBILITY (tmpl_func);
3256 : : }
3257 : : }
3258 : :
3259 : : /* If DECL is a friend declaration, declared using an
3260 : : unqualified name, the namespace associated with DECL may
3261 : : have been set incorrectly. For example, in:
3262 : :
3263 : : template <typename T> void f(T);
3264 : : namespace N {
3265 : : struct S { friend void f<int>(int); }
3266 : : }
3267 : :
3268 : : we will have set the DECL_CONTEXT for the friend
3269 : : declaration to N, rather than to the global namespace. */
3270 : 1427619 : if (DECL_NAMESPACE_SCOPE_P (decl))
3271 : 955615 : DECL_CONTEXT (decl) = DECL_CONTEXT (tmpl);
3272 : :
3273 : 1427619 : if (is_friend && !have_def)
3274 : : /* This is not really a declaration of a specialization.
3275 : : It's just the name of an instantiation. But, it's not
3276 : : a request for an instantiation, either. */
3277 : 57 : SET_DECL_IMPLICIT_INSTANTIATION (decl);
3278 : 1427562 : else if (TREE_CODE (decl) == FUNCTION_DECL)
3279 : : /* A specialization is not necessarily COMDAT. */
3280 : 564027 : DECL_COMDAT (decl) = (TREE_PUBLIC (decl)
3281 : 564027 : && DECL_DECLARED_INLINE_P (decl));
3282 : 863535 : else if (VAR_P (decl))
3283 : 863535 : DECL_COMDAT (decl) = false;
3284 : :
3285 : : /* If this is a full specialization, register it so that we can find
3286 : : it again. Partial specializations will be registered in
3287 : : process_partial_specialization. */
3288 : 1427619 : if (!processing_template_decl)
3289 : : {
3290 : 849133 : warn_spec_missing_attributes (gen_tmpl, decl, attrlist);
3291 : :
3292 : 849133 : decl = register_specialization (decl, gen_tmpl, targs,
3293 : : is_friend, 0);
3294 : : }
3295 : :
3296 : : /* If this is a specialization, splice any contracts that may have
3297 : : been inherited from the template, removing them. */
3298 : 1427619 : if (decl != error_mark_node && DECL_TEMPLATE_SPECIALIZATION (decl))
3299 : 1427536 : remove_contract_attributes (decl);
3300 : :
3301 : : /* A 'structor should already have clones. */
3302 : 1991680 : gcc_assert (decl == error_mark_node
3303 : : || variable_template_p (tmpl)
3304 : : || !(DECL_CONSTRUCTOR_P (decl)
3305 : : || DECL_DESTRUCTOR_P (decl))
3306 : : || DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl)));
3307 : : }
3308 : : }
3309 : :
3310 : : return decl;
3311 : : }
3312 : :
3313 : : /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
3314 : : parameters. These are represented in the same format used for
3315 : : DECL_TEMPLATE_PARMS. */
3316 : :
3317 : : int
3318 : 149082337 : comp_template_parms (const_tree parms1, const_tree parms2)
3319 : : {
3320 : 149082337 : if (parms1 == parms2)
3321 : : return 1;
3322 : :
3323 : 148576861 : tree t1 = TREE_VALUE (parms1);
3324 : 148576861 : tree t2 = TREE_VALUE (parms2);
3325 : 148576861 : int i;
3326 : :
3327 : 148576861 : gcc_assert (TREE_CODE (t1) == TREE_VEC);
3328 : 148576861 : gcc_assert (TREE_CODE (t2) == TREE_VEC);
3329 : :
3330 : 148576861 : if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2))
3331 : : return 0;
3332 : :
3333 : 156804331 : for (i = 0; i < TREE_VEC_LENGTH (t2); ++i)
3334 : : {
3335 : 124949848 : tree parm1 = TREE_VALUE (TREE_VEC_ELT (t1, i));
3336 : 124949848 : tree parm2 = TREE_VALUE (TREE_VEC_ELT (t2, i));
3337 : :
3338 : : /* If either of the template parameters are invalid, assume
3339 : : they match for the sake of error recovery. */
3340 : 124949848 : if (error_operand_p (parm1) || error_operand_p (parm2))
3341 : : return 1;
3342 : :
3343 : 124949824 : if (TREE_CODE (parm1) != TREE_CODE (parm2))
3344 : : return 0;
3345 : :
3346 : 215891739 : if (TREE_CODE (parm1) == TYPE_DECL
3347 : 121813686 : && (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm1))
3348 : 102081182 : == TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm2))))
3349 : 94078053 : continue;
3350 : 27735633 : else if (!same_type_p (TREE_TYPE (parm1), TREE_TYPE (parm2)))
3351 : : return 0;
3352 : : }
3353 : :
3354 : : return 1;
3355 : : }
3356 : :
3357 : : /* Returns true if two template parameters are declared with
3358 : : equivalent constraints. */
3359 : :
3360 : : static bool
3361 : 215719456 : template_parameter_constraints_equivalent_p (const_tree parm1, const_tree parm2)
3362 : : {
3363 : 215719456 : tree req1 = TREE_TYPE (parm1);
3364 : 215719456 : tree req2 = TREE_TYPE (parm2);
3365 : 215719456 : if (!req1 != !req2)
3366 : : return false;
3367 : 215239811 : if (req1)
3368 : 234719 : return cp_tree_equal (req1, req2);
3369 : : return true;
3370 : : }
3371 : :
3372 : : /* Returns true when two template parameters are equivalent. */
3373 : :
3374 : : static bool
3375 : 239677423 : template_parameters_equivalent_p (const_tree parm1, const_tree parm2)
3376 : : {
3377 : 239677423 : tree decl1 = TREE_VALUE (parm1);
3378 : 239677423 : tree decl2 = TREE_VALUE (parm2);
3379 : :
3380 : : /* If either of the template parameters are invalid, assume
3381 : : they match for the sake of error recovery. */
3382 : 239677423 : if (error_operand_p (decl1) || error_operand_p (decl2))
3383 : : return true;
3384 : :
3385 : : /* ... they declare parameters of the same kind. */
3386 : 239677420 : if (TREE_CODE (decl1) != TREE_CODE (decl2))
3387 : : return false;
3388 : :
3389 : : /* ... one parameter was introduced by a parameter declaration, then
3390 : : both are. This case arises as a result of eagerly rewriting declarations
3391 : : during parsing. */
3392 : 228496261 : if (DECL_IMPLICIT_TEMPLATE_PARM_P (decl1)
3393 : 228496261 : != DECL_IMPLICIT_TEMPLATE_PARM_P (decl2))
3394 : : return false;
3395 : :
3396 : : /* ... if either declares a pack, they both do. */
3397 : 228496037 : if (template_parameter_pack_p (decl1) != template_parameter_pack_p (decl2))
3398 : : return false;
3399 : :
3400 : 212368158 : if (TREE_CODE (decl1) == PARM_DECL)
3401 : : {
3402 : : /* ... if they declare non-type parameters, the types are equivalent. */
3403 : 2802764 : if (!same_type_p (TREE_TYPE (decl1), TREE_TYPE (decl2)))
3404 : : return false;
3405 : : }
3406 : 209565394 : else if (TREE_CODE (decl2) == TEMPLATE_DECL)
3407 : : {
3408 : : /* ... if they declare template template parameters, their template
3409 : : parameter lists are equivalent. */
3410 : 19655 : if (!template_heads_equivalent_p (decl1, decl2))
3411 : : return false;
3412 : : }
3413 : :
3414 : : /* ... if they are declared with a qualified-concept name, they both
3415 : : are, and those names are equivalent. */
3416 : 212174369 : return template_parameter_constraints_equivalent_p (parm1, parm2);
3417 : : }
3418 : :
3419 : : /* Returns true if two template parameters lists are equivalent.
3420 : : Two template parameter lists are equivalent if they have the
3421 : : same length and their corresponding parameters are equivalent.
3422 : :
3423 : : PARMS1 and PARMS2 are TREE_LISTs containing TREE_VECs: the
3424 : : data structure returned by DECL_TEMPLATE_PARMS.
3425 : :
3426 : : This is generally the same implementation as comp_template_parms
3427 : : except that it also the concept names and arguments used to
3428 : : introduce parameters. */
3429 : :
3430 : : static bool
3431 : 379950923 : template_parameter_lists_equivalent_p (const_tree parms1, const_tree parms2)
3432 : : {
3433 : 379950923 : if (parms1 == parms2)
3434 : : return true;
3435 : :
3436 : 379950923 : tree list1 = TREE_VALUE (parms1);
3437 : 379950923 : tree list2 = TREE_VALUE (parms2);
3438 : :
3439 : 379950923 : if (TREE_VEC_LENGTH (list1) != TREE_VEC_LENGTH (list2))
3440 : : return 0;
3441 : :
3442 : 358093917 : for (int i = 0; i < TREE_VEC_LENGTH (list2); ++i)
3443 : : {
3444 : 239677423 : tree parm1 = TREE_VEC_ELT (list1, i);
3445 : 239677423 : tree parm2 = TREE_VEC_ELT (list2, i);
3446 : 239677423 : if (!template_parameters_equivalent_p (parm1, parm2))
3447 : : return false;
3448 : : }
3449 : :
3450 : : return true;
3451 : : }
3452 : :
3453 : : /* Return true if the requires-clause of the template parameter lists are
3454 : : equivalent and false otherwise. */
3455 : : static bool
3456 : 132920575 : template_requirements_equivalent_p (const_tree parms1, const_tree parms2)
3457 : : {
3458 : 132920575 : tree req1 = TEMPLATE_PARMS_CONSTRAINTS (parms1);
3459 : 132920575 : tree req2 = TEMPLATE_PARMS_CONSTRAINTS (parms2);
3460 : 132920575 : if ((req1 != NULL_TREE) != (req2 != NULL_TREE))
3461 : : return false;
3462 : 119504141 : if (!cp_tree_equal (req1, req2))
3463 : : return false;
3464 : : return true;
3465 : : }
3466 : :
3467 : : /* Returns true if two template heads are equivalent. 17.6.6.1p6:
3468 : : Two template heads are equivalent if their template parameter
3469 : : lists are equivalent and their requires clauses are equivalent.
3470 : :
3471 : : In pre-C++20, this is equivalent to calling comp_template_parms
3472 : : for the template parameters of TMPL1 and TMPL2. */
3473 : :
3474 : : bool
3475 : 379950923 : template_heads_equivalent_p (const_tree tmpl1, const_tree tmpl2)
3476 : : {
3477 : 379950923 : tree parms1 = DECL_TEMPLATE_PARMS (tmpl1);
3478 : 379950923 : tree parms2 = DECL_TEMPLATE_PARMS (tmpl2);
3479 : :
3480 : : /* ... have the same number of template parameters, and their
3481 : : corresponding parameters are equivalent. */
3482 : 379950923 : if (!template_parameter_lists_equivalent_p (parms1, parms2))
3483 : : return false;
3484 : :
3485 : : /* ... if either has a requires-clause, they both do and their
3486 : : corresponding constraint-expressions are equivalent. */
3487 : 118416494 : return template_requirements_equivalent_p (parms1, parms2);
3488 : : }
3489 : :
3490 : : /* Determine whether PARM is a parameter pack. */
3491 : :
3492 : : bool
3493 : 3543149477 : template_parameter_pack_p (const_tree parm)
3494 : : {
3495 : : /* Determine if we have a non-type template parameter pack. */
3496 : 3543149477 : if (TREE_CODE (parm) == PARM_DECL)
3497 : 419907382 : return (DECL_TEMPLATE_PARM_P (parm)
3498 : 419907382 : && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)));
3499 : 3123242095 : if (TREE_CODE (parm) == TEMPLATE_PARM_INDEX)
3500 : 1345695 : return TEMPLATE_PARM_PARAMETER_PACK (parm);
3501 : :
3502 : : /* If this is a list of template parameters, we could get a
3503 : : TYPE_DECL or a TEMPLATE_DECL. */
3504 : 3121896400 : if (TREE_CODE (parm) == TYPE_DECL || TREE_CODE (parm) == TEMPLATE_DECL)
3505 : 2966591649 : parm = TREE_TYPE (parm);
3506 : :
3507 : : /* Otherwise it must be a type template parameter. */
3508 : 3121896400 : return ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
3509 : 3121896400 : || TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM)
3510 : 3121896400 : && TEMPLATE_TYPE_PARAMETER_PACK (parm));
3511 : : }
3512 : :
3513 : : /* Determine if T is a function parameter pack. */
3514 : :
3515 : : bool
3516 : 1425431 : function_parameter_pack_p (const_tree t)
3517 : : {
3518 : 1425431 : if (t && TREE_CODE (t) == PARM_DECL)
3519 : 1425431 : return DECL_PACK_P (t);
3520 : : return false;
3521 : : }
3522 : :
3523 : : /* Return the function template declaration of PRIMARY_FUNC_TMPL_INST.
3524 : : PRIMARY_FUNC_TMPL_INST is a primary function template instantiation. */
3525 : :
3526 : : tree
3527 : 1623876 : get_function_template_decl (const_tree primary_func_tmpl_inst)
3528 : : {
3529 : 1623876 : if (! primary_func_tmpl_inst
3530 : 1623876 : || TREE_CODE (primary_func_tmpl_inst) != FUNCTION_DECL
3531 : 3247752 : || ! primary_template_specialization_p (primary_func_tmpl_inst))
3532 : 1217979 : return NULL;
3533 : :
3534 : 405897 : return DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (primary_func_tmpl_inst));
3535 : : }
3536 : :
3537 : : /* Return true iff the function parameter PARAM_DECL was expanded
3538 : : from the function parameter pack PACK. */
3539 : :
3540 : : bool
3541 : 399118 : function_parameter_expanded_from_pack_p (tree param_decl, tree pack)
3542 : : {
3543 : 399118 : if (DECL_ARTIFICIAL (param_decl)
3544 : 399118 : || !function_parameter_pack_p (pack))
3545 : 0 : return false;
3546 : :
3547 : : /* The parameter pack and its pack arguments have the same
3548 : : DECL_PARM_INDEX. */
3549 : 399118 : return DECL_PARM_INDEX (pack) == DECL_PARM_INDEX (param_decl);
3550 : : }
3551 : :
3552 : : /* Determine whether ARGS describes a variadic template args list,
3553 : : i.e., one that is terminated by a template argument pack. */
3554 : :
3555 : : static bool
3556 : 8 : template_args_variadic_p (tree args)
3557 : : {
3558 : 8 : int nargs;
3559 : 8 : tree last_parm;
3560 : :
3561 : 8 : if (args == NULL_TREE)
3562 : : return false;
3563 : :
3564 : 8 : args = INNERMOST_TEMPLATE_ARGS (args);
3565 : 8 : nargs = TREE_VEC_LENGTH (args);
3566 : :
3567 : 8 : if (nargs == 0)
3568 : : return false;
3569 : :
3570 : 8 : last_parm = TREE_VEC_ELT (args, nargs - 1);
3571 : :
3572 : 8 : return ARGUMENT_PACK_P (last_parm);
3573 : : }
3574 : :
3575 : : /* Generate a new name for the parameter pack name NAME (an
3576 : : IDENTIFIER_NODE) that incorporates its */
3577 : :
3578 : : static tree
3579 : 818758 : make_ith_pack_parameter_name (tree name, int i)
3580 : : {
3581 : : /* Munge the name to include the parameter index. */
3582 : : #define NUMBUF_LEN 128
3583 : 818758 : char numbuf[NUMBUF_LEN];
3584 : 818758 : char* newname;
3585 : 818758 : int newname_len;
3586 : :
3587 : 818758 : if (name == NULL_TREE)
3588 : : return name;
3589 : 815561 : snprintf (numbuf, NUMBUF_LEN, "%i", i);
3590 : 815561 : newname_len = IDENTIFIER_LENGTH (name)
3591 : 815561 : + strlen (numbuf) + 2;
3592 : 815561 : newname = (char*)alloca (newname_len);
3593 : 815561 : snprintf (newname, newname_len,
3594 : 815561 : "%s#%i", IDENTIFIER_POINTER (name), i);
3595 : 815561 : return get_identifier (newname);
3596 : : }
3597 : :
3598 : : /* Return true if T is a primary function, class or alias template
3599 : : specialization, not including the template pattern. */
3600 : :
3601 : : bool
3602 : 124867656 : primary_template_specialization_p (const_tree t)
3603 : : {
3604 : 124867656 : if (!t)
3605 : : return false;
3606 : :
3607 : 124867656 : if (VAR_OR_FUNCTION_DECL_P (t))
3608 : 66813008 : return (DECL_LANG_SPECIFIC (t)
3609 : 66812920 : && DECL_USE_TEMPLATE (t)
3610 : 63045739 : && DECL_TEMPLATE_INFO (t)
3611 : 129858747 : && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t)));
3612 : 58054648 : else if (CLASS_TYPE_P (t) && !TYPE_DECL_ALIAS_P (TYPE_NAME (t)))
3613 : 58054648 : return (CLASSTYPE_TEMPLATE_INFO (t)
3614 : 58054648 : && CLASSTYPE_USE_TEMPLATE (t)
3615 : 116109296 : && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)));
3616 : 0 : else if (alias_template_specialization_p (t, nt_transparent))
3617 : : return true;
3618 : : return false;
3619 : : }
3620 : :
3621 : : /* Return true if PARM is a template template parameter. */
3622 : :
3623 : : bool
3624 : 40069955 : template_template_parameter_p (const_tree parm)
3625 : : {
3626 : 40069955 : return DECL_TEMPLATE_TEMPLATE_PARM_P (parm);
3627 : : }
3628 : :
3629 : : /* Return true iff PARM is a DECL representing a type template
3630 : : parameter. */
3631 : :
3632 : : bool
3633 : 1313871863 : template_type_parameter_p (const_tree parm)
3634 : : {
3635 : 1313871863 : return (parm
3636 : 1313871863 : && (TREE_CODE (parm) == TYPE_DECL
3637 : 637242601 : || TREE_CODE (parm) == TEMPLATE_DECL)
3638 : 1990655814 : && DECL_TEMPLATE_PARM_P (parm));
3639 : : }
3640 : :
3641 : : /* Return the template parameters of T if T is a
3642 : : primary template instantiation, NULL otherwise. */
3643 : :
3644 : : tree
3645 : 138927133 : get_primary_template_innermost_parameters (const_tree t)
3646 : : {
3647 : 138927133 : tree parms = NULL, template_info = NULL;
3648 : :
3649 : 138927133 : if ((template_info = get_template_info (t))
3650 : 138927133 : && primary_template_specialization_p (t))
3651 : 58119528 : parms = INNERMOST_TEMPLATE_PARMS
3652 : : (DECL_TEMPLATE_PARMS (TI_TEMPLATE (template_info)));
3653 : :
3654 : 138927133 : return parms;
3655 : : }
3656 : :
3657 : : /* Returns the template arguments of T if T is a template instantiation,
3658 : : NULL otherwise. */
3659 : :
3660 : : tree
3661 : 27782462 : get_template_innermost_arguments (const_tree t)
3662 : : {
3663 : 27782462 : tree args = NULL, template_info = NULL;
3664 : :
3665 : 27782462 : if ((template_info = get_template_info (t))
3666 : 55564924 : && TI_ARGS (template_info))
3667 : 27782462 : args = INNERMOST_TEMPLATE_ARGS (TI_ARGS (template_info));
3668 : :
3669 : 27782462 : return args;
3670 : : }
3671 : :
3672 : : /* Return the argument pack elements of T if T is a template argument pack,
3673 : : NULL otherwise. */
3674 : :
3675 : : tree
3676 : 42833003 : get_template_argument_pack_elems (const_tree t)
3677 : : {
3678 : 42833003 : if (TREE_CODE (t) != TYPE_ARGUMENT_PACK
3679 : 42833003 : && TREE_CODE (t) != NONTYPE_ARGUMENT_PACK)
3680 : : return NULL;
3681 : :
3682 : 4299273 : return ARGUMENT_PACK_ARGS (t);
3683 : : }
3684 : :
3685 : : /* In an ARGUMENT_PACK_SELECT, the actual underlying argument that the
3686 : : ARGUMENT_PACK_SELECT represents. */
3687 : :
3688 : : static tree
3689 : 10600050 : argument_pack_select_arg (tree t)
3690 : : {
3691 : 10600050 : tree args = ARGUMENT_PACK_ARGS (ARGUMENT_PACK_SELECT_FROM_PACK (t));
3692 : 10600050 : tree arg = TREE_VEC_ELT (args, ARGUMENT_PACK_SELECT_INDEX (t));
3693 : :
3694 : : /* If the selected argument is an expansion E, that most likely means we were
3695 : : called from gen_elem_of_pack_expansion_instantiation during the
3696 : : substituting of an argument pack (of which the Ith element is a pack
3697 : : expansion, where I is ARGUMENT_PACK_SELECT_INDEX) into a pack expansion.
3698 : : In this case, the Ith element resulting from this substituting is going to
3699 : : be a pack expansion, which pattern is the pattern of E. Let's return the
3700 : : pattern of E, and gen_elem_of_pack_expansion_instantiation will build the
3701 : : resulting pack expansion from it. */
3702 : 10600050 : if (PACK_EXPANSION_P (arg))
3703 : : {
3704 : : /* Make sure we aren't throwing away arg info. */
3705 : 435608 : gcc_assert (!PACK_EXPANSION_EXTRA_ARGS (arg));
3706 : 435608 : arg = PACK_EXPANSION_PATTERN (arg);
3707 : : }
3708 : :
3709 : 10600050 : return arg;
3710 : : }
3711 : :
3712 : : /* Return a modification of ARGS that's suitable for preserving inside a hash
3713 : : table. In particular, this replaces each ARGUMENT_PACK_SELECT with its
3714 : : underlying argument. ARGS is copied (upon modification) iff COW_P. */
3715 : :
3716 : : static tree
3717 : 311133 : preserve_args (tree args, bool cow_p = true)
3718 : : {
3719 : 311133 : if (!args)
3720 : : return NULL_TREE;
3721 : :
3722 : 833525 : for (int i = 0, len = TREE_VEC_LENGTH (args); i < len; ++i)
3723 : : {
3724 : 522398 : tree t = TREE_VEC_ELT (args, i);
3725 : 522398 : tree r;
3726 : 522398 : if (!t)
3727 : : r = NULL_TREE;
3728 : 522340 : else if (TREE_CODE (t) == ARGUMENT_PACK_SELECT)
3729 : 69 : r = argument_pack_select_arg (t);
3730 : 522271 : else if (TREE_CODE (t) == TREE_VEC)
3731 : 90466 : r = preserve_args (t, cow_p);
3732 : : else
3733 : : r = t;
3734 : 522340 : if (r != t)
3735 : : {
3736 : 69 : if (cow_p)
3737 : : {
3738 : 63 : args = copy_template_args (args);
3739 : 63 : cow_p = false;
3740 : : }
3741 : 69 : TREE_VEC_ELT (args, i) = r;
3742 : : }
3743 : : }
3744 : :
3745 : : return args;
3746 : : }
3747 : :
3748 : : /* True iff FN is a function representing a built-in variadic parameter
3749 : : pack. */
3750 : :
3751 : : bool
3752 : 287477990 : builtin_pack_fn_p (tree fn)
3753 : : {
3754 : 287477990 : if (!fn
3755 : 287450684 : || TREE_CODE (fn) != FUNCTION_DECL
3756 : 379381666 : || !DECL_IS_UNDECLARED_BUILTIN (fn))
3757 : : return false;
3758 : :
3759 : 9772410 : if (id_equal (DECL_NAME (fn), "__integer_pack"))
3760 : : return true;
3761 : :
3762 : : return false;
3763 : : }
3764 : :
3765 : : /* True iff CALL is a call to a function representing a built-in variadic
3766 : : parameter pack. */
3767 : :
3768 : : static bool
3769 : 271941067 : builtin_pack_call_p (tree call)
3770 : : {
3771 : 271941067 : if (TREE_CODE (call) != CALL_EXPR)
3772 : : return false;
3773 : 205285731 : return builtin_pack_fn_p (CALL_EXPR_FN (call));
3774 : : }
3775 : :
3776 : : /* Return a TREE_VEC for the expansion of __integer_pack(HI). */
3777 : :
3778 : : static tree
3779 : 106885 : expand_integer_pack (tree call, tree args, tsubst_flags_t complain,
3780 : : tree in_decl)
3781 : : {
3782 : 106885 : tree ohi = CALL_EXPR_ARG (call, 0);
3783 : 106885 : tree hi = tsubst_expr (ohi, args, complain, in_decl);
3784 : :
3785 : 106885 : if (instantiation_dependent_expression_p (hi))
3786 : : {
3787 : 105507 : if (hi != ohi)
3788 : : {
3789 : 105507 : call = copy_node (call);
3790 : 105507 : CALL_EXPR_ARG (call, 0) = hi;
3791 : : }
3792 : 105507 : tree ex = make_pack_expansion (call, complain);
3793 : 105507 : tree vec = make_tree_vec (1);
3794 : 105507 : TREE_VEC_ELT (vec, 0) = ex;
3795 : 105507 : return vec;
3796 : : }
3797 : : else
3798 : : {
3799 : 1378 : hi = instantiate_non_dependent_expr (hi, complain);
3800 : 1378 : hi = cxx_constant_value (hi, complain);
3801 : 1378 : int len = valid_constant_size_p (hi) ? tree_to_shwi (hi) : -1;
3802 : :
3803 : : /* Calculate the largest value of len that won't make the size of the vec
3804 : : overflow an int. The compiler will exceed resource limits long before
3805 : : this, but it seems a decent place to diagnose. */
3806 : 1378 : int max = ((INT_MAX - sizeof (tree_vec)) / sizeof (tree)) + 1;
3807 : :
3808 : 1378 : if (len < 0 || len > max)
3809 : : {
3810 : 12 : if ((complain & tf_error)
3811 : 9 : && hi != error_mark_node)
3812 : 9 : error ("argument to %<__integer_pack%> must be between 0 and %d",
3813 : : max);
3814 : 12 : return error_mark_node;
3815 : : }
3816 : :
3817 : 1366 : tree vec = make_tree_vec (len);
3818 : :
3819 : 6908 : for (int i = 0; i < len; ++i)
3820 : 5542 : TREE_VEC_ELT (vec, i) = size_int (i);
3821 : :
3822 : : return vec;
3823 : : }
3824 : : }
3825 : :
3826 : : /* Return a TREE_VEC for the expansion of built-in template parameter pack
3827 : : CALL. */
3828 : :
3829 : : static tree
3830 : 106885 : expand_builtin_pack_call (tree call, tree args, tsubst_flags_t complain,
3831 : : tree in_decl)
3832 : : {
3833 : 106885 : if (!builtin_pack_call_p (call))
3834 : : return NULL_TREE;
3835 : :
3836 : 106885 : tree fn = CALL_EXPR_FN (call);
3837 : :
3838 : 106885 : if (id_equal (DECL_NAME (fn), "__integer_pack"))
3839 : 106885 : return expand_integer_pack (call, args, complain, in_decl);
3840 : :
3841 : : return NULL_TREE;
3842 : : }
3843 : :
3844 : : /* Return true if the tree T has the extra args mechanism for
3845 : : avoiding partial instantiation. */
3846 : :
3847 : : static bool
3848 : 6276785570 : has_extra_args_mechanism_p (const_tree t)
3849 : : {
3850 : 6276785570 : return (PACK_EXPANSION_P (t) /* PACK_EXPANSION_EXTRA_ARGS */
3851 : 6243545597 : || TREE_CODE (t) == REQUIRES_EXPR /* REQUIRES_EXPR_EXTRA_ARGS */
3852 : 6242917938 : || (TREE_CODE (t) == IF_STMT
3853 : 507750 : && IF_STMT_CONSTEXPR_P (t)) /* IF_STMT_EXTRA_ARGS */
3854 : 12519498274 : || TREE_CODE (t) == LAMBDA_EXPR); /* LAMBDA_EXPR_EXTRA_ARGS */
3855 : : }
3856 : :
3857 : : /* Return *_EXTRA_ARGS of the given supported tree T. */
3858 : :
3859 : : static tree&
3860 : 24375 : tree_extra_args (tree t)
3861 : : {
3862 : 24375 : gcc_checking_assert (has_extra_args_mechanism_p (t));
3863 : :
3864 : 24375 : if (PACK_EXPANSION_P (t))
3865 : 587 : return PACK_EXPANSION_EXTRA_ARGS (t);
3866 : 23788 : else if (TREE_CODE (t) == REQUIRES_EXPR)
3867 : 1169 : return REQUIRES_EXPR_EXTRA_ARGS (t);
3868 : 22619 : else if (TREE_CODE (t) == IF_STMT
3869 : 22619 : && IF_STMT_CONSTEXPR_P (t))
3870 : 22428 : return IF_STMT_EXTRA_ARGS (t);
3871 : 191 : else if (TREE_CODE (t) == LAMBDA_EXPR)
3872 : 191 : return LAMBDA_EXPR_EXTRA_ARGS (t);
3873 : :
3874 : 0 : gcc_unreachable ();
3875 : : }
3876 : :
3877 : : /* Structure used to track the progress of find_parameter_packs_r. */
3878 : 1747569197 : struct find_parameter_pack_data
3879 : : {
3880 : : /* TREE_LIST that will contain all of the parameter packs found by
3881 : : the traversal. */
3882 : : tree* parameter_packs;
3883 : :
3884 : : /* Set of AST nodes that have been visited by the traversal. */
3885 : : hash_set<tree> *visited;
3886 : :
3887 : : /* True iff we found a subtree that has the extra args mechanism. */
3888 : : bool found_extra_args_tree_p = false;
3889 : : };
3890 : :
3891 : : /* Identifies all of the argument packs that occur in a template
3892 : : argument and appends them to the TREE_LIST inside DATA, which is a
3893 : : find_parameter_pack_data structure. This is a subroutine of
3894 : : make_pack_expansion and uses_parameter_packs. */
3895 : : static tree
3896 : 6448050785 : find_parameter_packs_r (tree *tp, int *walk_subtrees, void* data)
3897 : : {
3898 : 6448050785 : tree t = *tp;
3899 : 6448050785 : struct find_parameter_pack_data* ppd =
3900 : : (struct find_parameter_pack_data*)data;
3901 : 6448050785 : bool parameter_pack_p = false;
3902 : :
3903 : : #define WALK_SUBTREE(NODE) \
3904 : : cp_walk_tree (&(NODE), &find_parameter_packs_r, \
3905 : : ppd, ppd->visited) \
3906 : :
3907 : : /* Don't look through typedefs; we are interested in whether a
3908 : : parameter pack is actually written in the expression/type we're
3909 : : looking at, not the target type. */
3910 : 6448050785 : if (TYPE_P (t) && typedef_variant_p (t))
3911 : : {
3912 : : /* But do look at arguments for an alias template. */
3913 : 172493528 : if (tree tinfo = TYPE_ALIAS_TEMPLATE_INFO (t))
3914 : 131208353 : cp_walk_tree (&TI_ARGS (tinfo),
3915 : : &find_parameter_packs_r,
3916 : : ppd, ppd->visited);
3917 : 172493528 : *walk_subtrees = 0;
3918 : 172493528 : return NULL_TREE;
3919 : : }
3920 : :
3921 : : /* Identify whether this is a parameter pack or not. */
3922 : 6275557257 : switch (TREE_CODE (t))
3923 : : {
3924 : 64632917 : case TEMPLATE_PARM_INDEX:
3925 : 64632917 : if (TEMPLATE_PARM_PARAMETER_PACK (t))
3926 : : parameter_pack_p = true;
3927 : : break;
3928 : :
3929 : 1075379996 : case TEMPLATE_TYPE_PARM:
3930 : 1075379996 : t = TYPE_MAIN_VARIANT (t);
3931 : : /* FALLTHRU */
3932 : 1076059390 : case TEMPLATE_TEMPLATE_PARM:
3933 : 1076059390 : if (TEMPLATE_TYPE_PARAMETER_PACK (t))
3934 : : parameter_pack_p = true;
3935 : : break;
3936 : :
3937 : 364411918 : case FIELD_DECL:
3938 : 364411918 : case PARM_DECL:
3939 : 364411918 : if (DECL_PACK_P (t))
3940 : : {
3941 : : /* We don't want to walk into the type of a PARM_DECL,
3942 : : because we don't want to see the type parameter pack. */
3943 : 2726077 : *walk_subtrees = 0;
3944 : 2726077 : parameter_pack_p = true;
3945 : : }
3946 : : break;
3947 : :
3948 : 153300364 : case VAR_DECL:
3949 : 153300364 : if (DECL_PACK_P (t))
3950 : : {
3951 : : /* We don't want to walk into the type of a variadic capture proxy,
3952 : : because we don't want to see the type parameter pack. */
3953 : 56 : *walk_subtrees = 0;
3954 : 56 : parameter_pack_p = true;
3955 : : }
3956 : 153300308 : else if (variable_template_specialization_p (t))
3957 : : {
3958 : 64847 : cp_walk_tree (&DECL_TI_ARGS (t),
3959 : : find_parameter_packs_r,
3960 : : ppd, ppd->visited);
3961 : 64847 : *walk_subtrees = 0;
3962 : : }
3963 : : break;
3964 : :
3965 : 205071958 : case CALL_EXPR:
3966 : 205071958 : if (builtin_pack_call_p (t))
3967 : : parameter_pack_p = true;
3968 : : break;
3969 : :
3970 : : case BASES:
3971 : : parameter_pack_p = true;
3972 : : break;
3973 : : default:
3974 : : /* Not a parameter pack. */
3975 : : break;
3976 : : }
3977 : :
3978 : 2790980 : if (parameter_pack_p)
3979 : : {
3980 : : /* Add this parameter pack to the list. */
3981 : 59941605 : *ppd->parameter_packs = tree_cons (NULL_TREE, t, *ppd->parameter_packs);
3982 : : }
3983 : :
3984 : 6275557257 : if (has_extra_args_mechanism_p (t) && !PACK_EXPANSION_P (t))
3985 : 1476943 : ppd->found_extra_args_tree_p = true;
3986 : :
3987 : 6275557257 : if (TYPE_P (t))
3988 : 2062248866 : cp_walk_tree (&TYPE_CONTEXT (t),
3989 : : &find_parameter_packs_r, ppd, ppd->visited);
3990 : :
3991 : : /* This switch statement will return immediately if we don't find a
3992 : : parameter pack. ??? Should some of these be in cp_walk_subtrees? */
3993 : 6275557257 : switch (TREE_CODE (t))
3994 : : {
3995 : 336053 : case BOUND_TEMPLATE_TEMPLATE_PARM:
3996 : : /* Check the template itself. */
3997 : 336053 : cp_walk_tree (&TREE_TYPE (TYPE_TI_TEMPLATE (t)),
3998 : : &find_parameter_packs_r, ppd, ppd->visited);
3999 : 336053 : return NULL_TREE;
4000 : :
4001 : 1181288 : case DECL_EXPR:
4002 : 1181288 : {
4003 : 1181288 : tree decl = DECL_EXPR_DECL (t);
4004 : : /* Ignore the declaration of a capture proxy for a parameter pack. */
4005 : 1181288 : if (is_capture_proxy (decl))
4006 : 873347 : *walk_subtrees = 0;
4007 : 1181288 : if (is_typedef_decl (decl))
4008 : : /* Since we stop at typedefs above, we need to look through them at
4009 : : the point of the DECL_EXPR. */
4010 : 69340 : cp_walk_tree (&DECL_ORIGINAL_TYPE (decl),
4011 : : &find_parameter_packs_r, ppd, ppd->visited);
4012 : : return NULL_TREE;
4013 : : }
4014 : :
4015 : 171999608 : case TEMPLATE_DECL:
4016 : 171999608 : if (!DECL_TEMPLATE_TEMPLATE_PARM_P (t))
4017 : : return NULL_TREE;
4018 : 5839 : cp_walk_tree (&TREE_TYPE (t),
4019 : : &find_parameter_packs_r, ppd, ppd->visited);
4020 : 5839 : return NULL_TREE;
4021 : :
4022 : 33238799 : case TYPE_PACK_EXPANSION:
4023 : 33238799 : case EXPR_PACK_EXPANSION:
4024 : 33238799 : *walk_subtrees = 0;
4025 : 33238799 : return NULL_TREE;
4026 : :
4027 : 27764463 : case INTEGER_TYPE:
4028 : 27764463 : cp_walk_tree (&TYPE_MAX_VALUE (t), &find_parameter_packs_r,
4029 : : ppd, ppd->visited);
4030 : 27764463 : *walk_subtrees = 0;
4031 : 27764463 : return NULL_TREE;
4032 : :
4033 : 189817415 : case IDENTIFIER_NODE:
4034 : 189817415 : cp_walk_tree (&TREE_TYPE (t), &find_parameter_packs_r, ppd,
4035 : : ppd->visited);
4036 : 189817415 : *walk_subtrees = 0;
4037 : 189817415 : return NULL_TREE;
4038 : :
4039 : 691244 : case LAMBDA_EXPR:
4040 : 691244 : {
4041 : : /* Since we defer implicit capture, look in the parms and body. */
4042 : 691244 : tree fn = lambda_function (t);
4043 : 691244 : cp_walk_tree (&TREE_TYPE (fn), &find_parameter_packs_r, ppd,
4044 : : ppd->visited);
4045 : 691244 : cp_walk_tree (&DECL_SAVED_TREE (fn), &find_parameter_packs_r, ppd,
4046 : : ppd->visited);
4047 : 691244 : return NULL_TREE;
4048 : : }
4049 : :
4050 : 5149621 : case DECLTYPE_TYPE:
4051 : 5149621 : cp_walk_tree (&DECLTYPE_TYPE_EXPR (t), &find_parameter_packs_r,
4052 : : ppd, ppd->visited);
4053 : 5149621 : *walk_subtrees = 0;
4054 : 5149621 : return NULL_TREE;
4055 : :
4056 : 451896 : case IF_STMT:
4057 : 451896 : cp_walk_tree (&IF_COND (t), &find_parameter_packs_r,
4058 : : ppd, ppd->visited);
4059 : 451896 : cp_walk_tree (&THEN_CLAUSE (t), &find_parameter_packs_r,
4060 : : ppd, ppd->visited);
4061 : 451896 : cp_walk_tree (&ELSE_CLAUSE (t), &find_parameter_packs_r,
4062 : : ppd, ppd->visited);
4063 : : /* Don't walk into IF_STMT_EXTRA_ARGS. */
4064 : 451896 : *walk_subtrees = 0;
4065 : 451896 : return NULL_TREE;
4066 : :
4067 : 90 : case TAG_DEFN:
4068 : 90 : t = TREE_TYPE (t);
4069 : 90 : if (CLASS_TYPE_P (t))
4070 : : {
4071 : : /* Local class, need to look through the whole definition.
4072 : : TYPE_BINFO might be unset for a partial instantiation. */
4073 : 45 : if (TYPE_BINFO (t))
4074 : 51 : for (tree bb : BINFO_BASE_BINFOS (TYPE_BINFO (t)))
4075 : 9 : cp_walk_tree (&BINFO_TYPE (bb), &find_parameter_packs_r,
4076 : : ppd, ppd->visited);
4077 : : }
4078 : : else
4079 : : /* Enum, look at the values. */
4080 : 165 : for (tree l = TYPE_VALUES (t); l; l = TREE_CHAIN (l))
4081 : 120 : cp_walk_tree (&DECL_INITIAL (TREE_VALUE (l)),
4082 : : &find_parameter_packs_r,
4083 : : ppd, ppd->visited);
4084 : : return NULL_TREE;
4085 : :
4086 : 5906595 : case FUNCTION_TYPE:
4087 : 5906595 : case METHOD_TYPE:
4088 : 5906595 : WALK_SUBTREE (TYPE_RAISES_EXCEPTIONS (t));
4089 : 5906595 : break;
4090 : :
4091 : : default:
4092 : : return NULL_TREE;
4093 : : }
4094 : :
4095 : : #undef WALK_SUBTREE
4096 : :
4097 : 5906595 : return NULL_TREE;
4098 : : }
4099 : :
4100 : : /* Determines if the expression or type T uses any parameter packs. */
4101 : : tree
4102 : 13625774 : uses_parameter_packs (tree t)
4103 : : {
4104 : 13625774 : tree parameter_packs = NULL_TREE;
4105 : 13625774 : struct find_parameter_pack_data ppd;
4106 : 13625774 : ppd.parameter_packs = ¶meter_packs;
4107 : 13625774 : ppd.visited = new hash_set<tree>;
4108 : 13625774 : cp_walk_tree (&t, &find_parameter_packs_r, &ppd, ppd.visited);
4109 : 27251548 : delete ppd.visited;
4110 : 13625774 : return parameter_packs;
4111 : : }
4112 : :
4113 : : /* Turn ARG, which may be an expression, type, or a TREE_LIST
4114 : : representation a base-class initializer into a parameter pack
4115 : : expansion. If all goes well, the resulting node will be an
4116 : : EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
4117 : : respectively. */
4118 : : tree
4119 : 55201016 : make_pack_expansion (tree arg, tsubst_flags_t complain)
4120 : : {
4121 : 55201016 : tree result;
4122 : 55201016 : tree parameter_packs = NULL_TREE;
4123 : 55201016 : bool for_types = false;
4124 : 55201016 : struct find_parameter_pack_data ppd;
4125 : :
4126 : 55201016 : if (!arg || arg == error_mark_node)
4127 : : return arg;
4128 : :
4129 : 55201001 : if (TREE_CODE (arg) == TREE_LIST && TREE_PURPOSE (arg))
4130 : : {
4131 : : /* A TREE_LIST with a non-null TREE_PURPOSE is for a base
4132 : : class initializer. In this case, the TREE_PURPOSE will be a
4133 : : _TYPE node (representing the base class expansion we're
4134 : : initializing) and the TREE_VALUE will be a TREE_LIST
4135 : : containing the initialization arguments.
4136 : :
4137 : : The resulting expansion looks somewhat different from most
4138 : : expansions. Rather than returning just one _EXPANSION, we
4139 : : return a TREE_LIST whose TREE_PURPOSE is a
4140 : : TYPE_PACK_EXPANSION containing the bases that will be
4141 : : initialized. The TREE_VALUE will be identical to the
4142 : : original TREE_VALUE, which is a list of arguments that will
4143 : : be passed to each base. We do not introduce any new pack
4144 : : expansion nodes into the TREE_VALUE (although it is possible
4145 : : that some already exist), because the TREE_PURPOSE and
4146 : : TREE_VALUE all need to be expanded together with the same
4147 : : _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
4148 : : resulting TREE_PURPOSE will mention the parameter packs in
4149 : : both the bases and the arguments to the bases. */
4150 : 33 : tree purpose;
4151 : 33 : tree value;
4152 : 33 : tree parameter_packs = NULL_TREE;
4153 : :
4154 : : /* Determine which parameter packs will be used by the base
4155 : : class expansion. */
4156 : 33 : ppd.visited = new hash_set<tree>;
4157 : 33 : ppd.parameter_packs = ¶meter_packs;
4158 : 33 : gcc_assert (TYPE_P (TREE_PURPOSE (arg)));
4159 : 33 : cp_walk_tree (&TREE_PURPOSE (arg), &find_parameter_packs_r,
4160 : : &ppd, ppd.visited);
4161 : :
4162 : 33 : if (parameter_packs == NULL_TREE)
4163 : : {
4164 : 0 : if (complain & tf_error)
4165 : 0 : error ("base initializer expansion %qT contains no parameter packs",
4166 : : arg);
4167 : 0 : delete ppd.visited;
4168 : 0 : return error_mark_node;
4169 : : }
4170 : :
4171 : 33 : if (TREE_VALUE (arg) != void_type_node)
4172 : : {
4173 : : /* Collect the sets of parameter packs used in each of the
4174 : : initialization arguments. */
4175 : 63 : for (value = TREE_VALUE (arg); value; value = TREE_CHAIN (value))
4176 : : {
4177 : : /* Determine which parameter packs will be expanded in this
4178 : : argument. */
4179 : 36 : cp_walk_tree (&TREE_VALUE (value), &find_parameter_packs_r,
4180 : : &ppd, ppd.visited);
4181 : : }
4182 : : }
4183 : :
4184 : 66 : delete ppd.visited;
4185 : :
4186 : : /* Create the pack expansion type for the base type. */
4187 : 33 : purpose = cxx_make_type (TYPE_PACK_EXPANSION);
4188 : 33 : PACK_EXPANSION_PATTERN (purpose) = TREE_PURPOSE (arg);
4189 : 66 : PACK_EXPANSION_PARAMETER_PACKS (purpose) = parameter_packs;
4190 : 33 : PACK_EXPANSION_LOCAL_P (purpose) = at_function_scope_p ();
4191 : :
4192 : : /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
4193 : : they will rarely be compared to anything. */
4194 : 33 : SET_TYPE_STRUCTURAL_EQUALITY (purpose);
4195 : :
4196 : 33 : return tree_cons (purpose, TREE_VALUE (arg), NULL_TREE);
4197 : : }
4198 : :
4199 : 55200968 : if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
4200 : 48693019 : for_types = true;
4201 : :
4202 : : /* Build the PACK_EXPANSION_* node. */
4203 : 110401936 : result = for_types
4204 : 48693019 : ? cxx_make_type (TYPE_PACK_EXPANSION)
4205 : 6507949 : : make_node (EXPR_PACK_EXPANSION);
4206 : 55200968 : PACK_EXPANSION_PATTERN (result) = arg;
4207 : 55200968 : if (TREE_CODE (result) == EXPR_PACK_EXPANSION)
4208 : : {
4209 : : /* Propagate type and const-expression information. */
4210 : 6507949 : TREE_TYPE (result) = TREE_TYPE (arg);
4211 : 6507949 : TREE_CONSTANT (result) = TREE_CONSTANT (arg);
4212 : : /* Mark this read now, since the expansion might be length 0. */
4213 : 6507949 : mark_exp_read (arg);
4214 : : }
4215 : : else
4216 : : /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
4217 : : they will rarely be compared to anything. */
4218 : 48693019 : SET_TYPE_STRUCTURAL_EQUALITY (result);
4219 : :
4220 : : /* Determine which parameter packs will be expanded. */
4221 : 55200968 : ppd.parameter_packs = ¶meter_packs;
4222 : 55200968 : ppd.visited = new hash_set<tree>;
4223 : 55200968 : cp_walk_tree (&arg, &find_parameter_packs_r, &ppd, ppd.visited);
4224 : 110401936 : delete ppd.visited;
4225 : :
4226 : : /* Make sure we found some parameter packs. */
4227 : 55200968 : if (parameter_packs == NULL_TREE)
4228 : : {
4229 : 67 : if (complain & tf_error)
4230 : : {
4231 : 67 : if (TYPE_P (arg))
4232 : 30 : error ("expansion pattern %qT contains no parameter packs", arg);
4233 : : else
4234 : 37 : error ("expansion pattern %qE contains no parameter packs", arg);
4235 : : }
4236 : 67 : return error_mark_node;
4237 : : }
4238 : 103893890 : PACK_EXPANSION_PARAMETER_PACKS (result) = parameter_packs;
4239 : :
4240 : 55200901 : PACK_EXPANSION_LOCAL_P (result) = at_function_scope_p ();
4241 : 55200901 : if (ppd.found_extra_args_tree_p)
4242 : : /* If the pattern of this pack expansion contains a subtree that has
4243 : : the extra args mechanism for avoiding partial instantiation, then
4244 : : force this pack expansion to also use extra args. Otherwise
4245 : : partial instantiation of this pack expansion may not lower the
4246 : : level of some parameter packs within the pattern, which would
4247 : : confuse tsubst_pack_expansion later (PR101764). */
4248 : 18272 : PACK_EXPANSION_FORCE_EXTRA_ARGS_P (result) = true;
4249 : :
4250 : : return result;
4251 : : }
4252 : :
4253 : : /* Checks T for any "bare" parameter packs, which have not yet been
4254 : : expanded, and issues an error if any are found. This operation can
4255 : : only be done on full expressions or types (e.g., an expression
4256 : : statement, "if" condition, etc.), because we could have expressions like:
4257 : :
4258 : : foo(f(g(h(args)))...)
4259 : :
4260 : : where "args" is a parameter pack. check_for_bare_parameter_packs
4261 : : should not be called for the subexpressions args, h(args),
4262 : : g(h(args)), or f(g(h(args))), because we would produce erroneous
4263 : : error messages.
4264 : :
4265 : : Returns TRUE and emits an error if there were bare parameter packs,
4266 : : returns FALSE otherwise. */
4267 : : bool
4268 : 1678741579 : check_for_bare_parameter_packs (tree t, location_t loc /* = UNKNOWN_LOCATION */)
4269 : : {
4270 : 1678741579 : tree parameter_packs = NULL_TREE;
4271 : 1678741579 : struct find_parameter_pack_data ppd;
4272 : :
4273 : 1678741579 : if (!processing_template_decl || !t || t == error_mark_node)
4274 : : return false;
4275 : :
4276 : 1070782102 : if (TREE_CODE (t) == TYPE_DECL)
4277 : 0 : t = TREE_TYPE (t);
4278 : :
4279 : 1070782102 : ppd.parameter_packs = ¶meter_packs;
4280 : 1070782102 : ppd.visited = new hash_set<tree>;
4281 : 1070782102 : cp_walk_tree (&t, &find_parameter_packs_r, &ppd, ppd.visited);
4282 : 2141564204 : delete ppd.visited;
4283 : :
4284 : 1070782102 : if (!parameter_packs)
4285 : : return false;
4286 : :
4287 : 352 : if (loc == UNKNOWN_LOCATION)
4288 : 346 : loc = cp_expr_loc_or_input_loc (t);
4289 : :
4290 : : /* It's OK for a lambda to have an unexpanded parameter pack from the
4291 : : containing context, but do complain about unexpanded capture packs. */
4292 : 352 : tree lam = current_lambda_expr ();
4293 : 352 : if (lam)
4294 : 90 : lam = TREE_TYPE (lam);
4295 : :
4296 : 90 : if (lam && lam != current_class_type)
4297 : : {
4298 : : /* We're in a lambda, but it isn't the innermost class.
4299 : : This should work, but currently doesn't. */
4300 : 9 : sorry_at (loc, "unexpanded parameter pack in local class in lambda");
4301 : 9 : return true;
4302 : : }
4303 : :
4304 : 343 : if (lam && CLASSTYPE_TEMPLATE_INFO (lam))
4305 : 149 : for (; parameter_packs;
4306 : 71 : parameter_packs = TREE_CHAIN (parameter_packs))
4307 : : {
4308 : 78 : tree pack = TREE_VALUE (parameter_packs);
4309 : 78 : if (is_capture_proxy (pack)
4310 : 78 : || (TREE_CODE (pack) == PARM_DECL
4311 : 18 : && DECL_CONTEXT (DECL_CONTEXT (pack)) == lam))
4312 : : break;
4313 : : }
4314 : :
4315 : 343 : if (parameter_packs)
4316 : : {
4317 : 272 : auto_diagnostic_group d;
4318 : 272 : error_at (loc, "parameter packs not expanded with %<...%>:");
4319 : 816 : while (parameter_packs)
4320 : : {
4321 : 272 : tree pack = TREE_VALUE (parameter_packs);
4322 : 272 : tree name = NULL_TREE;
4323 : :
4324 : 272 : if (TREE_CODE (pack) == TEMPLATE_TYPE_PARM
4325 : 272 : || TREE_CODE (pack) == TEMPLATE_TEMPLATE_PARM)
4326 : 202 : name = TYPE_NAME (pack);
4327 : 70 : else if (TREE_CODE (pack) == TEMPLATE_PARM_INDEX)
4328 : 39 : name = DECL_NAME (TEMPLATE_PARM_DECL (pack));
4329 : 31 : else if (TREE_CODE (pack) == CALL_EXPR)
4330 : 3 : name = DECL_NAME (CALL_EXPR_FN (pack));
4331 : : else
4332 : 28 : name = DECL_NAME (pack);
4333 : :
4334 : 272 : if (name)
4335 : 272 : inform (loc, " %qD", name);
4336 : : else
4337 : 0 : inform (loc, " %s", "<anonymous>");
4338 : :
4339 : 272 : parameter_packs = TREE_CHAIN (parameter_packs);
4340 : : }
4341 : :
4342 : 272 : return true;
4343 : 272 : }
4344 : :
4345 : : return false;
4346 : : }
4347 : :
4348 : : /* Expand any parameter packs that occur in the template arguments in
4349 : : ARGS. */
4350 : : tree
4351 : 589189907 : expand_template_argument_pack (tree args)
4352 : : {
4353 : 589189907 : if (args == error_mark_node)
4354 : : return error_mark_node;
4355 : :
4356 : 589189886 : tree result_args = NULL_TREE;
4357 : 1178379772 : int in_arg, out_arg = 0, nargs = args ? TREE_VEC_LENGTH (args) : 0;
4358 : 589189886 : int num_result_args = -1;
4359 : 589189886 : int non_default_args_count = -1;
4360 : :
4361 : : /* First, determine if we need to expand anything, and the number of
4362 : : slots we'll need. */
4363 : 1544255100 : for (in_arg = 0; in_arg < nargs; ++in_arg)
4364 : : {
4365 : 955065247 : tree arg = TREE_VEC_ELT (args, in_arg);
4366 : 955065247 : if (arg == NULL_TREE)
4367 : : return args;
4368 : 955065214 : if (ARGUMENT_PACK_P (arg))
4369 : : {
4370 : 55921635 : int num_packed = TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg));
4371 : 55921635 : if (num_result_args < 0)
4372 : 55921635 : num_result_args = in_arg + num_packed;
4373 : : else
4374 : 0 : num_result_args += num_packed;
4375 : : }
4376 : : else
4377 : : {
4378 : 899143579 : if (num_result_args >= 0)
4379 : 0 : num_result_args++;
4380 : : }
4381 : : }
4382 : :
4383 : : /* If no expansion is necessary, we're done. */
4384 : 589189853 : if (num_result_args < 0)
4385 : : return args;
4386 : :
4387 : : /* Expand arguments. */
4388 : 55921635 : result_args = make_tree_vec (num_result_args);
4389 : 55921635 : if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (args))
4390 : 54901698 : non_default_args_count =
4391 : 54901698 : GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args);
4392 : 133946856 : for (in_arg = 0; in_arg < nargs; ++in_arg)
4393 : : {
4394 : 78025221 : tree arg = TREE_VEC_ELT (args, in_arg);
4395 : 78025221 : if (ARGUMENT_PACK_P (arg))
4396 : : {
4397 : 55921635 : tree packed = ARGUMENT_PACK_ARGS (arg);
4398 : 55921635 : int i, num_packed = TREE_VEC_LENGTH (packed);
4399 : 157317980 : for (i = 0; i < num_packed; ++i, ++out_arg)
4400 : 101396345 : TREE_VEC_ELT (result_args, out_arg) = TREE_VEC_ELT(packed, i);
4401 : 55921635 : if (non_default_args_count > 0)
4402 : 54901694 : non_default_args_count += num_packed - 1;
4403 : : }
4404 : : else
4405 : : {
4406 : 22103586 : TREE_VEC_ELT (result_args, out_arg) = arg;
4407 : 22103586 : ++out_arg;
4408 : : }
4409 : : }
4410 : 55921635 : if (non_default_args_count >= 0)
4411 : 54901698 : SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (result_args, non_default_args_count);
4412 : : return result_args;
4413 : : }
4414 : :
4415 : : /* Checks if DECL shadows a template parameter.
4416 : :
4417 : : [temp.local]: A template-parameter shall not be redeclared within its
4418 : : scope (including nested scopes).
4419 : :
4420 : : Emits an error and returns TRUE if the DECL shadows a parameter,
4421 : : returns FALSE otherwise. */
4422 : :
4423 : : bool
4424 : 1548266142 : check_template_shadow (tree decl)
4425 : : {
4426 : 1548266142 : tree olddecl;
4427 : :
4428 : : /* If we're not in a template, we can't possibly shadow a template
4429 : : parameter. */
4430 : 1548266142 : if (!current_template_parms)
4431 : : return true;
4432 : :
4433 : : /* Figure out what we're shadowing. */
4434 : 779782222 : decl = OVL_FIRST (decl);
4435 : 779782222 : olddecl = innermost_non_namespace_value (DECL_NAME (decl));
4436 : :
4437 : : /* If there's no previous binding for this name, we're not shadowing
4438 : : anything, let alone a template parameter. */
4439 : 779782222 : if (!olddecl)
4440 : : return true;
4441 : :
4442 : : /* If we're not shadowing a template parameter, we're done. Note
4443 : : that OLDDECL might be an OVERLOAD (or perhaps even an
4444 : : ERROR_MARK), so we can't just blithely assume it to be a _DECL
4445 : : node. */
4446 : 58647054 : if (!DECL_P (olddecl) || !DECL_TEMPLATE_PARM_P (olddecl))
4447 : : return true;
4448 : :
4449 : : /* We check for decl != olddecl to avoid bogus errors for using a
4450 : : name inside a class. We check TPFI to avoid duplicate errors for
4451 : : inline member templates. */
4452 : 150 : if (decl == olddecl
4453 : 150 : || (DECL_TEMPLATE_PARM_P (decl)
4454 : 69 : && TEMPLATE_PARMS_FOR_INLINE (current_template_parms)))
4455 : : return true;
4456 : :
4457 : : /* Don't complain about the injected class name, as we've already
4458 : : complained about the class itself. */
4459 : 117 : if (DECL_SELF_REFERENCE_P (decl))
4460 : : return false;
4461 : :
4462 : 111 : auto_diagnostic_group d;
4463 : 111 : if (DECL_TEMPLATE_PARM_P (decl))
4464 : 36 : error ("declaration of template parameter %q+D shadows "
4465 : : "template parameter", decl);
4466 : : else
4467 : 75 : error ("declaration of %q+#D shadows template parameter", decl);
4468 : 111 : inform (DECL_SOURCE_LOCATION (olddecl),
4469 : : "template parameter %qD declared here", olddecl);
4470 : 111 : return false;
4471 : 111 : }
4472 : :
4473 : : /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
4474 : : ORIG_LEVEL, DECL, and TYPE. */
4475 : :
4476 : : static tree
4477 : 180758761 : build_template_parm_index (int index,
4478 : : int level,
4479 : : int orig_level,
4480 : : tree decl,
4481 : : tree type)
4482 : : {
4483 : 180758761 : tree t = make_node (TEMPLATE_PARM_INDEX);
4484 : 180758761 : TEMPLATE_PARM_IDX (t) = index;
4485 : 180758761 : TEMPLATE_PARM_LEVEL (t) = level;
4486 : 180758761 : TEMPLATE_PARM_ORIG_LEVEL (t) = orig_level;
4487 : 180758761 : TEMPLATE_PARM_DECL (t) = decl;
4488 : 180758761 : TREE_TYPE (t) = type;
4489 : 180758761 : TREE_CONSTANT (t) = TREE_CONSTANT (decl);
4490 : 180758761 : TREE_READONLY (t) = TREE_READONLY (decl);
4491 : :
4492 : 180758761 : return t;
4493 : : }
4494 : :
4495 : : struct ctp_hasher : ggc_ptr_hash<tree_node>
4496 : : {
4497 : 953263062 : static hashval_t hash (tree t)
4498 : : {
4499 : 953263062 : ++comparing_specializations;
4500 : 953263062 : tree_code code = TREE_CODE (t);
4501 : 953263062 : hashval_t val = iterative_hash_object (code, 0);
4502 : 953263062 : val = iterative_hash_object (TEMPLATE_TYPE_LEVEL (t), val);
4503 : 953263062 : val = iterative_hash_object (TEMPLATE_TYPE_IDX (t), val);
4504 : 953263062 : if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
4505 : : {
4506 : 801264659 : val
4507 : 801264659 : = iterative_hash_template_arg (CLASS_PLACEHOLDER_TEMPLATE (t), val);
4508 : 801264659 : if (tree c = NON_ERROR (PLACEHOLDER_TYPE_CONSTRAINTS (t)))
4509 : 76718042 : val = iterative_hash_placeholder_constraint (c, val);
4510 : : }
4511 : 953263062 : if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
4512 : 149943332 : val = iterative_hash_template_arg (TYPE_TI_ARGS (t), val);
4513 : 953263062 : --comparing_specializations;
4514 : 953263062 : return val;
4515 : : }
4516 : :
4517 : 1109335089 : static bool equal (tree t, tree u)
4518 : : {
4519 : 1109335089 : ++comparing_specializations;
4520 : 1109335089 : bool eq = comptypes (t, u, COMPARE_STRUCTURAL);
4521 : 1109335089 : --comparing_specializations;
4522 : 1109335089 : return eq;
4523 : : }
4524 : : };
4525 : :
4526 : : static GTY (()) hash_table<ctp_hasher> *ctp_table;
4527 : :
4528 : : /* Find the canonical type parameter for the given template type
4529 : : parameter. Returns the canonical type parameter, which may be TYPE
4530 : : if no such parameter existed. */
4531 : :
4532 : : tree
4533 : 167655672 : canonical_type_parameter (tree type)
4534 : : {
4535 : 167655672 : if (ctp_table == NULL)
4536 : 92069 : ctp_table = hash_table<ctp_hasher>::create_ggc (61);
4537 : :
4538 : 167655672 : tree& slot = *ctp_table->find_slot (type, INSERT);
4539 : 167655672 : if (slot == NULL_TREE)
4540 : 1583546 : slot = type;
4541 : 167655672 : return slot;
4542 : : }
4543 : :
4544 : : /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
4545 : : TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
4546 : : TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
4547 : : new one is created. */
4548 : :
4549 : : static tree
4550 : 20809133 : reduce_template_parm_level (tree index, tree type, int levels, tree args,
4551 : : tsubst_flags_t complain)
4552 : : {
4553 : 20809133 : if (TEMPLATE_PARM_DESCENDANTS (index) == NULL_TREE
4554 : 7826183 : || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index))
4555 : 7826183 : != TEMPLATE_PARM_LEVEL (index) - levels)
4556 : 28609440 : || !same_type_p (type, TREE_TYPE (TEMPLATE_PARM_DESCENDANTS (index))))
4557 : : {
4558 : 14145277 : tree orig_decl = TEMPLATE_PARM_DECL (index);
4559 : :
4560 : 14145277 : tree decl = build_decl (DECL_SOURCE_LOCATION (orig_decl),
4561 : 14145277 : TREE_CODE (orig_decl), DECL_NAME (orig_decl),
4562 : : type);
4563 : 14145277 : TREE_CONSTANT (decl) = TREE_CONSTANT (orig_decl);
4564 : 14145277 : TREE_READONLY (decl) = TREE_READONLY (orig_decl);
4565 : 14145277 : DECL_VIRTUAL_P (decl) = DECL_VIRTUAL_P (orig_decl);
4566 : 14145277 : DECL_ARTIFICIAL (decl) = 1;
4567 : 14145277 : SET_DECL_TEMPLATE_PARM_P (decl);
4568 : :
4569 : 14145277 : tree tpi = build_template_parm_index (TEMPLATE_PARM_IDX (index),
4570 : 14145277 : TEMPLATE_PARM_LEVEL (index) - levels,
4571 : 14145277 : TEMPLATE_PARM_ORIG_LEVEL (index),
4572 : : decl, type);
4573 : 14145277 : TEMPLATE_PARM_DESCENDANTS (index) = tpi;
4574 : 28290554 : TEMPLATE_PARM_PARAMETER_PACK (tpi)
4575 : 14145277 : = TEMPLATE_PARM_PARAMETER_PACK (index);
4576 : :
4577 : : /* Template template parameters need this. */
4578 : 14145277 : tree inner = decl;
4579 : 14145277 : if (TREE_CODE (decl) == TEMPLATE_DECL)
4580 : : {
4581 : 1753 : inner = build_lang_decl_loc (DECL_SOURCE_LOCATION (decl),
4582 : 1753 : TYPE_DECL, DECL_NAME (decl), type);
4583 : 1753 : DECL_TEMPLATE_RESULT (decl) = inner;
4584 : 1753 : DECL_ARTIFICIAL (inner) = true;
4585 : 1753 : tree parms = tsubst_template_parms (DECL_TEMPLATE_PARMS (orig_decl),
4586 : : args, complain);
4587 : 1753 : DECL_TEMPLATE_PARMS (decl) = parms;
4588 : 1753 : tree orig_inner = DECL_TEMPLATE_RESULT (orig_decl);
4589 : 1753 : DECL_TEMPLATE_INFO (inner)
4590 : 3506 : = build_template_info (DECL_TI_TEMPLATE (orig_inner),
4591 : : template_parms_to_args (parms));
4592 : : }
4593 : :
4594 : : /* Attach the TPI to the decl. */
4595 : 14145277 : if (TREE_CODE (inner) == TYPE_DECL)
4596 : 11931776 : TEMPLATE_TYPE_PARM_INDEX (type) = tpi;
4597 : : else
4598 : 2213501 : DECL_INITIAL (decl) = tpi;
4599 : : }
4600 : :
4601 : 20809133 : return TEMPLATE_PARM_DESCENDANTS (index);
4602 : : }
4603 : :
4604 : : /* Process information from new template parameter PARM and append it
4605 : : to the LIST being built. This new parameter is a non-type
4606 : : parameter iff IS_NON_TYPE is true. This new parameter is a
4607 : : parameter pack iff IS_PARAMETER_PACK is true. The location of PARM
4608 : : is in PARM_LOC. */
4609 : :
4610 : : tree
4611 : 147867207 : process_template_parm (tree list, location_t parm_loc, tree parm,
4612 : : bool is_non_type, bool is_parameter_pack)
4613 : : {
4614 : 147867207 : gcc_assert (TREE_CODE (parm) == TREE_LIST);
4615 : 147867207 : tree prev = NULL_TREE;
4616 : 147867207 : int idx = 0;
4617 : :
4618 : 147867207 : if (list)
4619 : : {
4620 : 70467635 : prev = tree_last (list);
4621 : :
4622 : 70467635 : tree p = TREE_VALUE (prev);
4623 : 70467635 : if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
4624 : 64752720 : idx = TEMPLATE_TYPE_IDX (TREE_TYPE (p));
4625 : 5714915 : else if (TREE_CODE (p) == PARM_DECL)
4626 : 5714895 : idx = TEMPLATE_PARM_IDX (DECL_INITIAL (p));
4627 : :
4628 : 70467635 : ++idx;
4629 : : }
4630 : :
4631 : 147867207 : tree decl = NULL_TREE;
4632 : 147867207 : tree defval = TREE_PURPOSE (parm);
4633 : 147867207 : tree constr = TREE_TYPE (parm);
4634 : :
4635 : 147867207 : if (is_non_type)
4636 : : {
4637 : 11664328 : parm = TREE_VALUE (parm);
4638 : :
4639 : 11664328 : SET_DECL_TEMPLATE_PARM_P (parm);
4640 : :
4641 : 11664328 : if (TREE_TYPE (parm) != error_mark_node)
4642 : : {
4643 : : /* [temp.param]
4644 : :
4645 : : The top-level cv-qualifiers on the template-parameter are
4646 : : ignored when determining its type. */
4647 : 11664245 : TREE_TYPE (parm) = TYPE_MAIN_VARIANT (TREE_TYPE (parm));
4648 : 11664245 : if (invalid_nontype_parm_type_p (TREE_TYPE (parm), 1))
4649 : 101 : TREE_TYPE (parm) = error_mark_node;
4650 : 11664144 : else if (uses_parameter_packs (TREE_TYPE (parm))
4651 : 51 : && !is_parameter_pack
4652 : : /* If we're in a nested template parameter list, the template
4653 : : template parameter could be a parameter pack. */
4654 : 11664162 : && processing_template_parmlist == 1)
4655 : : {
4656 : : /* This template parameter is not a parameter pack, but it
4657 : : should be. Complain about "bare" parameter packs. */
4658 : 12 : check_for_bare_parameter_packs (TREE_TYPE (parm));
4659 : :
4660 : : /* Recover by calling this a parameter pack. */
4661 : 12 : is_parameter_pack = true;
4662 : : }
4663 : : }
4664 : :
4665 : : /* A template parameter is not modifiable. */
4666 : 11664328 : TREE_CONSTANT (parm) = 1;
4667 : 11664328 : TREE_READONLY (parm) = 1;
4668 : 11664328 : decl = build_decl (parm_loc,
4669 : 11664328 : CONST_DECL, DECL_NAME (parm), TREE_TYPE (parm));
4670 : 11664328 : TREE_CONSTANT (decl) = 1;
4671 : 11664328 : TREE_READONLY (decl) = 1;
4672 : 11664328 : DECL_INITIAL (parm) = DECL_INITIAL (decl)
4673 : 23328656 : = build_template_parm_index (idx, current_template_depth,
4674 : 11664328 : current_template_depth,
4675 : 11664328 : decl, TREE_TYPE (parm));
4676 : :
4677 : 11664328 : TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm))
4678 : 11664328 : = is_parameter_pack;
4679 : : }
4680 : : else
4681 : : {
4682 : 136202879 : tree t;
4683 : 136202879 : parm = TREE_VALUE (TREE_VALUE (parm));
4684 : :
4685 : 136202879 : if (parm && TREE_CODE (parm) == TEMPLATE_DECL)
4686 : : {
4687 : 308092 : t = cxx_make_type (TEMPLATE_TEMPLATE_PARM);
4688 : : /* This is for distinguishing between real templates and template
4689 : : template parameters */
4690 : 308092 : TREE_TYPE (parm) = t;
4691 : :
4692 : : /* any_template_parm_r expects to be able to get the targs of a
4693 : : DECL_TEMPLATE_RESULT. */
4694 : 308092 : tree result = DECL_TEMPLATE_RESULT (parm);
4695 : 308092 : TREE_TYPE (result) = t;
4696 : 308092 : tree args = template_parms_to_args (DECL_TEMPLATE_PARMS (parm));
4697 : 308092 : tree tinfo = build_template_info (parm, args);
4698 : 308092 : retrofit_lang_decl (result);
4699 : 308092 : DECL_TEMPLATE_INFO (result) = tinfo;
4700 : :
4701 : 308092 : decl = parm;
4702 : 308092 : }
4703 : : else
4704 : : {
4705 : 135894787 : t = cxx_make_type (TEMPLATE_TYPE_PARM);
4706 : : /* parm is either IDENTIFIER_NODE or NULL_TREE. */
4707 : 135894787 : decl = build_decl (parm_loc,
4708 : : TYPE_DECL, parm, t);
4709 : : }
4710 : :
4711 : 136202879 : TYPE_NAME (t) = decl;
4712 : 136202879 : TYPE_STUB_DECL (t) = decl;
4713 : 136202879 : parm = decl;
4714 : 136202879 : TEMPLATE_TYPE_PARM_INDEX (t)
4715 : 136202879 : = build_template_parm_index (idx, current_template_depth,
4716 : 136202879 : current_template_depth,
4717 : 136202879 : decl, TREE_TYPE (parm));
4718 : 136202879 : TEMPLATE_TYPE_PARAMETER_PACK (t) = is_parameter_pack;
4719 : 136202879 : TYPE_CANONICAL (t) = canonical_type_parameter (t);
4720 : : }
4721 : 147867207 : DECL_ARTIFICIAL (decl) = 1;
4722 : 147867207 : SET_DECL_TEMPLATE_PARM_P (decl);
4723 : :
4724 : 147867207 : if (TREE_CODE (parm) == TEMPLATE_DECL
4725 : 147867207 : && !uses_outer_template_parms (parm))
4726 : 308059 : TEMPLATE_TEMPLATE_PARM_SIMPLE_P (TREE_TYPE (parm)) = true;
4727 : :
4728 : : /* Build requirements for the type/template parameter.
4729 : : This must be done after SET_DECL_TEMPLATE_PARM_P or
4730 : : process_template_parm could fail. */
4731 : 147867207 : tree reqs = finish_shorthand_constraint (parm, constr);
4732 : :
4733 : 147867207 : decl = pushdecl (decl);
4734 : 147867207 : if (!is_non_type)
4735 : 136202879 : parm = decl;
4736 : :
4737 : : /* Build the parameter node linking the parameter declaration,
4738 : : its default argument (if any), and its constraints (if any). */
4739 : 147867207 : parm = build_tree_list (defval, parm);
4740 : 147867207 : TEMPLATE_PARM_CONSTRAINTS (parm) = reqs;
4741 : :
4742 : 147867207 : if (prev)
4743 : 70467635 : TREE_CHAIN (prev) = parm;
4744 : : else
4745 : : list = parm;
4746 : :
4747 : 147867207 : return list;
4748 : : }
4749 : :
4750 : : /* The end of a template parameter list has been reached. Process the
4751 : : tree list into a parameter vector, converting each parameter into a more
4752 : : useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
4753 : : as PARM_DECLs. */
4754 : :
4755 : : tree
4756 : 77189934 : end_template_parm_list (tree parms)
4757 : : {
4758 : 77189934 : tree saved_parmlist = make_tree_vec (list_length (parms));
4759 : :
4760 : : /* Pop the dummy parameter level and add the real one. We do not
4761 : : morph the dummy parameter in place, as it might have been
4762 : : captured by a (nested) template-template-parm. */
4763 : 77189934 : current_template_parms = TREE_CHAIN (current_template_parms);
4764 : :
4765 : 154379868 : current_template_parms
4766 : 77189934 : = tree_cons (size_int (current_template_depth + 1),
4767 : : saved_parmlist, current_template_parms);
4768 : :
4769 : 224710779 : for (unsigned ix = 0; parms; ix++)
4770 : : {
4771 : 147520845 : tree parm = parms;
4772 : 147520845 : parms = TREE_CHAIN (parms);
4773 : 147520845 : TREE_CHAIN (parm) = NULL_TREE;
4774 : :
4775 : 147520845 : TREE_VEC_ELT (saved_parmlist, ix) = parm;
4776 : : }
4777 : :
4778 : 77189934 : --processing_template_parmlist;
4779 : :
4780 : 77189934 : return saved_parmlist;
4781 : : }
4782 : :
4783 : : // Explicitly indicate the end of the template parameter list. We assume
4784 : : // that the current template parameters have been constructed and/or
4785 : : // managed explicitly, as when creating new template template parameters
4786 : : // from a shorthand constraint.
4787 : : void
4788 : 0 : end_template_parm_list ()
4789 : : {
4790 : 0 : --processing_template_parmlist;
4791 : 0 : }
4792 : :
4793 : : /* end_template_decl is called after a template declaration is seen. */
4794 : :
4795 : : void
4796 : 77399710 : end_template_decl (void)
4797 : : {
4798 : 77399710 : reset_specialization ();
4799 : :
4800 : 77399710 : if (! processing_template_decl)
4801 : : return;
4802 : :
4803 : : /* This matches the pushlevel in begin_template_parm_list. */
4804 : 77399710 : finish_scope ();
4805 : :
4806 : 77399710 : --processing_template_decl;
4807 : 77399710 : current_template_parms = TREE_CHAIN (current_template_parms);
4808 : : }
4809 : :
4810 : : /* Takes a TEMPLATE_PARM_P or DECL_TEMPLATE_PARM_P node or a TREE_LIST
4811 : : thereof, and converts it into an argument suitable to be passed to
4812 : : the type substitution functions. Note that if the TREE_LIST contains
4813 : : an error_mark node, the returned argument is error_mark_node. */
4814 : :
4815 : : tree
4816 : 694448317 : template_parm_to_arg (tree t)
4817 : : {
4818 : 694448317 : if (!t)
4819 : : return NULL_TREE;
4820 : :
4821 : 694448241 : if (TREE_CODE (t) == TREE_LIST)
4822 : 692671180 : t = TREE_VALUE (t);
4823 : :
4824 : 694448241 : if (error_operand_p (t))
4825 : 620 : return error_mark_node;
4826 : :
4827 : 694447621 : if (DECL_P (t) && DECL_TEMPLATE_PARM_P (t))
4828 : : {
4829 : 693147584 : if (TREE_CODE (t) == TYPE_DECL
4830 : 56682759 : || TREE_CODE (t) == TEMPLATE_DECL)
4831 : 637198747 : t = TREE_TYPE (t);
4832 : : else
4833 : 55948837 : t = DECL_INITIAL (t);
4834 : : }
4835 : :
4836 : 694447621 : gcc_assert (TEMPLATE_PARM_P (t));
4837 : :
4838 : 694447621 : if (TREE_CODE (t) == TEMPLATE_TYPE_PARM
4839 : 694447621 : || TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM)
4840 : : {
4841 : 638453503 : if (TEMPLATE_TYPE_PARAMETER_PACK (t))
4842 : : {
4843 : : /* Turn this argument into a TYPE_ARGUMENT_PACK
4844 : : with a single element, which expands T. */
4845 : 23804036 : tree vec = make_tree_vec (1);
4846 : 23804036 : if (CHECKING_P)
4847 : 23804036 : SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (vec, TREE_VEC_LENGTH (vec));
4848 : :
4849 : 23804036 : TREE_VEC_ELT (vec, 0) = make_pack_expansion (t);
4850 : :
4851 : 23804036 : t = cxx_make_type (TYPE_ARGUMENT_PACK);
4852 : 23804036 : ARGUMENT_PACK_ARGS (t) = vec;
4853 : : }
4854 : : }
4855 : : else
4856 : : {
4857 : 55994118 : if (TEMPLATE_PARM_PARAMETER_PACK (t))
4858 : : {
4859 : : /* Turn this argument into a NONTYPE_ARGUMENT_PACK
4860 : : with a single element, which expands T. */
4861 : 1390594 : tree vec = make_tree_vec (1);
4862 : 1390594 : if (CHECKING_P)
4863 : 1390594 : SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (vec, TREE_VEC_LENGTH (vec));
4864 : :
4865 : 1390594 : t = convert_from_reference (t);
4866 : 1390594 : TREE_VEC_ELT (vec, 0) = make_pack_expansion (t);
4867 : :
4868 : 1390594 : t = make_node (NONTYPE_ARGUMENT_PACK);
4869 : 1390594 : ARGUMENT_PACK_ARGS (t) = vec;
4870 : : }
4871 : : else
4872 : 54603524 : t = convert_from_reference (t);
4873 : : }
4874 : : return t;
4875 : : }
4876 : :
4877 : : /* If T looks like a generic template argument produced by template_parm_to_arg,
4878 : : return the corresponding template parameter, otherwise return NULL_TREE. */
4879 : :
4880 : : static tree
4881 : 1346567684 : template_arg_to_parm (tree t)
4882 : : {
4883 : 1346567684 : if (t == NULL_TREE)
4884 : : return NULL_TREE;
4885 : :
4886 : 1346567684 : if (ARGUMENT_PACK_P (t))
4887 : : {
4888 : 142874046 : tree args = ARGUMENT_PACK_ARGS (t);
4889 : 142874046 : if (TREE_VEC_LENGTH (args) == 1
4890 : 142874046 : && PACK_EXPANSION_P (TREE_VEC_ELT (args, 0)))
4891 : 59575840 : t = PACK_EXPANSION_PATTERN (TREE_VEC_ELT (args, 0));
4892 : : }
4893 : :
4894 : 1346567684 : if (REFERENCE_REF_P (t))
4895 : 401 : t = TREE_OPERAND (t, 0);
4896 : :
4897 : 1346567684 : if (TEMPLATE_PARM_P (t))
4898 : : return t;
4899 : : else
4900 : 328874258 : return NULL_TREE;
4901 : : }
4902 : :
4903 : : /* Given a single level of template parameters (a TREE_VEC), return it
4904 : : as a set of template arguments. */
4905 : :
4906 : : tree
4907 : 328138177 : template_parms_level_to_args (tree parms)
4908 : : {
4909 : 328138177 : parms = copy_node (parms);
4910 : 328138177 : TREE_TYPE (parms) = NULL_TREE;
4911 : 1019390207 : for (tree& parm : tree_vec_range (parms))
4912 : 691252030 : parm = template_parm_to_arg (parm);
4913 : :
4914 : 328138177 : if (CHECKING_P)
4915 : 328138177 : SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (parms, TREE_VEC_LENGTH (parms));
4916 : :
4917 : 328138177 : return parms;
4918 : : }
4919 : :
4920 : : /* Given a set of template parameters, return them as a set of template
4921 : : arguments. The template parameters are represented as a TREE_VEC, in
4922 : : the form documented in cp-tree.h for template arguments. */
4923 : :
4924 : : tree
4925 : 267522028 : template_parms_to_args (tree parms)
4926 : : {
4927 : 267522028 : tree header;
4928 : 267522028 : tree args = NULL_TREE;
4929 : 267522028 : int length = TMPL_PARMS_DEPTH (parms);
4930 : 267522028 : int l = length;
4931 : :
4932 : : /* If there is only one level of template parameters, we do not
4933 : : create a TREE_VEC of TREE_VECs. Instead, we return a single
4934 : : TREE_VEC containing the arguments. */
4935 : 267522028 : if (length > 1)
4936 : 42170915 : args = make_tree_vec (length);
4937 : :
4938 : 577718746 : for (header = parms; header; header = TREE_CHAIN (header))
4939 : : {
4940 : 310196718 : tree a = template_parms_level_to_args (TREE_VALUE (header));
4941 : :
4942 : 310196718 : if (length > 1)
4943 : 84845605 : TREE_VEC_ELT (args, --l) = a;
4944 : : else
4945 : : args = a;
4946 : : }
4947 : :
4948 : 267522028 : return args;
4949 : : }
4950 : :
4951 : : /* Within the declaration of a template, return the currently active
4952 : : template parameters as an argument TREE_VEC. */
4953 : :
4954 : : static tree
4955 : 266848992 : current_template_args (void)
4956 : : {
4957 : 0 : return template_parms_to_args (current_template_parms);
4958 : : }
4959 : :
4960 : : /* Return the fully generic arguments for of TMPL, i.e. what
4961 : : current_template_args would be while parsing it. */
4962 : :
4963 : : tree
4964 : 18320812 : generic_targs_for (tree tmpl)
4965 : : {
4966 : 18320812 : if (tmpl == NULL_TREE)
4967 : : return NULL_TREE;
4968 : 18320812 : if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl)
4969 : 36641624 : || DECL_TEMPLATE_SPECIALIZATION (tmpl))
4970 : : /* DECL_TEMPLATE_RESULT doesn't have the arguments we want. For a template
4971 : : template parameter, it has no TEMPLATE_INFO; for a partial
4972 : : specialization, it has the arguments for the primary template, and we
4973 : : want the arguments for the partial specialization. */;
4974 : 18225336 : else if (tree result = DECL_TEMPLATE_RESULT (tmpl))
4975 : 18225336 : if (tree ti = get_template_info (result))
4976 : 18225336 : return TI_ARGS (ti);
4977 : 95476 : return template_parms_to_args (DECL_TEMPLATE_PARMS (tmpl));
4978 : : }
4979 : :
4980 : : /* Return the template arguments corresponding to the template parameters of
4981 : : DECL's enclosing scope. When DECL is a member of a partial specialization,
4982 : : this returns the arguments for the partial specialization as opposed to those
4983 : : for the primary template, which is the main difference between this function
4984 : : and simply using e.g. the TYPE_TI_ARGS of DECL's DECL_CONTEXT. */
4985 : :
4986 : : tree
4987 : 29348 : outer_template_args (const_tree decl)
4988 : : {
4989 : 29348 : if (TREE_CODE (decl) == TEMPLATE_DECL)
4990 : 5551 : decl = DECL_TEMPLATE_RESULT (decl);
4991 : 29348 : tree ti = get_template_info (decl);
4992 : 29348 : if (!ti)
4993 : : return NULL_TREE;
4994 : 29348 : tree args = TI_ARGS (ti);
4995 : 29348 : if (!PRIMARY_TEMPLATE_P (TI_TEMPLATE (ti)))
4996 : : return args;
4997 : 58696 : if (TMPL_ARGS_DEPTH (args) == 1)
4998 : : return NULL_TREE;
4999 : 23897 : return strip_innermost_template_args (args, 1);
5000 : : }
5001 : :
5002 : : /* Update the declared TYPE by doing any lookups which were thought to be
5003 : : dependent, but are not now that we know the SCOPE of the declarator. */
5004 : :
5005 : : tree
5006 : 155234667 : maybe_update_decl_type (tree orig_type, tree scope)
5007 : : {
5008 : 155234667 : tree type = orig_type;
5009 : :
5010 : 155234667 : if (type == NULL_TREE)
5011 : : return type;
5012 : :
5013 : 147982398 : if (TREE_CODE (orig_type) == TYPE_DECL)
5014 : 69712743 : type = TREE_TYPE (type);
5015 : :
5016 : 7902228 : if (scope && TYPE_P (scope) && dependent_type_p (scope)
5017 : 6781451 : && dependent_type_p (type)
5018 : : /* Don't bother building up the args in this case. */
5019 : 151348279 : && TREE_CODE (type) != TEMPLATE_TYPE_PARM)
5020 : : {
5021 : : /* tsubst in the args corresponding to the template parameters,
5022 : : including auto if present. Most things will be unchanged, but
5023 : : make_typename_type and tsubst_qualified_id will resolve
5024 : : TYPENAME_TYPEs and SCOPE_REFs that were previously dependent. */
5025 : 2442461 : tree args = current_template_args ();
5026 : 2442461 : tree auto_node = type_uses_auto (type);
5027 : 2442461 : tree pushed;
5028 : 2442461 : if (auto_node)
5029 : : {
5030 : 0 : tree auto_vec = make_tree_vec (1);
5031 : 0 : TREE_VEC_ELT (auto_vec, 0) = auto_node;
5032 : 0 : args = add_to_template_args (args, auto_vec);
5033 : : }
5034 : 2442461 : pushed = push_scope (scope);
5035 : 2442461 : type = tsubst (type, args, tf_warning_or_error, NULL_TREE);
5036 : 2442461 : if (pushed)
5037 : 2442458 : pop_scope (scope);
5038 : : }
5039 : :
5040 : 147982398 : if (type == error_mark_node)
5041 : : return orig_type;
5042 : :
5043 : 147981711 : if (TREE_CODE (orig_type) == TYPE_DECL)
5044 : : {
5045 : 69712710 : if (same_type_p (type, TREE_TYPE (orig_type)))
5046 : : type = orig_type;
5047 : : else
5048 : 68360 : type = TYPE_NAME (type);
5049 : : }
5050 : : return type;
5051 : : }
5052 : :
5053 : : /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
5054 : : template PARMS and constraints, CONSTR. If MEMBER_TEMPLATE_P is true,
5055 : : the new template is a member template. */
5056 : :
5057 : : static tree
5058 : 152925531 : build_template_decl (tree decl, tree parms, bool member_template_p)
5059 : : {
5060 : 152925531 : gcc_checking_assert (TREE_CODE (decl) != TEMPLATE_DECL);
5061 : :
5062 : 152925531 : tree tmpl = build_lang_decl (TEMPLATE_DECL, DECL_NAME (decl), NULL_TREE);
5063 : 152925531 : SET_DECL_LANGUAGE (tmpl, DECL_LANGUAGE (decl));
5064 : 152925531 : DECL_TEMPLATE_PARMS (tmpl) = parms;
5065 : 152925531 : DECL_TEMPLATE_RESULT (tmpl) = decl;
5066 : 152925531 : DECL_CONTEXT (tmpl) = DECL_CONTEXT (decl);
5067 : 152925531 : TREE_TYPE (tmpl) = TREE_TYPE (decl);
5068 : 152925531 : DECL_SOURCE_LOCATION (tmpl) = DECL_SOURCE_LOCATION (decl);
5069 : 152925531 : DECL_MEMBER_TEMPLATE_P (tmpl) = member_template_p;
5070 : :
5071 : : /* Propagate module information from the decl. */
5072 : 152925531 : DECL_MODULE_EXPORT_P (tmpl) = DECL_MODULE_EXPORT_P (decl);
5073 : :
5074 : 152925531 : return tmpl;
5075 : : }
5076 : :
5077 : : struct template_parm_data
5078 : : {
5079 : : /* The level of the template parameters we are currently
5080 : : processing. */
5081 : : int level;
5082 : :
5083 : : /* The index of the specialization argument we are currently
5084 : : processing. */
5085 : : int current_arg;
5086 : :
5087 : : /* An array whose size is the number of template parameters. The
5088 : : elements are nonzero if the parameter has been used in any one
5089 : : of the arguments processed so far. */
5090 : : int* parms;
5091 : :
5092 : : /* An array whose size is the number of template arguments. The
5093 : : elements are nonzero if the argument makes use of template
5094 : : parameters of this level. */
5095 : : int* arg_uses_template_parms;
5096 : : };
5097 : :
5098 : : /* Subroutine of push_template_decl used to see if each template
5099 : : parameter in a partial specialization is used in the explicit
5100 : : argument list. If T is of the LEVEL given in DATA (which is
5101 : : treated as a template_parm_data*), then DATA->PARMS is marked
5102 : : appropriately. */
5103 : :
5104 : : static int
5105 : 14449804 : mark_template_parm (tree t, void* data)
5106 : : {
5107 : 14449804 : int level;
5108 : 14449804 : int idx;
5109 : 14449804 : struct template_parm_data* tpd = (struct template_parm_data*) data;
5110 : :
5111 : 14449804 : template_parm_level_and_index (t, &level, &idx);
5112 : :
5113 : 14449804 : if (level == tpd->level)
5114 : : {
5115 : 14437738 : tpd->parms[idx] = 1;
5116 : 14437738 : tpd->arg_uses_template_parms[tpd->current_arg] = 1;
5117 : : }
5118 : :
5119 : : /* In C++17 the type of a non-type argument is a deduced context. */
5120 : 14449804 : if (cxx_dialect >= cxx17
5121 : 14329968 : && TREE_CODE (t) == TEMPLATE_PARM_INDEX)
5122 : 1812723 : for_each_template_parm (TREE_TYPE (t),
5123 : : &mark_template_parm,
5124 : : data,
5125 : : NULL,
5126 : : /*include_nondeduced_p=*/false);
5127 : :
5128 : : /* Return zero so that for_each_template_parm will continue the
5129 : : traversal of the tree; we want to mark *every* template parm. */
5130 : 14449804 : return 0;
5131 : : }
5132 : :
5133 : : /* Process the partial specialization DECL. */
5134 : :
5135 : : static tree
5136 : 6941239 : process_partial_specialization (tree decl)
5137 : : {
5138 : 6941239 : tree type = TREE_TYPE (decl);
5139 : 6941239 : tree tinfo = get_template_info (decl);
5140 : 6941239 : tree maintmpl = TI_TEMPLATE (tinfo);
5141 : 6941239 : tree specargs = TI_ARGS (tinfo);
5142 : 6941239 : tree inner_args = INNERMOST_TEMPLATE_ARGS (specargs);
5143 : 6941239 : tree main_inner_parms = DECL_INNERMOST_TEMPLATE_PARMS (maintmpl);
5144 : 6941239 : tree inner_parms;
5145 : 6941239 : tree inst;
5146 : 6941239 : int nargs = TREE_VEC_LENGTH (inner_args);
5147 : 6941239 : int ntparms;
5148 : 6941239 : int i;
5149 : 6941239 : struct template_parm_data tpd;
5150 : 6941239 : struct template_parm_data tpd2;
5151 : :
5152 : 6941239 : gcc_assert (current_template_parms);
5153 : :
5154 : 6941239 : inner_parms = INNERMOST_TEMPLATE_PARMS (current_template_parms);
5155 : 6941239 : ntparms = TREE_VEC_LENGTH (inner_parms);
5156 : :
5157 : : /* We check that each of the template parameters given in the
5158 : : partial specialization is used in the argument list to the
5159 : : specialization. For example:
5160 : :
5161 : : template <class T> struct S;
5162 : : template <class T> struct S<T*>;
5163 : :
5164 : : The second declaration is OK because `T*' uses the template
5165 : : parameter T, whereas
5166 : :
5167 : : template <class T> struct S<int>;
5168 : :
5169 : : is no good. Even trickier is:
5170 : :
5171 : : template <class T>
5172 : : struct S1
5173 : : {
5174 : : template <class U>
5175 : : struct S2;
5176 : : template <class U>
5177 : : struct S2<T>;
5178 : : };
5179 : :
5180 : : The S2<T> declaration is actually invalid; it is a
5181 : : full-specialization. Of course,
5182 : :
5183 : : template <class U>
5184 : : struct S2<T (*)(U)>;
5185 : :
5186 : : or some such would have been OK. */
5187 : 6941239 : tpd.level = TMPL_PARMS_DEPTH (current_template_parms);
5188 : 6941239 : tpd.parms = XALLOCAVEC (int, ntparms);
5189 : 6941239 : memset (tpd.parms, 0, sizeof (int) * ntparms);
5190 : :
5191 : 6941239 : tpd.arg_uses_template_parms = XALLOCAVEC (int, nargs);
5192 : 6941239 : memset (tpd.arg_uses_template_parms, 0, sizeof (int) * nargs);
5193 : 21766708 : for (i = 0; i < nargs; ++i)
5194 : : {
5195 : 14825469 : tpd.current_arg = i;
5196 : 14825469 : for_each_template_parm (TREE_VEC_ELT (inner_args, i),
5197 : : &mark_template_parm,
5198 : : &tpd,
5199 : : NULL,
5200 : : /*include_nondeduced_p=*/false);
5201 : : }
5202 : :
5203 : 6941239 : {
5204 : 6941239 : auto_diagnostic_group d;
5205 : 6941239 : bool did_error_intro = false;
5206 : 27377523 : for (i = 0; i < ntparms; ++i)
5207 : 13495045 : if (tpd.parms[i] == 0)
5208 : : {
5209 : : /* One of the template parms was not used in a deduced context in the
5210 : : specialization. */
5211 : 50 : if (!did_error_intro)
5212 : : {
5213 : 50 : error ("template parameters not deducible in "
5214 : : "partial specialization:");
5215 : 50 : did_error_intro = true;
5216 : : }
5217 : :
5218 : 100 : inform (input_location, " %qD",
5219 : 50 : TREE_VALUE (TREE_VEC_ELT (inner_parms, i)));
5220 : : }
5221 : :
5222 : 6941239 : if (did_error_intro)
5223 : 50 : return error_mark_node;
5224 : 6941239 : }
5225 : :
5226 : : /* [temp.class.spec]
5227 : :
5228 : : The argument list of the specialization shall not be identical to
5229 : : the implicit argument list of the primary template. */
5230 : 6941189 : tree main_args
5231 : 6941189 : = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (maintmpl)));
5232 : 6941189 : if (comp_template_args (inner_args, INNERMOST_TEMPLATE_ARGS (main_args))
5233 : 6941189 : && (!flag_concepts
5234 : 150068 : || !strictly_subsumes (current_template_constraints (), maintmpl)))
5235 : : {
5236 : 21 : auto_diagnostic_group d;
5237 : 21 : if (!flag_concepts)
5238 : 8 : error ("partial specialization %q+D does not specialize "
5239 : : "any template arguments; to define the primary template, "
5240 : : "remove the template argument list", decl);
5241 : : else
5242 : 13 : error ("partial specialization %q+D does not specialize any "
5243 : : "template arguments and is not more constrained than "
5244 : : "the primary template; to define the primary template, "
5245 : : "remove the template argument list", decl);
5246 : 21 : inform (DECL_SOURCE_LOCATION (maintmpl), "primary template here");
5247 : 21 : }
5248 : :
5249 : : /* A partial specialization that replaces multiple parameters of the
5250 : : primary template with a pack expansion is less specialized for those
5251 : : parameters. */
5252 : 6941189 : if (nargs < DECL_NTPARMS (maintmpl))
5253 : : {
5254 : 3 : auto_diagnostic_group d;
5255 : 3 : error ("partial specialization is not more specialized than the "
5256 : : "primary template because it replaces multiple parameters "
5257 : : "with a pack expansion");
5258 : 3 : inform (DECL_SOURCE_LOCATION (maintmpl), "primary template here");
5259 : : /* Avoid crash in process_partial_specialization. */
5260 : 3 : return decl;
5261 : 3 : }
5262 : :
5263 : 6941186 : else if (nargs > DECL_NTPARMS (maintmpl))
5264 : : {
5265 : 5 : auto_diagnostic_group d;
5266 : 5 : error ("too many arguments for partial specialization %qT", type);
5267 : 5 : inform (DECL_SOURCE_LOCATION (maintmpl), "primary template here");
5268 : : /* Avoid crash below. */
5269 : 5 : return decl;
5270 : 5 : }
5271 : :
5272 : : /* If we aren't in a dependent class, we can actually try deduction. */
5273 : 6941181 : else if (tpd.level == 1
5274 : : /* FIXME we should be able to handle a partial specialization of a
5275 : : partial instantiation, but currently we can't (c++/41727). */
5276 : 13346998 : && TMPL_ARGS_DEPTH (specargs) == 1
5277 : 13614674 : && !get_partial_spec_bindings (maintmpl, maintmpl, specargs))
5278 : : {
5279 : 17 : auto_diagnostic_group d;
5280 : 17 : if (pedwarn (input_location, 0,
5281 : : "partial specialization %qD is not more specialized than",
5282 : : decl))
5283 : 17 : inform (DECL_SOURCE_LOCATION (maintmpl), "primary template %qD",
5284 : : maintmpl);
5285 : 17 : }
5286 : :
5287 : : /* [temp.spec.partial]
5288 : :
5289 : : The type of a template parameter corresponding to a specialized
5290 : : non-type argument shall not be dependent on a parameter of the
5291 : : specialization.
5292 : :
5293 : : Also, we verify that pack expansions only occur at the
5294 : : end of the argument list. */
5295 : 6941181 : tpd2.parms = 0;
5296 : 21766566 : for (i = 0; i < nargs; ++i)
5297 : : {
5298 : 14825385 : tree parm = TREE_VALUE (TREE_VEC_ELT (main_inner_parms, i));
5299 : 14825385 : tree arg = TREE_VEC_ELT (inner_args, i);
5300 : 14825385 : tree packed_args = NULL_TREE;
5301 : 14825385 : int j, len = 1;
5302 : :
5303 : 14825385 : if (ARGUMENT_PACK_P (arg))
5304 : : {
5305 : : /* Extract the arguments from the argument pack. We'll be
5306 : : iterating over these in the following loop. */
5307 : 725369 : packed_args = ARGUMENT_PACK_ARGS (arg);
5308 : 725369 : len = TREE_VEC_LENGTH (packed_args);
5309 : : }
5310 : :
5311 : 29970962 : for (j = 0; j < len; j++)
5312 : : {
5313 : 15145577 : if (packed_args)
5314 : : /* Get the Jth argument in the parameter pack. */
5315 : 1045561 : arg = TREE_VEC_ELT (packed_args, j);
5316 : :
5317 : 15145577 : if (PACK_EXPANSION_P (arg))
5318 : : {
5319 : : /* Pack expansions must come at the end of the
5320 : : argument list. */
5321 : 439548 : if ((packed_args && j < len - 1)
5322 : 6 : || (!packed_args && i < nargs - 1))
5323 : : {
5324 : 12 : if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
5325 : 6 : error ("parameter pack argument %qE must be at the "
5326 : : "end of the template argument list", arg);
5327 : : else
5328 : 6 : error ("parameter pack argument %qT must be at the "
5329 : : "end of the template argument list", arg);
5330 : : }
5331 : : }
5332 : :
5333 : 15145577 : if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
5334 : : /* We only care about the pattern. */
5335 : 68822 : arg = PACK_EXPANSION_PATTERN (arg);
5336 : :
5337 : 15145577 : if (/* These first two lines are the `non-type' bit. */
5338 : 15145577 : !TYPE_P (arg)
5339 : 4496878 : && TREE_CODE (arg) != TEMPLATE_DECL
5340 : : /* This next two lines are the `argument expression is not just a
5341 : : simple identifier' condition and also the `specialized
5342 : : non-type argument' bit. */
5343 : 4235921 : && TREE_CODE (arg) != TEMPLATE_PARM_INDEX
5344 : 18117564 : && !((REFERENCE_REF_P (arg)
5345 : 2971963 : || TREE_CODE (arg) == VIEW_CONVERT_EXPR)
5346 : 36 : && TREE_CODE (TREE_OPERAND (arg, 0)) == TEMPLATE_PARM_INDEX))
5347 : : {
5348 : : /* Look at the corresponding template parameter,
5349 : : marking which template parameters its type depends
5350 : : upon. */
5351 : 2971954 : tree type = TREE_TYPE (parm);
5352 : :
5353 : 2971954 : if (!tpd2.parms)
5354 : : {
5355 : : /* We haven't yet initialized TPD2. Do so now. */
5356 : 1896451 : tpd2.arg_uses_template_parms = XALLOCAVEC (int, nargs);
5357 : : /* The number of parameters here is the number in the
5358 : : main template, which, as checked in the assertion
5359 : : above, is NARGS. */
5360 : 1896451 : tpd2.parms = XALLOCAVEC (int, nargs);
5361 : 1896451 : tpd2.level =
5362 : 1896451 : TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl));
5363 : : }
5364 : :
5365 : : /* Mark the template parameters. But this time, we're
5366 : : looking for the template parameters of the main
5367 : : template, not in the specialization. */
5368 : 2971954 : tpd2.current_arg = i;
5369 : 2971954 : tpd2.arg_uses_template_parms[i] = 0;
5370 : 2971954 : memset (tpd2.parms, 0, sizeof (int) * nargs);
5371 : 2971954 : for_each_template_parm (type,
5372 : : &mark_template_parm,
5373 : : &tpd2,
5374 : : NULL,
5375 : : /*include_nondeduced_p=*/false);
5376 : :
5377 : 2971954 : if (tpd2.arg_uses_template_parms [i])
5378 : : {
5379 : : /* The type depended on some template parameters.
5380 : : If they are fully specialized in the
5381 : : specialization, that's OK. */
5382 : : int j;
5383 : : int count = 0;
5384 : 78 : for (j = 0; j < nargs; ++j)
5385 : 54 : if (tpd2.parms[j] != 0
5386 : 24 : && tpd.arg_uses_template_parms [j])
5387 : 18 : ++count;
5388 : 24 : if (count != 0)
5389 : 18 : error_n (input_location, count,
5390 : : "type %qT of template argument %qE depends "
5391 : : "on a template parameter",
5392 : : "type %qT of template argument %qE depends "
5393 : : "on template parameters",
5394 : : type,
5395 : : arg);
5396 : : }
5397 : : }
5398 : : }
5399 : : }
5400 : :
5401 : : /* We should only get here once. */
5402 : 6941181 : if (TREE_CODE (decl) == TYPE_DECL)
5403 : 6362698 : gcc_assert (!COMPLETE_TYPE_P (type));
5404 : :
5405 : : // Build the template decl.
5406 : 6941181 : tree tmpl = build_template_decl (decl, current_template_parms,
5407 : 6941181 : DECL_MEMBER_TEMPLATE_P (maintmpl));
5408 : 6941181 : SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
5409 : 6941181 : DECL_TEMPLATE_INFO (tmpl) = build_template_info (maintmpl, specargs);
5410 : 6941181 : DECL_PRIMARY_TEMPLATE (tmpl) = maintmpl;
5411 : :
5412 : : /* Give template template parms a DECL_CONTEXT of the template
5413 : : for which they are a parameter. */
5414 : 20436156 : for (i = 0; i < ntparms; ++i)
5415 : : {
5416 : 13494975 : tree parm = TREE_VALUE (TREE_VEC_ELT (inner_parms, i));
5417 : 13494975 : if (TREE_CODE (parm) == TEMPLATE_DECL)
5418 : 111921 : DECL_CONTEXT (parm) = tmpl;
5419 : : }
5420 : :
5421 : 6941181 : if (VAR_P (decl))
5422 : : {
5423 : : /* We didn't register this in check_explicit_specialization so we could
5424 : : wait until the constraints were set. */
5425 : 578483 : tree reg = register_specialization (decl, maintmpl, specargs, false, 0);
5426 : 578483 : if (reg != decl)
5427 : : /* Redeclaration. */
5428 : : return reg;
5429 : : }
5430 : : else
5431 : 6362698 : associate_classtype_constraints (type);
5432 : :
5433 : 13882344 : DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)
5434 : 6941172 : = tree_cons (specargs, tmpl,
5435 : 6941172 : DECL_TEMPLATE_SPECIALIZATIONS (maintmpl));
5436 : 6941172 : TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)) = type;
5437 : : /* Link the DECL_TEMPLATE_RESULT back to the partial TEMPLATE_DECL. */
5438 : 6941172 : gcc_checking_assert (!TI_PARTIAL_INFO (tinfo));
5439 : 6941172 : TI_PARTIAL_INFO (tinfo) = build_template_info (tmpl, NULL_TREE);
5440 : :
5441 : 6941172 : set_defining_module_for_partial_spec (decl);
5442 : :
5443 : 49230516 : for (inst = DECL_TEMPLATE_INSTANTIATIONS (maintmpl); inst;
5444 : 42289344 : inst = TREE_CHAIN (inst))
5445 : : {
5446 : 42289344 : tree instance = TREE_VALUE (inst);
5447 : 43767318 : if (TYPE_P (instance)
5448 : 42289344 : ? (COMPLETE_TYPE_P (instance)
5449 : 40811370 : && CLASSTYPE_IMPLICIT_INSTANTIATION (instance))
5450 : 1477974 : : DECL_TEMPLATE_INSTANTIATION (instance))
5451 : : {
5452 : 95748 : tree partial_ti = most_specialized_partial_spec (instance, tf_none,
5453 : : /*rechecking=*/true);
5454 : 95748 : tree inst_decl = (DECL_P (instance)
5455 : 95748 : ? instance : TYPE_NAME (instance));
5456 : 95748 : if (!partial_ti)
5457 : : /* OK */;
5458 : 48065 : else if (partial_ti == error_mark_node)
5459 : 3 : permerror (input_location,
5460 : : "declaration of %qD ambiguates earlier template "
5461 : : "instantiation for %qD", decl, inst_decl);
5462 : 48062 : else if (TI_TEMPLATE (partial_ti) == tmpl)
5463 : 6 : permerror (input_location,
5464 : : "partial specialization of %qD after instantiation "
5465 : : "of %qD", decl, inst_decl);
5466 : : }
5467 : : }
5468 : :
5469 : : return decl;
5470 : : }
5471 : :
5472 : : /* PARM is a template parameter of some form; return the corresponding
5473 : : TEMPLATE_PARM_INDEX. */
5474 : :
5475 : : static tree
5476 : 299972871 : get_template_parm_index (tree parm)
5477 : : {
5478 : 299972871 : if (TREE_CODE (parm) == PARM_DECL
5479 : 299972871 : || TREE_CODE (parm) == CONST_DECL)
5480 : 143658273 : parm = DECL_INITIAL (parm);
5481 : 156314598 : else if (TREE_CODE (parm) == TYPE_DECL
5482 : 9627274 : || TREE_CODE (parm) == TEMPLATE_DECL)
5483 : 146691659 : parm = TREE_TYPE (parm);
5484 : 299972871 : if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
5485 : 144885457 : || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM
5486 : 144885394 : || TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM)
5487 : 155153573 : parm = TEMPLATE_TYPE_PARM_INDEX (parm);
5488 : 299972871 : gcc_assert (TREE_CODE (parm) == TEMPLATE_PARM_INDEX);
5489 : 299972871 : return parm;
5490 : : }
5491 : :
5492 : : /* Subroutine of fixed_parameter_pack_p below. Look for any template
5493 : : parameter packs used by the template parameter PARM. */
5494 : :
5495 : : static void
5496 : 861 : fixed_parameter_pack_p_1 (tree parm, struct find_parameter_pack_data *ppd)
5497 : : {
5498 : : /* A type parm can't refer to another parm. */
5499 : 861 : if (TREE_CODE (parm) == TYPE_DECL || parm == error_mark_node)
5500 : : return;
5501 : 846 : else if (TREE_CODE (parm) == PARM_DECL)
5502 : : {
5503 : 804 : cp_walk_tree (&TREE_TYPE (parm), &find_parameter_packs_r,
5504 : : ppd, ppd->visited);
5505 : 804 : return;
5506 : : }
5507 : :
5508 : 42 : gcc_assert (TREE_CODE (parm) == TEMPLATE_DECL);
5509 : :
5510 : 42 : tree vec = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (parm));
5511 : 93 : for (int i = 0; i < TREE_VEC_LENGTH (vec); ++i)
5512 : : {
5513 : 51 : tree p = TREE_VALUE (TREE_VEC_ELT (vec, i));
5514 : 51 : if (template_parameter_pack_p (p))
5515 : : /* Any packs in the type are expanded by this parameter. */;
5516 : : else
5517 : 33 : fixed_parameter_pack_p_1 (p, ppd);
5518 : : }
5519 : : }
5520 : :
5521 : : /* PARM is a template parameter pack. Return any parameter packs used in
5522 : : its type or the type of any of its template parameters. If there are
5523 : : any such packs, it will be instantiated into a fixed template parameter
5524 : : list by partial instantiation rather than be fully deduced. */
5525 : :
5526 : : tree
5527 : 150774032 : fixed_parameter_pack_p (tree parm)
5528 : : {
5529 : : /* This can only be true in a member template. */
5530 : 150774032 : if (TEMPLATE_PARM_ORIG_LEVEL (get_template_parm_index (parm)) < 2)
5531 : : return NULL_TREE;
5532 : : /* This can only be true for a parameter pack. */
5533 : 3035341 : if (!template_parameter_pack_p (parm))
5534 : : return NULL_TREE;
5535 : : /* A type parm can't refer to another parm. */
5536 : 3035341 : if (TREE_CODE (parm) == TYPE_DECL)
5537 : : return NULL_TREE;
5538 : :
5539 : 828 : tree parameter_packs = NULL_TREE;
5540 : 828 : struct find_parameter_pack_data ppd;
5541 : 828 : ppd.parameter_packs = ¶meter_packs;
5542 : 828 : ppd.visited = new hash_set<tree>;
5543 : :
5544 : 828 : fixed_parameter_pack_p_1 (parm, &ppd);
5545 : :
5546 : 1656 : delete ppd.visited;
5547 : 828 : return parameter_packs;
5548 : : }
5549 : :
5550 : : /* Check that a template declaration's use of default arguments and
5551 : : parameter packs is not invalid. Here, PARMS are the template
5552 : : parameters. IS_PRIMARY is true if DECL is the thing declared by
5553 : : a primary template. IS_PARTIAL is true if DECL is a partial
5554 : : specialization.
5555 : :
5556 : : IS_FRIEND_DECL is nonzero if DECL is either a non-defining friend
5557 : : function template declaration or a friend class template
5558 : : declaration. In the function case, 1 indicates a declaration, 2
5559 : : indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
5560 : : emitted for extraneous default arguments.
5561 : :
5562 : : Returns TRUE if there were no errors found, FALSE otherwise. */
5563 : :
5564 : : bool
5565 : 210555368 : check_default_tmpl_args (tree decl, tree parms, bool is_primary,
5566 : : bool is_partial, int is_friend_decl)
5567 : : {
5568 : 210555368 : const char *msg;
5569 : 210555368 : int last_level_to_check;
5570 : 210555368 : tree parm_level;
5571 : 210555368 : bool no_errors = true;
5572 : :
5573 : : /* [temp.param]
5574 : :
5575 : : A default template-argument shall not be specified in a
5576 : : function template declaration or a function template definition, nor
5577 : : in the template-parameter-list of the definition of a member of a
5578 : : class template. */
5579 : :
5580 : 210555368 : if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL
5581 : 210555368 : || (TREE_CODE (decl) == FUNCTION_DECL && DECL_LOCAL_DECL_P (decl)))
5582 : : /* You can't have a function template declaration in a local
5583 : : scope, nor you can you define a member of a class template in a
5584 : : local scope. */
5585 : : return true;
5586 : :
5587 : 209913853 : if ((TREE_CODE (decl) == TYPE_DECL
5588 : 54273730 : && TREE_TYPE (decl)
5589 : 93617147 : && LAMBDA_TYPE_P (TREE_TYPE (decl)))
5590 : 263698251 : || (TREE_CODE (decl) == FUNCTION_DECL
5591 : 157848006 : && LAMBDA_FUNCTION_P (decl)))
5592 : : /* A lambda doesn't have an explicit declaration; don't complain
5593 : : about the parms of the enclosing class. */
5594 : : return true;
5595 : :
5596 : 208431110 : if (current_class_type
5597 : 162811751 : && !TYPE_BEING_DEFINED (current_class_type)
5598 : 58348354 : && DECL_LANG_SPECIFIC (decl)
5599 : 58258856 : && DECL_DECLARES_FUNCTION_P (decl)
5600 : : /* If this is either a friend defined in the scope of the class
5601 : : or a member function. */
5602 : 120024260 : && (DECL_FUNCTION_MEMBER_P (decl)
5603 : 57947731 : ? same_type_p (DECL_CONTEXT (decl), current_class_type)
5604 : 0 : : DECL_FRIEND_CONTEXT (decl)
5605 : 0 : ? same_type_p (DECL_FRIEND_CONTEXT (decl), current_class_type)
5606 : : : false)
5607 : : /* And, if it was a member function, it really was defined in
5608 : : the scope of the class. */
5609 : 324326572 : && (!DECL_FUNCTION_MEMBER_P (decl)
5610 : 57947731 : || DECL_INITIALIZED_IN_CLASS_P (decl)))
5611 : : /* We already checked these parameters when the template was
5612 : : declared, so there's no need to do it again now. This function
5613 : : was defined in class scope, but we're processing its body now
5614 : : that the class is complete. */
5615 : : return true;
5616 : :
5617 : : /* Core issue 226 (C++0x only): the following only applies to class
5618 : : templates. */
5619 : 157829673 : if (is_primary
5620 : 65417580 : && ((cxx_dialect == cxx98) || TREE_CODE (decl) != FUNCTION_DECL))
5621 : : {
5622 : : /* [temp.param]
5623 : :
5624 : : If a template-parameter has a default template-argument, all
5625 : : subsequent template-parameters shall have a default
5626 : : template-argument supplied. */
5627 : 48561168 : for (parm_level = parms; parm_level; parm_level = TREE_CHAIN (parm_level))
5628 : : {
5629 : 25462298 : tree inner_parms = TREE_VALUE (parm_level);
5630 : 25462298 : int ntparms = TREE_VEC_LENGTH (inner_parms);
5631 : 25462298 : int seen_def_arg_p = 0;
5632 : 25462298 : int i;
5633 : :
5634 : 71141958 : for (i = 0; i < ntparms; ++i)
5635 : : {
5636 : 45679660 : tree parm = TREE_VEC_ELT (inner_parms, i);
5637 : :
5638 : 45679660 : if (parm == error_mark_node)
5639 : 0 : continue;
5640 : :
5641 : 45679660 : if (TREE_PURPOSE (parm))
5642 : : seen_def_arg_p = 1;
5643 : 41545899 : else if (seen_def_arg_p
5644 : 41545899 : && !template_parameter_pack_p (TREE_VALUE (parm)))
5645 : : {
5646 : 21 : error ("no default argument for %qD", TREE_VALUE (parm));
5647 : : /* For better subsequent error-recovery, we indicate that
5648 : : there should have been a default argument. */
5649 : 21 : TREE_PURPOSE (parm) = error_mark_node;
5650 : 21 : no_errors = false;
5651 : : }
5652 : 41545878 : else if (!is_partial
5653 : 41545878 : && !is_friend_decl
5654 : : /* Don't complain about an enclosing partial
5655 : : specialization. */
5656 : 26153049 : && parm_level == parms
5657 : 23186371 : && (TREE_CODE (decl) == TYPE_DECL || VAR_P (decl))
5658 : 21978995 : && i < ntparms - 1
5659 : 9688195 : && template_parameter_pack_p (TREE_VALUE (parm))
5660 : : /* A fixed parameter pack will be partially
5661 : : instantiated into a fixed length list. */
5662 : 41545917 : && !fixed_parameter_pack_p (TREE_VALUE (parm)))
5663 : : {
5664 : : /* A primary class template, primary variable template
5665 : : (DR 2032), or alias template can only have one
5666 : : parameter pack, at the end of the template
5667 : : parameter list. */
5668 : :
5669 : 24 : error ("parameter pack %q+D must be at the end of the"
5670 : 24 : " template parameter list", TREE_VALUE (parm));
5671 : :
5672 : 24 : TREE_VALUE (TREE_VEC_ELT (inner_parms, i))
5673 : 24 : = error_mark_node;
5674 : 24 : no_errors = false;
5675 : : }
5676 : : }
5677 : : }
5678 : : }
5679 : :
5680 : 157829673 : if (((cxx_dialect == cxx98) && TREE_CODE (decl) != TYPE_DECL)
5681 : : || is_partial
5682 : 157349347 : || !is_primary
5683 : 58315975 : || is_friend_decl)
5684 : : /* For an ordinary class template, default template arguments are
5685 : : allowed at the innermost level, e.g.:
5686 : : template <class T = int>
5687 : : struct S {};
5688 : : but, in a partial specialization, they're not allowed even
5689 : : there, as we have in [temp.class.spec]:
5690 : :
5691 : : The template parameter list of a specialization shall not
5692 : : contain default template argument values.
5693 : :
5694 : : So, for a partial specialization, or for a function template
5695 : : (in C++98/C++03), we look at all of them. */
5696 : : ;
5697 : : else
5698 : : /* But, for a primary class template that is not a partial
5699 : : specialization we look at all template parameters except the
5700 : : innermost ones. */
5701 : 56823042 : parms = TREE_CHAIN (parms);
5702 : :
5703 : : /* Figure out what error message to issue. */
5704 : 157829673 : if (is_friend_decl == 2)
5705 : : msg = G_("default template arguments may not be used in function template "
5706 : : "friend re-declaration");
5707 : 157620956 : else if (is_friend_decl)
5708 : : msg = G_("default template arguments may not be used in template "
5709 : : "friend declarations");
5710 : 156336740 : else if (TREE_CODE (decl) == FUNCTION_DECL && (cxx_dialect == cxx98))
5711 : : msg = G_("default template arguments may not be used in function templates "
5712 : : "without %<-std=c++11%> or %<-std=gnu++11%>");
5713 : 155869780 : else if (is_partial)
5714 : : msg = G_("default template arguments may not be used in "
5715 : : "partial specializations");
5716 : 148928505 : else if (current_class_type && CLASSTYPE_IS_TEMPLATE (current_class_type))
5717 : : msg = G_("default argument for template parameter for class enclosing %qD");
5718 : : else
5719 : : /* Per [temp.param]/9, "A default template-argument shall not be
5720 : : specified in the template-parameter-lists of the definition of
5721 : : a member of a class template that appears outside of the member's
5722 : : class.", thus if we aren't handling a member of a class template
5723 : : there is no need to examine the parameters. */
5724 : : return true;
5725 : :
5726 : 89327928 : if (current_class_type && TYPE_BEING_DEFINED (current_class_type))
5727 : : /* If we're inside a class definition, there's no need to
5728 : : examine the parameters to the class itself. On the one
5729 : : hand, they will be checked when the class is defined, and,
5730 : : on the other, default arguments are valid in things like:
5731 : : template <class T = double>
5732 : : struct S { template <class U> void f(U); };
5733 : : Here the default argument for `S' has no bearing on the
5734 : : declaration of `f'. */
5735 : 75351078 : last_level_to_check = template_class_depth (current_class_type) + 1;
5736 : : else
5737 : : /* Check everything. */
5738 : : last_level_to_check = 0;
5739 : :
5740 : 89327928 : for (parm_level = parms;
5741 : 199758613 : parm_level && TMPL_PARMS_DEPTH (parm_level) >= last_level_to_check;
5742 : 17789547 : parm_level = TREE_CHAIN (parm_level))
5743 : : {
5744 : 17789550 : tree inner_parms = TREE_VALUE (parm_level);
5745 : 17789550 : int i;
5746 : 17789550 : int ntparms;
5747 : :
5748 : 17789550 : ntparms = TREE_VEC_LENGTH (inner_parms);
5749 : 56116560 : for (i = 0; i < ntparms; ++i)
5750 : : {
5751 : 38327013 : if (TREE_VEC_ELT (inner_parms, i) == error_mark_node)
5752 : 0 : continue;
5753 : :
5754 : 38327013 : if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)))
5755 : : {
5756 : 30 : if (msg)
5757 : : {
5758 : 30 : no_errors = false;
5759 : 30 : if (is_friend_decl == 2)
5760 : : return no_errors;
5761 : :
5762 : 27 : error (msg, decl);
5763 : 27 : msg = 0;
5764 : : }
5765 : :
5766 : : /* Clear out the default argument so that we are not
5767 : : confused later. */
5768 : 27 : TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)) = NULL_TREE;
5769 : : }
5770 : : }
5771 : :
5772 : : /* At this point, if we're still interested in issuing messages,
5773 : : they must apply to classes surrounding the object declared. */
5774 : 17789547 : if (msg)
5775 : 17789519 : msg = G_("default argument for template parameter for class "
5776 : : "enclosing %qD");
5777 : : }
5778 : :
5779 : : return no_errors;
5780 : : }
5781 : :
5782 : : /* Worker for push_template_decl_real, called via
5783 : : for_each_template_parm. DATA is really an int, indicating the
5784 : : level of the parameters we are interested in. If T is a template
5785 : : parameter of that level, return nonzero. */
5786 : :
5787 : : static int
5788 : 3237030 : template_parm_this_level_p (tree t, void* data)
5789 : : {
5790 : 3237030 : int this_level = *(int *)data;
5791 : 3237030 : int level;
5792 : :
5793 : 3237030 : if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
5794 : 388635 : level = TEMPLATE_PARM_LEVEL (t);
5795 : : else
5796 : 2848395 : level = TEMPLATE_TYPE_LEVEL (t);
5797 : 3237030 : return level == this_level;
5798 : : }
5799 : :
5800 : : /* Worker for uses_outer_template_parms, called via for_each_template_parm.
5801 : : DATA is really an int, indicating the innermost outer level of parameters.
5802 : : If T is a template parameter of that level or further out, return
5803 : : nonzero. */
5804 : :
5805 : : static int
5806 : 8619982 : template_parm_outer_level (tree t, void *data)
5807 : : {
5808 : 8619982 : int this_level = *(int *)data;
5809 : 8619982 : int level;
5810 : :
5811 : 8619982 : if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
5812 : 247477 : level = TEMPLATE_PARM_LEVEL (t);
5813 : : else
5814 : 8372505 : level = TEMPLATE_TYPE_LEVEL (t);
5815 : 8619982 : return level <= this_level;
5816 : : }
5817 : :
5818 : : /* Creates a TEMPLATE_DECL for the indicated DECL using the template
5819 : : parameters given by current_template_args, or reuses a
5820 : : previously existing one, if appropriate. Returns the DECL, or an
5821 : : equivalent one, if it is replaced via a call to duplicate_decls.
5822 : :
5823 : : If IS_FRIEND is true, DECL is a friend declaration. */
5824 : :
5825 : : tree
5826 : 270805156 : push_template_decl (tree decl, bool is_friend)
5827 : : {
5828 : 270805156 : if (decl == error_mark_node || !current_template_parms)
5829 : : return error_mark_node;
5830 : :
5831 : : /* See if this is a partial specialization. */
5832 : 65212066 : bool is_partial = ((DECL_IMPLICIT_TYPEDEF_P (decl)
5833 : 17735620 : && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE
5834 : 17473338 : && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)))
5835 : 329654413 : || (VAR_P (decl)
5836 : 50061762 : && DECL_LANG_SPECIFIC (decl)
5837 : 5021392 : && DECL_TEMPLATE_SPECIALIZATION (decl)
5838 : 578498 : && TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (decl))));
5839 : :
5840 : : /* No surprising friend functions. */
5841 : 270805136 : gcc_checking_assert (is_friend
5842 : : || !(TREE_CODE (decl) == FUNCTION_DECL
5843 : : && DECL_UNIQUE_FRIEND_P (decl)));
5844 : :
5845 : 270805136 : tree ctx;
5846 : 270805136 : if (is_friend)
5847 : : /* For a friend, we want the context of the friend, not
5848 : : the type of which it is a friend. */
5849 : 6134969 : ctx = CP_DECL_CONTEXT (decl);
5850 : 264670167 : else if (CP_DECL_CONTEXT (decl)
5851 : 264670167 : && TREE_CODE (CP_DECL_CONTEXT (decl)) != NAMESPACE_DECL)
5852 : : /* In the case of a virtual function, we want the class in which
5853 : : it is defined. */
5854 : 219530349 : ctx = CP_DECL_CONTEXT (decl);
5855 : : else
5856 : : /* Otherwise, if we're currently defining some class, the DECL
5857 : : is assumed to be a member of the class. */
5858 : 45139818 : ctx = current_scope ();
5859 : :
5860 : 270805136 : if (ctx && TREE_CODE (ctx) == NAMESPACE_DECL)
5861 : 51251700 : ctx = NULL_TREE;
5862 : :
5863 : 270805136 : if (!DECL_CONTEXT (decl))
5864 : 133 : DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
5865 : :
5866 : : /* See if this is a primary template. */
5867 : 270805136 : bool is_primary = false;
5868 : 270805136 : if (is_friend && ctx
5869 : 270805136 : && uses_template_parms_level (ctx, current_template_depth))
5870 : : /* A friend template that specifies a class context, i.e.
5871 : : template <typename T> friend void A<T>::f();
5872 : : is not primary. */
5873 : : ;
5874 : 315242617 : else if (TREE_CODE (decl) == TYPE_DECL && LAMBDA_TYPE_P (TREE_TYPE (decl)))
5875 : : /* Lambdas are not primary. */
5876 : : ;
5877 : : else
5878 : 269831632 : is_primary = template_parm_scope_p ();
5879 : :
5880 : : /* True if the template is a member template, in the sense of
5881 : : [temp.mem]. */
5882 : 269831632 : bool member_template_p = false;
5883 : :
5884 : 269831632 : if (is_primary)
5885 : : {
5886 : 66092744 : warning (OPT_Wtemplates, "template %qD declared", decl);
5887 : :
5888 : 66092744 : if (DECL_CLASS_SCOPE_P (decl))
5889 : : member_template_p = true;
5890 : :
5891 : 66092744 : if (TREE_CODE (decl) == TYPE_DECL
5892 : 66092744 : && IDENTIFIER_ANON_P (DECL_NAME (decl)))
5893 : : {
5894 : 6 : error ("template class without a name");
5895 : 6 : return error_mark_node;
5896 : : }
5897 : 66092738 : else if (TREE_CODE (decl) == FUNCTION_DECL)
5898 : : {
5899 : 43462321 : if (member_template_p)
5900 : : {
5901 : 16275607 : if (DECL_OVERRIDE_P (decl) || DECL_FINAL_P (decl))
5902 : 6 : error ("member template %qD may not have virt-specifiers", decl);
5903 : : }
5904 : 86924642 : if (DECL_DESTRUCTOR_P (decl))
5905 : : {
5906 : : /* [temp.mem]
5907 : :
5908 : : A destructor shall not be a member template. */
5909 : 6 : error_at (DECL_SOURCE_LOCATION (decl),
5910 : : "destructor %qD declared as member template", decl);
5911 : 6 : return error_mark_node;
5912 : : }
5913 : 86924630 : if (IDENTIFIER_NEWDEL_OP_P (DECL_NAME (decl))
5914 : 43466654 : && (!prototype_p (TREE_TYPE (decl))
5915 : 4339 : || TYPE_ARG_TYPES (TREE_TYPE (decl)) == void_list_node
5916 : 4339 : || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
5917 : 4339 : || (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
5918 : : == void_list_node)))
5919 : : {
5920 : : /* [basic.stc.dynamic.allocation]
5921 : :
5922 : : An allocation function can be a function
5923 : : template. ... Template allocation functions shall
5924 : : have two or more parameters. */
5925 : 9 : error ("invalid template declaration of %qD", decl);
5926 : 9 : return error_mark_node;
5927 : : }
5928 : : }
5929 : 19612285 : else if (DECL_IMPLICIT_TYPEDEF_P (decl)
5930 : 38642696 : && CLASS_TYPE_P (TREE_TYPE (decl)))
5931 : : /* Class template. */;
5932 : 6618144 : else if (TREE_CODE (decl) == TYPE_DECL
5933 : 6618144 : && TYPE_DECL_ALIAS_P (decl))
5934 : : /* alias-declaration */
5935 : 3600003 : gcc_assert (!DECL_ARTIFICIAL (decl));
5936 : 3018141 : else if (VAR_P (decl))
5937 : : /* C++14 variable template. */;
5938 : 581182 : else if (TREE_CODE (decl) == CONCEPT_DECL)
5939 : : /* C++20 concept definitions. */;
5940 : : else
5941 : : {
5942 : 9 : error ("template declaration of %q#D", decl);
5943 : 9 : return error_mark_node;
5944 : : }
5945 : : }
5946 : :
5947 : 65212051 : bool local_p = (!DECL_IMPLICIT_TYPEDEF_P (decl)
5948 : 318281549 : && ((ctx && TREE_CODE (ctx) == FUNCTION_DECL)
5949 : 197153701 : || (VAR_OR_FUNCTION_DECL_P (decl)
5950 : 159700983 : && DECL_LOCAL_DECL_P (decl))));
5951 : :
5952 : : /* Check to see that the rules regarding the use of default
5953 : : arguments are not being violated. We check args for a friend
5954 : : functions when we know whether it's a definition, introducing
5955 : : declaration or re-declaration. */
5956 : 214889309 : if (!local_p && (!is_friend || TREE_CODE (decl) != FUNCTION_DECL))
5957 : 209107099 : check_default_tmpl_args (decl, current_template_parms,
5958 : : is_primary, is_partial, is_friend);
5959 : :
5960 : : /* Ensure that there are no parameter packs in the type of this
5961 : : declaration that have not been expanded. */
5962 : 270805106 : if (TREE_CODE (decl) == FUNCTION_DECL)
5963 : : {
5964 : : /* Check each of the arguments individually to see if there are
5965 : : any bare parameter packs. */
5966 : 154950120 : tree type = TREE_TYPE (decl);
5967 : 154950120 : tree arg = DECL_ARGUMENTS (decl);
5968 : 154950120 : tree argtype = TYPE_ARG_TYPES (type);
5969 : :
5970 : 496488342 : while (arg && argtype)
5971 : : {
5972 : 341538222 : if (!DECL_PACK_P (arg)
5973 : 678652756 : && check_for_bare_parameter_packs (TREE_TYPE (arg)))
5974 : : {
5975 : : /* This is a PARM_DECL that contains unexpanded parameter
5976 : : packs. We have already complained about this in the
5977 : : check_for_bare_parameter_packs call, so just replace
5978 : : these types with ERROR_MARK_NODE. */
5979 : 42 : TREE_TYPE (arg) = error_mark_node;
5980 : 42 : TREE_VALUE (argtype) = error_mark_node;
5981 : : }
5982 : :
5983 : 341538222 : arg = DECL_CHAIN (arg);
5984 : 341538222 : argtype = TREE_CHAIN (argtype);
5985 : : }
5986 : :
5987 : : /* Check for bare parameter packs in the return type and the
5988 : : exception specifiers. */
5989 : 154950120 : if (check_for_bare_parameter_packs (TREE_TYPE (type)))
5990 : : /* Errors were already issued, set return type to int
5991 : : as the frontend doesn't expect error_mark_node as
5992 : : the return type. */
5993 : 3 : TREE_TYPE (type) = integer_type_node;
5994 : 154950120 : if (check_for_bare_parameter_packs (TYPE_RAISES_EXCEPTIONS (type)))
5995 : 0 : TYPE_RAISES_EXCEPTIONS (type) = NULL_TREE;
5996 : : }
5997 : : else
5998 : : {
5999 : 231709972 : if (check_for_bare_parameter_packs (is_typedef_decl (decl)
6000 : : ? DECL_ORIGINAL_TYPE (decl)
6001 : 68378613 : : TREE_TYPE (decl)))
6002 : : {
6003 : 64 : TREE_TYPE (decl) = error_mark_node;
6004 : 64 : return error_mark_node;
6005 : : }
6006 : :
6007 : 6941242 : if (is_partial && VAR_P (decl)
6008 : 116433408 : && check_for_bare_parameter_packs (DECL_TI_ARGS (decl)))
6009 : 3 : return error_mark_node;
6010 : : }
6011 : :
6012 : 270805039 : if (is_partial)
6013 : 6941239 : return process_partial_specialization (decl);
6014 : :
6015 : 263863800 : tree args = current_template_args ();
6016 : 263863800 : tree tmpl = NULL_TREE;
6017 : 263863800 : bool new_template_p = false;
6018 : 263863800 : if (local_p)
6019 : : {
6020 : : /* Does not get a template head. */
6021 : 55915788 : tmpl = NULL_TREE;
6022 : 55915788 : gcc_checking_assert (!is_primary);
6023 : : }
6024 : 207948012 : else if (!ctx
6025 : 163037687 : || TREE_CODE (ctx) == FUNCTION_DECL
6026 : 162396172 : || (CLASS_TYPE_P (ctx) && TYPE_BEING_DEFINED (ctx))
6027 : 58438239 : || (TREE_CODE (decl) == TYPE_DECL && LAMBDA_TYPE_P (TREE_TYPE (decl)))
6028 : 266296396 : || (is_friend && !(DECL_LANG_SPECIFIC (decl)
6029 : 72 : && DECL_TEMPLATE_INFO (decl))))
6030 : : {
6031 : 149599703 : if (DECL_LANG_SPECIFIC (decl)
6032 : 136110964 : && DECL_TEMPLATE_INFO (decl)
6033 : 153338186 : && DECL_TI_TEMPLATE (decl))
6034 : 3738483 : tmpl = DECL_TI_TEMPLATE (decl);
6035 : : /* If DECL is a TYPE_DECL for a class-template, then there won't
6036 : : be DECL_LANG_SPECIFIC. The information equivalent to
6037 : : DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
6038 : 48154686 : else if (DECL_IMPLICIT_TYPEDEF_P (decl)
6039 : 11283159 : && TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
6040 : 145910364 : && TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
6041 : : {
6042 : : /* Since a template declaration already existed for this
6043 : : class-type, we must be redeclaring it here. Make sure
6044 : : that the redeclaration is valid. */
6045 : 24572 : redeclare_class_template (TREE_TYPE (decl),
6046 : : current_template_parms,
6047 : : current_template_constraints ());
6048 : : /* We don't need to create a new TEMPLATE_DECL; just use the
6049 : : one we already had. */
6050 : 49144 : tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
6051 : : }
6052 : : else
6053 : : {
6054 : 145836648 : tmpl = build_template_decl (decl, current_template_parms,
6055 : : member_template_p);
6056 : 145836648 : new_template_p = true;
6057 : :
6058 : 145836648 : if (DECL_LANG_SPECIFIC (decl)
6059 : 145836648 : && DECL_TEMPLATE_SPECIALIZATION (decl))
6060 : : {
6061 : : /* A specialization of a member template of a template
6062 : : class. */
6063 : 0 : SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
6064 : 0 : DECL_TEMPLATE_INFO (tmpl) = DECL_TEMPLATE_INFO (decl);
6065 : 0 : DECL_TEMPLATE_INFO (decl) = NULL_TREE;
6066 : : }
6067 : : }
6068 : : }
6069 : : else
6070 : : {
6071 : 58348309 : tree a, t, current, parms;
6072 : 58348309 : int i;
6073 : 58348309 : tree tinfo = get_template_info (decl);
6074 : :
6075 : 58348309 : if (!tinfo)
6076 : : {
6077 : 15 : error ("template definition of non-template %q#D", decl);
6078 : 15 : return error_mark_node;
6079 : : }
6080 : :
6081 : 58348294 : tmpl = TI_TEMPLATE (tinfo);
6082 : :
6083 : 58348294 : if (DECL_FUNCTION_TEMPLATE_P (tmpl)
6084 : 57947731 : && DECL_TEMPLATE_INFO (decl) && DECL_TI_ARGS (decl)
6085 : 57947731 : && DECL_TEMPLATE_SPECIALIZATION (decl)
6086 : 58348312 : && DECL_MEMBER_TEMPLATE_P (tmpl))
6087 : : {
6088 : : /* The declaration is a specialization of a member
6089 : : template, declared outside the class. Therefore, the
6090 : : innermost template arguments will be NULL, so we
6091 : : replace them with the arguments determined by the
6092 : : earlier call to check_explicit_specialization. */
6093 : 12 : args = DECL_TI_ARGS (decl);
6094 : :
6095 : 12 : tree new_tmpl
6096 : 12 : = build_template_decl (decl, current_template_parms,
6097 : : member_template_p);
6098 : 12 : DECL_TI_TEMPLATE (decl) = new_tmpl;
6099 : 12 : SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl);
6100 : 12 : DECL_TEMPLATE_INFO (new_tmpl)
6101 : 12 : = build_template_info (tmpl, args);
6102 : :
6103 : 12 : register_specialization (new_tmpl,
6104 : : most_general_template (tmpl),
6105 : : args,
6106 : : is_friend, 0);
6107 : 12 : return decl;
6108 : : }
6109 : :
6110 : : /* Make sure the template headers we got make sense. */
6111 : :
6112 : 58348282 : parms = DECL_TEMPLATE_PARMS (tmpl);
6113 : 58348282 : i = TMPL_PARMS_DEPTH (parms);
6114 : 162449544 : if (TMPL_ARGS_DEPTH (args) != i)
6115 : : {
6116 : 12 : error ("expected %d levels of template parms for %q#D, got %d",
6117 : 6 : i, decl, TMPL_ARGS_DEPTH (args));
6118 : 6 : DECL_INTERFACE_KNOWN (decl) = 1;
6119 : 6 : return error_mark_node;
6120 : : }
6121 : : else
6122 : 129357226 : for (current = decl; i > 0; --i, parms = TREE_CHAIN (parms))
6123 : : {
6124 : 142017930 : a = TMPL_ARGS_LEVEL (args, i);
6125 : 71008965 : t = INNERMOST_TEMPLATE_PARMS (parms);
6126 : :
6127 : 71008965 : if (TREE_VEC_LENGTH (t) != TREE_VEC_LENGTH (a))
6128 : : {
6129 : 15 : if (current == decl)
6130 : 15 : error ("got %d template parameters for %q#D",
6131 : 15 : TREE_VEC_LENGTH (a), decl);
6132 : : else
6133 : 0 : error ("got %d template parameters for %q#T",
6134 : 0 : TREE_VEC_LENGTH (a), current);
6135 : 15 : error (" but %d required", TREE_VEC_LENGTH (t));
6136 : : /* Avoid crash in import_export_decl. */
6137 : 15 : DECL_INTERFACE_KNOWN (decl) = 1;
6138 : 15 : return error_mark_node;
6139 : : }
6140 : :
6141 : 71008950 : if (current == decl)
6142 : : current = ctx;
6143 : 12660689 : else if (current == NULL_TREE)
6144 : : /* Can happen in erroneous input. */
6145 : : break;
6146 : : else
6147 : 12660689 : current = get_containing_scope (current);
6148 : : }
6149 : :
6150 : : /* Check that the parms are used in the appropriate qualifying scopes
6151 : : in the declarator. */
6152 : 116696522 : if (!comp_template_args
6153 : 58348261 : (TI_ARGS (tinfo),
6154 : 58348261 : TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl)))))
6155 : : {
6156 : 3 : auto_diagnostic_group d;
6157 : 3 : error ("template arguments to %qD do not match original "
6158 : 3 : "template %qD", decl, DECL_TEMPLATE_RESULT (tmpl));
6159 : 3 : if (!uses_template_parms (TI_ARGS (tinfo)))
6160 : 3 : inform (input_location, "use %<template<>%> for"
6161 : : " an explicit specialization");
6162 : : /* Avoid crash in import_export_decl. */
6163 : 3 : DECL_INTERFACE_KNOWN (decl) = 1;
6164 : 3 : return error_mark_node;
6165 : 3 : }
6166 : :
6167 : : /* Check that the constraints for each enclosing template scope are
6168 : : consistent with the original declarations. */
6169 : 58348258 : if (flag_concepts)
6170 : : {
6171 : 15299989 : tree decl_parms = DECL_TEMPLATE_PARMS (tmpl);
6172 : 15299989 : tree scope_parms = current_template_parms;
6173 : 15299989 : if (PRIMARY_TEMPLATE_P (tmpl))
6174 : : {
6175 : 4354546 : decl_parms = TREE_CHAIN (decl_parms);
6176 : 4354546 : scope_parms = TREE_CHAIN (scope_parms);
6177 : : }
6178 : 29804052 : while (decl_parms)
6179 : : {
6180 : 14504081 : if (!template_requirements_equivalent_p (decl_parms, scope_parms))
6181 : : {
6182 : 18 : error ("redeclaration of %qD with different constraints",
6183 : 18 : TPARMS_PRIMARY_TEMPLATE (TREE_VALUE (decl_parms)));
6184 : 18 : break;
6185 : : }
6186 : 14504063 : decl_parms = TREE_CHAIN (decl_parms);
6187 : 14504063 : scope_parms = TREE_CHAIN (scope_parms);
6188 : : }
6189 : : }
6190 : : }
6191 : :
6192 : 415895922 : gcc_checking_assert (!tmpl || DECL_TEMPLATE_RESULT (tmpl) == decl);
6193 : :
6194 : 263863749 : if (new_template_p)
6195 : : {
6196 : : /* Push template declarations for global functions and types.
6197 : : Note that we do not try to push a global template friend
6198 : : declared in a template class; such a thing may well depend on
6199 : : the template parameters of the class and we'll push it when
6200 : : instantiating the befriending class. */
6201 : 145836648 : if (!ctx
6202 : 145836648 : && !(is_friend && template_class_depth (current_class_type) > 0))
6203 : : {
6204 : 39067886 : tree pushed = pushdecl_namespace_level (tmpl, /*hiding=*/is_friend);
6205 : 39067886 : if (pushed == error_mark_node)
6206 : : return error_mark_node;
6207 : :
6208 : : /* pushdecl may have found an existing template. */
6209 : 39067829 : if (pushed != tmpl)
6210 : : {
6211 : 2941408 : decl = DECL_TEMPLATE_RESULT (pushed);
6212 : 2941408 : tmpl = NULL_TREE;
6213 : : }
6214 : : }
6215 : 106768762 : else if (is_friend)
6216 : : {
6217 : : /* Record this decl as belonging to the current class. It's
6218 : : not chained onto anything else. */
6219 : 2610214 : DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (tmpl) = true;
6220 : 2610214 : gcc_checking_assert (!DECL_CHAIN (tmpl));
6221 : 2610214 : DECL_CHAIN (tmpl) = current_scope ();
6222 : : }
6223 : : }
6224 : 118027101 : else if (tmpl)
6225 : : /* The type may have been completed, or (erroneously) changed. */
6226 : 62111313 : TREE_TYPE (tmpl) = TREE_TYPE (decl);
6227 : :
6228 : 207947904 : if (tmpl)
6229 : : {
6230 : 205006496 : if (is_primary)
6231 : : {
6232 : 56210013 : tree parms = DECL_TEMPLATE_PARMS (tmpl);
6233 : :
6234 : 56210013 : DECL_PRIMARY_TEMPLATE (tmpl) = tmpl;
6235 : :
6236 : : /* Give template template parms a DECL_CONTEXT of the template
6237 : : for which they are a parameter. */
6238 : 56210013 : parms = INNERMOST_TEMPLATE_PARMS (parms);
6239 : 160011869 : for (int i = TREE_VEC_LENGTH (parms) - 1; i >= 0; --i)
6240 : : {
6241 : 103801856 : tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
6242 : 103801856 : if (TREE_CODE (parm) == TEMPLATE_DECL)
6243 : 191645 : DECL_CONTEXT (parm) = tmpl;
6244 : : }
6245 : :
6246 : 56210013 : if (TREE_CODE (decl) == TYPE_DECL
6247 : 56210013 : && TYPE_DECL_ALIAS_P (decl))
6248 : : {
6249 : 3599973 : if (tree constr
6250 : 3599973 : = TEMPLATE_PARMS_CONSTRAINTS (DECL_TEMPLATE_PARMS (tmpl)))
6251 : : {
6252 : : /* ??? Why don't we do this here for all templates? */
6253 : 69762 : constr = build_constraints (constr, NULL_TREE);
6254 : 69762 : set_constraints (decl, constr);
6255 : : }
6256 : : }
6257 : : }
6258 : :
6259 : : /* The DECL_TI_ARGS of DECL contains full set of arguments
6260 : : referring wback to its most general template. If TMPL is a
6261 : : specialization, ARGS may only have the innermost set of
6262 : : arguments. Add the missing argument levels if necessary. */
6263 : 205006496 : if (DECL_TEMPLATE_INFO (tmpl))
6264 : 1188 : args = add_outermost_template_args (DECL_TI_ARGS (tmpl), args);
6265 : :
6266 : 205006496 : tree info = build_template_info (tmpl, args);
6267 : :
6268 : 205006496 : if (DECL_IMPLICIT_TYPEDEF_P (decl))
6269 : 11372795 : SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl), info);
6270 : : else
6271 : : {
6272 : 193633701 : retrofit_lang_decl (decl);
6273 : 193633701 : DECL_TEMPLATE_INFO (decl) = info;
6274 : : }
6275 : : }
6276 : :
6277 : 263863692 : if (is_typedef_decl (decl)
6278 : 47476355 : && (dependent_opaque_alias_p (TREE_TYPE (decl))
6279 : 47476261 : || dependent_alias_template_spec_p (TREE_TYPE (decl), nt_opaque)))
6280 : : {
6281 : : /* Manually mark such aliases as dependent so that dependent_type_p_r
6282 : : doesn't have to handle them. */
6283 : 469631 : TYPE_DEPENDENT_P_VALID (TREE_TYPE (decl)) = true;
6284 : 469631 : TYPE_DEPENDENT_P (TREE_TYPE (decl)) = true;
6285 : : /* The identity of such aliases is hairy; see structural_comptypes. */
6286 : 469631 : SET_TYPE_STRUCTURAL_EQUALITY (TREE_TYPE (decl));
6287 : : }
6288 : :
6289 : 263863692 : if (flag_implicit_templates
6290 : 263159332 : && !is_friend
6291 : 257031152 : && TREE_PUBLIC (decl)
6292 : 151452735 : && VAR_OR_FUNCTION_DECL_P (decl))
6293 : : /* Set DECL_COMDAT on template instantiations; if we force
6294 : : them to be emitted by explicit instantiation,
6295 : : mark_needed will tell cgraph to do the right thing. */
6296 : 151338790 : DECL_COMDAT (decl) = true;
6297 : :
6298 : 468870188 : gcc_checking_assert (!tmpl || DECL_TEMPLATE_RESULT (tmpl) == decl);
6299 : :
6300 : : return decl;
6301 : : }
6302 : :
6303 : : /* FN is an inheriting constructor that inherits from the constructor
6304 : : template INHERITED; turn FN into a constructor template with a matching
6305 : : template header. */
6306 : :
6307 : : tree
6308 : 61198 : add_inherited_template_parms (tree fn, tree inherited)
6309 : : {
6310 : 61198 : tree inner_parms
6311 : 61198 : = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (inherited));
6312 : 61198 : inner_parms = copy_node (inner_parms);
6313 : 61198 : tree parms
6314 : 61198 : = tree_cons (size_int (current_template_depth + 1),
6315 : : inner_parms, current_template_parms);
6316 : 61198 : tree tmpl = build_template_decl (fn, parms, /*member*/true);
6317 : 61198 : tree args = template_parms_to_args (parms);
6318 : 61198 : DECL_TEMPLATE_INFO (fn) = build_template_info (tmpl, args);
6319 : 61198 : DECL_ARTIFICIAL (tmpl) = true;
6320 : 61198 : DECL_PRIMARY_TEMPLATE (tmpl) = tmpl;
6321 : 61198 : return tmpl;
6322 : : }
6323 : :
6324 : : /* Called when a class template TYPE is redeclared with the indicated
6325 : : template PARMS, e.g.:
6326 : :
6327 : : template <class T> struct S;
6328 : : template <class T> struct S {}; */
6329 : :
6330 : : bool
6331 : 2100614 : redeclare_class_template (tree type, tree parms, tree cons)
6332 : : {
6333 : 2100614 : tree tmpl;
6334 : 2100614 : tree tmpl_parms;
6335 : 2100614 : int i;
6336 : :
6337 : 2100614 : if (!TYPE_TEMPLATE_INFO (type))
6338 : : {
6339 : 0 : error ("%qT is not a template type", type);
6340 : 0 : return false;
6341 : : }
6342 : :
6343 : 2100614 : tmpl = TYPE_TI_TEMPLATE (type);
6344 : 2100614 : if (!PRIMARY_TEMPLATE_P (tmpl))
6345 : : /* The type is nested in some template class. Nothing to worry
6346 : : about here; there are no new template parameters for the nested
6347 : : type. */
6348 : : return true;
6349 : :
6350 : 2100614 : if (!parms)
6351 : : {
6352 : 3 : error ("template specifiers not specified in declaration of %qD",
6353 : : tmpl);
6354 : 3 : return false;
6355 : : }
6356 : :
6357 : 2100611 : parms = INNERMOST_TEMPLATE_PARMS (parms);
6358 : 2100611 : tmpl_parms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl);
6359 : :
6360 : 2100611 : if (TREE_VEC_LENGTH (parms) != TREE_VEC_LENGTH (tmpl_parms))
6361 : : {
6362 : 21 : auto_diagnostic_group d;
6363 : 21 : error_n (input_location, TREE_VEC_LENGTH (parms),
6364 : : "redeclared with %d template parameter",
6365 : : "redeclared with %d template parameters",
6366 : 21 : TREE_VEC_LENGTH (parms));
6367 : 42 : inform_n (DECL_SOURCE_LOCATION (tmpl), TREE_VEC_LENGTH (tmpl_parms),
6368 : : "previous declaration %qD used %d template parameter",
6369 : : "previous declaration %qD used %d template parameters",
6370 : 21 : tmpl, TREE_VEC_LENGTH (tmpl_parms));
6371 : 21 : return false;
6372 : 21 : }
6373 : :
6374 : 5645671 : for (i = 0; i < TREE_VEC_LENGTH (tmpl_parms); ++i)
6375 : : {
6376 : 3545129 : tree tmpl_parm;
6377 : 3545129 : tree parm;
6378 : :
6379 : 3545129 : if (TREE_VEC_ELT (tmpl_parms, i) == error_mark_node
6380 : 3545129 : || TREE_VEC_ELT (parms, i) == error_mark_node)
6381 : 0 : continue;
6382 : :
6383 : 3545129 : tmpl_parm = TREE_VALUE (TREE_VEC_ELT (tmpl_parms, i));
6384 : 3545129 : if (error_operand_p (tmpl_parm))
6385 : : return false;
6386 : :
6387 : 3545114 : parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
6388 : :
6389 : : /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
6390 : : TEMPLATE_DECL. */
6391 : 3545114 : if (TREE_CODE (tmpl_parm) != TREE_CODE (parm)
6392 : 3545102 : || (TREE_CODE (tmpl_parm) != TYPE_DECL
6393 : 354959 : && !same_type_p (TREE_TYPE (tmpl_parm), TREE_TYPE (parm)))
6394 : 3545093 : || (TREE_CODE (tmpl_parm) != PARM_DECL
6395 : 3190719 : && (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (tmpl_parm))
6396 : 3190719 : != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm))))
6397 : 7090204 : || (TREE_CODE (tmpl_parm) == PARM_DECL
6398 : 354374 : && (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (tmpl_parm))
6399 : 354374 : != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)))))
6400 : : {
6401 : 27 : auto_diagnostic_group d;
6402 : 27 : error ("template parameter %q+#D", tmpl_parm);
6403 : 27 : if (DECL_P (parm))
6404 : 24 : inform (DECL_SOURCE_LOCATION (parm), "redeclared here as %q#D", parm);
6405 : : else
6406 : 3 : inform (input_location, "redeclared here");
6407 : 27 : return false;
6408 : 27 : }
6409 : :
6410 : : /* The parameters can be declared to introduce different
6411 : : constraints. */
6412 : 3545087 : tree p1 = TREE_VEC_ELT (tmpl_parms, i);
6413 : 3545087 : tree p2 = TREE_VEC_ELT (parms, i);
6414 : 3545087 : if (!template_parameter_constraints_equivalent_p (p1, p2))
6415 : : {
6416 : 6 : auto_diagnostic_group d;
6417 : 6 : error ("declaration of template parameter %q+#D with different "
6418 : : "constraints", parm);
6419 : 6 : inform (DECL_SOURCE_LOCATION (tmpl_parm),
6420 : : "original declaration appeared here");
6421 : 6 : return false;
6422 : 6 : }
6423 : :
6424 : : /* Give each template template parm in this redeclaration a
6425 : : DECL_CONTEXT of the template for which they are a parameter. */
6426 : 3545081 : if (TREE_CODE (parm) == TEMPLATE_DECL)
6427 : : {
6428 : 576 : gcc_checking_assert (DECL_CONTEXT (parm) == NULL_TREE
6429 : : || DECL_CONTEXT (parm) == tmpl);
6430 : 576 : DECL_CONTEXT (parm) = tmpl;
6431 : : }
6432 : : }
6433 : :
6434 : 2100542 : if (!merge_default_template_args (parms, tmpl_parms, /*class_p=*/true))
6435 : : return false;
6436 : :
6437 : 2100539 : tree ci = get_constraints (tmpl);
6438 : 2109256 : tree req1 = ci ? CI_TEMPLATE_REQS (ci) : NULL_TREE;
6439 : 2109259 : tree req2 = cons ? CI_TEMPLATE_REQS (cons) : NULL_TREE;
6440 : :
6441 : : /* Two classes with different constraints declare different entities. */
6442 : 2100539 : if (!cp_tree_equal (req1, req2))
6443 : : {
6444 : 15 : auto_diagnostic_group d;
6445 : 15 : error_at (input_location, "redeclaration of %q#D with different "
6446 : : "constraints", tmpl);
6447 : 15 : inform (DECL_SOURCE_LOCATION (tmpl),
6448 : : "original declaration appeared here");
6449 : 15 : return false;
6450 : 15 : }
6451 : :
6452 : : return true;
6453 : : }
6454 : :
6455 : : /* The actual substitution part of instantiate_non_dependent_expr,
6456 : : to be used when the caller has already checked
6457 : : !instantiation_dependent_uneval_expression_p (expr)
6458 : : and cleared processing_template_decl. */
6459 : :
6460 : : tree
6461 : 62678957 : instantiate_non_dependent_expr_internal (tree expr, tsubst_flags_t complain)
6462 : : {
6463 : 62678957 : return tsubst_expr (expr, /*args=*/NULL_TREE, complain, /*in_decl=*/NULL_TREE);
6464 : : }
6465 : :
6466 : : /* Instantiate the non-dependent expression EXPR. */
6467 : :
6468 : : tree
6469 : 107465414 : instantiate_non_dependent_expr (tree expr,
6470 : : tsubst_flags_t complain /* = tf_error */)
6471 : : {
6472 : 107465414 : if (expr == NULL_TREE)
6473 : : return NULL_TREE;
6474 : :
6475 : 107465414 : if (processing_template_decl)
6476 : : {
6477 : : /* The caller should have checked this already. */
6478 : 29764660 : gcc_checking_assert (!instantiation_dependent_uneval_expression_p (expr));
6479 : 29764660 : processing_template_decl_sentinel s;
6480 : 29764660 : expr = instantiate_non_dependent_expr_internal (expr, complain);
6481 : 29764660 : }
6482 : : return expr;
6483 : : }
6484 : :
6485 : : /* Like instantiate_non_dependent_expr, but return NULL_TREE if the
6486 : : expression is dependent or non-constant. */
6487 : :
6488 : : tree
6489 : 108219586 : instantiate_non_dependent_or_null (tree expr)
6490 : : {
6491 : 108219586 : if (expr == NULL_TREE)
6492 : : return NULL_TREE;
6493 : 98170009 : if (processing_template_decl)
6494 : : {
6495 : 66185 : if (!is_nondependent_constant_expression (expr))
6496 : : expr = NULL_TREE;
6497 : : else
6498 : : {
6499 : 61359 : processing_template_decl_sentinel s;
6500 : 61359 : expr = instantiate_non_dependent_expr_internal (expr, tf_error);
6501 : 61359 : }
6502 : : }
6503 : : return expr;
6504 : : }
6505 : :
6506 : : /* True iff T is a specialization of a variable template. */
6507 : :
6508 : : bool
6509 : 193640704 : variable_template_specialization_p (tree t)
6510 : : {
6511 : 193640704 : if (!VAR_P (t) || !DECL_LANG_SPECIFIC (t) || !DECL_TEMPLATE_INFO (t))
6512 : : return false;
6513 : 12137809 : tree tmpl = DECL_TI_TEMPLATE (t);
6514 : 12137809 : return variable_template_p (tmpl);
6515 : : }
6516 : :
6517 : : /* Return TRUE iff T is a type alias, a TEMPLATE_DECL for an alias
6518 : : template declaration, or a TYPE_DECL for an alias declaration. */
6519 : :
6520 : : bool
6521 : 138946626 : alias_type_or_template_p (tree t)
6522 : : {
6523 : 138946626 : if (t == NULL_TREE)
6524 : : return false;
6525 : 0 : return ((TREE_CODE (t) == TYPE_DECL && TYPE_DECL_ALIAS_P (t))
6526 : 138946626 : || (TYPE_P (t)
6527 : 138946626 : && TYPE_NAME (t)
6528 : 138946626 : && TYPE_DECL_ALIAS_P (TYPE_NAME (t)))
6529 : 272675252 : || DECL_ALIAS_TEMPLATE_P (t));
6530 : : }
6531 : :
6532 : : /* If T is a specialization of an alias template, return it; otherwise return
6533 : : NULL_TREE. If TRANSPARENT_TYPEDEFS is true, look through other aliases. */
6534 : :
6535 : : tree
6536 : 20212053652 : alias_template_specialization_p (const_tree t,
6537 : : bool transparent_typedefs)
6538 : : {
6539 : 20212053652 : if (!TYPE_P (t))
6540 : : return NULL_TREE;
6541 : :
6542 : : /* It's an alias template specialization if it's an alias and its
6543 : : TYPE_NAME is a specialization of a primary template. */
6544 : 20212053652 : if (typedef_variant_p (t))
6545 : : {
6546 : 491671765 : if (tree tinfo = TYPE_ALIAS_TEMPLATE_INFO (t))
6547 : 438071480 : if (PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo)))
6548 : : return CONST_CAST_TREE (t);
6549 : 300554051 : if (transparent_typedefs && !dependent_opaque_alias_p (t))
6550 : 129411 : return alias_template_specialization_p (DECL_ORIGINAL_TYPE
6551 : : (TYPE_NAME (t)),
6552 : 129411 : transparent_typedefs);
6553 : : }
6554 : :
6555 : : return NULL_TREE;
6556 : : }
6557 : :
6558 : : /* A cache of the result of complex_alias_template_p. */
6559 : :
6560 : : static GTY((deletable)) hash_map<const_tree, tree> *complex_alias_tmpl_info;
6561 : :
6562 : : /* Data structure for complex_alias_template_*. */
6563 : :
6564 : : struct uses_all_template_parms_data
6565 : : {
6566 : : int level;
6567 : : tree *seen;
6568 : : };
6569 : :
6570 : : /* walk_tree callback for complex_alias_template_p. */
6571 : :
6572 : : static tree
6573 : 49825745 : complex_alias_template_r (tree *tp, int *walk_subtrees, void *data_)
6574 : : {
6575 : 49825745 : tree t = *tp;
6576 : 49825745 : auto &data = *(struct uses_all_template_parms_data*)data_;
6577 : :
6578 : 49825745 : switch (TREE_CODE (t))
6579 : : {
6580 : 9622939 : case TEMPLATE_TYPE_PARM:
6581 : 9622939 : case TEMPLATE_PARM_INDEX:
6582 : 9622939 : case TEMPLATE_TEMPLATE_PARM:
6583 : 9622939 : case BOUND_TEMPLATE_TEMPLATE_PARM:
6584 : 9622939 : {
6585 : 9622939 : tree idx = get_template_parm_index (t);
6586 : 9622939 : if (TEMPLATE_PARM_LEVEL (idx) == data.level)
6587 : 7646280 : data.seen[TEMPLATE_PARM_IDX (idx)] = boolean_true_node;
6588 : : }
6589 : :
6590 : 49825745 : default:;
6591 : : }
6592 : :
6593 : 49825745 : if (!PACK_EXPANSION_P (t))
6594 : : return 0;
6595 : :
6596 : : /* An alias template with a pack expansion that expands a pack from the
6597 : : enclosing class needs to be considered complex, to avoid confusion with
6598 : : the same pack being used as an argument to the alias's own template
6599 : : parameter (91966). */
6600 : 2768497 : for (tree pack = PACK_EXPANSION_PARAMETER_PACKS (t); pack;
6601 : 887404 : pack = TREE_CHAIN (pack))
6602 : : {
6603 : 1025574 : tree parm_pack = TREE_VALUE (pack);
6604 : 1025574 : if (!TEMPLATE_PARM_P (parm_pack))
6605 : 39206 : continue;
6606 : 986368 : int idx, level;
6607 : 986368 : template_parm_level_and_index (parm_pack, &level, &idx);
6608 : 986368 : if (level < data.level)
6609 : 138170 : return t;
6610 : :
6611 : : /* Consider the expanded packs to be used outside the expansion... */
6612 : 848198 : data.seen[idx] = boolean_true_node;
6613 : : }
6614 : :
6615 : : /* ...but don't walk into the pattern. Consider PR104008:
6616 : :
6617 : : template <typename T, typename... Ts>
6618 : : using IsOneOf = disjunction<is_same<T, Ts>...>;
6619 : :
6620 : : where IsOneOf seemingly uses all of its template parameters in its
6621 : : expansion (and does not expand a pack from the enclosing class), so the
6622 : : alias was not marked as complex. However, if it is used like
6623 : : "IsOneOf<T>", the empty pack for Ts means that T no longer appears in the
6624 : : expansion. So only Ts is considered used by the pack expansion. */
6625 : 875569 : *walk_subtrees = false;
6626 : :
6627 : 875569 : return 0;
6628 : : }
6629 : :
6630 : : /* An alias template is complex from a SFINAE perspective if a template-id
6631 : : using that alias can be ill-formed when the expansion is not, as with
6632 : : the void_t template.
6633 : :
6634 : : If this predicate returns true in the ordinary case, the out parameter
6635 : : SEEN_OUT is set to a TREE_VEC containing boolean_true_node at element I if
6636 : : the I'th template parameter of the alias template is used in the alias. */
6637 : :
6638 : : static bool
6639 : 96207348 : complex_alias_template_p (const_tree tmpl, tree *seen_out)
6640 : : {
6641 : 96207348 : tmpl = most_general_template (tmpl);
6642 : 96207348 : if (!PRIMARY_TEMPLATE_P (tmpl))
6643 : : return false;
6644 : :
6645 : : /* A renaming alias isn't complex. */
6646 : 61873173 : if (get_underlying_template (CONST_CAST_TREE (tmpl)) != tmpl)
6647 : : return false;
6648 : :
6649 : : /* Any other constrained alias is complex. */
6650 : 58802313 : if (get_constraints (tmpl))
6651 : : return true;
6652 : :
6653 : : /* An alias with dependent type attributes is complex. */
6654 : 52724879 : if (dependent_opaque_alias_p (TREE_TYPE (tmpl)))
6655 : : return true;
6656 : :
6657 : 52724814 : if (!complex_alias_tmpl_info)
6658 : 91981 : complex_alias_tmpl_info = hash_map<const_tree, tree>::create_ggc (13);
6659 : :
6660 : 52724814 : if (tree *slot = complex_alias_tmpl_info->get (tmpl))
6661 : : {
6662 : 47373008 : tree result = *slot;
6663 : 47373008 : if (result == boolean_false_node)
6664 : : return false;
6665 : 10739122 : if (result == boolean_true_node)
6666 : : return true;
6667 : 9018086 : gcc_assert (TREE_CODE (result) == TREE_VEC);
6668 : 9018086 : if (seen_out)
6669 : 9018086 : *seen_out = result;
6670 : 9018086 : return true;
6671 : : }
6672 : :
6673 : 5351806 : struct uses_all_template_parms_data data;
6674 : 5351806 : tree pat = DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl));
6675 : 5351806 : tree parms = DECL_TEMPLATE_PARMS (tmpl);
6676 : 5351806 : data.level = TMPL_PARMS_DEPTH (parms);
6677 : 5351806 : int len = TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS (parms));
6678 : 5351806 : tree seen = make_tree_vec (len);
6679 : 5351806 : data.seen = TREE_VEC_BEGIN (seen);
6680 : 13679526 : for (int i = 0; i < len; ++i)
6681 : 8327720 : data.seen[i] = boolean_false_node;
6682 : :
6683 : 5351806 : if (cp_walk_tree_without_duplicates (&pat, complex_alias_template_r, &data))
6684 : : {
6685 : 138170 : complex_alias_tmpl_info->put (tmpl, boolean_true_node);
6686 : 138170 : return true;
6687 : : }
6688 : :
6689 : 12495342 : for (int i = 0; i < len; ++i)
6690 : 7781036 : if (data.seen[i] != boolean_true_node)
6691 : : {
6692 : 499330 : complex_alias_tmpl_info->put (tmpl, seen);
6693 : 499330 : if (seen_out)
6694 : 499330 : *seen_out = seen;
6695 : 499330 : return true;
6696 : : }
6697 : :
6698 : 4714306 : complex_alias_tmpl_info->put (tmpl, boolean_false_node);
6699 : 4714306 : return false;
6700 : : }
6701 : :
6702 : : /* If T is a specialization of a complex alias template with a dependent
6703 : : argument for an unused template parameter, return it; otherwise return
6704 : : NULL_TREE. If T is a typedef to such a specialization, return the
6705 : : specialization. This predicate is usually checked alongside
6706 : : dependent_opaque_alias_p. Whereas dependent_opaque_alias_p checks
6707 : : type equivalence of an alias vs its expansion, this predicate more
6708 : : broadly checks SFINAE equivalence. */
6709 : :
6710 : : tree
6711 : 206532535 : dependent_alias_template_spec_p (const_tree t, bool transparent_typedefs)
6712 : : {
6713 : 206532535 : if (t == error_mark_node)
6714 : : return NULL_TREE;
6715 : 180757398 : gcc_assert (TYPE_P (t));
6716 : :
6717 : 180757398 : if (!processing_template_decl || !typedef_variant_p (t))
6718 : : return NULL_TREE;
6719 : :
6720 : 106820128 : if (tree tinfo = TYPE_ALIAS_TEMPLATE_INFO (t))
6721 : : {
6722 : 96207348 : tree seen = NULL_TREE;
6723 : 96207348 : if (complex_alias_template_p (TI_TEMPLATE (tinfo), &seen))
6724 : : {
6725 : 17454121 : tree args = INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo));
6726 : 17454121 : if (!seen)
6727 : : {
6728 : 7936705 : if (any_dependent_template_arguments_p (args))
6729 : 17454121 : return CONST_CAST_TREE (t);
6730 : : }
6731 : : else
6732 : : {
6733 : 9517416 : gcc_assert (TREE_VEC_LENGTH (args) == TREE_VEC_LENGTH (seen));
6734 : 15611303 : for (int i = 0, len = TREE_VEC_LENGTH (args); i < len; ++i)
6735 : 13469905 : if (TREE_VEC_ELT (seen, i) != boolean_true_node
6736 : 13469905 : && dependent_template_arg_p (TREE_VEC_ELT (args, i)))
6737 : : return CONST_CAST_TREE (t);
6738 : : }
6739 : :
6740 : 2179346 : return NULL_TREE;
6741 : : }
6742 : : }
6743 : :
6744 : 89366007 : if (transparent_typedefs && !dependent_opaque_alias_p (t))
6745 : : {
6746 : 1094314 : tree utype = DECL_ORIGINAL_TYPE (TYPE_NAME (t));
6747 : 1094314 : return dependent_alias_template_spec_p (utype, transparent_typedefs);
6748 : : }
6749 : :
6750 : : return NULL_TREE;
6751 : : }
6752 : :
6753 : : /* Return true if substituting into T would yield a different type than
6754 : : substituting into its expansion. This predicate is usually checked
6755 : : alongside dependent_alias_template_spec_p. */
6756 : :
6757 : : bool
6758 : 295636649 : dependent_opaque_alias_p (const_tree t)
6759 : : {
6760 : 295636649 : return (TYPE_P (t)
6761 : 295636649 : && typedef_variant_p (t)
6762 : 573971791 : && any_dependent_type_attributes_p (DECL_ATTRIBUTES
6763 : 295636649 : (TYPE_NAME (t))));
6764 : : }
6765 : :
6766 : : /* Return the number of innermost template parameters in TMPL. */
6767 : :
6768 : : static int
6769 : 52036726 : num_innermost_template_parms (const_tree tmpl)
6770 : : {
6771 : 52036726 : tree parms = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl));
6772 : 52036726 : return TREE_VEC_LENGTH (parms);
6773 : : }
6774 : :
6775 : : /* Return either TMPL or another template that it is equivalent to under DR
6776 : : 1286: An alias that just changes the name of a template is equivalent to
6777 : : the other template. */
6778 : :
6779 : : static tree
6780 : 78046241 : get_underlying_template (tree tmpl)
6781 : : {
6782 : 78046241 : gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
6783 : 81119125 : while (DECL_ALIAS_TEMPLATE_P (tmpl))
6784 : : {
6785 : : /* Determine if the alias is equivalent to an underlying template. */
6786 : 65435345 : tree orig_type = DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl));
6787 : : /* The underlying type may have been ill-formed. Don't proceed. */
6788 : 65435345 : if (!orig_type)
6789 : : break;
6790 : 65435342 : tree tinfo = TYPE_TEMPLATE_INFO_MAYBE_ALIAS (orig_type);
6791 : 26018764 : if (!tinfo)
6792 : : break;
6793 : :
6794 : 26018447 : tree underlying = TI_TEMPLATE (tinfo);
6795 : 26018447 : if (!PRIMARY_TEMPLATE_P (underlying)
6796 : 52036810 : || (num_innermost_template_parms (tmpl)
6797 : 26018363 : != num_innermost_template_parms (underlying)))
6798 : : break;
6799 : :
6800 : : /* Does the alias add cv-quals? */
6801 : 10926716 : if (TYPE_QUALS (TREE_TYPE (underlying)) != TYPE_QUALS (TREE_TYPE (tmpl)))
6802 : : break;
6803 : :
6804 : 10926695 : tree alias_args = INNERMOST_TEMPLATE_ARGS (generic_targs_for (tmpl));
6805 : 10926695 : if (!comp_template_args (TI_ARGS (tinfo), alias_args))
6806 : : break;
6807 : :
6808 : : /* Are any default template arguments equivalent? */
6809 : 3073037 : tree aparms = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl));
6810 : 3073037 : tree uparms = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (underlying));
6811 : 3073037 : const int nparms = TREE_VEC_LENGTH (aparms);
6812 : 6395311 : for (int i = 0; i < nparms; ++i)
6813 : : {
6814 : 3322364 : tree adefarg = TREE_PURPOSE (TREE_VEC_ELT (aparms, i));
6815 : 3322364 : tree udefarg = TREE_PURPOSE (TREE_VEC_ELT (uparms, i));
6816 : 3322364 : if (!template_args_equal (adefarg, udefarg))
6817 : 90 : goto top_break;
6818 : : }
6819 : :
6820 : : /* If TMPL adds or changes any constraints, it isn't equivalent. I think
6821 : : it's appropriate to treat a less-constrained alias as equivalent. */
6822 : 3072947 : if (!at_least_as_constrained (underlying, tmpl))
6823 : : break;
6824 : :
6825 : : /* If TMPL adds dependent type attributes, it isn't equivalent. */
6826 : 3072892 : if (dependent_opaque_alias_p (TREE_TYPE (tmpl)))
6827 : : break;
6828 : :
6829 : : /* Alias is equivalent. Strip it and repeat. */
6830 : : tmpl = underlying;
6831 : : }
6832 : 7854062 : top_break:;
6833 : :
6834 : 78046241 : return tmpl;
6835 : : }
6836 : :
6837 : : /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
6838 : : must be a reference-to-function or a pointer-to-function type, as specified
6839 : : in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
6840 : : and check that the resulting function has external linkage. */
6841 : :
6842 : : static tree
6843 : 748 : convert_nontype_argument_function (tree type, tree expr,
6844 : : tsubst_flags_t complain)
6845 : : {
6846 : 748 : tree fns = expr;
6847 : 748 : tree fn, fn_no_ptr;
6848 : 748 : linkage_kind linkage;
6849 : :
6850 : 748 : fn = instantiate_type (type, fns, tf_none);
6851 : 748 : if (fn == error_mark_node)
6852 : : return error_mark_node;
6853 : :
6854 : 743 : if (value_dependent_expression_p (fn))
6855 : 18 : goto accept;
6856 : :
6857 : 725 : fn_no_ptr = fn;
6858 : 725 : if (REFERENCE_REF_P (fn_no_ptr))
6859 : 10 : fn_no_ptr = TREE_OPERAND (fn_no_ptr, 0);
6860 : 725 : fn_no_ptr = strip_fnptr_conv (fn_no_ptr);
6861 : 725 : if (TREE_CODE (fn_no_ptr) == ADDR_EXPR)
6862 : 640 : fn_no_ptr = TREE_OPERAND (fn_no_ptr, 0);
6863 : 725 : if (BASELINK_P (fn_no_ptr))
6864 : 0 : fn_no_ptr = BASELINK_FUNCTIONS (fn_no_ptr);
6865 : :
6866 : : /* [temp.arg.nontype]/1
6867 : :
6868 : : A template-argument for a non-type, non-template template-parameter
6869 : : shall be one of:
6870 : : [...]
6871 : : -- the address of an object or function with external [C++11: or
6872 : : internal] linkage. */
6873 : :
6874 : 725 : STRIP_ANY_LOCATION_WRAPPER (fn_no_ptr);
6875 : 725 : if (TREE_CODE (fn_no_ptr) != FUNCTION_DECL)
6876 : : {
6877 : 27 : if (complain & tf_error)
6878 : : {
6879 : 17 : auto_diagnostic_group d;
6880 : 17 : location_t loc = cp_expr_loc_or_input_loc (expr);
6881 : 17 : error_at (loc, "%qE is not a valid template argument for type %qT",
6882 : : expr, type);
6883 : 17 : if (TYPE_PTR_P (type))
6884 : 13 : inform (loc, "it must be the address of a function "
6885 : : "with external linkage");
6886 : : else
6887 : 4 : inform (loc, "it must be the name of a function with "
6888 : : "external linkage");
6889 : 17 : }
6890 : 27 : return NULL_TREE;
6891 : : }
6892 : :
6893 : 698 : linkage = decl_linkage (fn_no_ptr);
6894 : 698 : if ((cxx_dialect < cxx11 && linkage != lk_external)
6895 : 697 : || (cxx_dialect < cxx17 && linkage == lk_none))
6896 : : {
6897 : 5 : if (complain & tf_error)
6898 : : {
6899 : 2 : location_t loc = cp_expr_loc_or_input_loc (expr);
6900 : 2 : if (cxx_dialect >= cxx11)
6901 : 2 : error_at (loc, "%qE is not a valid template argument for type "
6902 : : "%qT because %qD has no linkage",
6903 : : expr, type, fn_no_ptr);
6904 : : else
6905 : 0 : error_at (loc, "%qE is not a valid template argument for type "
6906 : : "%qT because %qD does not have external linkage",
6907 : : expr, type, fn_no_ptr);
6908 : : }
6909 : 5 : return NULL_TREE;
6910 : : }
6911 : :
6912 : 693 : accept:
6913 : 711 : if (TYPE_REF_P (type))
6914 : : {
6915 : 66 : if (REFERENCE_REF_P (fn))
6916 : 8 : fn = TREE_OPERAND (fn, 0);
6917 : : else
6918 : 58 : fn = build_address (fn);
6919 : : }
6920 : 711 : if (!same_type_ignoring_top_level_qualifiers_p (type, TREE_TYPE (fn)))
6921 : 58 : fn = build_nop (type, fn);
6922 : :
6923 : : return fn;
6924 : : }
6925 : :
6926 : : /* Subroutine of convert_nontype_argument.
6927 : : Check if EXPR of type TYPE is a valid pointer-to-member constant.
6928 : : Emit an error otherwise. */
6929 : :
6930 : : static bool
6931 : 821 : check_valid_ptrmem_cst_expr (tree type, tree expr,
6932 : : tsubst_flags_t complain)
6933 : : {
6934 : 821 : tree orig_expr = expr;
6935 : 821 : STRIP_NOPS (expr);
6936 : 821 : if (null_ptr_cst_p (expr))
6937 : : return true;
6938 : 821 : if (TREE_CODE (expr) == PTRMEM_CST
6939 : 821 : && same_type_p (TYPE_PTRMEM_CLASS_TYPE (type),
6940 : : PTRMEM_CST_CLASS (expr)))
6941 : : return true;
6942 : 79 : if (cxx_dialect >= cxx11 && null_member_pointer_value_p (expr))
6943 : : return true;
6944 : 37 : if (processing_template_decl
6945 : 0 : && TREE_CODE (expr) == ADDR_EXPR
6946 : 37 : && TREE_CODE (TREE_OPERAND (expr, 0)) == OFFSET_REF)
6947 : : return true;
6948 : 37 : if (complain & tf_error)
6949 : : {
6950 : 19 : auto_diagnostic_group d;
6951 : 19 : location_t loc = cp_expr_loc_or_input_loc (orig_expr);
6952 : 19 : error_at (loc, "%qE is not a valid template argument for type %qT",
6953 : : orig_expr, type);
6954 : 19 : if (TREE_CODE (expr) != PTRMEM_CST)
6955 : 10 : inform (loc, "it must be a pointer-to-member of the form %<&X::Y%>");
6956 : : else
6957 : 9 : inform (loc, "because it is a member of %qT", PTRMEM_CST_CLASS (expr));
6958 : 19 : }
6959 : : return false;
6960 : : }
6961 : :
6962 : : /* Returns TRUE iff the address of OP is value-dependent.
6963 : :
6964 : : 14.6.2.4 [temp.dep.temp]:
6965 : : A non-integral non-type template-argument is dependent if its type is
6966 : : dependent or it has either of the following forms
6967 : : qualified-id
6968 : : & qualified-id
6969 : : and contains a nested-name-specifier which specifies a class-name that
6970 : : names a dependent type.
6971 : :
6972 : : We generalize this to just say that the address of a member of a
6973 : : dependent class is value-dependent; the above doesn't cover the
6974 : : address of a static data member named with an unqualified-id. */
6975 : :
6976 : : static bool
6977 : 76626 : has_value_dependent_address (tree op)
6978 : : {
6979 : 76626 : STRIP_ANY_LOCATION_WRAPPER (op);
6980 : :
6981 : : /* We could use get_inner_reference here, but there's no need;
6982 : : this is only relevant for template non-type arguments, which
6983 : : can only be expressed as &id-expression. */
6984 : 76626 : if (DECL_P (op))
6985 : : {
6986 : 55287 : tree ctx = CP_DECL_CONTEXT (op);
6987 : :
6988 : 55287 : if (TYPE_P (ctx) && dependent_type_p (ctx))
6989 : : return true;
6990 : :
6991 : 55181 : if (VAR_P (op)
6992 : 55181 : && TREE_STATIC (op)
6993 : 2980 : && TREE_CODE (ctx) == FUNCTION_DECL
6994 : 55454 : && type_dependent_expression_p (ctx))
6995 : : return true;
6996 : : }
6997 : :
6998 : : return false;
6999 : : }
7000 : :
7001 : : /* The next set of functions are used for providing helpful explanatory
7002 : : diagnostics for failed overload resolution. Their messages should be
7003 : : indented by two spaces for consistency with the messages in
7004 : : call.cc */
7005 : :
7006 : : static int
7007 : 0 : unify_success (bool /*explain_p*/)
7008 : : {
7009 : 0 : return 0;
7010 : : }
7011 : :
7012 : : /* Other failure functions should call this one, to provide a single function
7013 : : for setting a breakpoint on. */
7014 : :
7015 : : static int
7016 : 0 : unify_invalid (bool /*explain_p*/)
7017 : : {
7018 : 0 : return 1;
7019 : : }
7020 : :
7021 : : static int
7022 : 172602 : unify_parameter_deduction_failure (bool explain_p, tree parm)
7023 : : {
7024 : 0 : if (explain_p)
7025 : 235 : inform (input_location,
7026 : : " couldn%'t deduce template parameter %qD", parm);
7027 : 0 : return unify_invalid (explain_p);
7028 : : }
7029 : :
7030 : : static int
7031 : 2066626 : unify_cv_qual_mismatch (bool explain_p, tree parm, tree arg)
7032 : : {
7033 : 0 : if (explain_p)
7034 : 56 : inform (input_location,
7035 : : " types %qT and %qT have incompatible cv-qualifiers",
7036 : : parm, arg);
7037 : 0 : return unify_invalid (explain_p);
7038 : : }
7039 : :
7040 : : static int
7041 : 163668879 : unify_type_mismatch (bool explain_p, tree parm, tree arg)
7042 : : {
7043 : 73787 : if (explain_p)
7044 : 795 : inform (input_location, " mismatched types %qT and %qT", parm, arg);
7045 : 73787 : return unify_invalid (explain_p);
7046 : : }
7047 : :
7048 : : static int
7049 : 459619 : unify_parameter_pack_mismatch (bool explain_p, tree parm, tree arg)
7050 : : {
7051 : 0 : if (explain_p)
7052 : 0 : inform (input_location,
7053 : : " template parameter %qD is not a parameter pack, but "
7054 : : "argument %qD is",
7055 : : parm, arg);
7056 : 0 : return unify_invalid (explain_p);
7057 : : }
7058 : :
7059 : : static int
7060 : 3 : unify_ptrmem_cst_mismatch (bool explain_p, tree parm, tree arg)
7061 : : {
7062 : 0 : if (explain_p)
7063 : 0 : inform (input_location,
7064 : : " template argument %qE does not match "
7065 : : "pointer-to-member constant %qE",
7066 : : arg, parm);
7067 : 0 : return unify_invalid (explain_p);
7068 : : }
7069 : :
7070 : : static int
7071 : 11 : unify_expression_unequal (bool explain_p, tree parm, tree arg)
7072 : : {
7073 : 0 : if (explain_p)
7074 : 0 : inform (input_location, " %qE is not equivalent to %qE", parm, arg);
7075 : 0 : return unify_invalid (explain_p);
7076 : : }
7077 : :
7078 : : static int
7079 : 18 : unify_parameter_pack_inconsistent (bool explain_p, tree old_arg, tree new_arg)
7080 : : {
7081 : 0 : if (explain_p)
7082 : 3 : inform (input_location,
7083 : : " inconsistent parameter pack deduction with %qT and %qT",
7084 : : old_arg, new_arg);
7085 : 18 : return unify_invalid (explain_p);
7086 : : }
7087 : :
7088 : : static int
7089 : 1287465 : unify_inconsistency (bool explain_p, tree parm, tree first, tree second)
7090 : : {
7091 : 1287465 : if (explain_p)
7092 : : {
7093 : 66 : if (TYPE_P (parm))
7094 : 60 : inform (input_location,
7095 : : " deduced conflicting types for parameter %qT (%qT and %qT)",
7096 : : parm, first, second);
7097 : : else
7098 : 6 : inform (input_location,
7099 : : " deduced conflicting values for non-type parameter "
7100 : : "%qE (%qE and %qE)", parm, first, second);
7101 : : }
7102 : 1287465 : return unify_invalid (explain_p);
7103 : : }
7104 : :
7105 : : static int
7106 : 20 : unify_vla_arg (bool explain_p, tree arg)
7107 : : {
7108 : 0 : if (explain_p)
7109 : 9 : inform (input_location,
7110 : : " variable-sized array type %qT is not "
7111 : : "a valid template argument",
7112 : : arg);
7113 : 0 : return unify_invalid (explain_p);
7114 : : }
7115 : :
7116 : : static int
7117 : 6 : unify_method_type_error (bool explain_p, tree arg)
7118 : : {
7119 : 0 : if (explain_p)
7120 : 0 : inform (input_location,
7121 : : " member function type %qT is not a valid template argument",
7122 : : arg);
7123 : 0 : return unify_invalid (explain_p);
7124 : : }
7125 : :
7126 : : static int
7127 : 1442123 : unify_arity (bool explain_p, int have, int wanted, bool least_p = false)
7128 : : {
7129 : 1442123 : if (explain_p)
7130 : : {
7131 : 3 : if (least_p)
7132 : 0 : inform_n (input_location, wanted,
7133 : : " candidate expects at least %d argument, %d provided",
7134 : : " candidate expects at least %d arguments, %d provided",
7135 : : wanted, have);
7136 : : else
7137 : 3 : inform_n (input_location, wanted,
7138 : : " candidate expects %d argument, %d provided",
7139 : : " candidate expects %d arguments, %d provided",
7140 : : wanted, have);
7141 : : }
7142 : 1442123 : return unify_invalid (explain_p);
7143 : : }
7144 : :
7145 : : static int
7146 : 93150 : unify_too_many_arguments (bool explain_p, int have, int wanted)
7147 : : {
7148 : 0 : return unify_arity (explain_p, have, wanted);
7149 : : }
7150 : :
7151 : : static int
7152 : 46696 : unify_too_few_arguments (bool explain_p, int have, int wanted,
7153 : : bool least_p = false)
7154 : : {
7155 : 0 : return unify_arity (explain_p, have, wanted, least_p);
7156 : : }
7157 : :
7158 : : static int
7159 : 2046957 : unify_arg_conversion (bool explain_p, tree to_type,
7160 : : tree from_type, tree arg)
7161 : : {
7162 : 2046957 : if (explain_p)
7163 : 301 : inform (cp_expr_loc_or_input_loc (arg),
7164 : : " cannot convert %qE (type %qT) to type %qT",
7165 : : arg, from_type, to_type);
7166 : 2046957 : return unify_invalid (explain_p);
7167 : : }
7168 : :
7169 : : static int
7170 : 70832853 : unify_no_common_base (bool explain_p, enum template_base_result r,
7171 : : tree parm, tree arg)
7172 : : {
7173 : 70832853 : if (explain_p)
7174 : 836 : switch (r)
7175 : : {
7176 : 3 : case tbr_ambiguous_baseclass:
7177 : 3 : inform (input_location, " %qT is an ambiguous base class of %qT",
7178 : : parm, arg);
7179 : 3 : break;
7180 : 833 : default:
7181 : 833 : inform (input_location, " %qT is not derived from %qT", arg, parm);
7182 : 833 : break;
7183 : : }
7184 : 70832853 : return unify_invalid (explain_p);
7185 : : }
7186 : :
7187 : : static int
7188 : 24 : unify_inconsistent_template_template_parameters (bool explain_p)
7189 : : {
7190 : 24 : if (explain_p)
7191 : 10 : inform (input_location,
7192 : : " template parameters of a template template argument are "
7193 : : "inconsistent with other deduced template arguments");
7194 : 24 : return unify_invalid (explain_p);
7195 : : }
7196 : :
7197 : : static int
7198 : 1017 : unify_template_deduction_failure (bool explain_p, tree parm, tree arg)
7199 : : {
7200 : 0 : if (explain_p)
7201 : 0 : inform (input_location,
7202 : : " cannot deduce a template for %qT from non-template type %qT",
7203 : : parm, arg);
7204 : 0 : return unify_invalid (explain_p);
7205 : : }
7206 : :
7207 : : static int
7208 : 4212489 : unify_template_argument_mismatch (bool explain_p, tree parm, tree arg)
7209 : : {
7210 : 0 : if (explain_p)
7211 : 9 : inform (input_location,
7212 : : " template argument %qE does not match %qE", arg, parm);
7213 : 0 : return unify_invalid (explain_p);
7214 : : }
7215 : :
7216 : : /* Subroutine of convert_nontype_argument, to check whether EXPR, as an
7217 : : argument for TYPE, points to an unsuitable object.
7218 : :
7219 : : Also adjust the type of the index in C++20 array subobject references. */
7220 : :
7221 : : static bool
7222 : 8693 : invalid_tparm_referent_p (tree type, tree expr, tsubst_flags_t complain)
7223 : : {
7224 : 8702 : switch (TREE_CODE (expr))
7225 : : {
7226 : 9 : CASE_CONVERT:
7227 : 9 : return invalid_tparm_referent_p (type, TREE_OPERAND (expr, 0),
7228 : 9 : complain);
7229 : :
7230 : 0 : case TARGET_EXPR:
7231 : 0 : return invalid_tparm_referent_p (type, TARGET_EXPR_INITIAL (expr),
7232 : 0 : complain);
7233 : :
7234 : 3601 : case CONSTRUCTOR:
7235 : 3601 : {
7236 : 15879 : for (auto &e: CONSTRUCTOR_ELTS (expr))
7237 : 6300 : if (invalid_tparm_referent_p (TREE_TYPE (e.value), e.value, complain))
7238 : : return true;
7239 : : }
7240 : : break;
7241 : :
7242 : 761 : case ADDR_EXPR:
7243 : 761 : {
7244 : 761 : tree decl = TREE_OPERAND (expr, 0);
7245 : :
7246 : 761 : if (cxx_dialect >= cxx20)
7247 : 428 : while (TREE_CODE (decl) == COMPONENT_REF
7248 : 428 : || TREE_CODE (decl) == ARRAY_REF)
7249 : : {
7250 : 86 : tree &op = TREE_OPERAND (decl, 1);
7251 : 86 : if (TREE_CODE (decl) == ARRAY_REF
7252 : 21 : && TREE_CODE (op) == INTEGER_CST)
7253 : : /* Canonicalize array offsets to ptrdiff_t; how they were
7254 : : written doesn't matter for subobject identity. */
7255 : 21 : op = fold_convert (ptrdiff_type_node, op);
7256 : 86 : decl = TREE_OPERAND (decl, 0);
7257 : : }
7258 : :
7259 : 761 : if (!VAR_OR_FUNCTION_DECL_P (decl))
7260 : : {
7261 : 18 : if (complain & tf_error)
7262 : 21 : error_at (cp_expr_loc_or_input_loc (expr),
7263 : : "%qE is not a valid template argument of type %qT "
7264 : : "because %qE is not a variable or function",
7265 : : expr, type, decl);
7266 : 18 : return true;
7267 : : }
7268 : 743 : else if (cxx_dialect < cxx11 && !DECL_EXTERNAL_LINKAGE_P (decl))
7269 : : {
7270 : 2 : if (complain & tf_error)
7271 : 3 : error_at (cp_expr_loc_or_input_loc (expr),
7272 : : "%qE is not a valid template argument of type %qT "
7273 : : "in C++98 because %qD does not have external linkage",
7274 : : expr, type, decl);
7275 : 2 : return true;
7276 : : }
7277 : 741 : else if ((cxx_dialect >= cxx11 && cxx_dialect < cxx17)
7278 : 741 : && decl_linkage (decl) == lk_none)
7279 : : {
7280 : 6 : if (complain & tf_error)
7281 : 12 : error_at (cp_expr_loc_or_input_loc (expr),
7282 : : "%qE is not a valid template argument of type %qT "
7283 : : "because %qD has no linkage", expr, type, decl);
7284 : 6 : return true;
7285 : : }
7286 : : /* C++17: For a non-type template-parameter of reference or pointer
7287 : : type, the value of the constant expression shall not refer to (or
7288 : : for a pointer type, shall not be the address of):
7289 : : * a subobject (4.5),
7290 : : * a temporary object (15.2),
7291 : : * a string literal (5.13.5),
7292 : : * the result of a typeid expression (8.2.8), or
7293 : : * a predefined __func__ variable (11.4.1). */
7294 : 726 : else if (VAR_P (decl) && DECL_ARTIFICIAL (decl)
7295 : 747 : && !DECL_NTTP_OBJECT_P (decl))
7296 : : {
7297 : 0 : gcc_checking_assert (DECL_TINFO_P (decl) || DECL_FNAME_P (decl));
7298 : 0 : if (complain & tf_error)
7299 : 0 : error ("the address of %qD is not a valid template argument",
7300 : : decl);
7301 : 0 : return true;
7302 : : }
7303 : 735 : else if (cxx_dialect < cxx20
7304 : 1136 : && !(same_type_ignoring_top_level_qualifiers_p
7305 : 401 : (strip_array_types (TREE_TYPE (type)),
7306 : 401 : strip_array_types (TREE_TYPE (decl)))))
7307 : : {
7308 : 6 : if (complain & tf_error)
7309 : 4 : error ("the address of the %qT subobject of %qD is not a "
7310 : 4 : "valid template argument", TREE_TYPE (type), decl);
7311 : 6 : return true;
7312 : : }
7313 : 729 : else if (!TREE_STATIC (decl) && !DECL_EXTERNAL (decl))
7314 : : {
7315 : 1 : if (complain & tf_error)
7316 : 1 : error ("the address of %qD is not a valid template argument "
7317 : : "because it does not have static storage duration",
7318 : : decl);
7319 : 1 : return true;
7320 : : }
7321 : : }
7322 : : break;
7323 : :
7324 : 4331 : default:
7325 : 4331 : if (!INDIRECT_TYPE_P (type))
7326 : : /* We're only concerned about pointers and references here. */;
7327 : 166 : else if (cxx_dialect >= cxx11 && integer_zerop (expr))
7328 : : /* Null pointer values are OK in C++11. */;
7329 : : else
7330 : : {
7331 : 11 : if (VAR_P (expr))
7332 : : {
7333 : 6 : if (complain & tf_error)
7334 : 6 : error ("%qD is not a valid template argument "
7335 : : "because %qD is a variable, not the address of "
7336 : : "a variable", expr, expr);
7337 : 6 : return true;
7338 : : }
7339 : : else
7340 : : {
7341 : 5 : if (complain & tf_error)
7342 : 2 : error ("%qE is not a valid template argument for %qT "
7343 : : "because it is not the address of a variable",
7344 : : expr, type);
7345 : 5 : return true;
7346 : : }
7347 : : }
7348 : : }
7349 : : return false;
7350 : :
7351 : : }
7352 : :
7353 : : /* Return a VAR_DECL for the C++20 template parameter object corresponding to
7354 : : template argument EXPR. */
7355 : :
7356 : : static tree
7357 : 1643 : create_template_parm_object (tree expr, tsubst_flags_t complain)
7358 : : {
7359 : 1643 : tree orig = expr;
7360 : 1643 : if (TREE_CODE (expr) == TARGET_EXPR)
7361 : 1643 : expr = TARGET_EXPR_INITIAL (expr);
7362 : :
7363 : 1643 : if (!TREE_CONSTANT (expr))
7364 : : {
7365 : 7 : if ((complain & tf_error)
7366 : 7 : && require_rvalue_constant_expression (orig))
7367 : 7 : cxx_constant_value (orig);
7368 : 7 : return error_mark_node;
7369 : : }
7370 : 1636 : if (invalid_tparm_referent_p (TREE_TYPE (expr), expr, complain))
7371 : 0 : return error_mark_node;
7372 : :
7373 : : /* This is no longer a compound literal. */
7374 : 1636 : gcc_assert (!TREE_HAS_CONSTRUCTOR (expr));
7375 : :
7376 : 1636 : return get_template_parm_object (expr, mangle_template_parm_object (expr));
7377 : : }
7378 : :
7379 : : /* The template arguments corresponding to template parameter objects of types
7380 : : that contain pointers to members. */
7381 : :
7382 : : static GTY(()) hash_map<tree, tree> *tparm_obj_values;
7383 : :
7384 : : /* Find or build an nttp object for (already-validated) EXPR with name
7385 : : NAME. When CHECK_INIT is false we don't need to process the initialiser,
7386 : : it's already been done. */
7387 : :
7388 : : tree
7389 : 1639 : get_template_parm_object (tree expr, tree name, bool check_init/*=true*/)
7390 : : {
7391 : 1639 : tree decl = get_global_binding (name);
7392 : 1639 : if (decl)
7393 : : return decl;
7394 : :
7395 : 476 : tree type = cp_build_qualified_type (TREE_TYPE (expr), TYPE_QUAL_CONST);
7396 : 476 : decl = create_temporary_var (type);
7397 : 476 : DECL_NTTP_OBJECT_P (decl) = true;
7398 : 476 : DECL_CONTEXT (decl) = NULL_TREE;
7399 : 476 : TREE_STATIC (decl) = true;
7400 : 476 : DECL_DECLARED_CONSTEXPR_P (decl) = true;
7401 : 476 : TREE_READONLY (decl) = true;
7402 : 476 : DECL_NAME (decl) = name;
7403 : 476 : SET_DECL_ASSEMBLER_NAME (decl, name);
7404 : 476 : comdat_linkage (decl);
7405 : :
7406 : 476 : if (!zero_init_p (type))
7407 : : {
7408 : : /* If EXPR contains any PTRMEM_CST, they will get clobbered by
7409 : : lower_var_init before we're done mangling. So store the original
7410 : : value elsewhere. We only need to unshare EXPR if it's not yet
7411 : : been processed. */
7412 : 28 : tree copy = check_init ? unshare_constructor (expr) : expr;
7413 : 28 : hash_map_safe_put<hm_ggc> (tparm_obj_values, decl, copy);
7414 : : }
7415 : :
7416 : 476 : if (!check_init)
7417 : : {
7418 : : /* The EXPR is the already processed initializer, set it on the NTTP
7419 : : object now so that cp_finish_decl doesn't do it again later. */
7420 : 2 : DECL_INITIAL (decl) = expr;
7421 : 2 : DECL_INITIALIZED_P (decl) = 1;
7422 : : }
7423 : :
7424 : 476 : pushdecl_top_level_and_finish (decl, expr);
7425 : :
7426 : 476 : return decl;
7427 : : }
7428 : :
7429 : : /* Return the actual template argument corresponding to template parameter
7430 : : object VAR. */
7431 : :
7432 : : tree
7433 : 5577 : tparm_object_argument (tree var)
7434 : : {
7435 : 5577 : if (zero_init_p (TREE_TYPE (var)))
7436 : 5560 : return DECL_INITIAL (var);
7437 : 17 : return *(tparm_obj_values->get (var));
7438 : : }
7439 : :
7440 : : /* Attempt to convert the non-type template parameter EXPR to the
7441 : : indicated TYPE. If the conversion is successful, return the
7442 : : converted value. If the conversion is unsuccessful, return
7443 : : NULL_TREE if we issued an error message, or error_mark_node if we
7444 : : did not. We issue error messages for out-and-out bad template
7445 : : parameters, but not simply because the conversion failed, since we
7446 : : might be just trying to do argument deduction. Both TYPE and EXPR
7447 : : must be non-dependent.
7448 : :
7449 : : The conversion follows the special rules described in
7450 : : [temp.arg.nontype], and it is much more strict than an implicit
7451 : : conversion.
7452 : :
7453 : : This function is called twice for each template argument (see
7454 : : lookup_template_class for a more accurate description of this
7455 : : problem). This means that we need to handle expressions which
7456 : : are not valid in a C++ source, but can be created from the
7457 : : first call (for instance, casts to perform conversions). These
7458 : : hacks can go away after we fix the double coercion problem. */
7459 : :
7460 : : static tree
7461 : 131103900 : convert_nontype_argument (tree type, tree expr, tsubst_flags_t complain)
7462 : : {
7463 : 131103900 : tree expr_type;
7464 : 131103900 : location_t loc = cp_expr_loc_or_input_loc (expr);
7465 : :
7466 : : /* Detect immediately string literals as invalid non-type argument.
7467 : : This special-case is not needed for correctness (we would easily
7468 : : catch this later), but only to provide better diagnostic for this
7469 : : common user mistake. As suggested by DR 100, we do not mention
7470 : : linkage issues in the diagnostic as this is not the point. */
7471 : 131103900 : if (TREE_CODE (expr) == STRING_CST && !CLASS_TYPE_P (type))
7472 : : {
7473 : 6 : if (complain & tf_error)
7474 |
