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 : : #include "pretty-print-markup.h"
52 : :
53 : : /* The type of functions taking a tree, and some additional data, and
54 : : returning an int. */
55 : : typedef int (*tree_fn_t) (tree, void*);
56 : :
57 : : /* The PENDING_TEMPLATES is a list of templates whose instantiations
58 : : have been deferred, either because their definitions were not yet
59 : : available, or because we were putting off doing the work. */
60 : : struct GTY ((chain_next ("%h.next"))) pending_template
61 : : {
62 : : struct pending_template *next;
63 : : struct tinst_level *tinst;
64 : : };
65 : :
66 : : static GTY(()) struct pending_template *pending_templates;
67 : : static GTY(()) struct pending_template *last_pending_template;
68 : :
69 : : int processing_template_parmlist;
70 : : static int template_header_count;
71 : :
72 : : static vec<int> inline_parm_levels;
73 : :
74 : : static GTY(()) struct tinst_level *current_tinst_level;
75 : :
76 : : static GTY(()) vec<tree, va_gc> *saved_access_scope;
77 : :
78 : : /* Live only within one (recursive) call to tsubst_expr. We use
79 : : this to pass the statement expression node from the STMT_EXPR
80 : : to the EXPR_STMT that is its result. */
81 : : static tree cur_stmt_expr;
82 : :
83 : : // -------------------------------------------------------------------------- //
84 : : // Local Specialization Stack
85 : : //
86 : : // Implementation of the RAII helper for creating new local
87 : : // specializations.
88 : 36586242 : local_specialization_stack::local_specialization_stack (lss_policy policy)
89 : 36586242 : : saved (local_specializations)
90 : : {
91 : 36586242 : if (policy == lss_nop)
92 : : ;
93 : 19994987 : else if (policy == lss_blank || !saved)
94 : 18442808 : local_specializations = new hash_map<tree, tree>;
95 : : else
96 : 1552179 : local_specializations = new hash_map<tree, tree>(*saved);
97 : 36586242 : }
98 : :
99 : 36583533 : local_specialization_stack::~local_specialization_stack ()
100 : : {
101 : 36583533 : if (local_specializations != saved)
102 : : {
103 : 39984556 : delete local_specializations;
104 : 19992278 : local_specializations = saved;
105 : : }
106 : 36583533 : }
107 : :
108 : : /* True if we've recursed into fn_type_unification too many times. */
109 : : static bool excessive_deduction_depth;
110 : :
111 : : struct spec_hasher : ggc_ptr_hash<spec_entry>
112 : : {
113 : : static hashval_t hash (tree, tree);
114 : : static hashval_t hash (spec_entry *);
115 : : static bool equal (spec_entry *, spec_entry *);
116 : : };
117 : :
118 : : /* The general template is not in these tables. */
119 : : typedef hash_table<spec_hasher> spec_hash_table;
120 : : static GTY (()) spec_hash_table *decl_specializations;
121 : : static GTY (()) spec_hash_table *type_specializations;
122 : :
123 : : /* Contains canonical template parameter types. The vector is indexed by
124 : : the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
125 : : TREE_LIST, whose TREE_VALUEs contain the canonical template
126 : : parameters of various types and levels. */
127 : : static GTY(()) vec<tree, va_gc> *canonical_template_parms;
128 : :
129 : : #define UNIFY_ALLOW_NONE 0
130 : : #define UNIFY_ALLOW_MORE_CV_QUAL 1
131 : : #define UNIFY_ALLOW_LESS_CV_QUAL 2
132 : : #define UNIFY_ALLOW_DERIVED 4
133 : : #define UNIFY_ALLOW_INTEGER 8
134 : : #define UNIFY_ALLOW_OUTER_LEVEL 16
135 : : #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
136 : : #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
137 : :
138 : : enum template_base_result {
139 : : tbr_incomplete_type,
140 : : tbr_ambiguous_baseclass,
141 : : tbr_success
142 : : };
143 : :
144 : : static bool resolve_overloaded_unification (tree, tree, tree, tree,
145 : : unification_kind_t, int,
146 : : bool);
147 : : static int try_one_overload (tree, tree, tree, tree, tree,
148 : : unification_kind_t, int, bool, bool);
149 : : static int unify (tree, tree, tree, tree, int, bool);
150 : : static void add_pending_template (tree);
151 : : static tree reopen_tinst_level (struct tinst_level *);
152 : : static tree tsubst_initializer_list (tree, tree);
153 : : static tree get_partial_spec_bindings (tree, tree, tree);
154 : : static void tsubst_enum (tree, tree, tree);
155 : : static bool check_instantiated_args (tree, tree, tsubst_flags_t);
156 : : static int check_non_deducible_conversion (tree, tree, unification_kind_t, int,
157 : : struct conversion **, bool, bool);
158 : : static int maybe_adjust_types_for_deduction (tree, unification_kind_t,
159 : : tree*, tree*, tree);
160 : : static int type_unification_real (tree, tree, tree, const tree *,
161 : : unsigned int, int, unification_kind_t,
162 : : vec<deferred_access_check, va_gc> **,
163 : : bool);
164 : : static void note_template_header (int);
165 : : static tree convert_nontype_argument_function (tree, tree, tsubst_flags_t);
166 : : static tree convert_nontype_argument (tree, tree, tsubst_flags_t);
167 : : static tree convert_template_argument (tree, tree, tree,
168 : : tsubst_flags_t, int, tree);
169 : : static tree for_each_template_parm (tree, tree_fn_t, void*,
170 : : hash_set<tree> *, bool, tree_fn_t = NULL);
171 : : static tree expand_template_argument_pack (tree);
172 : : static tree build_template_parm_index (int, int, int, tree, tree);
173 : : static bool inline_needs_template_parms (tree, bool);
174 : : static void push_inline_template_parms_recursive (tree, int);
175 : : static tree reduce_template_parm_level (tree, tree, int, tree, tsubst_flags_t);
176 : : static int mark_template_parm (tree, void *);
177 : : static int template_parm_this_level_p (tree, void *);
178 : : static tree tsubst_friend_function (tree, tree);
179 : : static tree tsubst_friend_class (tree, tree);
180 : : static int can_complete_type_without_circularity (tree);
181 : : static tree get_bindings (tree, tree, tree, bool);
182 : : static int template_decl_level (tree);
183 : : static int check_cv_quals_for_unify (int, tree, tree);
184 : : static int unify_pack_expansion (tree, tree, tree,
185 : : tree, unification_kind_t, bool, bool);
186 : : static tree copy_template_args (tree);
187 : : static tree tsubst_template_parms (tree, tree, tsubst_flags_t);
188 : : static void tsubst_each_template_parm_constraints (tree, tree, tsubst_flags_t);
189 : : static tree tsubst_arg_types (tree, tree, tree, tsubst_flags_t, tree);
190 : : static tree tsubst_function_type (tree, tree, tsubst_flags_t, tree);
191 : : static bool check_specialization_scope (void);
192 : : static tree process_partial_specialization (tree);
193 : : static enum template_base_result get_template_base (tree, tree, tree, tree,
194 : : bool , tree *);
195 : : static tree try_class_unification (tree, tree, tree, tree, bool);
196 : : static bool class_nttp_const_wrapper_p (tree t);
197 : : static int coerce_template_template_parms (tree, tree, tsubst_flags_t,
198 : : tree, tree);
199 : : static bool template_template_parm_bindings_ok_p (tree, tree);
200 : : static void tsubst_default_arguments (tree, tsubst_flags_t);
201 : : static tree for_each_template_parm_r (tree *, int *, void *);
202 : : static tree copy_default_args_to_explicit_spec_1 (tree, tree);
203 : : static void copy_default_args_to_explicit_spec (tree);
204 : : static bool invalid_nontype_parm_type_p (tree, tsubst_flags_t);
205 : : static bool dependent_template_arg_p (tree);
206 : : static bool dependent_type_p_r (tree);
207 : : static tree tsubst_stmt (tree, tree, tsubst_flags_t, tree);
208 : : static tree tsubst_decl (tree, tree, tsubst_flags_t, bool = true);
209 : : static tree tsubst_scope (tree, tree, tsubst_flags_t, tree);
210 : : static tree tsubst_name (tree, tree, tsubst_flags_t, tree);
211 : : static void perform_instantiation_time_access_checks (tree, tree);
212 : : static tree listify (tree);
213 : : static tree listify_autos (tree, tree);
214 : : static tree tsubst_template_parm (tree, tree, tsubst_flags_t);
215 : : static tree instantiate_alias_template (tree, tree, tsubst_flags_t);
216 : : static tree get_underlying_template (tree);
217 : : static tree tsubst_attributes (tree, tree, tsubst_flags_t, tree);
218 : : static tree canonicalize_expr_argument (tree, tsubst_flags_t);
219 : : static tree make_argument_pack (tree);
220 : : static tree enclosing_instantiation_of (tree tctx);
221 : : static void instantiate_body (tree pattern, tree args, tree d, bool nested);
222 : : static tree maybe_dependent_member_ref (tree, tree, tsubst_flags_t, tree);
223 : : static void mark_template_arguments_used (tree, tree);
224 : : static bool uses_outer_template_parms (tree);
225 : : static tree alias_ctad_tweaks (tree, tree);
226 : : static tree inherited_ctad_tweaks (tree, tree, tsubst_flags_t);
227 : : static tree deduction_guides_for (tree, bool&, tsubst_flags_t);
228 : :
229 : : /* Make the current scope suitable for access checking when we are
230 : : processing T. T can be FUNCTION_DECL for instantiated function
231 : : template, VAR_DECL for static member variable, or TYPE_DECL for
232 : : for a class or alias template (needed by instantiate_decl). */
233 : :
234 : : void
235 : 144370099 : push_access_scope (tree t)
236 : : {
237 : 144370099 : gcc_assert (VAR_OR_FUNCTION_DECL_P (t)
238 : : || TREE_CODE (t) == TYPE_DECL);
239 : :
240 : 244752652 : if (DECL_FRIEND_CONTEXT (t))
241 : 406076 : push_nested_class (DECL_FRIEND_CONTEXT (t));
242 : 35214932 : else if (DECL_IMPLICIT_TYPEDEF_P (t)
243 : 152048082 : && CLASS_TYPE_P (TREE_TYPE (t)))
244 : 8084059 : push_nested_class (TREE_TYPE (t));
245 : 135879964 : else if (DECL_CLASS_SCOPE_P (t))
246 : 36178755 : push_nested_class (DECL_CONTEXT (t));
247 : 99701209 : else if (deduction_guide_p (t) && DECL_ARTIFICIAL (t))
248 : : /* An artificial deduction guide should have the same access as
249 : : the constructor. */
250 : 38276 : push_nested_class (TREE_TYPE (TREE_TYPE (t)));
251 : : else
252 : 99662933 : push_to_top_level ();
253 : :
254 : 144370099 : if (TREE_CODE (t) == FUNCTION_DECL)
255 : : {
256 : 100630059 : vec_safe_push (saved_access_scope, current_function_decl);
257 : 100630059 : current_function_decl = t;
258 : : }
259 : 144370099 : }
260 : :
261 : : /* Restore the scope set up by push_access_scope. T is the node we
262 : : are processing. */
263 : :
264 : : void
265 : 144367399 : pop_access_scope (tree t)
266 : : {
267 : 144367399 : if (TREE_CODE (t) == FUNCTION_DECL)
268 : 100627359 : current_function_decl = saved_access_scope->pop();
269 : :
270 : 244747252 : if (DECL_FRIEND_CONTEXT (t)
271 : 143961323 : || (DECL_IMPLICIT_TYPEDEF_P (t)
272 : 8084059 : && CLASS_TYPE_P (TREE_TYPE (t)))
273 : 135877264 : || DECL_CLASS_SCOPE_P (t)
274 : 191933824 : || (deduction_guide_p (t) && DECL_ARTIFICIAL (t)))
275 : 44707166 : pop_nested_class ();
276 : : else
277 : 99660233 : pop_from_top_level ();
278 : 144367399 : }
279 : :
280 : : /* Do any processing required when DECL (a member template
281 : : declaration) is finished. Returns the TEMPLATE_DECL corresponding
282 : : to DECL, unless it is a specialization, in which case the DECL
283 : : itself is returned. */
284 : :
285 : : tree
286 : 17085087 : finish_member_template_decl (tree decl)
287 : : {
288 : 17085087 : if (decl == error_mark_node)
289 : : return error_mark_node;
290 : :
291 : 17085011 : gcc_assert (DECL_P (decl));
292 : :
293 : 17085011 : if (TREE_CODE (decl) == TYPE_DECL)
294 : : {
295 : 1155079 : tree type;
296 : :
297 : 1155079 : type = TREE_TYPE (decl);
298 : 1155079 : if (type == error_mark_node)
299 : : return error_mark_node;
300 : 1155079 : if (MAYBE_CLASS_TYPE_P (type)
301 : 1155079 : && CLASSTYPE_TEMPLATE_INFO (type)
302 : 1155079 : && !CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
303 : : {
304 : 657718 : tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
305 : 657718 : check_member_template (tmpl);
306 : 657718 : return tmpl;
307 : : }
308 : : return NULL_TREE;
309 : : }
310 : 15929932 : else if (TREE_CODE (decl) == FIELD_DECL)
311 : 3 : error_at (DECL_SOURCE_LOCATION (decl),
312 : : "data member %qD cannot be a member template", decl);
313 : 15929929 : else if (DECL_TEMPLATE_INFO (decl))
314 : : {
315 : 15929929 : if (!DECL_TEMPLATE_SPECIALIZATION (decl))
316 : : {
317 : 15850315 : check_member_template (DECL_TI_TEMPLATE (decl));
318 : 15850315 : return DECL_TI_TEMPLATE (decl);
319 : : }
320 : : else
321 : : return NULL_TREE;
322 : : }
323 : : else
324 : 0 : error_at (DECL_SOURCE_LOCATION (decl),
325 : : "invalid member template declaration %qD", decl);
326 : :
327 : 3 : return error_mark_node;
328 : : }
329 : :
330 : : /* Create a template info node. */
331 : :
332 : : tree
333 : 535287450 : build_template_info (tree template_decl, tree template_args)
334 : : {
335 : 535287450 : tree result = make_node (TEMPLATE_INFO);
336 : 535287450 : TI_TEMPLATE (result) = template_decl;
337 : 535287450 : TI_ARGS (result) = template_args;
338 : 535287450 : return result;
339 : : }
340 : :
341 : : /* DECL_TEMPLATE_INFO, if applicable, or NULL_TREE. */
342 : :
343 : : static tree
344 : 1644878557 : decl_template_info (const_tree decl)
345 : : {
346 : : /* This needs to match template_info_decl_check. */
347 : 1644878557 : if (DECL_LANG_SPECIFIC (decl))
348 : 1266869993 : switch (TREE_CODE (decl))
349 : : {
350 : 1095936009 : case FUNCTION_DECL:
351 : 1095936009 : if (DECL_THUNK_P (decl))
352 : : break;
353 : 1266866111 : gcc_fallthrough ();
354 : 1266866111 : case VAR_DECL:
355 : 1266866111 : case FIELD_DECL:
356 : 1266866111 : case TYPE_DECL:
357 : 1266866111 : case CONCEPT_DECL:
358 : 1266866111 : case TEMPLATE_DECL:
359 : 1266866111 : return DECL_TEMPLATE_INFO (decl);
360 : :
361 : : default:
362 : : break;
363 : : }
364 : : return NULL_TREE;
365 : : }
366 : :
367 : : /* Return the template info node corresponding to T, whatever T is. */
368 : :
369 : : tree
370 : 2215923398 : get_template_info (const_tree t)
371 : : {
372 : 2215923398 : tree tinfo = NULL_TREE;
373 : :
374 : 2215923398 : if (!t || t == error_mark_node)
375 : : return NULL;
376 : :
377 : 2215923396 : if (TREE_CODE (t) == NAMESPACE_DECL
378 : 2141454410 : || TREE_CODE (t) == PARM_DECL)
379 : : return NULL;
380 : :
381 : 2141454314 : if (DECL_P (t))
382 : 1644878557 : tinfo = decl_template_info (t);
383 : :
384 : 2141454314 : if (!tinfo && DECL_IMPLICIT_TYPEDEF_P (t))
385 : 375875281 : t = TREE_TYPE (t);
386 : :
387 : 2141454314 : if (OVERLOAD_TYPE_P (t))
388 : 854757702 : tinfo = TYPE_TEMPLATE_INFO (t);
389 : 1286696612 : else if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
390 : 11 : tinfo = TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t);
391 : :
392 : : return tinfo;
393 : : }
394 : :
395 : : /* Returns the template nesting level of the indicated class TYPE.
396 : :
397 : : For example, in:
398 : : template <class T>
399 : : struct A
400 : : {
401 : : template <class U>
402 : : struct B {};
403 : : };
404 : :
405 : : A<T>::B<U> has depth two, while A<T> has depth one.
406 : : Both A<T>::B<int> and A<int>::B<U> have depth one, if
407 : : they are instantiations, not specializations.
408 : :
409 : : This function is guaranteed to return 0 if passed NULL_TREE so
410 : : that, for example, `template_class_depth (current_class_type)' is
411 : : always safe. */
412 : :
413 : : int
414 : 514051696 : template_class_depth (tree type)
415 : : {
416 : 514051696 : int depth;
417 : :
418 : 709564284 : for (depth = 0; type && TREE_CODE (type) != NAMESPACE_DECL; )
419 : : {
420 : 195512588 : tree tinfo = get_template_info (type);
421 : :
422 : 195512588 : if (tinfo
423 : 176614474 : && TREE_CODE (TI_TEMPLATE (tinfo)) == TEMPLATE_DECL
424 : 176614474 : && PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo))
425 : 369185631 : && uses_template_parms (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo))))
426 : 144894503 : ++depth;
427 : :
428 : 195512588 : if (DECL_P (type))
429 : : {
430 : 894826 : if (tree fctx = DECL_FRIEND_CONTEXT (type))
431 : : type = fctx;
432 : : else
433 : 429162 : type = CP_DECL_CONTEXT (type);
434 : : }
435 : 389585211 : else if (LAMBDA_TYPE_P (type) && LAMBDA_TYPE_EXTRA_SCOPE (type))
436 : 341584 : type = LAMBDA_TYPE_EXTRA_SCOPE (type);
437 : : else
438 : 194721266 : type = CP_TYPE_CONTEXT (type);
439 : : }
440 : :
441 : 514051696 : return depth;
442 : : }
443 : :
444 : : /* Return TRUE if NODE instantiates a template that has arguments of
445 : : its own, be it directly a primary template or indirectly through a
446 : : partial specializations. */
447 : : static bool
448 : 105860615 : instantiates_primary_template_p (tree node)
449 : : {
450 : 105860615 : tree tinfo = get_template_info (node);
451 : 105860615 : if (!tinfo)
452 : : return false;
453 : :
454 : 105848549 : tree tmpl = TI_TEMPLATE (tinfo);
455 : 105848549 : if (PRIMARY_TEMPLATE_P (tmpl))
456 : : return true;
457 : :
458 : 95027334 : if (!DECL_TEMPLATE_SPECIALIZATION (tmpl))
459 : : return false;
460 : :
461 : : /* So now we know we have a specialization, but it could be a full
462 : : or a partial specialization. To tell which, compare the depth of
463 : : its template arguments with those of its context. */
464 : :
465 : 0 : tree ctxt = DECL_CONTEXT (tmpl);
466 : 0 : tree ctinfo = get_template_info (ctxt);
467 : 0 : if (!ctinfo)
468 : : return true;
469 : :
470 : 0 : return (TMPL_ARGS_DEPTH (TI_ARGS (tinfo))
471 : 0 : > TMPL_ARGS_DEPTH (TI_ARGS (ctinfo)));
472 : : }
473 : :
474 : : /* Subroutine of maybe_begin_member_template_processing.
475 : : Returns true if processing DECL needs us to push template parms. */
476 : :
477 : : static bool
478 : 153669386 : inline_needs_template_parms (tree decl, bool nsdmi)
479 : : {
480 : 153669386 : if (!decl || (!nsdmi && ! DECL_TEMPLATE_INFO (decl)))
481 : : return false;
482 : :
483 : 129691240 : return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl)))
484 : 129691240 : > (current_template_depth + DECL_TEMPLATE_SPECIALIZATION (decl)));
485 : : }
486 : :
487 : : /* Subroutine of maybe_begin_member_template_processing.
488 : : Push the template parms in PARMS, starting from LEVELS steps into the
489 : : chain, and ending at the beginning, since template parms are listed
490 : : innermost first. */
491 : :
492 : : static void
493 : 33524553 : push_inline_template_parms_recursive (tree parmlist, int levels)
494 : : {
495 : 33524553 : tree parms = TREE_VALUE (parmlist);
496 : 33524553 : int i;
497 : :
498 : 33524553 : if (levels > 1)
499 : 412732 : push_inline_template_parms_recursive (TREE_CHAIN (parmlist), levels - 1);
500 : :
501 : 33524553 : ++processing_template_decl;
502 : 67049106 : current_template_parms
503 : 33524553 : = tree_cons (size_int (current_template_depth + 1),
504 : : parms, current_template_parms);
505 : 67049106 : TEMPLATE_PARMS_CONSTRAINTS (current_template_parms)
506 : 33524553 : = TEMPLATE_PARMS_CONSTRAINTS (parmlist);
507 : 33524553 : TEMPLATE_PARMS_FOR_INLINE (current_template_parms) = 1;
508 : :
509 : 33524553 : begin_scope (TREE_VEC_LENGTH (parms) ? sk_template_parms : sk_template_spec,
510 : : NULL);
511 : 89704268 : for (i = 0; i < TREE_VEC_LENGTH (parms); ++i)
512 : : {
513 : 56179715 : tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
514 : :
515 : 56179715 : if (error_operand_p (parm))
516 : 37 : continue;
517 : :
518 : 56179678 : gcc_assert (DECL_P (parm));
519 : :
520 : 56179678 : switch (TREE_CODE (parm))
521 : : {
522 : 51805032 : case TYPE_DECL:
523 : 51805032 : case TEMPLATE_DECL:
524 : 51805032 : pushdecl (parm);
525 : 51805032 : break;
526 : :
527 : 4374646 : case PARM_DECL:
528 : : /* Push the CONST_DECL. */
529 : 4374646 : pushdecl (TEMPLATE_PARM_DECL (DECL_INITIAL (parm)));
530 : 4374646 : break;
531 : :
532 : 0 : default:
533 : 0 : gcc_unreachable ();
534 : : }
535 : : }
536 : 33524553 : }
537 : :
538 : : /* Restore the template parameter context for a member template, a
539 : : friend template defined in a class definition, or a non-template
540 : : member of template class. */
541 : :
542 : : void
543 : 153669386 : maybe_begin_member_template_processing (tree decl)
544 : : {
545 : 153669386 : tree parms;
546 : 153669386 : int levels = 0;
547 : 153669386 : bool nsdmi = TREE_CODE (decl) == FIELD_DECL;
548 : :
549 : 153669386 : if (nsdmi)
550 : : {
551 : 1023541 : tree ctx = DECL_CONTEXT (decl);
552 : 1023541 : decl = (CLASSTYPE_TEMPLATE_INFO (ctx)
553 : : /* Disregard full specializations (c++/60999). */
554 : 672543 : && uses_template_parms (ctx)
555 : 1692874 : ? CLASSTYPE_TI_TEMPLATE (ctx) : NULL_TREE);
556 : : }
557 : :
558 : 153669386 : if (inline_needs_template_parms (decl, nsdmi))
559 : : {
560 : 33111821 : parms = DECL_TEMPLATE_PARMS (most_general_template (decl));
561 : 33111821 : levels = TMPL_PARMS_DEPTH (parms) - current_template_depth;
562 : :
563 : 33111821 : if (DECL_TEMPLATE_SPECIALIZATION (decl))
564 : : {
565 : 0 : --levels;
566 : 0 : parms = TREE_CHAIN (parms);
567 : : }
568 : :
569 : 33111821 : push_inline_template_parms_recursive (parms, levels);
570 : : }
571 : :
572 : : /* Remember how many levels of template parameters we pushed so that
573 : : we can pop them later. */
574 : 153669386 : inline_parm_levels.safe_push (levels);
575 : 153669386 : }
576 : :
577 : : /* Undo the effects of maybe_begin_member_template_processing. */
578 : :
579 : : void
580 : 153669734 : maybe_end_member_template_processing (void)
581 : : {
582 : 153669734 : int i;
583 : 153669734 : int last;
584 : :
585 : 153669734 : if (inline_parm_levels.length () == 0)
586 : : return;
587 : :
588 : 153669386 : last = inline_parm_levels.pop ();
589 : 187193939 : for (i = 0; i < last; ++i)
590 : : {
591 : 33524553 : --processing_template_decl;
592 : 33524553 : current_template_parms = TREE_CHAIN (current_template_parms);
593 : 33524553 : poplevel (0, 0, 0);
594 : : }
595 : : }
596 : :
597 : : /* Return a new template argument vector which contains all of ARGS,
598 : : but has as its innermost set of arguments the EXTRA_ARGS. */
599 : :
600 : : tree
601 : 53287309 : add_to_template_args (tree args, tree extra_args)
602 : : {
603 : 53287309 : tree new_args;
604 : 53287309 : int extra_depth;
605 : 53287309 : int i;
606 : 53287309 : int j;
607 : :
608 : 53287309 : if (args == NULL_TREE || extra_args == error_mark_node)
609 : : return extra_args;
610 : :
611 : 79182906 : extra_depth = TMPL_ARGS_DEPTH (extra_args);
612 : 39591453 : new_args = make_tree_vec (TMPL_ARGS_DEPTH (args) + extra_depth);
613 : :
614 : 125983407 : for (i = 1; i <= TMPL_ARGS_DEPTH (args); ++i)
615 : 39772077 : SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (args, i));
616 : :
617 : 79182918 : for (j = 1; j <= extra_depth; ++j, ++i)
618 : 79182930 : SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (extra_args, j));
619 : :
620 : : return new_args;
621 : : }
622 : :
623 : : /* Like add_to_template_args, but only the outermost ARGS are added to
624 : : the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
625 : : (EXTRA_ARGS) levels are added. This function is used to combine
626 : : the template arguments from a partial instantiation with the
627 : : template arguments used to attain the full instantiation from the
628 : : partial instantiation.
629 : :
630 : : If ARGS is a TEMPLATE_DECL, use its parameters as args. */
631 : :
632 : : tree
633 : 708143367 : add_outermost_template_args (tree args, tree extra_args)
634 : : {
635 : 708143367 : tree new_args;
636 : :
637 : 708143367 : if (!args)
638 : : return extra_args;
639 : 708143367 : if (TREE_CODE (args) == TEMPLATE_DECL)
640 : : {
641 : 120655409 : tree ti = get_template_info (DECL_TEMPLATE_RESULT (args));
642 : 120655409 : args = TI_ARGS (ti);
643 : : }
644 : :
645 : : /* If there are more levels of EXTRA_ARGS than there are ARGS,
646 : : something very fishy is going on. */
647 : 2911123653 : gcc_assert (TMPL_ARGS_DEPTH (args) >= TMPL_ARGS_DEPTH (extra_args));
648 : :
649 : : /* If *all* the new arguments will be the EXTRA_ARGS, just return
650 : : them. */
651 : 3498611611 : if (TMPL_ARGS_DEPTH (args) == TMPL_ARGS_DEPTH (extra_args))
652 : : return extra_args;
653 : :
654 : : /* For the moment, we make ARGS look like it contains fewer levels. */
655 : 107495850 : TREE_VEC_LENGTH (args) -= TMPL_ARGS_DEPTH (extra_args);
656 : :
657 : 35963314 : new_args = add_to_template_args (args, extra_args);
658 : :
659 : : /* Now, we restore ARGS to its full dimensions. */
660 : 107495850 : TREE_VEC_LENGTH (args) += TMPL_ARGS_DEPTH (extra_args);
661 : :
662 : 35963314 : return new_args;
663 : : }
664 : :
665 : : /* Return the N levels of innermost template arguments from the ARGS. */
666 : :
667 : : tree
668 : 3913624211 : get_innermost_template_args (tree args, int n)
669 : : {
670 : 3913624211 : tree new_args;
671 : 3913624211 : int extra_levels;
672 : 3913624211 : int i;
673 : :
674 : 3913624211 : gcc_assert (n >= 0);
675 : :
676 : : /* If N is 1, just return the innermost set of template arguments. */
677 : 3913624211 : if (n == 1)
678 : 7827104784 : return TMPL_ARGS_LEVEL (args, TMPL_ARGS_DEPTH (args));
679 : :
680 : : /* If we're not removing anything, just return the arguments we were
681 : : given. */
682 : 143638 : extra_levels = TMPL_ARGS_DEPTH (args) - n;
683 : 71819 : gcc_assert (extra_levels >= 0);
684 : 71819 : if (extra_levels == 0)
685 : : return args;
686 : :
687 : : /* Make a new set of arguments, not containing the outer arguments. */
688 : 18 : new_args = make_tree_vec (n);
689 : 72 : for (i = 1; i <= n; ++i)
690 : 72 : SET_TMPL_ARGS_LEVEL (new_args, i,
691 : : TMPL_ARGS_LEVEL (args, i + extra_levels));
692 : :
693 : : return new_args;
694 : : }
695 : :
696 : : /* The inverse of get_innermost_template_args: Return all but the innermost
697 : : EXTRA_LEVELS levels of template arguments from the ARGS. */
698 : :
699 : : static tree
700 : 218923 : strip_innermost_template_args (tree args, int extra_levels)
701 : : {
702 : 218923 : tree new_args;
703 : 437846 : int n = TMPL_ARGS_DEPTH (args) - extra_levels;
704 : 218923 : int i;
705 : :
706 : 218923 : gcc_assert (n >= 0);
707 : :
708 : : /* If N is 1, just return the outermost set of template arguments. */
709 : 218923 : if (n == 1)
710 : 436914 : return TMPL_ARGS_LEVEL (args, 1);
711 : :
712 : : /* If we're not removing anything, just return the arguments we were
713 : : given. */
714 : 466 : gcc_assert (extra_levels >= 0);
715 : 466 : if (extra_levels == 0)
716 : : return args;
717 : :
718 : : /* Make a new set of arguments, not containing the inner arguments. */
719 : 466 : new_args = make_tree_vec (n);
720 : 1864 : for (i = 1; i <= n; ++i)
721 : 1864 : SET_TMPL_ARGS_LEVEL (new_args, i,
722 : : TMPL_ARGS_LEVEL (args, i));
723 : :
724 : : return new_args;
725 : : }
726 : :
727 : : /* We've got a template header coming up; push to a new level for storing
728 : : the parms. */
729 : :
730 : : void
731 : 76546550 : begin_template_parm_list (void)
732 : : {
733 : : /* We use a non-tag-transparent scope here, which causes pushtag to
734 : : put tags in this scope, rather than in the enclosing class or
735 : : namespace scope. This is the right thing, since we want
736 : : TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
737 : : global template class, push_template_decl handles putting the
738 : : TEMPLATE_DECL into top-level scope. For a nested template class,
739 : : e.g.:
740 : :
741 : : template <class T> struct S1 {
742 : : template <class T> struct S2 {};
743 : : };
744 : :
745 : : pushtag contains special code to insert the TEMPLATE_DECL for S2
746 : : at the right scope. */
747 : 76546550 : begin_scope (sk_template_parms, NULL);
748 : 76546550 : ++processing_template_decl;
749 : 76546550 : ++processing_template_parmlist;
750 : 76546550 : note_template_header (0);
751 : :
752 : : /* Add a dummy parameter level while we process the parameter list. */
753 : 153093100 : current_template_parms
754 : 76546550 : = tree_cons (size_int (current_template_depth + 1),
755 : : make_tree_vec (0),
756 : : current_template_parms);
757 : 76546550 : }
758 : :
759 : : /* This routine is called when a specialization is declared. If it is
760 : : invalid to declare a specialization here, an error is reported and
761 : : false is returned, otherwise this routine will return true. */
762 : :
763 : : static bool
764 : 4809530 : check_specialization_scope (void)
765 : : {
766 : 4809530 : tree scope = current_scope ();
767 : :
768 : : /* [temp.expl.spec]
769 : :
770 : : An explicit specialization shall be declared in the namespace of
771 : : which the template is a member, or, for member templates, in the
772 : : namespace of which the enclosing class or enclosing class
773 : : template is a member. An explicit specialization of a member
774 : : function, member class or static data member of a class template
775 : : shall be declared in the namespace of which the class template
776 : : is a member. */
777 : 4809530 : if (scope && TREE_CODE (scope) != NAMESPACE_DECL)
778 : : {
779 : 24 : error ("explicit specialization in non-namespace scope %qD", scope);
780 : 24 : return false;
781 : : }
782 : :
783 : : /* [temp.expl.spec]
784 : :
785 : : In an explicit specialization declaration for a member of a class
786 : : template or a member template that appears in namespace scope,
787 : : the member template and some of its enclosing class templates may
788 : : remain unspecialized, except that the declaration shall not
789 : : explicitly specialize a class member template if its enclosing
790 : : class templates are not explicitly specialized as well. */
791 : 4809506 : if (current_template_parms)
792 : : {
793 : 6 : error ("enclosing class templates are not explicitly specialized");
794 : 6 : return false;
795 : : }
796 : :
797 : : return true;
798 : : }
799 : :
800 : : /* We've just seen template <>. */
801 : :
802 : : bool
803 : 4809530 : begin_specialization (void)
804 : : {
805 : 4809530 : begin_scope (sk_template_spec, NULL);
806 : 4809530 : note_template_header (1);
807 : 9619060 : return check_specialization_scope ();
808 : : }
809 : :
810 : : /* Called at then end of processing a declaration preceded by
811 : : template<>. */
812 : :
813 : : void
814 : 4809530 : end_specialization (void)
815 : : {
816 : 4809530 : finish_scope ();
817 : 4809530 : reset_specialization ();
818 : 4809530 : }
819 : :
820 : : /* Any template <>'s that we have seen thus far are not referring to a
821 : : function specialization. */
822 : :
823 : : void
824 : 143140329 : reset_specialization (void)
825 : : {
826 : 143140329 : processing_specialization = 0;
827 : 143140329 : template_header_count = 0;
828 : 143140329 : }
829 : :
830 : : /* We've just seen a template header. If SPECIALIZATION is nonzero,
831 : : it was of the form template <>. */
832 : :
833 : : static void
834 : 81356080 : note_template_header (int specialization)
835 : : {
836 : 81356080 : processing_specialization = specialization;
837 : 81356080 : template_header_count++;
838 : 0 : }
839 : :
840 : : /* We're beginning an explicit instantiation. */
841 : :
842 : : void
843 : 2743327 : begin_explicit_instantiation (void)
844 : : {
845 : 2743327 : gcc_assert (!processing_explicit_instantiation);
846 : 2743327 : processing_explicit_instantiation = true;
847 : 2743327 : }
848 : :
849 : :
850 : : void
851 : 2743324 : end_explicit_instantiation (void)
852 : : {
853 : 2743324 : gcc_assert (processing_explicit_instantiation);
854 : 2743324 : processing_explicit_instantiation = false;
855 : 2743324 : }
856 : :
857 : : /* An explicit specialization or partial specialization of TMPL is being
858 : : declared. Check that the namespace in which the specialization is
859 : : occurring is permissible. Returns false iff it is invalid to
860 : : specialize TMPL in the current namespace. */
861 : :
862 : : static bool
863 : 11454126 : check_specialization_namespace (tree tmpl)
864 : : {
865 : 11454126 : tree tpl_ns = decl_namespace_context (tmpl);
866 : :
867 : : /* [tmpl.expl.spec]
868 : :
869 : : An explicit specialization shall be declared in a namespace enclosing the
870 : : specialized template. An explicit specialization whose declarator-id is
871 : : not qualified shall be declared in the nearest enclosing namespace of the
872 : : template, or, if the namespace is inline (7.3.1), any namespace from its
873 : : enclosing namespace set. */
874 : 11454126 : if (current_scope() != DECL_CONTEXT (tmpl)
875 : 11454126 : && !at_namespace_scope_p ())
876 : : {
877 : 12 : error ("specialization of %qD must appear at namespace scope", tmpl);
878 : 12 : return false;
879 : : }
880 : :
881 : 11454114 : if (is_nested_namespace (current_namespace, tpl_ns, cxx_dialect < cxx11))
882 : : /* Same or enclosing namespace. */
883 : : return true;
884 : : else
885 : : {
886 : 14 : auto_diagnostic_group d;
887 : 14 : if (permerror (input_location,
888 : : "specialization of %qD in different namespace", tmpl))
889 : 11 : inform (DECL_SOURCE_LOCATION (tmpl),
890 : : " from definition of %q#D", tmpl);
891 : 14 : return false;
892 : 14 : }
893 : : }
894 : :
895 : : /* SPEC is an explicit instantiation. Check that it is valid to
896 : : perform this explicit instantiation in the current namespace. */
897 : :
898 : : static void
899 : 2774650 : check_explicit_instantiation_namespace (tree spec)
900 : : {
901 : 2774650 : tree ns;
902 : :
903 : : /* DR 275: An explicit instantiation shall appear in an enclosing
904 : : namespace of its template. */
905 : 2774650 : ns = decl_namespace_context (spec);
906 : 2774650 : if (!is_nested_namespace (current_namespace, ns))
907 : 6 : permerror (input_location, "explicit instantiation of %qD in namespace %qD "
908 : : "(which does not enclose namespace %qD)",
909 : : spec, current_namespace, ns);
910 : 2774650 : }
911 : :
912 : : /* Returns true if TYPE is a new partial specialization that needs to be
913 : : set up. This may also modify TYPE to point to the correct (new or
914 : : existing) constrained partial specialization. */
915 : :
916 : : static bool
917 : 29704972 : maybe_new_partial_specialization (tree& type)
918 : : {
919 : : /* An implicit instantiation of an incomplete type implies
920 : : the definition of a new class template.
921 : :
922 : : template<typename T>
923 : : struct S;
924 : :
925 : : template<typename T>
926 : : struct S<T*>;
927 : :
928 : : Here, S<T*> is an implicit instantiation of S whose type
929 : : is incomplete. */
930 : 29704972 : if (CLASSTYPE_IMPLICIT_INSTANTIATION (type) && !COMPLETE_TYPE_P (type))
931 : : return true;
932 : :
933 : : /* It can also be the case that TYPE is a completed specialization.
934 : : Continuing the previous example, suppose we also declare:
935 : :
936 : : template<typename T>
937 : : requires Integral<T>
938 : : struct S<T*>;
939 : :
940 : : Here, S<T*> refers to the specialization S<T*> defined
941 : : above. However, we need to differentiate definitions because
942 : : we intend to define a new partial specialization. In this case,
943 : : we rely on the fact that the constraints are different for
944 : : this declaration than that above.
945 : :
946 : : Note that we also get here for injected class names and
947 : : late-parsed template definitions. We must ensure that we
948 : : do not create new type declarations for those cases. */
949 : 19786995 : if (flag_concepts && CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
950 : : {
951 : 5275784 : tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
952 : 5275784 : tree args = CLASSTYPE_TI_ARGS (type);
953 : :
954 : : /* If there are no template parameters, this cannot be a new
955 : : partial template specialization? */
956 : 5275784 : if (!current_template_parms)
957 : : return false;
958 : :
959 : : /* The injected-class-name is not a new partial specialization. */
960 : 3391061 : if (DECL_SELF_REFERENCE_P (TYPE_NAME (type)))
961 : : return false;
962 : :
963 : : /* If the constraints are not the same as those of the primary
964 : : then, we can probably create a new specialization. */
965 : 3391061 : tree type_constr = current_template_constraints ();
966 : :
967 : 3391061 : if (type == TREE_TYPE (tmpl))
968 : : {
969 : 18 : tree main_constr = get_constraints (tmpl);
970 : 18 : if (equivalent_constraints (type_constr, main_constr))
971 : : return false;
972 : : }
973 : :
974 : : /* Also, if there's a pre-existing specialization with matching
975 : : constraints, then this also isn't new. */
976 : 3391043 : tree specs = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
977 : 3539695 : while (specs)
978 : : {
979 : 3491640 : tree spec_tmpl = TREE_VALUE (specs);
980 : 3491640 : tree spec_args = TREE_PURPOSE (specs);
981 : 3491640 : tree spec_constr = get_constraints (spec_tmpl);
982 : 3491640 : if (comp_template_args (args, spec_args)
983 : 3491640 : && equivalent_constraints (type_constr, spec_constr))
984 : : {
985 : 3342988 : type = TREE_TYPE (spec_tmpl);
986 : 3342988 : return false;
987 : : }
988 : 148652 : specs = TREE_CHAIN (specs);
989 : : }
990 : :
991 : : /* Create a new type node (and corresponding type decl)
992 : : for the newly declared specialization. */
993 : 48055 : tree t = make_class_type (TREE_CODE (type));
994 : 48055 : CLASSTYPE_DECLARED_CLASS (t) = CLASSTYPE_DECLARED_CLASS (type);
995 : 48055 : SET_TYPE_TEMPLATE_INFO (t, build_template_info (tmpl, args));
996 : 48055 : TYPE_CONTEXT (t) = TYPE_CONTEXT (type);
997 : :
998 : : /* We only need a separate type node for storing the definition of this
999 : : partial specialization; uses of S<T*> are unconstrained, so all are
1000 : : equivalent. So keep TYPE_CANONICAL the same. */
1001 : 48055 : TYPE_CANONICAL (t) = TYPE_CANONICAL (type);
1002 : :
1003 : : /* Build the corresponding type decl. */
1004 : 48055 : tree d = create_implicit_typedef (DECL_NAME (tmpl), t);
1005 : 48055 : DECL_CONTEXT (d) = TYPE_CONTEXT (t);
1006 : 48055 : DECL_SOURCE_LOCATION (d) = input_location;
1007 : 48055 : TREE_PUBLIC (d) = TREE_PUBLIC (DECL_TEMPLATE_RESULT (tmpl));
1008 : :
1009 : 48055 : set_instantiating_module (d);
1010 : 48055 : DECL_MODULE_EXPORT_P (d) = DECL_MODULE_EXPORT_P (tmpl);
1011 : :
1012 : 48055 : type = t;
1013 : 48055 : return true;
1014 : : }
1015 : :
1016 : : return false;
1017 : : }
1018 : :
1019 : : /* The TYPE is being declared. If it is a template type, that means it
1020 : : is a partial specialization. Do appropriate error-checking. */
1021 : :
1022 : : tree
1023 : 61261263 : maybe_process_partial_specialization (tree type)
1024 : : {
1025 : 61261263 : tree context;
1026 : :
1027 : 61261263 : if (type == error_mark_node)
1028 : : return error_mark_node;
1029 : :
1030 : : /* A lambda that appears in specialization context is not itself a
1031 : : specialization. */
1032 : 61260499 : if (CLASS_TYPE_P (type) && CLASSTYPE_LAMBDA_EXPR (type))
1033 : : return type;
1034 : :
1035 : : /* An injected-class-name is not a specialization. */
1036 : 60507423 : if (DECL_SELF_REFERENCE_P (TYPE_NAME (type)))
1037 : : return type;
1038 : :
1039 : 60507417 : if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
1040 : : {
1041 : 3 : error ("name of class shadows template template parameter %qD",
1042 : 3 : TYPE_NAME (type));
1043 : 3 : return error_mark_node;
1044 : : }
1045 : :
1046 : 60507414 : context = TYPE_CONTEXT (type);
1047 : :
1048 : 60507414 : if (TYPE_ALIAS_P (type))
1049 : : {
1050 : 6 : tree tinfo = TYPE_ALIAS_TEMPLATE_INFO (type);
1051 : :
1052 : 12 : if (tinfo && DECL_ALIAS_TEMPLATE_P (TI_TEMPLATE (tinfo)))
1053 : 6 : error ("specialization of alias template %qD",
1054 : 6 : TI_TEMPLATE (tinfo));
1055 : : else
1056 : 0 : error ("explicit specialization of non-template %qT", type);
1057 : 6 : return error_mark_node;
1058 : : }
1059 : 60507408 : else if (CLASS_TYPE_P (type) && CLASSTYPE_USE_TEMPLATE (type))
1060 : : {
1061 : : /* This is for ordinary explicit specialization and partial
1062 : : specialization of a template class such as:
1063 : :
1064 : : template <> class C<int>;
1065 : :
1066 : : or:
1067 : :
1068 : : template <class T> class C<T*>;
1069 : :
1070 : : Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
1071 : :
1072 : 29704972 : if (maybe_new_partial_specialization (type))
1073 : : {
1074 : 9966032 : if (!check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (type))
1075 : 9966032 : && !at_namespace_scope_p ())
1076 : 12 : return error_mark_node;
1077 : 9966020 : SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
1078 : 9966020 : DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)) = input_location;
1079 : 9966020 : if (processing_template_decl)
1080 : : {
1081 : 6202235 : tree decl = push_template_decl (TYPE_MAIN_DECL (type));
1082 : 6202235 : if (decl == error_mark_node)
1083 : : return error_mark_node;
1084 : 6202152 : return TREE_TYPE (decl);
1085 : : }
1086 : : }
1087 : 19738940 : else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type))
1088 : 0 : error ("specialization of %qT after instantiation", type);
1089 : 5066 : else if (errorcount && !processing_specialization
1090 : 3930 : && CLASSTYPE_TEMPLATE_SPECIALIZATION (type)
1091 : 19742870 : && !uses_template_parms (CLASSTYPE_TI_ARGS (type)))
1092 : : /* Trying to define a specialization either without a template<> header
1093 : : or in an inappropriate place. We've already given an error, so just
1094 : : bail now so we don't actually define the specialization. */
1095 : 1129 : return error_mark_node;
1096 : : }
1097 : 30067365 : else if (CLASS_TYPE_P (type)
1098 : 30067365 : && !CLASSTYPE_USE_TEMPLATE (type)
1099 : 30067365 : && CLASSTYPE_TEMPLATE_INFO (type)
1100 : 21290958 : && context && CLASS_TYPE_P (context)
1101 : 32967265 : && CLASSTYPE_TEMPLATE_INFO (context))
1102 : : {
1103 : : /* This is for an explicit specialization of member class
1104 : : template according to [temp.expl.spec/18]:
1105 : :
1106 : : template <> template <class U> class C<int>::D;
1107 : :
1108 : : The context `C<int>' must be an implicit instantiation.
1109 : : Otherwise this is just a member class template declared
1110 : : earlier like:
1111 : :
1112 : : template <> class C<int> { template <class U> class D; };
1113 : : template <> template <class U> class C<int>::D;
1114 : :
1115 : : In the first case, `C<int>::D' is a specialization of `C<T>::D'
1116 : : while in the second case, `C<int>::D' is a primary template
1117 : : and `C<T>::D' may not exist. */
1118 : :
1119 : 1699085 : if (CLASSTYPE_IMPLICIT_INSTANTIATION (context)
1120 : 1699085 : && !COMPLETE_TYPE_P (type))
1121 : : {
1122 : 32 : tree t;
1123 : 32 : tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
1124 : :
1125 : 32 : if (current_namespace
1126 : 32 : != decl_namespace_context (tmpl))
1127 : : {
1128 : 0 : auto_diagnostic_group d;
1129 : 0 : if (permerror (input_location,
1130 : : "specialization of %qD in different namespace",
1131 : : type))
1132 : 0 : inform (DECL_SOURCE_LOCATION (tmpl),
1133 : : "from definition of %q#D", tmpl);
1134 : 0 : }
1135 : :
1136 : : /* Check for invalid specialization after instantiation:
1137 : :
1138 : : template <> template <> class C<int>::D<int>;
1139 : : template <> template <class U> class C<int>::D; */
1140 : :
1141 : 32 : for (t = DECL_TEMPLATE_INSTANTIATIONS (tmpl);
1142 : 43 : t; t = TREE_CHAIN (t))
1143 : : {
1144 : 11 : tree inst = TREE_VALUE (t);
1145 : 11 : if (CLASSTYPE_TEMPLATE_SPECIALIZATION (inst)
1146 : 11 : || !COMPLETE_OR_OPEN_TYPE_P (inst))
1147 : : {
1148 : : /* We already have a full specialization of this partial
1149 : : instantiation, or a full specialization has been
1150 : : looked up but not instantiated. Reassign it to the
1151 : : new member specialization template. */
1152 : 8 : spec_entry elt;
1153 : 8 : spec_entry *entry;
1154 : :
1155 : 8 : elt.tmpl = most_general_template (tmpl);
1156 : 8 : elt.args = CLASSTYPE_TI_ARGS (inst);
1157 : 8 : elt.spec = inst;
1158 : :
1159 : 8 : type_specializations->remove_elt (&elt);
1160 : :
1161 : 8 : elt.tmpl = tmpl;
1162 : 8 : CLASSTYPE_TI_ARGS (inst)
1163 : 8 : = elt.args = INNERMOST_TEMPLATE_ARGS (elt.args);
1164 : 8 : elt.hash = 0; /* Recalculate after changing tmpl/args. */
1165 : :
1166 : 8 : spec_entry **slot
1167 : 8 : = type_specializations->find_slot (&elt, INSERT);
1168 : 8 : entry = ggc_alloc<spec_entry> ();
1169 : 8 : *entry = elt;
1170 : 8 : *slot = entry;
1171 : : }
1172 : : else
1173 : : /* But if we've had an implicit instantiation, that's a
1174 : : problem ([temp.expl.spec]/6). */
1175 : 3 : error ("specialization %qT after instantiation %qT",
1176 : : type, inst);
1177 : : }
1178 : :
1179 : : /* Make sure that the specialization is valid. */
1180 : 32 : if (!redeclare_class_template (type, current_template_parms,
1181 : : current_template_constraints ()))
1182 : 6 : return error_mark_node;
1183 : :
1184 : : /* Mark TYPE as a specialization. And as a result, we only
1185 : : have one level of template argument for the innermost
1186 : : class template. */
1187 : 26 : SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
1188 : 26 : DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)) = input_location;
1189 : 26 : CLASSTYPE_TI_ARGS (type)
1190 : 52 : = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
1191 : : }
1192 : : }
1193 : 29103351 : else if (processing_specialization)
1194 : : {
1195 : : /* Someday C++0x may allow for enum template specialization. */
1196 : 18 : if (cxx_dialect > cxx98 && TREE_CODE (type) == ENUMERAL_TYPE
1197 : 37 : && CLASS_TYPE_P (context) && CLASSTYPE_USE_TEMPLATE (context))
1198 : 9 : pedwarn (input_location, OPT_Wpedantic, "template specialization "
1199 : : "of %qD not allowed by ISO C++", type);
1200 : : else
1201 : : {
1202 : 12 : error ("explicit specialization of non-template %qT", type);
1203 : 12 : return error_mark_node;
1204 : : }
1205 : : }
1206 : :
1207 : 54304014 : return type;
1208 : : }
1209 : :
1210 : : /* Make sure ARGS doesn't use any inappropriate typedefs; we should have
1211 : : gone through coerce_template_parms by now. */
1212 : :
1213 : : static void
1214 : 471614870 : verify_unstripped_args_1 (tree inner)
1215 : : {
1216 : 1502554010 : for (int i = 0; i < TREE_VEC_LENGTH (inner); ++i)
1217 : : {
1218 : 1030939140 : tree arg = TREE_VEC_ELT (inner, i);
1219 : 1030939140 : if (TREE_CODE (arg) == TEMPLATE_DECL)
1220 : : /* OK */;
1221 : 1030212511 : else if (TYPE_P (arg))
1222 : 953517361 : gcc_assert (strip_typedefs (arg, NULL) == arg);
1223 : 76695150 : else if (ARGUMENT_PACK_P (arg))
1224 : 1776425 : verify_unstripped_args_1 (ARGUMENT_PACK_ARGS (arg));
1225 : 74918725 : else if (strip_typedefs (TREE_TYPE (arg), NULL) != TREE_TYPE (arg))
1226 : : /* Allow typedefs on the type of a non-type argument, since a
1227 : : parameter can have them. */;
1228 : : else
1229 : 74918565 : gcc_assert (strip_typedefs_expr (arg, NULL) == arg);
1230 : : }
1231 : 471614870 : }
1232 : :
1233 : : static void
1234 : 528266054 : verify_unstripped_args (tree args)
1235 : : {
1236 : 528266054 : ++processing_template_decl;
1237 : 528266054 : if (!any_dependent_template_arguments_p (args))
1238 : 469838445 : verify_unstripped_args_1 (INNERMOST_TEMPLATE_ARGS (args));
1239 : 528266054 : --processing_template_decl;
1240 : 528266054 : }
1241 : :
1242 : : /* Retrieve the specialization (in the sense of [temp.spec] - a
1243 : : specialization is either an instantiation or an explicit
1244 : : specialization) of TMPL for the given template ARGS. If there is
1245 : : no such specialization, return NULL_TREE. The ARGS are a vector of
1246 : : arguments, or a vector of vectors of arguments, in the case of
1247 : : templates with more than one level of parameters.
1248 : :
1249 : : If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
1250 : : then we search for a partial specialization matching ARGS. This
1251 : : parameter is ignored if TMPL is not a class template.
1252 : :
1253 : : We can also look up a FIELD_DECL, if it is a lambda capture pack; the
1254 : : result is a NONTYPE_ARGUMENT_PACK. */
1255 : :
1256 : : static tree
1257 : 528266054 : retrieve_specialization (tree tmpl, tree args, hashval_t hash)
1258 : : {
1259 : 528266054 : if (tmpl == NULL_TREE)
1260 : : return NULL_TREE;
1261 : :
1262 : 528266054 : if (args == error_mark_node)
1263 : : return NULL_TREE;
1264 : :
1265 : 528266054 : gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL
1266 : : || TREE_CODE (tmpl) == FIELD_DECL);
1267 : :
1268 : : /* There should be as many levels of arguments as there are
1269 : : levels of parameters. */
1270 : 1056532108 : gcc_assert (TMPL_ARGS_DEPTH (args)
1271 : : == (TREE_CODE (tmpl) == TEMPLATE_DECL
1272 : : ? TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl))
1273 : : : template_class_depth (DECL_CONTEXT (tmpl))));
1274 : :
1275 : 528266054 : if (flag_checking)
1276 : 528266054 : verify_unstripped_args (args);
1277 : :
1278 : : /* Lambda functions in templates aren't instantiated normally, but through
1279 : : tsubst_lambda_expr. */
1280 : 528266054 : if (lambda_fn_in_template_p (tmpl))
1281 : : return NULL_TREE;
1282 : :
1283 : 528266054 : spec_entry elt;
1284 : 528266054 : elt.tmpl = tmpl;
1285 : 528266054 : elt.args = args;
1286 : 528266054 : elt.hash = hash;
1287 : :
1288 : 528266054 : spec_hash_table *specializations;
1289 : 528266054 : if (DECL_CLASS_TEMPLATE_P (tmpl))
1290 : 1530981 : specializations = type_specializations;
1291 : : else
1292 : 526735073 : specializations = decl_specializations;
1293 : :
1294 : 528266054 : if (spec_entry *found = specializations->find (&elt))
1295 : 261522379 : return found->spec;
1296 : :
1297 : : return NULL_TREE;
1298 : : }
1299 : :
1300 : : /* Like retrieve_specialization, but for local declarations. */
1301 : :
1302 : : tree
1303 : 149983402 : retrieve_local_specialization (tree tmpl)
1304 : : {
1305 : 149983402 : if (local_specializations == NULL)
1306 : : return NULL_TREE;
1307 : :
1308 : 146572632 : tree *slot = local_specializations->get (tmpl);
1309 : 146572632 : return slot ? *slot : NULL_TREE;
1310 : : }
1311 : :
1312 : : /* Returns nonzero iff DECL is a specialization of TMPL. */
1313 : :
1314 : : int
1315 : 1129695 : is_specialization_of (tree decl, tree tmpl)
1316 : : {
1317 : 1129695 : tree t;
1318 : :
1319 : 1129695 : if (TREE_CODE (decl) == FUNCTION_DECL)
1320 : : {
1321 : 459413 : for (t = decl;
1322 : 901905 : t != NULL_TREE;
1323 : 459413 : t = DECL_TEMPLATE_INFO (t) ? DECL_TI_TEMPLATE (t) : NULL_TREE)
1324 : 616893 : if (t == tmpl)
1325 : : return 1;
1326 : : }
1327 : : else
1328 : : {
1329 : 687203 : gcc_assert (TREE_CODE (decl) == TYPE_DECL);
1330 : :
1331 : 687203 : for (t = TREE_TYPE (decl);
1332 : 1574818 : t != NULL_TREE;
1333 : 887615 : t = CLASSTYPE_USE_TEMPLATE (t)
1334 : 887615 : ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t)) : NULL_TREE)
1335 : 1319209 : 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 : 1255341 : is_specialization_of_friend (tree decl, tree friend_decl)
1347 : : {
1348 : 1255341 : bool need_template = true;
1349 : 1255341 : int template_depth;
1350 : :
1351 : 1255341 : 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 : 1255341 : if (TREE_CODE (friend_decl) == FUNCTION_DECL
1358 : 125841 : && DECL_CLASS_SCOPE_P (friend_decl)
1359 : 56 : && DECL_TEMPLATE_INFO (friend_decl)
1360 : 1255395 : && !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 : 1255287 : else if (TREE_CODE (friend_decl) == TEMPLATE_DECL
1367 : 1255287 : && !PRIMARY_TEMPLATE_P (friend_decl))
1368 : : need_template = false;
1369 : :
1370 : : /* There is nothing to do if this is not a template friend. */
1371 : 1255341 : if (TREE_CODE (friend_decl) != TEMPLATE_DECL)
1372 : : return false;
1373 : :
1374 : 1129554 : 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 : 540618 : template_depth = template_class_depth (CP_DECL_CONTEXT (friend_decl));
1398 : 540618 : if (template_depth
1399 : 147 : && DECL_CLASS_SCOPE_P (decl)
1400 : 540759 : && 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 : 197612273 : register_specialization (tree spec, tree tmpl, tree args, bool is_friend,
1537 : : hashval_t hash)
1538 : : {
1539 : 197612273 : tree fn;
1540 : :
1541 : 197612273 : 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 : 197612273 : spec_entry elt;
1546 : 197612273 : elt.tmpl = tmpl;
1547 : 197612273 : elt.args = args;
1548 : 197612273 : elt.spec = spec;
1549 : 197612273 : elt.hash = hash;
1550 : :
1551 : 197612273 : spec_entry **slot = decl_specializations->find_slot (&elt, INSERT);
1552 : 197612273 : if (*slot)
1553 : 555553 : fn = (*slot)->spec;
1554 : : else
1555 : : fn = NULL_TREE;
1556 : :
1557 : : /* We can sometimes try to re-register a specialization that we've
1558 : : already got. In particular, regenerate_decl_from_template calls
1559 : : duplicate_decls which will update the specialization list. But,
1560 : : we'll still get called again here anyhow. It's more convenient
1561 : : to simply allow this than to try to prevent it. */
1562 : 197612273 : if (fn == spec)
1563 : : return spec;
1564 : 197611316 : else if (fn && DECL_TEMPLATE_SPECIALIZATION (spec))
1565 : : {
1566 : 554527 : if (DECL_TEMPLATE_INSTANTIATION (fn))
1567 : : {
1568 : 554283 : if (DECL_ODR_USED (fn)
1569 : 554283 : || DECL_EXPLICIT_INSTANTIATION (fn))
1570 : : {
1571 : 8 : error ("specialization of %qD after instantiation",
1572 : : fn);
1573 : 8 : return error_mark_node;
1574 : : }
1575 : : else
1576 : : {
1577 : 554275 : tree clone;
1578 : : /* This situation should occur only if the first
1579 : : specialization is an implicit instantiation, the
1580 : : second is an explicit specialization, and the
1581 : : implicit instantiation has not yet been used. That
1582 : : situation can occur if we have implicitly
1583 : : instantiated a member function and then specialized
1584 : : it later.
1585 : :
1586 : : We can also wind up here if a friend declaration that
1587 : : looked like an instantiation turns out to be a
1588 : : specialization:
1589 : :
1590 : : template <class T> void foo(T);
1591 : : class S { friend void foo<>(int) };
1592 : : template <> void foo(int);
1593 : :
1594 : : We transform the existing DECL in place so that any
1595 : : pointers to it become pointers to the updated
1596 : : declaration.
1597 : :
1598 : : If there was a definition for the template, but not
1599 : : for the specialization, we want this to look as if
1600 : : there were no definition, and vice versa. */
1601 : 554275 : DECL_INITIAL (fn) = NULL_TREE;
1602 : 554275 : duplicate_decls (spec, fn, /*hiding=*/is_friend);
1603 : :
1604 : : /* The call to duplicate_decls will have applied
1605 : : [temp.expl.spec]:
1606 : :
1607 : : An explicit specialization of a function template
1608 : : is inline only if it is explicitly declared to be,
1609 : : and independently of whether its function template
1610 : : is.
1611 : :
1612 : : to the primary function; now copy the inline bits to
1613 : : the various clones. */
1614 : 742142 : FOR_EACH_CLONE (clone, fn)
1615 : : {
1616 : 187867 : DECL_DECLARED_INLINE_P (clone)
1617 : 187867 : = DECL_DECLARED_INLINE_P (fn);
1618 : 375734 : DECL_SOURCE_LOCATION (clone)
1619 : 187867 : = DECL_SOURCE_LOCATION (fn);
1620 : 187867 : DECL_DELETED_FN (clone)
1621 : 375734 : = DECL_DELETED_FN (fn);
1622 : : }
1623 : 554275 : check_specialization_namespace (tmpl);
1624 : :
1625 : 554275 : return fn;
1626 : : }
1627 : : }
1628 : 244 : else if (DECL_TEMPLATE_SPECIALIZATION (fn))
1629 : : {
1630 : 244 : tree dd = duplicate_decls (spec, fn, /*hiding=*/is_friend);
1631 : 244 : if (dd == error_mark_node)
1632 : : /* We've already complained in duplicate_decls. */
1633 : : return error_mark_node;
1634 : :
1635 : 223 : if (dd == NULL_TREE && DECL_INITIAL (spec))
1636 : : /* Dup decl failed, but this is a new definition. Set the
1637 : : line number so any errors match this new
1638 : : definition. */
1639 : 0 : DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (spec);
1640 : :
1641 : 223 : return fn;
1642 : : }
1643 : : }
1644 : 197056789 : else if (fn)
1645 : 69 : return duplicate_decls (spec, fn, /*hiding=*/is_friend);
1646 : :
1647 : : /* A specialization must be declared in the same namespace as the
1648 : : template it is specializing. */
1649 : 197056720 : if (DECL_P (spec) && DECL_TEMPLATE_SPECIALIZATION (spec)
1650 : 197990539 : && !check_specialization_namespace (tmpl))
1651 : 0 : DECL_CONTEXT (spec) = DECL_CONTEXT (tmpl);
1652 : :
1653 : 197056720 : spec_entry *entry = ggc_alloc<spec_entry> ();
1654 : 197056720 : gcc_assert (tmpl && args && spec);
1655 : 197056720 : *entry = elt;
1656 : 197056720 : *slot = entry;
1657 : 91388524 : if ((TREE_CODE (spec) == FUNCTION_DECL && DECL_NAMESPACE_SCOPE_P (spec)
1658 : 16491694 : && PRIMARY_TEMPLATE_P (tmpl)
1659 : 15835869 : && DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (tmpl)) == NULL_TREE)
1660 : 190845228 : || module_maybe_has_cmi_p ()
1661 : 387353091 : || variable_template_p (tmpl))
1662 : : /* If TMPL is a forward declaration of a template function, keep a list
1663 : : of all specializations in case we need to reassign them to a friend
1664 : : template later in tsubst_friend_function.
1665 : :
1666 : : If we're building a CMI, keep a list for all function templates.
1667 : :
1668 : : Also keep a list of all variable template instantiations so that
1669 : : process_partial_specialization can check whether a later partial
1670 : : specialization would have used it. */
1671 : 22472134 : DECL_TEMPLATE_INSTANTIATIONS (tmpl)
1672 : 22472134 : = tree_cons (args, spec, DECL_TEMPLATE_INSTANTIATIONS (tmpl));
1673 : :
1674 : : return spec;
1675 : : }
1676 : :
1677 : : /* Restricts tree and type comparisons. */
1678 : : int comparing_specializations;
1679 : : int comparing_dependent_aliases;
1680 : :
1681 : : /* Whether we are comparing template arguments during partial ordering
1682 : : (and therefore want the comparison to look through dependent alias
1683 : : template specializations). */
1684 : :
1685 : : static int comparing_for_partial_ordering;
1686 : :
1687 : : /* Returns true iff two spec_entry nodes are equivalent. */
1688 : :
1689 : : bool
1690 : 8724455728 : spec_hasher::equal (spec_entry *e1, spec_entry *e2)
1691 : : {
1692 : 8724455728 : int equal;
1693 : :
1694 : 8724455728 : ++comparing_specializations;
1695 : 8724455728 : ++comparing_dependent_aliases;
1696 : 8724455728 : ++processing_template_decl;
1697 : 9300630857 : equal = (e1->tmpl == e2->tmpl
1698 : 8724455728 : && comp_template_args (e1->args, e2->args));
1699 : 576175129 : if (equal && flag_concepts
1700 : : /* tmpl could be a FIELD_DECL for a capture pack. */
1701 : 220421077 : && TREE_CODE (e1->tmpl) == TEMPLATE_DECL
1702 : 220421077 : && VAR_P (DECL_TEMPLATE_RESULT (e1->tmpl))
1703 : 7662545 : && uses_template_parms (e1->args))
1704 : : {
1705 : : /* Partial specializations of a variable template can be distinguished by
1706 : : constraints. */
1707 : 517 : tree c1 = e1->spec ? get_constraints (e1->spec) : NULL_TREE;
1708 : 517 : tree c2 = e2->spec ? get_constraints (e2->spec) : NULL_TREE;
1709 : 517 : equal = equivalent_constraints (c1, c2);
1710 : : }
1711 : 8724455728 : --processing_template_decl;
1712 : 8724455728 : --comparing_dependent_aliases;
1713 : 8724455728 : --comparing_specializations;
1714 : :
1715 : 8724455728 : return equal;
1716 : : }
1717 : :
1718 : : /* Returns a hash for a template TMPL and template arguments ARGS. */
1719 : :
1720 : : static hashval_t
1721 : 917140370 : hash_tmpl_and_args (tree tmpl, tree args)
1722 : : {
1723 : 917140370 : hashval_t val = iterative_hash_object (DECL_UID (tmpl), 0);
1724 : 917140370 : return iterative_hash_template_arg (args, val);
1725 : : }
1726 : :
1727 : : hashval_t
1728 : 899581677 : spec_hasher::hash (tree tmpl, tree args)
1729 : : {
1730 : 899581677 : ++comparing_specializations;
1731 : 899581677 : hashval_t val = hash_tmpl_and_args (tmpl, args);
1732 : 899581677 : --comparing_specializations;
1733 : 899581677 : return val;
1734 : : }
1735 : :
1736 : : /* Returns a hash for a spec_entry node based on the TMPL and ARGS members,
1737 : : ignoring SPEC. */
1738 : :
1739 : : hashval_t
1740 : 8100450769 : spec_hasher::hash (spec_entry *e)
1741 : : {
1742 : 8100450769 : if (e->hash == 0)
1743 : 590090906 : e->hash = hash (e->tmpl, e->args);
1744 : 8100450769 : return e->hash;
1745 : : }
1746 : :
1747 : : /* Recursively calculate a hash value for a template argument ARG, for use
1748 : : in the hash tables of template specializations. We must be
1749 : : careful to (at least) skip the same entities template_args_equal
1750 : : does. */
1751 : :
1752 : : hashval_t
1753 : 7509447704 : iterative_hash_template_arg (tree arg, hashval_t val)
1754 : : {
1755 : 7509447704 : if (arg == NULL_TREE)
1756 : 838449025 : return iterative_hash_hashval_t (0, val);
1757 : :
1758 : 6670998679 : if (!TYPE_P (arg))
1759 : : /* Strip nop-like things, but not the same as STRIP_NOPS. */
1760 : 2297807901 : while (CONVERT_EXPR_P (arg)
1761 : : || TREE_CODE (arg) == NON_LVALUE_EXPR
1762 : 2297807901 : || class_nttp_const_wrapper_p (arg))
1763 : 842889 : arg = TREE_OPERAND (arg, 0);
1764 : :
1765 : 6670998679 : enum tree_code code = TREE_CODE (arg);
1766 : :
1767 : 6670998679 : val = iterative_hash_hashval_t (code, val);
1768 : :
1769 : 6670998679 : switch (code)
1770 : : {
1771 : 0 : case ARGUMENT_PACK_SELECT:
1772 : : /* Getting here with an ARGUMENT_PACK_SELECT means we're probably
1773 : : preserving it in a hash table, which is bad because it will change
1774 : : meaning when gen_elem_of_pack_expansion_instantiation changes the
1775 : : ARGUMENT_PACK_SELECT_INDEX. */
1776 : 0 : gcc_unreachable ();
1777 : :
1778 : : case ERROR_MARK:
1779 : : return val;
1780 : :
1781 : 214193033 : case IDENTIFIER_NODE:
1782 : 214193033 : return iterative_hash_hashval_t (IDENTIFIER_HASH_VALUE (arg), val);
1783 : :
1784 : 1385783060 : case TREE_VEC:
1785 : 3861548810 : for (tree elt : tree_vec_range (arg))
1786 : 2475765750 : val = iterative_hash_template_arg (elt, val);
1787 : 1385783060 : return val;
1788 : :
1789 : 67021598 : case TYPE_PACK_EXPANSION:
1790 : 67021598 : case EXPR_PACK_EXPANSION:
1791 : 67021598 : val = iterative_hash_template_arg (PACK_EXPANSION_PATTERN (arg), val);
1792 : 67021598 : return iterative_hash_template_arg (PACK_EXPANSION_EXTRA_ARGS (arg), val);
1793 : :
1794 : 25 : case PACK_INDEX_TYPE:
1795 : 25 : case PACK_INDEX_EXPR:
1796 : 25 : val = iterative_hash_template_arg (PACK_INDEX_PACK (arg), val);
1797 : 25 : return iterative_hash_template_arg (PACK_INDEX_INDEX (arg), val);
1798 : :
1799 : 193979512 : case TYPE_ARGUMENT_PACK:
1800 : 193979512 : case NONTYPE_ARGUMENT_PACK:
1801 : 193979512 : return iterative_hash_template_arg (ARGUMENT_PACK_ARGS (arg), val);
1802 : :
1803 : : case TREE_LIST:
1804 : 1556880 : for (; arg; arg = TREE_CHAIN (arg))
1805 : 778443 : val = iterative_hash_template_arg (TREE_VALUE (arg), val);
1806 : : return val;
1807 : :
1808 : 102 : case OVERLOAD:
1809 : 216 : for (lkp_iterator iter (arg); iter; ++iter)
1810 : 114 : val = iterative_hash_template_arg (*iter, val);
1811 : 102 : return val;
1812 : :
1813 : 12007553 : case CONSTRUCTOR:
1814 : 12007553 : {
1815 : 12007553 : iterative_hash_template_arg (TREE_TYPE (arg), val);
1816 : 12533295 : for (auto &e: CONSTRUCTOR_ELTS (arg))
1817 : : {
1818 : 209958 : val = iterative_hash_template_arg (e.index, val);
1819 : 209958 : val = iterative_hash_template_arg (e.value, val);
1820 : : }
1821 : : return val;
1822 : : }
1823 : :
1824 : 10532609 : case PARM_DECL:
1825 : 10532609 : if (!DECL_ARTIFICIAL (arg))
1826 : : {
1827 : 10518014 : val = iterative_hash_object (DECL_PARM_INDEX (arg), val);
1828 : 10518014 : val = iterative_hash_object (DECL_PARM_LEVEL (arg), val);
1829 : : }
1830 : 10532609 : return iterative_hash_template_arg (TREE_TYPE (arg), val);
1831 : :
1832 : 324970734 : case TEMPLATE_DECL:
1833 : 324970734 : if (DECL_TEMPLATE_TEMPLATE_PARM_P (arg))
1834 : 17300307 : return iterative_hash_template_arg (TREE_TYPE (arg), val);
1835 : : break;
1836 : :
1837 : 0 : case TARGET_EXPR:
1838 : 0 : return iterative_hash_template_arg (TARGET_EXPR_INITIAL (arg), val);
1839 : :
1840 : 6395 : case PTRMEM_CST:
1841 : 6395 : val = iterative_hash_template_arg (PTRMEM_CST_CLASS (arg), val);
1842 : 6395 : return iterative_hash_template_arg (PTRMEM_CST_MEMBER (arg), val);
1843 : :
1844 : 21095920 : case TEMPLATE_PARM_INDEX:
1845 : 21095920 : val = iterative_hash_template_arg
1846 : 21095920 : (TREE_TYPE (TEMPLATE_PARM_DECL (arg)), val);
1847 : 21095920 : val = iterative_hash_object (TEMPLATE_PARM_LEVEL (arg), val);
1848 : 21095920 : return iterative_hash_object (TEMPLATE_PARM_IDX (arg), val);
1849 : :
1850 : 2008294 : case TRAIT_EXPR:
1851 : 2008294 : val = iterative_hash_object (TRAIT_EXPR_KIND (arg), val);
1852 : 2008294 : val = iterative_hash_template_arg (TRAIT_EXPR_TYPE1 (arg), val);
1853 : 2008294 : return iterative_hash_template_arg (TRAIT_EXPR_TYPE2 (arg), val);
1854 : :
1855 : 4299388 : case BASELINK:
1856 : 4299388 : val = iterative_hash_template_arg (BINFO_TYPE (BASELINK_BINFO (arg)),
1857 : : val);
1858 : 4299388 : return iterative_hash_template_arg (DECL_NAME (get_first_fn (arg)),
1859 : 4299388 : val);
1860 : :
1861 : 101 : case MODOP_EXPR:
1862 : 101 : val = iterative_hash_template_arg (TREE_OPERAND (arg, 0), val);
1863 : 101 : code = TREE_CODE (TREE_OPERAND (arg, 1));
1864 : 101 : val = iterative_hash_object (code, val);
1865 : 101 : return iterative_hash_template_arg (TREE_OPERAND (arg, 2), val);
1866 : :
1867 : 38 : case LAMBDA_EXPR:
1868 : : /* [temp.over.link] Two lambda-expressions are never considered
1869 : : equivalent.
1870 : :
1871 : : So just hash the closure type. */
1872 : 38 : return iterative_hash_template_arg (TREE_TYPE (arg), val);
1873 : :
1874 : 7919836 : case CAST_EXPR:
1875 : 7919836 : case IMPLICIT_CONV_EXPR:
1876 : 7919836 : case STATIC_CAST_EXPR:
1877 : 7919836 : case REINTERPRET_CAST_EXPR:
1878 : 7919836 : case CONST_CAST_EXPR:
1879 : 7919836 : case DYNAMIC_CAST_EXPR:
1880 : 7919836 : case NEW_EXPR:
1881 : 7919836 : val = iterative_hash_template_arg (TREE_TYPE (arg), val);
1882 : : /* Now hash operands as usual. */
1883 : 7919836 : break;
1884 : :
1885 : 90204079 : case CALL_EXPR:
1886 : 90204079 : {
1887 : 90204079 : tree fn = CALL_EXPR_FN (arg);
1888 : 90204079 : if (tree name = call_expr_dependent_name (arg))
1889 : : {
1890 : 70946427 : if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
1891 : 36581988 : val = iterative_hash_template_arg (TREE_OPERAND (fn, 1), val);
1892 : : fn = name;
1893 : : }
1894 : 90204079 : val = iterative_hash_template_arg (fn, val);
1895 : 90204079 : call_expr_arg_iterator ai;
1896 : 138112069 : for (tree x = first_call_expr_arg (arg, &ai); x;
1897 : 47907990 : x = next_call_expr_arg (&ai))
1898 : 47907990 : val = iterative_hash_template_arg (x, val);
1899 : 90204079 : return val;
1900 : : }
1901 : :
1902 : : default:
1903 : : break;
1904 : : }
1905 : :
1906 : 4651788209 : char tclass = TREE_CODE_CLASS (code);
1907 : 4651788209 : switch (tclass)
1908 : : {
1909 : 4117928741 : case tcc_type:
1910 : 4117928741 : if (tree ats = alias_template_specialization_p (arg, nt_transparent))
1911 : : {
1912 : : // We want an alias specialization that survived strip_typedefs
1913 : : // to hash differently from its TYPE_CANONICAL, to avoid hash
1914 : : // collisions that compare as different in template_args_equal.
1915 : : // These could be dependent specializations that strip_typedefs
1916 : : // left alone, or untouched specializations because
1917 : : // coerce_template_parms returns the unconverted template
1918 : : // arguments if it sees incomplete argument packs.
1919 : 17558693 : tree ti = TYPE_ALIAS_TEMPLATE_INFO (ats);
1920 : 17558693 : return hash_tmpl_and_args (TI_TEMPLATE (ti), TI_ARGS (ti));
1921 : : }
1922 : :
1923 : 4100370048 : switch (code)
1924 : : {
1925 : 46082332 : case DECLTYPE_TYPE:
1926 : 46082332 : val = iterative_hash_template_arg (DECLTYPE_TYPE_EXPR (arg), val);
1927 : 46082332 : break;
1928 : :
1929 : 129133318 : case TYPENAME_TYPE:
1930 : 129133318 : if (comparing_specializations)
1931 : : {
1932 : : /* Hash the components that are relevant to TYPENAME_TYPE
1933 : : equivalence as determined by structural_comptypes. We
1934 : : can only coherently do this when comparing_specializations
1935 : : is set, because otherwise structural_comptypes tries
1936 : : resolving TYPENAME_TYPE via the current instantiation. */
1937 : 115486186 : tree context = TYPE_MAIN_VARIANT (TYPE_CONTEXT (arg));
1938 : 115486186 : tree fullname = TYPENAME_TYPE_FULLNAME (arg);
1939 : 115486186 : val = iterative_hash_template_arg (context, val);
1940 : 115486186 : val = iterative_hash_template_arg (fullname, val);
1941 : : }
1942 : : break;
1943 : :
1944 : 3925154398 : default:
1945 : 3925154398 : if (tree canonical = TYPE_CANONICAL (arg))
1946 : 3872667717 : val = iterative_hash_hashval_t (TYPE_HASH (canonical), val);
1947 : 52486681 : else if (tree ti = TYPE_TEMPLATE_INFO (arg))
1948 : : {
1949 : 3421729 : val = iterative_hash_template_arg (TI_TEMPLATE (ti), val);
1950 : 3421729 : val = iterative_hash_template_arg (TI_ARGS (ti), val);
1951 : : }
1952 : : break;
1953 : : }
1954 : :
1955 : : return val;
1956 : :
1957 : 465999499 : case tcc_declaration:
1958 : 465999499 : case tcc_constant:
1959 : 465999499 : return iterative_hash_expr (arg, val);
1960 : :
1961 : 67859969 : default:
1962 : 67859969 : gcc_assert (IS_EXPR_CODE_CLASS (tclass));
1963 : 179105498 : for (int i = 0, n = cp_tree_operand_length (arg); i < n; ++i)
1964 : 111245529 : val = iterative_hash_template_arg (TREE_OPERAND (arg, i), val);
1965 : : return val;
1966 : : }
1967 : : }
1968 : :
1969 : : /* Unregister the specialization SPEC as a specialization of TMPL.
1970 : : Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1971 : : if the SPEC was listed as a specialization of TMPL.
1972 : :
1973 : : Note that SPEC has been ggc_freed, so we can't look inside it. */
1974 : :
1975 : : bool
1976 : 565611 : reregister_specialization (tree spec, tree tinfo, tree new_spec)
1977 : : {
1978 : 565611 : spec_entry *entry;
1979 : 565611 : spec_entry elt;
1980 : :
1981 : 565611 : elt.tmpl = most_general_template (TI_TEMPLATE (tinfo));
1982 : 565611 : elt.args = TI_ARGS (tinfo);
1983 : :
1984 : 565611 : entry = decl_specializations->find (&elt);
1985 : 565611 : if (entry != NULL)
1986 : : {
1987 : 565611 : gcc_assert (entry->spec == spec || entry->spec == new_spec);
1988 : 565611 : gcc_assert (new_spec != NULL_TREE);
1989 : 565611 : entry->spec = new_spec;
1990 : 565611 : return 1;
1991 : : }
1992 : :
1993 : : return 0;
1994 : : }
1995 : :
1996 : : /* Like register_specialization, but for local declarations. We are
1997 : : registering SPEC, an instantiation of TMPL. */
1998 : :
1999 : : void
2000 : 54826072 : register_local_specialization (tree spec, tree tmpl)
2001 : : {
2002 : 54826072 : gcc_assert (tmpl != spec);
2003 : 54826072 : local_specializations->put (tmpl, spec);
2004 : 54826072 : }
2005 : :
2006 : : /* Registers T as a specialization of itself. This is used to preserve
2007 : : the references to already-parsed parameters when instantiating
2008 : : postconditions. */
2009 : :
2010 : : void
2011 : 54 : register_local_identity (tree t)
2012 : : {
2013 : 54 : local_specializations->put (t, t);
2014 : 54 : }
2015 : :
2016 : : /* TYPE is a class type. Returns true if TYPE is an explicitly
2017 : : specialized class. */
2018 : :
2019 : : bool
2020 : 17691064 : explicit_class_specialization_p (tree type)
2021 : : {
2022 : 17691064 : if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
2023 : : return false;
2024 : 443011 : return !uses_template_parms (CLASSTYPE_TI_ARGS (type));
2025 : : }
2026 : :
2027 : : /* Print the list of functions at FNS, going through all the overloads
2028 : : for each element of the list. Alternatively, FNS cannot be a
2029 : : TREE_LIST, in which case it will be printed together with all the
2030 : : overloads.
2031 : :
2032 : : MORE and *STR should respectively be FALSE and NULL when the function
2033 : : is called from the outside. They are used internally on recursive
2034 : : calls. print_candidates manages the two parameters and leaves NULL
2035 : : in *STR when it ends. */
2036 : :
2037 : : static void
2038 : 1251 : print_candidates_1 (tree fns, char **str, bool more = false)
2039 : : {
2040 : 1251 : if (TREE_CODE (fns) == TREE_LIST)
2041 : 879 : for (; fns; fns = TREE_CHAIN (fns))
2042 : 903 : print_candidates_1 (TREE_VALUE (fns), str, more || TREE_CHAIN (fns));
2043 : : else
2044 : 2301 : for (lkp_iterator iter (fns); iter;)
2045 : : {
2046 : 1335 : tree cand = *iter;
2047 : 1335 : ++iter;
2048 : :
2049 : 1335 : const char *pfx = *str;
2050 : 1335 : if (!pfx)
2051 : : {
2052 : 657 : if (more || iter)
2053 : 423 : pfx = _("candidates are:");
2054 : : else
2055 : 234 : pfx = _("candidate is:");
2056 : 657 : *str = get_spaces (pfx);
2057 : : }
2058 : 1335 : inform (DECL_SOURCE_LOCATION (cand), "%s %#qD", pfx, cand);
2059 : : }
2060 : 1251 : }
2061 : :
2062 : : /* Print the list of candidate FNS in an error message. FNS can also
2063 : : be a TREE_LIST of non-functions in the case of an ambiguous lookup. */
2064 : :
2065 : : void
2066 : 657 : print_candidates (tree fns)
2067 : : {
2068 : 657 : char *str = NULL;
2069 : 657 : print_candidates_1 (fns, &str);
2070 : 657 : free (str);
2071 : 657 : }
2072 : :
2073 : : /* Get a (possibly) constrained template declaration for the
2074 : : purpose of ordering candidates. */
2075 : : static tree
2076 : 154 : get_template_for_ordering (tree list)
2077 : : {
2078 : 154 : gcc_assert (TREE_CODE (list) == TREE_LIST);
2079 : 154 : tree f = TREE_VALUE (list);
2080 : 154 : if (f == NULL_TREE)
2081 : : /* Also handle a list from resolve_address_of_overloaded_function with the
2082 : : function in TREE_PURPOSE. */
2083 : 106 : f = TREE_PURPOSE (list);
2084 : 154 : if (tree ti = DECL_TEMPLATE_INFO (f))
2085 : 66 : return TI_TEMPLATE (ti);
2086 : : return f;
2087 : : }
2088 : :
2089 : : /* Among candidates having the same signature, return the
2090 : : most constrained or NULL_TREE if there is no best candidate.
2091 : : If the signatures of candidates vary (e.g., template
2092 : : specialization vs. member function), then there can be no
2093 : : most constrained.
2094 : :
2095 : : Note that we don't compare constraints on the functions
2096 : : themselves, but rather those of their templates. */
2097 : : tree
2098 : 65 : most_constrained_function (tree candidates)
2099 : : {
2100 : : // Try to find the best candidate in a first pass.
2101 : 65 : tree champ = candidates;
2102 : 86 : for (tree c = TREE_CHAIN (champ); c; c = TREE_CHAIN (c))
2103 : : {
2104 : 65 : int winner = more_constrained (get_template_for_ordering (champ),
2105 : : get_template_for_ordering (c));
2106 : 65 : if (winner == -1)
2107 : : champ = c; // The candidate is more constrained
2108 : 53 : else if (winner == 0)
2109 : : return NULL_TREE; // Neither is more constrained
2110 : : }
2111 : :
2112 : : // Verify that the champ is better than previous candidates.
2113 : 33 : for (tree c = candidates; c != champ; c = TREE_CHAIN (c)) {
2114 : 12 : if (!more_constrained (get_template_for_ordering (champ),
2115 : : get_template_for_ordering (c)))
2116 : : return NULL_TREE;
2117 : : }
2118 : :
2119 : : return champ;
2120 : : }
2121 : :
2122 : :
2123 : : /* Returns the template (one of the functions given by TEMPLATE_ID)
2124 : : which can be specialized to match the indicated DECL with the
2125 : : explicit template args given in TEMPLATE_ID. The DECL may be
2126 : : NULL_TREE if none is available. In that case, the functions in
2127 : : TEMPLATE_ID are non-members.
2128 : :
2129 : : If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
2130 : : specialization of a member template.
2131 : :
2132 : : The TEMPLATE_COUNT is the number of references to qualifying
2133 : : template classes that appeared in the name of the function. See
2134 : : check_explicit_specialization for a more accurate description.
2135 : :
2136 : : TSK indicates what kind of template declaration (if any) is being
2137 : : declared. TSK_TEMPLATE indicates that the declaration given by
2138 : : DECL, though a FUNCTION_DECL, has template parameters, and is
2139 : : therefore a template function.
2140 : :
2141 : : The template args (those explicitly specified and those deduced)
2142 : : are output in a newly created vector *TARGS_OUT.
2143 : :
2144 : : If it is impossible to determine the result, an error message is
2145 : : issued. The error_mark_node is returned to indicate failure. */
2146 : :
2147 : : static tree
2148 : 3462793 : determine_specialization (tree template_id,
2149 : : tree decl,
2150 : : tree* targs_out,
2151 : : int need_member_template,
2152 : : int template_count,
2153 : : tmpl_spec_kind tsk)
2154 : : {
2155 : 3462793 : tree fns;
2156 : 3462793 : tree targs;
2157 : 3462793 : tree explicit_targs;
2158 : 3462793 : tree candidates = NULL_TREE;
2159 : :
2160 : : /* A TREE_LIST of templates of which DECL may be a specialization.
2161 : : The TREE_VALUE of each node is a TEMPLATE_DECL. The
2162 : : corresponding TREE_PURPOSE is the set of template arguments that,
2163 : : when used to instantiate the template, would produce a function
2164 : : with the signature of DECL. */
2165 : 3462793 : tree templates = NULL_TREE;
2166 : 3462793 : int header_count;
2167 : 3462793 : cp_binding_level *b;
2168 : :
2169 : 3462793 : *targs_out = NULL_TREE;
2170 : :
2171 : 3462793 : if (template_id == error_mark_node || decl == error_mark_node)
2172 : : return error_mark_node;
2173 : :
2174 : : /* We shouldn't be specializing a member template of an
2175 : : unspecialized class template; we already gave an error in
2176 : : check_specialization_scope, now avoid crashing. */
2177 : 3462790 : if (!VAR_P (decl)
2178 : 2528877 : && template_count && DECL_CLASS_SCOPE_P (decl)
2179 : 4327503 : && template_class_depth (DECL_CONTEXT (decl)) > 0)
2180 : : {
2181 : 3 : gcc_assert (errorcount);
2182 : 3 : return error_mark_node;
2183 : : }
2184 : :
2185 : 3462787 : fns = TREE_OPERAND (template_id, 0);
2186 : 3462787 : explicit_targs = TREE_OPERAND (template_id, 1);
2187 : :
2188 : 3462787 : if (fns == error_mark_node)
2189 : : return error_mark_node;
2190 : :
2191 : : /* Check for baselinks. */
2192 : 3462787 : if (BASELINK_P (fns))
2193 : 0 : fns = BASELINK_FUNCTIONS (fns);
2194 : :
2195 : 3462787 : if (TREE_CODE (decl) == FUNCTION_DECL && !is_overloaded_fn (fns))
2196 : : {
2197 : 10 : error_at (DECL_SOURCE_LOCATION (decl),
2198 : : "%qD is not a function template", fns);
2199 : 10 : return error_mark_node;
2200 : : }
2201 : 3462777 : else if (VAR_P (decl) && !variable_template_p (fns))
2202 : : {
2203 : 3 : error ("%qD is not a variable template", fns);
2204 : 3 : return error_mark_node;
2205 : : }
2206 : :
2207 : : /* Count the number of template headers specified for this
2208 : : specialization. */
2209 : 3462774 : header_count = 0;
2210 : 3462774 : for (b = current_binding_level;
2211 : 4953238 : b->kind == sk_template_parms;
2212 : 1490464 : b = b->level_chain)
2213 : 1490464 : ++header_count;
2214 : :
2215 : 3462774 : tree orig_fns = fns;
2216 : 3462774 : bool header_mismatch = false;
2217 : :
2218 : 3462774 : if (variable_template_p (fns))
2219 : : {
2220 : 933910 : tree parms = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (fns));
2221 : 933910 : targs = coerce_template_parms (parms, explicit_targs, fns,
2222 : : tf_warning_or_error);
2223 : 933910 : if (targs != error_mark_node
2224 : 933910 : && constraints_satisfied_p (fns, targs))
2225 : 933901 : templates = tree_cons (targs, fns, templates);
2226 : : }
2227 : 14662860 : else for (lkp_iterator iter (fns); iter; ++iter)
2228 : : {
2229 : 12133996 : tree fn = *iter;
2230 : :
2231 : 12133996 : if (TREE_CODE (fn) == TEMPLATE_DECL)
2232 : : {
2233 : 11547842 : tree decl_arg_types;
2234 : 11547842 : tree fn_arg_types;
2235 : :
2236 : : /* In case of explicit specialization, we need to check if
2237 : : the number of template headers appearing in the specialization
2238 : : is correct. This is usually done in check_explicit_specialization,
2239 : : but the check done there cannot be exhaustive when specializing
2240 : : member functions. Consider the following code:
2241 : :
2242 : : template <> void A<int>::f(int);
2243 : : template <> template <> void A<int>::f(int);
2244 : :
2245 : : Assuming that A<int> is not itself an explicit specialization
2246 : : already, the first line specializes "f" which is a non-template
2247 : : member function, whilst the second line specializes "f" which
2248 : : is a template member function. So both lines are syntactically
2249 : : correct, and check_explicit_specialization does not reject
2250 : : them.
2251 : :
2252 : : Here, we can do better, as we are matching the specialization
2253 : : against the declarations. We count the number of template
2254 : : headers, and we check if they match TEMPLATE_COUNT + 1
2255 : : (TEMPLATE_COUNT is the number of qualifying template classes,
2256 : : plus there must be another header for the member template
2257 : : itself).
2258 : :
2259 : : Notice that if header_count is zero, this is not a
2260 : : specialization but rather a template instantiation, so there
2261 : : is no check we can perform here. */
2262 : 11547842 : if (header_count && header_count != template_count + 1)
2263 : : {
2264 : 6 : header_mismatch = true;
2265 : 6 : continue;
2266 : : }
2267 : :
2268 : : /* Check that the number of template arguments at the
2269 : : innermost level for DECL is the same as for FN. */
2270 : 11547836 : if (current_binding_level->kind == sk_template_parms
2271 : 11547836 : && !current_binding_level->explicit_spec_p
2272 : 11547836 : && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn))
2273 : 991 : != TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
2274 : : (current_template_parms))))
2275 : 3 : continue;
2276 : :
2277 : : /* DECL might be a specialization of FN. */
2278 : 11547833 : decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
2279 : 11547833 : fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
2280 : :
2281 : : /* For a non-static member function, we need to make sure
2282 : : that the const qualification is the same. Since
2283 : : get_bindings does not try to merge the "this" parameter,
2284 : : we must do the comparison explicitly. */
2285 : 11547833 : if (DECL_IOBJ_MEMBER_FUNCTION_P (fn))
2286 : : {
2287 : 394813 : if (!same_type_p (TREE_VALUE (fn_arg_types),
2288 : : TREE_VALUE (decl_arg_types)))
2289 : 54 : continue;
2290 : :
2291 : : /* And the ref-qualification. */
2292 : 789518 : if (type_memfn_rqual (TREE_TYPE (decl))
2293 : 394759 : != type_memfn_rqual (TREE_TYPE (fn)))
2294 : 38 : continue;
2295 : : }
2296 : :
2297 : : /* Skip the "this" parameter and, for constructors of
2298 : : classes with virtual bases, the VTT parameter. A
2299 : : full specialization of a constructor will have a VTT
2300 : : parameter, but a template never will. */
2301 : 11547741 : decl_arg_types
2302 : 11547741 : = skip_artificial_parms_for (decl, decl_arg_types);
2303 : 11547741 : fn_arg_types
2304 : 11547741 : = skip_artificial_parms_for (fn, fn_arg_types);
2305 : :
2306 : : /* Function templates cannot be specializations; there are
2307 : : no partial specializations of functions. Therefore, if
2308 : : the type of DECL does not match FN, there is no
2309 : : match.
2310 : :
2311 : : Note that it should never be the case that we have both
2312 : : candidates added here, and for regular member functions
2313 : : below. */
2314 : 11547741 : if (tsk == tsk_template)
2315 : : {
2316 : 988 : if (!comp_template_parms (DECL_TEMPLATE_PARMS (fn),
2317 : 988 : current_template_parms))
2318 : 0 : continue;
2319 : 988 : if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
2320 : : TREE_TYPE (TREE_TYPE (fn))))
2321 : 0 : continue;
2322 : 988 : if (!compparms (fn_arg_types, decl_arg_types))
2323 : 3 : continue;
2324 : :
2325 : 985 : tree freq = get_constraints (fn);
2326 : 985 : tree dreq = get_constraints (decl);
2327 : 985 : if (!freq != !dreq)
2328 : 0 : continue;
2329 : 985 : if (freq)
2330 : : {
2331 : : /* C++20 CA104: Substitute directly into the
2332 : : constraint-expression. */
2333 : 38 : tree fargs = DECL_TI_ARGS (fn);
2334 : 38 : tsubst_flags_t complain = tf_none;
2335 : 38 : freq = tsubst_constraint_info (freq, fargs, complain, fn);
2336 : 38 : if (!cp_tree_equal (freq, dreq))
2337 : 28 : continue;
2338 : : }
2339 : :
2340 : 957 : candidates = tree_cons (NULL_TREE, fn, candidates);
2341 : 957 : continue;
2342 : 957 : }
2343 : :
2344 : : /* See whether this function might be a specialization of this
2345 : : template. Suppress access control because we might be trying
2346 : : to make this specialization a friend, and we have already done
2347 : : access control for the declaration of the specialization. */
2348 : 11546753 : push_deferring_access_checks (dk_no_check);
2349 : 11546753 : targs = get_bindings (fn, decl, explicit_targs, /*check_ret=*/true);
2350 : 11546753 : pop_deferring_access_checks ();
2351 : :
2352 : 11546753 : if (!targs)
2353 : : /* We cannot deduce template arguments that when used to
2354 : : specialize TMPL will produce DECL. */
2355 : 9446909 : continue;
2356 : :
2357 : 2099844 : if (uses_template_parms (targs))
2358 : : /* We deduced something involving 'auto', which isn't a valid
2359 : : template argument. */
2360 : 3 : continue;
2361 : :
2362 : : /* Save this template, and the arguments deduced. */
2363 : 2099841 : templates = tree_cons (targs, fn, templates);
2364 : : }
2365 : 586154 : else if (need_member_template)
2366 : : /* FN is an ordinary member function, and we need a
2367 : : specialization of a member template. */
2368 : : ;
2369 : 586108 : else if (TREE_CODE (fn) != FUNCTION_DECL)
2370 : : /* We can get IDENTIFIER_NODEs here in certain erroneous
2371 : : cases. */
2372 : : ;
2373 : 586108 : else if (!DECL_FUNCTION_MEMBER_P (fn))
2374 : : /* This is just an ordinary non-member function. Nothing can
2375 : : be a specialization of that. */
2376 : : ;
2377 : 575518 : else if (DECL_ARTIFICIAL (fn))
2378 : : /* Cannot specialize functions that are created implicitly. */
2379 : : ;
2380 : : else
2381 : : {
2382 : 575381 : tree decl_arg_types;
2383 : :
2384 : : /* This is an ordinary member function. However, since
2385 : : we're here, we can assume its enclosing class is a
2386 : : template class. For example,
2387 : :
2388 : : template <typename T> struct S { void f(); };
2389 : : template <> void S<int>::f() {}
2390 : :
2391 : : Here, S<int>::f is a non-template, but S<int> is a
2392 : : template class. If FN has the same type as DECL, we
2393 : : might be in business. */
2394 : :
2395 : 575381 : if (!DECL_TEMPLATE_INFO (fn))
2396 : : /* Its enclosing class is an explicit specialization
2397 : : of a template class. This is not a candidate. */
2398 : 6 : continue;
2399 : :
2400 : 575375 : if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
2401 : : TREE_TYPE (TREE_TYPE (fn))))
2402 : : /* The return types differ. */
2403 : 906 : continue;
2404 : :
2405 : : /* Adjust the type of DECL in case FN is a static member. */
2406 : 574469 : decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
2407 : 574469 : if (DECL_STATIC_FUNCTION_P (fn)
2408 : 574469 : && DECL_IOBJ_MEMBER_FUNCTION_P (decl))
2409 : 190 : decl_arg_types = TREE_CHAIN (decl_arg_types);
2410 : :
2411 : 574469 : if (!compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
2412 : : decl_arg_types))
2413 : 104880 : continue;
2414 : :
2415 : 469589 : if (DECL_IOBJ_MEMBER_FUNCTION_P (fn)
2416 : 938999 : && (type_memfn_rqual (TREE_TYPE (decl))
2417 : 469410 : != type_memfn_rqual (TREE_TYPE (fn))))
2418 : 6 : continue;
2419 : :
2420 : : // If the deduced arguments do not satisfy the constraints,
2421 : : // this is not a candidate.
2422 : 469583 : if (flag_concepts && !constraints_satisfied_p (fn))
2423 : 21 : continue;
2424 : :
2425 : : // Add the candidate.
2426 : 469562 : candidates = tree_cons (NULL_TREE, fn, candidates);
2427 : : }
2428 : : }
2429 : :
2430 : 3462765 : if (templates && TREE_CHAIN (templates))
2431 : : {
2432 : : /* We have:
2433 : :
2434 : : [temp.expl.spec]
2435 : :
2436 : : It is possible for a specialization with a given function
2437 : : signature to be instantiated from more than one function
2438 : : template. In such cases, explicit specification of the
2439 : : template arguments must be used to uniquely identify the
2440 : : function template specialization being specialized.
2441 : :
2442 : : Note that here, there's no suggestion that we're supposed to
2443 : : determine which of the candidate templates is most
2444 : : specialized. However, we, also have:
2445 : :
2446 : : [temp.func.order]
2447 : :
2448 : : Partial ordering of overloaded function template
2449 : : declarations is used in the following contexts to select
2450 : : the function template to which a function template
2451 : : specialization refers:
2452 : :
2453 : : -- when an explicit specialization refers to a function
2454 : : template.
2455 : :
2456 : : So, we do use the partial ordering rules, at least for now.
2457 : : This extension can only serve to make invalid programs valid,
2458 : : so it's safe. And, there is strong anecdotal evidence that
2459 : : the committee intended the partial ordering rules to apply;
2460 : : the EDG front end has that behavior, and John Spicer claims
2461 : : that the committee simply forgot to delete the wording in
2462 : : [temp.expl.spec]. */
2463 : 20873 : tree tmpl = most_specialized_instantiation (templates);
2464 : 20873 : if (tmpl != error_mark_node)
2465 : : {
2466 : 20870 : templates = tmpl;
2467 : 20870 : TREE_CHAIN (templates) = NULL_TREE;
2468 : : }
2469 : : }
2470 : :
2471 : : // Concepts allows multiple declarations of member functions
2472 : : // with the same signature. Like above, we need to rely on
2473 : : // on the partial ordering of those candidates to determine which
2474 : : // is the best.
2475 : 3462774 : if (flag_concepts && candidates && TREE_CHAIN (candidates))
2476 : : {
2477 : 12 : if (tree cand = most_constrained_function (candidates))
2478 : : {
2479 : 12 : candidates = cand;
2480 : 12 : TREE_CHAIN (cand) = NULL_TREE;
2481 : : }
2482 : : }
2483 : :
2484 : 3462774 : if (templates == NULL_TREE && candidates == NULL_TREE)
2485 : : {
2486 : 219 : auto_diagnostic_group d;
2487 : 219 : error ("template-id %qD for %q+D does not match any template "
2488 : : "declaration", template_id, decl);
2489 : 219 : if (header_mismatch)
2490 : 3 : inform (DECL_SOURCE_LOCATION (decl),
2491 : : "saw %d %<template<>%>, need %d for "
2492 : : "specializing a member function template",
2493 : : header_count, template_count + 1);
2494 : 219 : print_candidates (orig_fns);
2495 : 219 : return error_mark_node;
2496 : 219 : }
2497 : 2992048 : else if ((templates && TREE_CHAIN (templates))
2498 : 3462552 : || (candidates && TREE_CHAIN (candidates))
2499 : 6925107 : || (templates && candidates))
2500 : : {
2501 : 3 : auto_diagnostic_group d;
2502 : 3 : error ("ambiguous template specialization %qD for %q+D",
2503 : : template_id, decl);
2504 : 3 : candidates = chainon (candidates, templates);
2505 : 3 : print_candidates (candidates);
2506 : 3 : return error_mark_node;
2507 : 3 : }
2508 : :
2509 : : /* We have one, and exactly one, match. */
2510 : 3462552 : if (candidates)
2511 : : {
2512 : 470507 : tree fn = TREE_VALUE (candidates);
2513 : 470507 : *targs_out = copy_node (DECL_TI_ARGS (fn));
2514 : :
2515 : : /* Propagate the candidate's constraints to the declaration. */
2516 : 470507 : if (tsk != tsk_template)
2517 : 469550 : set_constraints (decl, get_constraints (fn));
2518 : :
2519 : : /* DECL is a re-declaration or partial instantiation of a template
2520 : : function. */
2521 : 470507 : if (TREE_CODE (fn) == TEMPLATE_DECL)
2522 : : return fn;
2523 : : /* It was a specialization of an ordinary member function in a
2524 : : template class. */
2525 : 469550 : return DECL_TI_TEMPLATE (fn);
2526 : : }
2527 : :
2528 : : /* It was a specialization of a template. */
2529 : 2992045 : tree tmpl = TREE_VALUE (templates);
2530 : 2992045 : *targs_out = add_outermost_template_args (tmpl, TREE_PURPOSE (templates));
2531 : :
2532 : : /* Propagate the template's constraints to the declaration. */
2533 : 2992045 : if (tsk != tsk_template)
2534 : 2372474 : set_constraints (decl, get_constraints (tmpl));
2535 : :
2536 : : return tmpl;
2537 : : }
2538 : :
2539 : : /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
2540 : : but with the default argument values filled in from those in the
2541 : : TMPL_TYPES. */
2542 : :
2543 : : static tree
2544 : 206569 : copy_default_args_to_explicit_spec_1 (tree spec_types,
2545 : : tree tmpl_types)
2546 : : {
2547 : 206569 : tree new_spec_types;
2548 : :
2549 : 206569 : if (!spec_types)
2550 : : return NULL_TREE;
2551 : :
2552 : 206569 : if (spec_types == void_list_node)
2553 : : return void_list_node;
2554 : :
2555 : : /* Substitute into the rest of the list. */
2556 : 123656 : new_spec_types =
2557 : 123656 : copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types),
2558 : 123656 : TREE_CHAIN (tmpl_types));
2559 : :
2560 : : /* Add the default argument for this parameter. */
2561 : 247312 : return hash_tree_cons (TREE_PURPOSE (tmpl_types),
2562 : 123656 : TREE_VALUE (spec_types),
2563 : 123656 : new_spec_types);
2564 : : }
2565 : :
2566 : : /* DECL is an explicit specialization. Replicate default arguments
2567 : : from the template it specializes. (That way, code like:
2568 : :
2569 : : template <class T> void f(T = 3);
2570 : : template <> void f(double);
2571 : : void g () { f (); }
2572 : :
2573 : : works, as required.) An alternative approach would be to look up
2574 : : the correct default arguments at the call-site, but this approach
2575 : : is consistent with how implicit instantiations are handled. */
2576 : :
2577 : : static void
2578 : 554560 : copy_default_args_to_explicit_spec (tree decl)
2579 : : {
2580 : 554560 : tree tmpl;
2581 : 554560 : tree spec_types;
2582 : 554560 : tree tmpl_types;
2583 : 554560 : tree new_spec_types;
2584 : 554560 : tree old_type;
2585 : 554560 : tree new_type;
2586 : 554560 : tree t;
2587 : 554560 : tree object_type = NULL_TREE;
2588 : 554560 : tree in_charge = NULL_TREE;
2589 : 554560 : tree vtt = NULL_TREE;
2590 : :
2591 : : /* See if there's anything we need to do. */
2592 : 554560 : tmpl = DECL_TI_TEMPLATE (decl);
2593 : 554560 : tmpl_types = TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl)));
2594 : 2245428 : for (t = tmpl_types; t; t = TREE_CHAIN (t))
2595 : 1773781 : if (TREE_PURPOSE (t))
2596 : : break;
2597 : 554560 : if (!t)
2598 : : return;
2599 : :
2600 : 82913 : old_type = TREE_TYPE (decl);
2601 : 82913 : spec_types = TYPE_ARG_TYPES (old_type);
2602 : :
2603 : 82913 : if (DECL_IOBJ_MEMBER_FUNCTION_P (decl))
2604 : : {
2605 : : /* Remove the this pointer, but remember the object's type for
2606 : : CV quals. */
2607 : 82913 : object_type = TREE_TYPE (TREE_VALUE (spec_types));
2608 : 82913 : spec_types = TREE_CHAIN (spec_types);
2609 : 82913 : tmpl_types = TREE_CHAIN (tmpl_types);
2610 : :
2611 : 82913 : if (DECL_HAS_IN_CHARGE_PARM_P (decl))
2612 : : {
2613 : : /* DECL may contain more parameters than TMPL due to the extra
2614 : : in-charge parameter in constructors and destructors. */
2615 : 0 : in_charge = spec_types;
2616 : 0 : spec_types = TREE_CHAIN (spec_types);
2617 : : }
2618 : 82913 : if (DECL_HAS_VTT_PARM_P (decl))
2619 : : {
2620 : 0 : vtt = spec_types;
2621 : 0 : spec_types = TREE_CHAIN (spec_types);
2622 : : }
2623 : : }
2624 : :
2625 : : /* Compute the merged default arguments. */
2626 : 82913 : new_spec_types =
2627 : 82913 : copy_default_args_to_explicit_spec_1 (spec_types, tmpl_types);
2628 : :
2629 : : /* Compute the new FUNCTION_TYPE. */
2630 : 82913 : if (object_type)
2631 : : {
2632 : 82913 : if (vtt)
2633 : 0 : new_spec_types = hash_tree_cons (TREE_PURPOSE (vtt),
2634 : 0 : TREE_VALUE (vtt),
2635 : : new_spec_types);
2636 : :
2637 : 82913 : if (in_charge)
2638 : : /* Put the in-charge parameter back. */
2639 : 0 : new_spec_types = hash_tree_cons (TREE_PURPOSE (in_charge),
2640 : 0 : TREE_VALUE (in_charge),
2641 : : new_spec_types);
2642 : :
2643 : 82913 : new_type = build_method_type_directly (object_type,
2644 : 82913 : TREE_TYPE (old_type),
2645 : : new_spec_types);
2646 : : }
2647 : : else
2648 : 0 : new_type = build_function_type (TREE_TYPE (old_type),
2649 : : new_spec_types);
2650 : 82913 : new_type = cp_build_type_attribute_variant (new_type,
2651 : 82913 : TYPE_ATTRIBUTES (old_type));
2652 : 82913 : new_type = cxx_copy_lang_qualifiers (new_type, old_type);
2653 : :
2654 : 82913 : TREE_TYPE (decl) = new_type;
2655 : : }
2656 : :
2657 : : /* Return the number of template headers we expect to see for a definition
2658 : : or specialization of CTYPE or one of its non-template members. */
2659 : :
2660 : : int
2661 : 29480120 : num_template_headers_for_class (tree ctype)
2662 : : {
2663 : 29480120 : int num_templates = 0;
2664 : :
2665 : 47006439 : while (ctype && CLASS_TYPE_P (ctype))
2666 : : {
2667 : : /* You're supposed to have one `template <...>' for every
2668 : : template class, but you don't need one for a full
2669 : : specialization. For example:
2670 : :
2671 : : template <class T> struct S{};
2672 : : template <> struct S<int> { void f(); };
2673 : : void S<int>::f () {}
2674 : :
2675 : : is correct; there shouldn't be a `template <>' for the
2676 : : definition of `S<int>::f'. */
2677 : 23820351 : if (!CLASSTYPE_TEMPLATE_INFO (ctype))
2678 : : /* If CTYPE does not have template information of any
2679 : : kind, then it is not a template, nor is it nested
2680 : : within a template. */
2681 : : break;
2682 : 17691064 : if (explicit_class_specialization_p (ctype))
2683 : : break;
2684 : 17526319 : if (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (ctype)))
2685 : 17204575 : ++num_templates;
2686 : :
2687 : 17526319 : ctype = TYPE_CONTEXT (ctype);
2688 : : }
2689 : :
2690 : 29480120 : return num_templates;
2691 : : }
2692 : :
2693 : : /* Do a simple sanity check on the template headers that precede the
2694 : : variable declaration DECL. */
2695 : :
2696 : : void
2697 : 3140349 : check_template_variable (tree decl)
2698 : : {
2699 : 3140349 : tree ctx = CP_DECL_CONTEXT (decl);
2700 : 3140349 : int wanted = num_template_headers_for_class (ctx);
2701 : 6280695 : if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)
2702 : 6280686 : && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl)))
2703 : : {
2704 : 2814891 : if (cxx_dialect < cxx14)
2705 : 3930 : pedwarn (DECL_SOURCE_LOCATION (decl), OPT_Wc__14_extensions,
2706 : : "variable templates only available with "
2707 : : "%<-std=c++14%> or %<-std=gnu++14%>");
2708 : :
2709 : : // Namespace-scope variable templates should have a template header.
2710 : 2814891 : ++wanted;
2711 : : }
2712 : 3140349 : if (template_header_count > wanted)
2713 : : {
2714 : 12 : auto_diagnostic_group d;
2715 : 12 : bool warned = pedwarn (DECL_SOURCE_LOCATION (decl), 0,
2716 : : "too many template headers for %qD "
2717 : : "(should be %d)",
2718 : : decl, wanted);
2719 : 12 : if (warned && CLASS_TYPE_P (ctx)
2720 : 21 : && CLASSTYPE_TEMPLATE_SPECIALIZATION (ctx))
2721 : 3 : inform (DECL_SOURCE_LOCATION (decl),
2722 : : "members of an explicitly specialized class are defined "
2723 : : "without a template header");
2724 : 12 : }
2725 : 3140349 : }
2726 : :
2727 : : /* An explicit specialization whose declarator-id or class-head-name is not
2728 : : qualified shall be declared in the nearest enclosing namespace of the
2729 : : template, or, if the namespace is inline (7.3.1), any namespace from its
2730 : : enclosing namespace set.
2731 : :
2732 : : If the name declared in the explicit instantiation is an unqualified name,
2733 : : the explicit instantiation shall appear in the namespace where its template
2734 : : is declared or, if that namespace is inline (7.3.1), any namespace from its
2735 : : enclosing namespace set. */
2736 : :
2737 : : void
2738 : 13272788 : check_unqualified_spec_or_inst (tree t, location_t loc)
2739 : : {
2740 : 13272788 : tree tmpl = most_general_template (t);
2741 : 26545576 : if (DECL_NAMESPACE_SCOPE_P (tmpl)
2742 : 26048188 : && !is_nested_namespace (current_namespace,
2743 : 12775400 : CP_DECL_CONTEXT (tmpl), true))
2744 : : {
2745 : 17 : if (processing_specialization)
2746 : 6 : permerror (loc, "explicit specialization of %qD outside its "
2747 : : "namespace must use a nested-name-specifier", tmpl);
2748 : 11 : else if (processing_explicit_instantiation
2749 : 11 : && cxx_dialect >= cxx11)
2750 : : /* This was allowed in C++98, so only pedwarn. */
2751 : 9 : pedwarn (loc, OPT_Wpedantic, "explicit instantiation of %qD "
2752 : : "outside its namespace must use a nested-name-"
2753 : : "specifier", tmpl);
2754 : : }
2755 : 13272788 : }
2756 : :
2757 : : /* Warn for a template specialization SPEC that is missing some of a set
2758 : : of function or type attributes that the template TEMPL is declared with.
2759 : : ATTRLIST is a list of additional attributes that SPEC should be taken
2760 : : to ultimately be declared with. */
2761 : :
2762 : : static void
2763 : 868826 : warn_spec_missing_attributes (tree tmpl, tree spec, tree attrlist)
2764 : : {
2765 : 868826 : if (DECL_FUNCTION_TEMPLATE_P (tmpl))
2766 : : tmpl = DECL_TEMPLATE_RESULT (tmpl);
2767 : :
2768 : : /* Avoid warning if the difference between the primary and
2769 : : the specialization is not in one of the attributes below. */
2770 : 868826 : const char* const blacklist[] = {
2771 : : "alloc_align", "alloc_size", "assume_aligned", "format",
2772 : : "format_arg", "malloc", "nonnull", NULL
2773 : : };
2774 : :
2775 : : /* Put together a list of the black listed attributes that the primary
2776 : : template is declared with that the specialization is not, in case
2777 : : it's not apparent from the most recent declaration of the primary. */
2778 : 868826 : auto_vec<const char *> mismatches;
2779 : 868826 : unsigned nattrs = decls_mismatched_attributes (tmpl, spec, attrlist,
2780 : : blacklist, mismatches);
2781 : :
2782 : 868826 : if (!nattrs)
2783 : 868799 : return;
2784 : :
2785 : 27 : auto_diagnostic_group d;
2786 : 27 : if (warning_at (DECL_SOURCE_LOCATION (spec), OPT_Wmissing_attributes,
2787 : : "explicit specialization %q#D may be missing attributes",
2788 : : spec))
2789 : : {
2790 : 27 : pp_markup::comma_separated_quoted_strings e (mismatches);
2791 : 51 : inform (DECL_SOURCE_LOCATION (tmpl),
2792 : : nattrs > 1
2793 : : ? G_("missing primary template attributes %e")
2794 : : : G_("missing primary template attribute %e"),
2795 : : &e);
2796 : 27 : }
2797 : 868826 : }
2798 : :
2799 : : /* Check to see if the function just declared, as indicated in
2800 : : DECLARATOR, and in DECL, is a specialization of a function
2801 : : template. We may also discover that the declaration is an explicit
2802 : : instantiation at this point.
2803 : :
2804 : : Returns DECL, or an equivalent declaration that should be used
2805 : : instead if all goes well. Issues an error message if something is
2806 : : amiss. Returns error_mark_node if the error is not easily
2807 : : recoverable.
2808 : :
2809 : : FLAGS is a bitmask consisting of the following flags:
2810 : :
2811 : : 2: The function has a definition.
2812 : : 4: The function is a friend.
2813 : :
2814 : : The TEMPLATE_COUNT is the number of references to qualifying
2815 : : template classes that appeared in the name of the function. For
2816 : : example, in
2817 : :
2818 : : template <class T> struct S { void f(); };
2819 : : void S<int>::f();
2820 : :
2821 : : the TEMPLATE_COUNT would be 1. However, explicitly specialized
2822 : : classes are not counted in the TEMPLATE_COUNT, so that in
2823 : :
2824 : : template <class T> struct S {};
2825 : : template <> struct S<int> { void f(); }
2826 : : template <> void S<int>::f();
2827 : :
2828 : : the TEMPLATE_COUNT would be 0. (Note that this declaration is
2829 : : invalid; there should be no template <>.)
2830 : :
2831 : : If the function is a specialization, it is marked as such via
2832 : : DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2833 : : is set up correctly, and it is added to the list of specializations
2834 : : for that template. */
2835 : :
2836 : : tree
2837 : 212117066 : check_explicit_specialization (tree declarator,
2838 : : tree decl,
2839 : : int template_count,
2840 : : int flags,
2841 : : tree attrlist)
2842 : : {
2843 : 212117066 : int have_def = flags & 2;
2844 : 212117066 : int is_friend = flags & 4;
2845 : 212117066 : bool is_concept = flags & 8;
2846 : 212117066 : int specialization = 0;
2847 : 212117066 : int explicit_instantiation = 0;
2848 : 212117066 : int member_specialization = 0;
2849 : 212117066 : tree ctype = DECL_CLASS_CONTEXT (decl);
2850 : 212117066 : tree dname = DECL_NAME (decl);
2851 : 212117066 : tmpl_spec_kind tsk;
2852 : :
2853 : 212117066 : if (is_friend)
2854 : : {
2855 : 70 : if (!processing_specialization)
2856 : : tsk = tsk_none;
2857 : : else
2858 : : tsk = tsk_excessive_parms;
2859 : : }
2860 : : else
2861 : 212116996 : tsk = current_tmpl_spec_kind (template_count);
2862 : :
2863 : 212116996 : switch (tsk)
2864 : : {
2865 : 164352798 : case tsk_none:
2866 : 164352798 : if (processing_specialization && !VAR_P (decl))
2867 : : {
2868 : 464778 : specialization = 1;
2869 : 464778 : SET_DECL_TEMPLATE_SPECIALIZATION (decl);
2870 : : }
2871 : 163888020 : else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
2872 : 163888020 : || (DECL_LANG_SPECIFIC (decl)
2873 : 114473304 : && DECL_IMPLICIT_INSTANTIATION (decl)))
2874 : : {
2875 : 82 : if (is_friend)
2876 : : /* This could be something like:
2877 : :
2878 : : template <class T> void f(T);
2879 : : class S { friend void f<>(int); } */
2880 : : specialization = 1;
2881 : : else
2882 : : {
2883 : : /* This case handles bogus declarations like template <>
2884 : : template <class T> void f<int>(); */
2885 : :
2886 : 12 : error_at (cp_expr_loc_or_input_loc (declarator),
2887 : : "template-id %qE in declaration of primary template",
2888 : : declarator);
2889 : 12 : return decl;
2890 : : }
2891 : : }
2892 : : break;
2893 : :
2894 : 0 : case tsk_invalid_member_spec:
2895 : : /* The error has already been reported in
2896 : : check_specialization_scope. */
2897 : 0 : return error_mark_node;
2898 : :
2899 : 0 : case tsk_invalid_expl_inst:
2900 : 0 : error ("template parameter list used in explicit instantiation");
2901 : :
2902 : : /* Fall through. */
2903 : :
2904 : 1949755 : case tsk_expl_inst:
2905 : 1949755 : if (have_def)
2906 : 0 : error ("definition provided for explicit instantiation");
2907 : :
2908 : : explicit_instantiation = 1;
2909 : : break;
2910 : :
2911 : 0 : case tsk_excessive_parms:
2912 : 0 : case tsk_insufficient_parms:
2913 : 0 : if (tsk == tsk_excessive_parms)
2914 : 0 : error ("too many template parameter lists in declaration of %qD",
2915 : : decl);
2916 : 0 : else if (template_header_count)
2917 : 0 : error("too few template parameter lists in declaration of %qD", decl);
2918 : : else
2919 : 0 : error("explicit specialization of %qD must be introduced by "
2920 : : "%<template <>%>", decl);
2921 : :
2922 : : /* Fall through. */
2923 : 404079 : case tsk_expl_spec:
2924 : 404079 : if (is_concept)
2925 : 0 : error ("explicit specialization declared %<concept%>");
2926 : :
2927 : 404079 : if (VAR_P (decl) && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
2928 : : /* In cases like template<> constexpr bool v = true;
2929 : : We'll give an error in check_template_variable. */
2930 : : break;
2931 : :
2932 : 404067 : SET_DECL_TEMPLATE_SPECIALIZATION (decl);
2933 : 404067 : if (ctype)
2934 : : member_specialization = 1;
2935 : : else
2936 : : specialization = 1;
2937 : : break;
2938 : :
2939 : 45410434 : case tsk_template:
2940 : 45410434 : if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
2941 : : {
2942 : : /* This case handles bogus declarations like template <>
2943 : : template <class T> void f<int>(); */
2944 : :
2945 : 619597 : if (!uses_template_parms (TREE_OPERAND (declarator, 1)))
2946 : 14 : error_at (cp_expr_loc_or_input_loc (declarator),
2947 : : "template-id %qE in declaration of primary template",
2948 : : declarator);
2949 : 619586 : else if (variable_template_p (TREE_OPERAND (declarator, 0)))
2950 : : {
2951 : : /* Partial specialization of variable template. */
2952 : 619571 : SET_DECL_TEMPLATE_SPECIALIZATION (decl);
2953 : 619571 : specialization = 1;
2954 : 619571 : goto ok;
2955 : : }
2956 : 15 : else if (cxx_dialect < cxx14)
2957 : 5 : error_at (cp_expr_loc_or_input_loc (declarator),
2958 : : "non-type partial specialization %qE "
2959 : : "is not allowed", declarator);
2960 : : else
2961 : 16 : error_at (cp_expr_loc_or_input_loc (declarator),
2962 : : "non-class, non-variable partial specialization %qE "
2963 : : "is not allowed", declarator);
2964 : 26 : return decl;
2965 : 619571 : ok:;
2966 : : }
2967 : :
2968 : 45410408 : if (ctype && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype))
2969 : : /* This is a specialization of a member template, without
2970 : : specialization the containing class. Something like:
2971 : :
2972 : : template <class T> struct S {
2973 : : template <class U> void f (U);
2974 : : };
2975 : : template <> template <class U> void S<int>::f(U) {}
2976 : :
2977 : : That's a specialization -- but of the entire template. */
2978 : : specialization = 1;
2979 : : break;
2980 : :
2981 : 0 : default:
2982 : 0 : gcc_unreachable ();
2983 : : }
2984 : :
2985 : 464778 : if ((specialization || member_specialization)
2986 : : /* This doesn't apply to variable templates. */
2987 : 46279323 : && FUNC_OR_METHOD_TYPE_P (TREE_TYPE (decl)))
2988 : : {
2989 : 555606 : tree t = TYPE_ARG_TYPES (TREE_TYPE (decl));
2990 : 2456259 : for (; t; t = TREE_CHAIN (t))
2991 : 1900656 : if (TREE_PURPOSE (t))
2992 : : {
2993 : 3 : permerror (input_location,
2994 : : "default argument specified in explicit specialization");
2995 : 3 : break;
2996 : : }
2997 : : }
2998 : :
2999 : 212117028 : if (specialization || member_specialization || explicit_instantiation)
3000 : : {
3001 : 3439213 : tree tmpl = NULL_TREE;
3002 : 3439213 : tree targs = NULL_TREE;
3003 : 3439213 : bool was_template_id = (TREE_CODE (declarator) == TEMPLATE_ID_EXPR);
3004 : 3439213 : bool found_hidden = false;
3005 : :
3006 : : /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
3007 : 3439213 : if (!was_template_id)
3008 : : {
3009 : 1667455 : tree fns;
3010 : :
3011 : 1667455 : gcc_assert (identifier_p (declarator));
3012 : 1667455 : if (ctype)
3013 : : fns = dname;
3014 : : else
3015 : : {
3016 : : /* If there is no class context, the explicit instantiation
3017 : : must be at namespace scope. */
3018 : 802718 : gcc_assert (DECL_NAMESPACE_SCOPE_P (decl));
3019 : :
3020 : : /* Find the namespace binding, using the declaration
3021 : : context. */
3022 : 802718 : fns = lookup_qualified_name (CP_DECL_CONTEXT (decl), dname,
3023 : : LOOK_want::NORMAL, true);
3024 : 802718 : if (fns == error_mark_node)
3025 : : {
3026 : : /* If lookup fails, look for a friend declaration so we can
3027 : : give a better diagnostic. */
3028 : 22 : fns = (lookup_qualified_name
3029 : 22 : (CP_DECL_CONTEXT (decl), dname,
3030 : : LOOK_want::NORMAL | LOOK_want::HIDDEN_FRIEND,
3031 : : /*complain*/true));
3032 : 22 : found_hidden = true;
3033 : : }
3034 : :
3035 : 802718 : if (fns == error_mark_node || !is_overloaded_fn (fns))
3036 : : {
3037 : 22 : error ("%qD is not a template function", dname);
3038 : 22 : fns = error_mark_node;
3039 : : }
3040 : : }
3041 : :
3042 : 1667455 : declarator = lookup_template_function (fns, NULL_TREE);
3043 : : }
3044 : :
3045 : 3439213 : if (declarator == error_mark_node)
3046 : 1950816 : return error_mark_node;
3047 : :
3048 : 3439191 : if (ctype != NULL_TREE && TYPE_BEING_DEFINED (ctype))
3049 : : {
3050 : 0 : if (!explicit_instantiation)
3051 : : /* A specialization in class scope. This is invalid,
3052 : : but the error will already have been flagged by
3053 : : check_specialization_scope. */
3054 : : return error_mark_node;
3055 : : else
3056 : : {
3057 : : /* It's not valid to write an explicit instantiation in
3058 : : class scope, e.g.:
3059 : :
3060 : : class C { template void f(); }
3061 : :
3062 : : This case is caught by the parser. However, on
3063 : : something like:
3064 : :
3065 : : template class C { void f(); };
3066 : :
3067 : : (which is invalid) we can get here. The error will be
3068 : : issued later. */
3069 : 0 : ;
3070 : : }
3071 : :
3072 : 0 : return decl;
3073 : : }
3074 : 3439191 : else if (ctype != NULL_TREE
3075 : 3439191 : && (identifier_p (TREE_OPERAND (declarator, 0))))
3076 : : {
3077 : : // We'll match variable templates in start_decl.
3078 : 864737 : if (VAR_P (decl))
3079 : : return decl;
3080 : :
3081 : : /* Find the list of functions in ctype that have the same
3082 : : name as the declared function. */
3083 : 864680 : tree name = TREE_OPERAND (declarator, 0);
3084 : :
3085 : 864680 : if (constructor_name_p (name, ctype))
3086 : : {
3087 : 0 : if (DECL_CONSTRUCTOR_P (decl)
3088 : 0 : ? !TYPE_HAS_USER_CONSTRUCTOR (ctype)
3089 : 0 : : !CLASSTYPE_DESTRUCTOR (ctype))
3090 : : {
3091 : : /* From [temp.expl.spec]:
3092 : :
3093 : : If such an explicit specialization for the member
3094 : : of a class template names an implicitly-declared
3095 : : special member function (clause _special_), the
3096 : : program is ill-formed.
3097 : :
3098 : : Similar language is found in [temp.explicit]. */
3099 : 0 : error ("specialization of implicitly-declared special member function");
3100 : 0 : return error_mark_node;
3101 : : }
3102 : :
3103 : 0 : name = DECL_NAME (decl);
3104 : : }
3105 : :
3106 : : /* For a type-conversion operator, We might be looking for
3107 : : `operator int' which will be a specialization of
3108 : : `operator T'. Grab all the conversion operators, and
3109 : : then select from them. */
3110 : 864680 : tree fns = get_class_binding (ctype, IDENTIFIER_CONV_OP_P (name)
3111 : : ? conv_op_identifier : name);
3112 : :
3113 : 864680 : if (fns == NULL_TREE)
3114 : : {
3115 : 0 : error ("no member function %qD declared in %qT", name, ctype);
3116 : 0 : return error_mark_node;
3117 : : }
3118 : : else
3119 : 864680 : TREE_OPERAND (declarator, 0) = fns;
3120 : : }
3121 : :
3122 : : /* Figure out what exactly is being specialized at this point.
3123 : : Note that for an explicit instantiation, even one for a
3124 : : member function, we cannot tell a priori whether the
3125 : : instantiation is for a member template, or just a member
3126 : : function of a template class. Even if a member template is
3127 : : being instantiated, the member template arguments may be
3128 : : elided if they can be deduced from the rest of the
3129 : : declaration. */
3130 : 3439134 : tmpl = determine_specialization (declarator, decl,
3131 : : &targs,
3132 : : member_specialization,
3133 : : template_count,
3134 : : tsk);
3135 : :
3136 : 3439134 : if (!tmpl || tmpl == error_mark_node)
3137 : : /* We couldn't figure out what this declaration was
3138 : : specializing. */
3139 : 232 : return error_mark_node;
3140 : : else
3141 : : {
3142 : 3438902 : if (found_hidden && TREE_CODE (decl) == FUNCTION_DECL)
3143 : : {
3144 : 9 : auto_diagnostic_group d;
3145 : 9 : if (pedwarn (DECL_SOURCE_LOCATION (decl), 0,
3146 : : "friend declaration %qD is not visible to "
3147 : : "explicit specialization", tmpl))
3148 : 9 : inform (DECL_SOURCE_LOCATION (tmpl),
3149 : : "friend declaration here");
3150 : 9 : }
3151 : :
3152 : 3438902 : if (!ctype && !is_friend
3153 : 3438902 : && CP_DECL_CONTEXT (decl) == current_namespace)
3154 : 2491605 : check_unqualified_spec_or_inst (tmpl, DECL_SOURCE_LOCATION (decl));
3155 : :
3156 : 3438902 : tree gen_tmpl = most_general_template (tmpl);
3157 : :
3158 : 3438902 : if (explicit_instantiation)
3159 : : {
3160 : : /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
3161 : : is done by do_decl_instantiation later. */
3162 : :
3163 : 1949548 : int arg_depth = TMPL_ARGS_DEPTH (targs);
3164 : 1949548 : int parm_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
3165 : :
3166 : 1949548 : if (arg_depth > parm_depth)
3167 : : {
3168 : : /* If TMPL is not the most general template (for
3169 : : example, if TMPL is a friend template that is
3170 : : injected into namespace scope), then there will
3171 : : be too many levels of TARGS. Remove some of them
3172 : : here. */
3173 : 394092 : int i;
3174 : 394092 : tree new_targs;
3175 : :
3176 : 394092 : new_targs = make_tree_vec (parm_depth);
3177 : 788184 : for (i = arg_depth - parm_depth; i < arg_depth; ++i)
3178 : 788184 : TREE_VEC_ELT (new_targs, i - (arg_depth - parm_depth))
3179 : 394092 : = TREE_VEC_ELT (targs, i);
3180 : 394092 : targs = new_targs;
3181 : : }
3182 : :
3183 : 1949548 : return instantiate_template (tmpl, targs, tf_error);
3184 : : }
3185 : :
3186 : : /* If we thought that the DECL was a member function, but it
3187 : : turns out to be specializing a static member function,
3188 : : make DECL a static member function as well. */
3189 : 1489354 : if (DECL_FUNCTION_TEMPLATE_P (tmpl)
3190 : 555517 : && DECL_STATIC_FUNCTION_P (tmpl)
3191 : 1490403 : && DECL_IOBJ_MEMBER_FUNCTION_P (decl))
3192 : 1040 : revert_static_member_fn (decl);
3193 : :
3194 : : /* If this is a specialization of a member template of a
3195 : : template class, we want to return the TEMPLATE_DECL, not
3196 : : the specialization of it. */
3197 : 1489354 : if (tsk == tsk_template && !was_template_id)
3198 : : {
3199 : 957 : tree result = DECL_TEMPLATE_RESULT (tmpl);
3200 : 957 : SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
3201 : 957 : DECL_INITIAL (result) = NULL_TREE;
3202 : 957 : if (have_def)
3203 : : {
3204 : 945 : tree parm;
3205 : 945 : DECL_SOURCE_LOCATION (tmpl) = DECL_SOURCE_LOCATION (decl);
3206 : 1890 : DECL_SOURCE_LOCATION (result)
3207 : 945 : = DECL_SOURCE_LOCATION (decl);
3208 : : /* We want to use the argument list specified in the
3209 : : definition, not in the original declaration. */
3210 : 945 : DECL_ARGUMENTS (result) = DECL_ARGUMENTS (decl);
3211 : 1963 : for (parm = DECL_ARGUMENTS (result); parm;
3212 : 1018 : parm = DECL_CHAIN (parm))
3213 : 1018 : DECL_CONTEXT (parm) = result;
3214 : : }
3215 : 957 : decl = register_specialization (tmpl, gen_tmpl, targs,
3216 : : is_friend, 0);
3217 : 957 : remove_contract_attributes (result);
3218 : 957 : return decl;
3219 : : }
3220 : :
3221 : : /* Set up the DECL_TEMPLATE_INFO for DECL. */
3222 : 1488397 : DECL_TEMPLATE_INFO (decl) = build_template_info (tmpl, targs);
3223 : :
3224 : 1488397 : if (was_template_id)
3225 : 934544 : TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (decl)) = true;
3226 : :
3227 : : /* Inherit default function arguments from the template
3228 : : DECL is specializing. */
3229 : 1488397 : if (DECL_FUNCTION_TEMPLATE_P (tmpl))
3230 : 554560 : copy_default_args_to_explicit_spec (decl);
3231 : :
3232 : : /* This specialization has the same protection as the
3233 : : template it specializes. */
3234 : 1488397 : TREE_PRIVATE (decl) = TREE_PRIVATE (gen_tmpl);
3235 : 1488397 : TREE_PROTECTED (decl) = TREE_PROTECTED (gen_tmpl);
3236 : :
3237 : : /* 7.1.1-1 [dcl.stc]
3238 : :
3239 : : A storage-class-specifier shall not be specified in an
3240 : : explicit specialization...
3241 : :
3242 : : The parser rejects these, so unless action is taken here,
3243 : : explicit function specializations will always appear with
3244 : : global linkage.
3245 : :
3246 : : The action recommended by the C++ CWG in response to C++
3247 : : defect report 605 is to make the storage class and linkage
3248 : : of the explicit specialization match the templated function:
3249 : :
3250 : : http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
3251 : : */
3252 : 1488397 : if (tsk == tsk_expl_spec && DECL_FUNCTION_TEMPLATE_P (gen_tmpl))
3253 : : {
3254 : 89731 : tree tmpl_func = DECL_TEMPLATE_RESULT (gen_tmpl);
3255 : 89731 : gcc_assert (TREE_CODE (tmpl_func) == FUNCTION_DECL);
3256 : :
3257 : : /* This specialization has the same linkage and visibility as
3258 : : the function template it specializes. */
3259 : 89731 : TREE_PUBLIC (decl) = TREE_PUBLIC (tmpl_func);
3260 : 89731 : if (! TREE_PUBLIC (decl))
3261 : : {
3262 : 37 : DECL_INTERFACE_KNOWN (decl) = 1;
3263 : 37 : DECL_NOT_REALLY_EXTERN (decl) = 1;
3264 : : }
3265 : 89731 : DECL_THIS_STATIC (decl) = DECL_THIS_STATIC (tmpl_func);
3266 : 89731 : if (DECL_VISIBILITY_SPECIFIED (tmpl_func))
3267 : : {
3268 : 39 : DECL_VISIBILITY_SPECIFIED (decl) = 1;
3269 : 39 : DECL_VISIBILITY (decl) = DECL_VISIBILITY (tmpl_func);
3270 : : }
3271 : : }
3272 : :
3273 : : /* If DECL is a friend declaration, declared using an
3274 : : unqualified name, the namespace associated with DECL may
3275 : : have been set incorrectly. For example, in:
3276 : :
3277 : : template <typename T> void f(T);
3278 : : namespace N {
3279 : : struct S { friend void f<int>(int); }
3280 : : }
3281 : :
3282 : : we will have set the DECL_CONTEXT for the friend
3283 : : declaration to N, rather than to the global namespace. */
3284 : 1488397 : if (DECL_NAMESPACE_SCOPE_P (decl))
3285 : 1023373 : DECL_CONTEXT (decl) = DECL_CONTEXT (tmpl);
3286 : :
3287 : 1488397 : if (is_friend && !have_def)
3288 : : /* This is not really a declaration of a specialization.
3289 : : It's just the name of an instantiation. But, it's not
3290 : : a request for an instantiation, either. */
3291 : 60 : SET_DECL_IMPLICIT_INSTANTIATION (decl);
3292 : 1488337 : else if (TREE_CODE (decl) == FUNCTION_DECL)
3293 : : /* A specialization is not necessarily COMDAT. */
3294 : 554500 : DECL_COMDAT (decl) = (TREE_PUBLIC (decl)
3295 : 554500 : && DECL_DECLARED_INLINE_P (decl));
3296 : 933837 : else if (VAR_P (decl))
3297 : 933837 : DECL_COMDAT (decl) = false;
3298 : :
3299 : : /* If this is a full specialization, register it so that we can find
3300 : : it again. Partial specializations will be registered in
3301 : : process_partial_specialization. */
3302 : 1488397 : if (!processing_template_decl)
3303 : : {
3304 : 868826 : warn_spec_missing_attributes (gen_tmpl, decl, attrlist);
3305 : :
3306 : 868826 : decl = register_specialization (decl, gen_tmpl, targs,
3307 : : is_friend, 0);
3308 : : }
3309 : :
3310 : : /* If this is a specialization, splice any contracts that may have
3311 : : been inherited from the template, removing them. */
3312 : 1488397 : if (decl != error_mark_node && DECL_TEMPLATE_SPECIALIZATION (decl))
3313 : 1488311 : remove_contract_attributes (decl);
3314 : :
3315 : : /* A 'structor should already have clones. */
3316 : 2042934 : gcc_assert (decl == error_mark_node
3317 : : || variable_template_p (tmpl)
3318 : : || !(DECL_CONSTRUCTOR_P (decl)
3319 : : || DECL_DESTRUCTOR_P (decl))
3320 : : || DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl)));
3321 : : }
3322 : : }
3323 : :
3324 : : return decl;
3325 : : }
3326 : :
3327 : : /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
3328 : : parameters. These are represented in the same format used for
3329 : : DECL_TEMPLATE_PARMS. */
3330 : :
3331 : : int
3332 : 147298446 : comp_template_parms (const_tree parms1, const_tree parms2)
3333 : : {
3334 : 147298446 : if (parms1 == parms2)
3335 : : return 1;
3336 : :
3337 : 146773669 : tree t1 = TREE_VALUE (parms1);
3338 : 146773669 : tree t2 = TREE_VALUE (parms2);
3339 : 146773669 : int i;
3340 : :
3341 : 146773669 : gcc_assert (TREE_CODE (t1) == TREE_VEC);
3342 : 146773669 : gcc_assert (TREE_CODE (t2) == TREE_VEC);
3343 : :
3344 : 146773669 : if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2))
3345 : : return 0;
3346 : :
3347 : 153386992 : for (i = 0; i < TREE_VEC_LENGTH (t2); ++i)
3348 : : {
3349 : 121382751 : tree parm1 = TREE_VALUE (TREE_VEC_ELT (t1, i));
3350 : 121382751 : tree parm2 = TREE_VALUE (TREE_VEC_ELT (t2, i));
3351 : :
3352 : : /* If either of the template parameters are invalid, assume
3353 : : they match for the sake of error recovery. */
3354 : 121382751 : if (error_operand_p (parm1) || error_operand_p (parm2))
3355 : : return 1;
3356 : :
3357 : 121382727 : if (TREE_CODE (parm1) != TREE_CODE (parm2))
3358 : : return 0;
3359 : :
3360 : 210064423 : if (TREE_CODE (parm1) == TYPE_DECL
3361 : 118273812 : && (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm1))
3362 : 99895372 : == TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm2))))
3363 : 91790611 : continue;
3364 : 26483201 : else if (!same_type_p (TREE_TYPE (parm1), TREE_TYPE (parm2)))
3365 : : return 0;
3366 : : }
3367 : :
3368 : : return 1;
3369 : : }
3370 : :
3371 : : /* Returns true if two template parameters are declared with
3372 : : equivalent constraints. */
3373 : :
3374 : : static bool
3375 : 177196251 : template_parameter_constraints_equivalent_p (const_tree parm1, const_tree parm2)
3376 : : {
3377 : 177196251 : tree req1 = TREE_TYPE (parm1);
3378 : 177196251 : tree req2 = TREE_TYPE (parm2);
3379 : 177196251 : if (!req1 != !req2)
3380 : : return false;
3381 : 176625596 : if (req1)
3382 : 343100 : return cp_tree_equal (req1, req2);
3383 : : return true;
3384 : : }
3385 : :
3386 : : /* Returns true when two template parameters are equivalent. */
3387 : :
3388 : : static bool
3389 : 195381583 : template_parameters_equivalent_p (const_tree parm1, const_tree parm2)
3390 : : {
3391 : 195381583 : tree decl1 = TREE_VALUE (parm1);
3392 : 195381583 : tree decl2 = TREE_VALUE (parm2);
3393 : :
3394 : : /* If either of the template parameters are invalid, assume
3395 : : they match for the sake of error recovery. */
3396 : 195381583 : if (error_operand_p (decl1) || error_operand_p (decl2))
3397 : : return true;
3398 : :
3399 : : /* ... they declare parameters of the same kind. */
3400 : 195381580 : if (TREE_CODE (decl1) != TREE_CODE (decl2))
3401 : : return false;
3402 : :
3403 : : /* ... one parameter was introduced by a parameter declaration, then
3404 : : both are. This case arises as a result of eagerly rewriting declarations
3405 : : during parsing. */
3406 : 185947222 : if (DECL_IMPLICIT_TEMPLATE_PARM_P (decl1)
3407 : 185947222 : != DECL_IMPLICIT_TEMPLATE_PARM_P (decl2))
3408 : : return false;
3409 : :
3410 : : /* ... if either declares a pack, they both do. */
3411 : 185946971 : if (template_parameter_pack_p (decl1) != template_parameter_pack_p (decl2))
3412 : : return false;
3413 : :
3414 : 173662870 : if (TREE_CODE (decl1) == PARM_DECL)
3415 : : {
3416 : : /* ... if they declare non-type parameters, the types are equivalent. */
3417 : 2759475 : if (!same_type_p (TREE_TYPE (decl1), TREE_TYPE (decl2)))
3418 : : return false;
3419 : : }
3420 : 170903395 : else if (TREE_CODE (decl2) == TEMPLATE_DECL)
3421 : : {
3422 : : /* ... if they declare template template parameters, their template
3423 : : parameter lists are equivalent. */
3424 : 19667 : if (!template_heads_equivalent_p (decl1, decl2))
3425 : : return false;
3426 : : }
3427 : :
3428 : : /* ... if they are declared with a qualified-concept name, they both
3429 : : are, and those names are equivalent. */
3430 : 173470131 : return template_parameter_constraints_equivalent_p (parm1, parm2);
3431 : : }
3432 : :
3433 : : /* Returns true if two template parameters lists are equivalent.
3434 : : Two template parameter lists are equivalent if they have the
3435 : : same length and their corresponding parameters are equivalent.
3436 : :
3437 : : PARMS1 and PARMS2 are TREE_LISTs containing TREE_VECs: the
3438 : : data structure returned by DECL_TEMPLATE_PARMS.
3439 : :
3440 : : This is generally the same implementation as comp_template_parms
3441 : : except that it also the concept names and arguments used to
3442 : : introduce parameters. */
3443 : :
3444 : : static bool
3445 : 302883396 : template_parameter_lists_equivalent_p (const_tree parms1, const_tree parms2)
3446 : : {
3447 : 302883396 : if (parms1 == parms2)
3448 : : return true;
3449 : :
3450 : 302883396 : tree list1 = TREE_VALUE (parms1);
3451 : 302883396 : tree list2 = TREE_VALUE (parms2);
3452 : :
3453 : 302883396 : if (TREE_VEC_LENGTH (list1) != TREE_VEC_LENGTH (list2))
3454 : : return 0;
3455 : :
3456 : 290519028 : for (int i = 0; i < TREE_VEC_LENGTH (list2); ++i)
3457 : : {
3458 : 195381583 : tree parm1 = TREE_VEC_ELT (list1, i);
3459 : 195381583 : tree parm2 = TREE_VEC_ELT (list2, i);
3460 : 195381583 : if (!template_parameters_equivalent_p (parm1, parm2))
3461 : : return false;
3462 : : }
3463 : :
3464 : : return true;
3465 : : }
3466 : :
3467 : : /* Return true if the requires-clause of the template parameter lists are
3468 : : equivalent and false otherwise. */
3469 : : static bool
3470 : 110612752 : template_requirements_equivalent_p (const_tree parms1, const_tree parms2)
3471 : : {
3472 : 110612752 : tree req1 = TEMPLATE_PARMS_CONSTRAINTS (parms1);
3473 : 110612752 : tree req2 = TEMPLATE_PARMS_CONSTRAINTS (parms2);
3474 : 110612752 : if ((req1 != NULL_TREE) != (req2 != NULL_TREE))
3475 : : return false;
3476 : 101495357 : if (!cp_tree_equal (req1, req2))
3477 : : return false;
3478 : : return true;
3479 : : }
3480 : :
3481 : : /* Returns true if two template heads are equivalent. 17.6.6.1p6:
3482 : : Two template heads are equivalent if their template parameter
3483 : : lists are equivalent and their requires clauses are equivalent.
3484 : :
3485 : : In pre-C++20, this is equivalent to calling comp_template_parms
3486 : : for the template parameters of TMPL1 and TMPL2. */
3487 : :
3488 : : bool
3489 : 302883396 : template_heads_equivalent_p (const_tree tmpl1, const_tree tmpl2)
3490 : : {
3491 : 302883396 : tree parms1 = DECL_TEMPLATE_PARMS (tmpl1);
3492 : 302883396 : tree parms2 = DECL_TEMPLATE_PARMS (tmpl2);
3493 : :
3494 : : /* ... have the same number of template parameters, and their
3495 : : corresponding parameters are equivalent. */
3496 : 302883396 : if (!template_parameter_lists_equivalent_p (parms1, parms2))
3497 : : return false;
3498 : :
3499 : : /* ... if either has a requires-clause, they both do and their
3500 : : corresponding constraint-expressions are equivalent. */
3501 : 95137445 : return template_requirements_equivalent_p (parms1, parms2);
3502 : : }
3503 : :
3504 : : /* Determine whether PARM is a parameter pack. */
3505 : :
3506 : : bool
3507 : 3328370454 : template_parameter_pack_p (const_tree parm)
3508 : : {
3509 : : /* Determine if we have a non-type template parameter pack. */
3510 : 3328370454 : if (TREE_CODE (parm) == PARM_DECL)
3511 : 402249357 : return (DECL_TEMPLATE_PARM_P (parm)
3512 : 402249357 : && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)));
3513 : 2926121097 : if (TREE_CODE (parm) == TEMPLATE_PARM_INDEX)
3514 : 1292224 : return TEMPLATE_PARM_PARAMETER_PACK (parm);
3515 : :
3516 : : /* If this is a list of template parameters, we could get a
3517 : : TYPE_DECL or a TEMPLATE_DECL. */
3518 : 2924828873 : if (TREE_CODE (parm) == TYPE_DECL || TREE_CODE (parm) == TEMPLATE_DECL)
3519 : 2774613711 : parm = TREE_TYPE (parm);
3520 : :
3521 : : /* Otherwise it must be a type template parameter. */
3522 : 2924828873 : return ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
3523 : 2924828873 : || TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM)
3524 : 2924828873 : && TEMPLATE_TYPE_PARAMETER_PACK (parm));
3525 : : }
3526 : :
3527 : : /* Determine if T is a function parameter pack. */
3528 : :
3529 : : bool
3530 : 1438959 : function_parameter_pack_p (const_tree t)
3531 : : {
3532 : 1438959 : if (t && TREE_CODE (t) == PARM_DECL)
3533 : 1438959 : return DECL_PACK_P (t);
3534 : : return false;
3535 : : }
3536 : :
3537 : : /* Return the function template declaration of PRIMARY_FUNC_TMPL_INST.
3538 : : PRIMARY_FUNC_TMPL_INST is a primary function template instantiation. */
3539 : :
3540 : : tree
3541 : 1596509 : get_function_template_decl (const_tree primary_func_tmpl_inst)
3542 : : {
3543 : 1596509 : if (! primary_func_tmpl_inst
3544 : 1596509 : || TREE_CODE (primary_func_tmpl_inst) != FUNCTION_DECL
3545 : 3193018 : || ! primary_template_specialization_p (primary_func_tmpl_inst))
3546 : 1187046 : return NULL;
3547 : :
3548 : 409463 : return DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (primary_func_tmpl_inst));
3549 : : }
3550 : :
3551 : : /* Return true iff the function parameter PARAM_DECL was expanded
3552 : : from the function parameter pack PACK. */
3553 : :
3554 : : bool
3555 : 406731 : function_parameter_expanded_from_pack_p (tree param_decl, tree pack)
3556 : : {
3557 : 406731 : if (DECL_ARTIFICIAL (param_decl)
3558 : 406731 : || !function_parameter_pack_p (pack))
3559 : 0 : return false;
3560 : :
3561 : : /* The parameter pack and its pack arguments have the same
3562 : : DECL_PARM_INDEX. */
3563 : 406731 : return DECL_PARM_INDEX (pack) == DECL_PARM_INDEX (param_decl);
3564 : : }
3565 : :
3566 : : /* Determine whether ARGS describes a variadic template args list,
3567 : : i.e., one that is terminated by a template argument pack. */
3568 : :
3569 : : static bool
3570 : 8 : template_args_variadic_p (tree args)
3571 : : {
3572 : 8 : int nargs;
3573 : 8 : tree last_parm;
3574 : :
3575 : 8 : if (args == NULL_TREE)
3576 : : return false;
3577 : :
3578 : 8 : args = INNERMOST_TEMPLATE_ARGS (args);
3579 : 8 : nargs = TREE_VEC_LENGTH (args);
3580 : :
3581 : 8 : if (nargs == 0)
3582 : : return false;
3583 : :
3584 : 8 : last_parm = TREE_VEC_ELT (args, nargs - 1);
3585 : :
3586 : 8 : return ARGUMENT_PACK_P (last_parm);
3587 : : }
3588 : :
3589 : : /* Generate a new name for the parameter pack name NAME (an
3590 : : IDENTIFIER_NODE) that incorporates its */
3591 : :
3592 : : static tree
3593 : 832299 : make_ith_pack_parameter_name (tree name, int i)
3594 : : {
3595 : : /* Munge the name to include the parameter index. */
3596 : : #define NUMBUF_LEN 128
3597 : 832299 : char numbuf[NUMBUF_LEN];
3598 : 832299 : char* newname;
3599 : 832299 : int newname_len;
3600 : :
3601 : 832299 : if (name == NULL_TREE)
3602 : : return name;
3603 : 829010 : snprintf (numbuf, NUMBUF_LEN, "%i", i);
3604 : 829010 : newname_len = IDENTIFIER_LENGTH (name)
3605 : 829010 : + strlen (numbuf) + 2;
3606 : 829010 : newname = (char*)alloca (newname_len);
3607 : 829010 : snprintf (newname, newname_len,
3608 : 829010 : "%s#%i", IDENTIFIER_POINTER (name), i);
3609 : 829010 : return get_identifier (newname);
3610 : : }
3611 : :
3612 : : /* Return true if T is a primary function, class or alias template
3613 : : specialization, not including the template pattern. */
3614 : :
3615 : : bool
3616 : 122032276 : primary_template_specialization_p (const_tree t)
3617 : : {
3618 : 122032276 : if (!t)
3619 : : return false;
3620 : :
3621 : 122032276 : if (VAR_OR_FUNCTION_DECL_P (t))
3622 : 65913623 : return (DECL_LANG_SPECIFIC (t)
3623 : 65913535 : && DECL_USE_TEMPLATE (t)
3624 : 62205288 : && DECL_TEMPLATE_INFO (t)
3625 : 128118911 : && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t)));
3626 : 56118653 : else if (CLASS_TYPE_P (t) && !TYPE_DECL_ALIAS_P (TYPE_NAME (t)))
3627 : 56118653 : return (CLASSTYPE_TEMPLATE_INFO (t)
3628 : 56118653 : && CLASSTYPE_USE_TEMPLATE (t)
3629 : 112237306 : && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)));
3630 : 0 : else if (alias_template_specialization_p (t, nt_transparent))
3631 : : return true;
3632 : : return false;
3633 : : }
3634 : :
3635 : : /* Return true if PARM is a template template parameter. */
3636 : :
3637 : : bool
3638 : 37693442 : template_template_parameter_p (const_tree parm)
3639 : : {
3640 : 37693442 : return DECL_TEMPLATE_TEMPLATE_PARM_P (parm);
3641 : : }
3642 : :
3643 : : /* Return true iff PARM is a DECL representing a type template
3644 : : parameter. */
3645 : :
3646 : : bool
3647 : 1302552374 : template_type_parameter_p (const_tree parm)
3648 : : {
3649 : 1302552374 : return (parm
3650 : 1302552374 : && (TREE_CODE (parm) == TYPE_DECL
3651 : 632254567 : || TREE_CODE (parm) == TEMPLATE_DECL)
3652 : 1973003815 : && DECL_TEMPLATE_PARM_P (parm));
3653 : : }
3654 : :
3655 : : /* Return the template parameters of T if T is a
3656 : : primary template instantiation, NULL otherwise. */
3657 : :
3658 : : tree
3659 : 136072242 : get_primary_template_innermost_parameters (const_tree t)
3660 : : {
3661 : 136072242 : tree parms = NULL, template_info = NULL;
3662 : :
3663 : 136072242 : if ((template_info = get_template_info (t))
3664 : 136072242 : && primary_template_specialization_p (t))
3665 : 56158063 : parms = INNERMOST_TEMPLATE_PARMS
3666 : : (DECL_TEMPLATE_PARMS (TI_TEMPLATE (template_info)));
3667 : :
3668 : 136072242 : return parms;
3669 : : }
3670 : :
3671 : : /* Returns the template arguments of T if T is a template instantiation,
3672 : : NULL otherwise. */
3673 : :
3674 : : tree
3675 : 26848486 : get_template_innermost_arguments (const_tree t)
3676 : : {
3677 : 26848486 : tree args = NULL, template_info = NULL;
3678 : :
3679 : 26848486 : if ((template_info = get_template_info (t))
3680 : 53696972 : && TI_ARGS (template_info))
3681 : 26848486 : args = INNERMOST_TEMPLATE_ARGS (TI_ARGS (template_info));
3682 : :
3683 : 26848486 : return args;
3684 : : }
3685 : :
3686 : : /* Return the argument pack elements of T if T is a template argument pack,
3687 : : NULL otherwise. */
3688 : :
3689 : : tree
3690 : 39992001 : get_template_argument_pack_elems (const_tree t)
3691 : : {
3692 : 39992001 : if (TREE_CODE (t) != TYPE_ARGUMENT_PACK
3693 : 39992001 : && TREE_CODE (t) != NONTYPE_ARGUMENT_PACK)
3694 : : return NULL;
3695 : :
3696 : 4126889 : return ARGUMENT_PACK_ARGS (t);
3697 : : }
3698 : :
3699 : : /* In an ARGUMENT_PACK_SELECT, the actual underlying argument that the
3700 : : ARGUMENT_PACK_SELECT represents. */
3701 : :
3702 : : static tree
3703 : 10146032 : argument_pack_select_arg (tree t)
3704 : : {
3705 : 10146032 : tree args = ARGUMENT_PACK_ARGS (ARGUMENT_PACK_SELECT_FROM_PACK (t));
3706 : 10146032 : tree arg = TREE_VEC_ELT (args, ARGUMENT_PACK_SELECT_INDEX (t));
3707 : :
3708 : : /* If the selected argument is an expansion E, that most likely means we were
3709 : : called from gen_elem_of_pack_expansion_instantiation during the
3710 : : substituting of an argument pack (of which the Ith element is a pack
3711 : : expansion, where I is ARGUMENT_PACK_SELECT_INDEX) into a pack expansion.
3712 : : In this case, the Ith element resulting from this substituting is going to
3713 : : be a pack expansion, which pattern is the pattern of E. Let's return the
3714 : : pattern of E, and gen_elem_of_pack_expansion_instantiation will build the
3715 : : resulting pack expansion from it. */
3716 : 10146032 : if (PACK_EXPANSION_P (arg))
3717 : : {
3718 : : /* Make sure we aren't throwing away arg info. */
3719 : 426842 : gcc_assert (!PACK_EXPANSION_EXTRA_ARGS (arg));
3720 : 426842 : arg = PACK_EXPANSION_PATTERN (arg);
3721 : : }
3722 : :
3723 : 10146032 : return arg;
3724 : : }
3725 : :
3726 : : /* Return a modification of ARGS that's suitable for preserving inside a hash
3727 : : table. In particular, this replaces each ARGUMENT_PACK_SELECT with its
3728 : : underlying argument. ARGS is copied (upon modification) iff COW_P. */
3729 : :
3730 : : static tree
3731 : 318709 : preserve_args (tree args, bool cow_p = true)
3732 : : {
3733 : 318709 : if (!args)
3734 : : return NULL_TREE;
3735 : :
3736 : 853504 : for (int i = 0, len = TREE_VEC_LENGTH (args); i < len; ++i)
3737 : : {
3738 : 534801 : tree t = TREE_VEC_ELT (args, i);
3739 : 534801 : tree r;
3740 : 534801 : if (!t)
3741 : : r = NULL_TREE;
3742 : 534695 : else if (TREE_CODE (t) == ARGUMENT_PACK_SELECT)
3743 : 69 : r = argument_pack_select_arg (t);
3744 : 534626 : else if (TREE_CODE (t) == TREE_VEC)
3745 : 93500 : r = preserve_args (t, cow_p);
3746 : : else
3747 : : r = t;
3748 : 534695 : if (r != t)
3749 : : {
3750 : 69 : if (cow_p)
3751 : : {
3752 : 63 : args = copy_template_args (args);
3753 : 63 : cow_p = false;
3754 : : }
3755 : 69 : TREE_VEC_ELT (args, i) = r;
3756 : : }
3757 : : }
3758 : :
3759 : : return args;
3760 : : }
3761 : :
3762 : : /* True iff FN is a function representing a built-in variadic parameter
3763 : : pack. */
3764 : :
3765 : : bool
3766 : 287146986 : builtin_pack_fn_p (tree fn)
3767 : : {
3768 : 287146986 : if (!fn
3769 : 287119400 : || TREE_CODE (fn) != FUNCTION_DECL
3770 : 376592464 : || !DECL_IS_UNDECLARED_BUILTIN (fn))
3771 : : return false;
3772 : :
3773 : 7519298 : if (id_equal (DECL_NAME (fn), "__integer_pack"))
3774 : : return true;
3775 : :
3776 : : return false;
3777 : : }
3778 : :
3779 : : /* True iff CALL is a call to a function representing a built-in variadic
3780 : : parameter pack. */
3781 : :
3782 : : static bool
3783 : 270300869 : builtin_pack_call_p (tree call)
3784 : : {
3785 : 270300869 : if (TREE_CODE (call) != CALL_EXPR)
3786 : : return false;
3787 : 204719593 : return builtin_pack_fn_p (CALL_EXPR_FN (call));
3788 : : }
3789 : :
3790 : : /* Return a TREE_VEC for the expansion of __integer_pack(HI). */
3791 : :
3792 : : static tree
3793 : 105350 : expand_integer_pack (tree call, tree args, tsubst_flags_t complain,
3794 : : tree in_decl)
3795 : : {
3796 : 105350 : tree ohi = CALL_EXPR_ARG (call, 0);
3797 : 105350 : tree hi = tsubst_expr (ohi, args, complain, in_decl);
3798 : :
3799 : 105350 : if (instantiation_dependent_expression_p (hi))
3800 : : {
3801 : 104064 : if (hi != ohi)
3802 : : {
3803 : 104064 : call = copy_node (call);
3804 : 104064 : CALL_EXPR_ARG (call, 0) = hi;
3805 : : }
3806 : 104064 : tree ex = make_pack_expansion (call, complain);
3807 : 104064 : tree vec = make_tree_vec (1);
3808 : 104064 : TREE_VEC_ELT (vec, 0) = ex;
3809 : 104064 : return vec;
3810 : : }
3811 : : else
3812 : : {
3813 : 1286 : hi = instantiate_non_dependent_expr (hi, complain);
3814 : 1286 : hi = cxx_constant_value (hi, complain);
3815 : 1286 : int len = valid_constant_size_p (hi) ? tree_to_shwi (hi) : -1;
3816 : :
3817 : : /* Calculate the largest value of len that won't make the size of the vec
3818 : : overflow an int. The compiler will exceed resource limits long before
3819 : : this, but it seems a decent place to diagnose. */
3820 : 1286 : int max = ((INT_MAX - sizeof (tree_vec)) / sizeof (tree)) + 1;
3821 : :
3822 : 1286 : if (len < 0 || len > max)
3823 : : {
3824 : 12 : if ((complain & tf_error)
3825 : 9 : && hi != error_mark_node)
3826 : 9 : error ("argument to %<__integer_pack%> must be between 0 and %d",
3827 : : max);
3828 : 12 : return error_mark_node;
3829 : : }
3830 : :
3831 : 1274 : tree vec = make_tree_vec (len);
3832 : :
3833 : 6802 : for (int i = 0; i < len; ++i)
3834 : 5528 : TREE_VEC_ELT (vec, i) = size_int (i);
3835 : :
3836 : : return vec;
3837 : : }
3838 : : }
3839 : :
3840 : : /* Return a TREE_VEC for the expansion of built-in template parameter pack
3841 : : CALL. */
3842 : :
3843 : : static tree
3844 : 105350 : expand_builtin_pack_call (tree call, tree args, tsubst_flags_t complain,
3845 : : tree in_decl)
3846 : : {
3847 : 105350 : if (!builtin_pack_call_p (call))
3848 : : return NULL_TREE;
3849 : :
3850 : 105350 : tree fn = CALL_EXPR_FN (call);
3851 : :
3852 : 105350 : if (id_equal (DECL_NAME (fn), "__integer_pack"))
3853 : 105350 : return expand_integer_pack (call, args, complain, in_decl);
3854 : :
3855 : : return NULL_TREE;
3856 : : }
3857 : :
3858 : : /* Return true if the tree T has the extra args mechanism for
3859 : : avoiding partial instantiation. */
3860 : :
3861 : : static bool
3862 : 6334600829 : has_extra_args_mechanism_p (const_tree t)
3863 : : {
3864 : 6334600829 : return (PACK_EXPANSION_P (t) /* PACK_EXPANSION_EXTRA_ARGS */
3865 : 6301394735 : || TREE_CODE (t) == REQUIRES_EXPR /* REQUIRES_EXPR_EXTRA_ARGS */
3866 : 6300723563 : || (TREE_CODE (t) == IF_STMT
3867 : 520873 : && IF_STMT_CONSTEXPR_P (t)) /* IF_STMT_EXTRA_ARGS */
3868 : 12635115820 : || TREE_CODE (t) == LAMBDA_EXPR); /* LAMBDA_EXPR_EXTRA_ARGS */
3869 : : }
3870 : :
3871 : : /* Return *_EXTRA_ARGS of the given supported tree T. */
3872 : :
3873 : : static tree&
3874 : 25232 : tree_extra_args (tree t)
3875 : : {
3876 : 25232 : gcc_checking_assert (has_extra_args_mechanism_p (t));
3877 : :
3878 : 25232 : if (PACK_EXPANSION_P (t))
3879 : 589 : return PACK_EXPANSION_EXTRA_ARGS (t);
3880 : 24643 : else if (TREE_CODE (t) == REQUIRES_EXPR)
3881 : 1233 : return REQUIRES_EXPR_EXTRA_ARGS (t);
3882 : 23410 : else if (TREE_CODE (t) == IF_STMT
3883 : 23410 : && IF_STMT_CONSTEXPR_P (t))
3884 : 23213 : return IF_STMT_EXTRA_ARGS (t);
3885 : 197 : else if (TREE_CODE (t) == LAMBDA_EXPR)
3886 : 197 : return LAMBDA_EXPR_EXTRA_ARGS (t);
3887 : :
3888 : 0 : gcc_unreachable ();
3889 : : }
3890 : :
3891 : : /* Structure used to track the progress of find_parameter_packs_r. */
3892 : 1752895643 : struct find_parameter_pack_data
3893 : : {
3894 : : /* TREE_LIST that will contain all of the parameter packs found by
3895 : : the traversal. */
3896 : : tree* parameter_packs;
3897 : :
3898 : : /* Set of AST nodes that have been visited by the traversal. */
3899 : : hash_set<tree> *visited;
3900 : :
3901 : : /* True iff we found a subtree that has the extra args mechanism. */
3902 : : bool found_extra_args_tree_p = false;
3903 : : };
3904 : :
3905 : : /* Identifies all of the argument packs that occur in a template
3906 : : argument and appends them to the TREE_LIST inside DATA, which is a
3907 : : find_parameter_pack_data structure. This is a subroutine of
3908 : : make_pack_expansion and uses_parameter_packs. */
3909 : : static tree
3910 : 6507447362 : find_parameter_packs_r (tree *tp, int *walk_subtrees, void* data)
3911 : : {
3912 : 6507447362 : tree t = *tp;
3913 : 6507447362 : struct find_parameter_pack_data* ppd =
3914 : : (struct find_parameter_pack_data*)data;
3915 : 6507447362 : bool parameter_pack_p = false;
3916 : :
3917 : : #define WALK_SUBTREE(NODE) \
3918 : : cp_walk_tree (&(NODE), &find_parameter_packs_r, \
3919 : : ppd, ppd->visited) \
3920 : :
3921 : : /* Don't look through typedefs; we are interested in whether a
3922 : : parameter pack is actually written in the expression/type we're
3923 : : looking at, not the target type. */
3924 : 6507447362 : if (TYPE_P (t) && typedef_variant_p (t))
3925 : : {
3926 : : /* But do look at arguments for an alias template. */
3927 : 174117614 : if (tree tinfo = TYPE_ALIAS_TEMPLATE_INFO (t))
3928 : 132992767 : cp_walk_tree (&TI_ARGS (tinfo),
3929 : : &find_parameter_packs_r,
3930 : : ppd, ppd->visited);
3931 : 174117614 : *walk_subtrees = 0;
3932 : 174117614 : return NULL_TREE;
3933 : : }
3934 : :
3935 : : /* Identify whether this is a parameter pack or not. */
3936 : 6333329748 : switch (TREE_CODE (t))
3937 : : {
3938 : 67258516 : case TEMPLATE_PARM_INDEX:
3939 : 67258516 : if (TEMPLATE_PARM_PARAMETER_PACK (t))
3940 : : parameter_pack_p = true;
3941 : : break;
3942 : :
3943 : 1072189647 : case TEMPLATE_TYPE_PARM:
3944 : 1072189647 : t = TYPE_MAIN_VARIANT (t);
3945 : : /* FALLTHRU */
3946 : 1072866096 : case TEMPLATE_TEMPLATE_PARM:
3947 : 1072866096 : if (TEMPLATE_TYPE_PARAMETER_PACK (t))
3948 : : parameter_pack_p = true;
3949 : : break;
3950 : :
3951 : 367883771 : case FIELD_DECL:
3952 : 367883771 : case PARM_DECL:
3953 : 367883771 : if (DECL_PACK_P (t))
3954 : : {
3955 : : /* We don't want to walk into the type of a PARM_DECL,
3956 : : because we don't want to see the type parameter pack. */
3957 : 2741222 : *walk_subtrees = 0;
3958 : 2741222 : parameter_pack_p = true;
3959 : : }
3960 : : break;
3961 : :
3962 : 154937110 : case VAR_DECL:
3963 : 154937110 : if (DECL_PACK_P (t))
3964 : : {
3965 : : /* We don't want to walk into the type of a variadic capture proxy,
3966 : : because we don't want to see the type parameter pack. */
3967 : 56 : *walk_subtrees = 0;
3968 : 56 : parameter_pack_p = true;
3969 : : }
3970 : 154937054 : else if (variable_template_specialization_p (t))
3971 : : {
3972 : 66362 : cp_walk_tree (&DECL_TI_ARGS (t),
3973 : : find_parameter_packs_r,
3974 : : ppd, ppd->visited);
3975 : 66362 : *walk_subtrees = 0;
3976 : : }
3977 : : break;
3978 : :
3979 : 204508890 : case CALL_EXPR:
3980 : 204508890 : if (builtin_pack_call_p (t))
3981 : : parameter_pack_p = true;
3982 : : break;
3983 : :
3984 : : case BASES:
3985 : : parameter_pack_p = true;
3986 : : break;
3987 : : default:
3988 : : /* Not a parameter pack. */
3989 : : break;
3990 : : }
3991 : :
3992 : 2807640 : if (parameter_pack_p)
3993 : : {
3994 : : /* Add this parameter pack to the list. */
3995 : 59427527 : *ppd->parameter_packs = tree_cons (NULL_TREE, t, *ppd->parameter_packs);
3996 : : }
3997 : :
3998 : 6333329748 : if (has_extra_args_mechanism_p (t) && !PACK_EXPANSION_P (t))
3999 : 1537491 : ppd->found_extra_args_tree_p = true;
4000 : :
4001 : 6333329748 : if (TYPE_P (t))
4002 : 2067228347 : cp_walk_tree (&TYPE_CONTEXT (t),
4003 : : &find_parameter_packs_r, ppd, ppd->visited);
4004 : :
4005 : : /* This switch statement will return immediately if we don't find a
4006 : : parameter pack. ??? Should some of these be in cp_walk_subtrees? */
4007 : 6333329748 : switch (TREE_CODE (t))
4008 : : {
4009 : 332094 : case BOUND_TEMPLATE_TEMPLATE_PARM:
4010 : : /* Check the template itself. */
4011 : 332094 : cp_walk_tree (&TREE_TYPE (TYPE_TI_TEMPLATE (t)),
4012 : : &find_parameter_packs_r, ppd, ppd->visited);
4013 : 332094 : return NULL_TREE;
4014 : :
4015 : 1233063 : case DECL_EXPR:
4016 : 1233063 : {
4017 : 1233063 : tree decl = DECL_EXPR_DECL (t);
4018 : : /* Ignore the declaration of a capture proxy for a parameter pack. */
4019 : 1233063 : if (is_capture_proxy (decl))
4020 : 896470 : *walk_subtrees = 0;
4021 : 1233063 : if (is_typedef_decl (decl))
4022 : : /* Since we stop at typedefs above, we need to look through them at
4023 : : the point of the DECL_EXPR. */
4024 : 70246 : cp_walk_tree (&DECL_ORIGINAL_TYPE (decl),
4025 : : &find_parameter_packs_r, ppd, ppd->visited);
4026 : : return NULL_TREE;
4027 : : }
4028 : :
4029 : 175597253 : case TEMPLATE_DECL:
4030 : 175597253 : if (!DECL_TEMPLATE_TEMPLATE_PARM_P (t))
4031 : : return NULL_TREE;
4032 : 6159 : cp_walk_tree (&TREE_TYPE (t),
4033 : : &find_parameter_packs_r, ppd, ppd->visited);
4034 : 6159 : return NULL_TREE;
4035 : :
4036 : 33204916 : case TYPE_PACK_EXPANSION:
4037 : 33204916 : case EXPR_PACK_EXPANSION:
4038 : 33204916 : *walk_subtrees = 0;
4039 : 33204916 : return NULL_TREE;
4040 : :
4041 : 176 : case PACK_INDEX_TYPE:
4042 : 176 : case PACK_INDEX_EXPR:
4043 : : /* We can have an expansion of an expansion, such as "Ts...[Is]...",
4044 : : so do look into the index (but not the pack). */
4045 : 176 : cp_walk_tree (&PACK_INDEX_INDEX (t), &find_parameter_packs_r, ppd,
4046 : : ppd->visited);
4047 : 176 : *walk_subtrees = 0;
4048 : 176 : return NULL_TREE;
4049 : :
4050 : 27657748 : case INTEGER_TYPE:
4051 : 27657748 : cp_walk_tree (&TYPE_MAX_VALUE (t), &find_parameter_packs_r,
4052 : : ppd, ppd->visited);
4053 : 27657748 : *walk_subtrees = 0;
4054 : 27657748 : return NULL_TREE;
4055 : :
4056 : 198472688 : case IDENTIFIER_NODE:
4057 : 198472688 : cp_walk_tree (&TREE_TYPE (t), &find_parameter_packs_r, ppd,
4058 : : ppd->visited);
4059 : 198472688 : *walk_subtrees = 0;
4060 : 198472688 : return NULL_TREE;
4061 : :
4062 : 706639 : case LAMBDA_EXPR:
4063 : 706639 : {
4064 : : /* Since we defer implicit capture, look in the parms and body. */
4065 : 706639 : tree fn = lambda_function (t);
4066 : 706639 : cp_walk_tree (&TREE_TYPE (fn), &find_parameter_packs_r, ppd,
4067 : : ppd->visited);
4068 : 706639 : cp_walk_tree (&DECL_SAVED_TREE (fn), &find_parameter_packs_r, ppd,
4069 : : ppd->visited);
4070 : 706639 : return NULL_TREE;
4071 : : }
4072 : :
4073 : 5374146 : case DECLTYPE_TYPE:
4074 : 5374146 : cp_walk_tree (&DECLTYPE_TYPE_EXPR (t), &find_parameter_packs_r,
4075 : : ppd, ppd->visited);
4076 : 5374146 : *walk_subtrees = 0;
4077 : 5374146 : return NULL_TREE;
4078 : :
4079 : 463059 : case IF_STMT:
4080 : 463059 : cp_walk_tree (&IF_COND (t), &find_parameter_packs_r,
4081 : : ppd, ppd->visited);
4082 : 463059 : cp_walk_tree (&THEN_CLAUSE (t), &find_parameter_packs_r,
4083 : : ppd, ppd->visited);
4084 : 463059 : cp_walk_tree (&ELSE_CLAUSE (t), &find_parameter_packs_r,
4085 : : ppd, ppd->visited);
4086 : : /* Don't walk into IF_STMT_EXTRA_ARGS. */
4087 : 463059 : *walk_subtrees = 0;
4088 : 463059 : return NULL_TREE;
4089 : :
4090 : 95 : case TAG_DEFN:
4091 : 95 : t = TREE_TYPE (t);
4092 : 95 : if (CLASS_TYPE_P (t))
4093 : : {
4094 : : /* Local class, need to look through the whole definition.
4095 : : TYPE_BINFO might be unset for a partial instantiation. */
4096 : 45 : if (TYPE_BINFO (t))
4097 : 51 : for (tree bb : BINFO_BASE_BINFOS (TYPE_BINFO (t)))
4098 : 9 : cp_walk_tree (&BINFO_TYPE (bb), &find_parameter_packs_r,
4099 : : ppd, ppd->visited);
4100 : : }
4101 : : else
4102 : : /* Enum, look at the values. */
4103 : 195 : for (tree l = TYPE_VALUES (t); l; l = TREE_CHAIN (l))
4104 : 145 : cp_walk_tree (&DECL_INITIAL (TREE_VALUE (l)),
4105 : : &find_parameter_packs_r,
4106 : : ppd, ppd->visited);
4107 : : return NULL_TREE;
4108 : :
4109 : 5866531 : case FUNCTION_TYPE:
4110 : 5866531 : case METHOD_TYPE:
4111 : 5866531 : WALK_SUBTREE (TYPE_RAISES_EXCEPTIONS (t));
4112 : 5866531 : break;
4113 : :
4114 : : default:
4115 : : return NULL_TREE;
4116 : : }
4117 : :
4118 : : #undef WALK_SUBTREE
4119 : :
4120 : 5866531 : return NULL_TREE;
4121 : : }
4122 : :
4123 : : /* Determines if the expression or type T uses any parameter packs. */
4124 : : tree
4125 : 13310896 : uses_parameter_packs (tree t)
4126 : : {
4127 : 13310896 : tree parameter_packs = NULL_TREE;
4128 : 13310896 : struct find_parameter_pack_data ppd;
4129 : 13310896 : ppd.parameter_packs = ¶meter_packs;
4130 : 13310896 : ppd.visited = new hash_set<tree>;
4131 : 13310896 : cp_walk_tree (&t, &find_parameter_packs_r, &ppd, ppd.visited);
4132 : 26621792 : delete ppd.visited;
4133 : 13310896 : return parameter_packs;
4134 : : }
4135 : :
4136 : : /* Turn ARG, which may be an expression, type, or a TREE_LIST
4137 : : representation a base-class initializer into a parameter pack
4138 : : expansion. If all goes well, the resulting node will be an
4139 : : EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
4140 : : respectively. */
4141 : : tree
4142 : 54681027 : make_pack_expansion (tree arg, tsubst_flags_t complain)
4143 : : {
4144 : 54681027 : tree result;
4145 : 54681027 : tree parameter_packs = NULL_TREE;
4146 : 54681027 : bool for_types = false;
4147 : 54681027 : struct find_parameter_pack_data ppd;
4148 : :
4149 : 54681027 : if (!arg || arg == error_mark_node)
4150 : : return arg;
4151 : :
4152 : 54681012 : if (TREE_CODE (arg) == TREE_LIST && TREE_PURPOSE (arg))
4153 : : {
4154 : : /* A TREE_LIST with a non-null TREE_PURPOSE is for a base
4155 : : class initializer. In this case, the TREE_PURPOSE will be a
4156 : : _TYPE node (representing the base class expansion we're
4157 : : initializing) and the TREE_VALUE will be a TREE_LIST
4158 : : containing the initialization arguments.
4159 : :
4160 : : The resulting expansion looks somewhat different from most
4161 : : expansions. Rather than returning just one _EXPANSION, we
4162 : : return a TREE_LIST whose TREE_PURPOSE is a
4163 : : TYPE_PACK_EXPANSION containing the bases that will be
4164 : : initialized. The TREE_VALUE will be identical to the
4165 : : original TREE_VALUE, which is a list of arguments that will
4166 : : be passed to each base. We do not introduce any new pack
4167 : : expansion nodes into the TREE_VALUE (although it is possible
4168 : : that some already exist), because the TREE_PURPOSE and
4169 : : TREE_VALUE all need to be expanded together with the same
4170 : : _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
4171 : : resulting TREE_PURPOSE will mention the parameter packs in
4172 : : both the bases and the arguments to the bases. */
4173 : 33 : tree purpose;
4174 : 33 : tree value;
4175 : 33 : tree parameter_packs = NULL_TREE;
4176 : :
4177 : : /* Determine which parameter packs will be used by the base
4178 : : class expansion. */
4179 : 33 : ppd.visited = new hash_set<tree>;
4180 : 33 : ppd.parameter_packs = ¶meter_packs;
4181 : 33 : gcc_assert (TYPE_P (TREE_PURPOSE (arg)));
4182 : 33 : cp_walk_tree (&TREE_PURPOSE (arg), &find_parameter_packs_r,
4183 : : &ppd, ppd.visited);
4184 : :
4185 : 33 : if (parameter_packs == NULL_TREE)
4186 : : {
4187 : 0 : if (complain & tf_error)
4188 : 0 : error ("base initializer expansion %qT contains no parameter packs",
4189 : : arg);
4190 : 0 : delete ppd.visited;
4191 : 0 : return error_mark_node;
4192 : : }
4193 : :
4194 : 33 : if (TREE_VALUE (arg) != void_type_node)
4195 : : {
4196 : : /* Collect the sets of parameter packs used in each of the
4197 : : initialization arguments. */
4198 : 63 : for (value = TREE_VALUE (arg); value; value = TREE_CHAIN (value))
4199 : : {
4200 : : /* Determine which parameter packs will be expanded in this
4201 : : argument. */
4202 : 36 : cp_walk_tree (&TREE_VALUE (value), &find_parameter_packs_r,
4203 : : &ppd, ppd.visited);
4204 : : }
4205 : : }
4206 : :
4207 : 66 : delete ppd.visited;
4208 : :
4209 : : /* Create the pack expansion type for the base type. */
4210 : 33 : purpose = cxx_make_type (TYPE_PACK_EXPANSION);
4211 : 33 : PACK_EXPANSION_PATTERN (purpose) = TREE_PURPOSE (arg);
4212 : 66 : PACK_EXPANSION_PARAMETER_PACKS (purpose) = parameter_packs;
4213 : 33 : PACK_EXPANSION_LOCAL_P (purpose) = at_function_scope_p ();
4214 : :
4215 : : /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
4216 : : they will rarely be compared to anything. */
4217 : 33 : SET_TYPE_STRUCTURAL_EQUALITY (purpose);
4218 : :
4219 : 33 : return tree_cons (purpose, TREE_VALUE (arg), NULL_TREE);
4220 : : }
4221 : :
4222 : 54680979 : if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
4223 : 48222716 : for_types = true;
4224 : :
4225 : : /* Build the PACK_EXPANSION_* node. */
4226 : 109361958 : result = for_types
4227 : 48222716 : ? cxx_make_type (TYPE_PACK_EXPANSION)
4228 : 6458263 : : make_node (EXPR_PACK_EXPANSION);
4229 : 54680979 : PACK_EXPANSION_PATTERN (result) = arg;
4230 : 54680979 : if (TREE_CODE (result) == EXPR_PACK_EXPANSION)
4231 : : {
4232 : : /* Propagate type and const-expression information. */
4233 : 6458263 : TREE_TYPE (result) = TREE_TYPE (arg);
4234 : 6458263 : TREE_CONSTANT (result) = TREE_CONSTANT (arg);
4235 : : /* Mark this read now, since the expansion might be length 0. */
4236 : 6458263 : mark_exp_read (arg);
4237 : : }
4238 : : else
4239 : : /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
4240 : : they will rarely be compared to anything. */
4241 : 48222716 : SET_TYPE_STRUCTURAL_EQUALITY (result);
4242 : :
4243 : : /* Determine which parameter packs will be expanded. */
4244 : 54680979 : ppd.parameter_packs = ¶meter_packs;
4245 : 54680979 : ppd.visited = new hash_set<tree>;
4246 : 54680979 : cp_walk_tree (&arg, &find_parameter_packs_r, &ppd, ppd.visited);
4247 : 109361958 : delete ppd.visited;
4248 : :
4249 : : /* Make sure we found some parameter packs. */
4250 : 54680979 : if (parameter_packs == NULL_TREE)
4251 : : {
4252 : 80 : if (complain & tf_error)
4253 : : {
4254 : 80 : if (TYPE_P (arg))
4255 : 38 : error ("expansion pattern %qT contains no parameter packs", arg);
4256 : : else
4257 : 42 : error ("expansion pattern %qE contains no parameter packs", arg);
4258 : : }
4259 : 80 : return error_mark_node;
4260 : : }
4261 : 102903577 : PACK_EXPANSION_PARAMETER_PACKS (result) = parameter_packs;
4262 : :
4263 : 54680899 : PACK_EXPANSION_LOCAL_P (result) = at_function_scope_p ();
4264 : 54680899 : if (ppd.found_extra_args_tree_p)
4265 : : /* If the pattern of this pack expansion contains a subtree that has
4266 : : the extra args mechanism for avoiding partial instantiation, then
4267 : : force this pack expansion to also use extra args. Otherwise
4268 : : partial instantiation of this pack expansion may not lower the
4269 : : level of some parameter packs within the pattern, which would
4270 : : confuse tsubst_pack_expansion later (PR101764). */
4271 : 18894 : PACK_EXPANSION_FORCE_EXTRA_ARGS_P (result) = true;
4272 : :
4273 : : return result;
4274 : : }
4275 : :
4276 : : /* Create a PACK_INDEX_* using the pack expansion PACK and index INDEX. */
4277 : :
4278 : : tree
4279 : 245 : make_pack_index (tree pack, tree index)
4280 : : {
4281 : 245 : if (pack == error_mark_node)
4282 : : return error_mark_node;
4283 : :
4284 : 232 : bool for_types;
4285 : 232 : if (TREE_CODE (pack) == TYPE_PACK_EXPANSION)
4286 : : for_types = true;
4287 : 101 : else if (TREE_CODE (pack) == EXPR_PACK_EXPANSION)
4288 : : for_types = false;
4289 : : else
4290 : : {
4291 : : /* Maybe we've already partially substituted the pack. */
4292 : 4 : gcc_checking_assert (TREE_CODE (pack) == TREE_VEC);
4293 : 4 : for_types = TYPE_P (TREE_VEC_ELT (pack, 0));
4294 : : }
4295 : :
4296 : 4 : tree t = (for_types
4297 : 135 : ? cxx_make_type (PACK_INDEX_TYPE)
4298 : 98 : : make_node (PACK_INDEX_EXPR));
4299 : 232 : PACK_INDEX_PACK (t) = pack;
4300 : 232 : PACK_INDEX_INDEX (t) = index;
4301 : 232 : if (TREE_CODE (t) == PACK_INDEX_TYPE)
4302 : 134 : SET_TYPE_STRUCTURAL_EQUALITY (t);
4303 : : return t;
4304 : : }
4305 : :
4306 : : /* Checks T for any "bare" parameter packs, which have not yet been
4307 : : expanded, and issues an error if any are found. This operation can
4308 : : only be done on full expressions or types (e.g., an expression
4309 : : statement, "if" condition, etc.), because we could have expressions like:
4310 : :
4311 : : foo(f(g(h(args)))...)
4312 : :
4313 : : where "args" is a parameter pack. check_for_bare_parameter_packs
4314 : : should not be called for the subexpressions args, h(args),
4315 : : g(h(args)), or f(g(h(args))), because we would produce erroneous
4316 : : error messages.
4317 : :
4318 : : Returns TRUE and emits an error if there were bare parameter packs,
4319 : : returns FALSE otherwise. */
4320 : : bool
4321 : 1684902890 : check_for_bare_parameter_packs (tree t, location_t loc /* = UNKNOWN_LOCATION */)
4322 : : {
4323 : 1684902890 : tree parameter_packs = NULL_TREE;
4324 : 1684902890 : struct find_parameter_pack_data ppd;
4325 : :
4326 : 1684902890 : if (!processing_template_decl || !t || t == error_mark_node)
4327 : : return false;
4328 : :
4329 : 1077117799 : if (TREE_CODE (t) == TYPE_DECL)
4330 : 0 : t = TREE_TYPE (t);
4331 : :
4332 : 1077117799 : ppd.parameter_packs = ¶meter_packs;
4333 : 1077117799 : ppd.visited = new hash_set<tree>;
4334 : 1077117799 : cp_walk_tree (&t, &find_parameter_packs_r, &ppd, ppd.visited);
4335 : 2154235598 : delete ppd.visited;
4336 : :
4337 : 1077117799 : if (!parameter_packs)
4338 : : return false;
4339 : :
4340 : 352 : if (loc == UNKNOWN_LOCATION)
4341 : 346 : loc = cp_expr_loc_or_input_loc (t);
4342 : :
4343 : : /* It's OK for a lambda to have an unexpanded parameter pack from the
4344 : : containing context, but do complain about unexpanded capture packs. */
4345 : 352 : tree lam = current_lambda_expr ();
4346 : 352 : if (lam)
4347 : 90 : lam = TREE_TYPE (lam);
4348 : :
4349 : 90 : if (lam && lam != current_class_type)
4350 : : {
4351 : : /* We're in a lambda, but it isn't the innermost class.
4352 : : This should work, but currently doesn't. */
4353 : 9 : sorry_at (loc, "unexpanded parameter pack in local class in lambda");
4354 : 9 : return true;
4355 : : }
4356 : :
4357 : 343 : if (lam && CLASSTYPE_TEMPLATE_INFO (lam))
4358 : 149 : for (; parameter_packs;
4359 : 71 : parameter_packs = TREE_CHAIN (parameter_packs))
4360 : : {
4361 : 78 : tree pack = TREE_VALUE (parameter_packs);
4362 : 78 : if (is_capture_proxy (pack)
4363 : 78 : || (TREE_CODE (pack) == PARM_DECL
4364 : 18 : && DECL_CONTEXT (DECL_CONTEXT (pack)) == lam))
4365 : : break;
4366 : : }
4367 : :
4368 : 343 : if (parameter_packs)
4369 : : {
4370 : 272 : auto_diagnostic_group d;
4371 : 272 : error_at (loc, "parameter packs not expanded with %<...%>:");
4372 : 816 : while (parameter_packs)
4373 : : {
4374 : 272 : tree pack = TREE_VALUE (parameter_packs);
4375 : 272 : tree name = NULL_TREE;
4376 : :
4377 : 272 : if (TREE_CODE (pack) == TEMPLATE_TYPE_PARM
4378 : 272 : || TREE_CODE (pack) == TEMPLATE_TEMPLATE_PARM)
4379 : 202 : name = TYPE_NAME (pack);
4380 : 70 : else if (TREE_CODE (pack) == TEMPLATE_PARM_INDEX)
4381 : 39 : name = DECL_NAME (TEMPLATE_PARM_DECL (pack));
4382 : 31 : else if (TREE_CODE (pack) == CALL_EXPR)
4383 : 3 : name = DECL_NAME (CALL_EXPR_FN (pack));
4384 : : else
4385 : 28 : name = DECL_NAME (pack);
4386 : :
4387 : 272 : if (name)
4388 : 272 : inform (loc, " %qD", name);
4389 : : else
4390 : 0 : inform (loc, " %s", "<anonymous>");
4391 : :
4392 : 272 : parameter_packs = TREE_CHAIN (parameter_packs);
4393 : : }
4394 : :
4395 : 272 : return true;
4396 : 272 : }
4397 : :
4398 : : return false;
4399 : : }
4400 : :
4401 : : /* Expand any parameter packs that occur in the template arguments in
4402 : : ARGS. */
4403 : : tree
4404 : 575031727 : expand_template_argument_pack (tree args)
4405 : : {
4406 : 575031727 : if (args == error_mark_node)
4407 : : return error_mark_node;
4408 : :
4409 : 575031706 : tree result_args = NULL_TREE;
4410 : 1150063412 : int in_arg, out_arg = 0, nargs = args ? TREE_VEC_LENGTH (args) : 0;
4411 : 575031706 : int num_result_args = -1;
4412 : 575031706 : int non_default_args_count = -1;
4413 : :
4414 : : /* First, determine if we need to expand anything, and the number of
4415 : : slots we'll need. */
4416 : 1487461646 : for (in_arg = 0; in_arg < nargs; ++in_arg)
4417 : : {
4418 : 912429973 : tree arg = TREE_VEC_ELT (args, in_arg);
4419 : 912429973 : if (arg == NULL_TREE)
4420 : : return args;
4421 : 912429940 : if (ARGUMENT_PACK_P (arg))
4422 : : {
4423 : 53601793 : int num_packed = TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg));
4424 : 53601793 : if (num_result_args < 0)
4425 : 53601793 : num_result_args = in_arg + num_packed;
4426 : : else
4427 : 0 : num_result_args += num_packed;
4428 : : }
4429 : : else
4430 : : {
4431 : 858828147 : if (num_result_args >= 0)
4432 : 23 : num_result_args++;
4433 : : }
4434 : : }
4435 : :
4436 : : /* If no expansion is necessary, we're done. */
4437 : 575031673 : if (num_result_args < 0)
4438 : : return args;
4439 : :
4440 : : /* Expand arguments. */
4441 : 53601793 : result_args = make_tree_vec (num_result_args);
4442 : 53601793 : if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (args))
4443 : 52582428 : non_default_args_count =
4444 : 52582428 : GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args);
4445 : 128525047 : for (in_arg = 0; in_arg < nargs; ++in_arg)
4446 : : {
4447 : 74923254 : tree arg = TREE_VEC_ELT (args, in_arg);
4448 : 74923254 : if (ARGUMENT_PACK_P (arg))
4449 : : {
4450 : 53601793 : tree packed = ARGUMENT_PACK_ARGS (arg);
4451 : 53601793 : int i, num_packed = TREE_VEC_LENGTH (packed);
4452 : 151593123 : for (i = 0; i < num_packed; ++i, ++out_arg)
4453 : 97991330 : TREE_VEC_ELT (result_args, out_arg) = TREE_VEC_ELT(packed, i);
4454 : 53601793 : if (non_default_args_count > 0)
4455 : 52582424 : non_default_args_count += num_packed - 1;
4456 : : }
4457 : : else
4458 : : {
4459 : 21321461 : TREE_VEC_ELT (result_args, out_arg) = arg;
4460 : 21321461 : ++out_arg;
4461 : : }
4462 : : }
4463 : 53601793 : if (non_default_args_count >= 0)
4464 : 52582428 : SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (result_args, non_default_args_count);
4465 : : return result_args;
4466 : : }
4467 : :
4468 : : /* Checks if DECL shadows a template parameter.
4469 : :
4470 : : [temp.local]: A template-parameter shall not be redeclared within its
4471 : : scope (including nested scopes).
4472 : :
4473 : : Emits an error and returns TRUE if the DECL shadows a parameter,
4474 : : returns FALSE otherwise. */
4475 : :
4476 : : bool
4477 : 1542682395 : check_template_shadow (tree decl)
4478 : : {
4479 : 1542682395 : tree olddecl;
4480 : :
4481 : : /* If we're not in a template, we can't possibly shadow a template
4482 : : parameter. */
4483 : 1542682395 : if (!current_template_parms)
4484 : : return true;
4485 : :
4486 : : /* Figure out what we're shadowing. */
4487 : 775949509 : decl = OVL_FIRST (decl);
4488 : 775949509 : olddecl = innermost_non_namespace_value (DECL_NAME (decl));
4489 : :
4490 : : /* If there's no previous binding for this name, we're not shadowing
4491 : : anything, let alone a template parameter. */
4492 : 775949509 : if (!olddecl)
4493 : : return true;
4494 : :
4495 : : /* If we're not shadowing a template parameter, we're done. Note
4496 : : that OLDDECL might be an OVERLOAD (or perhaps even an
4497 : : ERROR_MARK), so we can't just blithely assume it to be a _DECL
4498 : : node. */
4499 : 58935899 : if (!DECL_P (olddecl) || !DECL_TEMPLATE_PARM_P (olddecl))
4500 : : return true;
4501 : :
4502 : : /* We check for decl != olddecl to avoid bogus errors for using a
4503 : : name inside a class. We check TPFI to avoid duplicate errors for
4504 : : inline member templates. */
4505 : 150 : if (decl == olddecl
4506 : 150 : || (DECL_TEMPLATE_PARM_P (decl)
4507 : 69 : && TEMPLATE_PARMS_FOR_INLINE (current_template_parms)))
4508 : : return true;
4509 : :
4510 : : /* Don't complain about the injected class name, as we've already
4511 : : complained about the class itself. */
4512 : 117 : if (DECL_SELF_REFERENCE_P (decl))
4513 : : return false;
4514 : :
4515 : 111 : auto_diagnostic_group d;
4516 : 111 : if (DECL_TEMPLATE_PARM_P (decl))
4517 : 36 : error ("declaration of template parameter %q+D shadows "
4518 : : "template parameter", decl);
4519 : : else
4520 : 75 : error ("declaration of %q+#D shadows template parameter", decl);
4521 : 111 : inform (DECL_SOURCE_LOCATION (olddecl),
4522 : : "template parameter %qD declared here", olddecl);
4523 : 111 : return false;
4524 : 111 : }
4525 : :
4526 : : /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
4527 : : ORIG_LEVEL, DECL, and TYPE. */
4528 : :
4529 : : static tree
4530 : 178251674 : build_template_parm_index (int index,
4531 : : int level,
4532 : : int orig_level,
4533 : : tree decl,
4534 : : tree type)
4535 : : {
4536 : 178251674 : tree t = make_node (TEMPLATE_PARM_INDEX);
4537 : 178251674 : TEMPLATE_PARM_IDX (t) = index;
4538 : 178251674 : TEMPLATE_PARM_LEVEL (t) = level;
4539 : 178251674 : TEMPLATE_PARM_ORIG_LEVEL (t) = orig_level;
4540 : 178251674 : TEMPLATE_PARM_DECL (t) = decl;
4541 : 178251674 : TREE_TYPE (t) = type;
4542 : 178251674 : TREE_CONSTANT (t) = TREE_CONSTANT (decl);
4543 : 178251674 : TREE_READONLY (t) = TREE_READONLY (decl);
4544 : :
4545 : 178251674 : return t;
4546 : : }
4547 : :
4548 : : struct ctp_hasher : ggc_ptr_hash<tree_node>
4549 : : {
4550 : 1110390272 : static hashval_t hash (tree t)
4551 : : {
4552 : 1110390272 : ++comparing_specializations;
4553 : 1110390272 : tree_code code = TREE_CODE (t);
4554 : 1110390272 : hashval_t val = iterative_hash_object (code, 0);
4555 : 1110390272 : val = iterative_hash_object (TEMPLATE_TYPE_LEVEL (t), val);
4556 : 1110390272 : val = iterative_hash_object (TEMPLATE_TYPE_IDX (t), val);
4557 : 1110390272 : if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
4558 : : {
4559 : 1010262712 : val
4560 : 1010262712 : = iterative_hash_template_arg (CLASS_PLACEHOLDER_TEMPLATE (t), val);
4561 : 1010262712 : if (tree c = NON_ERROR (PLACEHOLDER_TYPE_CONSTRAINTS (t)))
4562 : 98198372 : val = iterative_hash_placeholder_constraint (c, val);
4563 : : }
4564 : 1110390272 : if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
4565 : 56623858 : val = iterative_hash_template_arg (TYPE_TI_ARGS (t), val);
4566 : 1110390272 : --comparing_specializations;
4567 : 1110390272 : return val;
4568 : : }
4569 : :
4570 : 1228786759 : static bool equal (tree t, tree u)
4571 : : {
4572 : 1228786759 : ++comparing_specializations;
4573 : 1228786759 : bool eq = comptypes (t, u, COMPARE_STRUCTURAL);
4574 : 1228786759 : --comparing_specializations;
4575 : 1228786759 : return eq;
4576 : : }
4577 : : };
4578 : :
4579 : : static GTY (()) hash_table<ctp_hasher> *ctp_table;
4580 : :
4581 : : /* Find the canonical type parameter for the given template type
4582 : : parameter. Returns the canonical type parameter, which may be TYPE
4583 : : if no such parameter existed. */
4584 : :
4585 : : tree
4586 : 165537025 : canonical_type_parameter (tree type)
4587 : : {
4588 : 165537025 : if (ctp_table == NULL)
4589 : 92703 : ctp_table = hash_table<ctp_hasher>::create_ggc (61);
4590 : :
4591 : 165537025 : tree& slot = *ctp_table->find_slot (type, INSERT);
4592 : 165537025 : if (slot == NULL_TREE)
4593 : 1585657 : slot = type;
4594 : 165537025 : return slot;
4595 : : }
4596 : :
4597 : : /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
4598 : : TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
4599 : : TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
4600 : : new one is created. */
4601 : :
4602 : : static tree
4603 : 20171666 : reduce_template_parm_level (tree index, tree type, int levels, tree args,
4604 : : tsubst_flags_t complain)
4605 : : {
4606 : 20171666 : if (TEMPLATE_PARM_DESCENDANTS (index) == NULL_TREE
4607 : 7522870 : || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index))
4608 : 7522870 : != TEMPLATE_PARM_LEVEL (index) - levels)
4609 : 27667551 : || !same_type_p (type, TREE_TYPE (TEMPLATE_PARM_DESCENDANTS (index))))
4610 : : {
4611 : 13717132 : tree orig_decl = TEMPLATE_PARM_DECL (index);
4612 : :
4613 : 13717132 : tree decl = build_decl (DECL_SOURCE_LOCATION (orig_decl),
4614 : 13717132 : TREE_CODE (orig_decl), DECL_NAME (orig_decl),
4615 : : type);
4616 : 13717132 : TREE_CONSTANT (decl) = TREE_CONSTANT (orig_decl);
4617 : 13717132 : TREE_READONLY (decl) = TREE_READONLY (orig_decl);
4618 : 13717132 : DECL_VIRTUAL_P (decl) = DECL_VIRTUAL_P (orig_decl);
4619 : 13717132 : DECL_ARTIFICIAL (decl) = 1;
4620 : 13717132 : SET_DECL_TEMPLATE_PARM_P (decl);
4621 : :
4622 : 13717132 : tree tpi = build_template_parm_index (TEMPLATE_PARM_IDX (index),
4623 : 13717132 : TEMPLATE_PARM_LEVEL (index) - levels,
4624 : 13717132 : TEMPLATE_PARM_ORIG_LEVEL (index),
4625 : : decl, type);
4626 : 13717132 : TEMPLATE_PARM_DESCENDANTS (index) = tpi;
4627 : 27434264 : TEMPLATE_PARM_PARAMETER_PACK (tpi)
4628 : 13717132 : = TEMPLATE_PARM_PARAMETER_PACK (index);
4629 : :
4630 : : /* Template template parameters need this. */
4631 : 13717132 : tree inner = decl;
4632 : 13717132 : if (TREE_CODE (decl) == TEMPLATE_DECL)
4633 : : {
4634 : 1803 : inner = build_lang_decl_loc (DECL_SOURCE_LOCATION (decl),
4635 : 1803 : TYPE_DECL, DECL_NAME (decl), type);
4636 : 1803 : DECL_TEMPLATE_RESULT (decl) = inner;
4637 : 1803 : DECL_ARTIFICIAL (inner) = true;
4638 : 1803 : tree parms = tsubst_template_parms (DECL_TEMPLATE_PARMS (orig_decl),
4639 : : args, complain);
4640 : 1803 : DECL_TEMPLATE_PARMS (decl) = parms;
4641 : 1803 : tree orig_inner = DECL_TEMPLATE_RESULT (orig_decl);
4642 : 1803 : DECL_TEMPLATE_INFO (inner)
4643 : 3606 : = build_template_info (DECL_TI_TEMPLATE (orig_inner),
4644 : : template_parms_to_args (parms));
4645 : : }
4646 : :
4647 : : /* Attach the TPI to the decl. */
4648 : 13717132 : if (TREE_CODE (inner) == TYPE_DECL)
4649 : 11608388 : TEMPLATE_TYPE_PARM_INDEX (type) = tpi;
4650 : : else
4651 : 2108744 : DECL_INITIAL (decl) = tpi;
4652 : : }
4653 : :
4654 : 20171666 : return TEMPLATE_PARM_DESCENDANTS (index);
4655 : : }
4656 : :
4657 : : /* Process information from new template parameter PARM and append it
4658 : : to the LIST being built. This new parameter is a non-type
4659 : : parameter iff IS_NON_TYPE is true. This new parameter is a
4660 : : parameter pack iff IS_PARAMETER_PACK is true. The location of PARM
4661 : : is in PARM_LOC. */
4662 : :
4663 : : tree
4664 : 145084005 : process_template_parm (tree list, location_t parm_loc, tree parm,
4665 : : bool is_non_type, bool is_parameter_pack)
4666 : : {
4667 : 145084005 : gcc_assert (TREE_CODE (parm) == TREE_LIST);
4668 : 145084005 : tree prev = NULL_TREE;
4669 : 145084005 : int idx = 0;
4670 : :
4671 : 145084005 : if (list)
4672 : : {
4673 : 68325686 : prev = tree_last (list);
4674 : :
4675 : 68325686 : tree p = TREE_VALUE (prev);
4676 : 68325686 : if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
4677 : 62674855 : idx = TEMPLATE_TYPE_IDX (TREE_TYPE (p));
4678 : 5650831 : else if (TREE_CODE (p) == PARM_DECL)
4679 : 5650811 : idx = TEMPLATE_PARM_IDX (DECL_INITIAL (p));
4680 : :
4681 : 68325686 : ++idx;
4682 : : }
4683 : :
4684 : 145084005 : tree decl = NULL_TREE;
4685 : 145084005 : tree defval = TREE_PURPOSE (parm);
4686 : 145084005 : tree constr = TREE_TYPE (parm);
4687 : :
4688 : 145084005 : if (is_non_type)
4689 : : {
4690 : 11375753 : parm = TREE_VALUE (parm);
4691 : :
4692 : 11375753 : SET_DECL_TEMPLATE_PARM_P (parm);
4693 : :
4694 : 11375753 : if (TREE_TYPE (parm) != error_mark_node)
4695 : : {
4696 : : /* [temp.param]
4697 : :
4698 : : The top-level cv-qualifiers on the template-parameter are
4699 : : ignored when determining its type. */
4700 : 11375670 : TREE_TYPE (parm) = TYPE_MAIN_VARIANT (TREE_TYPE (parm));
4701 : 11375670 : if (invalid_nontype_parm_type_p (TREE_TYPE (parm), 1))
4702 : 101 : TREE_TYPE (parm) = error_mark_node;
4703 : 11375569 : else if (uses_parameter_packs (TREE_TYPE (parm))
4704 : 51 : && !is_parameter_pack
4705 : : /* If we're in a nested template parameter list, the template
4706 : : template parameter could be a parameter pack. */
4707 : 11375587 : && processing_template_parmlist == 1)
4708 : : {
4709 : : /* This template parameter is not a parameter pack, but it
4710 : : should be. Complain about "bare" parameter packs. */
4711 : 12 : check_for_bare_parameter_packs (TREE_TYPE (parm));
4712 : :
4713 : : /* Recover by calling this a parameter pack. */
4714 : 12 : is_parameter_pack = true;
4715 : : }
4716 : : }
4717 : :
4718 : : /* A template parameter is not modifiable. */
4719 : 11375753 : TREE_CONSTANT (parm) = 1;
4720 : 11375753 : TREE_READONLY (parm) = 1;
4721 : 11375753 : decl = build_decl (parm_loc,
4722 : 11375753 : CONST_DECL, DECL_NAME (parm), TREE_TYPE (parm));
4723 : 11375753 : TREE_CONSTANT (decl) = 1;
4724 : 11375753 : TREE_READONLY (decl) = 1;
4725 : 11375753 : DECL_INITIAL (parm) = DECL_INITIAL (decl)
4726 : 22751506 : = build_template_parm_index (idx, current_template_depth,
4727 : 11375753 : current_template_depth,
4728 : 11375753 : decl, TREE_TYPE (parm));
4729 : :
4730 : 11375753 : TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm))
4731 : 11375753 : = is_parameter_pack;
4732 : : }
4733 : : else
4734 : : {
4735 : 133708252 : tree t;
4736 : 133708252 : parm = TREE_VALUE (TREE_VALUE (parm));
4737 : :
4738 : 133708252 : if (parm && TREE_CODE (parm) == TEMPLATE_DECL)
4739 : : {
4740 : 305502 : t = cxx_make_type (TEMPLATE_TEMPLATE_PARM);
4741 : : /* This is for distinguishing between real templates and template
4742 : : template parameters */
4743 : 305502 : TREE_TYPE (parm) = t;
4744 : :
4745 : : /* any_template_parm_r expects to be able to get the targs of a
4746 : : DECL_TEMPLATE_RESULT. */
4747 : 305502 : tree result = DECL_TEMPLATE_RESULT (parm);
4748 : 305502 : TREE_TYPE (result) = t;
4749 : 305502 : tree args = template_parms_to_args (DECL_TEMPLATE_PARMS (parm));
4750 : 305502 : tree tinfo = build_template_info (parm, args);
4751 : 305502 : retrofit_lang_decl (result);
4752 : 305502 : DECL_TEMPLATE_INFO (result) = tinfo;
4753 : :
4754 : 305502 : decl = parm;
4755 : 305502 : }
4756 : : else
4757 : : {
4758 : 133402750 : t = cxx_make_type (TEMPLATE_TYPE_PARM);
4759 : : /* parm is either IDENTIFIER_NODE or NULL_TREE. */
4760 : 133402750 : decl = build_decl (parm_loc,
4761 : : TYPE_DECL, parm, t);
4762 : : }
4763 : :
4764 : 133708252 : TYPE_NAME (t) = decl;
4765 : 133708252 : TYPE_STUB_DECL (t) = decl;
4766 : 133708252 : parm = decl;
4767 : 133708252 : TEMPLATE_TYPE_PARM_INDEX (t)
4768 : 133708252 : = build_template_parm_index (idx, current_template_depth,
4769 : 133708252 : current_template_depth,
4770 : 133708252 : decl, TREE_TYPE (parm));
4771 : 133708252 : TEMPLATE_TYPE_PARAMETER_PACK (t) = is_parameter_pack;
4772 : 133708252 : TYPE_CANONICAL (t) = canonical_type_parameter (t);
4773 : : }
4774 : 145084005 : DECL_ARTIFICIAL (decl) = 1;
4775 : 145084005 : SET_DECL_TEMPLATE_PARM_P (decl);
4776 : :
4777 : 145084005 : if (TREE_CODE (parm) == TEMPLATE_DECL
4778 : 145084005 : && !uses_outer_template_parms (parm))
4779 : 305469 : TEMPLATE_TEMPLATE_PARM_SIMPLE_P (TREE_TYPE (parm)) = true;
4780 : :
4781 : : /* Build requirements for the type/template parameter.
4782 : : This must be done after SET_DECL_TEMPLATE_PARM_P or
4783 : : process_template_parm could fail. */
4784 : 145084005 : tree reqs = finish_shorthand_constraint (parm, constr);
4785 : :
4786 : 145084005 : decl = pushdecl (decl);
4787 : 145084005 : if (!is_non_type)
4788 : 133708252 : parm = decl;
4789 : :
4790 : : /* Build the parameter node linking the parameter declaration,
4791 : : its default argument (if any), and its constraints (if any). */
4792 : 145084005 : parm = build_tree_list (defval, parm);
4793 : 145084005 : TEMPLATE_PARM_CONSTRAINTS (parm) = reqs;
4794 : :
4795 : 145084005 : if (prev)
4796 : 68325686 : TREE_CHAIN (prev) = parm;
4797 : : else
4798 : : list = parm;
4799 : :
4800 : 145084005 : return list;
4801 : : }
4802 : :
4803 : : /* The end of a template parameter list has been reached. Process the
4804 : : tree list into a parameter vector, converting each parameter into a more
4805 : : useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
4806 : : as PARM_DECLs. */
4807 : :
4808 : : tree
4809 : 76546550 : end_template_parm_list (tree parms)
4810 : : {
4811 : 76546550 : tree saved_parmlist = make_tree_vec (list_length (parms));
4812 : :
4813 : : /* Pop the dummy parameter level and add the real one. We do not
4814 : : morph the dummy parameter in place, as it might have been
4815 : : captured by a (nested) template-template-parm. */
4816 : 76546550 : current_template_parms = TREE_CHAIN (current_template_parms);
4817 : :
4818 : 153093100 : current_template_parms
4819 : 76546550 : = tree_cons (size_int (current_template_depth + 1),
4820 : : saved_parmlist, current_template_parms);
4821 : :
4822 : 221281748 : for (unsigned ix = 0; parms; ix++)
4823 : : {
4824 : 144735198 : tree parm = parms;
4825 : 144735198 : parms = TREE_CHAIN (parms);
4826 : 144735198 : TREE_CHAIN (parm) = NULL_TREE;
4827 : :
4828 : 144735198 : TREE_VEC_ELT (saved_parmlist, ix) = parm;
4829 : : }
4830 : :
4831 : 76546550 : --processing_template_parmlist;
4832 : :
4833 : 76546550 : return saved_parmlist;
4834 : : }
4835 : :
4836 : : // Explicitly indicate the end of the template parameter list. We assume
4837 : : // that the current template parameters have been constructed and/or
4838 : : // managed explicitly, as when creating new template template parameters
4839 : : // from a shorthand constraint.
4840 : : void
4841 : 0 : end_template_parm_list ()
4842 : : {
4843 : 0 : --processing_template_parmlist;
4844 : 0 : }
4845 : :
4846 : : /* end_template_decl is called after a template declaration is seen. */
4847 : :
4848 : : void
4849 : 76758463 : end_template_decl (void)
4850 : : {
4851 : 76758463 : reset_specialization ();
4852 : :
4853 : 76758463 : if (! processing_template_decl)
4854 : : return;
4855 : :
4856 : : /* This matches the pushlevel in begin_template_parm_list. */
4857 : 76758463 : finish_scope ();
4858 : :
4859 : 76758463 : --processing_template_decl;
4860 : 76758463 : current_template_parms = TREE_CHAIN (current_template_parms);
4861 : : }
4862 : :
4863 : : /* Takes a TEMPLATE_PARM_P or DECL_TEMPLATE_PARM_P node or a TREE_LIST
4864 : : thereof, and converts it into an argument suitable to be passed to
4865 : : the type substitution functions. Note that if the TREE_LIST contains
4866 : : an error_mark node, the returned argument is error_mark_node. */
4867 : :
4868 : : tree
4869 : 693090809 : template_parm_to_arg (tree t)
4870 : : {
4871 : 693090809 : if (!t)
4872 : : return NULL_TREE;
4873 : :
4874 : 693090733 : if (TREE_CODE (t) == TREE_LIST)
4875 : 688128143 : t = TREE_VALUE (t);
4876 : :
4877 : 693090733 : if (error_operand_p (t))
4878 : 620 : return error_mark_node;
4879 : :
4880 : 693090113 : if (DECL_P (t) && DECL_TEMPLATE_PARM_P (t))
4881 : : {
4882 : 691756947 : if (TREE_CODE (t) == TYPE_DECL
4883 : 57529395 : || TREE_CODE (t) == TEMPLATE_DECL)
4884 : 634957925 : t = TREE_TYPE (t);
4885 : : else
4886 : 56799022 : t = DECL_INITIAL (t);
4887 : : }
4888 : :
4889 : 693090113 : gcc_assert (TEMPLATE_PARM_P (t));
4890 : :
4891 : 693090113 : if (TREE_CODE (t) == TEMPLATE_TYPE_PARM
4892 : 693090113 : || TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM)
4893 : : {
4894 : 636249218 : if (TEMPLATE_TYPE_PARAMETER_PACK (t))
4895 : : {
4896 : : /* Turn this argument into a TYPE_ARGUMENT_PACK
4897 : : with a single element, which expands T. */
4898 : 23666007 : tree vec = make_tree_vec (1);
4899 : 23666007 : if (CHECKING_P)
4900 : 23666007 : SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (vec, TREE_VEC_LENGTH (vec));
4901 : :
4902 : 23666007 : TREE_VEC_ELT (vec, 0) = make_pack_expansion (t);
4903 : :
4904 : 23666007 : t = cxx_make_type (TYPE_ARGUMENT_PACK);
4905 : 23666007 : ARGUMENT_PACK_ARGS (t) = vec;
4906 : : }
4907 : : }
4908 : : else
4909 : : {
4910 : 56840895 : if (TEMPLATE_PARM_PARAMETER_PACK (t))
4911 : : {
4912 : : /* Turn this argument into a NONTYPE_ARGUMENT_PACK
4913 : : with a single element, which expands T. */
4914 : 1385874 : tree vec = make_tree_vec (1);
4915 : 1385874 : if (CHECKING_P)
4916 : 1385874 : SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (vec, TREE_VEC_LENGTH (vec));
4917 : :
4918 : 1385874 : t = convert_from_reference (t);
4919 : 1385874 : TREE_VEC_ELT (vec, 0) = make_pack_expansion (t);
4920 : :
4921 : 1385874 : t = make_node (NONTYPE_ARGUMENT_PACK);
4922 : 1385874 : ARGUMENT_PACK_ARGS (t) = vec;
4923 : : }
4924 : : else
4925 : 55455021 : t = convert_from_reference (t);
4926 : : }
4927 : : return t;
4928 : : }
4929 : :
4930 : : /* If T looks like a generic template argument produced by template_parm_to_arg,
4931 : : return the corresponding template parameter, otherwise return NULL_TREE. */
4932 : :
4933 : : static tree
4934 : 1313562952 : template_arg_to_parm (tree t)
4935 : : {
4936 : 1313562952 : if (t == NULL_TREE)
4937 : : return NULL_TREE;
4938 : :
4939 : 1313562952 : if (ARGUMENT_PACK_P (t))
4940 : : {
4941 : 138490604 : tree args = ARGUMENT_PACK_ARGS (t);
4942 : 138490604 : if (TREE_VEC_LENGTH (args) == 1
4943 : 138490604 : && PACK_EXPANSION_P (TREE_VEC_ELT (args, 0)))
4944 : 58596311 : t = PACK_EXPANSION_PATTERN (TREE_VEC_ELT (args, 0));
4945 : : }
4946 : :
4947 : 1313562952 : if (REFERENCE_REF_P (t))
4948 : 413 : t = TREE_OPERAND (t, 0);
4949 : :
4950 : 1313562952 : if (TEMPLATE_PARM_P (t))
4951 : : return t;
4952 : : else
4953 : 312413428 : return NULL_TREE;
4954 : : }
4955 : :
4956 : : /* Given a single level of template parameters (a TREE_VEC), return it
4957 : : as a set of template arguments. */
4958 : :
4959 : : tree
4960 : 329621821 : template_parms_level_to_args (tree parms)
4961 : : {
4962 : 329621821 : parms = copy_node (parms);
4963 : 329621821 : TREE_TYPE (parms) = NULL_TREE;
4964 : 1016291696 : for (tree& parm : tree_vec_range (parms))
4965 : 686669875 : parm = template_parm_to_arg (parm);
4966 : :
4967 : 329621821 : if (CHECKING_P)
4968 : 329621821 : SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (parms, TREE_VEC_LENGTH (parms));
4969 : :
4970 : 329621821 : return parms;
4971 : : }
4972 : :
4973 : : /* Given a set of template parameters, return them as a set of template
4974 : : arguments. The template parameters are represented as a TREE_VEC, in
4975 : : the form documented in cp-tree.h for template arguments. */
4976 : :
4977 : : tree
4978 : 268910261 : template_parms_to_args (tree parms)
4979 : : {
4980 : 268910261 : tree header;
4981 : 268910261 : tree args = NULL_TREE;
4982 : 268910261 : int length = TMPL_PARMS_DEPTH (parms);
4983 : 268910261 : int l = length;
4984 : :
4985 : : /* If there is only one level of template parameters, we do not
4986 : : create a TREE_VEC of TREE_VECs. Instead, we return a single
4987 : : TREE_VEC containing the arguments. */
4988 : 268910261 : if (length > 1)
4989 : 42248310 : args = make_tree_vec (length);
4990 : :
4991 : 580588711 : for (header = parms; header; header = TREE_CHAIN (header))
4992 : : {
4993 : 311678450 : tree a = template_parms_level_to_args (TREE_VALUE (header));
4994 : :
4995 : 311678450 : if (length > 1)
4996 : 85016499 : TREE_VEC_ELT (args, --l) = a;
4997 : : else
4998 : : args = a;
4999 : : }
5000 : :
5001 : 268910261 : return args;
5002 : : }
5003 : :
5004 : : /* Within the declaration of a template, return the currently active
5005 : : template parameters as an argument TREE_VEC. */
5006 : :
5007 : : static tree
5008 : 268234424 : current_template_args (void)
5009 : : {
5010 : 0 : return template_parms_to_args (current_template_parms);
5011 : : }
5012 : :
5013 : : /* Return the fully generic arguments for of TMPL, i.e. what
5014 : : current_template_args would be while parsing it. */
5015 : :
5016 : : tree
5017 : 18862098 : generic_targs_for (tree tmpl)
5018 : : {
5019 : 18862098 : if (tmpl == NULL_TREE)
5020 : : return NULL_TREE;
5021 : 18862098 : if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl)
5022 : 37724196 : || DECL_TEMPLATE_SPECIALIZATION (tmpl))
5023 : : /* DECL_TEMPLATE_RESULT doesn't have the arguments we want. For a template
5024 : : template parameter, it has no TEMPLATE_INFO; for a partial
5025 : : specialization, it has the arguments for the primary template, and we
5026 : : want the arguments for the partial specialization. */;
5027 : 18767962 : else if (tree result = DECL_TEMPLATE_RESULT (tmpl))
5028 : 18767962 : if (tree ti = get_template_info (result))
5029 : 18767962 : return TI_ARGS (ti);
5030 : 94136 : return template_parms_to_args (DECL_TEMPLATE_PARMS (tmpl));
5031 : : }
5032 : :
5033 : : /* Return the template arguments corresponding to the template parameters of
5034 : : DECL's enclosing scope. When DECL is a member of a partial specialization,
5035 : : this returns the arguments for the partial specialization as opposed to those
5036 : : for the primary template, which is the main difference between this function
5037 : : and simply using e.g. the TYPE_TI_ARGS of DECL's DECL_CONTEXT. */
5038 : :
5039 : : tree
5040 : 66813 : outer_template_args (const_tree decl)
5041 : : {
5042 : 66813 : if (TREE_CODE (decl) == TEMPLATE_DECL)
5043 : 5692 : decl = DECL_TEMPLATE_RESULT (decl);
5044 : 66813 : tree ti = get_template_info (decl);
5045 : 66813 : if (!ti)
5046 : : return NULL_TREE;
5047 : 66813 : tree args = TI_ARGS (ti);
5048 : 66813 : if (!PRIMARY_TEMPLATE_P (TI_TEMPLATE (ti)))
5049 : : return args;
5050 : 133626 : if (TMPL_ARGS_DEPTH (args) == 1)
5051 : : return NULL_TREE;
5052 : 61221 : return strip_innermost_template_args (args, 1);
5053 : : }
5054 : :
5055 : : /* Update the declared TYPE by doing any lookups which were thought to be
5056 : : dependent, but are not now that we know the SCOPE of the declarator. */
5057 : :
5058 : : tree
5059 : 154439580 : maybe_update_decl_type (tree orig_type, tree scope)
5060 : : {
5061 : 154439580 : tree type = orig_type;
5062 : :
5063 : 154439580 : if (type == NULL_TREE)
5064 : : return type;
5065 : :
5066 : 147115845 : if (TREE_CODE (orig_type) == TYPE_DECL)
5067 : 68919959 : type = TREE_TYPE (type);
5068 : :
5069 : 7801567 : if (scope && TYPE_P (scope) && dependent_type_p (scope)
5070 : 6688636 : && dependent_type_p (type)
5071 : : /* Don't bother building up the args in this case. */
5072 : 150429539 : && TREE_CODE (type) != TEMPLATE_TYPE_PARM)
5073 : : {
5074 : : /* tsubst in the args corresponding to the template parameters,
5075 : : including auto if present. Most things will be unchanged, but
5076 : : make_typename_type and tsubst_qualified_id will resolve
5077 : : TYPENAME_TYPEs and SCOPE_REFs that were previously dependent. */
5078 : 2400248 : tree args = current_template_args ();
5079 : 2400248 : tree auto_node = type_uses_auto (type);
5080 : 2400248 : tree pushed;
5081 : 2400248 : if (auto_node)
5082 : : {
5083 : 0 : tree auto_vec = make_tree_vec (1);
5084 : 0 : TREE_VEC_ELT (auto_vec, 0) = auto_node;
5085 : 0 : args = add_to_template_args (args, auto_vec);
5086 : : }
5087 : 2400248 : pushed = push_scope (scope);
5088 : 2400248 : type = tsubst (type, args, tf_warning_or_error, NULL_TREE);
5089 : 2400248 : if (pushed)
5090 : 2400245 : pop_scope (scope);
5091 : : }
5092 : :
5093 : 147115845 : if (type == error_mark_node)
5094 : : return orig_type;
5095 : :
5096 : 147115151 : if (TREE_CODE (orig_type) == TYPE_DECL)
5097 : : {
5098 : 68919926 : if (same_type_p (type, TREE_TYPE (orig_type)))
5099 : : type = orig_type;
5100 : : else
5101 : 67905 : type = TYPE_NAME (type);
5102 : : }
5103 : : return type;
5104 : : }
5105 : :
5106 : : /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
5107 : : template PARMS and constraints, CONSTR. If MEMBER_TEMPLATE_P is true,
5108 : : the new template is a member template. */
5109 : :
5110 : : static tree
5111 : 153337463 : build_template_decl (tree decl, tree parms, bool member_template_p)
5112 : : {
5113 : 153337463 : gcc_checking_assert (TREE_CODE (decl) != TEMPLATE_DECL);
5114 : :
5115 : 153337463 : tree tmpl = build_lang_decl (TEMPLATE_DECL, DECL_NAME (decl), NULL_TREE);
5116 : 153337463 : SET_DECL_LANGUAGE (tmpl, DECL_LANGUAGE (decl));
5117 : 153337463 : DECL_TEMPLATE_PARMS (tmpl) = parms;
5118 : 153337463 : DECL_TEMPLATE_RESULT (tmpl) = decl;
5119 : 153337463 : DECL_CONTEXT (tmpl) = DECL_CONTEXT (decl);
5120 : 153337463 : TREE_TYPE (tmpl) = TREE_TYPE (decl);
5121 : 153337463 : DECL_SOURCE_LOCATION (tmpl) = DECL_SOURCE_LOCATION (decl);
5122 : 153337463 : DECL_MEMBER_TEMPLATE_P (tmpl) = member_template_p;
5123 : :
5124 : : /* Propagate module information from the decl. */
5125 : 153337463 : DECL_MODULE_EXPORT_P (tmpl) = DECL_MODULE_EXPORT_P (decl);
5126 : :
5127 : 153337463 : return tmpl;
5128 : : }
5129 : :
5130 : : struct template_parm_data
5131 : : {
5132 : : /* The level of the template parameters we are currently
5133 : : processing. */
5134 : : int level;
5135 : :
5136 : : /* The index of the specialization argument we are currently
5137 : : processing. */
5138 : : int current_arg;
5139 : :
5140 : : /* An array whose size is the number of template parameters. The
5141 : : elements are nonzero if the parameter has been used in any one
5142 : : of the arguments processed so far. */
5143 : : int* parms;
5144 : :
5145 : : /* An array whose size is the number of template arguments. The
5146 : : elements are nonzero if the argument makes use of template
5147 : : parameters of this level. */
5148 : : int* arg_uses_template_parms;
5149 : : };
5150 : :
5151 : : /* Subroutine of push_template_decl used to see if each template
5152 : : parameter in a partial specialization is used in the explicit
5153 : : argument list. If T is of the LEVEL given in DATA (which is
5154 : : treated as a template_parm_data*), then DATA->PARMS is marked
5155 : : appropriately. */
5156 : :
5157 : : static int
5158 : 13958292 : mark_template_parm (tree t, void* data)
5159 : : {
5160 : 13958292 : int level;
5161 : 13958292 : int idx;
5162 : 13958292 : struct template_parm_data* tpd = (struct template_parm_data*) data;
5163 : :
5164 : 13958292 : template_parm_level_and_index (t, &level, &idx);
5165 : :
5166 : 13958292 : if (level == tpd->level)
5167 : : {
5168 : 13936862 : tpd->parms[idx] = 1;
5169 : 13936862 : tpd->arg_uses_template_parms[tpd->current_arg] = 1;
5170 : : }
5171 : :
5172 : : /* In C++17 the type of a non-type argument is a deduced context. */
5173 : 13958292 : if (cxx_dialect >= cxx17
5174 : 13839318 : && TREE_CODE (t) == TEMPLATE_PARM_INDEX)
5175 : 1757589 : for_each_template_parm (TREE_TYPE (t),
5176 : : &mark_template_parm,
5177 : : data,
5178 : : NULL,
5179 : : /*include_nondeduced_p=*/false);
5180 : :
5181 : : /* Return zero so that for_each_template_parm will continue the
5182 : : traversal of the tree; we want to mark *every* template parm. */
5183 : 13958292 : return 0;
5184 : : }
5185 : :
5186 : : /* Process the partial specialization DECL. */
5187 : :
5188 : : static tree
5189 : 6821770 : process_partial_specialization (tree decl)
5190 : : {
5191 : 6821770 : tree type = TREE_TYPE (decl);
5192 : 6821770 : tree tinfo = get_template_info (decl);
5193 : 6821770 : tree maintmpl = TI_TEMPLATE (tinfo);
5194 : 6821770 : tree specargs = TI_ARGS (tinfo);
5195 : 6821770 : tree inner_args = INNERMOST_TEMPLATE_ARGS (specargs);
5196 : 6821770 : tree main_inner_parms = DECL_INNERMOST_TEMPLATE_PARMS (maintmpl);
5197 : 6821770 : tree inner_parms;
5198 : 6821770 : tree inst;
5199 : 6821770 : int nargs = TREE_VEC_LENGTH (inner_args);
5200 : 6821770 : int ntparms;
5201 : 6821770 : int i;
5202 : 6821770 : struct template_parm_data tpd;
5203 : 6821770 : struct template_parm_data tpd2;
5204 : :
5205 : 6821770 : gcc_assert (current_template_parms);
5206 : :
5207 : 6821770 : inner_parms = INNERMOST_TEMPLATE_PARMS (current_template_parms);
5208 : 6821770 : ntparms = TREE_VEC_LENGTH (inner_parms);
5209 : :
5210 : : /* We check that each of the template parameters given in the
5211 : : partial specialization is used in the argument list to the
5212 : : specialization. For example:
5213 : :
5214 : : template <class T> struct S;
5215 : : template <class T> struct S<T*>;
5216 : :
5217 : : The second declaration is OK because `T*' uses the template
5218 : : parameter T, whereas
5219 : :
5220 : : template <class T> struct S<int>;
5221 : :
5222 : : is no good. Even trickier is:
5223 : :
5224 : : template <class T>
5225 : : struct S1
5226 : : {
5227 : : template <class U>
5228 : : struct S2;
5229 : : template <class U>
5230 : : struct S2<T>;
5231 : : };
5232 : :
5233 : : The S2<T> declaration is actually invalid; it is a
5234 : : full-specialization. Of course,
5235 : :
5236 : : template <class U>
5237 : : struct S2<T (*)(U)>;
5238 : :
5239 : : or some such would have been OK. */
5240 : 6821770 : tpd.level = TMPL_PARMS_DEPTH (current_template_parms);
5241 : 6821770 : tpd.parms = XALLOCAVEC (int, ntparms);
5242 : 6821770 : memset (tpd.parms, 0, sizeof (int) * ntparms);
5243 : :
5244 : 6821770 : tpd.arg_uses_template_parms = XALLOCAVEC (int, nargs);
5245 : 6821770 : memset (tpd.arg_uses_template_parms, 0, sizeof (int) * nargs);
5246 : 20956747 : for (i = 0; i < nargs; ++i)
5247 : : {
5248 : 14134977 : tpd.current_arg = i;
5249 : 14134977 : for_each_template_parm (TREE_VEC_ELT (inner_args, i),
5250 : : &mark_template_parm,
5251 : : &tpd,
5252 : : NULL,
5253 : : /*include_nondeduced_p=*/false);
5254 : : }
5255 : :
5256 : 6821770 : {
5257 : 6821770 : auto_diagnostic_group d;
5258 : 6821770 : bool did_error_intro = false;
5259 : 26624683 : for (i = 0; i < ntparms; ++i)
5260 : 12981143 : if (tpd.parms[i] == 0)
5261 : : {
5262 : : /* One of the template parms was not used in a deduced context in the
5263 : : specialization. */
5264 : 50 : if (!did_error_intro)
5265 : : {
5266 : 50 : error ("template parameters not deducible in "
5267 : : "partial specialization:");
5268 : 50 : did_error_intro = true;
5269 : : }
5270 : :
5271 : 100 : inform (input_location, " %qD",
5272 : 50 : TREE_VALUE (TREE_VEC_ELT (inner_parms, i)));
5273 : : }
5274 : :
5275 : 6821770 : if (did_error_intro)
5276 : 50 : return error_mark_node;
5277 : 6821770 : }
5278 : :
5279 : : /* [temp.class.spec]
5280 : :
5281 : : The argument list of the specialization shall not be identical to
5282 : : the implicit argument list of the primary template. */
5283 : 6821720 : tree main_args
5284 : 6821720 : = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (maintmpl)));
5285 : 6821720 : if (comp_template_args (inner_args, INNERMOST_TEMPLATE_ARGS (main_args))
5286 : 6821720 : && (!flag_concepts
5287 : 155511 : || !strictly_subsumes (current_template_constraints (), maintmpl)))
5288 : : {
5289 : 21 : auto_diagnostic_group d;
5290 : 21 : if (!flag_concepts)
5291 : 8 : error ("partial specialization %q+D does not specialize "
5292 : : "any template arguments; to define the primary template, "
5293 : : "remove the template argument list", decl);
5294 : : else
5295 : 13 : error ("partial specialization %q+D does not specialize any "
5296 : : "template arguments and is not more constrained than "
5297 : : "the primary template; to define the primary template, "
5298 : : "remove the template argument list", decl);
5299 : 21 : inform (DECL_SOURCE_LOCATION (maintmpl), "primary template here");
5300 : 21 : }
5301 : :
5302 : : /* A partial specialization that replaces multiple parameters of the
5303 : : primary template with a pack expansion is less specialized for those
5304 : : parameters. */
5305 : 6821720 : if (nargs < DECL_NTPARMS (maintmpl))
5306 : : {
5307 : 3 : auto_diagnostic_group d;
5308 : 3 : error ("partial specialization is not more specialized than the "
5309 : : "primary template because it replaces multiple parameters "
5310 : : "with a pack expansion");
5311 : 3 : inform (DECL_SOURCE_LOCATION (maintmpl), "primary template here");
5312 : : /* Avoid crash in process_partial_specialization. */
5313 : 3 : return decl;
5314 : 3 : }
5315 : :
5316 : 6821717 : else if (nargs > DECL_NTPARMS (maintmpl))
5317 : : {
5318 : 5 : auto_diagnostic_group d;
5319 : 5 : error ("too many arguments for partial specialization %qT", type);
5320 : 5 : inform (DECL_SOURCE_LOCATION (maintmpl), "primary template here");
5321 : : /* Avoid crash below. */
5322 : 5 : return decl;
5323 : 5 : }
5324 : :
5325 : : /* If we aren't in a dependent class, we can actually try deduction. */
5326 : 6821712 : else if (tpd.level == 1
5327 : : /* FIXME we should be able to handle a partial specialization of a
5328 : : partial instantiation, but currently we can't (c++/41727). */
5329 : 13049980 : && TMPL_ARGS_DEPTH (specargs) == 1
5330 : 13346696 : && !get_partial_spec_bindings (maintmpl, maintmpl, specargs))
5331 : : {
5332 : 17 : auto_diagnostic_group d;
5333 : 17 : if (pedwarn (input_location, 0,
5334 : : "partial specialization %qD is not more specialized than",
5335 : : decl))
5336 : 17 : inform (DECL_SOURCE_LOCATION (maintmpl), "primary template %qD",
5337 : : maintmpl);
5338 : 17 : }
5339 : :
5340 : : /* [temp.spec.partial]
5341 : :
5342 : : The type of a template parameter corresponding to a specialized
5343 : : non-type argument shall not be dependent on a parameter of the
5344 : : specialization.
5345 : :
5346 : : Also, we verify that pack expansions only occur at the
5347 : : end of the argument list. */
5348 : 6821712 : tpd2.parms = 0;
5349 : 20956605 : for (i = 0; i < nargs; ++i)
5350 : : {
5351 : 14134893 : tree parm = TREE_VALUE (TREE_VEC_ELT (main_inner_parms, i));
5352 : 14134893 : tree arg = TREE_VEC_ELT (inner_args, i);
5353 : 14134893 : tree packed_args = NULL_TREE;
5354 : 14134893 : int j, len = 1;
5355 : :
5356 : 14134893 : if (ARGUMENT_PACK_P (arg))
5357 : : {
5358 : : /* Extract the arguments from the argument pack. We'll be
5359 : : iterating over these in the following loop. */
5360 : 710577 : packed_args = ARGUMENT_PACK_ARGS (arg);
5361 : 710577 : len = TREE_VEC_LENGTH (packed_args);
5362 : : }
5363 : :
5364 : 28586893 : for (j = 0; j < len; j++)
5365 : : {
5366 : 14452000 : if (packed_args)
5367 : : /* Get the Jth argument in the parameter pack. */
5368 : 1027684 : arg = TREE_VEC_ELT (packed_args, j);
5369 : :
5370 : 14452000 : if (PACK_EXPANSION_P (arg))
5371 : : {
5372 : : /* Pack expansions must come at the end of the
5373 : : argument list. */
5374 : 425786 : if ((packed_args && j < len - 1)
5375 : 6 : || (!packed_args && i < nargs - 1))
5376 : : {
5377 : 12 : if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
5378 : 6 : error ("parameter pack argument %qE must be at the "
5379 : : "end of the template argument list", arg);
5380 : : else
5381 : 6 : error ("parameter pack argument %qT must be at the "
5382 : : "end of the template argument list", arg);
5383 : : }
5384 : : }
5385 : :
5386 : 14452000 : if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
5387 : : /* We only care about the pattern. */
5388 : 68472 : arg = PACK_EXPANSION_PATTERN (arg);
5389 : :
5390 : 14452000 : if (/* These first two lines are the `non-type' bit. */
5391 : 14452000 : !TYPE_P (arg)
5392 : 4244570 : && TREE_CODE (arg) != TEMPLATE_DECL
5393 : : /* This next two lines are the `argument expression is not just a
5394 : : simple identifier' condition and also the `specialized
5395 : : non-type argument' bit. */
5396 : 3983781 : && TREE_CODE (arg) != TEMPLATE_PARM_INDEX
5397 : 17226168 : && !((REFERENCE_REF_P (arg)
5398 : 2774144 : || TREE_CODE (arg) == VIEW_CONVERT_EXPR)
5399 : 36 : && TREE_CODE (TREE_OPERAND (arg, 0)) == TEMPLATE_PARM_INDEX))
5400 : : {
5401 : : /* Look at the corresponding template parameter,
5402 : : marking which template parameters its type depends
5403 : : upon. */
5404 : 2774135 : tree type = TREE_TYPE (parm);
5405 : :
5406 : 2774135 : if (!tpd2.parms)
5407 : : {
5408 : : /* We haven't yet initialized TPD2. Do so now. */
5409 : 1732400 : tpd2.arg_uses_template_parms = XALLOCAVEC (int, nargs);
5410 : : /* The number of parameters here is the number in the
5411 : : main template, which, as checked in the assertion
5412 : : above, is NARGS. */
5413 : 1732400 : tpd2.parms = XALLOCAVEC (int, nargs);
5414 : 1732400 : tpd2.level =
5415 : 1732400 : TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl));
5416 : : }
5417 : :
5418 : : /* Mark the template parameters. But this time, we're
5419 : : looking for the template parameters of the main
5420 : : template, not in the specialization. */
5421 : 2774135 : tpd2.current_arg = i;
5422 : 2774135 : tpd2.arg_uses_template_parms[i] = 0;
5423 : 2774135 : memset (tpd2.parms, 0, sizeof (int) * nargs);
5424 : 2774135 : for_each_template_parm (type,
5425 : : &mark_template_parm,
5426 : : &tpd2,
5427 : : NULL,
5428 : : /*include_nondeduced_p=*/false);
5429 : :
5430 : 2774135 : if (tpd2.arg_uses_template_parms [i])
5431 : : {
5432 : : /* The type depended on some template parameters.
5433 : : If they are fully specialized in the
5434 : : specialization, that's OK. */
5435 : : int j;
5436 : : int count = 0;
5437 : 78 : for (j = 0; j < nargs; ++j)
5438 : 54 : if (tpd2.parms[j] != 0
5439 : 24 : && tpd.arg_uses_template_parms [j])
5440 : 18 : ++count;
5441 : 24 : if (count != 0)
5442 : 18 : error_n (input_location, count,
5443 : : "type %qT of template argument %qE depends "
5444 : : "on a template parameter",
5445 : : "type %qT of template argument %qE depends "
5446 : : "on template parameters",
5447 : : type,
5448 : : arg);
5449 : : }
5450 : : }
5451 : : }
5452 : : }
5453 : :
5454 : : /* We should only get here once. */
5455 : 6821712 : if (TREE_CODE (decl) == TYPE_DECL)
5456 : 6202144 : gcc_assert (!COMPLETE_TYPE_P (type));
5457 : :
5458 : : // Build the template decl.
5459 : 6821712 : tree tmpl = build_template_decl (decl, current_template_parms,
5460 : 6821712 : DECL_MEMBER_TEMPLATE_P (maintmpl));
5461 : 6821712 : SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
5462 : 6821712 : DECL_TEMPLATE_INFO (tmpl) = build_template_info (maintmpl, specargs);
5463 : 6821712 : DECL_PRIMARY_TEMPLATE (tmpl) = maintmpl;
5464 : :
5465 : : /* Give template template parms a DECL_CONTEXT of the template
5466 : : for which they are a parameter. */
5467 : 19802785 : for (i = 0; i < ntparms; ++i)
5468 : : {
5469 : 12981073 : tree parm = TREE_VALUE (TREE_VEC_ELT (inner_parms, i));
5470 : 12981073 : if (TREE_CODE (parm) == TEMPLATE_DECL)
5471 : 110156 : DECL_CONTEXT (parm) = tmpl;
5472 : : }
5473 : :
5474 : 6821712 : if (VAR_P (decl))
5475 : : {
5476 : : /* We didn't register this in check_explicit_specialization so we could
5477 : : wait until the constraints were set. */
5478 : 619568 : tree reg = register_specialization (decl, maintmpl, specargs, false, 0);
5479 : 619568 : if (reg != decl)
5480 : : /* Redeclaration. */
5481 : : return reg;
5482 : : }
5483 : : else
5484 : 6202144 : associate_classtype_constraints (type);
5485 : :
5486 : 13643406 : DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)
5487 : 6821703 : = tree_cons (specargs, tmpl,
5488 : 6821703 : DECL_TEMPLATE_SPECIALIZATIONS (maintmpl));
5489 : 6821703 : TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)) = type;
5490 : : /* Link the DECL_TEMPLATE_RESULT back to the partial TEMPLATE_DECL. */
5491 : 6821703 : gcc_checking_assert (!TI_PARTIAL_INFO (tinfo));
5492 : 6821703 : TI_PARTIAL_INFO (tinfo) = build_template_info (tmpl, NULL_TREE);
5493 : :
5494 : 6821703 : set_defining_module_for_partial_spec (decl);
5495 : :
5496 : 48808689 : for (inst = DECL_TEMPLATE_INSTANTIATIONS (maintmpl); inst;
5497 : 41986986 : inst = TREE_CHAIN (inst))
5498 : : {
5499 : 41986986 : tree instance = TREE_VALUE (inst);
5500 : 43531210 : if (TYPE_P (instance)
5501 : 41986986 : ? (COMPLETE_TYPE_P (instance)
5502 : 40442762 : && CLASSTYPE_IMPLICIT_INSTANTIATION (instance))
5503 : 1544224 : : DECL_TEMPLATE_INSTANTIATION (instance))
5504 : : {
5505 : 95861 : tree partial_ti = most_specialized_partial_spec (instance, tf_none,
5506 : : /*rechecking=*/true);
5507 : 95861 : tree inst_decl = (DECL_P (instance)
5508 : 95861 : ? instance : TYPE_NAME (instance));
5509 : 95861 : if (!partial_ti)
5510 : : /* OK */;
5511 : 47819 : else if (partial_ti == error_mark_node)
5512 : 3 : permerror (input_location,
5513 : : "declaration of %qD ambiguates earlier template "
5514 : : "instantiation for %qD", decl, inst_decl);
5515 : 47816 : else if (TI_TEMPLATE (partial_ti) == tmpl)
5516 : 6 : permerror (input_location,
5517 : : "partial specialization of %qD after instantiation "
5518 : : "of %qD", decl, inst_decl);
5519 : : }
5520 : : }
5521 : :
5522 : : return decl;
5523 : : }
5524 : :
5525 : : /* PARM is a template parameter of some form; return the corresponding
5526 : : TEMPLATE_PARM_INDEX. */
5527 : :
5528 : : static tree
5529 : 288316869 : get_template_parm_index (tree parm)
5530 : : {
5531 : 288316869 : if (TREE_CODE (parm) == PARM_DECL
5532 : 288316869 : || TREE_CODE (parm) == CONST_DECL)
5533 : 137785078 : parm = DECL_INITIAL (parm);
5534 : 150531791 : else if (TREE_CODE (parm) == TYPE_DECL
5535 : 9239721 : || TREE_CODE (parm) == TEMPLATE_DECL)
5536 : 141296405 : parm = TREE_TYPE (parm);
5537 : 288316869 : if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
5538 : 139011900 : || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM
5539 : 139011837 : || TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM)
5540 : 149378522 : parm = TEMPLATE_TYPE_PARM_INDEX (parm);
5541 : 288316869 : gcc_assert (TREE_CODE (parm) == TEMPLATE_PARM_INDEX);
5542 : 288316869 : return parm;
5543 : : }
5544 : :
5545 : : /* Subroutine of fixed_parameter_pack_p below. Look for any template
5546 : : parameter packs used by the template parameter PARM. */
5547 : :
5548 : : static void
5549 : 863 : fixed_parameter_pack_p_1 (tree parm, struct find_parameter_pack_data *ppd)
5550 : : {
5551 : : /* A type parm can't refer to another parm. */
5552 : 863 : if (TREE_CODE (parm) == TYPE_DECL || parm == error_mark_node)
5553 : : return;
5554 : 848 : else if (TREE_CODE (parm) == PARM_DECL)
5555 : : {
5556 : 806 : cp_walk_tree (&TREE_TYPE (parm), &find_parameter_packs_r,
5557 : : ppd, ppd->visited);
5558 : 806 : return;
5559 : : }
5560 : :
5561 : 42 : gcc_assert (TREE_CODE (parm) == TEMPLATE_DECL);
5562 : :
5563 : 42 : tree vec = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (parm));
5564 : 93 : for (int i = 0; i < TREE_VEC_LENGTH (vec); ++i)
5565 : : {
5566 : 51 : tree p = TREE_VALUE (TREE_VEC_ELT (vec, i));
5567 : 51 : if (template_parameter_pack_p (p))
5568 : : /* Any packs in the type are expanded by this parameter. */;
5569 : : else
5570 : 33 : fixed_parameter_pack_p_1 (p, ppd);
5571 : : }
5572 : : }
5573 : :
5574 : : /* PARM is a template parameter pack. Return any parameter packs used in
5575 : : its type or the type of any of its template parameters. If there are
5576 : : any such packs, it will be instantiated into a fixed template parameter
5577 : : list by partial instantiation rather than be fully deduced. */
5578 : :
5579 : : tree
5580 : 145329498 : fixed_parameter_pack_p (tree parm)
5581 : : {
5582 : : /* This can only be true in a member template. */
5583 : 145329498 : if (TEMPLATE_PARM_ORIG_LEVEL (get_template_parm_index (parm)) < 2)
5584 : : return NULL_TREE;
5585 : : /* This can only be true for a parameter pack. */
5586 : 3009927 : if (!template_parameter_pack_p (parm))
5587 : : return NULL_TREE;
5588 : : /* A type parm can't refer to another parm. */
5589 : 3009927 : if (TREE_CODE (parm) == TYPE_DECL)
5590 : : return NULL_TREE;
5591 : :
5592 : 830 : tree parameter_packs = NULL_TREE;
5593 : 830 : struct find_parameter_pack_data ppd;
5594 : 830 : ppd.parameter_packs = ¶meter_packs;
5595 : 830 : ppd.visited = new hash_set<tree>;
5596 : :
5597 : 830 : fixed_parameter_pack_p_1 (parm, &ppd);
5598 : :
5599 : 1660 : delete ppd.visited;
5600 : 830 : return parameter_packs;
5601 : : }
5602 : :
5603 : : /* Check that a template declaration's use of default arguments and
5604 : : parameter packs is not invalid. Here, PARMS are the template
5605 : : parameters. IS_PRIMARY is true if DECL is the thing declared by
5606 : : a primary template. IS_PARTIAL is true if DECL is a partial
5607 : : specialization.
5608 : :
5609 : : IS_FRIEND_DECL is nonzero if DECL is either a non-defining friend
5610 : : function template declaration or a friend class template
5611 : : declaration. In the function case, 1 indicates a declaration, 2
5612 : : indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
5613 : : emitted for extraneous default arguments.
5614 : :
5615 : : Returns TRUE if there were no errors found, FALSE otherwise. */
5616 : :
5617 : : bool
5618 : 211145198 : check_default_tmpl_args (tree decl, tree parms, bool is_primary,
5619 : : bool is_partial, int is_friend_decl)
5620 : : {
5621 : 211145198 : const char *msg;
5622 : 211145198 : int last_level_to_check;
5623 : 211145198 : tree parm_level;
5624 : 211145198 : bool no_errors = true;
5625 : :
5626 : : /* [temp.param]
5627 : :
5628 : : A default template-argument shall not be specified in a
5629 : : function template declaration or a function template definition, nor
5630 : : in the template-parameter-list of the definition of a member of a
5631 : : class template. */
5632 : :
5633 : 211145198 : if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL
5634 : 211145198 : || (TREE_CODE (decl) == FUNCTION_DECL && DECL_LOCAL_DECL_P (decl)))
5635 : : /* You can't have a function template declaration in a local
5636 : : scope, nor you can you define a member of a class template in a
5637 : : local scope. */
5638 : : return true;
5639 : :
5640 : 210471143 : if ((TREE_CODE (decl) == TYPE_DECL
5641 : 54329383 : && TREE_TYPE (decl)
5642 : 93444343 : && LAMBDA_TYPE_P (TREE_TYPE (decl)))
5643 : 264300860 : || (TREE_CODE (decl) == FUNCTION_DECL
5644 : 158214736 : && LAMBDA_FUNCTION_P (decl)))
5645 : : /* A lambda doesn't have an explicit declaration; don't complain
5646 : : about the parms of the enclosing class. */
5647 : : return true;
5648 : :
5649 : 208956818 : if (current_class_type
5650 : 163660267 : && !TYPE_BEING_DEFINED (current_class_type)
5651 : 58606717 : && DECL_LANG_SPECIFIC (decl)
5652 : 58514853 : && DECL_DECLARES_FUNCTION_P (decl)
5653 : : /* If this is either a friend defined in the scope of the class
5654 : : or a member function. */
5655 : 120259441 : && (DECL_FUNCTION_MEMBER_P (decl)
5656 : 58209586 : ? same_type_p (DECL_CONTEXT (decl), current_class_type)
5657 : 0 : : DECL_FRIEND_CONTEXT (decl)
5658 : 0 : ? same_type_p (DECL_FRIEND_CONTEXT (decl), current_class_type)
5659 : : : false)
5660 : : /* And, if it was a member function, it really was defined in
5661 : : the scope of the class. */
5662 : 325375990 : && (!DECL_FUNCTION_MEMBER_P (decl)
5663 : 58209586 : || DECL_INITIALIZED_IN_CLASS_P (decl)))
5664 : : /* We already checked these parameters when the template was
5665 : : declared, so there's no need to do it again now. This function
5666 : : was defined in class scope, but we're processing its body now
5667 : : that the class is complete. */
5668 : : return true;
5669 : :
5670 : : /* Core issue 226 (C++0x only): the following only applies to class
5671 : : templates. */
5672 : 158001490 : if (is_primary
5673 : 64801912 : && ((cxx_dialect == cxx98) || TREE_CODE (decl) != FUNCTION_DECL))
5674 : : {
5675 : : /* [temp.param]
5676 : :
5677 : : If a template-parameter has a default template-argument, all
5678 : : subsequent template-parameters shall have a default
5679 : : template-argument supplied. */
5680 : 48370458 : for (parm_level = parms; parm_level; parm_level = TREE_CHAIN (parm_level))
5681 : : {
5682 : 25397243 : tree inner_parms = TREE_VALUE (parm_level);
5683 : 25397243 : int ntparms = TREE_VEC_LENGTH (inner_parms);
5684 : 25397243 : int seen_def_arg_p = 0;
5685 : 25397243 : int i;
5686 : :
5687 : 70227774 : for (i = 0; i < ntparms; ++i)
5688 : : {
5689 : 44830531 : tree parm = TREE_VEC_ELT (inner_parms, i);
5690 : :
5691 : 44830531 : if (parm == error_mark_node)
5692 : 0 : continue;
5693 : :
5694 : 44830531 : if (TREE_PURPOSE (parm))
5695 : : seen_def_arg_p = 1;
5696 : 40782172 : else if (seen_def_arg_p
5697 : 40782172 : && !template_parameter_pack_p (TREE_VALUE (parm)))
5698 : : {
5699 : 21 : error ("no default argument for %qD", TREE_VALUE (parm));
5700 : : /* For better subsequent error-recovery, we indicate that
5701 : : there should have been a default argument. */
5702 : 21 : TREE_PURPOSE (parm) = error_mark_node;
5703 : 21 : no_errors = false;
5704 : : }
5705 : 40782151 : else if (!is_partial
5706 : 40782151 : && !is_friend_decl
5707 : : /* Don't complain about an enclosing partial
5708 : : specialization. */
5709 : 25595563 : && parm_level == parms
5710 : 22782758 : && (TREE_CODE (decl) == TYPE_DECL || VAR_P (decl))
5711 : 21570560 : && i < ntparms - 1
5712 : 9267619 : && template_parameter_pack_p (TREE_VALUE (parm))
5713 : : /* A fixed parameter pack will be partially
5714 : : instantiated into a fixed length list. */
5715 : 40782190 : && !fixed_parameter_pack_p (TREE_VALUE (parm)))
5716 : : {
5717 : : /* A primary class template, primary variable template
5718 : : (DR 2032), or alias template can only have one
5719 : : parameter pack, at the end of the template
5720 : : parameter list. */
5721 : :
5722 : 24 : error ("parameter pack %q+D must be at the end of the"
5723 : 24 : " template parameter list", TREE_VALUE (parm));
5724 : :
5725 : 24 : TREE_VALUE (TREE_VEC_ELT (inner_parms, i))
5726 : 24 : = error_mark_node;
5727 : 24 : no_errors = false;
5728 : : }
5729 : : }
5730 : : }
5731 : : }
5732 : :
5733 : 158001490 : if (((cxx_dialect == cxx98) && TREE_CODE (decl) != TYPE_DECL)
5734 : : || is_partial
5735 : 157613017 : || !is_primary
5736 : 57845676 : || is_friend_decl)
5737 : : /* For an ordinary class template, default template arguments are
5738 : : allowed at the innermost level, e.g.:
5739 : : template <class T = int>
5740 : : struct S {};
5741 : : but, in a partial specialization, they're not allowed even
5742 : : there, as we have in [temp.class.spec]:
5743 : :
5744 : : The template parameter list of a specialization shall not
5745 : : contain default template argument values.
5746 : :
5747 : : So, for a partial specialization, or for a function template
5748 : : (in C++98/C++03), we look at all of them. */
5749 : : ;
5750 : : else
5751 : : /* But, for a primary class template that is not a partial
5752 : : specialization we look at all template parameters except the
5753 : : innermost ones. */
5754 : 56318551 : parms = TREE_CHAIN (parms);
5755 : :
5756 : : /* Figure out what error message to issue. */
5757 : 158001490 : if (is_friend_decl == 2)
5758 : : msg = G_("default template arguments may not be used in function template "
5759 : : "friend re-declaration");
5760 : 157794776 : else if (is_friend_decl)
5761 : : msg = G_("default template arguments may not be used in template "
5762 : : "friend declarations");
5763 : 156474365 : else if (TREE_CODE (decl) == FUNCTION_DECL && (cxx_dialect == cxx98))
5764 : : msg = G_("default template arguments may not be used in function templates "
5765 : : "without %<-std=c++11%> or %<-std=gnu++11%>");
5766 : 156097350 : else if (is_partial)
5767 : : msg = G_("default template arguments may not be used in "
5768 : : "partial specializations");
5769 : 149275544 : else if (current_class_type && CLASSTYPE_IS_TEMPLATE (current_class_type))
5770 : : msg = G_("default argument for template parameter for class enclosing %qD");
5771 : : else
5772 : : /* Per [temp.param]/9, "A default template-argument shall not be
5773 : : specified in the template-parameter-lists of the definition of
5774 : : a member of a class template that appears outside of the member's
5775 : : class.", thus if we aren't handling a member of a class template
5776 : : there is no need to examine the parameters. */
5777 : : return true;
5778 : :
5779 : 90226519 : if (current_class_type && TYPE_BEING_DEFINED (current_class_type))
5780 : : /* If we're inside a class definition, there's no need to
5781 : : examine the parameters to the class itself. On the one
5782 : : hand, they will be checked when the class is defined, and,
5783 : : on the other, default arguments are valid in things like:
5784 : : template <class T = double>
5785 : : struct S { template <class U> void f(U); };
5786 : : Here the default argument for `S' has no bearing on the
5787 : : declaration of `f'. */
5788 : 76477056 : last_level_to_check = template_class_depth (current_class_type) + 1;
5789 : : else
5790 : : /* Check everything. */
5791 : : last_level_to_check = 0;
5792 : :
5793 : 90226519 : for (parm_level = parms;
5794 : 201366659 : parm_level && TMPL_PARMS_DEPTH (parm_level) >= last_level_to_check;
5795 : 17571352 : parm_level = TREE_CHAIN (parm_level))
5796 : : {
5797 : 17571355 : tree inner_parms = TREE_VALUE (parm_level);
5798 : 17571355 : int i;
5799 : 17571355 : int ntparms;
5800 : :
5801 : 17571355 : ntparms = TREE_VEC_LENGTH (inner_parms);
5802 : 54811428 : for (i = 0; i < ntparms; ++i)
5803 : : {
5804 : 37240076 : if (TREE_VEC_ELT (inner_parms, i) == error_mark_node)
5805 : 0 : continue;
5806 : :
5807 : 37240076 : if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)))
5808 : : {
5809 : 30 : if (msg)
5810 : : {
5811 : 30 : no_errors = false;
5812 : 30 : if (is_friend_decl == 2)
5813 : : return no_errors;
5814 : :
5815 : 27 : error (msg, decl);
5816 : 27 : msg = 0;
5817 : : }
5818 : :
5819 : : /* Clear out the default argument so that we are not
5820 : : confused later. */
5821 : 27 : TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)) = NULL_TREE;
5822 : : }
5823 : : }
5824 : :
5825 : : /* At this point, if we're still interested in issuing messages,
5826 : : they must apply to classes surrounding the object declared. */
5827 : 17571352 : if (msg)
5828 : 17571324 : msg = G_("default argument for template parameter for class "
5829 : : "enclosing %qD");
5830 : : }
5831 : :
5832 : : return no_errors;
5833 : : }
5834 : :
5835 : : /* Worker for push_template_decl_real, called via
5836 : : for_each_template_parm. DATA is really an int, indicating the
5837 : : level of the parameters we are interested in. If T is a template
5838 : : parameter of that level, return nonzero. */
5839 : :
5840 : : static int
5841 : 1841791 : template_parm_this_level_p (tree t, void* data)
5842 : : {
5843 : 1841791 : int this_level = *(int *)data;
5844 : 1841791 : int level;
5845 : :
5846 : 1841791 : if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
5847 : 310582 : level = TEMPLATE_PARM_LEVEL (t);
5848 : : else
5849 : 1531209 : level = TEMPLATE_TYPE_LEVEL (t);
5850 : 1841791 : return level == this_level;
5851 : : }
5852 : :
5853 : : /* Worker for uses_outer_template_parms, called via for_each_template_parm.
5854 : : DATA is really an int, indicating the innermost outer level of parameters.
5855 : : If T is a template parameter of that level or further out, return
5856 : : nonzero. */
5857 : :
5858 : : static int
5859 : 8850256 : template_parm_outer_level (tree t, void *data)
5860 : : {
5861 : 8850256 : int this_level = *(int *)data;
5862 : 8850256 : int level;
5863 : :
5864 : 8850256 : if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
5865 : 247979 : level = TEMPLATE_PARM_LEVEL (t);
5866 : : else
5867 : 8602277 : level = TEMPLATE_TYPE_LEVEL (t);
5868 : 8850256 : return level <= this_level;
5869 : : }
5870 : :
5871 : : /* Creates a TEMPLATE_DECL for the indicated DECL using the template
5872 : : parameters given by current_template_args, or reuses a
5873 : : previously existing one, if appropriate. Returns the DECL, or an
5874 : : equivalent one, if it is replaced via a call to duplicate_decls.
5875 : :
5876 : : If IS_FRIEND is true, DECL is a friend declaration. */
5877 : :
5878 : : tree
5879 : 272104302 : push_template_decl (tree decl, bool is_friend)
5880 : : {
5881 : 272104302 : if (decl == error_mark_node || !current_template_parms)
5882 : : return error_mark_node;
5883 : :
5884 : : /* See if this is a partial specialization. */
5885 : 65477116 : bool is_partial = ((DECL_IMPLICIT_TYPEDEF_P (decl)
5886 : 17653560 : && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE
5887 : 17357878 : && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)))
5888 : 331379163 : || (VAR_P (decl)
5889 : 50369643 : && DECL_LANG_SPECIFIC (decl)
5890 : 5088838 : && DECL_TEMPLATE_SPECIALIZATION (decl)
5891 : 619583 : && TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (decl))));
5892 : :
5893 : : /* No surprising friend functions. */
5894 : 272104282 : gcc_checking_assert (is_friend
5895 : : || !(TREE_CODE (decl) == FUNCTION_DECL
5896 : : && DECL_UNIQUE_FRIEND_P (decl)));
5897 : :
5898 : 272104282 : tree ctx;
5899 : 272104282 : if (is_friend)
5900 : : /* For a friend, we want the context of the friend, not
5901 : : the type of which it is a friend. */
5902 : 6416857 : ctx = CP_DECL_CONTEXT (decl);
5903 : 265687425 : else if (CP_DECL_CONTEXT (decl)
5904 : 265687425 : && TREE_CODE (CP_DECL_CONTEXT (decl)) != NAMESPACE_DECL)
5905 : : /* In the case of a virtual function, we want the class in which
5906 : : it is defined. */
5907 : 220866984 : ctx = CP_DECL_CONTEXT (decl);
5908 : : else
5909 : : /* Otherwise, if we're currently defining some class, the DECL
5910 : : is assumed to be a member of the class. */
5911 : 44820441 : ctx = current_scope ();
5912 : :
5913 : 272104282 : if (ctx && TREE_CODE (ctx) == NAMESPACE_DECL)
5914 : 51214057 : ctx = NULL_TREE;
5915 : :
5916 : 272104282 : if (!DECL_CONTEXT (decl))
5917 : 133 : DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
5918 : :
5919 : : /* See if this is a primary template. */
5920 : 272104282 : bool is_primary = false;
5921 : 272104282 : if (is_friend && ctx
5922 : 272104282 : && uses_template_parms_level (ctx, current_template_depth))
5923 : : /* A friend template that specifies a class context, i.e.
5924 : : template <typename T> friend void A<T>::f();
5925 : : is not primary. */
5926 : : ;
5927 : 316398993 : else if (TREE_CODE (decl) == TYPE_DECL && LAMBDA_TYPE_P (TREE_TYPE (decl)))
5928 : : /* Lambdas are not primary. */
5929 : : ;
5930 : : else
5931 : 271110288 : is_primary = template_parm_scope_p ();
5932 : :
5933 : : /* True if the template is a member template, in the sense of
5934 : : [temp.mem]. */
5935 : 271110288 : bool member_template_p = false;
5936 : :
5937 : 271110288 : if (is_primary)
5938 : : {
5939 : 65512650 : warning (OPT_Wtemplates, "template %qD declared", decl);
5940 : :
5941 : 65512650 : if (DECL_CLASS_SCOPE_P (decl))
5942 : : member_template_p = true;
5943 : :
5944 : 65512650 : if (TREE_CODE (decl) == TYPE_DECL
5945 : 65512650 : && IDENTIFIER_ANON_P (DECL_NAME (decl)))
5946 : : {
5947 : 6 : error ("template class without a name");
5948 : 6 : return error_mark_node;
5949 : : }
5950 : 65512644 : else if (TREE_CODE (decl) == FUNCTION_DECL)
5951 : : {
5952 : 42979392 : if (member_template_p)
5953 : : {
5954 : 15960670 : if (DECL_OVERRIDE_P (decl) || DECL_FINAL_P (decl))
5955 : 6 : error ("member template %qD may not have virt-specifiers", decl);
5956 : : }
5957 : 85958784 : if (DECL_DESTRUCTOR_P (decl))
5958 : : {
5959 : : /* [temp.mem]
5960 : :
5961 : : A destructor shall not be a member template. */
5962 : 6 : error_at (DECL_SOURCE_LOCATION (decl),
5963 : : "destructor %qD declared as member template", decl);
5964 : 6 : return error_mark_node;
5965 : : }
5966 : 85958772 : if (IDENTIFIER_NEWDEL_OP_P (DECL_NAME (decl))
5967 : 42983977 : && (!prototype_p (TREE_TYPE (decl))
5968 : 4591 : || TYPE_ARG_TYPES (TREE_TYPE (decl)) == void_list_node
5969 : 4591 : || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
5970 : 4591 : || (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
5971 : : == void_list_node)))
5972 : : {
5973 : : /* [basic.stc.dynamic.allocation]
5974 : :
5975 : : An allocation function can be a function
5976 : : template. ... Template allocation functions shall
5977 : : have two or more parameters. */
5978 : 9 : error ("invalid template declaration of %qD", decl);
5979 : 9 : return error_mark_node;
5980 : : }
5981 : : }
5982 : 19412151 : else if (DECL_IMPLICIT_TYPEDEF_P (decl)
5983 : 38382639 : && CLASS_TYPE_P (TREE_TYPE (decl)))
5984 : : /* Class template. */;
5985 : 6683871 : else if (TREE_CODE (decl) == TYPE_DECL
5986 : 6683871 : && TYPE_DECL_ALIAS_P (decl))
5987 : : /* alias-declaration */
5988 : 3562761 : gcc_assert (!DECL_ARTIFICIAL (decl));
5989 : 3121110 : else if (VAR_P (decl))
5990 : : /* C++14 variable template. */;
5991 : 620551 : else if (TREE_CODE (decl) == CONCEPT_DECL)
5992 : : /* C++20 concept definitions. */;
5993 : : else
5994 : : {
5995 : 9 : error ("template declaration of %q#D", decl);
5996 : 9 : return error_mark_node;
5997 : : }
5998 : : }
5999 : :
6000 : 65477101 : bool local_p = (!DECL_IMPLICIT_TYPEDEF_P (decl)
6001 : 319927805 : && ((ctx && TREE_CODE (ctx) == FUNCTION_DECL)
6002 : 198075877 : || (VAR_OR_FUNCTION_DECL_P (decl)
6003 : 160410947 : && DECL_LOCAL_DECL_P (decl))));
6004 : :
6005 : : /* Check to see that the rules regarding the use of default
6006 : : arguments are not being violated. We check args for a friend
6007 : : functions when we know whether it's a definition, introducing
6008 : : declaration or re-declaration. */
6009 : 215729425 : if (!local_p && (!is_friend || TREE_CODE (decl) != FUNCTION_DECL))
6010 : 209701432 : check_default_tmpl_args (decl, current_template_parms,
6011 : : is_primary, is_partial, is_friend);
6012 : :
6013 : : /* Ensure that there are no parameter packs in the type of this
6014 : : declaration that have not been expanded. */
6015 : 272104252 : if (TREE_CODE (decl) == FUNCTION_DECL)
6016 : : {
6017 : : /* Check each of the arguments individually to see if there are
6018 : : any bare parameter packs. */
6019 : 155636966 : tree type = TREE_TYPE (decl);
6020 : 155636966 : tree arg = DECL_ARGUMENTS (decl);
6021 : 155636966 : tree argtype = TYPE_ARG_TYPES (type);
6022 : :
6023 : 496547962 : while (arg && argtype)
6024 : : {
6025 : 340910996 : if (!DECL_PACK_P (arg)
6026 : 677441618 : && check_for_bare_parameter_packs (TREE_TYPE (arg)))
6027 : : {
6028 : : /* This is a PARM_DECL that contains unexpanded parameter
6029 : : packs. We have already complained about this in the
6030 : : check_for_bare_parameter_packs call, so just replace
6031 : : these types with ERROR_MARK_NODE. */
6032 : 42 : TREE_TYPE (arg) = error_mark_node;
6033 : 42 : TREE_VALUE (argtype) = error_mark_node;
6034 : : }
6035 : :
6036 : 340910996 : arg = DECL_CHAIN (arg);
6037 : 340910996 : argtype = TREE_CHAIN (argtype);
6038 : : }
6039 : :
6040 : : /* Check for bare parameter packs in the return type and the
6041 : : exception specifiers. */
6042 : 155636966 : if (check_for_bare_parameter_packs (TREE_TYPE (type)))
6043 : : /* Errors were already issued, set return type to int
6044 : : as the frontend doesn't expect error_mark_node as
6045 : : the return type. */
6046 : 3 : TREE_TYPE (type) = integer_type_node;
6047 : 155636966 : if (check_for_bare_parameter_packs (TYPE_RAISES_EXCEPTIONS (type)))
6048 : 0 : TYPE_RAISES_EXCEPTIONS (type) = NULL_TREE;
6049 : : }
6050 : : else
6051 : : {
6052 : 232934572 : if (check_for_bare_parameter_packs (is_typedef_decl (decl)
6053 : : ? DECL_ORIGINAL_TYPE (decl)
6054 : 68643803 : : TREE_TYPE (decl)))
6055 : : {
6056 : 64 : TREE_TYPE (decl) = error_mark_node;
6057 : 64 : return error_mark_node;
6058 : : }
6059 : :
6060 : 6821773 : if (is_partial && VAR_P (decl)
6061 : 117086793 : && check_for_bare_parameter_packs (DECL_TI_ARGS (decl)))
6062 : 3 : return error_mark_node;
6063 : : }
6064 : :
6065 : 272104185 : if (is_partial)
6066 : 6821770 : return process_partial_specialization (decl);
6067 : :
6068 : 265282415 : tree args = current_template_args ();
6069 : 265282415 : tree tmpl = NULL_TREE;
6070 : 265282415 : bool new_template_p = false;
6071 : 265282415 : if (local_p)
6072 : : {
6073 : : /* Does not get a template head. */
6074 : 56374818 : tmpl = NULL_TREE;
6075 : 56374818 : gcc_checking_assert (!is_primary);
6076 : : }
6077 : 208907597 : else if (!ctx
6078 : 163901067 : || TREE_CODE (ctx) == FUNCTION_DECL
6079 : 163227012 : || (CLASS_TYPE_P (ctx) && TYPE_BEING_DEFINED (ctx))
6080 : 58699008 : || (TREE_CODE (decl) == TYPE_DECL && LAMBDA_TYPE_P (TREE_TYPE (decl)))
6081 : 267514344 : || (is_friend && !(DECL_LANG_SPECIFIC (decl)
6082 : 72 : && DECL_TEMPLATE_INFO (decl))))
6083 : : {
6084 : 150300925 : if (DECL_LANG_SPECIFIC (decl)
6085 : 136754162 : && DECL_TEMPLATE_INFO (decl)
6086 : 154215451 : && DECL_TI_TEMPLATE (decl))
6087 : 3914526 : tmpl = DECL_TI_TEMPLATE (decl);
6088 : : /* If DECL is a TYPE_DECL for a class-template, then there won't
6089 : : be DECL_LANG_SPECIFIC. The information equivalent to
6090 : : DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
6091 : 48403617 : else if (DECL_IMPLICIT_TYPEDEF_P (decl)
6092 : 11359247 : && TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
6093 : 146434491 : && TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
6094 : : {
6095 : : /* Since a template declaration already existed for this
6096 : : class-type, we must be redeclaring it here. Make sure
6097 : : that the redeclaration is valid. */
6098 : 24046 : redeclare_class_template (TREE_TYPE (decl),
6099 : : current_template_parms,
6100 : : current_template_constraints ());
6101 : : /* We don't need to create a new TEMPLATE_DECL; just use the
6102 : : one we already had. */
6103 : 48092 : tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
6104 : : }
6105 : : else
6106 : : {
6107 : 146362353 : tmpl = build_template_decl (decl, current_template_parms,
6108 : : member_template_p);
6109 : 146362353 : new_template_p = true;
6110 : :
6111 : 146362353 : if (DECL_LANG_SPECIFIC (decl)
6112 : 146362353 : && DECL_TEMPLATE_SPECIALIZATION (decl))
6113 : : {
6114 : : /* A specialization of a member template of a template
6115 : : class. */
6116 : 0 : SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
6117 : 0 : DECL_TEMPLATE_INFO (tmpl) = DECL_TEMPLATE_INFO (decl);
6118 : 0 : DECL_TEMPLATE_INFO (decl) = NULL_TREE;
6119 : : }
6120 : : }
6121 : : }
6122 : : else
6123 : : {
6124 : 58606672 : tree a, t, current, parms;
6125 : 58606672 : int i;
6126 : 58606672 : tree tinfo = get_template_info (decl);
6127 : :
6128 : 58606672 : if (!tinfo)
6129 : : {
6130 : 15 : error ("template definition of non-template %q#D", decl);
6131 : 15 : return error_mark_node;
6132 : : }
6133 : :
6134 : 58606657 : tmpl = TI_TEMPLATE (tinfo);
6135 : :
6136 : 58606657 : if (DECL_FUNCTION_TEMPLATE_P (tmpl)
6137 : 58209586 : && DECL_TEMPLATE_INFO (decl) && DECL_TI_ARGS (decl)
6138 : 58209586 : && DECL_TEMPLATE_SPECIALIZATION (decl)
6139 : 58606675 : && DECL_MEMBER_TEMPLATE_P (tmpl))
6140 : : {
6141 : : /* The declaration is a specialization of a member
6142 : : template, declared outside the class. Therefore, the
6143 : : innermost template arguments will be NULL, so we
6144 : : replace them with the arguments determined by the
6145 : : earlier call to check_explicit_specialization. */
6146 : 12 : args = DECL_TI_ARGS (decl);
6147 : :
6148 : 12 : tree new_tmpl
6149 : 12 : = build_template_decl (decl, current_template_parms,
6150 : : member_template_p);
6151 : 12 : DECL_TI_TEMPLATE (decl) = new_tmpl;
6152 : 12 : SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl);
6153 : 12 : DECL_TEMPLATE_INFO (new_tmpl)
6154 : 12 : = build_template_info (tmpl, args);
6155 : :
6156 : 12 : register_specialization (new_tmpl,
6157 : : most_general_template (tmpl),
6158 : : args,
6159 : : is_friend, 0);
6160 : 12 : return decl;
6161 : : }
6162 : :
6163 : : /* Make sure the template headers we got make sense. */
6164 : :
6165 : 58606645 : parms = DECL_TEMPLATE_PARMS (tmpl);
6166 : 58606645 : i = TMPL_PARMS_DEPTH (parms);
6167 : 163353762 : if (TMPL_ARGS_DEPTH (args) != i)
6168 : : {
6169 : 12 : error ("expected %d levels of template parms for %q#D, got %d",
6170 : 6 : i, decl, TMPL_ARGS_DEPTH (args));
6171 : 6 : DECL_INTERFACE_KNOWN (decl) = 1;
6172 : 6 : return error_mark_node;
6173 : : }
6174 : : else
6175 : 129745957 : for (current = decl; i > 0; --i, parms = TREE_CHAIN (parms))
6176 : : {
6177 : 142278666 : a = TMPL_ARGS_LEVEL (args, i);
6178 : 71139333 : t = INNERMOST_TEMPLATE_PARMS (parms);
6179 : :
6180 : 71139333 : if (TREE_VEC_LENGTH (t) != TREE_VEC_LENGTH (a))
6181 : : {
6182 : 15 : if (current == decl)
6183 : 15 : error ("got %d template parameters for %q#D",
6184 : 15 : TREE_VEC_LENGTH (a), decl);
6185 : : else
6186 : 0 : error ("got %d template parameters for %q#T",
6187 : 0 : TREE_VEC_LENGTH (a), current);
6188 : 15 : error (" but %d required", TREE_VEC_LENGTH (t));
6189 : : /* Avoid crash in import_export_decl. */
6190 : 15 : DECL_INTERFACE_KNOWN (decl) = 1;
6191 : 15 : return error_mark_node;
6192 : : }
6193 : :
6194 : 71139318 : if (current == decl)
6195 : : current = ctx;
6196 : 12532694 : else if (current == NULL_TREE)
6197 : : /* Can happen in erroneous input. */
6198 : : break;
6199 : : else
6200 : 12532694 : current = get_containing_scope (current);
6201 : : }
6202 : :
6203 : : /* Check that the parms are used in the appropriate qualifying scopes
6204 : : in the declarator. */
6205 : 117213248 : if (!comp_template_args
6206 : 58606624 : (TI_ARGS (tinfo),
6207 : 58606624 : TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl)))))
6208 : : {
6209 : 3 : auto_diagnostic_group d;
6210 : 3 : error ("template arguments to %qD do not match original "
6211 : 3 : "template %qD", decl, DECL_TEMPLATE_RESULT (tmpl));
6212 : 3 : if (!uses_template_parms (TI_ARGS (tinfo)))
6213 : 3 : inform (input_location, "use %<template<>%> for"
6214 : : " an explicit specialization");
6215 : : /* Avoid crash in import_export_decl. */
6216 : 3 : DECL_INTERFACE_KNOWN (decl) = 1;
6217 : 3 : return error_mark_node;
6218 : 3 : }
6219 : :
6220 : : /* Check that the constraints for each enclosing template scope are
6221 : : consistent with the original declarations. */
6222 : 58606621 : if (flag_concepts)
6223 : : {
6224 : 16244321 : tree decl_parms = DECL_TEMPLATE_PARMS (tmpl);
6225 : 16244321 : tree scope_parms = current_template_parms;
6226 : 16244321 : if (PRIMARY_TEMPLATE_P (tmpl))
6227 : : {
6228 : 4561420 : decl_parms = TREE_CHAIN (decl_parms);
6229 : 4561420 : scope_parms = TREE_CHAIN (scope_parms);
6230 : : }
6231 : 31719610 : while (decl_parms)
6232 : : {
6233 : 15475307 : if (!template_requirements_equivalent_p (decl_parms, scope_parms))
6234 : : {
6235 : 18 : error ("redeclaration of %qD with different constraints",
6236 : 18 : TPARMS_PRIMARY_TEMPLATE (TREE_VALUE (decl_parms)));
6237 : 18 : break;
6238 : : }
6239 : 15475289 : decl_parms = TREE_CHAIN (decl_parms);
6240 : 15475289 : scope_parms = TREE_CHAIN (scope_parms);
6241 : : }
6242 : : }
6243 : : }
6244 : :
6245 : 417815092 : gcc_checking_assert (!tmpl || DECL_TEMPLATE_RESULT (tmpl) == decl);
6246 : :
6247 : 265282364 : if (new_template_p)
6248 : : {
6249 : : /* Push template declarations for global functions and types.
6250 : : Note that we do not try to push a global template friend
6251 : : declared in a template class; such a thing may well depend on
6252 : : the template parameters of the class and we'll push it when
6253 : : instantiating the befriending class. */
6254 : 146362353 : if (!ctx
6255 : 146362353 : && !(is_friend && template_class_depth (current_class_type) > 0))
6256 : : {
6257 : 38883636 : tree pushed = pushdecl_namespace_level (tmpl, /*hiding=*/is_friend);
6258 : 38883636 : if (pushed == error_mark_node)
6259 : : return error_mark_node;
6260 : :
6261 : : /* pushdecl may have found an existing template. */
6262 : 38883579 : if (pushed != tmpl)
6263 : : {
6264 : 2912121 : decl = DECL_TEMPLATE_RESULT (pushed);
6265 : 2912121 : tmpl = NULL_TREE;
6266 : : }
6267 : : }
6268 : 107478717 : else if (is_friend)
6269 : : {
6270 : : /* Record this decl as belonging to the current class. It's
6271 : : not chained onto anything else. */
6272 : 2726596 : DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (tmpl) = true;
6273 : 2726596 : gcc_checking_assert (!DECL_CHAIN (tmpl));
6274 : 2726596 : DECL_CHAIN (tmpl) = current_scope ();
6275 : : }
6276 : : }
6277 : 118920011 : else if (tmpl)
6278 : : /* The type may have been completed, or (erroneously) changed. */
6279 : 62545193 : TREE_TYPE (tmpl) = TREE_TYPE (decl);
6280 : :
6281 : 208907489 : if (tmpl)
6282 : : {
6283 : 205995368 : if (is_primary)
6284 : : {
6285 : 55778675 : tree parms = DECL_TEMPLATE_PARMS (tmpl);
6286 : :
6287 : 55778675 : DECL_PRIMARY_TEMPLATE (tmpl) = tmpl;
6288 : :
6289 : : /* Give template template parms a DECL_CONTEXT of the template
6290 : : for which they are a parameter. */
6291 : 55778675 : parms = INNERMOST_TEMPLATE_PARMS (parms);
6292 : 158254446 : for (int i = TREE_VEC_LENGTH (parms) - 1; i >= 0; --i)
6293 : : {
6294 : 102475771 : tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
6295 : 102475771 : if (TREE_CODE (parm) == TEMPLATE_DECL)
6296 : 190817 : DECL_CONTEXT (parm) = tmpl;
6297 : : }
6298 : :
6299 : 55778675 : if (TREE_CODE (decl) == TYPE_DECL
6300 : 55778675 : && TYPE_DECL_ALIAS_P (decl))
6301 : : {
6302 : 3562731 : if (tree constr
6303 : 3562731 : = TEMPLATE_PARMS_CONSTRAINTS (DECL_TEMPLATE_PARMS (tmpl)))
6304 : : {
6305 : : /* ??? Why don't we do this here for all templates? */
6306 : 77053 : constr = build_constraints (constr, NULL_TREE);
6307 : 77053 : set_constraints (decl, constr);
6308 : : }
6309 : : }
6310 : : }
6311 : :
6312 : : /* The DECL_TI_ARGS of DECL contains full set of arguments
6313 : : referring wback to its most general template. If TMPL is a
6314 : : specialization, ARGS may only have the innermost set of
6315 : : arguments. Add the missing argument levels if necessary. */
6316 : 205995368 : if (DECL_TEMPLATE_INFO (tmpl))
6317 : 948 : args = add_outermost_template_args (DECL_TI_ARGS (tmpl), args);
6318 : :
6319 : 205995368 : tree info = build_template_info (tmpl, args);
6320 : :
6321 : 205995368 : if (DECL_IMPLICIT_TYPEDEF_P (decl))
6322 : 11451289 : SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl), info);
6323 : : else
6324 : : {
6325 : 194544079 : retrofit_lang_decl (decl);
6326 : 194544079 : DECL_TEMPLATE_INFO (decl) = info;
6327 : : }
6328 : : }
6329 : :
6330 : 265282307 : if (is_typedef_decl (decl)
6331 : 47823465 : && (dependent_opaque_alias_p (TREE_TYPE (decl))
6332 : 47823350 : || dependent_alias_template_spec_p (TREE_TYPE (decl), nt_opaque)))
6333 : : {
6334 : : /* Manually mark such aliases as dependent so that dependent_type_p_r
6335 : : doesn't have to handle them. */
6336 : 472619 : TYPE_DEPENDENT_P_VALID (TREE_TYPE (decl)) = true;
6337 : 472619 : TYPE_DEPENDENT_P (TREE_TYPE (decl)) = true;
6338 : : /* The identity of such aliases is hairy; see structural_comptypes. */
6339 : 472619 : SET_TYPE_STRUCTURAL_EQUALITY (TREE_TYPE (decl));
6340 : : }
6341 : :
6342 : 265282307 : if (flag_implicit_templates
6343 : 264578781 : && !is_friend
6344 : 258168745 : && TREE_PUBLIC (decl)
6345 : 152467545 : && VAR_OR_FUNCTION_DECL_P (decl))
6346 : : /* Set DECL_COMDAT on template instantiations; if we force
6347 : : them to be emitted by explicit instantiation,
6348 : : mark_needed will tell cgraph to do the right thing. */
6349 : 151731190 : DECL_COMDAT (decl) = true;
6350 : :
6351 : 471277675 : gcc_checking_assert (!tmpl || DECL_TEMPLATE_RESULT (tmpl) == decl);
6352 : :
6353 : : return decl;
6354 : : }
6355 : :
6356 : : /* FN is an inheriting constructor that inherits from the constructor
6357 : : template INHERITED; turn FN into a constructor template with a matching
6358 : : template header. */
6359 : :
6360 : : tree
6361 : 62824 : add_inherited_template_parms (tree fn, tree inherited)
6362 : : {
6363 : 62824 : tree inner_parms
6364 : 62824 : = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (inherited));
6365 : 62824 : inner_parms = copy_node (inner_parms);
6366 : 62824 : tree parms
6367 : 62824 : = tree_cons (size_int (current_template_depth + 1),
6368 : : inner_parms, current_template_parms);
6369 : 62824 : tree tmpl = build_template_decl (fn, parms, /*member*/true);
6370 : 62824 : tree args = template_parms_to_args (parms);
6371 : 62824 : DECL_TEMPLATE_INFO (fn) = build_template_info (tmpl, args);
6372 : 62824 : DECL_ARTIFICIAL (tmpl) = true;
6373 : 62824 : DECL_PRIMARY_TEMPLATE (tmpl) = tmpl;
6374 : 62824 : return tmpl;
6375 : : }
6376 : :
6377 : : /* Called when a class template TYPE is redeclared with the indicated
6378 : : template PARMS, e.g.:
6379 : :
6380 : : template <class T> struct S;
6381 : : template <class T> struct S {}; */
6382 : :
6383 : : bool
6384 : 2192503 : redeclare_class_template (tree type, tree parms, tree cons)
6385 : : {
6386 : 2192503 : tree tmpl;
6387 : 2192503 : tree tmpl_parms;
6388 : 2192503 : int i;
6389 : :
6390 : 2192503 : if (!TYPE_TEMPLATE_INFO (type))
6391 : : {
6392 : 0 : error ("%qT is not a template type", type);
6393 : 0 : return false;
6394 : : }
6395 : :
6396 : 2192503 : tmpl = TYPE_TI_TEMPLATE (type);
6397 : 2192503 : if (!PRIMARY_TEMPLATE_P (tmpl))
6398 : : /* The type is nested in some template class. Nothing to worry
6399 : : about here; there are no new template parameters for the nested
6400 : : type. */
6401 : : return true;
6402 : :
6403 : 2192503 : if (!parms)
6404 : : {
6405 : 3 : error ("template specifiers not specified in declaration of %qD",
6406 : : tmpl);
6407 : 3 : return false;
6408 : : }
6409 : :
6410 : 2192500 : parms = INNERMOST_TEMPLATE_PARMS (parms);
6411 : 2192500 : tmpl_parms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl);
6412 : :
6413 : 2192500 : if (TREE_VEC_LENGTH (parms) != TREE_VEC_LENGTH (tmpl_parms))
6414 : : {
6415 : 21 : auto_diagnostic_group d;
6416 : 21 : error_n (input_location, TREE_VEC_LENGTH (parms),
6417 : : "redeclared with %d template parameter",
6418 : : "redeclared with %d template parameters",
6419 : 21 : TREE_VEC_LENGTH (parms));
6420 : 42 : inform_n (DECL_SOURCE_LOCATION (tmpl), TREE_VEC_LENGTH (tmpl_parms),
6421 : : "previous declaration %qD used %d template parameter",
6422 : : "previous declaration %qD used %d template parameters",
6423 : 21 : tmpl, TREE_VEC_LENGTH (tmpl_parms));
6424 : 21 : return false;
6425 : 21 : }
6426 : :
6427 : 5918593 : for (i = 0; i < TREE_VEC_LENGTH (tmpl_parms); ++i)
6428 : : {
6429 : 3726162 : tree tmpl_parm;
6430 : 3726162 : tree parm;
6431 : :
6432 : 3726162 : if (TREE_VEC_ELT (tmpl_parms, i) == error_mark_node
6433 : 3726162 : || TREE_VEC_ELT (parms, i) == error_mark_node)
6434 : 0 : continue;
6435 : :
6436 : 3726162 : tmpl_parm = TREE_VALUE (TREE_VEC_ELT (tmpl_parms, i));
6437 : 3726162 : if (error_operand_p (tmpl_parm))
6438 : : return false;
6439 : :
6440 : 3726147 : parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
6441 : :
6442 : : /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
6443 : : TEMPLATE_DECL. */
6444 : 3726147 : if (TREE_CODE (tmpl_parm) != TREE_CODE (parm)
6445 : 3726135 : || (TREE_CODE (tmpl_parm) != TYPE_DECL
6446 : 364493 : && !same_type_p (TREE_TYPE (tmpl_parm), TREE_TYPE (parm)))
6447 : 3726126 : || (TREE_CODE (tmpl_parm) != PARM_DECL
6448 : 3362218 : && (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (tmpl_parm))
6449 : 3362218 : != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm))))
6450 : 7452270 : || (TREE_CODE (tmpl_parm) == PARM_DECL
6451 : 363908 : && (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (tmpl_parm))
6452 : 363908 : != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)))))
6453 : : {
6454 : 27 : auto_diagnostic_group d;
6455 : 27 : error ("template parameter %q+#D", tmpl_parm);
6456 : 27 : if (DECL_P (parm))
6457 : 24 : inform (DECL_SOURCE_LOCATION (parm), "redeclared here as %q#D", parm);
6458 : : else
6459 : 3 : inform (input_location, "redeclared here");
6460 : 27 : return false;
6461 : 27 : }
6462 : :
6463 : : /* The parameters can be declared to introduce different
6464 : : constraints. */
6465 : 3726120 : tree p1 = TREE_VEC_ELT (tmpl_parms, i);
6466 : 3726120 : tree p2 = TREE_VEC_ELT (parms, i);
6467 : 3726120 : if (!template_parameter_constraints_equivalent_p (p1, p2))
6468 : : {
6469 : 6 : auto_diagnostic_group d;
6470 : 6 : error ("declaration of template parameter %q+#D with different "
6471 : : "constraints", parm);
6472 : 6 : inform (DECL_SOURCE_LOCATION (tmpl_parm),
6473 : : "original declaration appeared here");
6474 : 6 : return false;
6475 : 6 : }
6476 : :
6477 : : /* Give each template template parm in this redeclaration a
6478 : : DECL_CONTEXT of the template for which they are a parameter. */
6479 : 3726114 : if (TREE_CODE (parm) == TEMPLATE_DECL)
6480 : : {
6481 : 576 : gcc_checking_assert (DECL_CONTEXT (parm) == NULL_TREE
6482 : : || DECL_CONTEXT (parm) == tmpl);
6483 : 576 : DECL_CONTEXT (parm) = tmpl;
6484 : : }
6485 : : }
6486 : :
6487 : 2192431 : if (!merge_default_template_args (parms, tmpl_parms, /*class_p=*/true))
6488 : : return false;
6489 : :
6490 : 2192428 : tree ci = get_constraints (tmpl);
6491 : 2201504 : tree req1 = ci ? CI_TEMPLATE_REQS (ci) : NULL_TREE;
6492 : 2201507 : tree req2 = cons ? CI_TEMPLATE_REQS (cons) : NULL_TREE;
6493 : :
6494 : : /* Two classes with different constraints declare different entities. */
6495 : 2192428 : if (!cp_tree_equal (req1, req2))
6496 : : {
6497 : 15 : auto_diagnostic_group d;
6498 : 15 : error_at (input_location, "redeclaration of %q#D with different "
6499 : : "constraints", tmpl);
6500 : 15 : inform (DECL_SOURCE_LOCATION (tmpl),
6501 : : "original declaration appeared here");
6502 : 15 : return false;
6503 : 15 : }
6504 : :
6505 : : return true;
6506 : : }
6507 : :
6508 : : /* The actual substitution part of instantiate_non_dependent_expr,
6509 : : to be used when the caller has already checked
6510 : : !instantiation_dependent_uneval_expression_p (expr)
6511 : : and cleared processing_template_decl. */
6512 : :
6513 : : tree
6514 : 62743437 : instantiate_non_dependent_expr_internal (tree expr, tsubst_flags_t complain)
6515 : : {
6516 : 62743437 : return tsubst_expr (expr, /*args=*/NULL_TREE, complain, /*in_decl=*/NULL_TREE);
6517 : : }
6518 : :
6519 : : /* Instantiate the non-dependent expression EXPR. */
6520 : :
6521 : : tree
6522 : 107734352 : instantiate_non_dependent_expr (tree expr,
6523 : : tsubst_flags_t complain /* = tf_error */)
6524 : : {
6525 : 107734352 : if (expr == NULL_TREE)
6526 : : return NULL_TREE;
6527 : :
6528 : 107734352 : if (processing_template_decl)
6529 : : {
6530 : : /* The caller should have checked this already. */
6531 : 30312147 : gcc_checking_assert (!instantiation_dependent_uneval_expression_p (expr));
6532 : 30312147 : processing_template_decl_sentinel s;
6533 : 30312147 : expr = instantiate_non_dependent_expr_internal (expr, complain);
6534 : 30312147 : }
6535 : : return expr;
6536 : : }
6537 : :
6538 : : /* Like instantiate_non_dependent_expr, but return NULL_TREE if the
6539 : : expression is dependent or non-constant. */
6540 : :
6541 : : tree
6542 : 105411282 : instantiate_non_dependent_or_null (tree expr)
6543 : : {
6544 : 105411282 : if (expr == NULL_TREE)
6545 : : return NULL_TREE;
6546 : 95385438 : if (processing_template_decl)
6547 : : {
6548 : 69206 : if (!is_nondependent_constant_expression (expr))
6549 : : expr = NULL_TREE;
6550 : : else
6551 : : {
6552 : 64228 : processing_template_decl_sentinel s;
6553 : 64228 : expr = instantiate_non_dependent_expr_internal (expr, tf_error);
6554 : 64228 : }
6555 : : }
6556 : : return expr;
6557 : : }
6558 : :
6559 : : /* True iff T is a specialization of a variable template. */
6560 : :
6561 : : bool
6562 : 195274979 : variable_template_specialization_p (tree t)
6563 : : {
6564 : 195274979 : if (!VAR_P (t) || !DECL_LANG_SPECIFIC (t) || !DECL_TEMPLATE_INFO (t))
6565 : : return false;
6566 : 12382635 : tree tmpl = DECL_TI_TEMPLATE (t);
6567 : 12382635 : return variable_template_p (tmpl);
6568 : : }
6569 : :
6570 : : /* Return TRUE iff T is a type alias, a TEMPLATE_DECL for an alias
6571 : : template declaration, or a TYPE_DECL for an alias declaration. */
6572 : :
6573 : : bool
6574 : 138188474 : alias_type_or_template_p (tree t)
6575 : : {
6576 : 138188474 : if (t == NULL_TREE)
6577 : : return false;
6578 : 0 : return ((TREE_CODE (t) == TYPE_DECL && TYPE_DECL_ALIAS_P (t))
6579 : 138188474 : || (TYPE_P (t)
6580 : 138188474 : && TYPE_NAME (t)
6581 : 138188474 : && TYPE_DECL_ALIAS_P (TYPE_NAME (t)))
6582 : 271221497 : || DECL_ALIAS_TEMPLATE_P (t));
6583 : : }
6584 : :
6585 : : /* If T is a specialization of an alias template, return it; otherwise return
6586 : : NULL_TREE. If TRANSPARENT_TYPEDEFS is true, look through other aliases. */
6587 : :
6588 : : tree
6589 : 4525043809 : alias_template_specialization_p (const_tree t,
6590 : : bool transparent_typedefs)
6591 : : {
6592 : 4525043809 : if (!TYPE_P (t))
6593 : : return NULL_TREE;
6594 : :
6595 : : /* It's an alias template specialization if it's an alias and its
6596 : : TYPE_NAME is a specialization of a primary template. */
6597 : 4525043809 : if (typedef_variant_p (t))
6598 : : {
6599 : 424390638 : if (tree tinfo = TYPE_ALIAS_TEMPLATE_INFO (t))
6600 : 372065387 : if (PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo)))
6601 : : return CONST_CAST_TREE (t);
6602 : 294258017 : if (transparent_typedefs && !dependent_opaque_alias_p (t))
6603 : 98236 : return alias_template_specialization_p (DECL_ORIGINAL_TYPE
6604 : : (TYPE_NAME (t)),
6605 : 98236 : transparent_typedefs);
6606 : : }
6607 : :
6608 : : return NULL_TREE;
6609 : : }
6610 : :
6611 : : /* A cache of the result of complex_alias_template_p. */
6612 : :
6613 : : static GTY((deletable)) hash_map<const_tree, tree> *complex_alias_tmpl_info;
6614 : :
6615 : : /* Data structure for complex_alias_template_*. */
6616 : :
6617 : : struct uses_all_template_parms_data
6618 : : {
6619 : : int level;
6620 : : tree *seen;
6621 : : };
6622 : :
6623 : : /* walk_tree callback for complex_alias_template_p. */
6624 : :
6625 : : static tree
6626 : 49242245 : complex_alias_template_r (tree *tp, int *walk_subtrees, void *data_)
6627 : : {
6628 : 49242245 : tree t = *tp;
6629 : 49242245 : auto &data = *(struct uses_all_template_parms_data*)data_;
6630 : :
6631 : 49242245 : switch (TREE_CODE (t))
6632 : : {
6633 : 9235386 : case TEMPLATE_TYPE_PARM:
6634 : 9235386 : case TEMPLATE_PARM_INDEX:
6635 : 9235386 : case TEMPLATE_TEMPLATE_PARM:
6636 : 9235386 : case BOUND_TEMPLATE_TEMPLATE_PARM:
6637 : 9235386 : {
6638 : 9235386 : tree idx = get_template_parm_index (t);
6639 : 9235386 : if (TEMPLATE_PARM_LEVEL (idx) == data.level)
6640 : 7604977 : data.seen[TEMPLATE_PARM_IDX (idx)] = boolean_true_node;
6641 : : }
6642 : :
6643 : 49242245 : default:;
6644 : : }
6645 : :
6646 : 49242245 : if (!PACK_EXPANSION_P (t))
6647 : : return 0;
6648 : :
6649 : : /* An alias template with a pack expansion that expands a pack from the
6650 : : enclosing class needs to be considered complex, to avoid confusion with
6651 : : the same pack being used as an argument to the alias's own template
6652 : : parameter (91966). */
6653 : 2770367 : for (tree pack = PACK_EXPANSION_PARAMETER_PACKS (t); pack;
6654 : 884770 : pack = TREE_CHAIN (pack))
6655 : : {
6656 : 1021053 : tree parm_pack = TREE_VALUE (pack);
6657 : 1021053 : if (!TEMPLATE_PARM_P (parm_pack))
6658 : 38048 : continue;
6659 : 983005 : int idx, level;
6660 : 983005 : template_parm_level_and_index (parm_pack, &level, &idx);
6661 : 983005 : if (level < data.level)
6662 : 136283 : return t;
6663 : :
6664 : : /* Consider the expanded packs to be used outside the expansion... */
6665 : 846722 : data.seen[idx] = boolean_true_node;
6666 : : }
6667 : :
6668 : : /* ...but don't walk into the pattern. Consider PR104008:
6669 : :
6670 : : template <typename T, typename... Ts>
6671 : : using IsOneOf = disjunction<is_same<T, Ts>...>;
6672 : :
6673 : : where IsOneOf seemingly uses all of its template parameters in its
6674 : : expansion (and does not expand a pack from the enclosing class), so the
6675 : : alias was not marked as complex. However, if it is used like
6676 : : "IsOneOf<T>", the empty pack for Ts means that T no longer appears in the
6677 : : expansion. So only Ts is considered used by the pack expansion. */
6678 : 873214 : *walk_subtrees = false;
6679 : :
6680 : 873214 : return 0;
6681 : : }
6682 : :
6683 : : /* An alias template is complex from a SFINAE perspective if a template-id
6684 : : using that alias can be ill-formed when the expansion is not, as with
6685 : : the void_t template.
6686 : :
6687 : : If this predicate returns true in the ordinary case, the out parameter
6688 : : SEEN_OUT is set to a TREE_VEC containing boolean_true_node at element I if
6689 : : the I'th template parameter of the alias template is used in the alias. */
6690 : :
6691 : : static bool
6692 : 96862827 : complex_alias_template_p (const_tree tmpl, tree *seen_out)
6693 : : {
6694 : 96862827 : tmpl = most_general_template (tmpl);
6695 : 96862827 : if (!PRIMARY_TEMPLATE_P (tmpl))
6696 : : return false;
6697 : :
6698 : : /* A renaming alias isn't complex. */
6699 : 62659801 : if (get_underlying_template (CONST_CAST_TREE (tmpl)) != tmpl)
6700 : : return false;
6701 : :
6702 : : /* Any other constrained alias is complex. */
6703 : 59434737 : if (get_constraints (tmpl))
6704 : : return true;
6705 : :
6706 : : /* An alias with dependent type attributes is complex. */
6707 : 53208248 : if (dependent_opaque_alias_p (TREE_TYPE (tmpl)))
6708 : : return true;
6709 : :
6710 : 53208180 : if (!complex_alias_tmpl_info)
6711 : 89788 : complex_alias_tmpl_info = hash_map<const_tree, tree>::create_ggc (13);
6712 : :
6713 : 53208180 : if (tree *slot = complex_alias_tmpl_info->get (tmpl))
6714 : : {
6715 : 47866818 : tree result = *slot;
6716 : 47866818 : if (result == boolean_false_node)
6717 : : return false;
6718 : 10470578 : if (result == boolean_true_node)
6719 : : return true;
6720 : 8779587 : gcc_assert (TREE_CODE (result) == TREE_VEC);
6721 : 8779587 : if (seen_out)
6722 : 8779587 : *seen_out = result;
6723 : 8779587 : return true;
6724 : : }
6725 : :
6726 : 5341362 : struct uses_all_template_parms_data data;
6727 : 5341362 : tree pat = DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl));
6728 : 5341362 : tree parms = DECL_TEMPLATE_PARMS (tmpl);
6729 : 5341362 : data.level = TMPL_PARMS_DEPTH (parms);
6730 : 5341362 : int len = TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS (parms));
6731 : 5341362 : tree seen = make_tree_vec (len);
6732 : 5341362 : data.seen = TREE_VEC_BEGIN (seen);
6733 : 13623399 : for (int i = 0; i < len; ++i)
6734 : 8282037 : data.seen[i] = boolean_false_node;
6735 : :
6736 : 5341362 : if (cp_walk_tree_without_duplicates (&pat, complex_alias_template_r, &data))
6737 : : {
6738 : 136283 : complex_alias_tmpl_info->put (tmpl, boolean_true_node);
6739 : 136283 : return true;
6740 : : }
6741 : :
6742 : 12472923 : for (int i = 0; i < len; ++i)
6743 : 7749385 : if (data.seen[i] != boolean_true_node)
6744 : : {
6745 : 481541 : complex_alias_tmpl_info->put (tmpl, seen);
6746 : 481541 : if (seen_out)
6747 : 481541 : *seen_out = seen;
6748 : 481541 : return true;
6749 : : }
6750 : :
6751 : 4723538 : complex_alias_tmpl_info->put (tmpl, boolean_false_node);
6752 : 4723538 : return false;
6753 : : }
6754 : :
6755 : : /* If T is a specialization of a complex alias template with a dependent
6756 : : argument for an unused template parameter, return it; otherwise return
6757 : : NULL_TREE. If T is a typedef to such a specialization, return the
6758 : : specialization. This predicate is usually checked alongside
6759 : : dependent_opaque_alias_p. Whereas dependent_opaque_alias_p checks
6760 : : type equivalence of an alias vs its expansion, this predicate more
6761 : : broadly checks SFINAE equivalence. */
6762 : :
6763 : : tree
6764 : 205380959 : dependent_alias_template_spec_p (const_tree t, bool transparent_typedefs)
6765 : : {
6766 : 205380959 : if (t == error_mark_node)
6767 : : return NULL_TREE;
6768 : 179439933 : gcc_assert (TYPE_P (t));
6769 : :
6770 : 179439933 : if (!processing_template_decl || !typedef_variant_p (t))
6771 : : return NULL_TREE;
6772 : :
6773 : 107649833 : if (tree tinfo = TYPE_ALIAS_TEMPLATE_INFO (t))
6774 : : {
6775 : 96862827 : tree seen = NULL_TREE;
6776 : 96862827 : if (complex_alias_template_p (TI_TEMPLATE (tinfo), &seen))
6777 : : {
6778 : 17314959 : tree args = INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo));
6779 : 17314959 : if (!seen)
6780 : : {
6781 : 8053831 : if (any_dependent_template_arguments_p (args))
6782 : 17314959 : return CONST_CAST_TREE (t);
6783 : : }
6784 : : else
6785 : : {
6786 : 9261128 : gcc_assert (TREE_VEC_LENGTH (args) == TREE_VEC_LENGTH (seen));
6787 : 15129345 : for (int i = 0, len = TREE_VEC_LENGTH (args); i < len; ++i)
6788 : 12993218 : if (TREE_VEC_ELT (seen, i) != boolean_true_node
6789 : 12993218 : && dependent_template_arg_p (TREE_VEC_ELT (args, i)))
6790 : : return CONST_CAST_TREE (t);
6791 : : }
6792 : :
6793 : 2174371 : return NULL_TREE;
6794 : : }
6795 : : }
6796 : :
6797 : 90334874 : if (transparent_typedefs && !dependent_opaque_alias_p (t))
6798 : : {
6799 : 753155 : tree utype = DECL_ORIGINAL_TYPE (TYPE_NAME (t));
6800 : 753155 : return dependent_alias_template_spec_p (utype, transparent_typedefs);
6801 : : }
6802 : :
6803 : : return NULL_TREE;
6804 : : }
6805 : :
6806 : : /* Return true if substituting into T would yield a different type than
6807 : : substituting into its expansion. This predicate is usually checked
6808 : : alongside dependent_alias_template_spec_p. */
6809 : :
6810 : : bool
6811 : 293751669 : dependent_opaque_alias_p (const_tree t)
6812 : : {
6813 : 293751669 : return (TYPE_P (t)
6814 : 293751669 : && typedef_variant_p (t)
6815 : 570061743 : && (any_dependent_type_attributes_p (DECL_ATTRIBUTES
6816 : : (TYPE_NAME (t)))
6817 : : /* Treat a dependent decltype(lambda) alias as opaque so that we
6818 : : don't prematurely strip it when used as a template argument.
6819 : : Otherwise substitution into each occurrence of the (stripped)
6820 : : alias would incorrectly yield a distinct lambda type. */
6821 : 276309749 : || (TREE_CODE (t) == DECLTYPE_TYPE
6822 : 7859810 : && TREE_CODE (DECLTYPE_TYPE_EXPR (t)) == LAMBDA_EXPR
6823 : 96 : && !typedef_variant_p (DECL_ORIGINAL_TYPE (TYPE_NAME (t))))));
6824 : : }
6825 : :
6826 : : /* Return the number of innermost template parameters in TMPL. */
6827 : :
6828 : : static int
6829 : 52965400 : num_innermost_template_parms (const_tree tmpl)
6830 : : {
6831 : 52965400 : tree parms = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl));
6832 : 52965400 : return TREE_VEC_LENGTH (parms);
6833 : : }
6834 : :
6835 : : /* Return either TMPL or another template that it is equivalent to under DR
6836 : : 1286: An alias that just changes the name of a template is equivalent to
6837 : : the other template. */
6838 : :
6839 : : static tree
6840 : 78744805 : get_underlying_template (tree tmpl)
6841 : : {
6842 : 78744805 : gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
6843 : 81971957 : while (DECL_ALIAS_TEMPLATE_P (tmpl))
6844 : : {
6845 : : /* Determine if the alias is equivalent to an underlying template. */
6846 : 66308977 : tree orig_type = DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl));
6847 : : /* The underlying type may have been ill-formed. Don't proceed. */
6848 : 66308977 : if (!orig_type)
6849 : : break;
6850 : 66308974 : tree tinfo = TYPE_TEMPLATE_INFO_MAYBE_ALIAS (orig_type);
6851 : 26483109 : if (!tinfo)
6852 : : break;
6853 : :
6854 : 26482784 : tree underlying = TI_TEMPLATE (tinfo);
6855 : 26482784 : if (!PRIMARY_TEMPLATE_P (underlying)
6856 : 52965484 : || (num_innermost_template_parms (tmpl)
6857 : 26482700 : != num_innermost_template_parms (underlying)))
6858 : : break;
6859 : :
6860 : : /* Does the alias add cv-quals? */
6861 : 11320932 : if (TYPE_QUALS (TREE_TYPE (underlying)) != TYPE_QUALS (TREE_TYPE (tmpl)))
6862 : : break;
6863 : :
6864 : 11320911 : tree alias_args = INNERMOST_TEMPLATE_ARGS (generic_targs_for (tmpl));
6865 : 11320911 : if (!comp_template_args (TI_ARGS (tinfo), alias_args))
6866 : : break;
6867 : :
6868 : : /* Are any default template arguments equivalent? */
6869 : 3227305 : tree aparms = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl));
6870 : 3227305 : tree uparms = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (underlying));
6871 : 3227305 : const int nparms = TREE_VEC_LENGTH (aparms);
6872 : 6715055 : for (int i = 0; i < nparms; ++i)
6873 : : {
6874 : 3487840 : tree adefarg = TREE_PURPOSE (TREE_VEC_ELT (aparms, i));
6875 : 3487840 : tree udefarg = TREE_PURPOSE (TREE_VEC_ELT (uparms, i));
6876 : 3487840 : if (!template_args_equal (adefarg, udefarg))
6877 : 90 : goto top_break;
6878 : : }
6879 : :
6880 : : /* If TMPL adds or changes any constraints, it isn't equivalent. I think
6881 : : it's appropriate to treat a less-constrained alias as equivalent. */
6882 : 3227215 : if (!at_least_as_constrained (underlying, tmpl))
6883 : : break;
6884 : :
6885 : : /* If TMPL adds dependent type attributes, it isn't equivalent. */
6886 : 3227160 : if (dependent_opaque_alias_p (TREE_TYPE (tmpl)))
6887 : : break;
6888 : :
6889 : : /* Alias is equivalent. Strip it and repeat. */
6890 : : tmpl = underlying;
6891 : : }
6892 : 8094018 : top_break:;
6893 : :
6894 : 78744805 : return tmpl;
6895 : : }
6896 : :
6897 : : /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
6898 : : must be a reference-to-function or a pointer-to-function type, as specified
6899 : : in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
6900 : : and check that the resulting function has external linkage. */
6901 : :
6902 : : static tree
6903 : 751 : convert_nontype_argument_function (tree type, tree expr,
6904 : : tsubst_flags_t complain)
6905 : : {
6906 : 751 : tree fns = expr;
6907 : 751 : tree fn, fn_no_ptr;
6908 : 751 : linkage_kind linkage;
6909 : :
6910 : 751 : fn = instantiate_type (type, fns, tf_none);
6911 : 751 : if (fn == error_mark_node)
6912 : : return error_mark_node;
6913 : :
6914 : 746 : if (value_dependent_expression_p (fn))
6915 : 18 : goto accept;
6916 : :
6917 : 728 : fn_no_ptr = fn;
6918 : 728 : if (REFERENCE_REF_P (fn_no_ptr))
6919 : 10 : fn_no_ptr = TREE_OPERAND (fn_no_ptr, 0);
6920 : 728 : fn_no_ptr = strip_fnptr_conv (fn_no_ptr);
6921 : 728 : if (TREE_CODE (fn_no_ptr) == ADDR_EXPR)
6922 : 643 : fn_no_ptr = TREE_OPERAND (fn_no_ptr, 0);
6923 : 728 : if (BASELINK_P (fn_no_ptr))
6924 : 0 : fn_no_ptr = BASELINK_FUNCTIONS (fn_no_ptr);
6925 : :
6926 : : /* [temp.arg.nontype]/1
6927 : :
6928 : : A template-argument for a non-type, non-template template-parameter
6929 : : shall be one of:
6930 : : [...]
6931 : : -- the address of an object or function with external [C++11: or
6932 : : internal] linkage. */
6933 : :
6934 : 728 : STRIP_ANY_LOCATION_WRAPPER (fn_no_ptr);
6935 : 728 : if (TREE_CODE (fn_no_ptr) != FUNCTION_DECL)
6936 : : {
6937 : 27 : if (complain & tf_error)
6938 : : {
6939 : 17 : auto_diagnostic_group d;
6940 : 17 : location_t loc = cp_expr_loc_or_input_loc (expr);
6941 : 17 : error_at (loc, "%qE is not a valid template argument for type %qT",
6942 : : expr, type);
6943 : 17 : if (TYPE_PTR_P (type))
6944 : 13 : inform (loc, "it must be the address of a function "
6945 : : "with external linkage");
6946 : : else
6947 : 4 : inform (loc, "it must be the name of a function with "
6948 : : "external linkage");
6949 : 17 : }
6950 : 27 : return NULL_TREE;
6951 : : }
6952 : :
6953 : 701 : linkage = decl_linkage (fn_no_ptr);
6954 : 701 : if ((cxx_dialect < cxx11 && linkage != lk_external)
6955 : 700 : || (cxx_dialect < cxx17 && linkage == lk_none))
6956 : : {
6957 : 5 : if (complain & tf_error)
6958 : : {
6959 : 2 : location_t loc = cp_expr_loc_or_input_loc (expr);
6960 : 2 : if (cxx_dialect >= cxx11)
6961 : 2 : error_at (loc, "%qE is not a valid template argument for type "
6962 : : "%qT because %qD has no linkage",
6963 : : expr, type, fn_no_ptr);
6964 : : else
6965 : 0 : error_at (loc, "%qE is not a valid template argument for type "
6966 : : "%qT because %qD does not have external linkage",
6967 : : expr, type, fn_no_ptr);
6968 : : }
6969 : 5 : return NULL_TREE;
6970 : : }
6971 : :
6972 : 696 : accept:
6973 : 714 : if (TYPE_REF_P (type))
6974 : : {
6975 : 66 : if (REFERENCE_REF_P (fn))
6976 : 8 : fn = TREE_OPERAND (fn, 0);
6977 : : else
6978 : 58 : fn = build_address (fn);
6979 : : }
6980 : 714 : if (!same_type_ignoring_top_level_qualifiers_p (type, TREE_TYPE (fn)))
6981 : 58 : fn = build_nop (type, fn);
6982 : :
6983 : : return fn;
6984 : : }
6985 : :
6986 : : /* Subroutine of convert_nontype_argument.
6987 : : Check if EXPR of type TYPE is a valid pointer-to-member constant.
6988 : : Emit an error otherwise. */
6989 : :
6990 : : static bool
6991 : 824 : check_valid_ptrmem_cst_expr (tree type, tree expr,
6992 : : tsubst_flags_t complain)
6993 : : {
6994 : 824 : tree orig_expr = expr;
6995 : 824 : STRIP_NOPS (expr);
6996 : 824 : if (null_ptr_cst_p (expr))
6997 : : return true;
6998 : 824 : if (TREE_CODE (expr) == PTRMEM_CST
6999 : 824 : && same_type_p (TYPE_PTRMEM_CLASS_TYPE (type),
7000 : : PTRMEM_CST_CLASS (expr)))
7001 : : return true;
7002 : 79 : if (cxx_dialect >= cxx11 && null_member_pointer_value_p (expr))
7003 : : return true;
7004 : 37 : if (processing_template_decl
7005 : 0 : && TREE_CODE (expr) == ADDR_EXPR
7006 : 37 : && TREE_CODE (TREE_OPERAND (expr, 0)) == OFFSET_REF)
7007 : : return true;
7008 : 37 : if (complain & tf_error)
7009 : : {
7010 : 19 : auto_diagnostic_group d;
7011 : 19 : location_t loc = cp_expr_loc_or_input_loc (orig_expr);
7012 : 19 : error_at (loc, "%qE is not a valid template argument for type %qT",
7013 : : orig_expr, type);
7014 : 19 : if (TREE_CODE (expr) != PTRMEM_CST)
7015 : 10 : inform (loc, "it must be a pointer-to-member of the form %<&X::Y%>");
7016 : : else
7017 : 9 : inform (loc, "because it is a member of %qT", PTRMEM_CST_CLASS (expr));
7018 : 19 : }
7019 : : return false;
7020 : : }
7021 : :
7022 : : /* Returns TRUE iff the address of OP is value-dependent.
7023 : :
7024 : : 14.6.2.4 [temp.dep.temp]:
7025 : : A non-integral non-type template-argument is dependent if its type is
7026 : : dependent or it has either of the following forms
7027 : : qualified-id
7028 : : & qualified-id
7029 : : and contains a nested-name-specifier which specifies a class-name that
7030 : : names a dependent type.
7031 : :
7032 : : We generalize this to just say that the address of a member of a
7033 : : dependent class is value-dependent; the above doesn't cover the
7034 : : address of a static data member named with an unqualified-id. */
7035 : :
7036 : : static bool
7037 : 77581 : has_value_dependent_address (tree op)
7038 : : {
7039 : 77581 : STRIP_ANY_LOCATION_WRAPPER (op);
7040 : :
7041 : : /* We could use get_inner_reference here, but there's no need;
7042 : : this is only relevant for template non-type arguments, which
7043 : : can only be expressed as &id-expression. */
7044 : 77581 : if (DECL_P (op))
7045 : : {
7046 : 56180 : tree ctx = CP_DECL_CONTEXT (op);
7047 : :
7048 : 56180 : if (TYPE_P (ctx) && dependent_type_p (ctx))
7049 : : return true;
7050 : :
7051 : 56074 : if (VAR_P (op)
7052 : 56074 : && TREE_STATIC (op)
7053 : 3047 : && TREE_CODE (ctx) == FUNCTION_DECL
7054 : 56352 : && type_dependent_expression_p (ctx))
7055 : : return true;
7056 : : }
7057 : :
7058 : : return false;
7059 : : }
7060 : :
7061 : : /* The next set of functions are used for providing helpful explanatory
7062 : : diagnostics for failed overload resolution. Their messages should be
7063 : : indented by two spaces for consistency with the messages in
7064 : : call.cc */
7065 : :
7066 : : static int
7067 : 0 : unify_success (bool /*explain_p*/)
7068 : : {
7069 : 0 : return 0;
7070 : : }
7071 : :
7072 : : /* Other failure functions should call this one, to provide a single function
7073 : : for setting a breakpoint on. */
7074 : :
7075 : : static int
7076 : 0 : unify_invalid (bool /*explain_p*/)
7077 : : {
7078 : 0 : return 1;
7079 : : }
7080 : :
7081 : : static int
7082 : 163769 : unify_parameter_deduction_failure (bool explain_p, tree parm)
7083 : : {
7084 : 0 : if (explain_p)
7085 : 241 : inform (input_location,
7086 : : " couldn%'t deduce template parameter %qD", parm);
7087 : 0 : return unify_invalid (explain_p);
7088 : : }
7089 : :
7090 : : static int
7091 : 2148675 : unify_cv_qual_mismatch (bool explain_p, tree parm, tree arg)
7092 : : {
7093 : 0 : if (explain_p)
7094 : 56 : inform (input_location,
7095 : : " types %qT and %qT have incompatible cv-qualifiers",
7096 : : parm, arg);
7097 : 0 : return unify_invalid (explain_p);
7098 : : }
7099 : :
7100 : : static int
7101 : 169448126 : unify_type_mismatch (bool explain_p, tree parm, tree arg)
7102 : : {
7103 : 5041 : if (explain_p)
7104 : 801 : inform (input_location, " mismatched types %qT and %qT", parm, arg);
7105 : 5041 : return unify_invalid (explain_p);
7106 : : }
7107 : :
7108 : : static int
7109 : 460383 : unify_parameter_pack_mismatch (bool explain_p, tree parm, tree arg)
7110 : : {
7111 : 0 : if (explain_p)
7112 : 0 : inform (input_location,
7113 : : " template parameter %qD is not a parameter pack, but "
7114 : : "argument %qD is",
7115 : : parm, arg);
7116 : 0 : return unify_invalid (explain_p);
7117 : : }
7118 : :
7119 : : static int
7120 : 3 : unify_ptrmem_cst_mismatch (bool explain_p, tree parm, tree arg)
7121 : : {
7122 : 0 : if (explain_p)
7123 : 0 : inform (input_location,
7124 : : " template argument %qE does not match "
7125 : : "pointer-to-member constant %qE",
7126 : : arg, parm);
7127 : 0 : return unify_invalid (explain_p);
7128 : : }
7129 : :
7130 : : static int
7131 : 11 : unify_expression_unequal (bool explain_p, tree parm, tree arg)
7132 : : {
7133 : 0 : if (explain_p)
7134 : 0 : inform (input_location, " %qE is not equivalent to %qE", parm, arg);
7135 : 0 : return unify_invalid (explain_p);
7136 : : }
7137 : :
7138 : : static int
7139 : 18 : unify_parameter_pack_inconsistent (bool explain_p, tree old_arg, tree new_arg)
7140 : : {
7141 : 0 : if (explain_p)
7142 : 3 : inform (input_location,
7143 : : " inconsistent parameter pack deduction with %qT and %qT",
7144 : : old_arg, new_arg);
7145 : 18 : return unify_invalid (explain_p);
7146 : : }
7147 : :
7148 : : static int
7149 : 1296267 : unify_inconsistency (bool explain_p, tree parm, tree first, tree second)
7150 : : {
7151 : 1296267 : if (explain_p)
7152 : : {
7153 : 68 : if (TYPE_P (parm))
7154 : 62 : inform (input_location,
7155 : : " deduced conflicting types for parameter %qT (%qT and %qT)",
7156 : : parm, first, second);
7157 : : else
7158 : 6 : inform (input_location,
7159 : : " deduced conflicting values for non-type parameter "
7160 : : "%qE (%qE and %qE)", parm, first, second);
7161 : : }
7162 : 1296267 : return unify_invalid (explain_p);
7163 : : }
7164 : :
7165 : : static int
7166 : 20 : unify_vla_arg (bool explain_p, tree arg)
7167 : : {
7168 : 0 : if (explain_p)
7169 : 9 : inform (input_location,
7170 : : " variable-sized array type %qT is not "
7171 : : "a valid template argument",
7172 : : arg);
7173 : 0 : return unify_invalid (explain_p);
7174 : : }
7175 : :
7176 : : static int
7177 : 6 : unify_method_type_error (bool explain_p, tree arg)
7178 : : {
7179 : 0 : if (explain_p)
7180 : 0 : inform (input_location,
7181 : : " member function type %qT is not a valid template argument",
7182 : : arg);
7183 : 0 : return unify_invalid (explain_p);
7184 : : }
7185 : :
7186 : : static int
7187 : 1402981 : unify_arity (bool explain_p, int have, int wanted, bool least_p = false)
7188 : : {
7189 : 1402981 : if (explain_p)
7190 : : {
7191 : 3 : if (least_p)
7192 : 0 : inform_n (input_location, wanted,
7193 : : " candidate expects at least %d argument, %d provided",
7194 : : " candidate expects at least %d arguments, %d provided",
7195 : : wanted, have);
7196 : : else
7197 : 3 : inform_n (input_location, wanted,
7198 : : " candidate expects %d argument, %d provided",
7199 : : " candidate expects %d arguments, %d provided",
7200 : : wanted, have);
7201 : : }
7202 : 1402981 : return unify_invalid (explain_p);
7203 : : }
7204 : :
7205 : : static int
7206 : 45922 : unify_too_many_arguments (bool explain_p, int have, int wanted)
7207 : : {
7208 : 0 : return unify_arity (explain_p, have, wanted);
7209 : : }
7210 : :
7211 : : static int
7212 : 23080 : unify_too_few_arguments (bool explain_p, int have, int wanted,
7213 : : bool least_p = false)
7214 : : {
7215 : 0 : return unify_arity (explain_p, have, wanted, least_p);
7216 : : }
7217 : :
7218 : : static int
7219 : 2021006 : unify_arg_conversion (bool explain_p, tree to_type,
7220 : : tree from_type, tree arg)
7221 : : {
7222 : 2021006 : if (explain_p)
7223 : 301 : inform (cp_expr_loc_or_input_loc (arg),
7224 : : " cannot convert %qE (type %qT) to type %qT",
7225 : : arg, from_type, to_type);
7226 : 2021006 : return unify_invalid (explain_p);
7227 : : }
7228 : :
7229 : : static int
7230 : 72039030 : unify_no_common_base (bool explain_p, enum template_base_result r,
7231 : : tree parm, tree arg)
7232 : : {
7233 : 72039030 : if (explain_p)
7234 : 859 : switch (r)
7235 : : {
7236 : 3 : case tbr_ambiguous_baseclass:
7237 : 3 : inform (input_location, " %qT is an ambiguous base class of %qT",
7238 : : parm, arg);
7239 : 3 : break;
7240 : 856 : default:
7241 : 856 : inform (input_location, " %qT is not derived from %qT", arg, parm);
7242 : 856 : break;
7243 : : }
7244 : 72039030 : return unify_invalid (explain_p);
7245 : : }
7246 : :
7247 : : static int
7248 : 24 : unify_inconsistent_template_template_parameters (bool explain_p)
7249 : : {
7250 : 24 : if (explain_p)
7251 : 10 : inform (input_location,
7252 : : " template parameters of a template template argument are "
7253 : : "inconsistent with other deduced template arguments");
7254 : 24 : return unify_invalid (explain_p);
7255 : : }
7256 : :
7257 : : static int
7258 : 1027 : unify_template_deduction_failure (bool explain_p, tree parm, tree arg)
7259 : : {
7260 : 0 : if (explain_p)
7261 : 0 : inform (input_location,
7262 : : " cannot deduce a template for %qT from non-template type %qT",
7263 : : parm, arg);
7264 : 0 : return unify_invalid (explain_p);
7265 : : }
7266 : :
7267 : : static int
7268 : 4136651 : unify_template_argument_mismatch (bool explain_p, tree parm, tree arg)
7269 : : {
7270 : 0 : if (explain_p)
7271 : 9 : inform (input_location,
7272 : : " template argument %qE does not match %qE", arg, parm);
7273 : 0 : return unify_invalid (explain_p);
7274 : : }
7275 : :
7276 : : /* Subroutine of convert_nontype_argument, to check whether EXPR, as an
7277 : : argument for TYPE, points to an unsuitable object.
7278 : :
7279 : : Also adjust the type of the index in C++20 array subobject references. */
7280 : :
7281 : : static bool
7282 : 8809 : invalid_tparm_referent_p (tree type, tree expr, tsubst_flags_t complain)
7283 : : {
7284 : 8821 : switch (TREE_CODE (expr))
7285 : : {
7286 : 12 : CASE_CONVERT:
7287 : 12 : return invalid_tparm_referent_p (type, TREE_OPERAND (expr, 0),
7288 : 12 : complain);
7289 : :
7290 : 0 : case TARGET_EXPR:
7291 : 0 : return invalid_tparm_referent_p (type, TARGET_EXPR_INITIAL (expr),
7292 : 0 : complain);
7293 : :
7294 : 3665 : case CONSTRUCTOR:
7295 : 3665 : {
7296 : 16060 : for (auto &e: CONSTRUCTOR_ELTS (expr))
7297 : 6339 : if (invalid_tparm_referent_p (TREE_TYPE (e.value), e.value, complain))
7298 : : return true;
7299 : : }
7300 : : break;
7301 : :
7302 : 777 : case ADDR_EXPR:
7303 : 777 : {
7304 : 777 : tree decl = TREE_OPERAND (expr, 0);
7305 : :
7306 : 777 : if (cxx_dialect >= cxx20)
7307 : 441 : while (TREE_CODE (decl) == COMPONENT_REF
7308 : 441 : || TREE_CODE (decl) == ARRAY_REF)
7309 : : {
7310 : 92 : tree &op = TREE_OPERAND (decl, 1);
7311 : 92 : if (TREE_CODE (decl) == ARRAY_REF
7312 : 21 : && TREE_CODE (op) == INTEGER_CST)
7313 : : /* Canonicalize array offsets to ptrdiff_t; how they were
7314 : : written doesn't matter for subobject identity. */
7315 : 21 : op = fold_convert (ptrdiff_type_node, op);
7316 : 92 : decl = TREE_OPERAND (decl, 0);
7317 : : }
7318 : :
7319 : 777 : if (!VAR_OR_FUNCTION_DECL_P (decl))
7320 : : {
7321 : 18 : if (complain & tf_error)
7322 : 21 : error_at (cp_expr_loc_or_input_loc (expr),
7323 : : "%qE is not a valid template argument of type %qT "
7324 : : "because %qE is not a variable or function",
7325 : : expr, type, decl);
7326 : 18 : return true;
7327 : : }
7328 : 759 : else if (cxx_dialect < cxx11 && !DECL_EXTERNAL_LINKAGE_P (decl))
7329 : : {
7330 : 2 : if (complain & tf_error)
7331 : 3 : error_at (cp_expr_loc_or_input_loc (expr),
7332 : : "%qE is not a valid template argument of type %qT "
7333 : : "in C++98 because %qD does not have external linkage",
7334 : : expr, type, decl);
7335 : 2 : return true;
7336 : : }
7337 : 757 : else if ((cxx_dialect >= cxx11 && cxx_dialect < cxx17)
7338 : 757 : && decl_linkage (decl) == lk_none)
7339 : : {
7340 : 7 : if (complain & tf_error)
7341 : 14 : error_at (cp_expr_loc_or_input_loc (expr),
7342 : : "%qE is not a valid template argument of type %qT "
7343 : : "because %qD has no linkage", expr, type, decl);
7344 : 7 : return true;
7345 : : }
7346 : : /* C++17: For a non-type template-parameter of reference or pointer
7347 : : type, the value of the constant expression shall not refer to (or
7348 : : for a pointer type, shall not be the address of):
7349 : : * a subobject (4.5),
7350 : : * a temporary object (15.2),
7351 : : * a string literal (5.13.5),
7352 : : * the result of a typeid expression (8.2.8), or
7353 : : * a predefined __func__ variable (11.4.1). */
7354 : 741 : else if (VAR_P (decl) && DECL_ARTIFICIAL (decl)
7355 : 762 : && !DECL_NTTP_OBJECT_P (decl))
7356 : : {
7357 : 0 : gcc_checking_assert (DECL_TINFO_P (decl) || DECL_FNAME_P (decl));
7358 : 0 : if (complain & tf_error)
7359 : 0 : error ("the address of %qD is not a valid template argument",
7360 : : decl);
7361 : 0 : return true;
7362 : : }
7363 : 750 : else if (cxx_dialect < cxx20
7364 : 1159 : && !(same_type_ignoring_top_level_qualifiers_p
7365 : 409 : (strip_array_types (TREE_TYPE (type)),
7366 : 409 : strip_array_types (TREE_TYPE (decl)))))
7367 : : {
7368 : 6 : if (complain & tf_error)
7369 : 4 : error ("the address of the %qT subobject of %qD is not a "
7370 : 4 : "valid template argument", TREE_TYPE (type), decl);
7371 : 6 : return true;
7372 : : }
7373 : 744 : else if (!TREE_STATIC (decl) && !DECL_EXTERNAL (decl))
7374 : : {
7375 : 1 : if (complain & tf_error)
7376 : 1 : error ("the address of %qD is not a valid template argument "
7377 : : "because it does not have static storage duration",
7378 : : decl);
7379 : 1 : return true;
7380 : : }
7381 : : }
7382 : : break;
7383 : :
7384 : 4367 : default:
7385 : 4367 : if (!INDIRECT_TYPE_P (type))
7386 : : /* We're only concerned about pointers and references here. */;
7387 : 166 : else if (cxx_dialect >= cxx11 && integer_zerop (expr))
7388 : : /* Null pointer values are OK in C++11. */;
7389 : : else
7390 : : {
7391 : 11 : if (VAR_P (expr))
7392 : : {
7393 : 6 : if (complain & tf_error)
7394 : 6 : error ("%qD is not a valid template argument "
7395 : : "because %qD is a variable, not the address of "
7396 : : "a variable", expr, expr);
7397 : 6 : return true;
7398 : : }
7399 : : else
7400 : : {
7401 : 5 : if (complain & tf_error)
7402 : 2 : error ("%qE is not a valid template argument for %qT "
7403 : : "because it is not the address of a variable",
7404 : : expr, type);
7405 : 5 : return true;
7406 : : }
7407 : : }
7408 : : }
7409 : : return false;
7410 : :
7411 : : }
7412 : :
7413 : : /* Return a VAR_DECL for the C++20 template parameter object corresponding to
7414 : : template argument EXPR. */
7415 : :
7416 : : static tree
7417 : 1707 : create_template_parm_object (tree expr, tsubst_flags_t complain)
7418 : : {
7419 : 1707 : tree orig = expr;
7420 : 1707 : if (TREE_CODE (expr) == TARGET_EXPR)
7421 : 1707 : expr = TARGET_EXPR_INITIAL (expr);
7422 : :
7423 : 1707 : if (!TREE_CONSTANT (expr))
7424 : : {
7425 : 7 : if ((complain & tf_error)
7426 : 7 : && require_rvalue_constant_expression (orig))
7427 : 7 : cxx_constant_value (orig);
7428 : 7 : return error_mark_node;
7429 : : }
7430 : 1700 : if (invalid_tparm_referent_p (TREE_TYPE (expr), expr, complain))
7431 : 0 : return error_mark_node;
7432 : :
7433 : : /* This is no longer a compound literal. */
7434 : 1700 : gcc_assert (!TREE_HAS_CONSTRUCTOR (expr));
7435 : :
7436 : 1700 : return get_template_parm_object (expr, mangle_template_parm_object (expr));
7437 : : }
7438 : :
7439 : : /* The template arguments corresponding to template parameter objects of types
7440 : : that contain pointers to members. */
7441 : :
7442 : : static GTY(()) hash_map<tree, tree> *tparm_obj_values;
7443 : :
7444 : : /* Find or build an nttp object for (already-validated) EXPR with name
7445 : : NAME. When CHECK_INIT is false we don't need to process the initialiser,
7446 : : it's already been done. */
7447 : :
7448 : : tree
7449 : 1703 : get_template_parm_object (tree expr, tree name, bool check_init/*=true*/)
7450 : : {
7451 : 1703 : tree decl = get_global_binding (name);
7452 : 1703 : if (decl)
7453 : : return decl;
7454 : :
7455 : 513 : tree type = cp_build_qualified_type (TREE_TYPE (expr), TYPE_QUAL_CONST);
7456 : 513 : decl = create_temporary_var (type);
7457 : 513 : DECL_NTTP_OBJECT_P (decl) = true;
7458 : 513 : DECL_CONTEXT (decl) = NULL_TREE;
7459 : 513 : TREE_STATIC (decl) = true;
7460 : 513 : DECL_DECLARED_CONSTEXPR_P (decl) = true;
7461 : 513 : TREE_READONLY (decl) = true;
7462 : 513 : DECL_NAME (decl) = name;
7463 : 513 : SET_DECL_ASSEMBLER_NAME (decl, name);
7464 : 513 : comdat_linkage (decl);
7465 : :
7466 : 513 : if (!zero_init_p (type))
7467 : : {
7468 : : /* If EXPR contains any PTRMEM_CST, they will get clobbered by
7469 : : lower_var_init before we're done mangling. So store the original
7470 : : value elsewhere. We only need to unshare EXPR if it's not yet
7471 : : been processed. */
7472 : 28 : tree copy = check_init ? unshare_constructor (expr) : expr;
7473 : 28 : hash_map_safe_put<hm_ggc> (tparm_obj_values, decl, copy);
7474 : : }
7475 : :
7476 : 513 : if (!check_init)
7477 : : {
7478 : : /* The EXPR is the already processed initializer, set it on the NTTP
7479 : : object now so that cp_finish_decl doesn't do it again later. */
7480 : 2 : DECL_INITIAL (decl) = expr;
7481 : 2 : DECL_INITIALIZED_P (decl) = 1;
7482 : : }
7483 : :
7484 : 513 : pushdecl_top_level_and_finish (decl, expr);
7485 : :
7486 : 513 : return decl;
7487 : : }
7488 : :
7489 : : /* Return the actual template argument corresponding to template parameter
7490 : : object VAR. */
7491 : :
7492 : : tree
7493 : 5663 : tparm_object_argument (tree var)
7494 : : {
7495 : 5663 : if (zero_init_p (TREE_TYPE (var)))
7496 : 5646 : return DECL_INITIAL (var);
7497 : 17 : return *(tparm_obj_values->get (var));
7498 : : }
7499 : :
7500 : : /* Attempt to convert the non-type template parameter EXPR to the
7501 : : indicated TYPE. If the conversion is successful, return the
7502 : : converted value. If the conversion is unsuccessful, return
7503 : : NULL_TREE if we issued an error message, or error_mark_node if we
7504 : : did not. We issue error messages for out-and-out bad template
7505 : : parameters, but not simply because the conversion failed, since we
7506 : : might be just trying to do argument deduction. Both TYPE and EXPR
7507 : : must be non-dependent.
7508 : :
7509 : : The conversion follows the special rules described in
7510 : : [temp.arg.nontype], and it is much more strict than an implicit
7511 : : conversion.
7512 : :
7513 : : This function is called twice for each template argument (see
7514 : : lookup_template_class for a more accurate description of this
7515 : : problem). This means that we need to handle expressions which
7516 : : are not valid in a C++ source, but can be created from the
7517 : : first call (for instance, casts to perform conversions). These
7518 : : hacks can go away after we fix the double coercion problem. */
7519 : :
7520 : : static tree
7521 : 126212169 : convert_nontype_argument (tree type, tree expr, tsubst_flags_t complain)
7522 : : {
7523 : 126212169 : tree expr_type;
7524 : 126212169 : location_t loc = cp_expr_loc_or_input_loc (expr);
7525 : :
7526 : : /* Detect immediately string literals as invalid non-type argument.
7527 : : This special-case is not needed for correctness (we would easily
7528 : : catch this later), but only to provide better diagnostic for this
7529 : : common user mistake. As suggested by DR 100, we do not mention
7530 : : linkage issues in the diagnostic as this is not the point. */
7531 : 126212169 : if (TREE_CODE (expr) == STRING_CST && !CLASS_TYPE_P (type))
7532 : : {
7533 : 6 : if (complain & tf_error)
7534 : 6 : error ("%qE is not a valid template argument for type %qT "
7535 : : "because string literals can never be used in this context",
7536 : : expr, type);
7537 : 6 : return NULL_TREE;
7538 : : }
7539 : :
7540 : : /* Add the ADDR_EXPR now for the benefit of
7541 : : value_dependent_expression_p. */
7542 : 1358 : if (TYPE_PTROBV_P (type)
7543 : 126212811 : && TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE)
7544 : : {
7545 : 94 : expr = decay_conversion (expr, complain);
7546 : 94 : if (expr == error_mark_node)
7547 : : return error_mark_node;
7548 : : }
7549 : :
7550 : : /* If we are in a template, EXPR may be non-dependent, but still
7551 : : have a syntactic, rather than semantic, form. For example, EXPR
7552 : : might be a SCOPE_REF, rather than the VAR_DECL to which the
7553 : : SCOPE_REF refers. Preserving the qualifying scope is necessary
7554 : : so that access checking can be performed when the template is
7555 : : instantiated -- but here we need the resolved form so that we can
7556 : : convert the argument. */
7557 : 126212163 : bool non_dep = false;
7558 : 442 : if (TYPE_REF_OBJ_P (type)
7559 : 126212523 : && has_value_dependent_address (expr))
7560 : : /* If we want the address and it's value-dependent, don't fold. */;
7561 : 126212142 : else if (processing_template_decl
7562 : 126212142 : && !instantiation_dependent_expression_p (expr))
7563 : : non_dep = true;
7564 : 126212163 : if (error_operand_p (expr))
7565 : 638 : return error_mark_node;
7566 : 126211525 : expr_type = TREE_TYPE (expr);
7567 : :
7568 : : /* If the argument is non-dependent, perform any conversions in
7569 : : non-dependent context as well. */
7570 : 126211525 : processing_template_decl_sentinel s (non_dep);
7571 : 19312061 : if (non_dep)
7572 : 19312061 : expr = instantiate_non_dependent_expr_internal (expr, complain);
7573 : :
7574 : 126211525 : bool val_dep_p = value_dependent_expression_p (expr);
7575 : 126211525 : if (val_dep_p)
7576 : 21987295 : expr = canonicalize_expr_argument (expr, complain);
7577 : : else
7578 : 104224230 : STRIP_ANY_LOCATION_WRAPPER (expr);
7579 : :
7580 : : /* 14.3.2/5: The null pointer{,-to-member} conversion is applied
7581 : : to a non-type argument of "nullptr". */
7582 : 126211525 : if (NULLPTR_TYPE_P (expr_type) && TYPE_PTR_OR_PTRMEM_P (type))
7583 : 86 : expr = fold_simple (convert (type, expr));
7584 : :
7585 : : /* In C++11, integral or enumeration non-type template arguments can be
7586 : : arbitrary constant expressions. Pointer and pointer to
7587 : : member arguments can be general constant expressions that evaluate
7588 : : to a null value, but otherwise still need to be of a specific form. */
7589 : 126211525 : if (cxx_dialect >= cxx11)
7590 : : {
7591 : 126180081 : if (TREE_CODE (expr) == PTRMEM_CST && TYPE_PTRMEM_P (type))
7592 : : /* A PTRMEM_CST is already constant, and a valid template
7593 : : argument for a parameter of pointer to member type, we just want
7594 : : to leave it in that form rather than lower it to a
7595 : : CONSTRUCTOR. */;
7596 : 126179537 : else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type)
7597 : 3630 : || cxx_dialect >= cxx17)
7598 : : {
7599 : : /* C++17: A template-argument for a non-type template-parameter shall
7600 : : be a converted constant expression (8.20) of the type of the
7601 : : template-parameter. */
7602 : 126179282 : expr = build_converted_constant_expr (type, expr, complain);
7603 : 126179282 : if (expr == error_mark_node)
7604 : : /* Make sure we return NULL_TREE only if we have really issued
7605 : : an error, as described above. */
7606 : 239 : return (complain & tf_error) ? NULL_TREE : error_mark_node;
7607 : 126179099 : else if (TREE_CODE (expr) == IMPLICIT_CONV_EXPR)
7608 : : {
7609 : 3604935 : IMPLICIT_CONV_EXPR_NONTYPE_ARG (expr) = true;
7610 : 3604935 : return expr;
7611 : : }
7612 : 122574164 : expr = maybe_constant_value (expr, NULL_TREE, mce_true);
7613 : 122574164 : expr = convert_from_reference (expr);
7614 : : /* EXPR may have become value-dependent. */
7615 : 122574164 : val_dep_p = value_dependent_expression_p (expr);
7616 : : }
7617 : 255 : else if (TYPE_PTR_OR_PTRMEM_P (type))
7618 : : {
7619 : 210 : tree folded = maybe_constant_value (expr, NULL_TREE, mce_true);
7620 : 235 : if (TYPE_PTR_P (type) ? integer_zerop (folded)
7621 : 25 : : null_member_pointer_value_p (folded))
7622 : 122606407 : expr = folded;
7623 : : }
7624 : : }
7625 : :
7626 : 122606407 : if (TYPE_REF_P (type))
7627 : 422 : expr = mark_lvalue_use (expr);
7628 : : else
7629 : 122605985 : expr = mark_rvalue_use (expr);
7630 : :
7631 : : /* HACK: Due to double coercion, we can get a
7632 : : NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
7633 : : which is the tree that we built on the first call (see
7634 : : below when coercing to reference to object or to reference to
7635 : : function). We just strip everything and get to the arg.
7636 : : See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
7637 : : for examples. */
7638 : 122606407 : if (TYPE_REF_OBJ_P (type) || TYPE_REFFN_P (type))
7639 : : {
7640 : : /* Check this before we strip *& to avoid redundancy. */
7641 : 422 : if (!mark_single_function (expr, complain))
7642 : 0 : return error_mark_node;
7643 : :
7644 : 422 : tree probe_type, probe = expr;
7645 : 422 : if (REFERENCE_REF_P (probe))
7646 : 349 : probe = TREE_OPERAND (probe, 0);
7647 : 422 : probe_type = TREE_TYPE (probe);
7648 : 422 : if (TREE_CODE (probe) == NOP_EXPR)
7649 : : {
7650 : : /* ??? Maybe we could use convert_from_reference here, but we
7651 : : would need to relax its constraints because the NOP_EXPR
7652 : : could actually change the type to something more cv-qualified,
7653 : : and this is not folded by convert_from_reference. */
7654 : 316 : tree addr = TREE_OPERAND (probe, 0);
7655 : 316 : if (TYPE_REF_P (probe_type)
7656 : 316 : && TREE_CODE (addr) == ADDR_EXPR
7657 : 314 : && TYPE_PTR_P (TREE_TYPE (addr))
7658 : 630 : && (same_type_ignoring_top_level_qualifiers_p
7659 : 314 : (TREE_TYPE (probe_type),
7660 : 314 : TREE_TYPE (TREE_TYPE (addr)))))
7661 : : {
7662 : 304 : expr = TREE_OPERAND (addr, 0);
7663 : 304 : expr_type = TREE_TYPE (probe_type);
7664 : : }
7665 : : }
7666 : : }
7667 : :
7668 : : /* [temp.arg.nontype]/5, bullet 1
7669 : :
7670 : : For a non-type template-parameter of integral or enumeration type,
7671 : : integral promotions (_conv.prom_) and integral conversions
7672 : : (_conv.integral_) are applied. */
7673 : 122606407 : if (INTEGRAL_OR_ENUMERATION_TYPE_P (type)
7674 : 4475 : || SCALAR_FLOAT_TYPE_P (type))
7675 : : {
7676 : 122602030 : if (cxx_dialect < cxx11)
7677 : : {
7678 : 31004 : tree t = build_converted_constant_expr (type, expr, complain);
7679 : 31004 : t = maybe_constant_value (t);
7680 : 31004 : if (t != error_mark_node)
7681 : 122602030 : expr = t;
7682 : : }
7683 : :
7684 : 122602030 : if (!same_type_ignoring_top_level_qualifiers_p (type, TREE_TYPE (expr)))
7685 : 11 : return error_mark_node;
7686 : :
7687 : : /* Notice that there are constant expressions like '4 % 0' which
7688 : : do not fold into integer constants. */
7689 : 122602019 : if (!CONSTANT_CLASS_P (expr) && !val_dep_p)
7690 : : {
7691 : 136 : if (complain & tf_error)
7692 : : {
7693 : 67 : int errs = errorcount, warns = warningcount + werrorcount;
7694 : 67 : if (!require_potential_constant_expression (expr))
7695 : 19 : expr = error_mark_node;
7696 : : else
7697 : 48 : expr = cxx_constant_value (expr);
7698 : 67 : if (errorcount > errs || warningcount + werrorcount > warns)
7699 : 54 : inform (loc, "in template argument for type %qT", type);
7700 : 67 : if (expr == error_mark_node)
7701 : : return NULL_TREE;
7702 : : /* else cxx_constant_value complained but gave us
7703 : : a real constant, so go ahead. */
7704 : 3 : if (!CONSTANT_CLASS_P (expr))
7705 : : {
7706 : : /* Some assemble time constant expressions like
7707 : : (intptr_t)&&lab1 - (intptr_t)&&lab2 or
7708 : : 4 + (intptr_t)&&var satisfy reduced_constant_expression_p
7709 : : as we can emit them into .rodata initializers of
7710 : : variables, yet they can't fold into an INTEGER_CST at
7711 : : compile time. Refuse them here. */
7712 : 0 : gcc_checking_assert (reduced_constant_expression_p (expr));
7713 : 0 : error_at (loc, "template argument %qE for type %qT not "
7714 : : "a compile-time constant", expr, type);
7715 : 0 : return NULL_TREE;
7716 : : }
7717 : : }
7718 : : else
7719 : : return NULL_TREE;
7720 : : }
7721 : :
7722 : : /* Avoid typedef problems. */
7723 : 122601886 : if (TREE_TYPE (expr) != type)
7724 : 582489 : expr = fold_convert (type, expr);
7725 : : }
7726 : : /* [temp.arg.nontype]/5, bullet 2
7727 : :
7728 : : For a non-type template-parameter of type pointer to object,
7729 : : qualification conversions (_conv.qual_) and the array-to-pointer
7730 : : conversion (_conv.array_) are applied. */
7731 : 4377 : else if (TYPE_PTROBV_P (type))
7732 : : {
7733 : 602 : tree decayed = expr;
7734 : :
7735 : : /* Look through any NOP_EXPRs around an ADDR_EXPR, whether they come from
7736 : : decay_conversion or an explicit cast. If it's a problematic cast,
7737 : : we'll complain about it below. */
7738 : 602 : if (TREE_CODE (expr) == NOP_EXPR)
7739 : : {
7740 : 153 : tree probe = expr;
7741 : 153 : STRIP_NOPS (probe);
7742 : 153 : if (TREE_CODE (probe) == ADDR_EXPR
7743 : 153 : && TYPE_PTR_P (TREE_TYPE (probe)))
7744 : : {
7745 : 150 : expr = probe;
7746 : 150 : expr_type = TREE_TYPE (expr);
7747 : : }
7748 : : }
7749 : :
7750 : : /* [temp.arg.nontype]/1 (TC1 version, DR 49):
7751 : :
7752 : : A template-argument for a non-type, non-template template-parameter
7753 : : shall be one of: [...]
7754 : :
7755 : : -- the name of a non-type template-parameter;
7756 : : -- the address of an object or function with external linkage, [...]
7757 : : expressed as "& id-expression" where the & is optional if the name
7758 : : refers to a function or array, or if the corresponding
7759 : : template-parameter is a reference.
7760 : :
7761 : : Here, we do not care about functions, as they are invalid anyway
7762 : : for a parameter of type pointer-to-object. */
7763 : :
7764 : 602 : if (val_dep_p)
7765 : : /* Non-type template parameters are OK. */
7766 : : ;
7767 : 541 : else if (cxx_dialect >= cxx11 && integer_zerop (expr))
7768 : : /* Null pointer values are OK in C++11. */;
7769 : 484 : else if (TREE_CODE (expr) != ADDR_EXPR
7770 : 36 : && !INDIRECT_TYPE_P (expr_type))
7771 : : /* Other values, like integer constants, might be valid
7772 : : non-type arguments of some other type. */
7773 : 25 : return error_mark_node;
7774 : 459 : else if (invalid_tparm_referent_p (type, expr, complain))
7775 : : return NULL_TREE;
7776 : :
7777 : 534 : expr = decayed;
7778 : :
7779 : 534 : expr = perform_qualification_conversions (type, expr);
7780 : 534 : if (expr == error_mark_node)
7781 : : return error_mark_node;
7782 : : }
7783 : : /* [temp.arg.nontype]/5, bullet 3
7784 : :
7785 : : For a non-type template-parameter of type reference to object, no
7786 : : conversions apply. The type referred to by the reference may be more
7787 : : cv-qualified than the (otherwise identical) type of the
7788 : : template-argument. The template-parameter is bound directly to the
7789 : : template-argument, which must be an lvalue. */
7790 : 3775 : else if (TYPE_REF_OBJ_P (type))
7791 : : {
7792 : 348 : if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type),
7793 : : expr_type))
7794 : 0 : return error_mark_node;
7795 : :
7796 : 348 : if (!at_least_as_qualified_p (TREE_TYPE (type), expr_type))
7797 : : {
7798 : 2 : if (complain & tf_error)
7799 : 1 : error ("%qE is not a valid template argument for type %qT "
7800 : : "because of conflicts in cv-qualification", expr, type);
7801 : 2 : return NULL_TREE;
7802 : : }
7803 : :
7804 : 346 : if (!lvalue_p (expr))
7805 : : {
7806 : 6 : if (complain & tf_error)
7807 : 6 : error ("%qE is not a valid template argument for type %qT "
7808 : : "because it is not an lvalue", expr, type);
7809 : 6 : return NULL_TREE;
7810 : : }
7811 : :
7812 : : /* [temp.arg.nontype]/1
7813 : :
7814 : : A template-argument for a non-type, non-template template-parameter
7815 : : shall be one of: [...]
7816 : :
7817 : : -- the address of an object or function with external linkage. */
7818 : 340 : if (INDIRECT_REF_P (expr)
7819 : 340 : && TYPE_REF_OBJ_P (TREE_TYPE (TREE_OPERAND (expr, 0))))
7820 : : {
7821 : 29 : expr = TREE_OPERAND (expr, 0);
7822 : 29 : if (DECL_P (expr))
7823 : : {
7824 : 3 : if (complain & tf_error)
7825 : 3 : error ("%q#D is not a valid template argument for type %qT "
7826 : : "because a reference variable does not have a constant "
7827 : : "address", expr, type);
7828 : 3 : return NULL_TREE;
7829 : : }
7830 : : }
7831 : :
7832 : 337 : if (TYPE_REF_OBJ_P (TREE_TYPE (expr)) && val_dep_p)
7833 : : /* OK, dependent reference. We don't want to ask whether a DECL is
7834 : : itself value-dependent, since what we want here is its address. */;
7835 : : else
7836 : : {
7837 : 311 : expr = build_address (expr);
7838 : :
7839 : 311 : if (invalid_tparm_referent_p (type, expr, complain))
7840 : : return NULL_TREE;
7841 : : }
7842 : :
7843 : 335 : if (!same_type_p (type, TREE_TYPE (expr)))
7844 : 309 : expr = build_nop (type, expr);
7845 : : }
7846 : : /* [temp.arg.nontype]/5, bullet 4
7847 : :
7848 : : For a non-type template-parameter of type pointer to function, only
7849 : : the function-to-pointer conversion (_conv.func_) is applied. If the
7850 : : template-argument represents a set of overloaded functions (or a
7851 : : pointer to such), the matching function is selected from the set
7852 : : (_over.over_). */
7853 : 3427 : else if (TYPE_PTRFN_P (type))
7854 : : {
7855 : : /* If the argument is a template-id, we might not have enough
7856 : : context information to decay the pointer. */
7857 : 692 : if (!type_unknown_p (expr_type))
7858 : : {
7859 : 433 : expr = decay_conversion (expr, complain);
7860 : 433 : if (expr == error_mark_node)
7861 : : return error_mark_node;
7862 : : }
7863 : :
7864 : 688 : if (cxx_dialect >= cxx11 && integer_zerop (expr))
7865 : : /* Null pointer values are OK in C++11. */
7866 : 11 : return perform_qualification_conversions (type, expr);
7867 : :
7868 : 677 : expr = convert_nontype_argument_function (type, expr, complain);
7869 : 677 : if (!expr || expr == error_mark_node)
7870 : : return expr;
7871 : : }
7872 : : /* [temp.arg.nontype]/5, bullet 5
7873 : :
7874 : : For a non-type template-parameter of type reference to function, no
7875 : : conversions apply. If the template-argument represents a set of
7876 : : overloaded functions, the matching function is selected from the set
7877 : : (_over.over_). */
7878 : 2735 : else if (TYPE_REFFN_P (type))
7879 : : {
7880 : 74 : if (TREE_CODE (expr) == ADDR_EXPR)
7881 : : {
7882 : 0 : if (complain & tf_error)
7883 : : {
7884 : 0 : auto_diagnostic_group d;
7885 : 0 : error ("%qE is not a valid template argument for type %qT "
7886 : : "because it is a pointer", expr, type);
7887 : 0 : inform (input_location, "try using %qE instead",
7888 : 0 : TREE_OPERAND (expr, 0));
7889 : 0 : }
7890 : 0 : return NULL_TREE;
7891 : : }
7892 : :
7893 : 74 : expr = convert_nontype_argument_function (type, expr, complain);
7894 : 74 : if (!expr || expr == error_mark_node)
7895 : : return expr;
7896 : : }
7897 : : /* [temp.arg.nontype]/5, bullet 6
7898 : :
7899 : : For a non-type template-parameter of type pointer to member function,
7900 : : no conversions apply. If the template-argument represents a set of
7901 : : overloaded member functions, the matching member function is selected
7902 : : from the set (_over.over_). */
7903 : 2661 : else if (TYPE_PTRMEMFUNC_P (type))
7904 : : {
7905 : 520 : expr = instantiate_type (type, expr, tf_none);
7906 : 520 : if (expr == error_mark_node)
7907 : : return error_mark_node;
7908 : :
7909 : : /* [temp.arg.nontype] bullet 1 says the pointer to member
7910 : : expression must be a pointer-to-member constant. */
7911 : 488 : if (!val_dep_p
7912 : 488 : && !check_valid_ptrmem_cst_expr (type, expr, complain))
7913 : : return NULL_TREE;
7914 : :
7915 : : /* Repeated conversion can't deal with a conversion that turns PTRMEM_CST
7916 : : into a CONSTRUCTOR, so build up a new PTRMEM_CST instead. */
7917 : 471 : if (fnptr_conv_p (type, TREE_TYPE (expr)))
7918 : 3 : expr = make_ptrmem_cst (type, PTRMEM_CST_MEMBER (expr));
7919 : : }
7920 : : /* [temp.arg.nontype]/5, bullet 7
7921 : :
7922 : : For a non-type template-parameter of type pointer to data member,
7923 : : qualification conversions (_conv.qual_) are applied. */
7924 : 2141 : else if (TYPE_PTRDATAMEM_P (type))
7925 : : {
7926 : : /* [temp.arg.nontype] bullet 1 says the pointer to member
7927 : : expression must be a pointer-to-member constant. */
7928 : 371 : if (!val_dep_p
7929 : 371 : && !check_valid_ptrmem_cst_expr (type, expr, complain))
7930 : : return NULL_TREE;
7931 : :
7932 : 351 : expr = perform_qualification_conversions (type, expr);
7933 : 351 : if (expr == error_mark_node)
7934 : : return expr;
7935 : : }
7936 : 1770 : else if (NULLPTR_TYPE_P (type))
7937 : : {
7938 : 15 : if (!NULLPTR_TYPE_P (TREE_TYPE (expr)))
7939 : : {
7940 : 0 : if (complain & tf_error)
7941 : 0 : error ("%qE is not a valid template argument for type %qT "
7942 : 0 : "because it is of type %qT", expr, type, TREE_TYPE (expr));
7943 : 0 : return NULL_TREE;
7944 : : }
7945 : : return expr;
7946 : : }
7947 : 1755 : else if (CLASS_TYPE_P (type))
7948 : : {
7949 : : /* Replace the argument with a reference to the corresponding template
7950 : : parameter object. */
7951 : 1755 : if (!val_dep_p)
7952 : 1707 : expr = create_template_parm_object (expr, complain);
7953 : 1755 : if (expr == error_mark_node)
7954 : : return NULL_TREE;
7955 : : }
7956 : : /* A template non-type parameter must be one of the above. */
7957 : : else
7958 : 0 : gcc_unreachable ();
7959 : :
7960 : : /* Sanity check: did we actually convert the argument to the
7961 : : right type? */
7962 : 122606032 : gcc_assert (same_type_ignoring_top_level_qualifiers_p
7963 : : (type, TREE_TYPE (expr)));
7964 : 122606032 : return convert_from_reference (expr);
7965 : 126211525 : }
7966 : :
7967 : : /* Subroutine of coerce_template_template_parms, which returns true if
7968 : : PARM and ARG match using the rule for the template parameters of
7969 : : template template parameters. Both PARM and ARG are template parameters;
7970 : : the rest of the arguments are the same as for
7971 : : coerce_template_template_parms. */
7972 : :
7973 : : static bool
7974 : 862807 : coerce_template_template_parm (tree parm, tree arg, tsubst_flags_t complain,
7975 : : tree in_decl, tree outer_args)
7976 : : {
7977 : 862807 : if (arg == NULL_TREE || error_operand_p (arg)
7978 : 1725608 : || parm == NULL_TREE || error_operand_p (parm))
7979 : : return false;
7980 : :
7981 : 862801 : if (TREE_CODE (arg) != TREE_CODE (parm))
7982 : : return false;
7983 : :
7984 : 862462 : switch (TREE_CODE (parm))
7985 : : {
7986 : 13 : case TEMPLATE_DECL:
7987 : : /* We encounter instantiations of templates like
7988 : : template <template <template <class> class> class TT>
7989 : : class C; */
7990 : 13 : {
7991 : 13 : if (!coerce_template_template_parms
7992 : 13 : (parm, arg, complain, in_decl, outer_args))
7993 : : return false;
7994 : : }
7995 : : /* Fall through. */
7996 : :
7997 : 859274 : case TYPE_DECL:
7998 : 859274 : if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (arg))
7999 : 859274 : && !TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm)))
8000 : : /* Argument is a parameter pack but parameter is not. */
8001 : : return false;
8002 : : break;
8003 : :
8004 : 3188 : case PARM_DECL:
8005 : : /* The tsubst call is used to handle cases such as
8006 : :
8007 : : template <int> class C {};
8008 : : template <class T, template <T> class TT> class D {};
8009 : : D<int, C> d;
8010 : :
8011 : : i.e. the parameter list of TT depends on earlier parameters. */
8012 : 3188 : if (!uses_template_parms (TREE_TYPE (arg)))
8013 : : {
8014 : 3159 : ++processing_template_decl;
8015 : 3159 : tree t = tsubst (TREE_TYPE (parm), outer_args, complain, in_decl);
8016 : 3159 : --processing_template_decl;
8017 : 3159 : if (!uses_template_parms (t)
8018 : 3159 : && !same_type_p (t, TREE_TYPE (arg)))
8019 : : return false;
8020 : : }
8021 : :
8022 : 3164 : if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (arg))
8023 : 3164 : && !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)))
8024 : : /* Argument is a parameter pack but parameter is not. */
8025 : : return false;
8026 : :
8027 : : break;
8028 : :
8029 : 0 : default:
8030 : 0 : gcc_unreachable ();
8031 : : }
8032 : :
8033 : : return true;
8034 : : }
8035 : :
8036 : : /* Coerce template argument list ARGLIST for use with template
8037 : : template-parameter TEMPL. */
8038 : :
8039 : : static tree
8040 : 233314 : coerce_template_args_for_ttp (tree templ, tree arglist,
8041 : : tsubst_flags_t complain)
8042 : : {
8043 : : /* Consider an example where a template template parameter declared as
8044 : :
8045 : : template <class T, class U = std::allocator<T> > class TT
8046 : :
8047 : : The template parameter level of T and U are one level larger than
8048 : : of TT. To proper process the default argument of U, say when an
8049 : : instantiation `TT<int>' is seen, we need to build the full
8050 : : arguments containing {int} as the innermost level. Outer levels,
8051 : : available when not appearing as default template argument, can be
8052 : : obtained from the arguments of the enclosing template.
8053 : :
8054 : : Suppose that TT is later substituted with std::vector. The above
8055 : : instantiation is `TT<int, std::allocator<T> >' with TT at
8056 : : level 1, and T at level 2, while the template arguments at level 1
8057 : : becomes {std::vector} and the inner level 2 is {int}. */
8058 : :
8059 : 233314 : tree outer = DECL_CONTEXT (templ);
8060 : 233314 : if (outer)
8061 : 141054 : outer = generic_targs_for (outer);
8062 : 92260 : else if (current_template_parms)
8063 : : {
8064 : : /* This is an argument of the current template, so we haven't set
8065 : : DECL_CONTEXT yet. We can also get here when level-lowering a
8066 : : bound ttp. */
8067 : : tree relevant_template_parms;
8068 : :
8069 : : /* Parameter levels that are greater than the level of the given
8070 : : template template parm are irrelevant. */
8071 : : relevant_template_parms = current_template_parms;
8072 : 87844 : while (TMPL_PARMS_DEPTH (relevant_template_parms)
8073 : 175688 : != TEMPLATE_TYPE_LEVEL (TREE_TYPE (templ)))
8074 : 0 : relevant_template_parms = TREE_CHAIN (relevant_template_parms);
8075 : :
8076 : 87844 : outer = template_parms_to_args (relevant_template_parms);
8077 : : }
8078 : :
8079 : 233314 : if (outer)
8080 : 228898 : arglist = add_to_template_args (outer, arglist);
8081 : :
8082 : 233314 : tree parmlist = DECL_INNERMOST_TEMPLATE_PARMS (templ);
8083 : 233314 : return coerce_template_parms (parmlist, arglist, templ, complain);
8084 : : }
8085 : :
8086 : : /* A cache of template template parameters with match-all default
8087 : : arguments. */
8088 : : static GTY((deletable)) hash_map<tree,tree> *defaulted_ttp_cache;
8089 : :
8090 : : /* T is a bound template template-parameter. Copy its arguments into default
8091 : : arguments of the template template-parameter's template parameters. */
8092 : :
8093 : : static tree
8094 : 48 : add_defaults_to_ttp (tree otmpl)
8095 : : {
8096 : 82 : if (tree *c = hash_map_safe_get (defaulted_ttp_cache, otmpl))
8097 : 18 : return *c;
8098 : :
8099 : 30 : tree ntmpl = copy_node (otmpl);
8100 : :
8101 : 30 : tree ntype = copy_node (TREE_TYPE (otmpl));
8102 : 30 : TYPE_STUB_DECL (ntype) = TYPE_NAME (ntype) = ntmpl;
8103 : 30 : TYPE_MAIN_VARIANT (ntype) = ntype;
8104 : 30 : TYPE_POINTER_TO (ntype) = TYPE_REFERENCE_TO (ntype) = NULL_TREE;
8105 : 30 : TYPE_NAME (ntype) = ntmpl;
8106 : 30 : SET_TYPE_STRUCTURAL_EQUALITY (ntype);
8107 : :
8108 : 30 : tree idx = TEMPLATE_TYPE_PARM_INDEX (ntype)
8109 : 30 : = copy_node (TEMPLATE_TYPE_PARM_INDEX (ntype));
8110 : 30 : TEMPLATE_PARM_DECL (idx) = ntmpl;
8111 : 30 : TREE_TYPE (ntmpl) = TREE_TYPE (idx) = ntype;
8112 : :
8113 : 30 : tree oparms = DECL_TEMPLATE_PARMS (otmpl);
8114 : 30 : tree parms = DECL_TEMPLATE_PARMS (ntmpl) = copy_node (oparms);
8115 : 30 : TREE_CHAIN (parms) = TREE_CHAIN (oparms);
8116 : 30 : tree vec = TREE_VALUE (parms) = copy_node (TREE_VALUE (parms));
8117 : 68 : for (int i = 0; i < TREE_VEC_LENGTH (vec); ++i)
8118 : : {
8119 : 38 : tree o = TREE_VEC_ELT (vec, i);
8120 : 38 : if (!template_parameter_pack_p (TREE_VALUE (o)))
8121 : : {
8122 : 34 : tree n = TREE_VEC_ELT (vec, i) = copy_node (o);
8123 : 34 : TREE_PURPOSE (n) = any_targ_node;
8124 : : }
8125 : : }
8126 : :
8127 : 30 : tree oresult = DECL_TEMPLATE_RESULT (otmpl);
8128 : 30 : tree gen_otmpl = DECL_TI_TEMPLATE (oresult);
8129 : 30 : tree gen_ntmpl;
8130 : 30 : if (gen_otmpl == otmpl)
8131 : : gen_ntmpl = ntmpl;
8132 : : else
8133 : 0 : gen_ntmpl = add_defaults_to_ttp (gen_otmpl);
8134 : :
8135 : 30 : tree nresult = copy_decl (oresult);
8136 : 30 : DECL_TEMPLATE_INFO (nresult)
8137 : 30 : = build_template_info (gen_ntmpl, TI_ARGS (DECL_TEMPLATE_INFO (oresult)));
8138 : 30 : DECL_TEMPLATE_RESULT (ntmpl) = nresult;
8139 : :
8140 : 30 : hash_map_safe_put<hm_ggc> (defaulted_ttp_cache, otmpl, ntmpl);
8141 : 30 : return ntmpl;
8142 : : }
8143 : :
8144 : : /* ARG is a bound potential template template-argument, and PARGS is a list
8145 : : of arguments for the corresponding template template-parameter. Adjust
8146 : : PARGS as appropriate for application to ARG's template, and if ARG is a
8147 : : BOUND_TEMPLATE_TEMPLATE_PARM, possibly adjust it to add default template
8148 : : arguments to the template template parameter. */
8149 : :
8150 : : static tree
8151 : 46071 : coerce_ttp_args_for_tta (tree& arg, tree pargs, tsubst_flags_t complain)
8152 : : {
8153 : 46071 : ++processing_template_decl;
8154 : 46071 : tree arg_tmpl = TYPE_TI_TEMPLATE (arg);
8155 : 46071 : if (DECL_TEMPLATE_TEMPLATE_PARM_P (arg_tmpl))
8156 : : {
8157 : : /* When comparing two template template-parameters in partial ordering,
8158 : : rewrite the one currently being used as an argument to have default
8159 : : arguments for all parameters. */
8160 : 48 : arg_tmpl = add_defaults_to_ttp (arg_tmpl);
8161 : 48 : pargs = coerce_template_args_for_ttp (arg_tmpl, pargs, complain);
8162 : 48 : if (pargs != error_mark_node)
8163 : 44 : arg = bind_template_template_parm (TREE_TYPE (arg_tmpl),
8164 : 88 : TYPE_TI_ARGS (arg));
8165 : : }
8166 : : else
8167 : : {
8168 : 46023 : tree aparms
8169 : 46023 : = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (arg_tmpl));
8170 : 46023 : pargs = coerce_template_parms (aparms, pargs, arg_tmpl, complain);
8171 : : }
8172 : 46071 : --processing_template_decl;
8173 : 46071 : return pargs;
8174 : : }
8175 : :
8176 : : /* Subroutine of unify for the case when PARM is a
8177 : : BOUND_TEMPLATE_TEMPLATE_PARM. */
8178 : :
8179 : : static int
8180 : 46269 : unify_bound_ttp_args (tree tparms, tree targs, tree parm, tree& arg,
8181 : : bool explain_p)
8182 : : {
8183 : 46269 : tree parmvec = TYPE_TI_ARGS (parm);
8184 : 92538 : tree argvec = INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg));
8185 : :
8186 : : /* The template template parm might be variadic and the argument
8187 : : not, so flatten both argument lists. */
8188 : 46269 : parmvec = expand_template_argument_pack (parmvec);
8189 : 46269 : argvec = expand_template_argument_pack (argvec);
8190 : :
8191 : 46269 : if (flag_new_ttp)
8192 : : {
8193 : : /* In keeping with P0522R0, adjust P's template arguments
8194 : : to apply to A's template; then flatten it again. */
8195 : 46071 : tree nparmvec = coerce_ttp_args_for_tta (arg, parmvec, tf_none);
8196 : 46071 : nparmvec = expand_template_argument_pack (nparmvec);
8197 : :
8198 : 46071 : if (unify (tparms, targs, nparmvec, argvec,
8199 : : UNIFY_ALLOW_NONE, explain_p))
8200 : : return 1;
8201 : :
8202 : : /* If the P0522 adjustment eliminated a pack expansion, deduce
8203 : : empty packs. */
8204 : 46009 : if (flag_new_ttp
8205 : 46009 : && TREE_VEC_LENGTH (nparmvec) < TREE_VEC_LENGTH (parmvec)
8206 : 46009 : && unify_pack_expansion (tparms, targs, parmvec, argvec,
8207 : : DEDUCE_EXACT, /*sub*/true, explain_p))
8208 : : return 1;
8209 : : }
8210 : : else
8211 : : {
8212 : : /* Deduce arguments T, i from TT<T> or TT<i>.
8213 : : We check each element of PARMVEC and ARGVEC individually
8214 : : rather than the whole TREE_VEC since they can have
8215 : : different number of elements, which is allowed under N2555. */
8216 : :
8217 : 198 : int len = TREE_VEC_LENGTH (parmvec);
8218 : :
8219 : : /* Check if the parameters end in a pack, making them
8220 : : variadic. */
8221 : 198 : int parm_variadic_p = 0;
8222 : 198 : if (len > 0
8223 : 198 : && PACK_EXPANSION_P (TREE_VEC_ELT (parmvec, len - 1)))
8224 : : parm_variadic_p = 1;
8225 : :
8226 : 400 : for (int i = 0; i < len - parm_variadic_p; ++i)
8227 : : /* If the template argument list of P contains a pack
8228 : : expansion that is not the last template argument, the
8229 : : entire template argument list is a non-deduced
8230 : : context. */
8231 : 204 : if (PACK_EXPANSION_P (TREE_VEC_ELT (parmvec, i)))
8232 : 46188 : return unify_success (explain_p);
8233 : :
8234 : 196 : if (TREE_VEC_LENGTH (argvec) < len - parm_variadic_p)
8235 : 2 : return unify_too_few_arguments (explain_p,
8236 : 2 : TREE_VEC_LENGTH (argvec), len);
8237 : :
8238 : 377 : for (int i = 0; i < len - parm_variadic_p; ++i)
8239 : 198 : if (unify (tparms, targs,
8240 : 198 : TREE_VEC_ELT (parmvec, i),
8241 : 198 : TREE_VEC_ELT (argvec, i),
8242 : : UNIFY_ALLOW_NONE, explain_p))
8243 : : return 1;
8244 : :
8245 : 179 : if (parm_variadic_p
8246 : 179 : && unify_pack_expansion (tparms, targs,
8247 : : parmvec, argvec,
8248 : : DEDUCE_EXACT,
8249 : : /*subr=*/true, explain_p))
8250 : : return 1;
8251 : : }
8252 : :
8253 : : return 0;
8254 : : }
8255 : :
8256 : : /* Return 1 if PARM_TMPL and ARG_TMPL match using rule for
8257 : : template template parameters.
8258 : :
8259 : : Consider the example:
8260 : : template <class T> class A;
8261 : : template<template <class U> class TT> class B;
8262 : :
8263 : : For B<A>, PARM_TMPL is TT, while ARG_TMPL is A,
8264 : : and OUTER_ARGS contains A. */
8265 : :
8266 : : static int
8267 : 8993267 : coerce_template_template_parms (tree parm_tmpl,
8268 : : tree arg_tmpl,
8269 : : tsubst_flags_t complain,
8270 : : tree in_decl,
8271 : : tree outer_args)
8272 : : {
8273 : 8993267 : int nparms, nargs, i;
8274 : 8993267 : tree parm, arg;
8275 : 8993267 : int variadic_p = 0;
8276 : :
8277 : 8993267 : tree parm_parms = DECL_INNERMOST_TEMPLATE_PARMS (parm_tmpl);
8278 : 8993267 : tree arg_parms = DECL_INNERMOST_TEMPLATE_PARMS (arg_tmpl);
8279 : 8993267 : tree gen_arg_tmpl = most_general_template (arg_tmpl);
8280 : 8993267 : tree gen_arg_parms = DECL_INNERMOST_TEMPLATE_PARMS (gen_arg_tmpl);
8281 : :
8282 : 8993267 : nparms = TREE_VEC_LENGTH (parm_parms);
8283 : 8993267 : nargs = TREE_VEC_LENGTH (arg_parms);
8284 : :
8285 : 8993267 : if (flag_new_ttp)
8286 : : {
8287 : : /* P0522R0: A template template-parameter P is at least as specialized as
8288 : : a template template-argument A if, given the following rewrite to two
8289 : : function templates, the function template corresponding to P is at
8290 : : least as specialized as the function template corresponding to A
8291 : : according to the partial ordering rules for function templates
8292 : : ([temp.func.order]). Given an invented class template X with the
8293 : : template parameter list of A (including default arguments):
8294 : :
8295 : : * Each of the two function templates has the same template parameters,
8296 : : respectively, as P or A.
8297 : :
8298 : : * Each function template has a single function parameter whose type is
8299 : : a specialization of X with template arguments corresponding to the
8300 : : template parameters from the respective function template where, for
8301 : : each template parameter PP in the template parameter list of the
8302 : : function template, a corresponding template argument AA is formed. If
8303 : : PP declares a parameter pack, then AA is the pack expansion
8304 : : PP... ([temp.variadic]); otherwise, AA is the id-expression PP.
8305 : :
8306 : : If the rewrite produces an invalid type, then P is not at least as
8307 : : specialized as A. */
8308 : :
8309 : : /* So coerce P's args to apply to A's parms, and then deduce between A's
8310 : : args and the converted args. If that succeeds, A is at least as
8311 : : specialized as P, so they match.*/
8312 : 8972123 : processing_template_decl_sentinel ptds (/*reset*/false);
8313 : 8972123 : ++processing_template_decl;
8314 : :
8315 : 8972123 : tree pargs = template_parms_level_to_args (parm_parms);
8316 : :
8317 : : /* PARM and ARG might be at different template depths, and we want to
8318 : : pass the right additional levels of args when coercing PARGS to
8319 : : ARG_PARMS in case we need to do any substitution into non-type
8320 : : template parameter types.
8321 : :
8322 : : OUTER_ARGS are not the right outer levels in this case, as they are
8323 : : the args we're building up for PARM, and for the coercion we want the
8324 : : args for ARG. If DECL_CONTEXT isn't set for a template template
8325 : : parameter, we can assume that it's in the current scope. */
8326 : 8972123 : tree ctx = DECL_CONTEXT (arg_tmpl);
8327 : 8972123 : if (!ctx && DECL_TEMPLATE_TEMPLATE_PARM_P (arg_tmpl))
8328 : 338981 : ctx = current_scope ();
8329 : 8972123 : tree scope_args = NULL_TREE;
8330 : 8972123 : if (tree tinfo = get_template_info (ctx))
8331 : 203694 : scope_args = TI_ARGS (tinfo);
8332 : 8972123 : if (DECL_TEMPLATE_TEMPLATE_PARM_P (arg_tmpl))
8333 : : {
8334 : 357126 : int level = TEMPLATE_TYPE_LEVEL (TREE_TYPE (gen_arg_tmpl));
8335 : 381161 : int scope_depth = TMPL_ARGS_DEPTH (scope_args);
8336 : 357126 : tree full_pargs = make_tree_vec (level + 1);
8337 : :
8338 : : /* Only use as many levels from the scope as needed
8339 : : (excluding the level of ARG). */
8340 : 375058 : for (int i = 0; i < level - 1; ++i)
8341 : 17932 : if (i < scope_depth)
8342 : 34830 : TREE_VEC_ELT (full_pargs, i) = TMPL_ARGS_LEVEL (scope_args, i + 1);
8343 : : else
8344 : 517 : TREE_VEC_ELT (full_pargs, i) = make_tree_vec (0);
8345 : :
8346 : : /* Add the arguments that appear at the levels of ARG. */
8347 : 357126 : tree adjacent = DECL_TI_ARGS (DECL_TEMPLATE_RESULT (arg_tmpl));
8348 : 714252 : adjacent = TMPL_ARGS_LEVEL (adjacent, TMPL_ARGS_DEPTH (adjacent) - 1);
8349 : 357126 : TREE_VEC_ELT (full_pargs, level - 1) = adjacent;
8350 : :
8351 : 357126 : TREE_VEC_ELT (full_pargs, level) = pargs;
8352 : 357126 : pargs = full_pargs;
8353 : : }
8354 : : else
8355 : 8614997 : pargs = add_to_template_args (scope_args, pargs);
8356 : :
8357 : 8972123 : pargs = coerce_template_parms (gen_arg_parms, pargs,
8358 : : NULL_TREE, tf_none);
8359 : 8972123 : if (pargs != error_mark_node)
8360 : : {
8361 : 8971126 : tree targs = make_tree_vec (nargs);
8362 : 8971126 : tree aargs = template_parms_level_to_args (arg_parms);
8363 : 8971126 : if (!unify (arg_parms, targs, aargs, pargs, UNIFY_ALLOW_NONE,
8364 : : /*explain*/false))
8365 : 8335199 : return 1;
8366 : : }
8367 : 8972123 : }
8368 : :
8369 : : /* Determine whether we have a parameter pack at the end of the
8370 : : template template parameter's template parameter list. */
8371 : 658068 : if (TREE_VEC_ELT (parm_parms, nparms - 1) != error_mark_node)
8372 : : {
8373 : 658068 : parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, nparms - 1));
8374 : :
8375 : 658068 : if (error_operand_p (parm))
8376 : : return 0;
8377 : :
8378 : 658062 : switch (TREE_CODE (parm))
8379 : : {
8380 : 653930 : case TEMPLATE_DECL:
8381 : 653930 : case TYPE_DECL:
8382 : 653930 : if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm)))
8383 : 643235 : variadic_p = 1;
8384 : : break;
8385 : :
8386 : 4132 : case PARM_DECL:
8387 : 4132 : if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)))
8388 : 643235 : variadic_p = 1;
8389 : : break;
8390 : :
8391 : 0 : default:
8392 : 0 : gcc_unreachable ();
8393 : : }
8394 : : }
8395 : :
8396 : 658062 : if (nargs != nparms
8397 : 177884 : && !(variadic_p && nargs >= nparms - 1))
8398 : : return 0;
8399 : :
8400 : : /* Check all of the template parameters except the parameter pack at
8401 : : the end (if any). */
8402 : 715091 : for (i = 0; i < nparms - variadic_p; ++i)
8403 : : {
8404 : 58087 : if (TREE_VEC_ELT (parm_parms, i) == error_mark_node
8405 : 58087 : || TREE_VEC_ELT (arg_parms, i) == error_mark_node)
8406 : 0 : continue;
8407 : :
8408 : 58087 : parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, i));
8409 : 58087 : arg = TREE_VALUE (TREE_VEC_ELT (arg_parms, i));
8410 : :
8411 : 58087 : if (!coerce_template_template_parm (parm, arg, complain, in_decl,
8412 : : outer_args))
8413 : : return 0;
8414 : :
8415 : : }
8416 : :
8417 : 657004 : if (variadic_p)
8418 : : {
8419 : : /* Check each of the template parameters in the template
8420 : : argument against the template parameter pack at the end of
8421 : : the template template parameter. */
8422 : 643231 : if (TREE_VEC_ELT (parm_parms, i) == error_mark_node)
8423 : : return 0;
8424 : :
8425 : 643231 : parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, i));
8426 : :
8427 : 1447935 : for (; i < nargs; ++i)
8428 : : {
8429 : 804720 : if (TREE_VEC_ELT (arg_parms, i) == error_mark_node)
8430 : 0 : continue;
8431 : :
8432 : 804720 : arg = TREE_VALUE (TREE_VEC_ELT (arg_parms, i));
8433 : :
8434 : 804720 : if (!coerce_template_template_parm (parm, arg, complain, in_decl,
8435 : : outer_args))
8436 : : return 0;
8437 : : }
8438 : : }
8439 : :
8440 : : return 1;
8441 : : }
8442 : :
8443 : : /* Verifies that the deduced template arguments (in TARGS) for the
8444 : : template template parameters (in TPARMS) represent valid bindings,
8445 : : by comparing the template parameter list of each template argument
8446 : : to the template parameter list of its corresponding template
8447 : : template parameter, in accordance with DR150. This
8448 : : routine can only be called after all template arguments have been
8449 : : deduced. It will return TRUE if all of the template template
8450 : : parameter bindings are okay, FALSE otherwise. */
8451 : : bool
8452 : 50103917 : template_template_parm_bindings_ok_p (tree tparms, tree targs)
8453 : : {
8454 : 50103917 : int i, ntparms = TREE_VEC_LENGTH (tparms);
8455 : 50103917 : bool ret = true;
8456 : :
8457 : : /* We're dealing with template parms in this process. */
8458 : 50103917 : ++processing_template_decl;
8459 : :
8460 : 50103917 : targs = INNERMOST_TEMPLATE_ARGS (targs);
8461 : :
8462 : 130318905 : for (i = 0; i < ntparms; ++i)
8463 : : {
8464 : 80215024 : tree tparm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
8465 : 80215024 : tree targ = TREE_VEC_ELT (targs, i);
8466 : :
8467 : 80215024 : if (TREE_CODE (tparm) == TEMPLATE_DECL && targ)
8468 : : {
8469 : 421310 : tree packed_args = NULL_TREE;
8470 : 421310 : int idx, len = 1;
8471 : :
8472 : 421310 : if (ARGUMENT_PACK_P (targ))
8473 : : {
8474 : : /* Look inside the argument pack. */
8475 : 127 : packed_args = ARGUMENT_PACK_ARGS (targ);
8476 : 127 : len = TREE_VEC_LENGTH (packed_args);
8477 : : }
8478 : :
8479 : 842606 : for (idx = 0; idx < len; ++idx)
8480 : : {
8481 : 421332 : if (packed_args)
8482 : : /* Extract the next argument from the argument
8483 : : pack. */
8484 : 149 : targ = TREE_VEC_ELT (packed_args, idx);
8485 : :
8486 : 421332 : if (PACK_EXPANSION_P (targ))
8487 : : /* Look at the pattern of the pack expansion. */
8488 : 31 : targ = PACK_EXPANSION_PATTERN (targ);
8489 : :
8490 : : /* Extract the template parameters from the template
8491 : : argument. */
8492 : 421332 : if (TREE_CODE (targ) == TEMPLATE_TEMPLATE_PARM)
8493 : 74043 : targ = TYPE_NAME (targ);
8494 : :
8495 : : /* Verify that we can coerce the template template
8496 : : parameters from the template argument to the template
8497 : : parameter. This requires an exact match. */
8498 : 421332 : if (TREE_CODE (targ) == TEMPLATE_DECL
8499 : 842655 : && !coerce_template_template_parms
8500 : 421323 : (tparm,
8501 : : targ,
8502 : : tf_none,
8503 : : tparm,
8504 : : targs))
8505 : : {
8506 : 36 : ret = false;
8507 : 36 : goto out;
8508 : : }
8509 : : }
8510 : : }
8511 : : }
8512 : :
8513 : 50103881 : out:
8514 : :
8515 : 50103917 : --processing_template_decl;
8516 : 50103917 : return ret;
8517 : : }
8518 : :
8519 : : /* Since type attributes aren't mangled, we need to strip them from
8520 : : template type arguments. */
8521 : :
8522 : : tree
8523 : 1022209725 : canonicalize_type_argument (tree arg, tsubst_flags_t complain)
8524 : : {
8525 : 1022209725 : if (!arg || arg == error_mark_node || arg == TYPE_CANONICAL (arg))
8526 : : return arg;
8527 : 453234941 : bool removed_attributes = false;
8528 : 453234941 : tree canon = strip_typedefs (arg, &removed_attributes);
8529 : 453234941 : if (removed_attributes
8530 : 555 : && (complain & tf_warning))
8531 : 15 : warning (OPT_Wignored_attributes,
8532 : : "ignoring attributes on template argument %qT", arg);
8533 : : return canon;
8534 : : }
8535 : :
8536 : : /* And from inside dependent non-type arguments like sizeof(Type). */
8537 : :
8538 : : static tree
8539 : 44324001 : canonicalize_expr_argument (tree arg, tsubst_flags_t complain)
8540 : : {
8541 : 44324001 : if (!arg || arg == error_mark_node)
8542 : : return arg;
8543 : 44324001 : bool removed_attributes = false;
8544 : 44324001 : tree canon = strip_typedefs_expr (arg, &removed_attributes);
8545 : 44324001 : if (removed_attributes
8546 : 0 : && (complain & tf_warning))
8547 : 0 : warning (OPT_Wignored_attributes,
8548 : : "ignoring attributes in template argument %qE", arg);
8549 : : return canon;
8550 : : }
8551 : :
8552 : : /* A template declaration can be substituted for a constrained
8553 : : template template parameter only when the argument is no more
8554 : : constrained than the parameter. */
8555 : :
8556 : : static bool
8557 : 8570887 : is_compatible_template_arg (tree parm, tree arg, tree args)
8558 : : {
8559 : 8570887 : tree parm_cons = get_constraints (parm);
8560 : :
8561 : : /* For now, allow constrained template template arguments
8562 : : and unconstrained template template parameters. */
8563 : 8570887 : if (parm_cons == NULL_TREE)
8564 : : return true;
8565 : :
8566 : : /* If the template parameter is constrained, we need to rewrite its
8567 : : constraints in terms of the ARG's template parameters. This ensures
8568 : : that all of the template parameter types will have the same depth.
8569 : :
8570 : : Note that this is only valid when coerce_template_template_parm is
8571 : : true for the innermost template parameters of PARM and ARG. In other
8572 : : words, because coercion is successful, this conversion will be valid. */
8573 : 87 : tree new_args = NULL_TREE;
8574 : 87 : if (parm_cons)
8575 : : {
8576 : 87 : tree aparms = DECL_INNERMOST_TEMPLATE_PARMS (arg);
8577 : 87 : new_args = template_parms_level_to_args (aparms);
8578 : 87 : new_args = add_to_template_args (args, new_args);
8579 : 87 : ++processing_template_decl;
8580 : 87 : parm_cons = tsubst_constraint_info (parm_cons, new_args,
8581 : : tf_none, NULL_TREE);
8582 : 87 : --processing_template_decl;
8583 : 87 : if (parm_cons == error_mark_node)
8584 : : return false;
8585 : : }
8586 : :
8587 : 87 : return ttp_subsumes (parm_cons, arg);
8588 : : }
8589 : :
8590 : : /* We can't fully resolve ARG given as a non-type template argument to TYPE,
8591 : : because one of them is dependent. But we need to represent the
8592 : : conversion for the benefit of cp_tree_equal. */
8593 : :
8594 : : static tree
8595 : 22336706 : maybe_convert_nontype_argument (tree type, tree arg, bool force)
8596 : : {
8597 : : /* Auto parms get no conversion. */
8598 : 22336706 : if (type_uses_auto (type))
8599 : : return arg;
8600 : : /* ??? Do we need to push the IMPLICIT_CONV_EXPR into the pack expansion?
8601 : : That would complicate other things, and it doesn't seem necessary. */
8602 : 22334272 : if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
8603 : : return arg;
8604 : : /* We don't need or want to add this conversion now if we're going to use the
8605 : : argument for deduction. */
8606 : 21196038 : if (!value_dependent_expression_p (arg))
8607 : : force = false;
8608 : 21195897 : else if (!force)
8609 : : return arg;
8610 : :
8611 : 1876463 : type = cv_unqualified (type);
8612 : 1876463 : tree argtype = TREE_TYPE (arg);
8613 : 1876463 : if (argtype && same_type_p (type, argtype))
8614 : : return arg;
8615 : :
8616 : 1876442 : arg = build1 (IMPLICIT_CONV_EXPR, type, arg);
8617 : 1876442 : IMPLICIT_CONV_EXPR_NONTYPE_ARG (arg) = true;
8618 : 1876442 : IMPLICIT_CONV_EXPR_FORCED (arg) = force;
8619 : 1876442 : return arg;
8620 : : }
8621 : :
8622 : : /* Convert the indicated template ARG as necessary to match the
8623 : : indicated template PARM. Returns the converted ARG, or
8624 : : error_mark_node if the conversion was unsuccessful. Error and
8625 : : warning messages are issued under control of COMPLAIN. This
8626 : : conversion is for the Ith parameter in the parameter list. ARGS is
8627 : : the full set of template arguments deduced so far. */
8628 : :
8629 : : static tree
8630 : 981747844 : convert_template_argument (tree parm,
8631 : : tree arg,
8632 : : tree args,
8633 : : tsubst_flags_t complain,
8634 : : int i,
8635 : : tree in_decl)
8636 : : {
8637 : 981747844 : tree orig_arg;
8638 : 981747844 : tree val;
8639 : 981747844 : int is_type, requires_type, is_tmpl_type, requires_tmpl_type;
8640 : :
8641 : 981747844 : if (parm == error_mark_node || error_operand_p (arg))
8642 : : return error_mark_node;
8643 : :
8644 : 968988952 : if (arg == any_targ_node)
8645 : : return arg;
8646 : :
8647 : 968988940 : if (TREE_CODE (arg) == TREE_LIST
8648 : 968988940 : && TREE_CODE (TREE_VALUE (arg)) == OFFSET_REF)
8649 : : {
8650 : : /* The template argument was the name of some
8651 : : member function. That's usually
8652 : : invalid, but static members are OK. In any
8653 : : case, grab the underlying fields/functions
8654 : : and issue an error later if required. */
8655 : 0 : TREE_TYPE (arg) = unknown_type_node;
8656 : : }
8657 : :
8658 : 968988940 : orig_arg = arg;
8659 : :
8660 : 968988940 : requires_tmpl_type = TREE_CODE (parm) == TEMPLATE_DECL;
8661 : 1937977880 : requires_type = (TREE_CODE (parm) == TYPE_DECL
8662 : 968988940 : || requires_tmpl_type);
8663 : :
8664 : : /* When determining whether an argument pack expansion is a template,
8665 : : look at the pattern. */
8666 : 968988940 : if (PACK_EXPANSION_P (arg))
8667 : 17208124 : arg = PACK_EXPANSION_PATTERN (arg);
8668 : :
8669 : : /* Deal with an injected-class-name used as a template template arg. */
8670 : 968988940 : if (requires_tmpl_type && CLASS_TYPE_P (arg))
8671 : : {
8672 : 239 : tree t = maybe_get_template_decl_from_type_decl (TYPE_NAME (arg));
8673 : 239 : if (TREE_CODE (t) == TEMPLATE_DECL)
8674 : : {
8675 : 39 : if (cxx_dialect >= cxx11)
8676 : : /* OK under DR 1004. */;
8677 : 2 : else if (complain & tf_warning_or_error)
8678 : 2 : pedwarn (input_location, OPT_Wpedantic, "injected-class-name %qD"
8679 : 2 : " used as template template argument", TYPE_NAME (arg));
8680 : 0 : else if (flag_pedantic_errors)
8681 : 968988901 : t = arg;
8682 : :
8683 : : arg = t;
8684 : : }
8685 : : }
8686 : :
8687 : 1946563326 : is_tmpl_type =
8688 : 968988940 : ((TREE_CODE (arg) == TEMPLATE_DECL
8689 : 8432644 : && TREE_CODE (DECL_TEMPLATE_RESULT (arg)) == TYPE_DECL)
8690 : 960556296 : || (requires_tmpl_type && TREE_CODE (arg) == TYPE_ARGUMENT_PACK)
8691 : 960556290 : || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
8692 : 1929405876 : || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE);
8693 : :
8694 : 8585446 : if (is_tmpl_type
8695 : 8585446 : && (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
8696 : 8446092 : || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE))
8697 : 152796 : arg = TYPE_STUB_DECL (arg);
8698 : :
8699 : 968988940 : is_type = TYPE_P (arg) || is_tmpl_type;
8700 : :
8701 : 2132318 : if (requires_type && ! is_type && TREE_CODE (arg) == SCOPE_REF
8702 : 968988958 : && TREE_CODE (TREE_OPERAND (arg, 0)) == TEMPLATE_TYPE_PARM)
8703 : : {
8704 : 12 : if (TREE_CODE (TREE_OPERAND (arg, 1)) == BIT_NOT_EXPR)
8705 : : {
8706 : 3 : if (complain & tf_error)
8707 : 3 : error ("invalid use of destructor %qE as a type", orig_arg);
8708 : 3 : return error_mark_node;
8709 : : }
8710 : :
8711 : 9 : permerror (input_location,
8712 : : "to refer to a type member of a template parameter, "
8713 : : "use %<typename %E%>", orig_arg);
8714 : :
8715 : 9 : orig_arg = make_typename_type (TREE_OPERAND (arg, 0),
8716 : 9 : TREE_OPERAND (arg, 1),
8717 : : typename_type,
8718 : : complain);
8719 : 9 : arg = orig_arg;
8720 : 9 : is_type = 1;
8721 : : }
8722 : 968988937 : if (is_type != requires_type)
8723 : : {
8724 : 2134517 : if (in_decl)
8725 : : {
8726 : 2134107 : if (complain & tf_error)
8727 : : {
8728 : 128 : auto_diagnostic_group d;
8729 : 128 : error ("type/value mismatch at argument %d in template "
8730 : : "parameter list for %qD",
8731 : : i + 1, in_decl);
8732 : 128 : if (is_type)
8733 : : {
8734 : : /* The template argument is a type, but we're expecting
8735 : : an expression. */
8736 : 55 : inform (input_location,
8737 : : " expected a constant of type %qT, got %qT",
8738 : 40 : TREE_TYPE (parm),
8739 : 40 : (DECL_P (arg) ? DECL_NAME (arg) : orig_arg));
8740 : : /* [temp.arg]/2: "In a template-argument, an ambiguity
8741 : : between a type-id and an expression is resolved to a
8742 : : type-id, regardless of the form of the corresponding
8743 : : template-parameter." So give the user a clue. */
8744 : 40 : if (TREE_CODE (arg) == FUNCTION_TYPE)
8745 : 6 : inform (input_location, " ambiguous template argument "
8746 : : "for non-type template parameter is treated as "
8747 : : "function type");
8748 : : }
8749 : 88 : else if (requires_tmpl_type)
8750 : 9 : inform (input_location,
8751 : : " expected a class template, got %qE", orig_arg);
8752 : : else
8753 : 79 : inform (input_location,
8754 : : " expected a type, got %qE", orig_arg);
8755 : 128 : }
8756 : : }
8757 : 2134517 : return error_mark_node;
8758 : : }
8759 : 966854420 : if (is_tmpl_type ^ requires_tmpl_type)
8760 : : {
8761 : 261 : if (in_decl && (complain & tf_error))
8762 : : {
8763 : 15 : auto_diagnostic_group d;
8764 : 15 : error ("type/value mismatch at argument %d in template "
8765 : : "parameter list for %qD",
8766 : : i + 1, in_decl);
8767 : 15 : if (is_tmpl_type)
8768 : 6 : inform (input_location,
8769 : 6 : " expected a type, got %qT", DECL_NAME (arg));
8770 : : else
8771 : 9 : inform (input_location,
8772 : : " expected a class template, got %qT", orig_arg);
8773 : 15 : }
8774 : 261 : return error_mark_node;
8775 : : }
8776 : :
8777 : 966854159 : if (template_parameter_pack_p (parm) && ARGUMENT_PACK_P (orig_arg))
8778 : : /* We already did the appropriate conversion when packing args. */
8779 : : val = orig_arg;
8780 : 966854138 : else if (is_type)
8781 : : {
8782 : 833227334 : if (requires_tmpl_type)
8783 : : {
8784 : 8585367 : if (TREE_CODE (TREE_TYPE (arg)) == UNBOUND_CLASS_TEMPLATE)
8785 : : /* The number of argument required is not known yet.
8786 : : Just accept it for now. */
8787 : : val = orig_arg;
8788 : : else
8789 : : {
8790 : : /* Strip alias templates that are equivalent to another
8791 : : template. */
8792 : 8571931 : arg = get_underlying_template (arg);
8793 : :
8794 : 8571931 : if (coerce_template_template_parms (parm, arg,
8795 : : complain, in_decl,
8796 : : args))
8797 : : {
8798 : 8570887 : val = arg;
8799 : :
8800 : : /* TEMPLATE_TEMPLATE_PARM node is preferred over
8801 : : TEMPLATE_DECL. */
8802 : 8570887 : if (val != error_mark_node)
8803 : : {
8804 : 8570887 : if (DECL_TEMPLATE_TEMPLATE_PARM_P (val))
8805 : 288176 : val = TREE_TYPE (val);
8806 : 8570887 : if (TREE_CODE (orig_arg) == TYPE_PACK_EXPANSION)
8807 : 89 : val = make_pack_expansion (val, complain);
8808 : : }
8809 : : }
8810 : : else
8811 : : {
8812 : 1044 : if (in_decl && (complain & tf_error))
8813 : : {
8814 : 39 : auto_diagnostic_group d;
8815 : 39 : error ("type/value mismatch at argument %d in "
8816 : : "template parameter list for %qD",
8817 : : i + 1, in_decl);
8818 : 39 : inform (input_location,
8819 : : " expected a template of type %qD, got %qT",
8820 : : parm, orig_arg);
8821 : 39 : }
8822 : :
8823 : 1044 : val = error_mark_node;
8824 : : }
8825 : :
8826 : : // Check that the constraints are compatible before allowing the
8827 : : // substitution.
8828 : 8571931 : if (val != error_mark_node)
8829 : 8570887 : if (!is_compatible_template_arg (parm, arg, args))
8830 : : {
8831 : 18 : if (in_decl && (complain & tf_error))
8832 : : {
8833 : 15 : auto_diagnostic_group d;
8834 : 15 : error ("constraint mismatch at argument %d in "
8835 : : "template parameter list for %qD",
8836 : : i + 1, in_decl);
8837 : 15 : inform (input_location, " expected %qD but got %qD",
8838 : : parm, arg);
8839 : 15 : }
8840 : 18 : val = error_mark_node;
8841 : : }
8842 : : }
8843 : : }
8844 : : else
8845 : : val = orig_arg;
8846 : : /* We only form one instance of each template specialization.
8847 : : Therefore, if we use a non-canonical variant (i.e., a
8848 : : typedef), any future messages referring to the type will use
8849 : : the typedef, which is confusing if those future uses do not
8850 : : themselves also use the typedef. */
8851 : 833227334 : if (TYPE_P (val))
8852 : 824943579 : val = canonicalize_type_argument (val, complain);
8853 : : }
8854 : : else
8855 : : {
8856 : 133626804 : tree t = TREE_TYPE (parm);
8857 : :
8858 : 267253608 : if (TEMPLATE_PARM_LEVEL (get_template_parm_index (parm))
8859 : 267253608 : > TMPL_ARGS_DEPTH (args))
8860 : : /* We don't have enough levels of args to do any substitution. This
8861 : : can happen in the context of -fnew-ttp-matching. */;
8862 : 133626789 : else if (tree a = type_uses_auto (t))
8863 : : {
8864 : 5086 : t = do_auto_deduction (t, arg, a, complain, adc_unify, args,
8865 : : LOOKUP_IMPLICIT, /*tmpl=*/in_decl);
8866 : 5086 : if (t == error_mark_node)
8867 : : return error_mark_node;
8868 : : }
8869 : : else
8870 : 133621703 : t = tsubst (t, args, complain, in_decl);
8871 : :
8872 : : /* Perform array-to-pointer and function-to-pointer conversion
8873 : : as per [temp.param]/10. */
8874 : 133626760 : t = type_decays_to (t);
8875 : :
8876 : 133626760 : if (invalid_nontype_parm_type_p (t, complain))
8877 : 69 : return error_mark_node;
8878 : :
8879 : : /* Drop top-level cv-qualifiers on the substituted/deduced type of
8880 : : this non-type template parameter, as per [temp.param]/6. */
8881 : 133626691 : t = cv_unqualified (t);
8882 : :
8883 : 133626691 : if (t != TREE_TYPE (parm))
8884 : 4973921 : t = canonicalize_type_argument (t, complain);
8885 : :
8886 : : /* We need to handle arguments for alias or concept templates
8887 : : differently: we need to force building an IMPLICIT_CONV_EXPR, because
8888 : : these arguments are going to be substituted directly into the
8889 : : dependent type; they might not get another chance at
8890 : : convert_nontype_argument. But if the argument ends up here again for
8891 : : a template that isn't one of those, remove the conversion for
8892 : : consistency between naming the same dependent type directly or through
8893 : : an alias. */
8894 : 133626691 : bool force_conv = in_decl && (DECL_ALIAS_TEMPLATE_P (in_decl)
8895 : 100485782 : || concept_definition_p (in_decl));
8896 : 103040389 : if (!force_conv
8897 : 103040389 : && TREE_CODE (orig_arg) == IMPLICIT_CONV_EXPR
8898 : 4196350 : && IMPLICIT_CONV_EXPR_FORCED (orig_arg)
8899 : 4196194 : && same_type_p (TREE_TYPE (orig_arg), t))
8900 : 4196194 : orig_arg = TREE_OPERAND (orig_arg, 0);
8901 : :
8902 : 133626691 : if (!type_dependent_expression_p (orig_arg)
8903 : 133626691 : && !uses_template_parms (t))
8904 : : /* We used to call digest_init here. However, digest_init
8905 : : will report errors, which we don't want when complain
8906 : : is zero. More importantly, digest_init will try too
8907 : : hard to convert things: for example, `0' should not be
8908 : : converted to pointer type at this point according to
8909 : : the standard. Accepting this is not merely an
8910 : : extension, since deciding whether or not these
8911 : : conversions can occur is part of determining which
8912 : : function template to call, or whether a given explicit
8913 : : argument specification is valid. */
8914 : 111289985 : val = convert_nontype_argument (t, orig_arg, complain);
8915 : : else
8916 : : {
8917 : 22336706 : val = canonicalize_expr_argument (orig_arg, complain);
8918 : 22336706 : val = maybe_convert_nontype_argument (t, val, force_conv);
8919 : : }
8920 : :
8921 : 133626691 : if (val == NULL_TREE)
8922 : 361 : val = error_mark_node;
8923 : 133626330 : else if (val == error_mark_node && (complain & tf_error))
8924 : 60 : error_at (cp_expr_loc_or_input_loc (orig_arg),
8925 : : "could not convert template argument %qE from %qT to %qT",
8926 : 44 : orig_arg, TREE_TYPE (orig_arg), t);
8927 : :
8928 : 133626691 : if (INDIRECT_REF_P (val))
8929 : : {
8930 : : /* Reject template arguments that are references to built-in
8931 : : functions with no library fallbacks. */
8932 : 433 : const_tree inner = TREE_OPERAND (val, 0);
8933 : 433 : const_tree innertype = TREE_TYPE (inner);
8934 : 433 : if (innertype
8935 : 433 : && TYPE_REF_P (innertype)
8936 : 424 : && TREE_CODE (TREE_TYPE (innertype)) == FUNCTION_TYPE
8937 : 87 : && TREE_OPERAND_LENGTH (inner) > 0
8938 : 493 : && reject_gcc_builtin (TREE_OPERAND (inner, 0)))
8939 : 4 : return error_mark_node;
8940 : : }
8941 : :
8942 : 133626687 : if (TREE_CODE (val) == SCOPE_REF)
8943 : : {
8944 : : /* Strip typedefs from the SCOPE_REF. */
8945 : 8832980 : tree type = canonicalize_type_argument (TREE_TYPE (val), complain);
8946 : 8832980 : tree scope = canonicalize_type_argument (TREE_OPERAND (val, 0),
8947 : : complain);
8948 : 17665960 : val = build_qualified_name (type, scope, TREE_OPERAND (val, 1),
8949 : 8832980 : QUALIFIED_NAME_IS_TEMPLATE (val));
8950 : : }
8951 : : }
8952 : :
8953 : : return val;
8954 : : }
8955 : :
8956 : : /* Coerces the remaining template arguments in INNER_ARGS (from
8957 : : ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
8958 : : Returns the coerced argument pack. PARM_IDX is the position of this
8959 : : parameter in the template parameter list. ARGS is the original
8960 : : template argument list. */
8961 : : static tree
8962 : 72664741 : coerce_template_parameter_pack (tree parms,
8963 : : int parm_idx,
8964 : : tree args,
8965 : : tree inner_args,
8966 : : int arg_idx,
8967 : : tree new_args,
8968 : : int* lost,
8969 : : tree in_decl,
8970 : : tsubst_flags_t complain)
8971 : : {
8972 : 72664741 : tree parm = TREE_VEC_ELT (parms, parm_idx);
8973 : 145329482 : int nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0;
8974 : 72664741 : tree packed_args;
8975 : 72664741 : tree argument_pack;
8976 : 72664741 : tree packed_parms = NULL_TREE;
8977 : :
8978 : 72664741 : if (arg_idx > nargs)
8979 : : arg_idx = nargs;
8980 : :
8981 : 72664741 : if (tree packs = fixed_parameter_pack_p (TREE_VALUE (parm)))
8982 : : {
8983 : : /* When the template parameter is a non-type template parameter pack
8984 : : or template template parameter pack whose type or template
8985 : : parameters use parameter packs, we know exactly how many arguments
8986 : : we are looking for. Build a vector of the instantiated decls for
8987 : : these template parameters in PACKED_PARMS. */
8988 : : /* We can't use make_pack_expansion here because it would interpret a
8989 : : _DECL as a use rather than a declaration. */
8990 : 59 : tree decl = TREE_VALUE (parm);
8991 : 59 : tree exp = cxx_make_type (TYPE_PACK_EXPANSION);
8992 : 59 : PACK_EXPANSION_PATTERN (exp) = decl;
8993 : 118 : PACK_EXPANSION_PARAMETER_PACKS (exp) = packs;
8994 : 59 : SET_TYPE_STRUCTURAL_EQUALITY (exp);
8995 : :
8996 : 59 : TREE_VEC_LENGTH (args)--;
8997 : 59 : packed_parms = tsubst_pack_expansion (exp, args, complain, decl);
8998 : 56 : TREE_VEC_LENGTH (args)++;
8999 : :
9000 : 56 : if (packed_parms == error_mark_node)
9001 : : return error_mark_node;
9002 : :
9003 : : /* If we're doing a partial instantiation of a member template,
9004 : : verify that all of the types used for the non-type
9005 : : template parameter pack are, in fact, valid for non-type
9006 : : template parameters. */
9007 : 56 : if (arg_idx < nargs
9008 : 56 : && PACK_EXPANSION_P (TREE_VEC_ELT (inner_args, arg_idx)))
9009 : : {
9010 : 17 : int j, len = TREE_VEC_LENGTH (packed_parms);
9011 : 38 : for (j = 0; j < len; ++j)
9012 : : {
9013 : 23 : tree t = TREE_VEC_ELT (packed_parms, j);
9014 : 23 : if (TREE_CODE (t) == PARM_DECL
9015 : 23 : && invalid_nontype_parm_type_p (TREE_TYPE (t), complain))
9016 : 2 : return error_mark_node;
9017 : : }
9018 : : /* We don't know how many args we have yet, just
9019 : : use the unconverted ones for now. */
9020 : : return NULL_TREE;
9021 : : }
9022 : :
9023 : 39 : packed_args = make_tree_vec (TREE_VEC_LENGTH (packed_parms));
9024 : : }
9025 : : else
9026 : 72664682 : packed_args = make_tree_vec (nargs - arg_idx);
9027 : :
9028 : : /* Convert the remaining arguments, which will be a part of the
9029 : : parameter pack "parm". */
9030 : 72664721 : int first_pack_arg = arg_idx;
9031 : 205631227 : for (; arg_idx < nargs; ++arg_idx)
9032 : : {
9033 : 132966518 : tree arg = TREE_VEC_ELT (inner_args, arg_idx);
9034 : 132966518 : tree actual_parm = TREE_VALUE (parm);
9035 : 132966518 : int pack_idx = arg_idx - first_pack_arg;
9036 : :
9037 : 132966518 : if (packed_parms)
9038 : : {
9039 : : /* Once we've packed as many args as we have types, stop. */
9040 : 69 : if (pack_idx >= TREE_VEC_LENGTH (packed_parms))
9041 : : break;
9042 : 57 : else if (PACK_EXPANSION_P (arg))
9043 : : /* We don't know how many args we have yet, just
9044 : : use the unconverted ones for now. */
9045 : : return NULL_TREE;
9046 : : else
9047 : 57 : actual_parm = TREE_VEC_ELT (packed_parms, pack_idx);
9048 : : }
9049 : :
9050 : 132966506 : if (arg == error_mark_node)
9051 : : {
9052 : 749 : if (complain & tf_error)
9053 : 746 : error ("template argument %d is invalid", arg_idx + 1);
9054 : : }
9055 : : else
9056 : 132965757 : arg = convert_template_argument (actual_parm,
9057 : : arg, new_args, complain, parm_idx,
9058 : : in_decl);
9059 : 132966506 : if (arg == error_mark_node)
9060 : 909 : (*lost)++;
9061 : 132966506 : TREE_VEC_ELT (packed_args, pack_idx) = arg;
9062 : : }
9063 : :
9064 : 72664721 : if (arg_idx - first_pack_arg < TREE_VEC_LENGTH (packed_args)
9065 : 72664721 : && TREE_VEC_LENGTH (packed_args) > 0)
9066 : : {
9067 : 3 : if (complain & tf_error)
9068 : 3 : error ("wrong number of template arguments (%d, should be %d)",
9069 : 3 : arg_idx - first_pack_arg, TREE_VEC_LENGTH (packed_args));
9070 : 3 : return error_mark_node;
9071 : : }
9072 : :
9073 : 72664718 : if (TREE_CODE (TREE_VALUE (parm)) == TYPE_DECL
9074 : 72664718 : || TREE_CODE (TREE_VALUE (parm)) == TEMPLATE_DECL)
9075 : 70590516 : argument_pack = cxx_make_type (TYPE_ARGUMENT_PACK);
9076 : : else
9077 : : {
9078 : 2074202 : argument_pack = make_node (NONTYPE_ARGUMENT_PACK);
9079 : 2074202 : TREE_CONSTANT (argument_pack) = 1;
9080 : : }
9081 : :
9082 : 72664718 : ARGUMENT_PACK_ARGS (argument_pack) = packed_args;
9083 : 72664718 : if (CHECKING_P)
9084 : 72664718 : SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (packed_args,
9085 : : TREE_VEC_LENGTH (packed_args));
9086 : 72664718 : return argument_pack;
9087 : : }
9088 : :
9089 : : /* Returns the number of pack expansions in the template argument vector
9090 : : ARGS. */
9091 : :
9092 : : static int
9093 : 1424715503 : pack_expansion_args_count (tree args)
9094 : : {
9095 : 1424715503 : int i;
9096 : 1424715503 : int count = 0;
9097 : 1424715503 : if (args)
9098 : 4064920308 : for (i = 0; i < TREE_VEC_LENGTH (args); ++i)
9099 : : {
9100 : 2640204805 : tree elt = TREE_VEC_ELT (args, i);
9101 : 2640204805 : if (elt && PACK_EXPANSION_P (elt))
9102 : 28615340 : ++count;
9103 : : }
9104 : 1424715503 : return count;
9105 : : }
9106 : :
9107 : : /* Convert all template arguments to their appropriate types, and
9108 : : return a vector containing the innermost resulting template
9109 : : arguments. If any error occurs, return error_mark_node. Error and
9110 : : warning messages are issued under control of COMPLAIN.
9111 : :
9112 : : If PARMS represents all template parameters levels, this function
9113 : : returns a vector of vectors representing all the resulting argument
9114 : : levels. Note that in this case, only the innermost arguments are
9115 : : coerced because the outermost ones are supposed to have been coerced
9116 : : already. Otherwise, if PARMS represents only (the innermost) vector
9117 : : of parameters, this function returns a vector containing just the
9118 : : innermost resulting arguments.
9119 : :
9120 : : If REQUIRE_ALL_ARGS is false, argument deduction will be performed
9121 : : for arguments not specified in ARGS. If REQUIRE_ALL_ARGS is true,
9122 : : arguments not specified in ARGS must have default arguments which
9123 : : we'll use to fill in ARGS. */
9124 : :
9125 : : tree
9126 : 569636275 : coerce_template_parms (tree parms,
9127 : : tree args,
9128 : : tree in_decl,
9129 : : tsubst_flags_t complain,
9130 : : bool require_all_args /* = true */)
9131 : : {
9132 : 569636275 : int nparms, nargs, parm_idx, arg_idx, lost = 0;
9133 : 569636275 : tree orig_inner_args;
9134 : 569636275 : tree inner_args;
9135 : :
9136 : : /* When used as a boolean value, indicates whether this is a
9137 : : variadic template parameter list. Since it's an int, we can also
9138 : : subtract it from nparms to get the number of non-variadic
9139 : : parameters. */
9140 : 569636275 : int variadic_p = 0;
9141 : 569636275 : int variadic_args_p = 0;
9142 : 569636275 : int post_variadic_parms = 0;
9143 : :
9144 : : /* Adjustment to nparms for fixed parameter packs. */
9145 : 569636275 : int fixed_pack_adjust = 0;
9146 : 569636275 : int fixed_packs = 0;
9147 : 569636275 : int missing = 0;
9148 : :
9149 : : /* Likewise for parameters with default arguments. */
9150 : 569636275 : int default_p = 0;
9151 : :
9152 : 569636275 : if (args == error_mark_node)
9153 : : return error_mark_node;
9154 : :
9155 : 569636275 : bool return_full_args = false;
9156 : 569636275 : if (TREE_CODE (parms) == TREE_LIST)
9157 : : {
9158 : 485473135 : if (TMPL_PARMS_DEPTH (parms) > 1)
9159 : : {
9160 : 25263846 : gcc_assert (TMPL_PARMS_DEPTH (parms) == TMPL_ARGS_DEPTH (args));
9161 : : return_full_args = true;
9162 : : }
9163 : 485473135 : parms = INNERMOST_TEMPLATE_PARMS (parms);
9164 : : }
9165 : :
9166 : 569636275 : nparms = TREE_VEC_LENGTH (parms);
9167 : :
9168 : : /* Determine if there are any parameter packs or default arguments. */
9169 : 1479366504 : for (parm_idx = 0; parm_idx < nparms; ++parm_idx)
9170 : : {
9171 : 909730229 : tree parm = TREE_VEC_ELT (parms, parm_idx);
9172 : 909730229 : if (variadic_p)
9173 : 4000 : ++post_variadic_parms;
9174 : 909730229 : if (template_parameter_pack_p (TREE_VALUE (parm)))
9175 : 75356805 : ++variadic_p;
9176 : 909730229 : if (TREE_PURPOSE (parm))
9177 : 141844784 : ++default_p;
9178 : : }
9179 : :
9180 : 569636275 : inner_args = orig_inner_args = INNERMOST_TEMPLATE_ARGS (args);
9181 : : /* If there are no parameters that follow a parameter pack, we need to
9182 : : expand any argument packs so that we can deduce a parameter pack from
9183 : : some non-packed args followed by an argument pack, as in variadic85.C.
9184 : : If there are such parameters, we need to leave argument packs intact
9185 : : so the arguments are assigned properly. This can happen when dealing
9186 : : with a nested class inside a partial specialization of a class
9187 : : template, as in variadic92.C, or when deducing a template parameter pack
9188 : : from a sub-declarator, as in variadic114.C. */
9189 : 569636275 : if (!post_variadic_parms)
9190 : 569632802 : inner_args = expand_template_argument_pack (inner_args);
9191 : :
9192 : : /* Count any pack expansion args. */
9193 : 569636275 : variadic_args_p = pack_expansion_args_count (inner_args);
9194 : :
9195 : 1139272550 : nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0;
9196 : 40919773 : if ((nargs - variadic_args_p > nparms && !variadic_p)
9197 : 609957735 : || (nargs < nparms - variadic_p
9198 : : && require_all_args
9199 : 15640422 : && !variadic_args_p
9200 : 10808822 : && (TREE_VEC_ELT (parms, nargs) != error_mark_node
9201 : 10808822 : && !TREE_PURPOSE (TREE_VEC_ELT (parms, nargs)))))
9202 : : {
9203 : 598426 : bad_nargs:
9204 : 598426 : if (complain & tf_error)
9205 : : {
9206 : 84 : auto_diagnostic_group d;
9207 : 84 : if (variadic_p || default_p)
9208 : : {
9209 : 12 : nparms -= variadic_p + default_p;
9210 : 12 : error ("wrong number of template arguments "
9211 : : "(%d, should be at least %d)", nargs, nparms);
9212 : : }
9213 : : else
9214 : 72 : error ("wrong number of template arguments "
9215 : : "(%d, should be %d)", nargs, nparms);
9216 : :
9217 : 84 : if (in_decl)
9218 : 84 : inform (DECL_SOURCE_LOCATION (in_decl),
9219 : : "provided for %qD", in_decl);
9220 : 84 : }
9221 : :
9222 : 598426 : return error_mark_node;
9223 : : }
9224 : : /* We can't pass a pack expansion to a non-pack parameter of an alias
9225 : : template (DR 1430). */
9226 : 569037858 : else if (in_decl
9227 : 560062095 : && (DECL_ALIAS_TEMPLATE_P (in_decl)
9228 : 468878679 : || concept_definition_p (in_decl))
9229 : 106463521 : && variadic_args_p
9230 : 573095227 : && nargs - variadic_args_p < nparms - variadic_p)
9231 : : {
9232 : 24 : if (complain & tf_error)
9233 : : {
9234 : 27 : for (int i = 0; i < TREE_VEC_LENGTH (inner_args); ++i)
9235 : : {
9236 : 27 : tree arg = TREE_VEC_ELT (inner_args, i);
9237 : 27 : tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
9238 : :
9239 : 27 : if (PACK_EXPANSION_P (arg)
9240 : 27 : && !template_parameter_pack_p (parm))
9241 : : {
9242 : 24 : auto_diagnostic_group d;
9243 : 24 : if (DECL_ALIAS_TEMPLATE_P (in_decl))
9244 : 12 : error_at (location_of (arg),
9245 : : "pack expansion argument for non-pack parameter "
9246 : : "%qD of alias template %qD", parm, in_decl);
9247 : : else
9248 : 12 : error_at (location_of (arg),
9249 : : "pack expansion argument for non-pack parameter "
9250 : : "%qD of concept %qD", parm, in_decl);
9251 : 24 : inform (DECL_SOURCE_LOCATION (parm), "declared here");
9252 : 24 : goto found;
9253 : 24 : }
9254 : : }
9255 : 0 : gcc_unreachable ();
9256 : 24 : found:;
9257 : : }
9258 : 24 : return error_mark_node;
9259 : : }
9260 : :
9261 : : /* We need to evaluate the template arguments, even though this
9262 : : template-id may be nested within a "sizeof". */
9263 : 569037834 : cp_evaluated ev;
9264 : :
9265 : 569037834 : tree new_args = add_outermost_template_args (args, make_tree_vec (nparms));
9266 : 569037834 : tree& new_inner_args = TMPL_ARGS_LEVEL (new_args, TMPL_ARGS_DEPTH (new_args));
9267 : 569037834 : int pack_adjust = 0;
9268 : 1467311309 : for (parm_idx = 0, arg_idx = 0; parm_idx < nparms; parm_idx++, arg_idx++)
9269 : : {
9270 : 905840050 : tree arg;
9271 : 905840050 : tree parm;
9272 : :
9273 : : /* Get the Ith template parameter. */
9274 : 905840050 : parm = TREE_VEC_ELT (parms, parm_idx);
9275 : :
9276 : 905840050 : if (parm == error_mark_node)
9277 : : {
9278 : 0 : TREE_VEC_ELT (new_inner_args, arg_idx) = error_mark_node;
9279 : 0 : continue;
9280 : : }
9281 : :
9282 : : /* Calculate the next argument. */
9283 : 905840050 : if (arg_idx < nargs)
9284 : 884387759 : arg = TREE_VEC_ELT (inner_args, arg_idx);
9285 : : else
9286 : : arg = NULL_TREE;
9287 : :
9288 : 905840050 : if (template_parameter_pack_p (TREE_VALUE (parm))
9289 : 74792595 : && (arg || require_all_args || !(complain & tf_partial))
9290 : 978504812 : && !(arg && ARGUMENT_PACK_P (arg)))
9291 : : {
9292 : : /* Some arguments will be placed in the
9293 : : template parameter pack PARM. */
9294 : 72664741 : arg = coerce_template_parameter_pack (parms, parm_idx, args,
9295 : : inner_args, arg_idx,
9296 : : new_args, &lost,
9297 : : in_decl, complain);
9298 : :
9299 : 72664738 : if (arg == NULL_TREE)
9300 : : {
9301 : : /* We don't know how many args we have yet, just use the
9302 : : unconverted (and still packed) ones for now. */
9303 : 15 : ggc_free (new_inner_args);
9304 : 15 : new_inner_args = orig_inner_args;
9305 : 15 : arg_idx = nargs;
9306 : 15 : break;
9307 : : }
9308 : :
9309 : 72664723 : TREE_VEC_ELT (new_inner_args, parm_idx) = arg;
9310 : :
9311 : : /* Store this argument. */
9312 : 72664723 : if (arg == error_mark_node)
9313 : : {
9314 : 5 : lost++;
9315 : : /* We are done with all of the arguments. */
9316 : 5 : arg_idx = nargs;
9317 : 5 : break;
9318 : : }
9319 : : else
9320 : : {
9321 : 72664718 : pack_adjust = TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) - 1;
9322 : 72664718 : arg_idx += pack_adjust;
9323 : 72664718 : if (fixed_parameter_pack_p (TREE_VALUE (parm)))
9324 : : {
9325 : 36 : ++fixed_packs;
9326 : 36 : fixed_pack_adjust += pack_adjust;
9327 : : }
9328 : : }
9329 : :
9330 : 72664718 : continue;
9331 : : }
9332 : 833175309 : else if (arg)
9333 : : {
9334 : 813330241 : if (PACK_EXPANSION_P (arg))
9335 : : {
9336 : : /* "If every valid specialization of a variadic template
9337 : : requires an empty template parameter pack, the template is
9338 : : ill-formed, no diagnostic required." So check that the
9339 : : pattern works with this parameter. */
9340 : 834702 : tree pattern = PACK_EXPANSION_PATTERN (arg);
9341 : 834702 : tree conv = convert_template_argument (TREE_VALUE (parm),
9342 : : pattern, new_args,
9343 : : complain, parm_idx,
9344 : : in_decl);
9345 : 834702 : if (conv == error_mark_node)
9346 : : {
9347 : 10 : if (complain & tf_error)
9348 : 6 : inform (input_location, "so any instantiation with a "
9349 : : "non-empty parameter pack would be ill-formed");
9350 : 10 : ++lost;
9351 : : }
9352 : 834692 : else if (TYPE_P (conv) && !TYPE_P (pattern))
9353 : : /* Recover from missing typename. */
9354 : 9 : TREE_VEC_ELT (inner_args, arg_idx)
9355 : 18 : = make_pack_expansion (conv, complain);
9356 : :
9357 : : /* We don't know how many args we have yet, just
9358 : : use the unconverted (but unpacked) ones for now. */
9359 : 834702 : ggc_free (new_inner_args);
9360 : 834702 : new_inner_args = inner_args;
9361 : 834702 : arg_idx = nargs;
9362 : 834702 : break;
9363 : : }
9364 : : }
9365 : 19845068 : else if (require_all_args)
9366 : : {
9367 : : /* There must be a default arg in this case. */
9368 : 13113218 : arg = tsubst_template_arg (TREE_PURPOSE (parm), new_args,
9369 : 13113218 : complain | (processing_template_decl
9370 : 13113218 : ? tf_partial : tf_none),
9371 : : in_decl);
9372 : : /* The position of the first default template argument,
9373 : : is also the number of non-defaulted arguments in NEW_INNER_ARGS.
9374 : : Record that. */
9375 : 13113218 : if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args))
9376 : 10808757 : SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args,
9377 : : arg_idx - pack_adjust);
9378 : : }
9379 : : else
9380 : : break;
9381 : :
9382 : 825608757 : if (arg == error_mark_node)
9383 : : {
9384 : 976 : if (complain & tf_error)
9385 : 948 : error ("template argument %d is invalid", arg_idx + 1);
9386 : : }
9387 : 825607781 : else if (!arg)
9388 : : {
9389 : : /* This can occur if there was an error in the template
9390 : : parameter list itself (which we would already have
9391 : : reported) that we are trying to recover from, e.g., a class
9392 : : template with a parameter list such as
9393 : : template<typename..., typename> (cpp0x/variadic150.C). */
9394 : 31 : ++lost;
9395 : :
9396 : : /* This can also happen with a fixed parameter pack (71834). */
9397 : 31 : if (arg_idx >= nargs)
9398 : 6 : ++missing;
9399 : : }
9400 : : else
9401 : 825607750 : arg = convert_template_argument (TREE_VALUE (parm),
9402 : : arg, new_args, complain,
9403 : : parm_idx, in_decl);
9404 : :
9405 : 825608757 : if (arg == error_mark_node)
9406 : 2137287 : lost++;
9407 : :
9408 : 825608757 : TREE_VEC_ELT (new_inner_args, arg_idx - pack_adjust) = arg;
9409 : : }
9410 : :
9411 : 569037831 : if (missing || arg_idx < nargs - variadic_args_p)
9412 : : {
9413 : : /* If we had fixed parameter packs, we didn't know how many arguments we
9414 : : actually needed earlier; now we do. */
9415 : 9 : nparms += fixed_pack_adjust;
9416 : 9 : variadic_p -= fixed_packs;
9417 : 9 : goto bad_nargs;
9418 : : }
9419 : :
9420 : 569037822 : if (arg_idx < nargs)
9421 : : {
9422 : : /* We had some pack expansion arguments that will only work if the packs
9423 : : are empty, but wait until instantiation time to complain.
9424 : : See variadic-ttp3.C. */
9425 : :
9426 : : /* Except that we can't provide empty packs to alias templates or
9427 : : concepts when there are no corresponding parameters. Basically,
9428 : : we can get here with this:
9429 : :
9430 : : template<typename T> concept C = true;
9431 : :
9432 : : template<typename... Args>
9433 : : requires C<Args...>
9434 : : void f();
9435 : :
9436 : : When parsing C<Args...>, we try to form a concept check of
9437 : : C<?, Args...>. Without the extra check for substituting an empty
9438 : : pack past the last parameter, we can accept the check as valid.
9439 : :
9440 : : FIXME: This may be valid for alias templates (but I doubt it).
9441 : :
9442 : : FIXME: The error could be better also. */
9443 : 73422 : if (in_decl && concept_definition_p (in_decl))
9444 : : {
9445 : 0 : if (complain & tf_error)
9446 : 0 : error_at (location_of (TREE_VEC_ELT (args, arg_idx)),
9447 : : "too many arguments");
9448 : 569037822 : return error_mark_node;
9449 : : }
9450 : :
9451 : 48705 : int len = nparms + (nargs - arg_idx);
9452 : 48705 : tree args = make_tree_vec (len);
9453 : 48705 : int i = 0;
9454 : 146118 : for (; i < nparms; ++i)
9455 : 48708 : TREE_VEC_ELT (args, i) = TREE_VEC_ELT (new_inner_args, i);
9456 : 97410 : for (; i < len; ++i, ++arg_idx)
9457 : 48705 : TREE_VEC_ELT (args, i) = TREE_VEC_ELT (inner_args,
9458 : : arg_idx - pack_adjust);
9459 : 48705 : new_inner_args = args;
9460 : : }
9461 : :
9462 : 569037822 : if (lost)
9463 : : {
9464 : 2137902 : gcc_assert (!(complain & tf_error) || seen_error ());
9465 : 2137902 : return error_mark_node;
9466 : : }
9467 : :
9468 : 566899920 : if (CHECKING_P && !NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args))
9469 : 555256535 : SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args,
9470 : : TREE_VEC_LENGTH (new_inner_args));
9471 : :
9472 : : /* If we expanded packs in inner_args and aren't returning it now, the
9473 : : expanded vec is garbage. */
9474 : 566899920 : if (inner_args != new_inner_args
9475 : 566065228 : && inner_args != orig_inner_args)
9476 : 52944862 : ggc_free (inner_args);
9477 : :
9478 : 566899920 : return return_full_args ? new_args : new_inner_args;
9479 : : }
9480 : :
9481 : : /* Returns true if T is a wrapper to make a C++20 template parameter
9482 : : object const. */
9483 : :
9484 : : static bool
9485 : 5121690280 : class_nttp_const_wrapper_p (tree t)
9486 : : {
9487 : 5121690280 : if (cxx_dialect < cxx20)
9488 : : return false;
9489 : 2450747995 : return (TREE_CODE (t) == VIEW_CONVERT_EXPR
9490 : 189 : && CP_TYPE_CONST_P (TREE_TYPE (t))
9491 : 2450748184 : && TREE_CODE (TREE_OPERAND (t, 0)) == TEMPLATE_PARM_INDEX);
9492 : : }
9493 : :
9494 : : /* Returns 1 if template args OT and NT are equivalent. */
9495 : :
9496 : : int
9497 : 2345589420 : template_args_equal (tree ot, tree nt)
9498 : : {
9499 : 2345589420 : if (nt == ot)
9500 : : return 1;
9501 : 1412493862 : if (nt == NULL_TREE || ot == NULL_TREE)
9502 : : return false;
9503 : 1412362605 : if (nt == any_targ_node || ot == any_targ_node)
9504 : : return true;
9505 : :
9506 : 1412362601 : if (class_nttp_const_wrapper_p (nt))
9507 : 48 : nt = TREE_OPERAND (nt, 0);
9508 : 1412362601 : if (class_nttp_const_wrapper_p (ot))
9509 : 63 : ot = TREE_OPERAND (ot, 0);
9510 : :
9511 : : /* DR 1558: Don't treat an alias template specialization with dependent
9512 : : arguments as equivalent to its underlying type when used as a template
9513 : : argument; we need them to be distinct so that we substitute into the
9514 : : specialization arguments at instantiation time. And aliases can't be
9515 : : equivalent without being ==, so we don't need to look any deeper.
9516 : :
9517 : : During partial ordering, however, we need to treat them normally so we can
9518 : : order uses of the same alias with different cv-qualification (79960). */
9519 : 1412362601 : auto cso = make_temp_override (comparing_dependent_aliases);
9520 : 1412362601 : if (!comparing_for_partial_ordering)
9521 : 1410181971 : ++comparing_dependent_aliases;
9522 : :
9523 : 1412362601 : if (TREE_CODE (nt) == TREE_VEC || TREE_CODE (ot) == TREE_VEC)
9524 : : /* For member templates */
9525 : 68683693 : return TREE_CODE (ot) == TREE_CODE (nt) && comp_template_args (ot, nt);
9526 : 1368939862 : else if (PACK_EXPANSION_P (ot) || PACK_EXPANSION_P (nt))
9527 : 15427519 : return (PACK_EXPANSION_P (ot) && PACK_EXPANSION_P (nt)
9528 : 14176731 : && template_args_equal (PACK_EXPANSION_PATTERN (ot),
9529 : 14176731 : PACK_EXPANSION_PATTERN (nt))
9530 : 26582228 : && template_args_equal (PACK_EXPANSION_EXTRA_ARGS (ot),
9531 : 26582228 : PACK_EXPANSION_EXTRA_ARGS (nt)));
9532 : 1353097659 : else if (ARGUMENT_PACK_P (ot) || ARGUMENT_PACK_P (nt))
9533 : 243387270 : return cp_tree_equal (ot, nt);
9534 : 1109710389 : else if (TREE_CODE (ot) == ARGUMENT_PACK_SELECT)
9535 : 0 : gcc_unreachable ();
9536 : 1109710389 : else if (TYPE_P (nt) || TYPE_P (ot))
9537 : : {
9538 : 939212870 : if (!(TYPE_P (nt) && TYPE_P (ot)))
9539 : : return false;
9540 : 929848915 : return same_type_p (ot, nt);
9541 : : }
9542 : : else
9543 : : {
9544 : : /* Try to treat a template non-type argument that has been converted
9545 : : to the parameter type as equivalent to one that hasn't yet. */
9546 : 170497519 : for (enum tree_code code1 = TREE_CODE (ot);
9547 : 170748715 : CONVERT_EXPR_CODE_P (code1)
9548 : 170748715 : || code1 == NON_LVALUE_EXPR;
9549 : 251196 : code1 = TREE_CODE (ot))
9550 : 251196 : ot = TREE_OPERAND (ot, 0);
9551 : :
9552 : 170497519 : for (enum tree_code code2 = TREE_CODE (nt);
9553 : 170811574 : CONVERT_EXPR_CODE_P (code2)
9554 : 170811574 : || code2 == NON_LVALUE_EXPR;
9555 : 314055 : code2 = TREE_CODE (nt))
9556 : 314055 : nt = TREE_OPERAND (nt, 0);
9557 : :
9558 : 170497519 : return cp_tree_equal (ot, nt);
9559 : : }
9560 : 1412362601 : }
9561 : :
9562 : : /* Returns true iff the OLDARGS and NEWARGS are in fact identical sets of
9563 : : template arguments. Returns false otherwise, and updates OLDARG_PTR and
9564 : : NEWARG_PTR with the offending arguments if they are non-NULL. */
9565 : :
9566 : : bool
9567 : 1960782576 : comp_template_args (tree oldargs, tree newargs,
9568 : : tree *oldarg_ptr /* = NULL */, tree *newarg_ptr /* = NULL */)
9569 : : {
9570 : 1960782576 : if (oldargs == newargs)
9571 : : return true;
9572 : :
9573 : 1339388493 : if (!oldargs || !newargs)
9574 : : return false;
9575 : :
9576 : 1339388492 : if (TREE_VEC_LENGTH (oldargs) != TREE_VEC_LENGTH (newargs))
9577 : : return false;
9578 : :
9579 : 2267400375 : for (int i = 0; i < TREE_VEC_LENGTH (oldargs); ++i)
9580 : : {
9581 : 1744842627 : tree nt = TREE_VEC_ELT (newargs, i);
9582 : 1744842627 : tree ot = TREE_VEC_ELT (oldargs, i);
9583 : :
9584 : 1744842627 : if (! template_args_equal (ot, nt))
9585 : : {
9586 : 815743570 : if (oldarg_ptr != NULL)
9587 : 12 : *oldarg_ptr = ot;
9588 : 815743570 : if (newarg_ptr != NULL)
9589 : 12 : *newarg_ptr = nt;
9590 : 815743570 : return false;
9591 : : }
9592 : : }
9593 : : return true;
9594 : : }
9595 : :
9596 : : static bool
9597 : 12465147 : comp_template_args_porder (tree oargs, tree nargs)
9598 : : {
9599 : 12465147 : ++comparing_for_partial_ordering;
9600 : 12465147 : bool equal = comp_template_args (oargs, nargs);
9601 : 12465147 : --comparing_for_partial_ordering;
9602 : 12465147 : return equal;
9603 : : }
9604 : :
9605 : : /* Implement a freelist interface for objects of type T.
9606 : :
9607 : : Head is a separate object, rather than a regular member, so that we
9608 : : can define it as a GTY deletable pointer, which is highly
9609 : : desirable. A data member could be declared that way, but then the
9610 : : containing object would implicitly get GTY((user)), which would
9611 : : prevent us from instantiating freelists as global objects.
9612 : : Although this way we can create freelist global objects, they're
9613 : : such thin wrappers that instantiating temporaries at every use
9614 : : loses nothing and saves permanent storage for the freelist object.
9615 : :
9616 : : Member functions next, anew, poison and reinit have default
9617 : : implementations that work for most of the types we're interested
9618 : : in, but if they don't work for some type, they should be explicitly
9619 : : specialized. See the comments before them for requirements, and
9620 : : the example specializations for the tree_list_freelist. */
9621 : : template <typename T>
9622 : : class freelist
9623 : : {
9624 : : /* Return the next object in a chain. We could just do type
9625 : : punning, but if we access the object with its underlying type, we
9626 : : avoid strict-aliasing trouble. This needs only work between
9627 : : poison and reinit. */
9628 : 618762001 : static T *&next (T *obj) { return obj->next; }
9629 : :
9630 : : /* Return a newly allocated, uninitialized or minimally-initialized
9631 : : object of type T. Any initialization performed by anew should
9632 : : either remain across the life of the object and the execution of
9633 : : poison, or be redone by reinit. */
9634 : 13744836 : static T *anew () { return ggc_alloc<T> (); }
9635 : :
9636 : : /* Optionally scribble all over the bits holding the object, so that
9637 : : they become (mostly?) uninitialized memory. This is called while
9638 : : preparing to make the object part of the free list. */
9639 : 631065778 : static void poison (T *obj) {
9640 : 631065778 : T *p ATTRIBUTE_UNUSED = obj;
9641 : 631065778 : T **q ATTRIBUTE_UNUSED = &next (obj);
9642 : :
9643 : : #ifdef ENABLE_GC_CHECKING
9644 : : /* Poison the data, to indicate the data is garbage. */
9645 : : VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (p, sizeof (*p)));
9646 : 631065778 : memset (p, 0xa5, sizeof (*p));
9647 : : #endif
9648 : : /* Let valgrind know the object is free. */
9649 : : VALGRIND_DISCARD (VALGRIND_MAKE_MEM_NOACCESS (p, sizeof (*p)));
9650 : :
9651 : : /* Let valgrind know the next portion of the object is available,
9652 : : but uninitialized. */
9653 : : VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (q, sizeof (*q)));
9654 : : }
9655 : :
9656 : : /* Bring an object that underwent at least one lifecycle after anew
9657 : : and before the most recent free and poison, back to a usable
9658 : : state, reinitializing whatever is needed for it to be
9659 : : functionally equivalent to an object just allocated and returned
9660 : : by anew. This may poison or clear the next field, used by
9661 : : freelist housekeeping after poison was called. */
9662 : 618762001 : static void reinit (T *obj) {
9663 : 618762001 : T **q ATTRIBUTE_UNUSED = &next (obj);
9664 : :
9665 : : #ifdef ENABLE_GC_CHECKING
9666 : 618762001 : memset (q, 0xa5, sizeof (*q));
9667 : : #endif
9668 : : /* Let valgrind know the entire object is available, but
9669 : : uninitialized. */
9670 : : VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (obj, sizeof (*obj)));
9671 : : }
9672 : :
9673 : : /* Reference a GTY-deletable pointer that points to the first object
9674 : : in the free list proper. */
9675 : : T *&head;
9676 : : public:
9677 : : /* Construct a freelist object chaining objects off of HEAD. */
9678 : 1263574675 : freelist (T *&head) : head(head) {}
9679 : :
9680 : : /* Add OBJ to the free object list. The former head becomes OBJ's
9681 : : successor. */
9682 : 631066474 : void free (T *obj)
9683 : : {
9684 : 631066474 : poison (obj);
9685 : 631066474 : next (obj) = head;
9686 : 631066474 : head = obj;
9687 : 631066474 : }
9688 : :
9689 : : /* Take an object from the free list, if one is available, or
9690 : : allocate a new one. Objects taken from the free list should be
9691 : : regarded as filled with garbage, except for bits that are
9692 : : configured to be preserved across free and alloc. */
9693 : 632508201 : T *alloc ()
9694 : : {
9695 : 632508201 : if (head)
9696 : : {
9697 : 618762629 : T *obj = head;
9698 : 618762629 : head = next (head);
9699 : 618762629 : reinit (obj);
9700 : 618762629 : return obj;
9701 : : }
9702 : : else
9703 : 13745572 : return anew ();
9704 : : }
9705 : : };
9706 : :
9707 : : /* Explicitly specialize the interfaces for freelist<tree_node>: we
9708 : : want to allocate a TREE_LIST using the usual interface, and ensure
9709 : : TREE_CHAIN remains functional. Alas, we have to duplicate a bit of
9710 : : build_tree_list logic in reinit, so this could go out of sync. */
9711 : : template <>
9712 : : inline tree &
9713 : 2020 : freelist<tree_node>::next (tree obj)
9714 : : {
9715 : 2020 : return TREE_CHAIN (obj);
9716 : : }
9717 : : template <>
9718 : : inline tree
9719 : 736 : freelist<tree_node>::anew ()
9720 : : {
9721 : 736 : return build_tree_list (NULL, NULL);
9722 : : }
9723 : : template <>
9724 : : inline void
9725 : 696 : freelist<tree_node>::poison (tree obj ATTRIBUTE_UNUSED)
9726 : : {
9727 : 696 : int size ATTRIBUTE_UNUSED = sizeof (tree_list);
9728 : 696 : tree p ATTRIBUTE_UNUSED = obj;
9729 : 696 : tree_base *b ATTRIBUTE_UNUSED = &obj->base;
9730 : 696 : tree *q ATTRIBUTE_UNUSED = &next (obj);
9731 : :
9732 : : #ifdef ENABLE_GC_CHECKING
9733 : 696 : gcc_checking_assert (TREE_CODE (obj) == TREE_LIST);
9734 : :
9735 : : /* Poison the data, to indicate the data is garbage. */
9736 : 696 : VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (p, size));
9737 : 696 : memset (p, 0xa5, size);
9738 : : #endif
9739 : : /* Let valgrind know the object is free. */
9740 : 696 : VALGRIND_DISCARD (VALGRIND_MAKE_MEM_NOACCESS (p, size));
9741 : : /* But we still want to use the TREE_CODE and TREE_CHAIN parts. */
9742 : 696 : VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (b, sizeof (*b)));
9743 : 696 : VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (q, sizeof (*q)));
9744 : :
9745 : : #ifdef ENABLE_GC_CHECKING
9746 : 696 : VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (b, sizeof (*b)));
9747 : : /* Keep TREE_CHAIN functional. */
9748 : 696 : TREE_SET_CODE (obj, TREE_LIST);
9749 : : #else
9750 : : VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (b, sizeof (*b)));
9751 : : #endif
9752 : 696 : }
9753 : : template <>
9754 : : inline void
9755 : 628 : freelist<tree_node>::reinit (tree obj ATTRIBUTE_UNUSED)
9756 : : {
9757 : 628 : tree_common *c ATTRIBUTE_UNUSED = &obj->common;
9758 : :
9759 : : #ifdef ENABLE_GC_CHECKING
9760 : 628 : gcc_checking_assert (TREE_CODE (obj) == TREE_LIST);
9761 : 628 : VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (obj, sizeof (tree_list)));
9762 : 628 : memset (obj, 0, sizeof (tree_list));
9763 : : #endif
9764 : :
9765 : : /* Let valgrind know the entire object is available, but
9766 : : uninitialized. */
9767 : 628 : VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (obj, sizeof (tree_list)));
9768 : :
9769 : : #ifdef ENABLE_GC_CHECKING
9770 : 628 : TREE_SET_CODE (obj, TREE_LIST);
9771 : : #else
9772 : : TREE_CHAIN (obj) = NULL_TREE;
9773 : : TREE_TYPE (obj) = NULL_TREE;
9774 : : #endif
9775 : 628 : VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (c, sizeof (*c)));
9776 : 628 : }
9777 : :
9778 : : /* Point to the first object in the TREE_LIST freelist. */
9779 : : static GTY((deletable)) tree tree_list_freelist_head;
9780 : : /* Return the/an actual TREE_LIST freelist. */
9781 : : static inline freelist<tree_node>
9782 : 2060 : tree_list_freelist ()
9783 : : {
9784 : 2060 : return tree_list_freelist_head;
9785 : : }
9786 : :
9787 : : /* Point to the first object in the tinst_level freelist. */
9788 : : static GTY((deletable)) tinst_level *tinst_level_freelist_head;
9789 : : /* Return the/an actual tinst_level freelist. */
9790 : : static inline freelist<tinst_level>
9791 : 1233253706 : tinst_level_freelist ()
9792 : : {
9793 : 1233253706 : return tinst_level_freelist_head;
9794 : : }
9795 : :
9796 : : /* Point to the first object in the pending_template freelist. */
9797 : : static GTY((deletable)) pending_template *pending_template_freelist_head;
9798 : : /* Return the/an actual pending_template freelist. */
9799 : : static inline freelist<pending_template>
9800 : 30318909 : pending_template_freelist ()
9801 : : {
9802 : 30318909 : return pending_template_freelist_head;
9803 : : }
9804 : :
9805 : : /* Build the TREE_LIST object out of a split list, store it
9806 : : permanently, and return it. */
9807 : : tree
9808 : 1364 : tinst_level::to_list ()
9809 : : {
9810 : 1364 : gcc_assert (split_list_p ());
9811 : 1364 : tree ret = tree_list_freelist ().alloc ();
9812 : 1364 : TREE_PURPOSE (ret) = tldcl;
9813 : 1364 : TREE_VALUE (ret) = targs;
9814 : 1364 : tldcl = ret;
9815 : 1364 : targs = NULL;
9816 : 1364 : gcc_assert (tree_list_p ());
9817 : 1364 : return ret;
9818 : : }
9819 : :
9820 : : const unsigned short tinst_level::refcount_infinity;
9821 : :
9822 : : /* Increment OBJ's refcount unless it is already infinite. */
9823 : : static tinst_level *
9824 : 1901610659 : inc_refcount_use (tinst_level *obj)
9825 : : {
9826 : 1371409445 : if (obj && obj->refcount != tinst_level::refcount_infinity)
9827 : 1371409445 : ++obj->refcount;
9828 : 1901610659 : return obj;
9829 : : }
9830 : :
9831 : : /* Release storage for OBJ and node, if it's a TREE_LIST. */
9832 : : void
9833 : 616125733 : tinst_level::free (tinst_level *obj)
9834 : : {
9835 : 616125733 : if (obj->tree_list_p ())
9836 : 696 : tree_list_freelist ().free (obj->get_node ());
9837 : 616125733 : tinst_level_freelist ().free (obj);
9838 : 616125733 : }
9839 : :
9840 : : /* Decrement OBJ's refcount if not infinite. If it reaches zero, release
9841 : : OBJ's DECL and OBJ, and start over with the tinst_level object that
9842 : : used to be referenced by OBJ's NEXT. */
9843 : : static void
9844 : 1933987101 : dec_refcount_use (tinst_level *obj)
9845 : : {
9846 : 1933987101 : while (obj
9847 : 1370100489 : && obj->refcount != tinst_level::refcount_infinity
9848 : 3920213323 : && !--obj->refcount)
9849 : : {
9850 : 616125733 : tinst_level *next = obj->next;
9851 : 616125733 : tinst_level::free (obj);
9852 : 616125733 : obj = next;
9853 : : }
9854 : 1933987101 : }
9855 : :
9856 : : /* Modify PTR so that it points to OBJ, adjusting the refcounts of OBJ
9857 : : and of the former PTR. Omitting the second argument is equivalent
9858 : : to passing (T*)NULL; this is allowed because passing the
9859 : : zero-valued integral constant NULL confuses type deduction and/or
9860 : : overload resolution. */
9861 : : template <typename T>
9862 : : static void
9863 : 1933987101 : set_refcount_ptr (T *& ptr, T *obj = NULL)
9864 : : {
9865 : 1901610659 : T *save = ptr;
9866 : 1933987101 : ptr = inc_refcount_use (obj);
9867 : 1901610659 : dec_refcount_use (save);
9868 : 17436397 : }
9869 : :
9870 : : static void
9871 : 19316145 : add_pending_template (tree d)
9872 : : {
9873 : 19316145 : tree ti = (TYPE_P (d)
9874 : 19316145 : ? CLASSTYPE_TEMPLATE_INFO (d)
9875 : 19316145 : : DECL_TEMPLATE_INFO (d));
9876 : 19316145 : struct pending_template *pt;
9877 : 19316145 : int level;
9878 : :
9879 : 19316145 : if (TI_PENDING_TEMPLATE_FLAG (ti))
9880 : : return;
9881 : :
9882 : : /* We are called both from instantiate_decl, where we've already had a
9883 : : tinst_level pushed, and instantiate_template, where we haven't.
9884 : : Compensate. */
9885 : 15378864 : gcc_assert (TREE_CODE (d) != TREE_LIST);
9886 : 30757728 : level = !current_tinst_level
9887 : 30757728 : || current_tinst_level->maybe_get_node () != d;
9888 : :
9889 : 0 : if (level)
9890 : 0 : push_tinst_level (d);
9891 : :
9892 : 15378864 : pt = pending_template_freelist ().alloc ();
9893 : 15378864 : pt->next = NULL;
9894 : 15378864 : pt->tinst = NULL;
9895 : 15378864 : set_refcount_ptr (pt->tinst, current_tinst_level);
9896 : 15378864 : if (last_pending_template)
9897 : 15349561 : last_pending_template->next = pt;
9898 : : else
9899 : 29303 : pending_templates = pt;
9900 : :
9901 : 15378864 : last_pending_template = pt;
9902 : :
9903 : 15378864 : TI_PENDING_TEMPLATE_FLAG (ti) = 1;
9904 : :
9905 : 15378864 : if (level)
9906 : 0 : pop_tinst_level ();
9907 : : }
9908 : :
9909 : : /* Emit a diagnostic about instantiating a reference to TU-local entity E. */
9910 : :
9911 : : static void
9912 : 81 : complain_about_tu_local_entity (tree e)
9913 : : {
9914 : 81 : auto_diagnostic_group d;
9915 : 81 : error ("instantiation exposes TU-local entity %qD",
9916 : 81 : TU_LOCAL_ENTITY_NAME (e));
9917 : 81 : inform (TU_LOCAL_ENTITY_LOCATION (e), "declared here");
9918 : 81 : }
9919 : :
9920 : : /* Checks if T contains a TU-local entity. */
9921 : :
9922 : : static bool
9923 : 91929482 : expr_contains_tu_local_entity (tree t)
9924 : : {
9925 : 91929482 : if (!modules_p ())
9926 : : return false;
9927 : :
9928 : 312554 : auto walker = [](tree *tp, int *walk_subtrees, void *) -> tree
9929 : : {
9930 : : if (TREE_CODE (*tp) == TU_LOCAL_ENTITY)
9931 : : return *tp;
9932 : : if (!EXPR_P (*tp))
9933 : : *walk_subtrees = false;
9934 : : return NULL_TREE;
9935 : : };
9936 : 312554 : return cp_walk_tree (&t, walker, nullptr, nullptr);
9937 : : }
9938 : :
9939 : : /* Errors and returns TRUE if X is a function that contains a TU-local
9940 : : entity in its overload set. */
9941 : :
9942 : : static bool
9943 : 95318839 : function_contains_tu_local_entity (tree x)
9944 : : {
9945 : 95318839 : if (!modules_p ())
9946 : : return false;
9947 : :
9948 : 438262 : if (!x || x == error_mark_node)
9949 : : return false;
9950 : :
9951 : 437604 : if (TREE_CODE (x) == OFFSET_REF
9952 : 437493 : || TREE_CODE (x) == COMPONENT_REF)
9953 : 61851 : x = TREE_OPERAND (x, 1);
9954 : 437604 : x = MAYBE_BASELINK_FUNCTIONS (x);
9955 : 437604 : if (TREE_CODE (x) == TEMPLATE_ID_EXPR)
9956 : 110063 : x = TREE_OPERAND (x, 0);
9957 : :
9958 : 437604 : if (OVL_P (x))
9959 : 1346944 : for (tree ovl : lkp_range (x))
9960 : 556108 : if (TREE_CODE (ovl) == TU_LOCAL_ENTITY)
9961 : : {
9962 : : x = ovl;
9963 : : break;
9964 : : }
9965 : :
9966 : 437604 : if (TREE_CODE (x) == TU_LOCAL_ENTITY)
9967 : : {
9968 : 12 : complain_about_tu_local_entity (x);
9969 : 12 : return true;
9970 : : }
9971 : :
9972 : : return false;
9973 : : }
9974 : :
9975 : : /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
9976 : : ARGLIST. Valid choices for FNS are given in the cp-tree.def
9977 : : documentation for TEMPLATE_ID_EXPR. */
9978 : :
9979 : : tree
9980 : 43370528 : lookup_template_function (tree fns, tree arglist)
9981 : : {
9982 : 43370528 : if (fns == error_mark_node || arglist == error_mark_node)
9983 : : return error_mark_node;
9984 : :
9985 : 43370506 : gcc_assert (!arglist || TREE_CODE (arglist) == TREE_VEC);
9986 : :
9987 : 43370506 : if (!is_overloaded_fn (fns) && !identifier_p (fns))
9988 : : {
9989 : 3 : error ("%q#D is not a function template", fns);
9990 : 3 : return error_mark_node;
9991 : : }
9992 : :
9993 : 43370503 : if (BASELINK_P (fns))
9994 : : {
9995 : 3483442 : fns = copy_node (fns);
9996 : 6966884 : BASELINK_FUNCTIONS (fns) = build2 (TEMPLATE_ID_EXPR,
9997 : : unknown_type_node,
9998 : 3483442 : BASELINK_FUNCTIONS (fns),
9999 : : arglist);
10000 : 3483442 : return fns;
10001 : : }
10002 : :
10003 : 39887061 : return build2 (TEMPLATE_ID_EXPR, unknown_type_node, fns, arglist);
10004 : : }
10005 : :
10006 : : /* Within the scope of a template class S<T>, the name S gets bound
10007 : : (in build_self_reference) to a TYPE_DECL for the class, not a
10008 : : TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
10009 : : or one of its enclosing classes, and that type is a template,
10010 : : return the associated TEMPLATE_DECL. Otherwise, the original
10011 : : DECL is returned.
10012 : :
10013 : : Also handle the case when DECL is a TREE_LIST of ambiguous
10014 : : injected-class-names from different bases. */
10015 : :
10016 : : tree
10017 : 571677150 : maybe_get_template_decl_from_type_decl (tree decl)
10018 : : {
10019 : 571677150 : if (decl == NULL_TREE)
10020 : : return decl;
10021 : :
10022 : : /* DR 176: A lookup that finds an injected-class-name (10.2
10023 : : [class.member.lookup]) can result in an ambiguity in certain cases
10024 : : (for example, if it is found in more than one base class). If all of
10025 : : the injected-class-names that are found refer to specializations of
10026 : : the same class template, and if the name is followed by a
10027 : : template-argument-list, the reference refers to the class template
10028 : : itself and not a specialization thereof, and is not ambiguous. */
10029 : 571676629 : if (TREE_CODE (decl) == TREE_LIST)
10030 : : {
10031 : : tree t, tmpl = NULL_TREE;
10032 : 37645 : for (t = decl; t; t = TREE_CHAIN (t))
10033 : : {
10034 : 37564 : tree elt = maybe_get_template_decl_from_type_decl (TREE_VALUE (t));
10035 : 37564 : if (!tmpl)
10036 : : tmpl = elt;
10037 : 18782 : else if (tmpl != elt)
10038 : : break;
10039 : : }
10040 : 18782 : if (tmpl && t == NULL_TREE)
10041 : : return tmpl;
10042 : : else
10043 : : return decl;
10044 : : }
10045 : :
10046 : 571657847 : return (decl != NULL_TREE
10047 : 571657847 : && DECL_SELF_REFERENCE_P (decl)
10048 : 5757034 : && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl)))
10049 : 5757034 : ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl)) : decl;
10050 : : }
10051 : :
10052 : : /* If TYPE is the generic implicit instantiation A<T>, return the primary
10053 : : template type A<T> (which is suitable for entering into, e.g. for defining
10054 : : a member of A<T>), otherwise return TYPE. */
10055 : :
10056 : : tree
10057 : 337231885 : adjust_type_for_entering_scope (tree type)
10058 : : {
10059 : 335919120 : if (CLASS_TYPE_P (type)
10060 : 335919117 : && dependent_type_p (type)
10061 : 42842871 : && TYPE_TEMPLATE_INFO (type)
10062 : : /* We detect the generic implicit instantiation A<T> by inspecting
10063 : : TYPE_CANONICAL, which lookup_template_class sets to the primary
10064 : : template type A<T>. */
10065 : 380074740 : && TYPE_CANONICAL (type) == TREE_TYPE (TYPE_TI_TEMPLATE (type)))
10066 : 17491989 : type = TYPE_CANONICAL (type);
10067 : :
10068 : 337231885 : return type;
10069 : : }
10070 : :
10071 : : /* Convenience wrapper over tsubst that does adjust_type_for_entering_scope
10072 : : on the result. */
10073 : :
10074 : : static tree
10075 : 318958889 : tsubst_entering_scope (tree t, tree args, tsubst_flags_t complain, tree in_decl)
10076 : : {
10077 : 318958889 : t = tsubst (t, args, complain, in_decl);
10078 : 318958889 : return adjust_type_for_entering_scope (t);
10079 : : }
10080 : :
10081 : : /* Given an IDENTIFIER_NODE (or type TEMPLATE_DECL) and a chain of
10082 : : parameters, find the desired type.
10083 : :
10084 : : D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
10085 : :
10086 : : IN_DECL, if non-NULL, is the template declaration we are trying to
10087 : : instantiate.
10088 : :
10089 : : Issue error and warning messages under control of COMPLAIN.
10090 : :
10091 : : If the template class is really a local class in a template
10092 : : function, then the FUNCTION_CONTEXT is the function in which it is
10093 : : being instantiated.
10094 : :
10095 : : ??? Note that this function is currently called *twice* for each
10096 : : template-id: the first time from the parser, while creating the
10097 : : incomplete type (finish_template_type), and the second type during the
10098 : : real instantiation (instantiate_template_class). This is surely something
10099 : : that we want to avoid. It also causes some problems with argument
10100 : : coercion (see convert_nontype_argument for more information on this). */
10101 : :
10102 : : tree
10103 : 832950347 : lookup_template_class (tree d1, tree arglist, tree in_decl, tree context,
10104 : : tsubst_flags_t complain)
10105 : : {
10106 : 832950347 : auto_timevar tv (TV_TEMPLATE_INST);
10107 : :
10108 : 832950347 : tree templ = NULL_TREE, parmlist;
10109 : 832950347 : tree t;
10110 : 832950347 : spec_entry **slot;
10111 : 832950347 : spec_entry *entry;
10112 : :
10113 : 832950347 : if (identifier_p (d1))
10114 : : {
10115 : 93638 : tree value = innermost_non_namespace_value (d1);
10116 : 93638 : if (value && DECL_TEMPLATE_TEMPLATE_PARM_P (value))
10117 : : templ = value;
10118 : : else
10119 : : {
10120 : 93638 : if (context)
10121 : 93638 : push_decl_namespace (context);
10122 : 93638 : templ = lookup_name (d1);
10123 : 93638 : templ = maybe_get_template_decl_from_type_decl (templ);
10124 : 93638 : if (context)
10125 : 93638 : pop_decl_namespace ();
10126 : : }
10127 : : }
10128 : 832856709 : else if (TREE_CODE (d1) == TYPE_DECL && MAYBE_CLASS_TYPE_P (TREE_TYPE (d1)))
10129 : : {
10130 : 0 : tree type = TREE_TYPE (d1);
10131 : :
10132 : : /* If we are declaring a constructor, say A<T>::A<T>, we will get
10133 : : an implicit typename for the second A. Deal with it. */
10134 : 0 : if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
10135 : 0 : type = TREE_TYPE (type);
10136 : :
10137 : 0 : if (CLASSTYPE_TEMPLATE_INFO (type))
10138 : : {
10139 : 0 : templ = CLASSTYPE_TI_TEMPLATE (type);
10140 : 0 : d1 = DECL_NAME (templ);
10141 : : }
10142 : : }
10143 : 832856709 : else if (TREE_CODE (d1) == ENUMERAL_TYPE
10144 : 832856709 : || (TYPE_P (d1) && MAYBE_CLASS_TYPE_P (d1)))
10145 : : {
10146 : 672408398 : templ = TYPE_TI_TEMPLATE (d1);
10147 : 672408398 : d1 = DECL_NAME (templ);
10148 : : }
10149 : 160448311 : else if (DECL_TYPE_TEMPLATE_P (d1))
10150 : : {
10151 : 160448311 : templ = d1;
10152 : 160448311 : d1 = DECL_NAME (templ);
10153 : : }
10154 : 0 : else if (DECL_TEMPLATE_TEMPLATE_PARM_P (d1))
10155 : : {
10156 : 0 : templ = d1;
10157 : 0 : d1 = DECL_NAME (templ);
10158 : : }
10159 : :
10160 : : /* Issue an error message if we didn't find a template. */
10161 : 832950347 : if (! templ)
10162 : : {
10163 : 521 : if (complain & tf_error)
10164 : 0 : error ("%qT is not a template", d1);
10165 : 521 : return error_mark_node;
10166 : : }
10167 : :
10168 : 832949826 : if (TREE_CODE (templ) != TEMPLATE_DECL
10169 : : /* Make sure it's a user visible template, if it was named by
10170 : : the user. */
10171 : 832949826 : || ((complain & tf_user) && !DECL_TEMPLATE_PARM_P (templ)
10172 : 159883733 : && !PRIMARY_TEMPLATE_P (templ)))
10173 : : {
10174 : 0 : if (complain & tf_error)
10175 : : {
10176 : 0 : error ("non-template type %qT used as a template", d1);
10177 : 0 : if (in_decl)
10178 : 0 : error ("for template declaration %q+D", in_decl);
10179 : : }
10180 : 0 : return error_mark_node;
10181 : : }
10182 : :
10183 : 832949826 : complain &= ~tf_user;
10184 : :
10185 : : /* An alias that just changes the name of a template is equivalent to the
10186 : : other template, so if any of the arguments are pack expansions, strip
10187 : : the alias to avoid problems with a pack expansion passed to a non-pack
10188 : : alias template parameter (DR 1430). */
10189 : 832949826 : if (pack_expansion_args_count (INNERMOST_TEMPLATE_ARGS (arglist)))
10190 : 7500917 : templ = get_underlying_template (templ);
10191 : :
10192 : 832949826 : if (DECL_TEMPLATE_TEMPLATE_PARM_P (templ))
10193 : : {
10194 : 233266 : tree parm;
10195 : 233266 : tree arglist2 = coerce_template_args_for_ttp (templ, arglist, complain);
10196 : 233266 : if (arglist2 == error_mark_node
10197 : 233266 : || (!uses_template_parms (arglist2)
10198 : 9553 : && check_instantiated_args (templ, arglist2, complain)))
10199 : 18 : return error_mark_node;
10200 : :
10201 : 233248 : parm = bind_template_template_parm (TREE_TYPE (templ), arglist2);
10202 : 233248 : return parm;
10203 : : }
10204 : : else
10205 : : {
10206 : 832716560 : tree template_type = TREE_TYPE (templ);
10207 : 832716560 : tree gen_tmpl;
10208 : 832716560 : tree type_decl;
10209 : 832716560 : tree found = NULL_TREE;
10210 : 832716560 : int arg_depth;
10211 : 832716560 : int parm_depth;
10212 : 832716560 : int is_dependent_type;
10213 : 832716560 : int use_partial_inst_tmpl = false;
10214 : :
10215 : 832716560 : if (template_type == error_mark_node)
10216 : : /* An error occurred while building the template TEMPL, and a
10217 : : diagnostic has most certainly been emitted for that
10218 : : already. Let's propagate that error. */
10219 : : return error_mark_node;
10220 : :
10221 : 832716557 : gen_tmpl = most_general_template (templ);
10222 : 832716557 : if (modules_p ())
10223 : 3948836 : lazy_load_pendings (gen_tmpl);
10224 : :
10225 : 832716557 : parmlist = DECL_TEMPLATE_PARMS (gen_tmpl);
10226 : 832716557 : parm_depth = TMPL_PARMS_DEPTH (parmlist);
10227 : 1665433114 : arg_depth = TMPL_ARGS_DEPTH (arglist);
10228 : :
10229 : 832716557 : if (arg_depth == 1 && parm_depth > 1)
10230 : : {
10231 : : /* We've been given an incomplete set of template arguments.
10232 : : For example, given:
10233 : :
10234 : : template <class T> struct S1 {
10235 : : template <class U> struct S2 {};
10236 : : template <class U> struct S2<U*> {};
10237 : : };
10238 : :
10239 : : we will be called with an ARGLIST of `U*', but the
10240 : : TEMPLATE will be `template <class T> template
10241 : : <class U> struct S1<T>::S2'. We must fill in the missing
10242 : : arguments. */
10243 : 7294408 : tree ti = TYPE_TEMPLATE_INFO_MAYBE_ALIAS (TREE_TYPE (templ));
10244 : 7294408 : arglist = add_outermost_template_args (TI_ARGS (ti), arglist);
10245 : 14588816 : arg_depth = TMPL_ARGS_DEPTH (arglist);
10246 : : }
10247 : :
10248 : : /* Now we should have enough arguments. */
10249 : 832716557 : gcc_assert (parm_depth == arg_depth);
10250 : :
10251 : 832716557 : if (DECL_ALIAS_TEMPLATE_P (gen_tmpl))
10252 : : {
10253 : : /* The user referred to a specialization of an alias
10254 : : template represented by GEN_TMPL.
10255 : :
10256 : : [temp.alias]/2 says:
10257 : :
10258 : : When a template-id refers to the specialization of an
10259 : : alias template, it is equivalent to the associated
10260 : : type obtained by substitution of its
10261 : : template-arguments for the template-parameters in the
10262 : : type-id of the alias template. */
10263 : :
10264 : 24294337 : t = instantiate_alias_template (gen_tmpl, arglist, complain);
10265 : : /* Note that the call above (by indirectly calling
10266 : : register_specialization in tsubst_decl) registers the
10267 : : TYPE_DECL representing the specialization of the alias
10268 : : template. So next time someone substitutes ARGLIST for
10269 : : the template parms into the alias template (GEN_TMPL),
10270 : : she'll get that TYPE_DECL back. */
10271 : :
10272 : 24294337 : if (t == error_mark_node)
10273 : : return error_mark_node;
10274 : 24286981 : return TREE_TYPE (t);
10275 : : }
10276 : :
10277 : : /* From here on, we're only interested in the most general
10278 : : template. */
10279 : :
10280 : : /* Shortcut looking up the current class scope again. */
10281 : 808422220 : for (tree cur = current_nonlambda_class_type ();
10282 : 1389772343 : cur != NULL_TREE;
10283 : 581350123 : cur = get_containing_scope (cur))
10284 : : {
10285 : 1038109555 : if (!CLASS_TYPE_P (cur))
10286 : 396783950 : continue;
10287 : :
10288 : 641325605 : tree ti = CLASSTYPE_TEMPLATE_INFO (cur);
10289 : 1830662875 : if (!ti || arg_depth > TMPL_ARGS_DEPTH (TI_ARGS (ti)))
10290 : : break;
10291 : :
10292 : 593139195 : if (gen_tmpl == most_general_template (TI_TEMPLATE (ti))
10293 : 1015749714 : && comp_template_args (arglist, TI_ARGS (ti)))
10294 : : return cur;
10295 : : }
10296 : :
10297 : : /* Calculate the BOUND_ARGS. These will be the args that are
10298 : : actually tsubst'd into the definition to create the
10299 : : instantiation. */
10300 : 399849198 : if (PRIMARY_TEMPLATE_P (gen_tmpl))
10301 : 394289784 : arglist = coerce_template_parms (parmlist, arglist, gen_tmpl, complain);
10302 : :
10303 : 399849195 : if (arglist == error_mark_node)
10304 : : /* We were unable to bind the arguments. */
10305 : : return error_mark_node;
10306 : :
10307 : : /* In the scope of a template class, explicit references to the
10308 : : template class refer to the type of the template, not any
10309 : : instantiation of it. For example, in:
10310 : :
10311 : : template <class T> class C { void f(C<T>); }
10312 : :
10313 : : the `C<T>' is just the same as `C'. Outside of the
10314 : : class, however, such a reference is an instantiation.
10315 : : One can use adjust_type_for_entering_scope to make
10316 : : this adjustment as needed. */
10317 : 399847645 : if (!PRIMARY_TEMPLATE_P (gen_tmpl)
10318 : 399847645 : || currently_open_class (template_type))
10319 : : {
10320 : 8487489 : tree tinfo = TYPE_TEMPLATE_INFO (template_type);
10321 : :
10322 : 16974978 : if (tinfo && comp_template_args (TI_ARGS (tinfo), arglist))
10323 : : return template_type;
10324 : : }
10325 : :
10326 : : /* If we already have this specialization, return it. */
10327 : 399827152 : spec_entry elt;
10328 : 399827152 : elt.tmpl = gen_tmpl;
10329 : 399827152 : elt.args = arglist;
10330 : 399827152 : entry = type_specializations->find (&elt);
10331 : :
10332 : 399827152 : if (entry)
10333 : 311493435 : return entry->spec;
10334 : :
10335 : : /* If the template's constraints are not satisfied,
10336 : : then we cannot form a valid type.
10337 : :
10338 : : Note that the check is deferred until after the hash
10339 : : lookup. This prevents redundant checks on previously
10340 : : instantiated specializations. */
10341 : 88333717 : if (flag_concepts
10342 : 88333717 : && !constraints_satisfied_p (gen_tmpl, arglist))
10343 : : {
10344 : 703 : if (complain & tf_error)
10345 : : {
10346 : 74 : auto_diagnostic_group d;
10347 : 74 : error ("template constraint failure for %qD", gen_tmpl);
10348 : 74 : diagnose_constraints (input_location, gen_tmpl, arglist);
10349 : 74 : }
10350 : 703 : return error_mark_node;
10351 : : }
10352 : :
10353 : 88333014 : is_dependent_type = uses_template_parms (arglist);
10354 : :
10355 : : /* If the deduced arguments are invalid, then the binding
10356 : : failed. */
10357 : 88333014 : if (!is_dependent_type
10358 : 88333014 : && check_instantiated_args (gen_tmpl,
10359 : : INNERMOST_TEMPLATE_ARGS (arglist),
10360 : : complain))
10361 : 8 : return error_mark_node;
10362 : :
10363 : 88333006 : if (!is_dependent_type
10364 : 35142130 : && !PRIMARY_TEMPLATE_P (gen_tmpl)
10365 : 2817265 : && !LAMBDA_TYPE_P (TREE_TYPE (gen_tmpl))
10366 : 89934522 : && TREE_CODE (CP_DECL_CONTEXT (gen_tmpl)) == NAMESPACE_DECL)
10367 : : /* This occurs when the user has tried to define a tagged type
10368 : : in a scope that forbids it. We emitted an error during the
10369 : : parse. We didn't complete the bail out then, so here we
10370 : : are. */
10371 : 12 : return error_mark_node;
10372 : :
10373 : 88332994 : context = DECL_CONTEXT (gen_tmpl);
10374 : 88332994 : if (context && TYPE_P (context))
10375 : : {
10376 : 4503854 : if (!uses_template_parms (DECL_CONTEXT (templ)))
10377 : : /* If the context of the partially instantiated template is
10378 : : already non-dependent, then we might as well use it. */
10379 : 1641906 : context = DECL_CONTEXT (templ);
10380 : : else
10381 : : {
10382 : 2861948 : context = tsubst_entering_scope (context, arglist,
10383 : : complain, in_decl);
10384 : : /* Try completing the enclosing context if it's not already so. */
10385 : 2861948 : if (context != error_mark_node
10386 : 2861948 : && !COMPLETE_TYPE_P (context))
10387 : : {
10388 : 2684610 : context = complete_type (context);
10389 : 2684610 : if (COMPLETE_TYPE_P (context))
10390 : : {
10391 : : /* Completion could have caused us to register the desired
10392 : : specialization already, so check the table again. */
10393 : 3 : entry = type_specializations->find (&elt);
10394 : 3 : if (entry)
10395 : 3 : return entry->spec;
10396 : : }
10397 : : }
10398 : : }
10399 : : }
10400 : : else
10401 : 83829140 : context = tsubst (context, arglist, complain, in_decl);
10402 : :
10403 : 88332991 : if (context == error_mark_node)
10404 : : return error_mark_node;
10405 : :
10406 : 88332988 : if (!context)
10407 : 0 : context = global_namespace;
10408 : :
10409 : : /* Create the type. */
10410 : 88332988 : if (TREE_CODE (template_type) == ENUMERAL_TYPE)
10411 : : {
10412 : 326428 : if (!is_dependent_type)
10413 : : {
10414 : 326425 : set_current_access_from_decl (TYPE_NAME (template_type));
10415 : 652850 : t = start_enum (TYPE_IDENTIFIER (template_type), NULL_TREE,
10416 : 326425 : tsubst (ENUM_UNDERLYING_TYPE (template_type),
10417 : : arglist, complain, in_decl),
10418 : 326425 : tsubst_attributes (TYPE_ATTRIBUTES (template_type),
10419 : : arglist, complain, in_decl),
10420 : 326425 : SCOPED_ENUM_P (template_type), NULL);
10421 : :
10422 : 326425 : if (t == error_mark_node)
10423 : : return t;
10424 : : }
10425 : : else
10426 : : {
10427 : : /* We don't want to call start_enum for this type, since
10428 : : the values for the enumeration constants may involve
10429 : : template parameters. And, no one should be interested
10430 : : in the enumeration constants for such a type. */
10431 : 3 : t = cxx_make_type (ENUMERAL_TYPE);
10432 : 6 : SET_SCOPED_ENUM_P (t, SCOPED_ENUM_P (template_type));
10433 : : }
10434 : 652814 : SET_OPAQUE_ENUM_P (t, OPAQUE_ENUM_P (template_type));
10435 : 652844 : ENUM_FIXED_UNDERLYING_TYPE_P (t)
10436 : 326422 : = ENUM_FIXED_UNDERLYING_TYPE_P (template_type);
10437 : : }
10438 : 88006560 : else if (CLASS_TYPE_P (template_type))
10439 : : {
10440 : : /* Lambda closures are regenerated in tsubst_lambda_expr, not
10441 : : instantiated here. */
10442 : 175895986 : gcc_assert (!LAMBDA_TYPE_P (template_type));
10443 : :
10444 : 88006560 : t = make_class_type (TREE_CODE (template_type));
10445 : 264019680 : CLASSTYPE_DECLARED_CLASS (t)
10446 : 88006560 : = CLASSTYPE_DECLARED_CLASS (template_type);
10447 : 88006560 : SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t);
10448 : :
10449 : : /* A local class. Make sure the decl gets registered properly. */
10450 : 88006560 : if (context == current_function_decl)
10451 : 528867 : if (pushtag (DECL_NAME (gen_tmpl), t)
10452 : 528867 : == error_mark_node)
10453 : : return error_mark_node;
10454 : :
10455 : 88006548 : if (comp_template_args (CLASSTYPE_TI_ARGS (template_type), arglist))
10456 : : /* This instantiation is another name for the primary
10457 : : template type. Set the TYPE_CANONICAL field
10458 : : appropriately. */
10459 : 5133393 : TYPE_CANONICAL (t) = template_type;
10460 : 82873155 : else if (any_template_arguments_need_structural_equality_p (arglist))
10461 : 1026459 : SET_TYPE_STRUCTURAL_EQUALITY (t);
10462 : : }
10463 : : else
10464 : 0 : gcc_unreachable ();
10465 : :
10466 : : /* If we called start_enum or pushtag above, this information
10467 : : will already be set up. */
10468 : 88332970 : type_decl = TYPE_NAME (t);
10469 : 88332970 : if (!type_decl)
10470 : : {
10471 : 87477696 : TYPE_CONTEXT (t) = FROB_CONTEXT (context);
10472 : :
10473 : 87477696 : type_decl = create_implicit_typedef (DECL_NAME (gen_tmpl), t);
10474 : 87477696 : DECL_CONTEXT (type_decl) = TYPE_CONTEXT (t);
10475 : 174955392 : DECL_SOURCE_LOCATION (type_decl)
10476 : 87477696 : = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type));
10477 : : }
10478 : :
10479 : 88332970 : set_instantiating_module (type_decl);
10480 : : /* Although GEN_TMPL is the TEMPLATE_DECL, it has the same value
10481 : : of export flag. We want to propagate this because it might
10482 : : be a friend declaration that pushes a new hidden binding. */
10483 : 88332970 : DECL_MODULE_EXPORT_P (type_decl) = DECL_MODULE_EXPORT_P (gen_tmpl);
10484 : :
10485 : 88332970 : if (CLASS_TYPE_P (template_type))
10486 : : {
10487 : 88006548 : TREE_PRIVATE (type_decl)
10488 : 88006548 : = TREE_PRIVATE (TYPE_MAIN_DECL (template_type));
10489 : 88006548 : TREE_PROTECTED (type_decl)
10490 : 88006548 : = TREE_PROTECTED (TYPE_MAIN_DECL (template_type));
10491 : 88006548 : if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type))
10492 : : {
10493 : 87006527 : DECL_VISIBILITY_SPECIFIED (type_decl) = 1;
10494 : 87006527 : DECL_VISIBILITY (type_decl) = CLASSTYPE_VISIBILITY (template_type);
10495 : : }
10496 : : }
10497 : :
10498 : 88332970 : if (OVERLOAD_TYPE_P (t))
10499 : : {
10500 : : static const char *tags[] = {"abi_tag", "may_alias"};
10501 : :
10502 : 264998910 : for (unsigned ix = 0; ix != 2; ix++)
10503 : : {
10504 : 176665940 : tree attributes
10505 : 176665940 : = lookup_attribute (tags[ix], TYPE_ATTRIBUTES (template_type));
10506 : :
10507 : 176665940 : if (attributes)
10508 : 48 : TYPE_ATTRIBUTES (t)
10509 : 96 : = tree_cons (TREE_PURPOSE (attributes),
10510 : 48 : TREE_VALUE (attributes),
10511 : 48 : TYPE_ATTRIBUTES (t));
10512 : : }
10513 : : }
10514 : :
10515 : : /* Let's consider the explicit specialization of a member
10516 : : of a class template specialization that is implicitly instantiated,
10517 : : e.g.:
10518 : : template<class T>
10519 : : struct S
10520 : : {
10521 : : template<class U> struct M {}; //#0
10522 : : };
10523 : :
10524 : : template<>
10525 : : template<>
10526 : : struct S<int>::M<char> //#1
10527 : : {
10528 : : int i;
10529 : : };
10530 : : [temp.expl.spec]/4 says this is valid.
10531 : :
10532 : : In this case, when we write:
10533 : : S<int>::M<char> m;
10534 : :
10535 : : M is instantiated from the CLASSTYPE_TI_TEMPLATE of #1, not from
10536 : : the one of #0.
10537 : :
10538 : : When we encounter #1, we want to store the partial instantiation
10539 : : of M (template<class T> S<int>::M<T>) in its CLASSTYPE_TI_TEMPLATE.
10540 : :
10541 : : For all cases other than this "explicit specialization of member of a
10542 : : class template", we just want to store the most general template into
10543 : : the CLASSTYPE_TI_TEMPLATE of M.
10544 : :
10545 : : This case of "explicit specialization of member of a class template"
10546 : : only happens when:
10547 : : 1/ the enclosing class is an instantiation of, and therefore not
10548 : : the same as, the context of the most general template, and
10549 : : 2/ we aren't looking at the partial instantiation itself, i.e.
10550 : : the innermost arguments are not the same as the innermost parms of
10551 : : the most general template.
10552 : :
10553 : : So it's only when 1/ and 2/ happens that we want to use the partial
10554 : : instantiation of the member template in lieu of its most general
10555 : : template. */
10556 : :
10557 : 88332970 : if (PRIMARY_TEMPLATE_P (gen_tmpl)
10558 : 173462926 : && TMPL_ARGS_HAVE_MULTIPLE_LEVELS (arglist)
10559 : : /* the enclosing class must be an instantiation... */
10560 : 2022104 : && CLASS_TYPE_P (context)
10561 : 90354868 : && !same_type_p (context, DECL_CONTEXT (gen_tmpl)))
10562 : : {
10563 : 1349474 : TREE_VEC_LENGTH (arglist)--;
10564 : 1349474 : ++processing_template_decl;
10565 : 1349474 : tree tinfo = TYPE_TEMPLATE_INFO (TREE_TYPE (gen_tmpl));
10566 : 1349474 : tree partial_inst_args =
10567 : 1349474 : tsubst (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo)),
10568 : : arglist, complain, NULL_TREE);
10569 : 1349474 : --processing_template_decl;
10570 : 1349474 : TREE_VEC_LENGTH (arglist)++;
10571 : 1349474 : if (partial_inst_args == error_mark_node)
10572 : : return error_mark_node;
10573 : 2698942 : use_partial_inst_tmpl =
10574 : : /*...and we must not be looking at the partial instantiation
10575 : : itself. */
10576 : 1349471 : !comp_template_args (INNERMOST_TEMPLATE_ARGS (arglist),
10577 : : partial_inst_args);
10578 : : }
10579 : :
10580 : 1349471 : if (!use_partial_inst_tmpl)
10581 : : /* This case is easy; there are no member templates involved. */
10582 : : found = gen_tmpl;
10583 : : else
10584 : : {
10585 : : /* This is a full instantiation of a member template. Find
10586 : : the partial instantiation of which this is an instance. */
10587 : :
10588 : : /* Temporarily reduce by one the number of levels in the ARGLIST
10589 : : so as to avoid comparing the last set of arguments. */
10590 : 659008 : TREE_VEC_LENGTH (arglist)--;
10591 : : /* We don't use COMPLAIN in the following call because this isn't
10592 : : the immediate context of deduction. For instance, tf_partial
10593 : : could be set here as we might be at the beginning of template
10594 : : argument deduction when any explicitly specified template
10595 : : arguments are substituted into the function type. tf_partial
10596 : : could lead into trouble because we wouldn't find the partial
10597 : : instantiation that might have been created outside tf_partial
10598 : : context, because the levels of template parameters wouldn't
10599 : : match, because in a tf_partial context, tsubst doesn't reduce
10600 : : TEMPLATE_PARM_LEVEL. */
10601 : 659008 : found = tsubst (gen_tmpl, arglist, tf_none, NULL_TREE);
10602 : 659008 : TREE_VEC_LENGTH (arglist)++;
10603 : 1318016 : found = (TREE_CODE (found) == TEMPLATE_DECL
10604 : 659008 : ? found
10605 : 0 : : CLASSTYPE_TI_TEMPLATE (found));
10606 : :
10607 : 659008 : if (DECL_CLASS_TEMPLATE_P (found)
10608 : 1318016 : && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (found)))
10609 : : {
10610 : : /* If this partial instantiation is specialized, we want to
10611 : : use it for hash table lookup. */
10612 : 9 : elt.tmpl = found;
10613 : 9 : elt.args = arglist = INNERMOST_TEMPLATE_ARGS (arglist);
10614 : 9 : elt.hash = 0; /* Recalculate after changing tmpl/args. */
10615 : : }
10616 : : }
10617 : :
10618 : : /* Build template info for the new specialization. */
10619 : 88332967 : SET_TYPE_TEMPLATE_INFO (t, build_template_info (found, arglist));
10620 : :
10621 : 88332967 : elt.spec = t;
10622 : 88332967 : slot = type_specializations->find_slot (&elt, INSERT);
10623 : 88332967 : gcc_checking_assert (*slot == NULL);
10624 : 88332967 : entry = ggc_alloc<spec_entry> ();
10625 : 88332967 : *entry = elt;
10626 : 88332967 : *slot = entry;
10627 : :
10628 : : /* Note this use of the partial instantiation so we can check it
10629 : : later in maybe_process_partial_specialization. */
10630 : 176665934 : DECL_TEMPLATE_INSTANTIATIONS (found)
10631 : 88332967 : = tree_cons (arglist, t,
10632 : 88332967 : DECL_TEMPLATE_INSTANTIATIONS (found));
10633 : :
10634 : 88332967 : if (TREE_CODE (template_type) == ENUMERAL_TYPE
10635 : 88332967 : && !uses_template_parms (current_nonlambda_scope ()))
10636 : : /* Now that the type has been registered on the instantiations
10637 : : list, we set up the enumerators. Because the enumeration
10638 : : constants may involve the enumeration type itself, we make
10639 : : sure to register the type first, and then create the
10640 : : constants. That way, doing tsubst_expr for the enumeration
10641 : : constants won't result in recursive calls here; we'll find
10642 : : the instantiation and exit above. */
10643 : 326422 : tsubst_enum (template_type, t, arglist);
10644 : :
10645 : 88332922 : if (CLASS_TYPE_P (template_type) && is_dependent_type)
10646 : : /* If the type makes use of template parameters, the
10647 : : code that generates debugging information will crash. */
10648 : 53190864 : DECL_IGNORED_P (TYPE_MAIN_DECL (t)) = 1;
10649 : :
10650 : : /* Possibly limit visibility based on template args. */
10651 : 88332922 : TREE_PUBLIC (type_decl) = 1;
10652 : 88332922 : determine_visibility (type_decl);
10653 : :
10654 : 88332922 : inherit_targ_abi_tags (t);
10655 : :
10656 : 88332922 : return t;
10657 : : }
10658 : 832950299 : }
10659 : :
10660 : : /* Return a TEMPLATE_ID_EXPR for the given variable template and ARGLIST. */
10661 : :
10662 : : tree
10663 : 13385792 : lookup_template_variable (tree templ, tree arglist, tsubst_flags_t complain)
10664 : : {
10665 : 13385792 : tree gen_templ = most_general_template (templ);
10666 : 13385792 : tree parms = DECL_INNERMOST_TEMPLATE_PARMS (gen_templ);
10667 : 13385792 : arglist = add_outermost_template_args (templ, arglist);
10668 : 13385792 : arglist = coerce_template_parms (parms, arglist, templ, complain);
10669 : 13385792 : if (arglist == error_mark_node)
10670 : : return error_mark_node;
10671 : :
10672 : : /* The type of the expression is NULL_TREE since the template-id could refer
10673 : : to an explicit or partial specialization. */
10674 : 13385754 : return build2 (TEMPLATE_ID_EXPR, NULL_TREE, templ, arglist);
10675 : : }
10676 : :
10677 : : /* Instantiate a variable declaration from a TEMPLATE_ID_EXPR if it's
10678 : : not dependent. */
10679 : :
10680 : : tree
10681 : 12452484 : finish_template_variable (tree var, tsubst_flags_t complain)
10682 : : {
10683 : 12452484 : tree templ = TREE_OPERAND (var, 0);
10684 : 12452484 : tree arglist = TREE_OPERAND (var, 1);
10685 : :
10686 : : /* If the template or arguments are dependent, then we
10687 : : can't resolve the TEMPLATE_ID_EXPR yet. */
10688 : 12452484 : if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (templ)) != 1
10689 : 12452484 : || any_dependent_template_arguments_p (arglist))
10690 : 6385540 : return var;
10691 : :
10692 : 6066944 : if (flag_concepts && !constraints_satisfied_p (templ, arglist))
10693 : : {
10694 : 18 : if (complain & tf_error)
10695 : : {
10696 : 15 : auto_diagnostic_group d;
10697 : 15 : error ("use of invalid variable template %qE", var);
10698 : 15 : diagnose_constraints (location_of (var), templ, arglist);
10699 : 15 : }
10700 : 18 : return error_mark_node;
10701 : : }
10702 : :
10703 : 6066926 : return instantiate_template (templ, arglist, complain);
10704 : : }
10705 : :
10706 : : /* Construct a TEMPLATE_ID_EXPR for the given variable template TEMPL having
10707 : : TARGS template args, and instantiate it if it's not dependent. */
10708 : :
10709 : : tree
10710 : 6828712 : lookup_and_finish_template_variable (tree templ, tree targs,
10711 : : tsubst_flags_t complain)
10712 : : {
10713 : 6828712 : tree var = lookup_template_variable (templ, targs, complain);
10714 : 6828712 : if (var == error_mark_node)
10715 : : return error_mark_node;
10716 : 6828712 : var = finish_template_variable (var, complain);
10717 : 6828712 : mark_used (var, complain);
10718 : 6828712 : return var;
10719 : : }
10720 : :
10721 : : /* If the set of template parameters PARMS contains a template parameter
10722 : : at the given LEVEL and INDEX, then return this parameter. Otherwise
10723 : : return NULL_TREE. */
10724 : :
10725 : : static tree
10726 : 21355606 : corresponding_template_parameter_list (tree parms, int level, int index)
10727 : : {
10728 : 22848335 : while (TMPL_PARMS_DEPTH (parms) > level)
10729 : 1492729 : parms = TREE_CHAIN (parms);
10730 : :
10731 : 21355606 : if (TMPL_PARMS_DEPTH (parms) != level
10732 : 21355606 : || TREE_VEC_LENGTH (TREE_VALUE (parms)) <= index)
10733 : : return NULL_TREE;
10734 : :
10735 : 20808969 : return TREE_VEC_ELT (TREE_VALUE (parms), index);
10736 : : }
10737 : :
10738 : : /* Return the TREE_LIST for the template parameter from PARMS that positionally
10739 : : corresponds to the template parameter PARM, or else return NULL_TREE. */
10740 : :
10741 : : static tree
10742 : 21355606 : corresponding_template_parameter_list (tree parms, tree parm)
10743 : : {
10744 : 21355606 : int level, index;
10745 : 21355606 : template_parm_level_and_index (parm, &level, &index);
10746 : 21355606 : return corresponding_template_parameter_list (parms, level, index);
10747 : : }
10748 : :
10749 : : /* As above, but pull out the actual parameter. */
10750 : :
10751 : : static tree
10752 : 21355236 : corresponding_template_parameter (tree parms, tree parm)
10753 : : {
10754 : 21355236 : tree list = corresponding_template_parameter_list (parms, parm);
10755 : 21355236 : if (!list)
10756 : : return NULL_TREE;
10757 : :
10758 : 20808599 : tree t = TREE_VALUE (list);
10759 : : /* As in template_parm_to_arg. */
10760 : 20808599 : if (TREE_CODE (t) == TYPE_DECL || TREE_CODE (t) == TEMPLATE_DECL)
10761 : 20236485 : t = TREE_TYPE (t);
10762 : : else
10763 : 572114 : t = DECL_INITIAL (t);
10764 : :
10765 : 20808599 : gcc_assert (TEMPLATE_PARM_P (t));
10766 : : return t;
10767 : : }
10768 : :
10769 : : struct pair_fn_data
10770 : : {
10771 : : tree_fn_t fn;
10772 : : tree_fn_t any_fn;
10773 : : void *data;
10774 : : /* True when we should also visit template parameters that occur in
10775 : : non-deduced contexts. */
10776 : : bool include_nondeduced_p;
10777 : : hash_set<tree> *visited;
10778 : : };
10779 : :
10780 : : /* Called from for_each_template_parm via walk_tree. */
10781 : :
10782 : : static tree
10783 : 396975310 : for_each_template_parm_r (tree *tp, int *walk_subtrees, void *d)
10784 : : {
10785 : 396975310 : tree t = *tp;
10786 : 396975310 : struct pair_fn_data *pfd = (struct pair_fn_data *) d;
10787 : 396975310 : tree_fn_t fn = pfd->fn;
10788 : 396975310 : void *data = pfd->data;
10789 : 396975310 : tree result = NULL_TREE;
10790 : :
10791 : : #define WALK_SUBTREE(NODE) \
10792 : : do \
10793 : : { \
10794 : : result = for_each_template_parm (NODE, fn, data, pfd->visited, \
10795 : : pfd->include_nondeduced_p, \
10796 : : pfd->any_fn); \
10797 : : if (result) goto out; \
10798 : : } \
10799 : : while (0)
10800 : :
10801 : 396975310 : if (pfd->any_fn && (*pfd->any_fn)(t, data))
10802 : : return t;
10803 : :
10804 : 396975310 : if (TYPE_P (t)
10805 : 185154699 : && (pfd->include_nondeduced_p || TREE_CODE (t) != TYPENAME_TYPE))
10806 : 184709120 : WALK_SUBTREE (TYPE_CONTEXT (t));
10807 : :
10808 : 396905753 : switch (TREE_CODE (t))
10809 : : {
10810 : 30653016 : case RECORD_TYPE:
10811 : 30653016 : if (TYPE_PTRMEMFUNC_P (t))
10812 : : break;
10813 : : /* Fall through. */
10814 : :
10815 : 31029537 : case UNION_TYPE:
10816 : 31029537 : case ENUMERAL_TYPE:
10817 : 31029537 : if (!TYPE_TEMPLATE_INFO (t))
10818 : 4343414 : *walk_subtrees = 0;
10819 : : else
10820 : 26686123 : WALK_SUBTREE (TYPE_TI_ARGS (t));
10821 : : break;
10822 : :
10823 : 8107810 : case INTEGER_TYPE:
10824 : 8107810 : WALK_SUBTREE (TYPE_MIN_VALUE (t));
10825 : 8107810 : WALK_SUBTREE (TYPE_MAX_VALUE (t));
10826 : : break;
10827 : :
10828 : 8462046 : case METHOD_TYPE:
10829 : : /* Since we're not going to walk subtrees, we have to do this
10830 : : explicitly here. */
10831 : 8462046 : WALK_SUBTREE (TYPE_METHOD_BASETYPE (t));
10832 : : /* Fall through. */
10833 : :
10834 : 1948200 : case FUNCTION_TYPE:
10835 : : /* Check the return type. */
10836 : 1948200 : WALK_SUBTREE (TREE_TYPE (t));
10837 : :
10838 : : /* Check the parameter types. Since default arguments are not
10839 : : instantiated until they are needed, the TYPE_ARG_TYPES may
10840 : : contain expressions that involve template parameters. But,
10841 : : no-one should be looking at them yet. And, once they're
10842 : : instantiated, they don't contain template parameters, so
10843 : : there's no point in looking at them then, either. */
10844 : 1853324 : {
10845 : 1853324 : tree parm;
10846 : :
10847 : 6134269 : for (parm = TYPE_ARG_TYPES (t); parm; parm = TREE_CHAIN (parm))
10848 : 4300660 : WALK_SUBTREE (TREE_VALUE (parm));
10849 : :
10850 : : /* Since we've already handled the TYPE_ARG_TYPES, we don't
10851 : : want walk_tree walking into them itself. */
10852 : 1833609 : *walk_subtrees = 0;
10853 : : }
10854 : :
10855 : 1833609 : if (flag_noexcept_type)
10856 : : {
10857 : 1821057 : tree spec = TYPE_RAISES_EXCEPTIONS (t);
10858 : 1821057 : if (spec)
10859 : 461841 : WALK_SUBTREE (TREE_PURPOSE (spec));
10860 : : }
10861 : : break;
10862 : :
10863 : 3511550 : case TYPEOF_TYPE:
10864 : 3511550 : case DECLTYPE_TYPE:
10865 : 3511550 : if (pfd->include_nondeduced_p
10866 : 3511550 : && for_each_template_parm (TYPE_VALUES_RAW (t), fn, data,
10867 : : pfd->visited,
10868 : : pfd->include_nondeduced_p,
10869 : : pfd->any_fn))
10870 : 461 : return error_mark_node;
10871 : 3511089 : *walk_subtrees = false;
10872 : 3511089 : break;
10873 : :
10874 : 6 : case TRAIT_TYPE:
10875 : 6 : if (pfd->include_nondeduced_p)
10876 : : {
10877 : 0 : WALK_SUBTREE (TRAIT_TYPE_TYPE1 (t));
10878 : 0 : WALK_SUBTREE (TRAIT_TYPE_TYPE2 (t));
10879 : : }
10880 : 6 : *walk_subtrees = false;
10881 : 6 : break;
10882 : :
10883 : 445209 : case FUNCTION_DECL:
10884 : 445209 : case VAR_DECL:
10885 : 445209 : if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t))
10886 : 47265 : WALK_SUBTREE (DECL_TI_ARGS (t));
10887 : : break;
10888 : :
10889 : 1878600 : case PARM_DECL:
10890 : 1878600 : WALK_SUBTREE (TREE_TYPE (t));
10891 : : break;
10892 : :
10893 : 398601 : case CONST_DECL:
10894 : 398601 : if (DECL_TEMPLATE_PARM_P (t))
10895 : 0 : WALK_SUBTREE (DECL_INITIAL (t));
10896 : 398601 : if (DECL_CONTEXT (t)
10897 : 398601 : && pfd->include_nondeduced_p)
10898 : 6866 : WALK_SUBTREE (DECL_CONTEXT (t));
10899 : : break;
10900 : :
10901 : 57365 : case BOUND_TEMPLATE_TEMPLATE_PARM:
10902 : : /* Record template parameters such as `T' inside `TT<T>'. */
10903 : 57365 : WALK_SUBTREE (TYPE_TI_ARGS (t));
10904 : : /* Fall through. */
10905 : :
10906 : 66541388 : case TEMPLATE_TEMPLATE_PARM:
10907 : 66541388 : case TEMPLATE_TYPE_PARM:
10908 : 66541388 : case TEMPLATE_PARM_INDEX:
10909 : 66541388 : if (fn && (*fn)(t, data))
10910 : : return t;
10911 : 58079292 : else if (!fn)
10912 : : return t;
10913 : : break;
10914 : :
10915 : 10493233 : case TEMPLATE_DECL:
10916 : : /* A template template parameter is encountered. */
10917 : 10493233 : if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
10918 : 10 : WALK_SUBTREE (TREE_TYPE (t));
10919 : :
10920 : : /* Already substituted template template parameter */
10921 : 10493233 : *walk_subtrees = 0;
10922 : 10493233 : break;
10923 : :
10924 : 12675612 : case TYPENAME_TYPE:
10925 : : /* A template-id in a TYPENAME_TYPE might be a deduced context after
10926 : : partial instantiation. */
10927 : 12675612 : WALK_SUBTREE (TYPENAME_TYPE_FULLNAME (t));
10928 : 12675612 : *walk_subtrees = 0;
10929 : 12675612 : break;
10930 : :
10931 : 5149968 : case INDIRECT_REF:
10932 : 5149968 : case COMPONENT_REF:
10933 : : /* If there's no type, then this thing must be some expression
10934 : : involving template parameters. */
10935 : 5149968 : if (!fn && !TREE_TYPE (t))
10936 : 0 : return error_mark_node;
10937 : : break;
10938 : :
10939 : 458690 : case CONSTRUCTOR:
10940 : 458690 : case TRAIT_EXPR:
10941 : 458690 : case PLUS_EXPR:
10942 : 458690 : case MULT_EXPR:
10943 : 458690 : case SCOPE_REF:
10944 : : /* These are non-deduced contexts. */
10945 : 458690 : if (!pfd->include_nondeduced_p)
10946 : 60190 : *walk_subtrees = 0;
10947 : : break;
10948 : :
10949 : 3424995 : case MODOP_EXPR:
10950 : 3424995 : case CAST_EXPR:
10951 : 3424995 : case IMPLICIT_CONV_EXPR:
10952 : 3424995 : case REINTERPRET_CAST_EXPR:
10953 : 3424995 : case CONST_CAST_EXPR:
10954 : 3424995 : case STATIC_CAST_EXPR:
10955 : 3424995 : case DYNAMIC_CAST_EXPR:
10956 : 3424995 : case ARROW_EXPR:
10957 : 3424995 : case DOTSTAR_EXPR:
10958 : 3424995 : case TYPEID_EXPR:
10959 : 3424995 : case PSEUDO_DTOR_EXPR:
10960 : 3424995 : if (!fn)
10961 : 0 : return error_mark_node;
10962 : : break;
10963 : :
10964 : : default:
10965 : : break;
10966 : : }
10967 : :
10968 : : #undef WALK_SUBTREE
10969 : :
10970 : : /* We didn't find any template parameters we liked. */
10971 : : out:
10972 : : return result;
10973 : : }
10974 : :
10975 : : /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
10976 : : BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
10977 : : call FN with the parameter and the DATA.
10978 : : If FN returns nonzero, the iteration is terminated, and
10979 : : for_each_template_parm returns 1. Otherwise, the iteration
10980 : : continues. If FN never returns a nonzero value, the value
10981 : : returned by for_each_template_parm is 0. If FN is NULL, it is
10982 : : considered to be the function which always returns 1.
10983 : :
10984 : : If INCLUDE_NONDEDUCED_P, then this routine will also visit template
10985 : : parameters that occur in non-deduced contexts. When false, only
10986 : : visits those template parameters that can be deduced. */
10987 : :
10988 : : static tree
10989 : 361897047 : for_each_template_parm (tree t, tree_fn_t fn, void* data,
10990 : : hash_set<tree> *visited,
10991 : : bool include_nondeduced_p,
10992 : : tree_fn_t any_fn)
10993 : : {
10994 : 361897047 : struct pair_fn_data pfd;
10995 : 361897047 : tree result;
10996 : :
10997 : : /* Set up. */
10998 : 361897047 : pfd.fn = fn;
10999 : 361897047 : pfd.any_fn = any_fn;
11000 : 361897047 : pfd.data = data;
11001 : 361897047 : pfd.include_nondeduced_p = include_nondeduced_p;
11002 : :
11003 : : /* Walk the tree. (Conceptually, we would like to walk without
11004 : : duplicates, but for_each_template_parm_r recursively calls
11005 : : for_each_template_parm, so we would need to reorganize a fair
11006 : : bit to use walk_tree_without_duplicates, so we keep our own
11007 : : visited list.) */
11008 : 361897047 : if (visited)
11009 : 332094424 : pfd.visited = visited;
11010 : : else
11011 : 29802623 : pfd.visited = new hash_set<tree>;
11012 : 361897047 : result = cp_walk_tree (&t,
11013 : : for_each_template_parm_r,
11014 : : &pfd,
11015 : : pfd.visited);
11016 : :
11017 : : /* Clean up. */
11018 : 361897047 : if (!visited)
11019 : : {
11020 : 59605246 : delete pfd.visited;
11021 : 29802623 : pfd.visited = 0;
11022 : : }
11023 : :
11024 : 361897047 : return result;
11025 : : }
11026 : :
11027 : 13726295 : struct find_template_parameter_info
11028 : : {
11029 : 13726295 : explicit find_template_parameter_info (tree ctx_parms)
11030 : 27452590 : : ctx_parms (ctx_parms),
11031 : 13726295 : max_depth (TMPL_PARMS_DEPTH (ctx_parms))
11032 : 13726295 : {}
11033 : :
11034 : : hash_set<tree> visited;
11035 : : hash_set<tree> parms;
11036 : : tree parm_list = NULL_TREE;
11037 : : tree *parm_list_tail = &parm_list;
11038 : : tree ctx_parms;
11039 : : int max_depth;
11040 : :
11041 : : tree find_in (tree);
11042 : : tree find_in_recursive (tree);
11043 : : bool found (tree);
11044 : 361 : unsigned num_found () { return parms.elements (); }
11045 : : };
11046 : :
11047 : : /* Appends the declaration of T to the list in DATA. */
11048 : :
11049 : : static int
11050 : 23381023 : keep_template_parm (tree t, void* data)
11051 : : {
11052 : 23381023 : find_template_parameter_info *ftpi = (find_template_parameter_info*)data;
11053 : :
11054 : : /* Template parameters declared within the expression are not part of
11055 : : the parameter mapping. For example, in this concept:
11056 : :
11057 : : template<typename T>
11058 : : concept C = requires { <expr> } -> same_as<int>;
11059 : :
11060 : : the return specifier same_as<int> declares a new decltype parameter
11061 : : that must not be part of the parameter mapping. The same is true
11062 : : for generic lambda parameters, lambda template parameters, etc. */
11063 : 23381023 : int level;
11064 : 23381023 : int index;
11065 : 23381023 : template_parm_level_and_index (t, &level, &index);
11066 : 23381023 : if (level == 0 || level > ftpi->max_depth)
11067 : : return 0;
11068 : :
11069 : 21355236 : if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
11070 : : /* We want the underlying TEMPLATE_TEMPLATE_PARM, not the
11071 : : BOUND_TEMPLATE_TEMPLATE_PARM itself. */
11072 : 8419 : t = TREE_TYPE (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t));
11073 : :
11074 : : /* This template parameter might be an argument to a cached dependent
11075 : : specalization that was formed earlier inside some other template, in
11076 : : which case the parameter is not among the ones that are in-scope.
11077 : : Look in CTX_PARMS to find the corresponding in-scope template
11078 : : parameter, and use it instead. */
11079 : 21355236 : if (tree in_scope = corresponding_template_parameter (ftpi->ctx_parms, t))
11080 : 20808599 : t = in_scope;
11081 : :
11082 : : /* Arguments like const T yield parameters like const T. This means that
11083 : : a template-id like X<T, const T> would yield two distinct parameters:
11084 : : T and const T. Adjust types to their unqualified versions. */
11085 : 21355236 : if (TYPE_P (t))
11086 : 20783119 : t = TYPE_MAIN_VARIANT (t);
11087 : 21355236 : if (!ftpi->parms.add (t))
11088 : : {
11089 : : /* Append T to PARM_LIST. */
11090 : 18944483 : tree node = build_tree_list (NULL_TREE, t);
11091 : 18944483 : *ftpi->parm_list_tail = node;
11092 : 18944483 : ftpi->parm_list_tail = &TREE_CHAIN (node);
11093 : : }
11094 : :
11095 : : /* Verify the parameter we found has a valid index. */
11096 : 21355236 : if (flag_checking)
11097 : : {
11098 : 21355236 : tree parms = ftpi->ctx_parms;
11099 : 22847965 : while (TMPL_PARMS_DEPTH (parms) > level)
11100 : 1492729 : parms = TREE_CHAIN (parms);
11101 : 21355236 : if (int len = TREE_VEC_LENGTH (TREE_VALUE (parms)))
11102 : 20808599 : gcc_assert (index < len);
11103 : : }
11104 : :
11105 : : return 0;
11106 : : }
11107 : :
11108 : : /* Ensure that we recursively examine certain terms that are not normally
11109 : : visited in for_each_template_parm_r. */
11110 : :
11111 : : static int
11112 : 188321233 : any_template_parm_r (tree t, void *data)
11113 : : {
11114 : 188321233 : find_template_parameter_info *ftpi = (find_template_parameter_info*)data;
11115 : :
11116 : : #define WALK_SUBTREE(NODE) \
11117 : : do \
11118 : : { \
11119 : : for_each_template_parm (NODE, keep_template_parm, data, \
11120 : : &ftpi->visited, true, \
11121 : : any_template_parm_r); \
11122 : : } \
11123 : : while (0)
11124 : :
11125 : : /* A mention of a member alias/typedef is a use of all of its template
11126 : : arguments, including those from the enclosing class, so we don't use
11127 : : alias_template_specialization_p here. */
11128 : 188321233 : if (TYPE_P (t) && typedef_variant_p (t))
11129 : 2967786 : if (tree tinfo = TYPE_ALIAS_TEMPLATE_INFO (t))
11130 : 2967768 : WALK_SUBTREE (TI_ARGS (tinfo));
11131 : :
11132 : 188321233 : switch (TREE_CODE (t))
11133 : : {
11134 : 22782353 : case TEMPLATE_TYPE_PARM:
11135 : : /* Type constraints of a placeholder type may contain parameters. */
11136 : 22782353 : if (is_auto (t))
11137 : 2572404 : if (tree constr = PLACEHOLDER_TYPE_CONSTRAINTS (t))
11138 : 2571555 : WALK_SUBTREE (constr);
11139 : : break;
11140 : :
11141 : 11063557 : case TEMPLATE_ID_EXPR:
11142 : : /* Search through references to variable templates. */
11143 : 11063557 : WALK_SUBTREE (TREE_OPERAND (t, 0));
11144 : 11063557 : WALK_SUBTREE (TREE_OPERAND (t, 1));
11145 : 11063557 : break;
11146 : :
11147 : 572121 : case TEMPLATE_PARM_INDEX:
11148 : 572121 : WALK_SUBTREE (TREE_TYPE (t));
11149 : 572121 : break;
11150 : :
11151 : 10216189 : case TEMPLATE_DECL:
11152 : : /* If T is a member template that shares template parameters with
11153 : : ctx_parms, we need to mark all those parameters for mapping.
11154 : : To that end, it should suffice to just walk the DECL_CONTEXT of
11155 : : the template (assuming the template is not overly general). */
11156 : 10216189 : WALK_SUBTREE (DECL_CONTEXT (t));
11157 : 10216189 : break;
11158 : :
11159 : 35 : case LAMBDA_EXPR:
11160 : 35 : {
11161 : : /* Look in the parms and body. */
11162 : 35 : tree fn = lambda_function (t);
11163 : 35 : WALK_SUBTREE (TREE_TYPE (fn));
11164 : 35 : WALK_SUBTREE (DECL_SAVED_TREE (fn));
11165 : : }
11166 : 35 : break;
11167 : :
11168 : 5214482 : case IDENTIFIER_NODE:
11169 : 5214482 : if (IDENTIFIER_CONV_OP_P (t))
11170 : : /* The conversion-type-id of a conversion operator may be dependent. */
11171 : 4053 : WALK_SUBTREE (TREE_TYPE (t));
11172 : : break;
11173 : :
11174 : 15 : case CONVERT_EXPR:
11175 : 15 : if (is_dummy_object (t))
11176 : 12 : WALK_SUBTREE (TREE_TYPE (t));
11177 : : break;
11178 : :
11179 : : default:
11180 : : break;
11181 : : }
11182 : :
11183 : : /* Keep walking. */
11184 : 188321233 : return 0;
11185 : : }
11186 : :
11187 : : /* Look through T for template parameters. */
11188 : :
11189 : : tree
11190 : 13726665 : find_template_parameter_info::find_in (tree t)
11191 : : {
11192 : 13726665 : return for_each_template_parm (t, keep_template_parm, this, &visited,
11193 : : /*include_nondeduced*/true,
11194 : 13726665 : any_template_parm_r);
11195 : : }
11196 : :
11197 : : /* As above, but also recursively look into the default arguments of template
11198 : : parameters we found. Used for alias CTAD. */
11199 : :
11200 : : tree
11201 : 361 : find_template_parameter_info::find_in_recursive (tree t)
11202 : : {
11203 : 361 : if (tree r = find_in (t))
11204 : : return r;
11205 : : /* Since newly found parms are added to the end of the list, we
11206 : : can just walk it until we reach the end. */
11207 : 731 : for (tree pl = parm_list; pl; pl = TREE_CHAIN (pl))
11208 : : {
11209 : 370 : tree parm = TREE_VALUE (pl);
11210 : 370 : tree list = corresponding_template_parameter_list (ctx_parms, parm);
11211 : 370 : if (tree r = find_in (TREE_PURPOSE (list)))
11212 : : return r;
11213 : : }
11214 : : return NULL_TREE;
11215 : : }
11216 : :
11217 : : /* True if PARM was found by a previous call to find_in. PARM can be a
11218 : : TREE_LIST, a DECL_TEMPLATE_PARM_P, or a TEMPLATE_PARM_P. */
11219 : :
11220 : : bool
11221 : 431 : find_template_parameter_info::found (tree parm)
11222 : : {
11223 : 431 : if (TREE_CODE (parm) == TREE_LIST)
11224 : 431 : parm = TREE_VALUE (parm);
11225 : 431 : if (TREE_CODE (parm) == TYPE_DECL
11226 : 431 : || TREE_CODE (parm) == TEMPLATE_DECL)
11227 : 398 : parm = TREE_TYPE (parm);
11228 : : else
11229 : 33 : parm = DECL_INITIAL (parm);
11230 : 431 : gcc_checking_assert (TEMPLATE_PARM_P (parm));
11231 : 431 : return parms.contains (parm);
11232 : : }
11233 : :
11234 : : /* Returns a list of unique template parameters found within T, where CTX_PARMS
11235 : : are the template parameters in scope. */
11236 : :
11237 : : tree
11238 : 13725983 : find_template_parameters (tree t, tree ctx_parms)
11239 : : {
11240 : 13725983 : if (!ctx_parms)
11241 : : return NULL_TREE;
11242 : :
11243 : 13725934 : find_template_parameter_info ftpi (ctx_parms);
11244 : 13725934 : ftpi.find_in (t);
11245 : 13725934 : return ftpi.parm_list;
11246 : 13725934 : }
11247 : :
11248 : : /* Returns true if T depends on any template parameter. */
11249 : :
11250 : : bool
11251 : 2792557809 : uses_template_parms (tree t)
11252 : : {
11253 : 2792557809 : if (t == NULL_TREE || t == error_mark_node)
11254 : : return false;
11255 : :
11256 : : /* Namespaces can't depend on any template parameters. */
11257 : 2545569814 : if (TREE_CODE (t) == NAMESPACE_DECL)
11258 : : return false;
11259 : :
11260 : 2545569811 : processing_template_decl_sentinel ptds (/*reset*/false);
11261 : 2545569811 : ++processing_template_decl;
11262 : :
11263 : 2545569811 : if (TYPE_P (t))
11264 : 1587223611 : return dependent_type_p (t);
11265 : 958346200 : else if (TREE_CODE (t) == TREE_VEC)
11266 : 715806979 : return any_dependent_template_arguments_p (t);
11267 : 242539221 : else if (TREE_CODE (t) == TREE_LIST)
11268 : 117197328 : return (uses_template_parms (TREE_VALUE (t))
11269 : 117197328 : || uses_template_parms (TREE_CHAIN (t)));
11270 : 125341893 : else if (TREE_CODE (t) == TYPE_DECL)
11271 : 99 : return dependent_type_p (TREE_TYPE (t));
11272 : : else
11273 : 125341794 : return instantiation_dependent_expression_p (t);
11274 : 2545569811 : }
11275 : :
11276 : : /* Returns true if T depends on any template parameter with level LEVEL. */
11277 : :
11278 : : bool
11279 : 1677171 : uses_template_parms_level (tree t, int level)
11280 : : {
11281 : 1677171 : return for_each_template_parm (t, template_parm_this_level_p, &level, NULL,
11282 : 1677171 : /*include_nondeduced_p=*/true);
11283 : : }
11284 : :
11285 : : /* Returns true if the signature of DECL depends on any template parameter from
11286 : : its enclosing class. */
11287 : :
11288 : : static bool
11289 : 255713739 : uses_outer_template_parms (tree decl)
11290 : : {
11291 : 255713739 : int depth;
11292 : 255713739 : if (DECL_TEMPLATE_TEMPLATE_PARM_P (decl))
11293 : 305505 : depth = TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl)) - 1;
11294 : : else
11295 : 255408234 : depth = template_class_depth (CP_DECL_CONTEXT (decl));
11296 : 255713739 : if (depth == 0)
11297 : : return false;
11298 : 8764789 : if (for_each_template_parm (TREE_TYPE (decl), template_parm_outer_level,
11299 : : &depth, NULL, /*include_nondeduced_p=*/true))
11300 : : return true;
11301 : 760474 : if (PRIMARY_TEMPLATE_P (decl)
11302 : 760474 : || DECL_TEMPLATE_TEMPLATE_PARM_P (decl))
11303 : : {
11304 : 760474 : tree parms = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (decl));
11305 : 1735801 : for (int i = TREE_VEC_LENGTH (parms) - 1; i >= 0; --i)
11306 : : {
11307 : 975372 : tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
11308 : 975372 : tree defarg = TREE_PURPOSE (TREE_VEC_ELT (parms, i));
11309 : 975372 : if (TREE_CODE (parm) == PARM_DECL
11310 : 975372 : && for_each_template_parm (TREE_TYPE (parm),
11311 : : template_parm_outer_level,
11312 : : &depth, NULL, /*nondeduced*/true))
11313 : : return true;
11314 : 975333 : if (TREE_CODE (parm) == TEMPLATE_DECL
11315 : 975333 : && uses_outer_template_parms (parm))
11316 : : return true;
11317 : 975333 : if (defarg
11318 : 975333 : && for_each_template_parm (defarg, template_parm_outer_level,
11319 : : &depth, NULL, /*nondeduced*/true))
11320 : : return true;
11321 : : }
11322 : : }
11323 : 760429 : if (uses_outer_template_parms_in_constraints (decl))
11324 : : return true;
11325 : : return false;
11326 : : }
11327 : :
11328 : : /* Returns true if the constraints of DECL depend on any template parameters
11329 : : from its enclosing scope. */
11330 : :
11331 : : bool
11332 : 3292059 : uses_outer_template_parms_in_constraints (tree decl, tree ctx/*=NULL_TREE*/)
11333 : : {
11334 : 3292059 : tree ci = get_constraints (decl);
11335 : 3292059 : if (ci)
11336 : 9123 : ci = CI_ASSOCIATED_CONSTRAINTS (ci);
11337 : 9123 : if (!ci)
11338 : : return false;
11339 : 9123 : if (!ctx)
11340 : : {
11341 : 1775 : if (tree fc = DECL_FRIEND_CONTEXT (decl))
11342 : : ctx = fc;
11343 : : else
11344 : 108 : ctx = CP_DECL_CONTEXT (decl);
11345 : : }
11346 : 9123 : int depth = template_class_depth (ctx);
11347 : 9123 : if (depth == 0)
11348 : : return false;
11349 : 8969 : return for_each_template_parm (ci, template_parm_outer_level,
11350 : 8969 : &depth, NULL, /*nondeduced*/true);
11351 : : }
11352 : :
11353 : : /* Returns TRUE iff INST is an instantiation we don't need to do in an
11354 : : ill-formed translation unit, i.e. a variable or function that isn't
11355 : : usable in a constant expression. */
11356 : :
11357 : : static inline bool
11358 : 4841040 : neglectable_inst_p (tree d)
11359 : : {
11360 : 4766274 : return (d && DECL_P (d)
11361 : 4318164 : && !undeduced_auto_decl (d)
11362 : 9082006 : && !(TREE_CODE (d) == FUNCTION_DECL
11363 : 4899237 : ? FNDECL_MANIFESTLY_CONST_EVALUATED (d)
11364 : 658271 : : decl_maybe_constant_var_p (d)));
11365 : : }
11366 : :
11367 : : /* Returns TRUE iff we should refuse to instantiate DECL because it's
11368 : : neglectable and instantiated from within an erroneous instantiation. */
11369 : :
11370 : : static bool
11371 : 147745909 : limit_bad_template_recursion (tree decl)
11372 : : {
11373 : 147745909 : struct tinst_level *lev = current_tinst_level;
11374 : 147745909 : int errs = errorcount + sorrycount;
11375 : 147745909 : if (errs == 0 || !neglectable_inst_p (decl))
11376 : 145479631 : return false;
11377 : :
11378 : : /* Avoid instantiating members of an ill-formed class. */
11379 : 2266278 : bool refuse
11380 : 4532547 : = (DECL_CLASS_SCOPE_P (decl)
11381 : 3915882 : && CLASSTYPE_ERRONEOUS (DECL_CONTEXT (decl)));
11382 : :
11383 : : if (!refuse)
11384 : : {
11385 : 2439609 : for (; lev; lev = lev->next)
11386 : 2898286 : if (neglectable_inst_p (lev->maybe_get_node ()))
11387 : : break;
11388 : 2264845 : refuse = (lev && errs > lev->errors);
11389 : : }
11390 : :
11391 : : if (refuse)
11392 : : {
11393 : : /* Don't warn about it not being defined. */
11394 : 2622 : suppress_warning (decl, OPT_Wunused);
11395 : 2622 : tree clone;
11396 : 4530 : FOR_EACH_CLONE (clone, decl)
11397 : 1908 : suppress_warning (clone, OPT_Wunused);
11398 : : }
11399 : : return refuse;
11400 : : }
11401 : :
11402 : : static int tinst_depth;
11403 : : extern int max_tinst_depth;
11404 : : int depth_reached;
11405 : :
11406 : : static GTY(()) struct tinst_level *last_error_tinst_level;
11407 : :
11408 : : /* We're starting to instantiate D; record the template instantiation context
11409 : : at LOC for diagnostics and to restore it later. */
11410 : :
11411 : : bool
11412 : 617130643 : push_tinst_level_loc (tree tldcl, tree targs, location_t loc)
11413 : : {
11414 : 617130643 : struct tinst_level *new_level;
11415 : :
11416 : 617130643 : if (tinst_depth >= max_tinst_depth)
11417 : : {
11418 : : /* Tell error.cc not to try to instantiate any templates. */
11419 : 48 : at_eof = 3;
11420 : 48 : fatal_error (input_location,
11421 : : "template instantiation depth exceeds maximum of %d"
11422 : : " (use %<-ftemplate-depth=%> to increase the maximum)",
11423 : : max_tinst_depth);
11424 : : return false;
11425 : : }
11426 : :
11427 : : /* If the current instantiation caused problems, don't let it instantiate
11428 : : anything else. Do allow deduction substitution and decls usable in
11429 : : constant expressions. */
11430 : 617130595 : if (!targs && limit_bad_template_recursion (tldcl))
11431 : : {
11432 : : /* Avoid no_linkage_errors and unused function (and all other)
11433 : : warnings for this decl. */
11434 : 2622 : suppress_warning (tldcl);
11435 : 2622 : return false;
11436 : : }
11437 : :
11438 : : /* When not -quiet, dump template instantiations other than functions, since
11439 : : announce_function will take care of those. */
11440 : 617127973 : if (!quiet_flag && !targs
11441 : 0 : && TREE_CODE (tldcl) != TREE_LIST
11442 : 0 : && TREE_CODE (tldcl) != FUNCTION_DECL)
11443 : 0 : fprintf (stderr, " %s", decl_as_string (tldcl, TFF_DECL_SPECIFIERS));
11444 : :
11445 : 617127973 : new_level = tinst_level_freelist ().alloc ();
11446 : 617127973 : new_level->tldcl = tldcl;
11447 : 617127973 : new_level->targs = targs;
11448 : 617127973 : new_level->locus = loc;
11449 : 617127973 : new_level->errors = errorcount + sorrycount;
11450 : 617127973 : new_level->next = NULL;
11451 : 617127973 : new_level->refcount = 0;
11452 : 617127973 : new_level->path = new_level->visible = nullptr;
11453 : 617127973 : set_refcount_ptr (new_level->next, current_tinst_level);
11454 : 617127973 : set_refcount_ptr (current_tinst_level, new_level);
11455 : :
11456 : 617127973 : ++tinst_depth;
11457 : 617127973 : if (GATHER_STATISTICS && (tinst_depth > depth_reached))
11458 : : depth_reached = tinst_depth;
11459 : :
11460 : 617127973 : return true;
11461 : : }
11462 : :
11463 : : /* We're starting substitution of TMPL<ARGS>; record the template
11464 : : substitution context for diagnostics and to restore it later. */
11465 : :
11466 : : bool
11467 : 469384707 : push_tinst_level (tree tmpl, tree args)
11468 : : {
11469 : 469384707 : return push_tinst_level_loc (tmpl, args, input_location);
11470 : : }
11471 : :
11472 : : /* We're starting to instantiate D; record INPUT_LOCATION and the
11473 : : template instantiation context for diagnostics and to restore it
11474 : : later. */
11475 : :
11476 : : bool
11477 : 147595299 : push_tinst_level (tree d)
11478 : : {
11479 : 147595299 : return push_tinst_level_loc (d, input_location);
11480 : : }
11481 : :
11482 : : /* Likewise, but record LOC as the program location. */
11483 : :
11484 : : bool
11485 : 147745936 : push_tinst_level_loc (tree d, location_t loc)
11486 : : {
11487 : 147745936 : gcc_assert (TREE_CODE (d) != TREE_LIST);
11488 : 147745936 : return push_tinst_level_loc (d, NULL, loc);
11489 : : }
11490 : :
11491 : : /* We're done instantiating this template; return to the instantiation
11492 : : context. */
11493 : :
11494 : : void
11495 : 634534592 : pop_tinst_level (void)
11496 : : {
11497 : : /* Restore the filename and line number stashed away when we started
11498 : : this instantiation. */
11499 : 634534592 : input_location = current_tinst_level->locus;
11500 : 634534592 : set_refcount_ptr (current_tinst_level, current_tinst_level->next);
11501 : 634534592 : --tinst_depth;
11502 : 634534592 : }
11503 : :
11504 : : /* We're instantiating a deferred template; restore the template
11505 : : instantiation context in which the instantiation was requested, which
11506 : : is one step out from LEVEL. Return the corresponding DECL or TYPE. */
11507 : :
11508 : : static tree
11509 : 17436406 : reopen_tinst_level (struct tinst_level *level)
11510 : : {
11511 : 17436406 : struct tinst_level *t;
11512 : :
11513 : 17436406 : tinst_depth = 0;
11514 : 87217637 : for (t = level; t; t = t->next)
11515 : 69781231 : ++tinst_depth;
11516 : :
11517 : 17436406 : set_refcount_ptr (current_tinst_level, level);
11518 : 17436406 : pop_tinst_level ();
11519 : 17436406 : if (current_tinst_level)
11520 : 13473587 : current_tinst_level->errors = errorcount+sorrycount;
11521 : 17436406 : return level->maybe_get_node ();
11522 : : }
11523 : :
11524 : : /* Returns the TINST_LEVEL which gives the original instantiation
11525 : : context. */
11526 : :
11527 : : struct tinst_level *
11528 : 144 : outermost_tinst_level (void)
11529 : : {
11530 : 144 : struct tinst_level *level = current_tinst_level;
11531 : 144 : if (level)
11532 : 18 : while (level->next)
11533 : : level = level->next;
11534 : 144 : return level;
11535 : : }
11536 : :
11537 : : /* True iff T is a friend function declaration that is not itself a template
11538 : : and is not defined in a class template. */
11539 : :
11540 : : bool
11541 : 119193141 : non_templated_friend_p (tree t)
11542 : : {
11543 : 119193141 : if (t && TREE_CODE (t) == FUNCTION_DECL
11544 : 238060776 : && DECL_UNIQUE_FRIEND_P (t))
11545 : : {
11546 : 1753859 : tree ti = DECL_TEMPLATE_INFO (t);
11547 : 1753859 : if (!ti)
11548 : : return true;
11549 : : /* DECL_FRIEND_CONTEXT is set for a friend defined in class. */
11550 : 3507718 : if (DECL_FRIEND_CONTEXT (t))
11551 : : return false;
11552 : : /* Non-templated friends in a class template are still represented with a
11553 : : TEMPLATE_DECL; check that its primary template is the befriending
11554 : : class. Note that DECL_PRIMARY_TEMPLATE is null for
11555 : : template <class T> friend A<T>::f(); */
11556 : 661435 : tree tmpl = TI_TEMPLATE (ti);
11557 : 661435 : tree primary = DECL_PRIMARY_TEMPLATE (tmpl);
11558 : 661435 : return (primary && primary != tmpl);
11559 : : }
11560 : : else
11561 : : return false;
11562 : : }
11563 : :
11564 : : /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
11565 : : vector of template arguments, as for tsubst.
11566 : :
11567 : : Returns an appropriate tsubst'd friend declaration. */
11568 : :
11569 : : static tree
11570 : 1703904 : tsubst_friend_function (tree decl, tree args)
11571 : : {
11572 : 1703904 : tree new_friend;
11573 : :
11574 : 1703904 : if (TREE_CODE (decl) == FUNCTION_DECL
11575 : 679631 : && DECL_TEMPLATE_INSTANTIATION (decl)
11576 : 1727563 : && TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
11577 : : /* This was a friend declared with an explicit template
11578 : : argument list, e.g.:
11579 : :
11580 : : friend void f<>(T);
11581 : :
11582 : : to indicate that f was a template instantiation, not a new
11583 : : function declaration. Now, we have to figure out what
11584 : : instantiation of what template. */
11585 : : {
11586 : 23659 : tree template_id, arglist, fns;
11587 : 23659 : tree new_args;
11588 : 23659 : tree tmpl;
11589 : 23659 : tree ns = decl_namespace_context (TYPE_MAIN_DECL (current_class_type));
11590 : :
11591 : : /* Friend functions are looked up in the containing namespace scope.
11592 : : We must enter that scope, to avoid finding member functions of the
11593 : : current class with same name. */
11594 : 23659 : push_nested_namespace (ns);
11595 : 23659 : fns = tsubst_expr (DECL_TI_TEMPLATE (decl), args,
11596 : : tf_warning_or_error, NULL_TREE);
11597 : 23659 : pop_nested_namespace (ns);
11598 : 23659 : arglist = tsubst (DECL_TI_ARGS (decl), args,
11599 : : tf_warning_or_error, NULL_TREE);
11600 : 23659 : template_id = lookup_template_function (fns, arglist);
11601 : :
11602 : 23659 : new_friend = tsubst (decl, args, tf_warning_or_error, NULL_TREE);
11603 : 23659 : tmpl = determine_specialization (template_id, new_friend,
11604 : : &new_args,
11605 : : /*need_member_template=*/0,
11606 : 23659 : TREE_VEC_LENGTH (args),
11607 : : tsk_none);
11608 : 23659 : return instantiate_template (tmpl, new_args, tf_error);
11609 : : }
11610 : :
11611 : 1680245 : new_friend = tsubst (decl, args, tf_warning_or_error, NULL_TREE);
11612 : 1680245 : if (new_friend == error_mark_node)
11613 : : return error_mark_node;
11614 : :
11615 : : /* The NEW_FRIEND will look like an instantiation, to the
11616 : : compiler, but is not an instantiation from the point of view of
11617 : : the language. For example, we might have had:
11618 : :
11619 : : template <class T> struct S {
11620 : : template <class U> friend void f(T, U);
11621 : : };
11622 : :
11623 : : Then, in S<int>, template <class U> void f(int, U) is not an
11624 : : instantiation of anything. */
11625 : :
11626 : 1680245 : DECL_USE_TEMPLATE (new_friend) = 0;
11627 : 1680245 : if (TREE_CODE (new_friend) == TEMPLATE_DECL)
11628 : : {
11629 : 1024273 : DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (new_friend) = false;
11630 : 1024273 : DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend)) = 0;
11631 : 2048546 : DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend))
11632 : 1024273 : = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl));
11633 : :
11634 : : /* Substitute TEMPLATE_PARMS_CONSTRAINTS so that parameter levels will
11635 : : match in decls_match. */
11636 : 1024273 : tree parms = DECL_TEMPLATE_PARMS (new_friend);
11637 : 1024273 : tree treqs = TEMPLATE_PARMS_CONSTRAINTS (parms);
11638 : 1024273 : treqs = maybe_substitute_reqs_for (treqs, new_friend);
11639 : 1024273 : if (treqs != TEMPLATE_PARMS_CONSTRAINTS (parms))
11640 : : {
11641 : 61108 : TEMPLATE_PARMS_CONSTRAINTS (parms) = treqs;
11642 : : /* As well as each TEMPLATE_PARM_CONSTRAINTS. */
11643 : 61108 : tsubst_each_template_parm_constraints (parms, args,
11644 : : tf_warning_or_error);
11645 : : }
11646 : : }
11647 : :
11648 : : /* The mangled name for the NEW_FRIEND is incorrect. The function
11649 : : is not a template instantiation and should not be mangled like
11650 : : one. Therefore, we forget the mangling here; we'll recompute it
11651 : : later if we need it. */
11652 : 1680245 : if (TREE_CODE (new_friend) != TEMPLATE_DECL)
11653 : : {
11654 : 655972 : SET_DECL_RTL (new_friend, NULL);
11655 : 655972 : SET_DECL_ASSEMBLER_NAME (new_friend, NULL_TREE);
11656 : : }
11657 : :
11658 : 1680245 : if (DECL_NAMESPACE_SCOPE_P (new_friend))
11659 : : {
11660 : 1680182 : tree old_decl;
11661 : 1680182 : tree ns;
11662 : :
11663 : : /* We must save some information from NEW_FRIEND before calling
11664 : : duplicate decls since that function will free NEW_FRIEND if
11665 : : possible. */
11666 : 1680182 : tree new_friend_template_info = DECL_TEMPLATE_INFO (new_friend);
11667 : 1680182 : tree new_friend_result_template_info = NULL_TREE;
11668 : 1680182 : bool new_friend_is_defn =
11669 : : (new_friend_template_info
11670 : 1680182 : && (DECL_INITIAL (DECL_TEMPLATE_RESULT
11671 : : (template_for_substitution (new_friend)))
11672 : 1680182 : != NULL_TREE));
11673 : 1680182 : tree not_tmpl = new_friend;
11674 : :
11675 : 1680182 : if (TREE_CODE (new_friend) == TEMPLATE_DECL)
11676 : : {
11677 : : /* This declaration is a `primary' template. */
11678 : 1024234 : DECL_PRIMARY_TEMPLATE (new_friend) = new_friend;
11679 : :
11680 : 1024234 : not_tmpl = DECL_TEMPLATE_RESULT (new_friend);
11681 : 1024234 : new_friend_result_template_info = DECL_TEMPLATE_INFO (not_tmpl);
11682 : : }
11683 : :
11684 : : /* We need to propagate module attachment for the new friend from the
11685 : : owner of this template. */
11686 : 1680182 : propagate_defining_module (new_friend, decl);
11687 : :
11688 : : /* Inside pushdecl_namespace_level, we will push into the
11689 : : current namespace. However, the friend function should go
11690 : : into the namespace of the template. */
11691 : 1680182 : ns = decl_namespace_context (new_friend);
11692 : 1680182 : push_nested_namespace (ns);
11693 : 1680182 : old_decl = pushdecl_namespace_level (new_friend, /*hiding=*/true);
11694 : 1680182 : pop_nested_namespace (ns);
11695 : :
11696 : 1680182 : if (old_decl == error_mark_node)
11697 : : return error_mark_node;
11698 : :
11699 : 1680161 : if (old_decl != new_friend)
11700 : : {
11701 : : /* This new friend declaration matched an existing
11702 : : declaration. For example, given:
11703 : :
11704 : : template <class T> void f(T);
11705 : : template <class U> class C {
11706 : : template <class T> friend void f(T) {}
11707 : : };
11708 : :
11709 : : the friend declaration actually provides the definition
11710 : : of `f', once C has been instantiated for some type. So,
11711 : : old_decl will be the out-of-class template declaration,
11712 : : while new_friend is the in-class definition.
11713 : :
11714 : : But, if `f' was called before this point, the
11715 : : instantiation of `f' will have DECL_TI_ARGS corresponding
11716 : : to `T' but not to `U', references to which might appear
11717 : : in the definition of `f'. Previously, the most general
11718 : : template for an instantiation of `f' was the out-of-class
11719 : : version; now it is the in-class version. Therefore, we
11720 : : run through all specialization of `f', adding to their
11721 : : DECL_TI_ARGS appropriately. In particular, they need a
11722 : : new set of outer arguments, corresponding to the
11723 : : arguments for this class instantiation.
11724 : :
11725 : : The same situation can arise with something like this:
11726 : :
11727 : : friend void f(int);
11728 : : template <class T> class C {
11729 : : friend void f(T) {}
11730 : : };
11731 : :
11732 : : when `C<int>' is instantiated. Now, `f(int)' is defined
11733 : : in the class. */
11734 : :
11735 : 493952 : if (!new_friend_is_defn)
11736 : : /* On the other hand, if the in-class declaration does
11737 : : *not* provide a definition, then we don't want to alter
11738 : : existing definitions. We can just leave everything
11739 : : alone. */
11740 : : ;
11741 : : else
11742 : : {
11743 : 42 : tree old_template = most_general_template (old_decl);
11744 : 42 : tree new_template = TI_TEMPLATE (new_friend_template_info);
11745 : 42 : tree new_args = TI_ARGS (new_friend_template_info);
11746 : :
11747 : : /* Overwrite whatever template info was there before, if
11748 : : any, with the new template information pertaining to
11749 : : the declaration. */
11750 : 42 : DECL_TEMPLATE_INFO (old_decl) = new_friend_template_info;
11751 : :
11752 : 42 : if (TREE_CODE (old_decl) != TEMPLATE_DECL)
11753 : : {
11754 : : /* We should have called reregister_specialization in
11755 : : duplicate_decls. */
11756 : 24 : gcc_assert (retrieve_specialization (new_template,
11757 : : new_args, 0)
11758 : : == old_decl);
11759 : :
11760 : : /* Instantiate it if the global has already been used. */
11761 : 24 : if (DECL_ODR_USED (old_decl))
11762 : 3 : instantiate_decl (old_decl, /*defer_ok=*/true,
11763 : : /*expl_inst_class_mem_p=*/false);
11764 : : }
11765 : : else
11766 : : {
11767 : 18 : tree t;
11768 : :
11769 : : /* Indicate that the old function template is a partial
11770 : : instantiation. */
11771 : 18 : DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl))
11772 : 18 : = new_friend_result_template_info;
11773 : :
11774 : 18 : gcc_assert (new_template
11775 : : == most_general_template (new_template));
11776 : 18 : gcc_assert (new_template != old_decl);
11777 : :
11778 : : /* Reassign any specializations already in the hash table
11779 : : to the new more general template, and add the
11780 : : additional template args. */
11781 : 18 : for (t = DECL_TEMPLATE_INSTANTIATIONS (old_template);
11782 : 39 : t != NULL_TREE;
11783 : 21 : t = TREE_CHAIN (t))
11784 : : {
11785 : 21 : tree spec = TREE_VALUE (t);
11786 : 21 : spec_entry elt;
11787 : :
11788 : 21 : elt.tmpl = old_decl;
11789 : 21 : elt.args = DECL_TI_ARGS (spec);
11790 : 21 : elt.spec = NULL_TREE;
11791 : :
11792 : 21 : decl_specializations->remove_elt (&elt);
11793 : :
11794 : 21 : tree& spec_args = DECL_TI_ARGS (spec);
11795 : 42 : spec_args = add_outermost_template_args
11796 : 21 : (new_args, INNERMOST_TEMPLATE_ARGS (spec_args));
11797 : :
11798 : 21 : register_specialization
11799 : 21 : (spec, new_template, spec_args, true, 0);
11800 : :
11801 : : }
11802 : 18 : DECL_TEMPLATE_INSTANTIATIONS (old_template) = NULL_TREE;
11803 : : }
11804 : : }
11805 : :
11806 : : /* The information from NEW_FRIEND has been merged into OLD_DECL
11807 : : by duplicate_decls. */
11808 : : new_friend = old_decl;
11809 : : }
11810 : :
11811 : : /* We've just introduced a namespace-scope function in the purview
11812 : : without necessarily having opened the enclosing namespace, so
11813 : : make sure the namespace is in the purview now too. */
11814 : 1680161 : if (modules_p ()
11815 : 11478 : && DECL_MODULE_PURVIEW_P (STRIP_TEMPLATE (new_friend))
11816 : 1683338 : && TREE_CODE (DECL_CONTEXT (new_friend)) == NAMESPACE_DECL)
11817 : 3105 : DECL_MODULE_PURVIEW_P (DECL_CONTEXT (new_friend)) = true;
11818 : : }
11819 : : else
11820 : : {
11821 : 63 : tree context = DECL_CONTEXT (new_friend);
11822 : 63 : bool dependent_p;
11823 : :
11824 : : /* In the code
11825 : : template <class T> class C {
11826 : : template <class U> friend void C1<U>::f (); // case 1
11827 : : friend void C2<T>::f (); // case 2
11828 : : };
11829 : : we only need to make sure CONTEXT is a complete type for
11830 : : case 2. To distinguish between the two cases, we note that
11831 : : CONTEXT of case 1 remains dependent type after tsubst while
11832 : : this isn't true for case 2. */
11833 : 63 : ++processing_template_decl;
11834 : 63 : dependent_p = dependent_type_p (context);
11835 : 63 : --processing_template_decl;
11836 : :
11837 : 63 : if (!dependent_p
11838 : 63 : && !complete_type_or_else (context, NULL_TREE))
11839 : 0 : return error_mark_node;
11840 : :
11841 : 63 : if (COMPLETE_TYPE_P (context))
11842 : : {
11843 : 57 : tree fn = new_friend;
11844 : : /* do_friend adds the TEMPLATE_DECL for any member friend
11845 : : template even if it isn't a member template, i.e.
11846 : : template <class T> friend A<T>::f();
11847 : : Look through it in that case. */
11848 : 57 : if (TREE_CODE (fn) == TEMPLATE_DECL
11849 : 57 : && !PRIMARY_TEMPLATE_P (fn))
11850 : 18 : fn = DECL_TEMPLATE_RESULT (fn);
11851 : : /* Check to see that the declaration is really present, and,
11852 : : possibly obtain an improved declaration. */
11853 : 57 : fn = check_classfn (context, fn, NULL_TREE);
11854 : :
11855 : 57 : if (fn)
11856 : 1703904 : new_friend = fn;
11857 : : }
11858 : : }
11859 : :
11860 : : return new_friend;
11861 : : }
11862 : :
11863 : : /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
11864 : : template arguments, as for tsubst.
11865 : :
11866 : : Returns an appropriate tsubst'd friend type or error_mark_node on
11867 : : failure. */
11868 : :
11869 : : static tree
11870 : 456973 : tsubst_friend_class (tree friend_tmpl, tree args)
11871 : : {
11872 : 456973 : tree tmpl;
11873 : :
11874 : 456973 : if (DECL_TEMPLATE_TEMPLATE_PARM_P (friend_tmpl))
11875 : : {
11876 : 3 : tmpl = tsubst (TREE_TYPE (friend_tmpl), args, tf_none, NULL_TREE);
11877 : 3 : return TREE_TYPE (tmpl);
11878 : : }
11879 : :
11880 : 456970 : if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl)) == 1)
11881 : : /* The template has already been fully substituted, e.g. for
11882 : :
11883 : : template <typename> friend class ::C;
11884 : :
11885 : : so we can just return it directly. */
11886 : 100284 : return TREE_TYPE (friend_tmpl);
11887 : :
11888 : 356686 : tree context = CP_DECL_CONTEXT (friend_tmpl);
11889 : 356686 : if (TREE_CODE (context) == NAMESPACE_DECL)
11890 : 356285 : push_nested_namespace (context);
11891 : : else
11892 : : {
11893 : 401 : context = tsubst (context, args, tf_error, NULL_TREE);
11894 : 401 : push_nested_class (context);
11895 : : }
11896 : :
11897 : 356686 : tmpl = lookup_name (DECL_NAME (friend_tmpl), LOOK_where::CLASS_NAMESPACE,
11898 : : LOOK_want::NORMAL | LOOK_want::HIDDEN_FRIEND);
11899 : :
11900 : 356686 : if (!tmpl)
11901 : : /* If we didn't find by name lookup, the type may still exist but as a
11902 : : 'hidden' import; we should check for this too to avoid accidentally
11903 : : instantiating a duplicate. */
11904 : 214 : tmpl = lookup_imported_hidden_friend (friend_tmpl);
11905 : :
11906 : 356686 : if (tmpl && DECL_CLASS_TEMPLATE_P (tmpl))
11907 : : {
11908 : : /* The friend template has already been declared. Just
11909 : : check to see that the declarations match, and install any new
11910 : : default parameters. We must tsubst the default parameters,
11911 : : of course. We only need the innermost template parameters
11912 : : because that is all that redeclare_class_template will look
11913 : : at. */
11914 : :
11915 : 356475 : if (modules_p ())
11916 : : /* Check that the existing declaration's module attachment is
11917 : : compatible with the attachment of the friend template. */
11918 : 1313 : module_may_redeclare (tmpl, friend_tmpl);
11919 : :
11920 : 356475 : if (DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (friend_tmpl))
11921 : : {
11922 : 356472 : tree parms = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl),
11923 : : args, tf_warning_or_error);
11924 : 356472 : tsubst_each_template_parm_constraints (parms, args,
11925 : : tf_warning_or_error);
11926 : 356472 : location_t saved_input_location = input_location;
11927 : 356472 : input_location = DECL_SOURCE_LOCATION (friend_tmpl);
11928 : 356472 : tree cons = get_constraints (friend_tmpl);
11929 : 356472 : ++processing_template_decl;
11930 : 356472 : cons = tsubst_constraint_info (cons, args, tf_warning_or_error,
11931 : 356472 : DECL_FRIEND_CONTEXT (friend_tmpl));
11932 : 356472 : --processing_template_decl;
11933 : 356472 : redeclare_class_template (TREE_TYPE (tmpl), parms, cons);
11934 : 356472 : input_location = saved_input_location;
11935 : : }
11936 : : }
11937 : : else
11938 : : {
11939 : : /* The friend template has not already been declared. In this
11940 : : case, the instantiation of the template class will cause the
11941 : : injection of this template into the namespace scope. */
11942 : 211 : tmpl = tsubst (friend_tmpl, args, tf_warning_or_error, NULL_TREE);
11943 : :
11944 : 211 : if (tmpl != error_mark_node)
11945 : : {
11946 : : /* The new TMPL is not an instantiation of anything, so we
11947 : : forget its origins. It is also not a specialization of
11948 : : anything. We don't reset CLASSTYPE_TI_TEMPLATE
11949 : : for the new type because that is supposed to be the
11950 : : corresponding template decl, i.e., TMPL. */
11951 : 206 : spec_entry elt;
11952 : 206 : elt.tmpl = friend_tmpl;
11953 : 206 : elt.args = CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl));
11954 : 206 : elt.spec = TREE_TYPE (tmpl);
11955 : 206 : type_specializations->remove_elt (&elt);
11956 : :
11957 : 206 : DECL_USE_TEMPLATE (tmpl) = 0;
11958 : 206 : DECL_TEMPLATE_INFO (tmpl) = NULL_TREE;
11959 : 206 : CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl)) = 0;
11960 : 206 : CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl))
11961 : 206 : = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl)));
11962 : 206 : DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (tmpl) = false;
11963 : :
11964 : : /* Substitute into and set the constraints on the new declaration. */
11965 : 206 : if (tree ci = get_constraints (friend_tmpl))
11966 : : {
11967 : 6 : ++processing_template_decl;
11968 : 6 : ci = tsubst_constraint_info (ci, args, tf_warning_or_error,
11969 : 6 : DECL_FRIEND_CONTEXT (friend_tmpl));
11970 : 6 : --processing_template_decl;
11971 : 6 : set_constraints (tmpl, ci);
11972 : 6 : tsubst_each_template_parm_constraints (DECL_TEMPLATE_PARMS (tmpl),
11973 : : args, tf_warning_or_error);
11974 : : }
11975 : :
11976 : : /* We need to propagate the attachment of the original template to the
11977 : : newly instantiated template type. */
11978 : 206 : propagate_defining_module (tmpl, friend_tmpl);
11979 : :
11980 : : /* Inject this template into the enclosing namspace scope. */
11981 : 206 : tmpl = pushdecl_namespace_level (tmpl, /*hiding=*/true);
11982 : : }
11983 : : }
11984 : :
11985 : 356686 : if (TREE_CODE (context) == NAMESPACE_DECL)
11986 : 356285 : pop_nested_namespace (context);
11987 : : else
11988 : 401 : pop_nested_class ();
11989 : :
11990 : 356686 : return TREE_TYPE (tmpl);
11991 : : }
11992 : :
11993 : : /* Returns zero if TYPE cannot be completed later due to circularity.
11994 : : Otherwise returns one. */
11995 : :
11996 : : static int
11997 : 6104020 : can_complete_type_without_circularity (tree type)
11998 : : {
11999 : 6104412 : if (type == NULL_TREE || type == error_mark_node)
12000 : : return 0;
12001 : 6104412 : else if (COMPLETE_TYPE_P (type))
12002 : : return 1;
12003 : 494907 : else if (TREE_CODE (type) == ARRAY_TYPE)
12004 : 392 : return can_complete_type_without_circularity (TREE_TYPE (type));
12005 : 494512 : else if (CLASS_TYPE_P (type)
12006 : 989027 : && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type)))
12007 : : return 0;
12008 : : else
12009 : 494506 : return 1;
12010 : : }
12011 : :
12012 : : static tree tsubst_omp_clauses (tree, enum c_omp_region_type, tree,
12013 : : tsubst_flags_t, tree);
12014 : :
12015 : : /* Instantiate the contract statement. */
12016 : :
12017 : : static tree
12018 : 244 : tsubst_contract (tree decl, tree t, tree args, tsubst_flags_t complain,
12019 : : tree in_decl)
12020 : : {
12021 : 244 : tree type = decl ? TREE_TYPE (TREE_TYPE (decl)) : NULL_TREE;
12022 : 244 : bool auto_p = type_uses_auto (type);
12023 : :
12024 : 244 : tree r = copy_node (t);
12025 : :
12026 : : /* Rebuild the result variable. */
12027 : 244 : if (type && POSTCONDITION_P (t) && POSTCONDITION_IDENTIFIER (t))
12028 : : {
12029 : 27 : tree oldvar = POSTCONDITION_IDENTIFIER (t);
12030 : :
12031 : 27 : tree newvar = copy_node (oldvar);
12032 : 27 : TREE_TYPE (newvar) = type;
12033 : 27 : DECL_CONTEXT (newvar) = decl;
12034 : 27 : POSTCONDITION_IDENTIFIER (r) = newvar;
12035 : :
12036 : : /* Make sure the postcondition is valid. */
12037 : 27 : location_t loc = DECL_SOURCE_LOCATION (oldvar);
12038 : 27 : if (!auto_p)
12039 : 25 : if (!check_postcondition_result (decl, type, loc))
12040 : 0 : return invalidate_contract (r);
12041 : :
12042 : : /* Make the variable available for lookup. */
12043 : 27 : register_local_specialization (newvar, oldvar);
12044 : : }
12045 : :
12046 : : /* Instantiate the condition. If the return type is undeduced, process
12047 : : the expression as if inside a template to avoid spurious type errors. */
12048 : 244 : if (auto_p)
12049 : 2 : ++processing_template_decl;
12050 : 244 : ++processing_contract_condition;
12051 : 244 : CONTRACT_CONDITION (r)
12052 : 244 : = tsubst_expr (CONTRACT_CONDITION (t), args, complain, in_decl);
12053 : 244 : --processing_contract_condition;
12054 : 244 : if (auto_p)
12055 : 2 : --processing_template_decl;
12056 : :
12057 : : /* And the comment. */
12058 : 244 : CONTRACT_COMMENT (r)
12059 : 244 : = tsubst_expr (CONTRACT_COMMENT (r), args, complain, in_decl);
12060 : :
12061 : 244 : return r;
12062 : : }
12063 : :
12064 : : /* Update T by instantiating its contract attribute. */
12065 : :
12066 : : static void
12067 : 223 : tsubst_contract_attribute (tree decl, tree t, tree args,
12068 : : tsubst_flags_t complain, tree in_decl)
12069 : : {
12070 : : /* For non-specializations, adjust the current declaration to the most general
12071 : : version of in_decl. Because we defer the instantiation of contracts as long
12072 : : as possible, they are still written in terms of the parameters (and return
12073 : : type) of the most general template. */
12074 : 223 : tree tmpl = DECL_TI_TEMPLATE (in_decl);
12075 : 223 : if (!DECL_TEMPLATE_SPECIALIZATION (tmpl))
12076 : 217 : in_decl = DECL_TEMPLATE_RESULT (most_general_template (in_decl));
12077 : 223 : local_specialization_stack specs (lss_copy);
12078 : 223 : register_parameter_specializations (in_decl, decl);
12079 : :
12080 : : /* Get the contract to be instantiated. */
12081 : 223 : tree contract = CONTRACT_STATEMENT (t);
12082 : :
12083 : : /* Use the complete set of template arguments for instantiation. The
12084 : : contract may not have been instantiated and still refer to outer levels
12085 : : of template parameters. */
12086 : 223 : args = DECL_TI_ARGS (decl);
12087 : :
12088 : : /* For member functions, make this available for semantic analysis. */
12089 : 223 : tree save_ccp = current_class_ptr;
12090 : 223 : tree save_ccr = current_class_ref;
12091 : 223 : if (DECL_IOBJ_MEMBER_FUNCTION_P (decl))
12092 : : {
12093 : 110 : tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
12094 : 110 : tree this_type = TREE_TYPE (TREE_VALUE (arg_types));
12095 : 110 : inject_this_parameter (this_type, cp_type_quals (this_type));
12096 : : }
12097 : :
12098 : 223 : contract = tsubst_contract (decl, contract, args, complain, in_decl);
12099 : :
12100 : 223 : current_class_ptr = save_ccp;
12101 : 223 : current_class_ref = save_ccr;
12102 : :
12103 : : /* Rebuild the attribute. */
12104 : 223 : TREE_VALUE (t) = build_tree_list (NULL_TREE, contract);
12105 : 223 : }
12106 : :
12107 : : /* Rebuild the attribute list for DECL, substituting into contracts
12108 : : as needed. */
12109 : :
12110 : : void
12111 : 150 : tsubst_contract_attributes (tree decl, tree args, tsubst_flags_t complain, tree in_decl)
12112 : : {
12113 : 150 : tree list = copy_list (DECL_ATTRIBUTES (decl));
12114 : 375 : for (tree attr = list; attr; attr = CONTRACT_CHAIN (attr))
12115 : : {
12116 : 225 : if (cxx_contract_attribute_p (attr))
12117 : 223 : tsubst_contract_attribute (decl, attr, args, complain, in_decl);
12118 : : }
12119 : 150 : DECL_ATTRIBUTES (decl) = list;
12120 : 150 : }
12121 : :
12122 : : /* Instantiate a single dependent attribute T (a TREE_LIST), and return either
12123 : : T or a new TREE_LIST, possibly a chain in the case of a pack expansion. */
12124 : :
12125 : : static tree
12126 : 1285286 : tsubst_attribute (tree t, tree *decl_p, tree args,
12127 : : tsubst_flags_t complain, tree in_decl)
12128 : : {
12129 : 1285286 : gcc_assert (ATTR_IS_DEPENDENT (t));
12130 : :
12131 : : /* Note that contract attributes are never substituted from this function.
12132 : : Their instantiation is triggered by regenerate_from_template_decl when
12133 : : we instantiate the body of the function. */
12134 : :
12135 : 1285286 : tree val = TREE_VALUE (t);
12136 : 1285286 : if (val == NULL_TREE)
12137 : : /* Nothing to do. */;
12138 : 190773 : else if ((flag_openmp || flag_openmp_simd)
12139 : 191139 : && is_attribute_p ("omp declare simd",
12140 : 216 : get_attribute_name (t)))
12141 : : {
12142 : 105 : tree clauses = TREE_VALUE (val);
12143 : 105 : clauses = tsubst_omp_clauses (clauses, C_ORT_OMP_DECLARE_SIMD, args,
12144 : : complain, in_decl);
12145 : 105 : c_omp_declare_simd_clauses_to_decls (*decl_p, clauses);
12146 : 105 : clauses = finish_omp_clauses (clauses, C_ORT_OMP_DECLARE_SIMD);
12147 : 105 : tree parms = DECL_ARGUMENTS (*decl_p);
12148 : 105 : clauses
12149 : 105 : = c_omp_declare_simd_clauses_to_numbers (parms, clauses);
12150 : 105 : if (clauses)
12151 : 105 : val = build_tree_list (NULL_TREE, clauses);
12152 : : else
12153 : : val = NULL_TREE;
12154 : : }
12155 : 190818 : else if (flag_openmp
12156 : 190929 : && is_attribute_p ("omp declare variant base",
12157 : 111 : get_attribute_name (t)))
12158 : : {
12159 : 111 : ++cp_unevaluated_operand;
12160 : 111 : tree varid = tsubst_expr (TREE_PURPOSE (val), args, complain, in_decl);
12161 : 111 : --cp_unevaluated_operand;
12162 : 111 : tree chain = TREE_CHAIN (val);
12163 : 111 : location_t match_loc = cp_expr_loc_or_input_loc (TREE_PURPOSE (chain));
12164 : 111 : tree ctx = copy_list (TREE_VALUE (val));
12165 : 111 : tree append_args_list = TREE_CHAIN (TREE_CHAIN (chain));
12166 : 111 : if (append_args_list)
12167 : : {
12168 : 45 : append_args_list = TREE_VALUE (append_args_list);
12169 : 45 : if (append_args_list)
12170 : 45 : TREE_CHAIN (append_args_list)
12171 : 90 : = tsubst_omp_clauses (TREE_CHAIN (append_args_list),
12172 : : C_ORT_OMP_DECLARE_SIMD, args, complain, in_decl);
12173 : : }
12174 : 219 : for (tree tss = ctx; tss; tss = TREE_CHAIN (tss))
12175 : : {
12176 : 117 : enum omp_tss_code set = OMP_TSS_CODE (tss);
12177 : 117 : tree selectors = NULL_TREE;
12178 : 225 : for (tree ts = OMP_TSS_TRAIT_SELECTORS (tss); ts;
12179 : 108 : ts = TREE_CHAIN (ts))
12180 : : {
12181 : 117 : tree properties = NULL_TREE;
12182 : 117 : tree scoreval = NULL_TREE;
12183 : : /* FIXME: The body of this loop should really be dispatching
12184 : : according to omp_ts_map[OMP_TS_CODE (TS)].tp_type instead
12185 : : of having hard-wired knowledge of specific selectors. */
12186 : 117 : if (OMP_TS_CODE (ts) == OMP_TRAIT_CONSTRUCT_SIMD
12187 : 117 : && set == OMP_TRAIT_SET_CONSTRUCT)
12188 : : {
12189 : 0 : tree clauses = OMP_TS_PROPERTIES (ts);
12190 : 0 : clauses = tsubst_omp_clauses (clauses,
12191 : : C_ORT_OMP_DECLARE_SIMD, args,
12192 : : complain, in_decl);
12193 : 0 : c_omp_declare_simd_clauses_to_decls (*decl_p, clauses);
12194 : 0 : clauses = finish_omp_clauses (clauses, C_ORT_OMP_DECLARE_SIMD);
12195 : 0 : properties = clauses;
12196 : : }
12197 : : else
12198 : : {
12199 : 117 : tree v = OMP_TS_SCORE (ts);
12200 : 42 : if (v)
12201 : : {
12202 : 42 : v = tsubst_expr (v, args, complain, in_decl);
12203 : 42 : v = fold_non_dependent_expr (v);
12204 : 84 : if (!INTEGRAL_TYPE_P (TREE_TYPE (v))
12205 : 81 : || TREE_CODE (v) != INTEGER_CST)
12206 : : {
12207 : 3 : location_t loc
12208 : 3 : = cp_expr_loc_or_loc (OMP_TS_SCORE (ts),
12209 : : match_loc);
12210 : 3 : error_at (loc, "score argument must be "
12211 : : "constant integer expression");
12212 : 3 : return NULL_TREE;
12213 : : }
12214 : 39 : else if (tree_int_cst_sgn (v) < 0)
12215 : : {
12216 : 3 : location_t loc
12217 : 3 : = cp_expr_loc_or_loc (OMP_TS_SCORE (ts),
12218 : : match_loc);
12219 : 3 : error_at (loc, "score argument must be "
12220 : : "non-negative");
12221 : 3 : return NULL_TREE;
12222 : : }
12223 : : scoreval = v;
12224 : : }
12225 : 111 : properties = copy_list (OMP_TS_PROPERTIES (ts));
12226 : 174 : for (tree p = properties; p; p = TREE_CHAIN (p))
12227 : 66 : if (OMP_TP_NAME (p) == OMP_TP_NAMELIST_NODE)
12228 : 6 : continue;
12229 : 60 : else if (OMP_TP_VALUE (p))
12230 : : {
12231 : 60 : bool allow_string
12232 : 60 : = (OMP_TS_CODE (ts) != OMP_TRAIT_USER_CONDITION
12233 : 60 : || set != OMP_TRAIT_SET_USER);
12234 : 60 : tree v = OMP_TP_VALUE (p);
12235 : 60 : if (TREE_CODE (v) == STRING_CST && allow_string)
12236 : 0 : continue;
12237 : 60 : v = tsubst_expr (v, args, complain, in_decl);
12238 : 60 : v = fold_non_dependent_expr (v);
12239 : 120 : if (!INTEGRAL_TYPE_P (TREE_TYPE (v))
12240 : 117 : || !tree_fits_shwi_p (v))
12241 : : {
12242 : 3 : location_t loc
12243 : 3 : = cp_expr_loc_or_loc (OMP_TP_VALUE (p),
12244 : : match_loc);
12245 : 3 : if (allow_string)
12246 : 0 : error_at (loc, "property must be constant "
12247 : : "integer expression or string "
12248 : : "literal");
12249 : : else
12250 : 3 : error_at (loc, "property must be constant "
12251 : : "integer expression");
12252 : 3 : return NULL_TREE;
12253 : : }
12254 : 57 : OMP_TP_VALUE (p) = v;
12255 : : }
12256 : : }
12257 : 108 : selectors = make_trait_selector (OMP_TS_CODE (ts), scoreval,
12258 : : properties, selectors);
12259 : : }
12260 : 108 : OMP_TSS_TRAIT_SELECTORS (tss) = nreverse (selectors);
12261 : : }
12262 : 102 : if (varid == error_mark_node)
12263 : : val = error_mark_node;
12264 : : else
12265 : 96 : val = tree_cons (varid, ctx, chain);
12266 : : }
12267 : : /* If the first attribute argument is an identifier, don't
12268 : : pass it through tsubst. Attributes like mode, format,
12269 : : cleanup and several target specific attributes expect it
12270 : : unmodified. */
12271 : 190707 : else if (attribute_takes_identifier_p (get_attribute_name (t)))
12272 : : {
12273 : 202 : tree chain
12274 : 202 : = tsubst_expr (TREE_CHAIN (val), args, complain, in_decl);
12275 : 202 : if (chain != TREE_CHAIN (val))
12276 : 12 : val = tree_cons (NULL_TREE, TREE_VALUE (val), chain);
12277 : : }
12278 : 190505 : else if (PACK_EXPANSION_P (val))
12279 : : {
12280 : : /* An attribute pack expansion. */
12281 : 15 : tree purp = TREE_PURPOSE (t);
12282 : 15 : tree pack = tsubst_pack_expansion (val, args, complain, in_decl);
12283 : 15 : if (pack == error_mark_node)
12284 : : return error_mark_node;
12285 : 12 : int len = TREE_VEC_LENGTH (pack);
12286 : 12 : tree list = NULL_TREE;
12287 : 12 : tree *q = &list;
12288 : 24 : for (int i = 0; i < len; ++i)
12289 : : {
12290 : 12 : tree elt = TREE_VEC_ELT (pack, i);
12291 : 12 : *q = build_tree_list (purp, elt);
12292 : 12 : q = &TREE_CHAIN (*q);
12293 : : }
12294 : 12 : return list;
12295 : : }
12296 : : else
12297 : 190490 : val = tsubst_expr (val, args, complain, in_decl);
12298 : :
12299 : 1285262 : if (val == error_mark_node)
12300 : : return error_mark_node;
12301 : 1285239 : if (val != TREE_VALUE (t))
12302 : 190002 : return build_tree_list (TREE_PURPOSE (t), val);
12303 : : return t;
12304 : : }
12305 : :
12306 : : /* Instantiate any dependent attributes in ATTRIBUTES, returning either it
12307 : : unchanged or a new TREE_LIST chain. */
12308 : :
12309 : : static tree
12310 : 326425 : tsubst_attributes (tree attributes, tree args,
12311 : : tsubst_flags_t complain, tree in_decl)
12312 : : {
12313 : 326425 : tree last_dep = NULL_TREE;
12314 : :
12315 : 326425 : for (tree t = attributes; t; t = TREE_CHAIN (t))
12316 : 16 : if (ATTR_IS_DEPENDENT (t))
12317 : : {
12318 : 16 : last_dep = t;
12319 : 16 : attributes = copy_list (attributes);
12320 : 16 : break;
12321 : : }
12322 : :
12323 : 326425 : if (last_dep)
12324 : 32 : for (tree *p = &attributes; *p; )
12325 : : {
12326 : 16 : tree t = *p;
12327 : 16 : if (ATTR_IS_DEPENDENT (t))
12328 : : {
12329 : 16 : tree subst = tsubst_attribute (t, NULL, args, complain, in_decl);
12330 : 16 : if (subst != t)
12331 : : {
12332 : 6 : *p = subst;
12333 : 9 : while (*p)
12334 : 3 : p = &TREE_CHAIN (*p);
12335 : 6 : *p = TREE_CHAIN (t);
12336 : 6 : continue;
12337 : : }
12338 : : }
12339 : 10 : p = &TREE_CHAIN (*p);
12340 : : }
12341 : :
12342 : 326425 : return attributes;
12343 : : }
12344 : :
12345 : : /* Apply any attributes which had to be deferred until instantiation
12346 : : time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
12347 : : ARGS, COMPLAIN, IN_DECL are as tsubst. Returns true normally,
12348 : : false on error. */
12349 : :
12350 : : static bool
12351 : 623613143 : apply_late_template_attributes (tree *decl_p, tree attributes, int attr_flags,
12352 : : tree args, tsubst_flags_t complain, tree in_decl)
12353 : : {
12354 : 623613143 : tree t;
12355 : 623613143 : tree *p;
12356 : :
12357 : 623613143 : if (attributes == NULL_TREE)
12358 : : return true;
12359 : :
12360 : 26093482 : if (DECL_P (*decl_p))
12361 : : {
12362 : 26071590 : if (TREE_TYPE (*decl_p) == error_mark_node)
12363 : : return false;
12364 : 26071587 : p = &DECL_ATTRIBUTES (*decl_p);
12365 : : /* DECL_ATTRIBUTES comes from copy_node in tsubst_decl, and is identical
12366 : : to our attributes parameter. */
12367 : 26071587 : gcc_assert (*p == attributes);
12368 : : }
12369 : 21892 : else if (FUNC_OR_METHOD_TYPE_P (*decl_p))
12370 : : p = NULL;
12371 : : else
12372 : : {
12373 : 1505 : p = &TYPE_ATTRIBUTES (*decl_p);
12374 : : /* TYPE_ATTRIBUTES was set up (with abi_tag and may_alias) in
12375 : : lookup_template_class_1, and should be preserved. */
12376 : 1505 : gcc_assert (*p != attributes);
12377 : 1952 : while (*p)
12378 : 447 : p = &TREE_CHAIN (*p);
12379 : : }
12380 : :
12381 : : /* save_template_attributes puts the dependent attributes at the beginning of
12382 : : the list; find the non-dependent ones. */
12383 : 27378749 : for (t = attributes; t; t = TREE_CHAIN (t))
12384 : 26541577 : if (!ATTR_IS_DEPENDENT (t))
12385 : : break;
12386 : 26093479 : tree nondep = t;
12387 : :
12388 : : /* Apply any non-dependent attributes. */
12389 : 26093479 : if (p)
12390 : 26073092 : *p = nondep;
12391 : 20387 : else if (nondep)
12392 : 20352 : *decl_p = cp_build_type_attribute_variant (*decl_p, nondep);
12393 : :
12394 : 26093479 : if (nondep == attributes)
12395 : : return true;
12396 : :
12397 : : /* And then any dependent ones. */
12398 : 1285182 : tree late_attrs = NULL_TREE;
12399 : 1285182 : tree *q = &late_attrs;
12400 : 2570426 : for (t = attributes; t != nondep; t = TREE_CHAIN (t))
12401 : : {
12402 : 1285270 : *q = tsubst_attribute (t, decl_p, args, complain, in_decl);
12403 : 1285270 : if (*q == error_mark_node)
12404 : : return false;
12405 : 1285244 : if (*q == t)
12406 : : {
12407 : 1095227 : *q = copy_node (t);
12408 : 1095227 : TREE_CHAIN (*q) = NULL_TREE;
12409 : : }
12410 : 2570482 : while (*q)
12411 : 1285238 : q = &TREE_CHAIN (*q);
12412 : : }
12413 : :
12414 : : /* cplus_decl_attributes can add some attributes implicitly. For templates,
12415 : : those attributes should have been added already when those templates were
12416 : : parsed, and shouldn't be added based on from which context they are
12417 : : first time instantiated. */
12418 : 1285156 : auto o1 = make_temp_override (current_optimize_pragma, NULL_TREE);
12419 : 1285156 : auto o2 = make_temp_override (optimization_current_node,
12420 : 1285156 : optimization_default_node);
12421 : 1285156 : auto o3 = make_temp_override (current_target_pragma, NULL_TREE);
12422 : 1285156 : auto o4 = make_temp_override (scope_chain->omp_declare_target_attribute,
12423 : 1285156 : NULL);
12424 : 1285156 : auto o5 = make_temp_override (scope_chain->omp_begin_assumes, NULL);
12425 : :
12426 : 1285156 : cplus_decl_attributes (decl_p, late_attrs, attr_flags);
12427 : :
12428 : 1285156 : return true;
12429 : 1285156 : }
12430 : :
12431 : : /* The template TMPL is being instantiated with the template arguments TARGS.
12432 : : Perform the access checks that we deferred when parsing the template. */
12433 : :
12434 : : static void
12435 : 43105952 : perform_instantiation_time_access_checks (tree tmpl, tree targs)
12436 : : {
12437 : 43105952 : unsigned i;
12438 : 43105952 : deferred_access_check *chk;
12439 : :
12440 : 43105952 : if (!CLASS_TYPE_P (tmpl) && TREE_CODE (tmpl) != FUNCTION_DECL)
12441 : 43105952 : return;
12442 : :
12443 : 86211904 : if (vec<deferred_access_check, va_gc> *access_checks
12444 : 43105952 : = TI_DEFERRED_ACCESS_CHECKS (get_template_info (tmpl)))
12445 : 117 : FOR_EACH_VEC_ELT (*access_checks, i, chk)
12446 : : {
12447 : 63 : tree decl = chk->decl;
12448 : 63 : tree diag_decl = chk->diag_decl;
12449 : 63 : tree type_scope = TREE_TYPE (chk->binfo);
12450 : :
12451 : 63 : if (uses_template_parms (type_scope))
12452 : 12 : type_scope = tsubst (type_scope, targs, tf_error, NULL_TREE);
12453 : :
12454 : : /* Make access check error messages point to the location
12455 : : of the use of the typedef. */
12456 : 63 : iloc_sentinel ils (chk->loc);
12457 : 63 : perform_or_defer_access_check (TYPE_BINFO (type_scope),
12458 : : decl, diag_decl, tf_warning_or_error);
12459 : 63 : }
12460 : : }
12461 : :
12462 : : /* If the template T that we're about to instantiate contained errors at
12463 : : parse time that we downgraded into warnings or suppressed, diagnose the
12464 : : error now to render the TU ill-formed (if the TU has not already been
12465 : : deemed ill-formed by an earlier error). */
12466 : :
12467 : : static void
12468 : 66982708 : maybe_diagnose_erroneous_template (tree t)
12469 : : {
12470 : 66982708 : if (erroneous_templates && !(seen_error) ())
12471 : 1047 : if (location_t *error_loc = erroneous_templates->get (t))
12472 : : {
12473 : 12 : auto_diagnostic_group d;
12474 : 12 : location_t decl_loc = location_of (t);
12475 : 12 : error_at (decl_loc, "instantiating erroneous template");
12476 : 12 : inform (*error_loc, "first error appeared here");
12477 : 12 : }
12478 : 66982708 : }
12479 : :
12480 : : tree
12481 : 710778493 : instantiate_class_template (tree type)
12482 : : {
12483 : 710778493 : auto_timevar tv (TV_TEMPLATE_INST);
12484 : :
12485 : 710778493 : tree templ, args, pattern, t, member;
12486 : 710778493 : tree typedecl;
12487 : 710778493 : tree pbinfo;
12488 : 710778493 : tree base_list;
12489 : 710778493 : unsigned int saved_maximum_field_alignment;
12490 : 710778493 : tree fn_context;
12491 : :
12492 : 710778493 : if (type == error_mark_node)
12493 : : return error_mark_node;
12494 : :
12495 : 1416085132 : if (COMPLETE_OR_OPEN_TYPE_P (type)
12496 : 745037320 : || uses_template_parms (type))
12497 : 683501112 : return type;
12498 : :
12499 : : /* Figure out which template is being instantiated. */
12500 : 27277381 : templ = most_general_template (CLASSTYPE_TI_TEMPLATE (type));
12501 : 27277381 : gcc_assert (TREE_CODE (templ) == TEMPLATE_DECL);
12502 : :
12503 : : /* Mark the type as in the process of being defined. */
12504 : 27277381 : TYPE_BEING_DEFINED (type) = 1;
12505 : :
12506 : : /* We may be in the middle of deferred access check. Disable
12507 : : it now. */
12508 : 27277381 : deferring_access_check_sentinel acs (dk_no_deferred);
12509 : :
12510 : : /* Determine what specialization of the original template to
12511 : : instantiate. */
12512 : 27277381 : t = most_specialized_partial_spec (type, tf_warning_or_error);
12513 : 27277381 : if (t == error_mark_node)
12514 : : return error_mark_node;
12515 : 27277366 : else if (t)
12516 : : {
12517 : : /* This TYPE is actually an instantiation of a partial
12518 : : specialization. We replace the innermost set of ARGS with
12519 : : the arguments appropriate for substitution. For example,
12520 : : given:
12521 : :
12522 : : template <class T> struct S {};
12523 : : template <class T> struct S<T*> {};
12524 : :
12525 : : and supposing that we are instantiating S<int*>, ARGS will
12526 : : presently be {int*} -- but we need {int}. */
12527 : 4026840 : pattern = TREE_TYPE (TI_TEMPLATE (t));
12528 : 4026840 : args = TI_ARGS (t);
12529 : : }
12530 : : else
12531 : : {
12532 : 23250526 : pattern = TREE_TYPE (templ);
12533 : 23250526 : args = CLASSTYPE_TI_ARGS (type);
12534 : : }
12535 : :
12536 : : /* If the template we're instantiating is incomplete, then clearly
12537 : : there's nothing we can do. */
12538 : 27277366 : if (!COMPLETE_TYPE_P (pattern))
12539 : : {
12540 : : /* We can try again later. */
12541 : 632562 : TYPE_BEING_DEFINED (type) = 0;
12542 : 632562 : return type;
12543 : : }
12544 : :
12545 : : /* If we've recursively instantiated too many templates, stop. */
12546 : 26644804 : if (! push_tinst_level (type))
12547 : 0 : return type;
12548 : :
12549 : 30671546 : maybe_diagnose_erroneous_template (t ? TI_TEMPLATE (t) : templ);
12550 : :
12551 : 26644783 : int saved_unevaluated_operand = cp_unevaluated_operand;
12552 : 26644783 : int saved_inhibit_evaluation_warnings = c_inhibit_evaluation_warnings;
12553 : :
12554 : 26644783 : fn_context = decl_function_context (TYPE_MAIN_DECL (type));
12555 : : /* Also avoid push_to_top_level for a lambda in an NSDMI. */
12556 : 52699399 : if (!fn_context && LAMBDA_TYPE_P (type) && TYPE_CLASS_SCOPE_P (type))
12557 : 0 : fn_context = error_mark_node;
12558 : 26644783 : if (!fn_context)
12559 : 26115875 : push_to_top_level ();
12560 : : else
12561 : : {
12562 : 528908 : cp_unevaluated_operand = 0;
12563 : 528908 : c_inhibit_evaluation_warnings = 0;
12564 : : }
12565 : :
12566 : 26644783 : mark_template_arguments_used (templ, CLASSTYPE_TI_ARGS (type));
12567 : :
12568 : : /* Use #pragma pack from the template context. */
12569 : 26644783 : saved_maximum_field_alignment = maximum_field_alignment;
12570 : 26644783 : maximum_field_alignment = TYPE_PRECISION (pattern);
12571 : :
12572 : 26644783 : SET_CLASSTYPE_INTERFACE_UNKNOWN (type);
12573 : :
12574 : : /* Set the input location to the most specialized template definition.
12575 : : This is needed if tsubsting causes an error. */
12576 : 26644783 : typedecl = TYPE_MAIN_DECL (pattern);
12577 : 26644783 : input_location = DECL_SOURCE_LOCATION (TYPE_NAME (type)) =
12578 : 26644783 : DECL_SOURCE_LOCATION (typedecl);
12579 : :
12580 : 26644783 : set_instantiating_module (TYPE_NAME (type));
12581 : :
12582 : 26644783 : TYPE_PACKED (type) = TYPE_PACKED (pattern);
12583 : 26644783 : SET_TYPE_ALIGN (type, TYPE_ALIGN (pattern));
12584 : 26644783 : TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (pattern);
12585 : 26644783 : CLASSTYPE_NON_AGGREGATE (type) = CLASSTYPE_NON_AGGREGATE (pattern);
12586 : 26644783 : if (ANON_AGGR_TYPE_P (pattern))
12587 : 58160 : SET_ANON_AGGR_TYPE_P (type);
12588 : 26644783 : if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern))
12589 : : {
12590 : 26372493 : CLASSTYPE_VISIBILITY_SPECIFIED (type) = 1;
12591 : 26372493 : CLASSTYPE_VISIBILITY (type) = CLASSTYPE_VISIBILITY (pattern);
12592 : : /* Adjust visibility for template arguments. */
12593 : 26372493 : determine_visibility (TYPE_MAIN_DECL (type));
12594 : : }
12595 : 26644783 : if (CLASS_TYPE_P (type))
12596 : 26644783 : CLASSTYPE_FINAL (type) = CLASSTYPE_FINAL (pattern);
12597 : :
12598 : 26644783 : pbinfo = TYPE_BINFO (pattern);
12599 : :
12600 : : /* We should never instantiate a nested class before its enclosing
12601 : : class; we need to look up the nested class by name before we can
12602 : : instantiate it, and that lookup should instantiate the enclosing
12603 : : class. */
12604 : 26644783 : gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern))
12605 : : || COMPLETE_OR_OPEN_TYPE_P (TYPE_CONTEXT (type)));
12606 : :
12607 : 26644783 : base_list = NULL_TREE;
12608 : : /* Defer access checking while we substitute into the types named in
12609 : : the base-clause. */
12610 : 26644783 : push_deferring_access_checks (dk_deferred);
12611 : 26644783 : if (BINFO_N_BASE_BINFOS (pbinfo))
12612 : : {
12613 : : tree pbase_binfo;
12614 : : int i;
12615 : :
12616 : : /* Substitute into each of the bases to determine the actual
12617 : : basetypes. */
12618 : 32400758 : for (i = 0; BINFO_BASE_ITERATE (pbinfo, i, pbase_binfo); i++)
12619 : : {
12620 : 16434640 : tree base;
12621 : 16434640 : tree access = BINFO_BASE_ACCESS (pbinfo, i);
12622 : 16434640 : tree expanded_bases = NULL_TREE;
12623 : 16434640 : int idx, len = 1;
12624 : :
12625 : 16434640 : if (PACK_EXPANSION_P (BINFO_TYPE (pbase_binfo)))
12626 : : {
12627 : 365 : expanded_bases =
12628 : 365 : tsubst_pack_expansion (BINFO_TYPE (pbase_binfo),
12629 : : args, tf_error, NULL_TREE);
12630 : 365 : if (expanded_bases == error_mark_node)
12631 : 0 : continue;
12632 : :
12633 : 365 : len = TREE_VEC_LENGTH (expanded_bases);
12634 : : }
12635 : :
12636 : 32869771 : for (idx = 0; idx < len; idx++)
12637 : : {
12638 : 16435131 : if (expanded_bases)
12639 : : /* Extract the already-expanded base class. */
12640 : 856 : base = TREE_VEC_ELT (expanded_bases, idx);
12641 : : else
12642 : : /* Substitute to figure out the base class. */
12643 : 16434275 : base = tsubst (BINFO_TYPE (pbase_binfo), args, tf_error,
12644 : : NULL_TREE);
12645 : :
12646 : 16435131 : if (base == error_mark_node)
12647 : 32 : continue;
12648 : :
12649 : 16435099 : base_list = tree_cons (access, base, base_list);
12650 : 16435099 : if (BINFO_VIRTUAL_P (pbase_binfo))
12651 : 42548 : TREE_TYPE (base_list) = integer_type_node;
12652 : : }
12653 : : }
12654 : :
12655 : : /* The list is now in reverse order; correct that. */
12656 : 15966118 : base_list = nreverse (base_list);
12657 : : }
12658 : : /* Now call xref_basetypes to set up all the base-class
12659 : : information. */
12660 : 26644783 : xref_basetypes (type, base_list);
12661 : :
12662 : 26644783 : apply_late_template_attributes (&type, TYPE_ATTRIBUTES (pattern),
12663 : : (int) ATTR_FLAG_TYPE_IN_PLACE,
12664 : : args, tf_error, NULL_TREE);
12665 : 26644783 : fixup_attribute_variants (type);
12666 : :
12667 : : /* Now that our base classes are set up, enter the scope of the
12668 : : class, so that name lookups into base classes, etc. will work
12669 : : correctly. This is precisely analogous to what we do in
12670 : : begin_class_definition when defining an ordinary non-template
12671 : : class, except we also need to push the enclosing classes. */
12672 : 26644783 : push_nested_class (type);
12673 : :
12674 : : /* Now check accessibility of the types named in its base-clause,
12675 : : relative to the scope of the class. */
12676 : 26644783 : pop_to_parent_deferring_access_checks ();
12677 : :
12678 : : /* A vector to hold members marked with attribute used. */
12679 : 26644783 : auto_vec<tree> used;
12680 : :
12681 : : /* Now members are processed in the order of declaration. */
12682 : 26644783 : for (member = CLASSTYPE_DECL_LIST (pattern);
12683 : 193658537 : member; member = TREE_CHAIN (member))
12684 : : {
12685 : 167016505 : tree t = TREE_VALUE (member);
12686 : :
12687 : 167016505 : if (TREE_PURPOSE (member))
12688 : : {
12689 : 164456349 : if (TYPE_P (t))
12690 : : {
12691 : 3139780 : if (LAMBDA_TYPE_P (t))
12692 : : /* A closure type for a lambda in an NSDMI or default argument.
12693 : : Ignore it; it will be regenerated when needed. */
12694 : 50 : continue;
12695 : :
12696 : : /* If the member is a class template, we've
12697 : : already substituted its type. */
12698 : 1436712 : if (CLASS_TYPE_P (t)
12699 : 3199477 : && CLASSTYPE_IS_TEMPLATE (t))
12700 : 690482 : continue;
12701 : :
12702 : 1072283 : tree newtag = tsubst (t, args, tf_error, NULL_TREE);
12703 : 1072283 : if (newtag == error_mark_node)
12704 : 0 : continue;
12705 : :
12706 : 1072283 : if (TREE_CODE (newtag) != ENUMERAL_TYPE)
12707 : : {
12708 : 746230 : tree name = TYPE_IDENTIFIER (t);
12709 : :
12710 : : /* Now, install the tag. We don't use pushtag
12711 : : because that does too much work -- creating an
12712 : : implicit typedef, which we've already done. */
12713 : 746230 : set_identifier_type_value (name, TYPE_NAME (newtag));
12714 : 746230 : maybe_add_class_template_decl_list (type, newtag, false);
12715 : 746230 : TREE_PUBLIC (TYPE_NAME (newtag)) = true;
12716 : 746230 : determine_visibility (TYPE_NAME (newtag));
12717 : : }
12718 : : }
12719 : 162693534 : else if (DECL_DECLARES_FUNCTION_P (t))
12720 : : {
12721 : 87207364 : tree r;
12722 : :
12723 : 87207364 : if (TREE_CODE (t) == TEMPLATE_DECL)
12724 : 16546402 : ++processing_template_decl;
12725 : 87207364 : r = tsubst (t, args, tf_error, NULL_TREE);
12726 : 87207364 : if (TREE_CODE (t) == TEMPLATE_DECL)
12727 : 16546402 : --processing_template_decl;
12728 : :
12729 : 87207364 : set_current_access_from_decl (r);
12730 : 87207364 : finish_member_declaration (r);
12731 : : /* Instantiate members marked with attribute used. */
12732 : 87207364 : if (r != error_mark_node && DECL_PRESERVE_P (r))
12733 : 24 : used.safe_push (r);
12734 : 87207364 : if (TREE_CODE (r) == FUNCTION_DECL
12735 : 87207364 : && DECL_OMP_DECLARE_REDUCTION_P (r))
12736 : 134 : cp_check_omp_declare_reduction (r);
12737 : : }
12738 : 75486170 : else if ((DECL_CLASS_TEMPLATE_P (t) || DECL_IMPLICIT_TYPEDEF_P (t))
12739 : 78626015 : && LAMBDA_TYPE_P (TREE_TYPE (t)))
12740 : : /* A closure type for a lambda in an NSDMI or default argument.
12741 : : Ignore it; it will be regenerated when needed. */;
12742 : : else
12743 : : {
12744 : : /* Build new TYPE_FIELDS. */
12745 : 75486110 : if (TREE_CODE (t) == STATIC_ASSERT)
12746 : 3721746 : tsubst_stmt (t, args, tf_warning_or_error, NULL_TREE);
12747 : 71764364 : else if (TREE_CODE (t) != CONST_DECL)
12748 : : {
12749 : 71764364 : tree r;
12750 : 71764364 : tree vec = NULL_TREE;
12751 : 71764364 : int len = 1;
12752 : :
12753 : 71764364 : gcc_checking_assert (TREE_CODE (t) != CONST_DECL);
12754 : : /* The file and line for this declaration, to
12755 : : assist in error message reporting. Since we
12756 : : called push_tinst_level above, we don't need to
12757 : : restore these. */
12758 : 71764364 : input_location = DECL_SOURCE_LOCATION (t);
12759 : :
12760 : 71764364 : if (TREE_CODE (t) == TEMPLATE_DECL)
12761 : 2866308 : ++processing_template_decl;
12762 : 71764364 : r = tsubst (t, args, tf_warning_or_error, NULL_TREE);
12763 : 71764313 : if (TREE_CODE (t) == TEMPLATE_DECL)
12764 : 2866308 : --processing_template_decl;
12765 : :
12766 : 71764313 : if (TREE_CODE (r) == TREE_VEC)
12767 : : {
12768 : : /* A capture pack became multiple fields. */
12769 : 270 : vec = r;
12770 : 270 : len = TREE_VEC_LENGTH (vec);
12771 : : }
12772 : :
12773 : 143526333 : for (int i = 0; i < len; ++i)
12774 : : {
12775 : 71764720 : if (vec)
12776 : 677 : r = TREE_VEC_ELT (vec, i);
12777 : 71764720 : if (VAR_P (r))
12778 : : {
12779 : : /* In [temp.inst]:
12780 : :
12781 : : [t]he initialization (and any associated
12782 : : side-effects) of a static data member does
12783 : : not occur unless the static data member is
12784 : : itself used in a way that requires the
12785 : : definition of the static data member to
12786 : : exist.
12787 : :
12788 : : Therefore, we do not substitute into the
12789 : : initialized for the static data member here. */
12790 : 2413177 : finish_static_data_member_decl
12791 : 2413177 : (r,
12792 : : /*init=*/NULL_TREE,
12793 : : /*init_const_expr_p=*/false,
12794 : : /*asmspec_tree=*/NULL_TREE,
12795 : : /*flags=*/0);
12796 : : /* Instantiate members marked with attribute used. */
12797 : 2413177 : if (r != error_mark_node && DECL_PRESERVE_P (r))
12798 : 6 : used.safe_push (r);
12799 : : }
12800 : 69351543 : else if (TREE_CODE (r) == FIELD_DECL)
12801 : : {
12802 : : /* Determine whether R has a valid type and can be
12803 : : completed later. If R is invalid, then its type
12804 : : is replaced by error_mark_node. */
12805 : 6104020 : tree rtype = TREE_TYPE (r);
12806 : 6104020 : if (can_complete_type_without_circularity (rtype))
12807 : 6104011 : complete_type (rtype);
12808 : :
12809 : 6101320 : if (!complete_or_array_type_p (rtype))
12810 : : {
12811 : : /* If R's type couldn't be completed and
12812 : : it isn't a flexible array member (whose
12813 : : type is incomplete by definition) give
12814 : : an error. */
12815 : 27 : cxx_incomplete_type_error (r, rtype);
12816 : 27 : TREE_TYPE (r) = error_mark_node;
12817 : : }
12818 : 6101293 : else if (TREE_CODE (rtype) == ARRAY_TYPE
12819 : 159582 : && TYPE_DOMAIN (rtype) == NULL_TREE
12820 : 6101293 : && (TREE_CODE (type) == UNION_TYPE
12821 : 47 : || TREE_CODE (type) == QUAL_UNION_TYPE))
12822 : : {
12823 : 4 : error ("flexible array member %qD in union", r);
12824 : 4 : TREE_TYPE (r) = error_mark_node;
12825 : : }
12826 : 6101289 : else if (!verify_type_context (input_location,
12827 : : TCTX_FIELD, rtype))
12828 : 0 : TREE_TYPE (r) = error_mark_node;
12829 : : }
12830 : :
12831 : : /* If it is a TYPE_DECL for a class-scoped
12832 : : ENUMERAL_TYPE, such a thing will already have
12833 : : been added to the field list by tsubst_enum
12834 : : in finish_member_declaration case above. */
12835 : 71762020 : if (!(TREE_CODE (r) == TYPE_DECL
12836 : 59080934 : && TREE_CODE (TREE_TYPE (r)) == ENUMERAL_TYPE
12837 : 478998 : && DECL_ARTIFICIAL (r)))
12838 : : {
12839 : 71435967 : set_current_access_from_decl (r);
12840 : 71435967 : finish_member_declaration (r);
12841 : : }
12842 : : }
12843 : : }
12844 : : }
12845 : : }
12846 : : else
12847 : : {
12848 : 2560156 : if (TREE_CODE (t) == TU_LOCAL_ENTITY)
12849 : : /* Ignore. */;
12850 : 2160877 : else if (TYPE_P (t) || DECL_CLASS_TEMPLATE_P (t)
12851 : 4264021 : || DECL_TEMPLATE_TEMPLATE_PARM_P (t))
12852 : : {
12853 : : /* Build new CLASSTYPE_FRIEND_CLASSES. */
12854 : :
12855 : 856210 : tree friend_type = t;
12856 : 856210 : if (TREE_CODE (friend_type) == TEMPLATE_DECL)
12857 : : {
12858 : : /* template <class T> friend class C; */
12859 : 456973 : friend_type = tsubst_friend_class (friend_type, args);
12860 : : }
12861 : 399237 : else if (TREE_CODE (friend_type) == UNBOUND_CLASS_TEMPLATE)
12862 : : {
12863 : : /* template <class T> friend class C::D; */
12864 : 12 : friend_type = tsubst (friend_type, args,
12865 : : tf_warning_or_error, NULL_TREE);
12866 : 12 : if (TREE_CODE (friend_type) == TEMPLATE_DECL)
12867 : 9 : friend_type = TREE_TYPE (friend_type);
12868 : : }
12869 : 399225 : else if (TREE_CODE (friend_type) == TYPENAME_TYPE
12870 : 399225 : || TREE_CODE (friend_type) == TEMPLATE_TYPE_PARM)
12871 : : {
12872 : : /* This could be either
12873 : :
12874 : : friend class T::C;
12875 : :
12876 : : when dependent_type_p is false or
12877 : :
12878 : : template <class U> friend class T::C;
12879 : :
12880 : : otherwise. */
12881 : : /* Bump processing_template_decl in case this is something like
12882 : : template <class T> friend struct A<T>::B. */
12883 : 2166 : ++processing_template_decl;
12884 : 2166 : friend_type = tsubst (friend_type, args,
12885 : : tf_warning_or_error, NULL_TREE);
12886 : 2166 : --processing_template_decl;
12887 : : }
12888 : 397059 : else if (PACK_EXPANSION_P (friend_type))
12889 : : {
12890 : 24 : friend_type = tsubst_pack_expansion (friend_type, args,
12891 : : tf_warning_or_error,
12892 : : NULL_TREE);
12893 : 24 : if (friend_type != error_mark_node)
12894 : : {
12895 : 24 : unsigned int len = TREE_VEC_LENGTH (friend_type);
12896 : 63 : for (unsigned int idx = 0; idx < len; ++idx)
12897 : 39 : if (TREE_VEC_ELT (friend_type, idx) != error_mark_node)
12898 : 39 : make_friend_class (type,
12899 : 39 : TREE_VEC_ELT (friend_type, idx),
12900 : : /*complain=*/false);
12901 : : }
12902 : 24 : friend_type = error_mark_node;
12903 : : }
12904 : 397035 : else if (uses_template_parms (friend_type))
12905 : : /* friend class C<T>; */
12906 : 374046 : friend_type = tsubst (friend_type, args,
12907 : : tf_warning_or_error, NULL_TREE);
12908 : :
12909 : : /* Otherwise it's
12910 : :
12911 : : friend class C;
12912 : :
12913 : : where C is already declared or
12914 : :
12915 : : friend class C<int>;
12916 : :
12917 : : We don't have to do anything in these cases. */
12918 : :
12919 : 856210 : if (friend_type != error_mark_node)
12920 : 856166 : make_friend_class (type, friend_type, /*complain=*/false);
12921 : : }
12922 : : else
12923 : : {
12924 : : /* Build new DECL_FRIENDLIST. */
12925 : 1703904 : tree r;
12926 : :
12927 : : /* The file and line for this declaration, to
12928 : : assist in error message reporting. Since we
12929 : : called push_tinst_level above, we don't need to
12930 : : restore these. */
12931 : 1703904 : input_location = DECL_SOURCE_LOCATION (t);
12932 : :
12933 : 1703904 : if (TREE_CODE (t) == TEMPLATE_DECL)
12934 : : {
12935 : 1024273 : ++processing_template_decl;
12936 : 1024273 : push_deferring_access_checks (dk_no_check);
12937 : : }
12938 : :
12939 : 1703904 : r = tsubst_friend_function (t, args);
12940 : 1703904 : add_friend (type, r, /*complain=*/false);
12941 : 1703904 : if (TREE_CODE (t) == TEMPLATE_DECL)
12942 : : {
12943 : 1024273 : pop_deferring_access_checks ();
12944 : 1024273 : --processing_template_decl;
12945 : : }
12946 : : }
12947 : : }
12948 : : }
12949 : :
12950 : 26642032 : if (fn_context)
12951 : : {
12952 : : /* Restore these before substituting into the lambda capture
12953 : : initializers. */
12954 : 528908 : cp_unevaluated_operand = saved_unevaluated_operand;
12955 : 528908 : c_inhibit_evaluation_warnings = saved_inhibit_evaluation_warnings;
12956 : : }
12957 : :
12958 : : /* Set the file and line number information to whatever is given for
12959 : : the class itself. This puts error messages involving generated
12960 : : implicit functions at a predictable point, and the same point
12961 : : that would be used for non-template classes. */
12962 : 26642032 : input_location = DECL_SOURCE_LOCATION (typedecl);
12963 : :
12964 : 26642032 : unreverse_member_declarations (type);
12965 : 26642032 : finish_struct_1 (type);
12966 : 26642032 : TYPE_BEING_DEFINED (type) = 0;
12967 : :
12968 : : /* Remember if instantiating this class ran into errors, so we can avoid
12969 : : instantiating member functions in limit_bad_template_recursion. We set
12970 : : this flag even if the problem was in another instantiation triggered by
12971 : : this one, as that will likely also cause trouble for member functions. */
12972 : 26642032 : if (errorcount + sorrycount > current_tinst_level->errors)
12973 : 1068 : CLASSTYPE_ERRONEOUS (type) = true;
12974 : :
12975 : : /* We don't instantiate default arguments for member functions. 14.7.1:
12976 : :
12977 : : The implicit instantiation of a class template specialization causes
12978 : : the implicit instantiation of the declarations, but not of the
12979 : : definitions or default arguments, of the class member functions,
12980 : : member classes, static data members and member templates.... */
12981 : :
12982 : 26642032 : perform_instantiation_time_access_checks (pattern, args);
12983 : 26642032 : perform_deferred_access_checks (tf_warning_or_error);
12984 : :
12985 : : /* Now that we've gone through all the members, instantiate those
12986 : : marked with attribute used. We must do this in the context of
12987 : : the class -- not the context we pushed from, as that might be
12988 : : inside a template and change the behaviour of mark_used. */
12989 : 26642116 : for (tree x : used)
12990 : 30 : mark_used (x);
12991 : :
12992 : 26642032 : pop_nested_class ();
12993 : 26642032 : maximum_field_alignment = saved_maximum_field_alignment;
12994 : 26642032 : if (!fn_context)
12995 : 26113124 : pop_from_top_level ();
12996 : 26642032 : pop_tinst_level ();
12997 : :
12998 : : /* The vtable for a template class can be emitted in any translation
12999 : : unit in which the class is instantiated. When there is no key
13000 : : method, however, finish_struct_1 will already have added TYPE to
13001 : : the keyed_classes. */
13002 : 26642032 : if (TYPE_CONTAINS_VPTR_P (type) && CLASSTYPE_KEY_METHOD (type))
13003 : 0 : vec_safe_push (keyed_classes, type);
13004 : :
13005 : 26642032 : return type;
13006 : 737417753 : }
13007 : :
13008 : : tree
13009 : 2482478176 : tsubst_template_arg (tree t, tree args, tsubst_flags_t complain, tree in_decl)
13010 : : {
13011 : 2482478176 : tree r;
13012 : :
13013 : 2482478176 : if (!t)
13014 : : r = t;
13015 : 2454373682 : else if (TYPE_P (t))
13016 : 2243733846 : r = tsubst (t, args, complain, in_decl);
13017 : : else
13018 : : {
13019 : 210639836 : if (!(complain & tf_warning))
13020 : 142645476 : ++c_inhibit_evaluation_warnings;
13021 : 210639836 : r = tsubst_expr (t, args, complain, in_decl);
13022 : 210639800 : if (!(complain & tf_warning))
13023 : 142645446 : --c_inhibit_evaluation_warnings;
13024 : : }
13025 : :
13026 : 2482478140 : return r;
13027 : : }
13028 : :
13029 : : /* Given a function parameter pack TMPL_PARM and some function parameters
13030 : : instantiated from it at *SPEC_P, return a NONTYPE_ARGUMENT_PACK of them
13031 : : and set *SPEC_P to point at the next point in the list. */
13032 : :
13033 : : tree
13034 : 548379 : extract_fnparm_pack (tree tmpl_parm, tree *spec_p)
13035 : : {
13036 : : /* Collect all of the extra "packed" parameters into an
13037 : : argument pack. */
13038 : 548379 : tree argpack;
13039 : 548379 : tree spec_parm = *spec_p;
13040 : 548379 : int len;
13041 : :
13042 : 890066 : for (len = 0; spec_parm; ++len, spec_parm = TREE_CHAIN (spec_parm))
13043 : 341836 : if (tmpl_parm
13044 : 341836 : && !function_parameter_expanded_from_pack_p (spec_parm, tmpl_parm))
13045 : : break;
13046 : :
13047 : 548379 : spec_parm = *spec_p;
13048 : 548379 : if (len == 1 && DECL_PACK_P (spec_parm))
13049 : : {
13050 : : /* The instantiation is still a parameter pack; don't wrap it in a
13051 : : NONTYPE_ARGUMENT_PACK. */
13052 : 1186 : argpack = spec_parm;
13053 : 1186 : spec_parm = DECL_CHAIN (spec_parm);
13054 : : }
13055 : : else
13056 : : {
13057 : : /* Fill in PARMVEC with all of the parameters. */
13058 : 547193 : tree parmvec = make_tree_vec (len);
13059 : 547193 : argpack = make_node (NONTYPE_ARGUMENT_PACK);
13060 : 887694 : for (int i = 0; i < len; i++)
13061 : : {
13062 : 340501 : tree elt = spec_parm;
13063 : 340501 : if (DECL_PACK_P (elt))
13064 : 0 : elt = make_pack_expansion (elt);
13065 : 340501 : TREE_VEC_ELT (parmvec, i) = elt;
13066 : 340501 : spec_parm = DECL_CHAIN (spec_parm);
13067 : : }
13068 : :
13069 : : /* Build the argument packs. */
13070 : 547193 : ARGUMENT_PACK_ARGS (argpack) = parmvec;
13071 : : }
13072 : 548379 : *spec_p = spec_parm;
13073 : :
13074 : 548379 : return argpack;
13075 : : }
13076 : :
13077 : : /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
13078 : : NONTYPE_ARGUMENT_PACK. */
13079 : :
13080 : : static tree
13081 : 4585 : make_fnparm_pack (tree spec_parm)
13082 : : {
13083 : 0 : return extract_fnparm_pack (NULL_TREE, &spec_parm);
13084 : : }
13085 : :
13086 : : /* Return 1 if the Ith element of the argument pack ARG_PACK is a
13087 : : pack expansion with no extra args, 2 if it has extra args, or 0
13088 : : if it is not a pack expansion. */
13089 : :
13090 : : static int
13091 : 20982364 : argument_pack_element_is_expansion_p (tree arg_pack, int i)
13092 : : {
13093 : 20982364 : if (TREE_CODE (arg_pack) == ARGUMENT_PACK_SELECT)
13094 : : /* We're being called before this happens in tsubst_pack_expansion. */
13095 : 0 : arg_pack = ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack);
13096 : 20982364 : tree vec = ARGUMENT_PACK_ARGS (arg_pack);
13097 : 20982364 : if (i >= TREE_VEC_LENGTH (vec))
13098 : : return 0;
13099 : 20982364 : tree elt = TREE_VEC_ELT (vec, i);
13100 : 20982364 : if (DECL_P (elt))
13101 : : /* A decl pack is itself an expansion. */
13102 : 693437 : elt = TREE_TYPE (elt);
13103 : 20982364 : if (!PACK_EXPANSION_P (elt))
13104 : : return 0;
13105 : 500339 : if (PACK_EXPANSION_EXTRA_ARGS (elt))
13106 : 3 : return 2;
13107 : : return 1;
13108 : : }
13109 : :
13110 : :
13111 : : /* Creates and return an ARGUMENT_PACK_SELECT tree node. */
13112 : :
13113 : : static tree
13114 : 4695353 : make_argument_pack_select (tree arg_pack, unsigned index)
13115 : : {
13116 : 4695353 : tree aps = make_node (ARGUMENT_PACK_SELECT);
13117 : :
13118 : 4695353 : ARGUMENT_PACK_SELECT_FROM_PACK (aps) = arg_pack;
13119 : 4695353 : ARGUMENT_PACK_SELECT_INDEX (aps) = index;
13120 : :
13121 : 4695353 : return aps;
13122 : : }
13123 : :
13124 : : /* This is a subroutine of tsubst_pack_expansion.
13125 : :
13126 : : It returns TRUE if we need to use the PACK_EXPANSION_EXTRA_ARGS
13127 : : mechanism to store the (non complete list of) arguments of the
13128 : : substitution and return a non substituted pack expansion, in order
13129 : : to wait for when we have enough arguments to really perform the
13130 : : substitution. */
13131 : :
13132 : : static bool
13133 : 16657682 : use_pack_expansion_extra_args_p (tree t,
13134 : : tree parm_packs,
13135 : : int arg_pack_len,
13136 : : bool has_empty_arg)
13137 : : {
13138 : 16657682 : if (has_empty_arg
13139 : 16657682 : && PACK_EXPANSION_FORCE_EXTRA_ARGS_P (t))
13140 : : return true;
13141 : :
13142 : : /* If one pack has an expansion and another pack has a normal
13143 : : argument or if one pack has an empty argument and an another
13144 : : one hasn't then tsubst_pack_expansion cannot perform the
13145 : : substitution and need to fall back on the
13146 : : PACK_EXPANSION_EXTRA mechanism. */
13147 : 16657674 : if (parm_packs == NULL_TREE)
13148 : : return false;
13149 : 5547881 : else if (has_empty_arg)
13150 : : {
13151 : : /* If all the actual packs are pack expansions, we can still
13152 : : subsitute directly. */
13153 : 61725 : for (tree p = parm_packs; p; p = TREE_CHAIN (p))
13154 : : {
13155 : 61725 : tree a = TREE_VALUE (p);
13156 : 61725 : if (TREE_CODE (a) == ARGUMENT_PACK_SELECT)
13157 : 0 : a = ARGUMENT_PACK_SELECT_FROM_PACK (a);
13158 : 61725 : a = ARGUMENT_PACK_ARGS (a);
13159 : 61725 : if (TREE_VEC_LENGTH (a) == 1)
13160 : 1303 : a = TREE_VEC_ELT (a, 0);
13161 : 61725 : if (PACK_EXPANSION_P (a))
13162 : 0 : continue;
13163 : : return true;
13164 : : }
13165 : : return false;
13166 : : }
13167 : :
13168 : 16179763 : for (int i = 0 ; i < arg_pack_len; ++i)
13169 : : {
13170 : : bool has_expansion_arg = false;
13171 : : bool has_non_expansion_arg = false;
13172 : 11136811 : for (tree parm_pack = parm_packs;
13173 : 21830421 : parm_pack;
13174 : 11136811 : parm_pack = TREE_CHAIN (parm_pack))
13175 : : {
13176 : 11136814 : tree arg = TREE_VALUE (parm_pack);
13177 : :
13178 : 11136814 : int exp = argument_pack_element_is_expansion_p (arg, i);
13179 : 11136814 : if (exp == 2)
13180 : : /* We can't substitute a pack expansion with extra args into
13181 : : our pattern. */
13182 : : return true;
13183 : 11136811 : else if (exp)
13184 : : has_expansion_arg = true;
13185 : : else
13186 : 10886643 : has_non_expansion_arg = true;
13187 : : }
13188 : :
13189 : 10693607 : if (has_expansion_arg && has_non_expansion_arg)
13190 : : {
13191 : 0 : gcc_checking_assert (false);
13192 : : return true;
13193 : : }
13194 : : }
13195 : : return false;
13196 : : }
13197 : :
13198 : : /* [temp.variadic]/6 says that:
13199 : :
13200 : : The instantiation of a pack expansion [...]
13201 : : produces a list E1,E2, ..., En, where N is the number of elements
13202 : : in the pack expansion parameters.
13203 : :
13204 : : This subroutine of tsubst_pack_expansion produces one of these Ei.
13205 : :
13206 : : PATTERN is the pattern of the pack expansion. PARM_PACKS is a
13207 : : TREE_LIST in which each TREE_PURPOSE is a parameter pack of
13208 : : PATTERN, and each TREE_VALUE is its corresponding argument pack.
13209 : : INDEX is the index 'i' of the element Ei to produce. ARGS,
13210 : : COMPLAIN, and IN_DECL are the same parameters as for the
13211 : : tsubst_pack_expansion function.
13212 : :
13213 : : The function returns the resulting Ei upon successful completion,
13214 : : or error_mark_node.
13215 : :
13216 : : Note that this function possibly modifies the ARGS parameter, so
13217 : : it's the responsibility of the caller to restore it. */
13218 : :
13219 : : static tree
13220 : 9402346 : gen_elem_of_pack_expansion_instantiation (tree pattern,
13221 : : tree parm_packs,
13222 : : unsigned index,
13223 : : tree args /* This parm gets
13224 : : modified. */,
13225 : : tsubst_flags_t complain,
13226 : : tree in_decl)
13227 : : {
13228 : 9402346 : tree t;
13229 : 9402346 : bool ith_elem_is_expansion = false;
13230 : :
13231 : : /* For each parameter pack, change the substitution of the parameter
13232 : : pack to the ith argument in its argument pack, then expand the
13233 : : pattern. */
13234 : 19247896 : for (tree pack = parm_packs; pack; pack = TREE_CHAIN (pack))
13235 : : {
13236 : 9845550 : tree parm = TREE_PURPOSE (pack);
13237 : 9845550 : tree arg_pack = TREE_VALUE (pack);
13238 : 9845550 : tree aps; /* instance of ARGUMENT_PACK_SELECT. */
13239 : :
13240 : 19691100 : ith_elem_is_expansion |=
13241 : 9845550 : argument_pack_element_is_expansion_p (arg_pack, index);
13242 : :
13243 : : /* Select the Ith argument from the pack. */
13244 : 9845550 : if (TREE_CODE (parm) == PARM_DECL
13245 : 9499057 : || VAR_P (parm)
13246 : 9498981 : || TREE_CODE (parm) == FIELD_DECL)
13247 : : {
13248 : 346569 : if (index == 0)
13249 : : {
13250 : 267906 : aps = make_argument_pack_select (arg_pack, index);
13251 : 267906 : if (!mark_used (parm, complain) && !(complain & tf_error))
13252 : 0 : return error_mark_node;
13253 : 267906 : register_local_specialization (aps, parm);
13254 : : }
13255 : : else
13256 : 78663 : aps = retrieve_local_specialization (parm);
13257 : : }
13258 : : else
13259 : : {
13260 : 9498981 : int idx, level;
13261 : 9498981 : template_parm_level_and_index (parm, &level, &idx);
13262 : :
13263 : 9498981 : if (index == 0)
13264 : : {
13265 : 4427447 : aps = make_argument_pack_select (arg_pack, index);
13266 : : /* Update the corresponding argument. */
13267 : 8854894 : TMPL_ARG (args, level, idx) = aps;
13268 : : }
13269 : : else
13270 : : /* Re-use the ARGUMENT_PACK_SELECT. */
13271 : 10143068 : aps = TMPL_ARG (args, level, idx);
13272 : : }
13273 : 9845550 : ARGUMENT_PACK_SELECT_INDEX (aps) = index;
13274 : : }
13275 : :
13276 : : /* Substitute into the PATTERN with the (possibly altered)
13277 : : arguments. */
13278 : 9402346 : if (pattern == in_decl)
13279 : : /* Expanding a fixed parameter pack from
13280 : : coerce_template_parameter_pack. */
13281 : 83 : t = tsubst_decl (pattern, args, complain);
13282 : 9402263 : else if (pattern == error_mark_node)
13283 : : t = error_mark_node;
13284 : 9402260 : else if (!TYPE_P (pattern))
13285 : 997222 : t = tsubst_expr (pattern, args, complain, in_decl);
13286 : : else
13287 : : {
13288 : 8405038 : t = tsubst (pattern, args, complain, in_decl);
13289 : 8405038 : if (is_auto (t) && !ith_elem_is_expansion)
13290 : : /* When expanding the fake auto... pack expansion from add_capture, we
13291 : : need to mark that the expansion is no longer a pack. */
13292 : 34 : TEMPLATE_TYPE_PARAMETER_PACK (t) = false;
13293 : : }
13294 : :
13295 : : /* If the Ith argument pack element is a pack expansion, then
13296 : : the Ith element resulting from the substituting is going to
13297 : : be a pack expansion as well. */
13298 : 9402346 : if (ith_elem_is_expansion)
13299 : 227074 : t = make_pack_expansion (t, complain);
13300 : :
13301 : : return t;
13302 : : }
13303 : :
13304 : : /* When the unexpanded parameter pack in a fold expression expands to an empty
13305 : : sequence, the value of the expression is as follows; the program is
13306 : : ill-formed if the operator is not listed in this table.
13307 : :
13308 : : && true
13309 : : || false
13310 : : , void() */
13311 : :
13312 : : tree
13313 : 41193 : expand_empty_fold (tree t, tsubst_flags_t complain)
13314 : : {
13315 : 41193 : tree_code code = (tree_code)TREE_INT_CST_LOW (TREE_OPERAND (t, 0));
13316 : 41193 : if (!FOLD_EXPR_MODIFY_P (t))
13317 : 41160 : switch (code)
13318 : : {
13319 : 41086 : case TRUTH_ANDIF_EXPR:
13320 : 41086 : return boolean_true_node;
13321 : 11 : case TRUTH_ORIF_EXPR:
13322 : 11 : return boolean_false_node;
13323 : 9 : case COMPOUND_EXPR:
13324 : 9 : return void_node;
13325 : : default:
13326 : : break;
13327 : : }
13328 : :
13329 : 87 : if (complain & tf_error)
13330 : 87 : error_at (location_of (t),
13331 : : "fold of empty expansion over %O", code);
13332 : 87 : return error_mark_node;
13333 : : }
13334 : :
13335 : : /* Given a fold-expression T and a current LEFT and RIGHT operand,
13336 : : form an expression that combines the two terms using the
13337 : : operator of T. */
13338 : :
13339 : : static tree
13340 : 241163 : fold_expression (tree t, tree left, tree right, tsubst_flags_t complain)
13341 : : {
13342 : 241163 : tree_code code = FOLD_EXPR_OP (t);
13343 : :
13344 : 241163 : tree lookups = templated_operator_saved_lookups (t);
13345 : :
13346 : : // Handle compound assignment operators.
13347 : 241163 : if (FOLD_EXPR_MODIFY_P (t))
13348 : 516 : return build_x_modify_expr (input_location, left, code, right,
13349 : : lookups, complain);
13350 : :
13351 : 240647 : warning_sentinel s(warn_parentheses);
13352 : 240647 : switch (code)
13353 : : {
13354 : 929 : case COMPOUND_EXPR:
13355 : 929 : return build_x_compound_expr (input_location, left, right,
13356 : 929 : lookups, complain);
13357 : 239718 : default:
13358 : 239718 : return build_x_binary_op (input_location, code,
13359 : 239718 : left, TREE_CODE (left),
13360 : 239718 : right, TREE_CODE (right),
13361 : : lookups, /*overload=*/NULL,
13362 : : complain);
13363 : : }
13364 : 240647 : }
13365 : :
13366 : : /* Substitute ARGS into the pack of a fold expression T. */
13367 : :
13368 : : static inline tree
13369 : 189916 : tsubst_fold_expr_pack (tree t, tree args, tsubst_flags_t complain, tree in_decl)
13370 : : {
13371 : 189916 : return tsubst_pack_expansion (FOLD_EXPR_PACK (t), args, complain, in_decl);
13372 : : }
13373 : :
13374 : : /* Substitute ARGS into the pack of a fold expression T. */
13375 : :
13376 : : static inline tree
13377 : 1325 : tsubst_fold_expr_init (tree t, tree args, tsubst_flags_t complain, tree in_decl)
13378 : : {
13379 : 1325 : return tsubst_expr (FOLD_EXPR_INIT (t), args, complain, in_decl);
13380 : : }
13381 : :
13382 : : /* Expand a PACK of arguments into a grouped as left fold.
13383 : : Given a pack containing elements A0, A1, ..., An and an
13384 : : operator @, this builds the expression:
13385 : :
13386 : : ((A0 @ A1) @ A2) ... @ An
13387 : :
13388 : : Note that PACK must not be empty.
13389 : :
13390 : : The operator is defined by the original fold expression T. */
13391 : :
13392 : : static tree
13393 : 2217 : expand_left_fold (tree t, tree pack, tsubst_flags_t complain)
13394 : : {
13395 : 2217 : tree left = TREE_VEC_ELT (pack, 0);
13396 : 10016 : for (int i = 1; i < TREE_VEC_LENGTH (pack); ++i)
13397 : : {
13398 : 7799 : tree right = TREE_VEC_ELT (pack, i);
13399 : 7799 : left = fold_expression (t, left, right, complain);
13400 : : }
13401 : 2217 : return left;
13402 : : }
13403 : :
13404 : : /* Substitute into a unary left fold expression. */
13405 : :
13406 : : static tree
13407 : 1835 : tsubst_unary_left_fold (tree t, tree args, tsubst_flags_t complain,
13408 : : tree in_decl)
13409 : : {
13410 : 1835 : tree pack = tsubst_fold_expr_pack (t, args, complain, in_decl);
13411 : 1835 : if (pack == error_mark_node)
13412 : : return error_mark_node;
13413 : 1835 : if (PACK_EXPANSION_P (pack))
13414 : : {
13415 : 270 : tree r = copy_node (t);
13416 : 270 : FOLD_EXPR_PACK (r) = pack;
13417 : 270 : return r;
13418 : : }
13419 : 1565 : if (TREE_VEC_LENGTH (pack) == 0)
13420 : 118 : return expand_empty_fold (t, complain);
13421 : : else
13422 : 1447 : return expand_left_fold (t, pack, complain);
13423 : : }
13424 : :
13425 : : /* Substitute into a binary left fold expression.
13426 : :
13427 : : Do ths by building a single (non-empty) vector of argumnts and
13428 : : building the expression from those elements. */
13429 : :
13430 : : static tree
13431 : 866 : tsubst_binary_left_fold (tree t, tree args, tsubst_flags_t complain,
13432 : : tree in_decl)
13433 : : {
13434 : 866 : tree pack = tsubst_fold_expr_pack (t, args, complain, in_decl);
13435 : 866 : if (pack == error_mark_node)
13436 : : return error_mark_node;
13437 : 866 : tree init = tsubst_fold_expr_init (t, args, complain, in_decl);
13438 : 866 : if (init == error_mark_node)
13439 : : return error_mark_node;
13440 : :
13441 : 866 : if (PACK_EXPANSION_P (pack))
13442 : : {
13443 : 96 : tree r = copy_node (t);
13444 : 96 : FOLD_EXPR_PACK (r) = pack;
13445 : 96 : FOLD_EXPR_INIT (r) = init;
13446 : 96 : return r;
13447 : : }
13448 : :
13449 : 770 : tree vec = make_tree_vec (TREE_VEC_LENGTH (pack) + 1);
13450 : 770 : TREE_VEC_ELT (vec, 0) = init;
13451 : 1685 : for (int i = 0; i < TREE_VEC_LENGTH (pack); ++i)
13452 : 915 : TREE_VEC_ELT (vec, i + 1) = TREE_VEC_ELT (pack, i);
13453 : :
13454 : 770 : return expand_left_fold (t, vec, complain);
13455 : : }
13456 : :
13457 : : /* Expand a PACK of arguments into a grouped as right fold.
13458 : : Given a pack containing elementns A0, A1, ..., and an
13459 : : operator @, this builds the expression:
13460 : :
13461 : : A0@ ... (An-2 @ (An-1 @ An))
13462 : :
13463 : : Note that PACK must not be empty.
13464 : :
13465 : : The operator is defined by the original fold expression T. */
13466 : :
13467 : : tree
13468 : 142784 : expand_right_fold (tree t, tree pack, tsubst_flags_t complain)
13469 : : {
13470 : : // Build the expression.
13471 : 142784 : int n = TREE_VEC_LENGTH (pack);
13472 : 142784 : tree right = TREE_VEC_ELT (pack, n - 1);
13473 : 376148 : for (--n; n != 0; --n)
13474 : : {
13475 : 233364 : tree left = TREE_VEC_ELT (pack, n - 1);
13476 : 233364 : right = fold_expression (t, left, right, complain);
13477 : : }
13478 : 142784 : return right;
13479 : : }
13480 : :
13481 : : /* Substitute into a unary right fold expression. */
13482 : :
13483 : : static tree
13484 : 186756 : tsubst_unary_right_fold (tree t, tree args, tsubst_flags_t complain,
13485 : : tree in_decl)
13486 : : {
13487 : 186756 : tree pack = tsubst_fold_expr_pack (t, args, complain, in_decl);
13488 : 186756 : if (pack == error_mark_node)
13489 : : return error_mark_node;
13490 : 186748 : if (PACK_EXPANSION_P (pack))
13491 : : {
13492 : 3258 : tree r = copy_node (t);
13493 : 3258 : FOLD_EXPR_PACK (r) = pack;
13494 : 3258 : return r;
13495 : : }
13496 : 183490 : if (TREE_VEC_LENGTH (pack) == 0)
13497 : 41075 : return expand_empty_fold (t, complain);
13498 : : else
13499 : 142415 : return expand_right_fold (t, pack, complain);
13500 : : }
13501 : :
13502 : : /* Substitute into a binary right fold expression.
13503 : :
13504 : : Do ths by building a single (non-empty) vector of arguments and
13505 : : building the expression from those elements. */
13506 : :
13507 : : static tree
13508 : 459 : tsubst_binary_right_fold (tree t, tree args, tsubst_flags_t complain,
13509 : : tree in_decl)
13510 : : {
13511 : 459 : tree pack = tsubst_fold_expr_pack (t, args, complain, in_decl);
13512 : 459 : if (pack == error_mark_node)
13513 : : return error_mark_node;
13514 : 459 : tree init = tsubst_fold_expr_init (t, args, complain, in_decl);
13515 : 459 : if (init == error_mark_node)
13516 : : return error_mark_node;
13517 : :
13518 : 459 : if (PACK_EXPANSION_P (pack))
13519 : : {
13520 : 90 : tree r = copy_node (t);
13521 : 90 : FOLD_EXPR_PACK (r) = pack;
13522 : 90 : FOLD_EXPR_INIT (r) = init;
13523 : 90 : return r;
13524 : : }
13525 : :
13526 : 369 : int n = TREE_VEC_LENGTH (pack);
13527 : 369 : tree vec = make_tree_vec (n + 1);
13528 : 843 : for (int i = 0; i < n; ++i)
13529 : 474 : TREE_VEC_ELT (vec, i) = TREE_VEC_ELT (pack, i);
13530 : 369 : TREE_VEC_ELT (vec, n) = init;
13531 : :
13532 : 369 : return expand_right_fold (t, vec, complain);
13533 : : }
13534 : :
13535 : : /* Walk through the pattern of a pack expansion, adding everything in
13536 : : local_specializations to a list. */
13537 : :
13538 : : class el_data
13539 : : {
13540 : : public:
13541 : : /* Set of variables declared within the pattern. */
13542 : : hash_set<tree> internal;
13543 : : /* Set of AST nodes that have been visited by the traversal. */
13544 : : hash_set<tree> visited;
13545 : : /* List of local_specializations used within the pattern. */
13546 : : tree extra;
13547 : : tsubst_flags_t complain;
13548 : : /* True iff we don't want to walk into unevaluated contexts. */
13549 : : bool skip_unevaluated_operands = false;
13550 : : /* The unevaluated contexts that we avoided walking. */
13551 : : auto_vec<tree> skipped_trees;
13552 : :
13553 : 8565 : el_data (tsubst_flags_t c)
13554 : 8565 : : extra (NULL_TREE), complain (c) {}
13555 : : };
13556 : : static tree
13557 : 1254975 : extract_locals_r (tree *tp, int *walk_subtrees, void *data_)
13558 : : {
13559 : 1254975 : el_data &data = *reinterpret_cast<el_data*>(data_);
13560 : 1254975 : tree *extra = &data.extra;
13561 : 1254975 : tsubst_flags_t complain = data.complain;
13562 : :
13563 : 1254975 : if (data.skip_unevaluated_operands
13564 : 1254975 : && unevaluated_p (TREE_CODE (*tp)))
13565 : : {
13566 : 9126 : data.skipped_trees.safe_push (*tp);
13567 : 9126 : *walk_subtrees = 0;
13568 : 9126 : return NULL_TREE;
13569 : : }
13570 : :
13571 : 1245849 : if (TYPE_P (*tp) && typedef_variant_p (*tp))
13572 : : /* Remember local typedefs (85214). */
13573 : 3382 : tp = &TYPE_NAME (*tp);
13574 : :
13575 : 1245849 : if (has_extra_args_mechanism_p (*tp))
13576 : : /* Assert *_EXTRA_ARGS is empty, because we don't want to walk it and
13577 : : potentially see a previously captured local in an evaluated context
13578 : : that's really only used in an unevaluated context (PR114303). This
13579 : : means callers of build_extra_args need to clear *_EXTRA_ARGS of the
13580 : : outermost tree. Nested *_EXTRA_ARGS should naturally be empty since
13581 : : the outermost (extra-args) tree will intercept any substitution before
13582 : : a nested tree can. */
13583 : 25232 : gcc_checking_assert (tree_extra_args (*tp) == NULL_TREE
13584 : : /* Except a lambda nested inside an extra-args tree
13585 : : can have extra args if we deferred partial
13586 : : substitution into it at template parse time. But
13587 : : we don't walk LAMBDA_EXPR_EXTRA_ARGS anyway. */
13588 : : || TREE_CODE (*tp) == LAMBDA_EXPR);
13589 : :
13590 : 1245849 : if (TREE_CODE (*tp) == DECL_EXPR)
13591 : : {
13592 : 30649 : tree decl = DECL_EXPR_DECL (*tp);
13593 : 30649 : data.internal.add (decl);
13594 : 29973 : if (DECL_DECOMPOSITION_P (decl)
13595 : 30655 : && TREE_TYPE (decl) != error_mark_node)
13596 : : {
13597 : 6 : gcc_assert (DECL_NAME (decl) == NULL_TREE);
13598 : 6 : for (tree decl2 = DECL_CHAIN (decl);
13599 : 18 : decl2
13600 : 12 : && DECL_DECOMPOSITION_P (decl2)
13601 : 12 : && DECL_NAME (decl2)
13602 : 30 : && TREE_TYPE (decl2) != error_mark_node;
13603 : 12 : decl2 = DECL_CHAIN (decl2))
13604 : : {
13605 : 12 : gcc_assert (DECL_DECOMP_BASE (decl2) == decl);
13606 : 12 : data.internal.add (decl2);
13607 : : }
13608 : : }
13609 : : }
13610 : 1215200 : else if (TREE_CODE (*tp) == LAMBDA_EXPR)
13611 : : {
13612 : : /* Since we defer implicit capture, look in the parms and body. */
13613 : 197 : tree fn = lambda_function (*tp);
13614 : 197 : cp_walk_tree (&TREE_TYPE (fn), &extract_locals_r, &data,
13615 : : &data.visited);
13616 : 197 : cp_walk_tree (&DECL_SAVED_TREE (fn), &extract_locals_r, &data,
13617 : : &data.visited);
13618 : : }
13619 : 1215003 : else if (tree spec = retrieve_local_specialization (*tp))
13620 : : {
13621 : 17560 : if (data.internal.contains (*tp))
13622 : : /* Don't mess with variables declared within the pattern. */
13623 : : return NULL_TREE;
13624 : 17545 : if (TREE_CODE (spec) == NONTYPE_ARGUMENT_PACK)
13625 : : {
13626 : : /* Maybe pull out the PARM_DECL for a partial instantiation. */
13627 : 15 : tree args = ARGUMENT_PACK_ARGS (spec);
13628 : 15 : if (TREE_VEC_LENGTH (args) == 1)
13629 : : {
13630 : 6 : tree elt = TREE_VEC_ELT (args, 0);
13631 : 6 : if (PACK_EXPANSION_P (elt))
13632 : 0 : elt = PACK_EXPANSION_PATTERN (elt);
13633 : 6 : if (DECL_PACK_P (elt))
13634 : : spec = elt;
13635 : : }
13636 : 15 : if (TREE_CODE (spec) == NONTYPE_ARGUMENT_PACK)
13637 : : {
13638 : : /* Handle lambda capture here, since we aren't doing any
13639 : : substitution now, and so tsubst_copy won't call
13640 : : process_outer_var_ref. */
13641 : 15 : tree args = ARGUMENT_PACK_ARGS (spec);
13642 : 15 : int len = TREE_VEC_LENGTH (args);
13643 : 33 : for (int i = 0; i < len; ++i)
13644 : : {
13645 : 18 : tree arg = TREE_VEC_ELT (args, i);
13646 : 18 : tree carg = arg;
13647 : 18 : if (outer_automatic_var_p (arg))
13648 : 18 : carg = process_outer_var_ref (arg, complain);
13649 : 18 : if (carg != arg)
13650 : : {
13651 : : /* Make a new NONTYPE_ARGUMENT_PACK of the capture
13652 : : proxies. */
13653 : 18 : if (i == 0)
13654 : : {
13655 : 12 : spec = copy_node (spec);
13656 : 12 : args = copy_node (args);
13657 : 12 : ARGUMENT_PACK_ARGS (spec) = args;
13658 : 12 : register_local_specialization (spec, *tp);
13659 : : }
13660 : 18 : TREE_VEC_ELT (args, i) = carg;
13661 : : }
13662 : : }
13663 : : }
13664 : : }
13665 : 17545 : if (outer_automatic_var_p (spec))
13666 : 18 : spec = process_outer_var_ref (spec, complain);
13667 : 17545 : *extra = tree_cons (*tp, spec, *extra);
13668 : : }
13669 : : return NULL_TREE;
13670 : : }
13671 : : static tree
13672 : 8565 : extract_local_specs (tree pattern, tsubst_flags_t complain)
13673 : : {
13674 : 8565 : el_data data (complain);
13675 : : /* Walk the pattern twice, ignoring unevaluated operands the first time
13676 : : around, so that if a local specialization appears in both an evaluated
13677 : : and unevaluated context we prefer to process it in the evaluated context
13678 : : (since e.g. process_outer_var_ref is a no-op inside an unevaluated
13679 : : context). */
13680 : 8565 : data.skip_unevaluated_operands = true;
13681 : 8565 : cp_walk_tree (&pattern, extract_locals_r, &data, &data.visited);
13682 : : /* Now walk the unevaluated contexts we skipped the first time around. */
13683 : 8565 : data.skip_unevaluated_operands = false;
13684 : 34413 : for (tree t : data.skipped_trees)
13685 : : {
13686 : 9126 : data.visited.remove (t);
13687 : 9126 : cp_walk_tree (&t, extract_locals_r, &data, &data.visited);
13688 : : }
13689 : 17130 : return data.extra;
13690 : 8565 : }
13691 : :
13692 : : /* Extract any uses of local_specializations from PATTERN and add them to ARGS
13693 : : for use in PACK_EXPANSION_EXTRA_ARGS. */
13694 : :
13695 : : tree
13696 : 70315 : build_extra_args (tree pattern, tree args, tsubst_flags_t complain)
13697 : : {
13698 : : /* Make a copy of the extra arguments so that they won't get changed
13699 : : out from under us. */
13700 : 70315 : tree extra = preserve_args (copy_template_args (args), /*cow_p=*/false);
13701 : 70315 : if (complain & tf_partial)
13702 : : /* Remember whether this is a partial substitution. */
13703 : 36 : TREE_STATIC (extra) = true;
13704 : 70315 : if (local_specializations)
13705 : 8565 : if (tree locals = extract_local_specs (pattern, complain))
13706 : 7338 : extra = tree_cons (NULL_TREE, extra, locals);
13707 : 70315 : return extra;
13708 : : }
13709 : :
13710 : : /* Apply any local specializations from PACK_EXPANSION_EXTRA_ARGS and add the
13711 : : normal template args to ARGS. */
13712 : :
13713 : : tree
13714 : 70600624 : add_extra_args (tree extra, tree args, tsubst_flags_t complain, tree in_decl)
13715 : : {
13716 : 70600624 : if (!extra)
13717 : : return args;
13718 : :
13719 : 116381 : if (TREE_CODE (extra) == TREE_LIST)
13720 : : {
13721 : 389096 : for (tree elt = TREE_CHAIN (extra); elt; elt = TREE_CHAIN (elt))
13722 : : {
13723 : : /* The partial instantiation involved local declarations collected in
13724 : : extract_local_specs; map from the general template to our local
13725 : : context. */
13726 : 272856 : tree gen = TREE_PURPOSE (elt);
13727 : 272856 : tree inst = TREE_VALUE (elt);
13728 : 272856 : if (DECL_P (inst))
13729 : 272841 : if (tree local = retrieve_local_specialization (inst))
13730 : 272856 : inst = local;
13731 : : /* else inst is already a full instantiation of the pack. */
13732 : 272856 : register_local_specialization (inst, gen);
13733 : : }
13734 : 116240 : gcc_assert (!TREE_PURPOSE (extra));
13735 : 116240 : extra = TREE_VALUE (extra);
13736 : : }
13737 : 116381 : gcc_checking_assert (TREE_STATIC (extra) == uses_template_parms (extra));
13738 : 116381 : if (TREE_STATIC (extra))
13739 : : /* This is a partial substitution into e.g. a requires-expr or lambda-expr
13740 : : inside a default template argument; we expect 'extra' to be a full set
13741 : : of template arguments for the template context, so it suffices to just
13742 : : substitute into them. */
13743 : 48 : args = tsubst_template_args (extra, args, complain, in_decl);
13744 : : else
13745 : 116333 : args = add_to_template_args (extra, args);
13746 : : return args;
13747 : : }
13748 : :
13749 : : /* Substitute ARGS into T, which is a pack expansion
13750 : : (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
13751 : : TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
13752 : : (if only a partial substitution could be performed) or
13753 : : ERROR_MARK_NODE if there was an error. */
13754 : :
13755 : : tree
13756 : 65131400 : tsubst_pack_expansion (tree t, tree args, tsubst_flags_t complain,
13757 : : tree in_decl)
13758 : : {
13759 : 65131400 : tree pattern;
13760 : 65131400 : tree pack, packs = NULL_TREE;
13761 : 65131400 : bool unsubstituted_packs = false;
13762 : 65131400 : int i, len = -1;
13763 : 65131400 : tree result;
13764 : 65131400 : bool need_local_specializations = false;
13765 : 65131400 : int levels;
13766 : :
13767 : 65131400 : gcc_assert (PACK_EXPANSION_P (t));
13768 : 65131400 : pattern = PACK_EXPANSION_PATTERN (t);
13769 : :
13770 : : /* Add in any args remembered from an earlier partial instantiation. */
13771 : 65131400 : args = add_extra_args (PACK_EXPANSION_EXTRA_ARGS (t), args, complain, in_decl);
13772 : :
13773 : 130262800 : levels = TMPL_ARGS_DEPTH (args);
13774 : :
13775 : : /* Determine the argument packs that will instantiate the parameter
13776 : : packs used in the expansion expression. While we're at it,
13777 : : compute the number of arguments to be expanded and make sure it
13778 : : is consistent. */
13779 : 189195874 : for (pack = PACK_EXPANSION_PARAMETER_PACKS (t); pack;
13780 : 62971785 : pack = TREE_CHAIN (pack))
13781 : : {
13782 : 65686656 : tree parm_pack = TREE_VALUE (pack);
13783 : 65686656 : tree arg_pack = NULL_TREE;
13784 : 65686656 : tree orig_arg = NULL_TREE;
13785 : 65686656 : int level = 0;
13786 : :
13787 : 65686656 : if (TREE_CODE (parm_pack) == BASES)
13788 : : {
13789 : 27 : gcc_assert (parm_pack == pattern);
13790 : 27 : tree type = tsubst (BASES_TYPE (parm_pack), args, complain, in_decl);
13791 : 27 : if (BASES_DIRECT (parm_pack))
13792 : 2714868 : return calculate_direct_bases (type, complain);
13793 : : else
13794 : 12 : return calculate_bases (type, complain);
13795 : : }
13796 : 65686629 : else if (builtin_pack_call_p (parm_pack))
13797 : : {
13798 : 105353 : if (parm_pack != pattern)
13799 : : {
13800 : 3 : if (complain & tf_error)
13801 : 3 : sorry ("%qE is not the entire pattern of the pack expansion",
13802 : : parm_pack);
13803 : 3 : return error_mark_node;
13804 : : }
13805 : 105350 : return expand_builtin_pack_call (parm_pack, args,
13806 : 105350 : complain, in_decl);
13807 : : }
13808 : 65581276 : else if (TREE_CODE (parm_pack) == PARM_DECL)
13809 : : {
13810 : : /* We know we have correct local_specializations if this
13811 : : expansion is at function scope, or if we're dealing with a
13812 : : local parameter in a requires expression; for the latter,
13813 : : tsubst_requires_expr set it up appropriately. */
13814 : 558360 : if (PACK_EXPANSION_LOCAL_P (t) || CONSTRAINT_VAR_P (parm_pack))
13815 : 553654 : arg_pack = retrieve_local_specialization (parm_pack);
13816 : : else
13817 : : /* We can't rely on local_specializations for a parameter
13818 : : name used later in a function declaration (such as in a
13819 : : late-specified return type). Even if it exists, it might
13820 : : have the wrong value for a recursive call. */
13821 : : need_local_specializations = true;
13822 : :
13823 : 553654 : if (!arg_pack)
13824 : : {
13825 : : /* This parameter pack was used in an unevaluated context. Just
13826 : : make a dummy decl, since it's only used for its type. */
13827 : 4706 : ++cp_unevaluated_operand;
13828 : 4706 : arg_pack = tsubst_decl (parm_pack, args, complain);
13829 : 4706 : --cp_unevaluated_operand;
13830 : 4706 : if (arg_pack && DECL_PACK_P (arg_pack))
13831 : : /* Partial instantiation of the parm_pack, we can't build
13832 : : up an argument pack yet. */
13833 : : arg_pack = NULL_TREE;
13834 : : else
13835 : 4585 : arg_pack = make_fnparm_pack (arg_pack);
13836 : : }
13837 : 553654 : else if (DECL_PACK_P (arg_pack))
13838 : : /* This argument pack isn't fully instantiated yet. */
13839 : : arg_pack = NULL_TREE;
13840 : : }
13841 : 65022916 : else if (is_capture_proxy (parm_pack))
13842 : : {
13843 : 77 : arg_pack = retrieve_local_specialization (parm_pack);
13844 : 77 : if (DECL_PACK_P (arg_pack))
13845 : : arg_pack = NULL_TREE;
13846 : : }
13847 : : else
13848 : : {
13849 : 65022839 : int idx;
13850 : 65022839 : template_parm_level_and_index (parm_pack, &level, &idx);
13851 : 65022839 : if (level <= levels)
13852 : 113251048 : arg_pack = TMPL_ARG (args, level, idx);
13853 : :
13854 : 53852475 : if (arg_pack && TREE_CODE (arg_pack) == TEMPLATE_TYPE_PARM
13855 : 56625565 : && TEMPLATE_TYPE_PARAMETER_PACK (arg_pack))
13856 : 38 : arg_pack = NULL_TREE;
13857 : : }
13858 : :
13859 : 76751678 : orig_arg = arg_pack;
13860 : 65579575 : if (arg_pack && TREE_CODE (arg_pack) == ARGUMENT_PACK_SELECT)
13861 : 2640 : arg_pack = ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack);
13862 : :
13863 : 54409173 : if (arg_pack && !ARGUMENT_PACK_P (arg_pack))
13864 : : /* This can only happen if we forget to expand an argument
13865 : : pack somewhere else. Just return an error, silently. */
13866 : : {
13867 : 9 : result = make_tree_vec (1);
13868 : 9 : TREE_VEC_ELT (result, 0) = error_mark_node;
13869 : 9 : return result;
13870 : : }
13871 : :
13872 : 65581267 : if (arg_pack)
13873 : : {
13874 : 54409164 : int my_len =
13875 : 54409164 : TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack));
13876 : :
13877 : : /* Don't bother trying to do a partial substitution with
13878 : : incomplete packs; we'll try again after deduction. */
13879 : 54409164 : if (ARGUMENT_PACK_INCOMPLETE_P (arg_pack))
13880 : : return t;
13881 : :
13882 : 51799720 : if (len < 0)
13883 : : len = my_len;
13884 : 492951 : else if (len != my_len)
13885 : : {
13886 : 35 : if (!(complain & tf_error))
13887 : : /* Fail quietly. */;
13888 : 13 : else if (TREE_CODE (t) == TYPE_PACK_EXPANSION)
13889 : 7 : error ("mismatched argument pack lengths while expanding %qT",
13890 : : pattern);
13891 : : else
13892 : 6 : error ("mismatched argument pack lengths while expanding %qE",
13893 : : pattern);
13894 : 35 : return error_mark_node;
13895 : : }
13896 : :
13897 : : /* Keep track of the parameter packs and their corresponding
13898 : : argument packs. */
13899 : 51799685 : packs = tree_cons (parm_pack, arg_pack, packs);
13900 : 51799685 : TREE_TYPE (packs) = orig_arg;
13901 : : }
13902 : : else
13903 : : {
13904 : : /* We can't substitute for this parameter pack. We use a flag as
13905 : : well as the missing_level counter because function parameter
13906 : : packs don't have a level. */
13907 : 11172103 : gcc_assert (processing_template_decl || is_auto (parm_pack));
13908 : : unsubstituted_packs = true;
13909 : : }
13910 : : }
13911 : :
13912 : : /* If the expansion is just T..., return the matching argument pack, unless
13913 : : we need to call convert_from_reference on all the elements. This is an
13914 : : important optimization; see c++/68422. */
13915 : 62416529 : if (!unsubstituted_packs
13916 : 113661532 : && TREE_PURPOSE (packs) == pattern)
13917 : : {
13918 : 45770865 : tree args = ARGUMENT_PACK_ARGS (TREE_VALUE (packs));
13919 : :
13920 : : /* If the argument pack is a single pack expansion, pull it out. */
13921 : 45770865 : if (TREE_VEC_LENGTH (args) == 1
13922 : 45770865 : && pack_expansion_args_count (args))
13923 : : {
13924 : 2917800 : tree arg = TREE_VEC_ELT (args, 0);
13925 : 2917800 : if (PACK_EXPANSION_SIZEOF_P (t)
13926 : 2917800 : && !TEMPLATE_PARM_P (PACK_EXPANSION_PATTERN (arg)))
13927 : : /* Except if this isn't a simple sizeof...(T) which gets sZ
13928 : : mangling, keep the TREE_VEC to get sP mangling. */;
13929 : : else
13930 : 2917791 : return TREE_VEC_ELT (args, 0);
13931 : : }
13932 : :
13933 : : /* Types need no adjustment, nor does sizeof..., and if we still have
13934 : : some pack expansion args we won't do anything yet. */
13935 : 42853074 : if (TREE_CODE (t) == TYPE_PACK_EXPANSION
13936 : 2299892 : || PACK_EXPANSION_SIZEOF_P (t)
13937 : 45152275 : || pack_expansion_args_count (args))
13938 : : return args;
13939 : : /* Also optimize expression pack expansions if we can tell that the
13940 : : elements won't have reference type. */
13941 : 2211661 : tree type = TREE_TYPE (pattern);
13942 : 2211661 : if (type && !TYPE_REF_P (type)
13943 : : && !PACK_EXPANSION_P (type)
13944 : : && !WILDCARD_TYPE_P (type))
13945 : : return args;
13946 : : /* Otherwise use the normal path so we get convert_from_reference. */
13947 : : }
13948 : :
13949 : : /* We cannot expand this expansion expression, because we don't have
13950 : : all of the argument packs we need. */
13951 : 16657682 : if (use_pack_expansion_extra_args_p (t, packs, len, unsubstituted_packs))
13952 : : {
13953 : : /* We got some full packs, but we can't substitute them in until we
13954 : : have values for all the packs. So remember these until then. */
13955 : :
13956 : 61736 : t = make_pack_expansion (pattern, complain);
13957 : 61736 : PACK_EXPANSION_EXTRA_ARGS (t)
13958 : 61736 : = build_extra_args (pattern, args, complain);
13959 : 61736 : return t;
13960 : : }
13961 : :
13962 : : /* If NEED_LOCAL_SPECIALIZATIONS then we're in a late-specified return
13963 : : type, so create our own local specializations map; the current map is
13964 : : either NULL or (in the case of recursive unification) might have
13965 : : bindings that we don't want to use or alter. */
13966 : 16595946 : local_specialization_stack lss (need_local_specializations
13967 : 33187201 : ? lss_blank : lss_nop);
13968 : :
13969 : 16595946 : if (unsubstituted_packs)
13970 : : {
13971 : : /* There were no real arguments, we're just replacing a parameter
13972 : : pack with another version of itself. Substitute into the
13973 : : pattern and return a PACK_EXPANSION_*. The caller will need to
13974 : : deal with that. */
13975 : 11109793 : if (TREE_CODE (t) == EXPR_PACK_EXPANSION)
13976 : 465451 : result = tsubst_expr (pattern, args, complain, in_decl);
13977 : : else
13978 : 10644342 : result = tsubst (pattern, args, complain, in_decl);
13979 : 11109793 : result = make_pack_expansion (result, complain);
13980 : 11109793 : if (result == error_mark_node)
13981 : : return error_mark_node;
13982 : 11109790 : PACK_EXPANSION_LOCAL_P (result) = PACK_EXPANSION_LOCAL_P (t);
13983 : 11109790 : PACK_EXPANSION_SIZEOF_P (result) = PACK_EXPANSION_SIZEOF_P (t);
13984 : 11109790 : if (PACK_EXPANSION_AUTO_P (t))
13985 : : {
13986 : : /* This is a fake auto... pack expansion created in add_capture with
13987 : : _PACKS that don't appear in the pattern. Copy one over. */
13988 : 6 : packs = PACK_EXPANSION_PARAMETER_PACKS (t);
13989 : 3 : pack = retrieve_local_specialization (TREE_VALUE (packs));
13990 : 3 : gcc_checking_assert (DECL_PACK_P (pack));
13991 : 6 : PACK_EXPANSION_PARAMETER_PACKS (result)
13992 : 3 : = build_tree_list (NULL_TREE, pack);
13993 : 3 : PACK_EXPANSION_AUTO_P (result) = true;
13994 : : }
13995 : 11109790 : return result;
13996 : : }
13997 : :
13998 : 5486153 : gcc_assert (len >= 0);
13999 : :
14000 : : /* For each argument in each argument pack, substitute into the
14001 : : pattern. */
14002 : 5486153 : result = make_tree_vec (len);
14003 : 5486153 : tree elem_args = copy_template_args (args);
14004 : 19629950 : for (i = 0; i < len; ++i)
14005 : : {
14006 : 9402346 : t = gen_elem_of_pack_expansion_instantiation (pattern, packs,
14007 : : i,
14008 : : elem_args, complain,
14009 : : in_decl);
14010 : 9402346 : TREE_VEC_ELT (result, i) = t;
14011 : 9402346 : if (t == error_mark_node)
14012 : : {
14013 : : result = error_mark_node;
14014 : : break;
14015 : : }
14016 : : }
14017 : :
14018 : : /* Update ARGS to restore the substitution from parameter packs to
14019 : : their argument packs. */
14020 : 11465213 : for (pack = packs; pack; pack = TREE_CHAIN (pack))
14021 : : {
14022 : 5979060 : tree parm = TREE_PURPOSE (pack);
14023 : :
14024 : 5979060 : if (TREE_CODE (parm) == PARM_DECL
14025 : 5422703 : || VAR_P (parm)
14026 : 5422635 : || TREE_CODE (parm) == FIELD_DECL)
14027 : 556425 : register_local_specialization (TREE_TYPE (pack), parm);
14028 : : else
14029 : : {
14030 : 5422635 : int idx, level;
14031 : :
14032 : 5422635 : if (TREE_VALUE (pack) == NULL_TREE)
14033 : 0 : continue;
14034 : :
14035 : 5422635 : template_parm_level_and_index (parm, &level, &idx);
14036 : :
14037 : : /* Update the corresponding argument. */
14038 : 10845270 : if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
14039 : 913767 : TREE_VEC_ELT (TREE_VEC_ELT (args, level -1 ), idx) =
14040 : 913767 : TREE_TYPE (pack);
14041 : : else
14042 : 4508868 : TREE_VEC_ELT (args, idx) = TREE_TYPE (pack);
14043 : : }
14044 : : }
14045 : :
14046 : : /* If the dependent pack arguments were such that we end up with only a
14047 : : single pack expansion again, there's no need to keep it in a TREE_VEC. */
14048 : 1168508 : if (len == 1 && TREE_CODE (result) == TREE_VEC
14049 : 6652827 : && PACK_EXPANSION_P (TREE_VEC_ELT (result, 0)))
14050 : 217714 : return TREE_VEC_ELT (result, 0);
14051 : :
14052 : : return result;
14053 : 16595946 : }
14054 : :
14055 : : /* Substitute ARGS into T, which is a pack index (i.e., PACK_INDEX_TYPE or
14056 : : PACK_INDEX_EXPR). Returns a single type or expression, a PACK_INDEX_*
14057 : : node if only a partial substitution could be performed, or ERROR_MARK_NODE
14058 : : if there was an error. */
14059 : :
14060 : : tree
14061 : 136 : tsubst_pack_index (tree t, tree args, tsubst_flags_t complain, tree in_decl)
14062 : : {
14063 : 136 : tree pack = PACK_INDEX_PACK (t);
14064 : 136 : if (PACK_EXPANSION_P (pack))
14065 : 134 : pack = tsubst_pack_expansion (pack, args, complain, in_decl);
14066 : 136 : if (TREE_CODE (pack) == TREE_VEC && TREE_VEC_LENGTH (pack) == 0)
14067 : : {
14068 : 5 : if (complain & tf_error)
14069 : 5 : error ("cannot index an empty pack");
14070 : 5 : return error_mark_node;
14071 : : }
14072 : 131 : tree index = tsubst_expr (PACK_INDEX_INDEX (t), args, complain, in_decl);
14073 : 131 : const bool parenthesized_p = (TREE_CODE (t) == PACK_INDEX_EXPR
14074 : 131 : && PACK_INDEX_PARENTHESIZED_P (t));
14075 : 131 : if (!value_dependent_expression_p (index) && TREE_CODE (pack) == TREE_VEC)
14076 : 122 : return pack_index_element (index, pack, parenthesized_p, complain);
14077 : : else
14078 : 9 : return make_pack_index (pack, index);
14079 : : }
14080 : :
14081 : : /* Make an argument pack out of the TREE_VEC VEC. */
14082 : :
14083 : : static tree
14084 : 27 : make_argument_pack (tree vec)
14085 : : {
14086 : 27 : tree pack;
14087 : :
14088 : 27 : if (TYPE_P (TREE_VEC_ELT (vec, 0)))
14089 : 15 : pack = cxx_make_type (TYPE_ARGUMENT_PACK);
14090 : : else
14091 : : {
14092 : 12 : pack = make_node (NONTYPE_ARGUMENT_PACK);
14093 : 12 : TREE_CONSTANT (pack) = 1;
14094 : : }
14095 : 27 : ARGUMENT_PACK_ARGS (pack) = vec;
14096 : 27 : return pack;
14097 : : }
14098 : :
14099 : : /* Return an exact copy of template args T that can be modified
14100 : : independently. */
14101 : :
14102 : : static tree
14103 : 17468515 : copy_template_args (tree t)
14104 : : {
14105 : 17468515 : if (t == error_mark_node)
14106 : : return t;
14107 : :
14108 : 17468515 : int len = TREE_VEC_LENGTH (t);
14109 : 17468515 : tree new_vec = make_tree_vec (len);
14110 : :
14111 : 55751632 : for (int i = 0; i < len; ++i)
14112 : : {
14113 : 38283117 : tree elt = TREE_VEC_ELT (t, i);
14114 : 38283117 : if (elt && TREE_CODE (elt) == TREE_VEC)
14115 : 1587942 : elt = copy_template_args (elt);
14116 : 38283117 : TREE_VEC_ELT (new_vec, i) = elt;
14117 : : }
14118 : :
14119 : 34937030 : NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_vec)
14120 : 17468515 : = NON_DEFAULT_TEMPLATE_ARGS_COUNT (t);
14121 : :
14122 : 17468515 : return new_vec;
14123 : : }
14124 : :
14125 : : /* Substitute ARGS into the *_ARGUMENT_PACK orig_arg. */
14126 : :
14127 : : tree
14128 : 93172076 : tsubst_argument_pack (tree orig_arg, tree args, tsubst_flags_t complain,
14129 : : tree in_decl)
14130 : : {
14131 : : /* This flag is used only during deduction, and we don't expect to
14132 : : substitute such ARGUMENT_PACKs. */
14133 : 93172076 : gcc_assert (!ARGUMENT_PACK_INCOMPLETE_P (orig_arg));
14134 : :
14135 : : /* Substitute into each of the arguments. */
14136 : 93172076 : tree pack_args = tsubst_template_args (ARGUMENT_PACK_ARGS (orig_arg),
14137 : : args, complain, in_decl);
14138 : 93172076 : if (pack_args == error_mark_node)
14139 : : return error_mark_node;
14140 : :
14141 : 92291695 : if (pack_args == ARGUMENT_PACK_ARGS (orig_arg))
14142 : : return orig_arg;
14143 : :
14144 : : /* If we're substituting into a generic ARGUMENT_PACK for a variadic
14145 : : template parameter, we might be able to avoid allocating a new
14146 : : ARGUMENT_PACK and reuse the corresponding ARGUMENT_PACK from ARGS
14147 : : if the substituted result is identical to it. */
14148 : 88119370 : if (tree parm = template_arg_to_parm (orig_arg))
14149 : : {
14150 : 36985218 : int level, index;
14151 : 36985218 : template_parm_level_and_index (parm, &level, &index);
14152 : 108281263 : if (TMPL_ARGS_DEPTH (args) >= level)
14153 : 65350120 : if (tree arg = TMPL_ARG (args, level, index))
14154 : 30650838 : if (TREE_CODE (arg) == TREE_CODE (orig_arg)
14155 : 30650838 : && ARGUMENT_PACK_ARGS (arg) == pack_args)
14156 : : {
14157 : 28452325 : gcc_assert (!ARGUMENT_PACK_INCOMPLETE_P (arg));
14158 : 28452325 : return arg;
14159 : : }
14160 : : }
14161 : :
14162 : 59667045 : tree new_arg;
14163 : 59667045 : if (TYPE_P (orig_arg))
14164 : : {
14165 : 59042814 : new_arg = cxx_make_type (TREE_CODE (orig_arg));
14166 : 59042814 : SET_TYPE_STRUCTURAL_EQUALITY (new_arg);
14167 : : }
14168 : : else
14169 : : {
14170 : 624231 : new_arg = make_node (TREE_CODE (orig_arg));
14171 : 624231 : TREE_CONSTANT (new_arg) = TREE_CONSTANT (orig_arg);
14172 : : }
14173 : 59667045 : ARGUMENT_PACK_ARGS (new_arg) = pack_args;
14174 : : return new_arg;
14175 : : }
14176 : :
14177 : : /* Substitute ARGS into the vector or list of template arguments T. */
14178 : :
14179 : : tree
14180 : 1250131536 : tsubst_template_args (tree t, tree args, tsubst_flags_t complain, tree in_decl)
14181 : : {
14182 : 1250131536 : if (t == error_mark_node)
14183 : : return error_mark_node;
14184 : :
14185 : : /* In "sizeof(X<I>)" we need to evaluate "I". */
14186 : 1250131536 : cp_evaluated ev;
14187 : :
14188 : 1250131536 : const int len = TREE_VEC_LENGTH (t);
14189 : 1250131536 : tree *elts = XALLOCAVEC (tree, len);
14190 : 1250131536 : int expanded_len_adjust = 0;
14191 : :
14192 : : /* True iff the substituted result is identical to T. */
14193 : 1250131536 : bool const_subst_p = true;
14194 : :
14195 : 3843636298 : for (int i = 0; i < len; i++)
14196 : : {
14197 : 2595632275 : tree orig_arg = TREE_VEC_ELT (t, i);
14198 : 2595632275 : tree new_arg;
14199 : :
14200 : 2595632275 : if (!orig_arg)
14201 : : new_arg = NULL_TREE;
14202 : 2595632224 : else if (TREE_CODE (orig_arg) == TREE_VEC)
14203 : 64118955 : new_arg = tsubst_template_args (orig_arg, args, complain, in_decl);
14204 : 2531513269 : else if (PACK_EXPANSION_P (orig_arg))
14205 : : {
14206 : : /* Substitute into an expansion expression. */
14207 : 54303640 : new_arg = tsubst_pack_expansion (orig_arg, args, complain, in_decl);
14208 : :
14209 : 54303640 : if (TREE_CODE (new_arg) == TREE_VEC)
14210 : : /* Add to the expanded length adjustment the number of
14211 : : expanded arguments. We subtract one from this
14212 : : measurement, because the argument pack expression
14213 : : itself is already counted as 1 in
14214 : : LEN. EXPANDED_LEN_ADJUST can actually be negative, if
14215 : : the argument pack is empty. */
14216 : 41300306 : expanded_len_adjust += TREE_VEC_LENGTH (new_arg) - 1;
14217 : : }
14218 : 2477209629 : else if (ARGUMENT_PACK_P (orig_arg))
14219 : 92050794 : new_arg = tsubst_argument_pack (orig_arg, args, complain, in_decl);
14220 : : else
14221 : 2385158835 : new_arg = tsubst_template_arg (orig_arg, args, complain, in_decl);
14222 : :
14223 : 2595632239 : if (new_arg == error_mark_node)
14224 : : return error_mark_node;
14225 : :
14226 : 2593504762 : elts[i] = new_arg;
14227 : 2593504762 : if (new_arg != orig_arg)
14228 : 2488596945 : const_subst_p = false;
14229 : : }
14230 : :
14231 : 1248004023 : if (const_subst_p)
14232 : : return t;
14233 : :
14234 : 1231278965 : tree maybe_reuse = NULL_TREE;
14235 : :
14236 : : /* If ARGS and T are both multi-level, the substituted result may be
14237 : : identical to ARGS. */
14238 : 1231278965 : if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (t)
14239 : 63982914 : && TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args)
14240 : 6508490 : && TMPL_ARGS_DEPTH (t) == TMPL_ARGS_DEPTH (args))
14241 : : maybe_reuse = args;
14242 : : /* If T appears to be a vector of generic template arguments, the
14243 : : substituted result may be identical to the corresponding level
14244 : : from ARGS. */
14245 : 1225443582 : else if (tree parm = template_arg_to_parm (TREE_VEC_ELT (t, 0)))
14246 : : {
14247 : 964164306 : int level, index;
14248 : 964164306 : template_parm_level_and_index (parm, &level, &index);
14249 : 2749031716 : if (index == 0 && TMPL_ARGS_DEPTH (args) >= level)
14250 : 1743361198 : maybe_reuse = TMPL_ARGS_LEVEL (args, level);
14251 : : }
14252 : :
14253 : : /* If the substituted result is identical to MAYBE_REUSE, return
14254 : : it and avoid allocating a new TREE_VEC, as an optimization. */
14255 : 92483707 : if (maybe_reuse != NULL_TREE
14256 : 877515982 : && TREE_VEC_LENGTH (maybe_reuse) == len
14257 : 1675427717 : && std::equal (elts, elts+len, TREE_VEC_BEGIN (maybe_reuse)))
14258 : : return maybe_reuse;
14259 : :
14260 : : /* If T consists of only a pack expansion for which substitution yielded
14261 : : a TREE_VEC of the expanded elements, then reuse that TREE_VEC instead
14262 : : of effectively making a copy. */
14263 : 454296837 : if (len == 1
14264 : 243843610 : && PACK_EXPANSION_P (TREE_VEC_ELT (t, 0))
14265 : 498258956 : && TREE_CODE (elts[0]) == TREE_VEC)
14266 : : return elts[0];
14267 : :
14268 : : /* Make space for the expanded arguments coming from template
14269 : : argument packs. */
14270 : 419405880 : tree r = make_tree_vec (len + expanded_len_adjust);
14271 : : /* T can contain TREE_VECs. That happens if T contains the
14272 : : arguments for a member template.
14273 : : In that case each TREE_VEC in T represents a level of template
14274 : : arguments, and T won't carry any non defaulted argument count.
14275 : : It will rather be the nested TREE_VECs that will carry one.
14276 : : In other words, T carries a non defaulted argument count only
14277 : : if it doesn't contain any nested TREE_VEC. */
14278 : 419405880 : if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (t))
14279 : : {
14280 : 390294072 : int count = GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (t);
14281 : 390294072 : count += expanded_len_adjust;
14282 : 390294072 : SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (r, count);
14283 : : }
14284 : :
14285 : : int out = 0;
14286 : 1107145891 : for (int i = 0; i < len; i++)
14287 : : {
14288 : 687740011 : tree orig_arg = TREE_VEC_ELT (t, i);
14289 : 687740011 : if (orig_arg
14290 : 687739996 : && PACK_EXPANSION_P (orig_arg)
14291 : 16132057 : && TREE_CODE (elts[i]) == TREE_VEC)
14292 : : {
14293 : : /* Now expand the template argument pack "in place". */
14294 : 15683244 : for (int idx = 0; idx < TREE_VEC_LENGTH (elts[i]); idx++, out++)
14295 : 9273895 : TREE_VEC_ELT (r, out) = TREE_VEC_ELT (elts[i], idx);
14296 : : }
14297 : : else
14298 : : {
14299 : 681330662 : TREE_VEC_ELT (r, out) = elts[i];
14300 : 681330662 : out++;
14301 : : }
14302 : : }
14303 : 419405880 : gcc_assert (out == TREE_VEC_LENGTH (r));
14304 : :
14305 : : return r;
14306 : 1250131500 : }
14307 : :
14308 : : /* Substitute ARGS into one level PARMS of template parameters. */
14309 : :
14310 : : static tree
14311 : 20997858 : tsubst_template_parms_level (tree parms, tree args, tsubst_flags_t complain)
14312 : : {
14313 : 20997858 : if (parms == error_mark_node)
14314 : : return error_mark_node;
14315 : :
14316 : 20997858 : tree new_vec = make_tree_vec (TREE_VEC_LENGTH (parms));
14317 : :
14318 : 55001326 : for (int i = 0; i < TREE_VEC_LENGTH (new_vec); ++i)
14319 : : {
14320 : 34003468 : tree tuple = TREE_VEC_ELT (parms, i);
14321 : :
14322 : 34003468 : if (tuple == error_mark_node)
14323 : 0 : continue;
14324 : :
14325 : 34003468 : TREE_VEC_ELT (new_vec, i) =
14326 : 34003468 : tsubst_template_parm (tuple, args, complain);
14327 : : }
14328 : :
14329 : : return new_vec;
14330 : : }
14331 : :
14332 : : /* Return the result of substituting ARGS into the template parameters
14333 : : given by PARMS. If there are m levels of ARGS and m + n levels of
14334 : : PARMS, then the result will contain n levels of PARMS. For
14335 : : example, if PARMS is `template <class T> template <class U>
14336 : : template <T*, U, class V>' and ARGS is {{int}, {double}} then the
14337 : : result will be `template <int*, double, class V>'. */
14338 : :
14339 : : static tree
14340 : 20995857 : tsubst_template_parms (tree parms, tree args, tsubst_flags_t complain)
14341 : : {
14342 : 20995857 : tree r = NULL_TREE;
14343 : 20995857 : tree* new_parms;
14344 : :
14345 : : /* When substituting into a template, we must set
14346 : : PROCESSING_TEMPLATE_DECL as the template parameters may be
14347 : : dependent if they are based on one-another, and the dependency
14348 : : predicates are short-circuit outside of templates. */
14349 : 20995857 : ++processing_template_decl;
14350 : :
14351 : 20995857 : for (new_parms = &r;
14352 : 125980917 : parms && TMPL_PARMS_DEPTH (parms) > TMPL_ARGS_DEPTH (args);
14353 : 41995576 : new_parms = &(TREE_CHAIN (*new_parms)),
14354 : 20997788 : parms = TREE_CHAIN (parms))
14355 : : {
14356 : 20997788 : tree new_vec = tsubst_template_parms_level (TREE_VALUE (parms),
14357 : : args, complain);
14358 : 41995576 : *new_parms =
14359 : 41995570 : tree_cons (size_int (TMPL_PARMS_DEPTH (parms)
14360 : : - TMPL_ARGS_DEPTH (args)),
14361 : : new_vec, NULL_TREE);
14362 : 41995576 : TEMPLATE_PARMS_CONSTRAINTS (*new_parms)
14363 : 41995576 : = TEMPLATE_PARMS_CONSTRAINTS (parms);
14364 : : }
14365 : :
14366 : 20995857 : --processing_template_decl;
14367 : :
14368 : 20995857 : return r;
14369 : : }
14370 : :
14371 : : /* Return the result of substituting ARGS into one template parameter
14372 : : given by T. T Must be a TREE_LIST which TREE_VALUE is the template
14373 : : parameter and which TREE_PURPOSE is the default argument of the
14374 : : template parameter. */
14375 : :
14376 : : static tree
14377 : 34003468 : tsubst_template_parm (tree t, tree args, tsubst_flags_t complain)
14378 : : {
14379 : 34003468 : tree default_value, parm_decl;
14380 : :
14381 : 34003468 : if (args == NULL_TREE
14382 : 34003468 : || t == NULL_TREE
14383 : 34003462 : || t == error_mark_node)
14384 : : return t;
14385 : :
14386 : 34003462 : gcc_assert (TREE_CODE (t) == TREE_LIST);
14387 : :
14388 : 34003462 : default_value = TREE_PURPOSE (t);
14389 : 34003462 : parm_decl = TREE_VALUE (t);
14390 : :
14391 : 34003462 : parm_decl = tsubst (parm_decl, args, complain, NULL_TREE);
14392 : 34003462 : if (TREE_CODE (parm_decl) == PARM_DECL
14393 : 34003462 : && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl), complain))
14394 : 29 : parm_decl = error_mark_node;
14395 : 34003462 : default_value = tsubst_template_arg (default_value, args,
14396 : : complain, NULL_TREE);
14397 : :
14398 : 34003462 : tree r = build_tree_list (default_value, parm_decl);
14399 : 34003462 : TEMPLATE_PARM_CONSTRAINTS (r) = TEMPLATE_PARM_CONSTRAINTS (t);
14400 : 34003462 : return r;
14401 : : }
14402 : :
14403 : : /* Substitute in-place the TEMPLATE_PARM_CONSTRAINTS of each template
14404 : : parameter in PARMS for sake of declaration matching. */
14405 : :
14406 : : static void
14407 : 417586 : tsubst_each_template_parm_constraints (tree parms, tree args,
14408 : : tsubst_flags_t complain)
14409 : : {
14410 : 417586 : ++processing_template_decl;
14411 : 835172 : for (; parms; parms = TREE_CHAIN (parms))
14412 : : {
14413 : 417586 : tree level = TREE_VALUE (parms);
14414 : 1298692 : for (tree parm : tree_vec_range (level))
14415 : 1762212 : TEMPLATE_PARM_CONSTRAINTS (parm)
14416 : 1762212 : = tsubst_constraint (TEMPLATE_PARM_CONSTRAINTS (parm), args,
14417 : : complain, NULL_TREE);
14418 : : }
14419 : 417586 : --processing_template_decl;
14420 : 417586 : }
14421 : :
14422 : : /* Map from a FUNCTION_DECL to a vec of default argument instantiations,
14423 : : indexed in reverse order of the parameters. */
14424 : :
14425 : : static GTY((cache)) hash_table<tree_vec_map_cache_hasher> *defarg_inst;
14426 : :
14427 : : /* Return a reference to the vec* of defarg insts for FN. */
14428 : :
14429 : : static vec<tree,va_gc> *&
14430 : 742994 : defarg_insts_for (tree fn)
14431 : : {
14432 : 742994 : if (!defarg_inst)
14433 : 12599 : defarg_inst = hash_table<tree_vec_map_cache_hasher>::create_ggc (13);
14434 : 742994 : tree_vec_map in = { { fn }, nullptr };
14435 : 742994 : tree_vec_map **slot
14436 : 742994 : = defarg_inst->find_slot_with_hash (&in, DECL_UID (fn), INSERT);
14437 : 742994 : if (!*slot)
14438 : : {
14439 : 469763 : *slot = ggc_alloc<tree_vec_map> ();
14440 : 469763 : **slot = in;
14441 : : }
14442 : 742994 : return (*slot)->to;
14443 : : }
14444 : :
14445 : : /* Substitute into the default argument ARG (a default argument for
14446 : : FN), which has the indicated TYPE. */
14447 : :
14448 : : tree
14449 : 752026 : tsubst_default_argument (tree fn, int parmnum, tree type, tree arg,
14450 : : tsubst_flags_t complain)
14451 : : {
14452 : 752026 : int errs = errorcount + sorrycount;
14453 : :
14454 : : /* This can happen in invalid code. */
14455 : 752026 : if (TREE_CODE (arg) == DEFERRED_PARSE)
14456 : : return arg;
14457 : :
14458 : : /* Shortcut {}. */
14459 : 19512 : if (BRACE_ENCLOSED_INITIALIZER_P (arg)
14460 : 761058 : && CONSTRUCTOR_NELTS (arg) == 0)
14461 : : return arg;
14462 : :
14463 : 742994 : tree parm = FUNCTION_FIRST_USER_PARM (fn);
14464 : 742994 : parm = chain_index (parmnum, parm);
14465 : 742994 : tree parmtype = TREE_TYPE (parm);
14466 : 742994 : if (DECL_BY_REFERENCE (parm))
14467 : 3 : parmtype = TREE_TYPE (parmtype);
14468 : 742994 : if (parmtype == error_mark_node)
14469 : : return error_mark_node;
14470 : :
14471 : 742994 : gcc_assert (same_type_ignoring_top_level_qualifiers_p (type, parmtype));
14472 : :
14473 : : /* Remember the location of the pointer to the vec rather than the location
14474 : : of the particular element, in case the vec grows in tsubst_expr. */
14475 : 742994 : vec<tree,va_gc> *&defs = defarg_insts_for (fn);
14476 : : /* Index in reverse order to avoid allocating space for initial parameters
14477 : : that don't have default arguments. */
14478 : 742994 : unsigned ridx = list_length (parm);
14479 : 1016225 : if (vec_safe_length (defs) < ridx)
14480 : 469783 : vec_safe_grow_cleared (defs, ridx);
14481 : 273211 : else if (tree inst = (*defs)[ridx - 1])
14482 : : return inst;
14483 : :
14484 : : /* This default argument came from a template. Instantiate the
14485 : : default argument here, not in tsubst. In the case of
14486 : : something like:
14487 : :
14488 : : template <class T>
14489 : : struct S {
14490 : : static T t();
14491 : : void f(T = t());
14492 : : };
14493 : :
14494 : : we must be careful to do name lookup in the scope of S<T>,
14495 : : rather than in the current class. */
14496 : 532727 : push_to_top_level ();
14497 : 532727 : push_access_scope (fn);
14498 : 532727 : push_deferring_access_checks (dk_no_deferred);
14499 : : /* So in_immediate_context knows this is a default argument. */
14500 : 532727 : begin_scope (sk_function_parms, fn);
14501 : 532727 : start_lambda_scope (parm);
14502 : :
14503 : : /* The default argument expression may cause implicitly defined
14504 : : member functions to be synthesized, which will result in garbage
14505 : : collection. We must treat this situation as if we were within
14506 : : the body of function so as to avoid collecting live data on the
14507 : : stack. */
14508 : 532727 : ++function_depth;
14509 : 532727 : arg = tsubst_expr (arg, DECL_TI_ARGS (fn), complain, NULL_TREE);
14510 : 532727 : --function_depth;
14511 : :
14512 : 532727 : finish_lambda_scope ();
14513 : :
14514 : : /* Make sure the default argument is reasonable. */
14515 : 532727 : arg = check_default_argument (type, arg, complain);
14516 : :
14517 : 532727 : if (errorcount+sorrycount > errs
14518 : 532727 : && (complain & tf_warning_or_error))
14519 : 15 : inform (input_location,
14520 : : " when instantiating default argument for call to %qD", fn);
14521 : :
14522 : 532727 : leave_scope ();
14523 : 532727 : pop_deferring_access_checks ();
14524 : 532727 : pop_access_scope (fn);
14525 : 532727 : pop_from_top_level ();
14526 : :
14527 : 532727 : if (arg != error_mark_node && !cp_unevaluated_operand)
14528 : 409805 : (*defs)[ridx - 1] = arg;
14529 : :
14530 : : return arg;
14531 : : }
14532 : :
14533 : : /* Substitute into all the default arguments for FN. */
14534 : :
14535 : : static void
14536 : 655825 : tsubst_default_arguments (tree fn, tsubst_flags_t complain)
14537 : : {
14538 : 655825 : tree arg;
14539 : 655825 : tree tmpl_args;
14540 : :
14541 : 655825 : tmpl_args = DECL_TI_ARGS (fn);
14542 : :
14543 : : /* If this function is not yet instantiated, we certainly don't need
14544 : : its default arguments. */
14545 : 655825 : if (uses_template_parms (tmpl_args))
14546 : : return;
14547 : : /* Don't do this again for clones. */
14548 : 655825 : if (DECL_CLONED_FUNCTION_P (fn))
14549 : : return;
14550 : :
14551 : 655825 : int i = 0;
14552 : 655825 : for (arg = TYPE_ARG_TYPES (TREE_TYPE (fn));
14553 : 2636370 : arg;
14554 : 1980545 : arg = TREE_CHAIN (arg), ++i)
14555 : 1980545 : if (TREE_PURPOSE (arg))
14556 : 12 : TREE_PURPOSE (arg) = tsubst_default_argument (fn, i,
14557 : 12 : TREE_VALUE (arg),
14558 : 12 : TREE_PURPOSE (arg),
14559 : : complain);
14560 : : }
14561 : :
14562 : : /* Hash table mapping a FUNCTION_DECL to its dependent explicit-specifier. */
14563 : : static GTY((cache)) decl_tree_cache_map *explicit_specifier_map;
14564 : :
14565 : : /* Store a pair to EXPLICIT_SPECIFIER_MAP. */
14566 : :
14567 : : void
14568 : 456027 : store_explicit_specifier (tree v, tree t)
14569 : : {
14570 : 456027 : if (!explicit_specifier_map)
14571 : 2954 : explicit_specifier_map = decl_tree_cache_map::create_ggc (37);
14572 : 456027 : DECL_HAS_DEPENDENT_EXPLICIT_SPEC_P (v) = true;
14573 : 456027 : explicit_specifier_map->put (v, t);
14574 : 456027 : }
14575 : :
14576 : : /* Lookup an element in EXPLICIT_SPECIFIER_MAP. */
14577 : :
14578 : : tree
14579 : 475200 : lookup_explicit_specifier (tree v)
14580 : : {
14581 : 475200 : return *explicit_specifier_map->get (v);
14582 : : }
14583 : :
14584 : : /* Given T, a FUNCTION_TYPE or METHOD_TYPE, construct and return a corresponding
14585 : : FUNCTION_TYPE or METHOD_TYPE whose return type is RETURN_TYPE, argument types
14586 : : are ARG_TYPES, and exception specification is RAISES, and otherwise is
14587 : : identical to T. */
14588 : :
14589 : : static tree
14590 : 123969087 : rebuild_function_or_method_type (tree t, tree args, tree return_type,
14591 : : tree arg_types, tree raises,
14592 : : tsubst_flags_t complain)
14593 : : {
14594 : 123969087 : gcc_assert (FUNC_OR_METHOD_TYPE_P (t));
14595 : :
14596 : 123969087 : tree new_type;
14597 : 123969087 : if (TREE_CODE (t) == FUNCTION_TYPE)
14598 : : {
14599 : 41668577 : new_type = build_function_type (return_type, arg_types);
14600 : 41668577 : new_type = apply_memfn_quals (new_type, type_memfn_quals (t));
14601 : : }
14602 : : else
14603 : : {
14604 : 82300510 : tree r = TREE_TYPE (TREE_VALUE (arg_types));
14605 : : /* Don't pick up extra function qualifiers from the basetype. */
14606 : 82300510 : r = cp_build_qualified_type (r, type_memfn_quals (t), complain);
14607 : 82300510 : if (! MAYBE_CLASS_TYPE_P (r))
14608 : : {
14609 : : /* [temp.deduct]
14610 : :
14611 : : Type deduction may fail for any of the following
14612 : : reasons:
14613 : :
14614 : : -- Attempting to create "pointer to member of T" when T
14615 : : is not a class type. */
14616 : 0 : if (complain & tf_error)
14617 : 0 : error ("creating pointer to member function of non-class type %qT",
14618 : : r);
14619 : 0 : return error_mark_node;
14620 : : }
14621 : :
14622 : 82300510 : new_type = build_method_type_directly (r, return_type,
14623 : 82300510 : TREE_CHAIN (arg_types));
14624 : : }
14625 : 123969087 : if (!apply_late_template_attributes (&new_type, TYPE_ATTRIBUTES (t), 0,
14626 : : args, complain, NULL_TREE))
14627 : 0 : return error_mark_node;
14628 : :
14629 : 123969087 : cp_ref_qualifier rqual = type_memfn_rqual (t);
14630 : 123969087 : bool late_return_type_p = TYPE_HAS_LATE_RETURN_TYPE (t);
14631 : 123969087 : return build_cp_fntype_variant (new_type, rqual, raises, late_return_type_p);
14632 : : }
14633 : :
14634 : : /* Check if the function type of DECL, a FUNCTION_DECL, agrees with the type of
14635 : : each of its formal parameters. If there is a disagreement then rebuild
14636 : : DECL's function type according to its formal parameter types, as part of a
14637 : : resolution for Core issues 1001/1322. */
14638 : :
14639 : : static void
14640 : 109138904 : maybe_rebuild_function_decl_type (tree decl, tree args)
14641 : : {
14642 : 109138904 : bool function_type_needs_rebuilding = false;
14643 : 109138904 : if (tree parm_list = FUNCTION_FIRST_USER_PARM (decl))
14644 : : {
14645 : 79905981 : tree parm_type_list = FUNCTION_FIRST_USER_PARMTYPE (decl);
14646 : 300878564 : while (parm_type_list && parm_type_list != void_list_node)
14647 : : {
14648 : 141066692 : tree parm_type = TREE_VALUE (parm_type_list);
14649 : 141066692 : tree formal_parm_type_unqual = strip_top_quals (TREE_TYPE (parm_list));
14650 : 141066692 : if (!same_type_p (parm_type, formal_parm_type_unqual))
14651 : : {
14652 : : function_type_needs_rebuilding = true;
14653 : : break;
14654 : : }
14655 : :
14656 : 141066602 : parm_list = DECL_CHAIN (parm_list);
14657 : 141066602 : parm_type_list = TREE_CHAIN (parm_type_list);
14658 : : }
14659 : : }
14660 : :
14661 : 79905981 : if (!function_type_needs_rebuilding)
14662 : 109138814 : return;
14663 : :
14664 : 90 : const tree fntype = TREE_TYPE (decl);
14665 : 90 : tree parm_list = DECL_ARGUMENTS (decl);
14666 : 90 : tree old_parm_type_list = TYPE_ARG_TYPES (fntype);
14667 : 90 : tree new_parm_type_list = NULL_TREE;
14668 : 90 : tree *q = &new_parm_type_list;
14669 : 111 : for (int skip = num_artificial_parms_for (decl); skip > 0; skip--)
14670 : : {
14671 : 21 : *q = copy_node (old_parm_type_list);
14672 : 21 : parm_list = DECL_CHAIN (parm_list);
14673 : 21 : old_parm_type_list = TREE_CHAIN (old_parm_type_list);
14674 : 21 : q = &TREE_CHAIN (*q);
14675 : : }
14676 : 183 : while (old_parm_type_list && old_parm_type_list != void_list_node)
14677 : : {
14678 : 93 : *q = copy_node (old_parm_type_list);
14679 : 93 : tree *new_parm_type = &TREE_VALUE (*q);
14680 : 93 : tree formal_parm_type_unqual = strip_top_quals (TREE_TYPE (parm_list));
14681 : 93 : if (!same_type_p (*new_parm_type, formal_parm_type_unqual))
14682 : 90 : *new_parm_type = formal_parm_type_unqual;
14683 : :
14684 : 93 : parm_list = DECL_CHAIN (parm_list);
14685 : 93 : old_parm_type_list = TREE_CHAIN (old_parm_type_list);
14686 : 93 : q = &TREE_CHAIN (*q);
14687 : : }
14688 : 90 : if (old_parm_type_list == void_list_node)
14689 : 90 : *q = void_list_node;
14690 : :
14691 : 90 : TREE_TYPE (decl)
14692 : 180 : = rebuild_function_or_method_type (fntype, args,
14693 : 90 : TREE_TYPE (fntype), new_parm_type_list,
14694 : 90 : TYPE_RAISES_EXCEPTIONS (fntype), tf_none);
14695 : : }
14696 : :
14697 : : /* Subroutine of tsubst_decl for the case when T is a FUNCTION_DECL. */
14698 : :
14699 : : static tree
14700 : 111438698 : tsubst_function_decl (tree t, tree args, tsubst_flags_t complain,
14701 : : tree lambda_fntype, bool use_spec_table = true)
14702 : : {
14703 : 111438698 : tree gen_tmpl = NULL_TREE, argvec = NULL_TREE;
14704 : 111438698 : hashval_t hash = 0;
14705 : 111438698 : tree in_decl = t;
14706 : :
14707 : : /* Nobody should be tsubst'ing into non-template functions. */
14708 : 111438698 : gcc_assert (DECL_TEMPLATE_INFO (t) != NULL_TREE
14709 : : || DECL_LOCAL_DECL_P (t));
14710 : :
14711 : 111438698 : if (DECL_LOCAL_DECL_P (t))
14712 : : {
14713 : 611 : if (tree spec = retrieve_local_specialization (t))
14714 : : return spec;
14715 : : }
14716 : 111438087 : else if (TREE_CODE (DECL_TI_TEMPLATE (t)) == TEMPLATE_DECL)
14717 : : {
14718 : : /* If T is not dependent, just return it. */
14719 : 111414428 : if (!uses_template_parms (DECL_TI_ARGS (t))
14720 : 111414465 : && !LAMBDA_FUNCTION_P (t))
14721 : : return t;
14722 : :
14723 : : /* A non-templated friend doesn't get DECL_TEMPLATE_INFO. */
14724 : 111037653 : if (non_templated_friend_p (t))
14725 : 147 : goto friend_case;
14726 : :
14727 : : /* Calculate the most general template of which R is a
14728 : : specialization. */
14729 : 111037506 : gen_tmpl = most_general_template (DECL_TI_TEMPLATE (t));
14730 : :
14731 : : /* We're substituting a lambda function under tsubst_lambda_expr but not
14732 : : directly from it; find the matching function we're already inside.
14733 : : But don't do this if T is a generic lambda with a single level of
14734 : : template parms, as in that case we're doing a normal instantiation. */
14735 : 112100153 : if (LAMBDA_FUNCTION_P (t) && !lambda_fntype
14736 : 111170396 : && (!generic_lambda_fn_p (t)
14737 : 132866 : || TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl)) > 1))
14738 : 57 : return enclosing_instantiation_of (t);
14739 : :
14740 : : /* Calculate the complete set of arguments used to
14741 : : specialize R. */
14742 : 111037449 : if (use_spec_table && !lambda_fntype)
14743 : : {
14744 : 71846050 : argvec = tsubst_template_args (DECL_TI_ARGS
14745 : : (DECL_TEMPLATE_RESULT
14746 : : (DECL_TI_TEMPLATE (t))),
14747 : : args, complain, in_decl);
14748 : 71846050 : if (argvec == error_mark_node)
14749 : : return error_mark_node;
14750 : :
14751 : : /* Check to see if we already have this specialization. */
14752 : 71846050 : hash = spec_hasher::hash (gen_tmpl, argvec);
14753 : 71846050 : if (tree spec = retrieve_specialization (gen_tmpl, argvec, hash))
14754 : : /* The spec for these args might be a partial instantiation of the
14755 : : template, but here what we want is the FUNCTION_DECL. */
14756 : 529149 : return STRIP_TEMPLATE (spec);
14757 : : }
14758 : : else
14759 : : argvec = args;
14760 : : }
14761 : : else
14762 : : {
14763 : : /* This special case arises when we have something like this:
14764 : :
14765 : : template <class T> struct S {
14766 : : friend void f<int>(int, double);
14767 : : };
14768 : :
14769 : : Here, the DECL_TI_TEMPLATE for the friend declaration
14770 : : will be an IDENTIFIER_NODE. We are being called from
14771 : : tsubst_friend_function, and we want only to create a
14772 : : new decl (R) with appropriate types so that we can call
14773 : : determine_specialization. */
14774 : 23659 : friend_case:
14775 : : gen_tmpl = NULL_TREE;
14776 : : argvec = NULL_TREE;
14777 : : }
14778 : :
14779 : 110532717 : tree closure = (lambda_fntype ? TYPE_METHOD_BASETYPE (lambda_fntype)
14780 : 110532717 : : NULL_TREE);
14781 : 110532717 : tree ctx = closure ? closure : DECL_CONTEXT (t);
14782 : 110532717 : bool member = ctx && TYPE_P (ctx);
14783 : :
14784 : : /* If this is a static or xobj lambda, remove the 'this' pointer added in
14785 : : tsubst_lambda_expr now that we know the closure type. */
14786 : 110532717 : if (lambda_fntype && !DECL_IOBJ_MEMBER_FUNCTION_P (t))
14787 : 113 : lambda_fntype = static_fn_type (lambda_fntype);
14788 : :
14789 : 110532717 : if (member && !closure)
14790 : 91596585 : ctx = tsubst_entering_scope (ctx, args, complain, t);
14791 : :
14792 : 110532717 : tree type = (lambda_fntype ? lambda_fntype
14793 : 110377841 : : tsubst (TREE_TYPE (t), args,
14794 : 110524581 : complain | tf_fndecl_type, in_decl));
14795 : 110524581 : if (type == error_mark_node)
14796 : : return error_mark_node;
14797 : :
14798 : : /* If we hit excessive deduction depth, the type is bogus even if
14799 : : it isn't error_mark_node, so don't build a decl. */
14800 : 109138925 : if (excessive_deduction_depth)
14801 : : return error_mark_node;
14802 : :
14803 : : /* We do NOT check for matching decls pushed separately at this
14804 : : point, as they may not represent instantiations of this
14805 : : template, and in any case are considered separate under the
14806 : : discrete model. */
14807 : 109138925 : tree r = copy_decl (t);
14808 : 109138925 : DECL_USE_TEMPLATE (r) = 0;
14809 : 109138925 : TREE_TYPE (r) = type;
14810 : : /* Clear out the mangled name and RTL for the instantiation. */
14811 : 109138925 : SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
14812 : 109138925 : SET_DECL_RTL (r, NULL);
14813 : : /* Leave DECL_INITIAL set on deleted instantiations. */
14814 : 109138925 : if (!DECL_DELETED_FN (r))
14815 : 107302419 : DECL_INITIAL (r) = NULL_TREE;
14816 : 109138925 : DECL_CONTEXT (r) = ctx;
14817 : 109138925 : set_instantiating_module (r);
14818 : :
14819 : : /* Handle explicit(dependent-expr). */
14820 : 109138925 : if (DECL_HAS_DEPENDENT_EXPLICIT_SPEC_P (t))
14821 : : {
14822 : 469464 : tree spec = lookup_explicit_specifier (t);
14823 : 469464 : spec = tsubst_expr (spec, args, complain, in_decl);
14824 : 469464 : spec = build_explicit_specifier (spec, complain);
14825 : 469464 : if (spec == error_mark_node)
14826 : : return error_mark_node;
14827 : 469443 : if (instantiation_dependent_expression_p (spec))
14828 : 336135 : store_explicit_specifier (r, spec);
14829 : : else
14830 : : {
14831 : 133308 : DECL_NONCONVERTING_P (r) = (spec == boolean_true_node);
14832 : 133308 : DECL_HAS_DEPENDENT_EXPLICIT_SPEC_P (r) = false;
14833 : : }
14834 : : }
14835 : :
14836 : : /* OpenMP UDRs have the only argument a reference to the declared
14837 : : type. We want to diagnose if the declared type is a reference,
14838 : : which is invalid, but as references to references are usually
14839 : : quietly merged, diagnose it here. */
14840 : 109138904 : if (DECL_OMP_DECLARE_REDUCTION_P (t))
14841 : : {
14842 : 264 : tree argtype
14843 : 264 : = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (t))));
14844 : 264 : argtype = tsubst (argtype, args, complain, in_decl);
14845 : 264 : if (TYPE_REF_P (argtype))
14846 : 6 : error_at (DECL_SOURCE_LOCATION (t),
14847 : : "reference type %qT in "
14848 : : "%<#pragma omp declare reduction%>", argtype);
14849 : 264 : if (strchr (IDENTIFIER_POINTER (DECL_NAME (t)), '~') == NULL)
14850 : 207 : DECL_NAME (r) = omp_reduction_id (ERROR_MARK, DECL_NAME (t),
14851 : : argtype);
14852 : : }
14853 : :
14854 : 109138904 : if (member && DECL_CONV_FN_P (r))
14855 : : /* Type-conversion operator. Reconstruct the name, in
14856 : : case it's the name of one of the template's parameters. */
14857 : 889624 : DECL_NAME (r) = make_conv_op_name (TREE_TYPE (type));
14858 : :
14859 : 109138904 : tree parms = DECL_ARGUMENTS (t);
14860 : 109138904 : if (closure && DECL_IOBJ_MEMBER_FUNCTION_P (t))
14861 : 154763 : parms = DECL_CHAIN (parms);
14862 : 109138904 : parms = tsubst (parms, args, complain, t);
14863 : 332387035 : for (tree parm = parms; parm; parm = DECL_CHAIN (parm))
14864 : 223248131 : DECL_CONTEXT (parm) = r;
14865 : 109138904 : if (closure && DECL_IOBJ_MEMBER_FUNCTION_P (t))
14866 : : {
14867 : 154763 : tree tparm = build_this_parm (r, closure, type_memfn_quals (type));
14868 : 154763 : DECL_NAME (tparm) = closure_identifier;
14869 : 154763 : DECL_CHAIN (tparm) = parms;
14870 : 154763 : parms = tparm;
14871 : : }
14872 : 109138904 : DECL_ARGUMENTS (r) = parms;
14873 : 109138904 : DECL_RESULT (r) = NULL_TREE;
14874 : :
14875 : 109138904 : maybe_rebuild_function_decl_type (r, args);
14876 : :
14877 : 109138904 : TREE_STATIC (r) = 0;
14878 : 109138904 : TREE_PUBLIC (r) = TREE_PUBLIC (t);
14879 : 109138904 : DECL_EXTERNAL (r) = 1;
14880 : : /* If this is an instantiation of a function with internal
14881 : : linkage, we already know what object file linkage will be
14882 : : assigned to the instantiation. */
14883 : 109138904 : DECL_INTERFACE_KNOWN (r) = !TREE_PUBLIC (r);
14884 : 109138904 : DECL_DEFER_OUTPUT (r) = 0;
14885 : 109138904 : DECL_CHAIN (r) = NULL_TREE;
14886 : 109138904 : DECL_PENDING_INLINE_INFO (r) = 0;
14887 : 109138904 : DECL_PENDING_INLINE_P (r) = 0;
14888 : 109138904 : DECL_SAVED_TREE (r) = NULL_TREE;
14889 : 109138904 : DECL_STRUCT_FUNCTION (r) = NULL;
14890 : 109138904 : TREE_USED (r) = 0;
14891 : : /* We'll re-clone as appropriate in instantiate_template. */
14892 : 109138904 : DECL_CLONED_FUNCTION (r) = NULL_TREE;
14893 : :
14894 : : /* If we aren't complaining now, return on error before we register
14895 : : the specialization so that we'll complain eventually. */
14896 : 109138904 : if ((complain & tf_error) == 0
14897 : 20072309 : && IDENTIFIER_ANY_OP_P (DECL_NAME (r))
14898 : 110597697 : && !grok_op_properties (r, /*complain=*/false))
14899 : 3 : return error_mark_node;
14900 : :
14901 : : /* If we are looking at an xobj lambda, we might need to check the type of
14902 : : its xobj parameter. */
14903 : 110200589 : if (LAMBDA_FUNCTION_P (r) && DECL_XOBJ_MEMBER_FUNCTION_P (r))
14904 : : {
14905 : 543 : tree closure_obj = DECL_CONTEXT (r);
14906 : 543 : tree lambda_expr = CLASSTYPE_LAMBDA_EXPR (closure_obj);
14907 : 543 : tree obj_param = TREE_TYPE (DECL_ARGUMENTS (r));
14908 : :
14909 : 543 : if (!(LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr) != CPLD_NONE
14910 : 388 : || LAMBDA_EXPR_CAPTURE_LIST (lambda_expr)))
14911 : : /* If a lambda has an empty capture clause, an xobj parameter of
14912 : : unrelated type is not an error. */;
14913 : 405 : else if (dependent_type_p (obj_param))
14914 : : /* If we are coming from tsubst_lambda_expr we might not have
14915 : : substituted into our xobj parameter yet. We can't error out until
14916 : : we know what the type really is so do nothing...
14917 : : ...but if we are instantiating the call op for real and we don't
14918 : : have a real type then something has gone incredibly wrong. */
14919 : 95 : gcc_assert (lambda_fntype);
14920 : : else
14921 : : {
14922 : : /* We have a lambda with captures, and know the type of the xobj
14923 : : parameter, time to check it. */
14924 : 310 : tree obj_param_type = TYPE_MAIN_VARIANT (non_reference (obj_param));
14925 : 310 : if (!same_or_base_type_p (closure_obj, obj_param_type))
14926 : : {
14927 : : /* This error does not emit when the lambda's call operator
14928 : : template is instantiated by taking its address, such as in
14929 : : the following case:
14930 : :
14931 : : auto f = [x = 0](this auto&&){};
14932 : : int (*fp)(int&) = &decltype(f)::operator();
14933 : :
14934 : : It only emits when explicitly calling the call operator with
14935 : : an explicit template parameter:
14936 : :
14937 : : template<typename T>
14938 : : struct S : T {
14939 : : using T::operator();
14940 : : operator int() const {return {};}
14941 : : };
14942 : :
14943 : : auto s = S{[x = 0](this auto&&) {}};
14944 : : s.operator()<int>();
14945 : :
14946 : : This is due to resolve_address_of_overloaded_function being
14947 : : deficient at reporting candidates when overload resolution
14948 : : fails.
14949 : :
14950 : : This diagnostic will be active in the first case if/when
14951 : : resolve_address_of_overloaded_function is fixed to properly
14952 : : emit candidates upon failure to resolve to an overload. */
14953 : 36 : if (complain & tf_error)
14954 : 2 : error ("a lambda with captures may not have an explicit "
14955 : : "object parameter of an unrelated type");
14956 : 36 : return error_mark_node;
14957 : : }
14958 : : }
14959 : : }
14960 : :
14961 : : /* Associate the constraints directly with the instantiation. We
14962 : : don't substitute through the constraints; that's only done when
14963 : : they are checked. */
14964 : 109138865 : if (tree ci = get_constraints (t))
14965 : 2087445 : set_constraints (r, ci);
14966 : :
14967 : 215069560 : if (DECL_FRIEND_CONTEXT (t))
14968 : 1092477 : SET_DECL_FRIEND_CONTEXT (r,
14969 : : tsubst (DECL_FRIEND_CONTEXT (t),
14970 : : args, complain, in_decl));
14971 : :
14972 : 109138865 : if (!apply_late_template_attributes (&r, DECL_ATTRIBUTES (r), 0,
14973 : : args, complain, in_decl))
14974 : 15 : return error_mark_node;
14975 : :
14976 : : /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
14977 : : this in the special friend case mentioned above where
14978 : : GEN_TMPL is NULL. */
14979 : 109138850 : if (gen_tmpl && !closure)
14980 : : {
14981 : 108959560 : DECL_TEMPLATE_INFO (r)
14982 : 108959560 : = build_template_info (gen_tmpl, argvec);
14983 : 108959560 : SET_DECL_IMPLICIT_INSTANTIATION (r);
14984 : :
14985 : 108959560 : if (use_spec_table)
14986 : : {
14987 : 71316819 : tree new_r
14988 : 71316819 : = register_specialization (r, gen_tmpl, argvec, false, hash);
14989 : 71316819 : if (new_r != r)
14990 : : /* We instantiated this while substituting into
14991 : : the type earlier (template/friend54.C). */
14992 : : return new_r;
14993 : : }
14994 : :
14995 : : /* We're not supposed to instantiate default arguments
14996 : : until they are called, for a template. But, for a
14997 : : declaration like:
14998 : :
14999 : : template <class T> void f ()
15000 : : { extern void g(int i = T()); }
15001 : :
15002 : : we should do the substitution when the template is
15003 : : instantiated. We handle the member function case in
15004 : : instantiate_class_template since the default arguments
15005 : : might refer to other members of the class. */
15006 : 108959560 : if (!member
15007 : 17516259 : && !PRIMARY_TEMPLATE_P (gen_tmpl)
15008 : 109615385 : && !uses_template_parms (argvec))
15009 : 655825 : tsubst_default_arguments (r, complain);
15010 : : }
15011 : 179290 : else if (DECL_LOCAL_DECL_P (r))
15012 : : {
15013 : 611 : if (!cp_unevaluated_operand)
15014 : 611 : register_local_specialization (r, t);
15015 : : }
15016 : : else
15017 : 178679 : DECL_TEMPLATE_INFO (r) = NULL_TREE;
15018 : :
15019 : : /* Copy the list of befriending classes. */
15020 : 109138850 : for (tree *friends = &DECL_BEFRIENDING_CLASSES (r);
15021 : 110073787 : *friends;
15022 : 934937 : friends = &TREE_CHAIN (*friends))
15023 : : {
15024 : 934937 : *friends = copy_node (*friends);
15025 : 934937 : TREE_VALUE (*friends)
15026 : 1869874 : = tsubst (TREE_VALUE (*friends), args, complain, in_decl);
15027 : : }
15028 : :
15029 : 218277700 : if (DECL_CONSTRUCTOR_P (r) || DECL_DESTRUCTOR_P (r))
15030 : : {
15031 : 21707643 : maybe_retrofit_in_chrg (r);
15032 : 43415286 : if (DECL_CONSTRUCTOR_P (r) && !grok_ctor_properties (ctx, r))
15033 : 6 : return error_mark_node;
15034 : : /* If this is an instantiation of a member template, clone it.
15035 : : If it isn't, that'll be handled by
15036 : : clone_constructors_and_destructors. */
15037 : 43415268 : if (gen_tmpl && PRIMARY_TEMPLATE_P (gen_tmpl))
15038 : 7711681 : clone_cdtor (r, /*update_methods=*/false);
15039 : : }
15040 : 87431207 : else if ((complain & tf_error) != 0
15041 : 68320742 : && IDENTIFIER_ANY_OP_P (DECL_NAME (r))
15042 : 103850722 : && !grok_op_properties (r, /*complain=*/true))
15043 : 3 : return error_mark_node;
15044 : :
15045 : : /* Possibly limit visibility based on template args. */
15046 : 109138841 : DECL_VISIBILITY (r) = VISIBILITY_DEFAULT;
15047 : 109138841 : if (DECL_VISIBILITY_SPECIFIED (t))
15048 : : {
15049 : 89475012 : DECL_VISIBILITY_SPECIFIED (r) = 0;
15050 : 89475012 : DECL_ATTRIBUTES (r)
15051 : 178950024 : = remove_attribute ("visibility", DECL_ATTRIBUTES (r));
15052 : : }
15053 : 109138841 : determine_visibility (r);
15054 : 109138841 : if (DECL_SECTION_NAME (t))
15055 : 6 : set_decl_section_name (r, t);
15056 : 112592589 : if (DECL_DEFAULTED_OUTSIDE_CLASS_P (r)
15057 : 43029 : && COMPLETE_TYPE_P (DECL_CONTEXT (r))
15058 : 109138841 : && !processing_template_decl)
15059 : 0 : defaulted_late_check (r);
15060 : :
15061 : 109138841 : if (flag_openmp)
15062 : 50317 : if (tree attr = lookup_attribute ("omp declare variant base",
15063 : 50317 : DECL_ATTRIBUTES (r)))
15064 : 96 : omp_declare_variant_finalize (r, attr);
15065 : :
15066 : 109138841 : return r;
15067 : : }
15068 : :
15069 : : /* Subroutine of tsubst_decl for the case when T is a TEMPLATE_DECL. */
15070 : :
15071 : : static tree
15072 : 21312252 : tsubst_template_decl (tree t, tree args, tsubst_flags_t complain,
15073 : : tree lambda_fntype, tree lambda_tparms)
15074 : : {
15075 : : /* We can get here when processing a member function template,
15076 : : member class template, or template template parameter. */
15077 : 21312252 : tree decl = DECL_TEMPLATE_RESULT (t);
15078 : 21312252 : tree in_decl = t;
15079 : 21312252 : tree spec;
15080 : 21312252 : tree tmpl_args;
15081 : 21312252 : tree full_args = NULL_TREE;
15082 : 21312252 : tree r;
15083 : 21312252 : hashval_t hash = 0;
15084 : :
15085 : 21312252 : if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
15086 : : {
15087 : : /* Template template parameter is treated here. */
15088 : 15585 : tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
15089 : 15585 : if (new_type == error_mark_node)
15090 : : r = error_mark_node;
15091 : : /* If we get a real template back, return it. This can happen in
15092 : : the context of most_specialized_partial_spec. */
15093 : 15585 : else if (TREE_CODE (new_type) == TEMPLATE_DECL)
15094 : : r = new_type;
15095 : : else
15096 : : /* The new TEMPLATE_DECL was built in
15097 : : reduce_template_parm_level. */
15098 : 31170 : r = TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (new_type);
15099 : 15585 : return r;
15100 : : }
15101 : :
15102 : 21296667 : if (!lambda_fntype)
15103 : : {
15104 : : /* We might already have an instance of this template.
15105 : : The ARGS are for the surrounding class type, so the
15106 : : full args contain the tsubst'd args for the context,
15107 : : plus the innermost args from the template decl. */
15108 : 21278738 : tmpl_args = DECL_CLASS_TEMPLATE_P (t)
15109 : 1530996 : ? CLASSTYPE_TI_ARGS (TREE_TYPE (t))
15110 : 19747742 : : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t));
15111 : : /* Because this is a template, the arguments will still be
15112 : : dependent, even after substitution. If
15113 : : PROCESSING_TEMPLATE_DECL is not set, the dependency
15114 : : predicates will short-circuit. */
15115 : 21278738 : ++processing_template_decl;
15116 : 21278738 : full_args = tsubst_template_args (tmpl_args, args,
15117 : : complain, in_decl);
15118 : 21278738 : --processing_template_decl;
15119 : 21278738 : if (full_args == error_mark_node)
15120 : : return error_mark_node;
15121 : :
15122 : : /* If this is a default template template argument,
15123 : : tsubst might not have changed anything. */
15124 : 21278720 : if (full_args == tmpl_args)
15125 : : return t;
15126 : :
15127 : 21278720 : hash = spec_hasher::hash (t, full_args);
15128 : 21278720 : spec = retrieve_specialization (t, full_args, hash);
15129 : 21278720 : if (spec != NULL_TREE)
15130 : : {
15131 : 659154 : if (TYPE_P (spec))
15132 : : /* Type partial instantiations are stored as the type by
15133 : : lookup_template_class_1, not here as the template. */
15134 : 659008 : spec = CLASSTYPE_TI_TEMPLATE (spec);
15135 : 146 : else if (TREE_CODE (spec) != TEMPLATE_DECL)
15136 : 146 : spec = DECL_TI_TEMPLATE (spec);
15137 : 659154 : return spec;
15138 : : }
15139 : : }
15140 : :
15141 : : /* Make a new template decl. It will be similar to the
15142 : : original, but will record the current template arguments.
15143 : : We also create a new function declaration, which is just
15144 : : like the old one, but points to this new template, rather
15145 : : than the old one. */
15146 : 20637495 : r = copy_decl (t);
15147 : 20637495 : gcc_assert (DECL_LANG_SPECIFIC (r) != 0);
15148 : 20637495 : DECL_CHAIN (r) = NULL_TREE;
15149 : :
15150 : : // Build new template info linking to the original template decl.
15151 : 20637495 : if (!lambda_fntype)
15152 : : {
15153 : 20619566 : DECL_TEMPLATE_INFO (r) = build_template_info (t, args);
15154 : 20619566 : SET_DECL_IMPLICIT_INSTANTIATION (r);
15155 : : }
15156 : : else
15157 : 17929 : DECL_TEMPLATE_INFO (r) = NULL_TREE;
15158 : :
15159 : : /* The template parameters for this new template are all the
15160 : : template parameters for the old template, except the
15161 : : outermost level of parameters. */
15162 : 20637495 : auto tparm_guard = make_temp_override (current_template_parms);
15163 : 41274990 : DECL_TEMPLATE_PARMS (r)
15164 : 41274990 : = current_template_parms
15165 : 20637495 : = (lambda_tparms
15166 : 20637495 : ? lambda_tparms
15167 : 20619566 : : tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
15168 : : complain));
15169 : :
15170 : 20637495 : bool class_p = false;
15171 : 20637495 : tree inner = decl;
15172 : 20637495 : ++processing_template_decl;
15173 : 20637495 : if (TREE_CODE (inner) == FUNCTION_DECL)
15174 : 17588663 : inner = tsubst_function_decl (inner, args, complain, lambda_fntype,
15175 : : /*use_spec_table=*/false);
15176 : : else
15177 : : {
15178 : 3048832 : if (TREE_CODE (inner) == TYPE_DECL && !TYPE_DECL_ALIAS_P (inner))
15179 : : {
15180 : 871973 : class_p = true;
15181 : 871973 : inner = TREE_TYPE (inner);
15182 : : }
15183 : 3048832 : if (class_p)
15184 : 871973 : inner = tsubst_entering_scope (inner, args, complain, in_decl);
15185 : : else
15186 : 2176859 : inner = tsubst_decl (inner, args, complain, /*use_spec_table=*/false);
15187 : : }
15188 : 20637495 : --processing_template_decl;
15189 : 20637495 : if (inner == error_mark_node)
15190 : : return error_mark_node;
15191 : :
15192 : 20637439 : if (class_p)
15193 : : {
15194 : : /* For a partial specialization, we need to keep pointing to
15195 : : the primary template. */
15196 : 871955 : if (!DECL_TEMPLATE_SPECIALIZATION (t))
15197 : : {
15198 : 690669 : CLASSTYPE_TI_TEMPLATE (inner) = r;
15199 : 690669 : CLASSTYPE_USE_TEMPLATE (inner) = 0;
15200 : : }
15201 : :
15202 : 871955 : DECL_TI_ARGS (r) = CLASSTYPE_TI_ARGS (inner);
15203 : 871955 : inner = TYPE_MAIN_DECL (inner);
15204 : : }
15205 : 19765484 : else if (lambda_fntype)
15206 : : {
15207 : 17929 : tree args = template_parms_to_args (DECL_TEMPLATE_PARMS (r));
15208 : 17929 : DECL_TEMPLATE_INFO (inner) = build_template_info (r, args);
15209 : : }
15210 : : else
15211 : : {
15212 : 19747555 : DECL_TI_TEMPLATE (inner) = r;
15213 : : /* Set DECL_TI_ARGS to the full set of template arguments,
15214 : : which tsubst_function_decl / tsubst_decl didn't do due to
15215 : : use_spec_table=false. */
15216 : 19747555 : DECL_TI_ARGS (inner) = full_args;
15217 : 19747555 : DECL_TI_ARGS (r) = DECL_TI_ARGS (inner);
15218 : : }
15219 : :
15220 : 20637439 : DECL_TEMPLATE_RESULT (r) = inner;
15221 : 20637439 : TREE_TYPE (r) = TREE_TYPE (inner);
15222 : 20637439 : DECL_CONTEXT (r) = DECL_CONTEXT (inner);
15223 : :
15224 : 20637439 : if (modules_p ())
15225 : : {
15226 : : /* Propagate module information from the decl. */
15227 : 77419 : DECL_MODULE_EXPORT_P (r) = DECL_MODULE_EXPORT_P (inner);
15228 : 77419 : if (DECL_LANG_SPECIFIC (inner))
15229 : : /* If this is a constrained template, the above tsubst of
15230 : : inner can find the unconstrained template, which may have
15231 : : come from an import. This is ok, because we don't
15232 : : register this instantiation (see below). */
15233 : 75785 : gcc_checking_assert (!DECL_MODULE_IMPORT_P (inner)
15234 : : || (TEMPLATE_PARMS_CONSTRAINTS
15235 : : (DECL_TEMPLATE_PARMS (t))));
15236 : : }
15237 : :
15238 : 20637439 : DECL_TEMPLATE_INSTANTIATIONS (r) = NULL_TREE;
15239 : 20637439 : DECL_TEMPLATE_SPECIALIZATIONS (r) = NULL_TREE;
15240 : :
15241 : 20637439 : if (PRIMARY_TEMPLATE_P (t))
15242 : 20455055 : DECL_PRIMARY_TEMPLATE (r) = r;
15243 : :
15244 : 20637439 : if (!lambda_fntype && !class_p)
15245 : : {
15246 : : /* Record this non-type partial instantiation. */
15247 : : /* FIXME we'd like to always register the TEMPLATE_DECL, or always
15248 : : the DECL_TEMPLATE_RESULT, but it seems the modules code relies
15249 : : on this current behavior. */
15250 : 19747555 : if (TREE_CODE (inner) == FUNCTION_DECL)
15251 : 17570696 : register_specialization (r, t, full_args, false, hash);
15252 : : else
15253 : 2176859 : register_specialization (inner, t, full_args, false, hash);
15254 : : }
15255 : :
15256 : : return r;
15257 : 20637495 : }
15258 : :
15259 : : /* True if FN is the op() for a lambda in an uninstantiated template. */
15260 : :
15261 : : bool
15262 : 770079892 : lambda_fn_in_template_p (tree fn)
15263 : : {
15264 : 773848725 : if (!fn || !LAMBDA_FUNCTION_P (fn))
15265 : : return false;
15266 : 669969 : tree closure = DECL_CONTEXT (fn);
15267 : 669969 : return CLASSTYPE_TEMPLATE_INFO (closure) != NULL_TREE;
15268 : : }
15269 : :
15270 : : /* True if FN is the substitution (via tsubst_lambda_expr) of a function for
15271 : : which the above is true. */
15272 : :
15273 : : bool
15274 : 244517526 : regenerated_lambda_fn_p (tree fn)
15275 : : {
15276 : 247098658 : if (!fn || !LAMBDA_FUNCTION_P (fn))
15277 : : return false;
15278 : 789364 : tree closure = DECL_CONTEXT (fn);
15279 : 789364 : tree lam = CLASSTYPE_LAMBDA_EXPR (closure);
15280 : 789364 : return LAMBDA_EXPR_REGEN_INFO (lam) != NULL_TREE;
15281 : : }
15282 : :
15283 : : /* Return the LAMBDA_EXPR from which T was ultimately regenerated.
15284 : : If T is not a regenerated LAMBDA_EXPR, return T. */
15285 : :
15286 : : tree
15287 : 357346 : most_general_lambda (tree t)
15288 : : {
15289 : 714962 : while (tree ti = LAMBDA_EXPR_REGEN_INFO (t))
15290 : 357616 : t = TI_TEMPLATE (ti);
15291 : 357346 : return t;
15292 : : }
15293 : :
15294 : : /* Return the set of template arguments used to regenerate the lambda T
15295 : : from its most general lambda. */
15296 : :
15297 : : tree
15298 : 229028 : lambda_regenerating_args (tree t)
15299 : : {
15300 : 458056 : if (LAMBDA_FUNCTION_P (t))
15301 : 229028 : t = CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (t));
15302 : 229028 : gcc_assert (TREE_CODE (t) == LAMBDA_EXPR);
15303 : 229028 : if (tree ti = LAMBDA_EXPR_REGEN_INFO (t))
15304 : 229028 : return TI_ARGS (ti);
15305 : : else
15306 : : return NULL_TREE;
15307 : : }
15308 : :
15309 : : /* We're instantiating a variable from template function TCTX. Return the
15310 : : corresponding current enclosing scope. We can match them up using
15311 : : DECL_SOURCE_LOCATION because lambdas only ever have one source location, and
15312 : : the DECL_SOURCE_LOCATION for a function instantiation is updated to match
15313 : : the template definition in regenerate_decl_from_template. */
15314 : :
15315 : : static tree
15316 : 98474 : enclosing_instantiation_of (tree tctx)
15317 : : {
15318 : 98474 : tree fn = current_function_decl;
15319 : :
15320 : : /* We shouldn't ever need to do this for other artificial functions. */
15321 : 98576 : gcc_assert (!DECL_ARTIFICIAL (tctx) || LAMBDA_FUNCTION_P (tctx));
15322 : :
15323 : 98477 : for (; fn; fn = decl_function_context (fn))
15324 : 98477 : if (DECL_SOURCE_LOCATION (fn) == DECL_SOURCE_LOCATION (tctx))
15325 : 98474 : return fn;
15326 : 0 : gcc_unreachable ();
15327 : : }
15328 : :
15329 : : /* Substitute the ARGS into the T, which is a _DECL. Return the
15330 : : result of the substitution. Issue error and warning messages under
15331 : : control of COMPLAIN. The flag USE_SPEC_TABLE controls if we look up
15332 : : and insert into the specializations table or if we can assume it's
15333 : : the caller's responsibility; this is used by instantiate_template
15334 : : to avoid doing some redundant work. */
15335 : :
15336 : : static tree
15337 : 542721816 : tsubst_decl (tree t, tree args, tsubst_flags_t complain,
15338 : : bool use_spec_table /* = true */)
15339 : : {
15340 : : #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
15341 : 542721816 : location_t saved_loc;
15342 : 542721816 : tree r = NULL_TREE;
15343 : 542721816 : tree in_decl = t;
15344 : 542721816 : hashval_t hash = 0;
15345 : :
15346 : 542721816 : if (t == error_mark_node)
15347 : : return error_mark_node;
15348 : :
15349 : : /* Set the filename and linenumber to improve error-reporting. */
15350 : 542721813 : saved_loc = input_location;
15351 : 542721813 : input_location = DECL_SOURCE_LOCATION (t);
15352 : :
15353 : 542721813 : switch (TREE_CODE (t))
15354 : : {
15355 : 21294323 : case TEMPLATE_DECL:
15356 : 21294323 : r = tsubst_template_decl (t, args, complain,
15357 : : /*lambda_fntype=*/NULL_TREE,
15358 : : /*lambda_tparms=*/NULL_TREE);
15359 : 21294323 : break;
15360 : :
15361 : 93713088 : case FUNCTION_DECL:
15362 : 93713088 : r = tsubst_function_decl (t, args, complain, /*lambda*/NULL_TREE,
15363 : : use_spec_table);
15364 : 93704952 : break;
15365 : :
15366 : 250209416 : case PARM_DECL:
15367 : 250209416 : {
15368 : 250209416 : tree type = NULL_TREE;
15369 : 250209416 : int i, len = 1;
15370 : 250209416 : tree expanded_types = NULL_TREE;
15371 : 250209416 : tree prev_r = NULL_TREE;
15372 : 250209416 : tree first_r = NULL_TREE;
15373 : :
15374 : 250209416 : if (DECL_PACK_P (t))
15375 : : {
15376 : : /* If there is a local specialization that isn't a
15377 : : parameter pack, it means that we're doing a "simple"
15378 : : substitution from inside tsubst_pack_expansion. Just
15379 : : return the local specialization (which will be a single
15380 : : parm). */
15381 : 2915313 : tree spec = retrieve_local_specialization (t);
15382 : 2915313 : if (spec
15383 : 33 : && TREE_CODE (spec) == PARM_DECL
15384 : 2915319 : && TREE_CODE (TREE_TYPE (spec)) != TYPE_PACK_EXPANSION)
15385 : 0 : RETURN (spec);
15386 : :
15387 : : /* Expand the TYPE_PACK_EXPANSION that provides the types for
15388 : : the parameters in this function parameter pack. */
15389 : 2915313 : expanded_types = tsubst_pack_expansion (TREE_TYPE (t), args,
15390 : : complain, in_decl);
15391 : 2915313 : if (TREE_CODE (expanded_types) == TREE_VEC)
15392 : : {
15393 : 1218340 : len = TREE_VEC_LENGTH (expanded_types);
15394 : :
15395 : : /* Zero-length parameter packs are boring. Just substitute
15396 : : into the chain. */
15397 : 1218340 : if (len == 0 && !cp_unevaluated_operand)
15398 : 571517 : RETURN (tsubst (TREE_CHAIN (t), args, complain,
15399 : : TREE_CHAIN (t)));
15400 : : }
15401 : : else
15402 : : {
15403 : : /* All we did was update the type. Make a note of that. */
15404 : : type = expanded_types;
15405 : : expanded_types = NULL_TREE;
15406 : : }
15407 : : }
15408 : :
15409 : : /* Loop through all of the parameters we'll build. When T is
15410 : : a function parameter pack, LEN is the number of expanded
15411 : : types in EXPANDED_TYPES; otherwise, LEN is 1. */
15412 : 249637899 : r = NULL_TREE;
15413 : 499461122 : for (i = 0; i < len; ++i)
15414 : : {
15415 : 249823223 : prev_r = r;
15416 : 249823223 : r = copy_node (t);
15417 : 249823223 : if (DECL_TEMPLATE_PARM_P (t))
15418 : 3108771 : SET_DECL_TEMPLATE_PARM_P (r);
15419 : :
15420 : 249823223 : if (expanded_types)
15421 : : /* We're on the Ith parameter of the function parameter
15422 : : pack. */
15423 : : {
15424 : : /* Get the Ith type. */
15425 : 832147 : type = TREE_VEC_ELT (expanded_types, i);
15426 : :
15427 : : /* Rename the parameter to include the index. */
15428 : 832147 : DECL_NAME (r)
15429 : 1664294 : = make_ith_pack_parameter_name (DECL_NAME (r), i);
15430 : : }
15431 : 248991076 : else if (!type)
15432 : : /* We're dealing with a normal parameter. */
15433 : 247294103 : type = tsubst (TREE_TYPE (t), args, complain, in_decl);
15434 : :
15435 : 249823223 : type = type_decays_to (type);
15436 : 249823223 : TREE_TYPE (r) = type;
15437 : 249823223 : cp_apply_type_quals_to_decl (cp_type_quals (type), r);
15438 : :
15439 : 249823223 : if (DECL_INITIAL (r))
15440 : : {
15441 : 38643932 : if (TREE_CODE (DECL_INITIAL (r)) != TEMPLATE_PARM_INDEX)
15442 : 35535161 : DECL_INITIAL (r) = TREE_TYPE (r);
15443 : : else
15444 : 3108771 : DECL_INITIAL (r) = tsubst (DECL_INITIAL (r), args,
15445 : : complain, in_decl);
15446 : : }
15447 : :
15448 : 249823223 : DECL_CONTEXT (r) = NULL_TREE;
15449 : :
15450 : 249823223 : if (!DECL_TEMPLATE_PARM_P (r))
15451 : 246714452 : DECL_ARG_TYPE (r) = type_passed_as (type);
15452 : :
15453 : 249823223 : if (!apply_late_template_attributes (&r, DECL_ATTRIBUTES (r), 0,
15454 : : args, complain, in_decl))
15455 : 0 : return error_mark_node;
15456 : :
15457 : : /* Keep track of the first new parameter we
15458 : : generate. That's what will be returned to the
15459 : : caller. */
15460 : 249823223 : if (!first_r)
15461 : 249637738 : first_r = r;
15462 : :
15463 : : /* Build a proper chain of parameters when substituting
15464 : : into a function parameter pack. */
15465 : 249823223 : if (prev_r)
15466 : 185485 : DECL_CHAIN (prev_r) = r;
15467 : : }
15468 : :
15469 : : /* If cp_unevaluated_operand is set, we're just looking for a
15470 : : single dummy parameter, so don't keep going. */
15471 : 249637899 : if (DECL_CHAIN (t) && !cp_unevaluated_operand)
15472 : 131606792 : DECL_CHAIN (r) = tsubst (DECL_CHAIN (t), args,
15473 : 131606792 : complain, DECL_CHAIN (t));
15474 : :
15475 : : /* FIRST_R contains the start of the chain we've built. */
15476 : 249637899 : r = first_r;
15477 : : }
15478 : 249637899 : break;
15479 : :
15480 : 6392538 : case FIELD_DECL:
15481 : 6392538 : {
15482 : 6392538 : tree type = NULL_TREE;
15483 : 6392538 : tree vec = NULL_TREE;
15484 : 6392538 : tree expanded_types = NULL_TREE;
15485 : 6392538 : int len = 1;
15486 : :
15487 : 6392538 : if (PACK_EXPANSION_P (TREE_TYPE (t)))
15488 : : {
15489 : : /* This field is a lambda capture pack. Return a TREE_VEC of
15490 : : the expanded fields to instantiate_class_template_1. */
15491 : 83 : expanded_types = tsubst_pack_expansion (TREE_TYPE (t), args,
15492 : : complain, in_decl);
15493 : 83 : if (TREE_CODE (expanded_types) == TREE_VEC)
15494 : : {
15495 : 74 : len = TREE_VEC_LENGTH (expanded_types);
15496 : 74 : vec = make_tree_vec (len);
15497 : : }
15498 : : else
15499 : : {
15500 : : /* All we did was update the type. Make a note of that. */
15501 : : type = expanded_types;
15502 : : expanded_types = NULL_TREE;
15503 : : }
15504 : : }
15505 : :
15506 : 12784954 : for (int i = 0; i < len; ++i)
15507 : : {
15508 : 6392573 : r = copy_decl (t);
15509 : 6392573 : if (expanded_types)
15510 : : {
15511 : 109 : type = TREE_VEC_ELT (expanded_types, i);
15512 : 109 : DECL_NAME (r)
15513 : 218 : = make_ith_pack_parameter_name (DECL_NAME (r), i);
15514 : : }
15515 : 6392464 : else if (!type)
15516 : 6392455 : type = tsubst (TREE_TYPE (t), args, complain, in_decl);
15517 : :
15518 : 6392567 : if (type == error_mark_node)
15519 : 149 : RETURN (error_mark_node);
15520 : 6392418 : TREE_TYPE (r) = type;
15521 : 6392418 : cp_apply_type_quals_to_decl (cp_type_quals (type), r);
15522 : :
15523 : 6392418 : if (DECL_C_BIT_FIELD (r))
15524 : : /* For bit-fields, DECL_BIT_FIELD_REPRESENTATIVE gives the
15525 : : number of bits. */
15526 : 116540 : DECL_BIT_FIELD_REPRESENTATIVE (r)
15527 : 116540 : = tsubst_expr (DECL_BIT_FIELD_REPRESENTATIVE (t), args,
15528 : : complain, in_decl);
15529 : 6392418 : if (DECL_INITIAL (t))
15530 : : {
15531 : : /* Set up DECL_TEMPLATE_INFO so that we can get at the
15532 : : NSDMI in perform_member_init. Still set DECL_INITIAL
15533 : : so that we know there is one. */
15534 : 433958 : DECL_INITIAL (r) = void_node;
15535 : 433958 : gcc_assert (DECL_LANG_SPECIFIC (r) == NULL);
15536 : 433958 : retrofit_lang_decl (r);
15537 : 433958 : DECL_TEMPLATE_INFO (r) = build_template_info (t, args);
15538 : : }
15539 : : /* We don't have to set DECL_CONTEXT here; it is set by
15540 : : finish_member_declaration. */
15541 : 6392418 : DECL_CHAIN (r) = NULL_TREE;
15542 : :
15543 : 6392418 : if (!apply_late_template_attributes (&r, DECL_ATTRIBUTES (r), 0,
15544 : : args, complain, in_decl))
15545 : 2 : return error_mark_node;
15546 : :
15547 : 6392416 : if (vec)
15548 : 109 : TREE_VEC_ELT (vec, i) = r;
15549 : : }
15550 : :
15551 : 6392381 : if (vec)
15552 : 74 : r = vec;
15553 : : }
15554 : : break;
15555 : :
15556 : 1299717 : case USING_DECL:
15557 : : /* We reach here only for member using decls. We also need to check
15558 : : uses_template_parms because DECL_DEPENDENT_P is not set for a
15559 : : using-declaration that designates a member of the current
15560 : : instantiation (c++/53549). */
15561 : 1299717 : if (DECL_DEPENDENT_P (t)
15562 : 1299717 : || uses_template_parms (USING_DECL_SCOPE (t)))
15563 : : {
15564 : : /* True iff this using-decl was written as a pack expansion
15565 : : (and a pack appeared in its scope or name). If a pack
15566 : : appeared in both, we expand the packs separately and
15567 : : manually merge them. */
15568 : 1299491 : bool variadic_p = false;
15569 : :
15570 : 1299491 : tree scope = USING_DECL_SCOPE (t);
15571 : 1299491 : if (PACK_EXPANSION_P (scope))
15572 : : {
15573 : 264 : scope = tsubst_pack_expansion (scope, args,
15574 : : complain | tf_qualifying_scope,
15575 : : in_decl);
15576 : 264 : variadic_p = true;
15577 : : }
15578 : : else
15579 : 1299227 : scope = tsubst_scope (scope, args, complain, in_decl);
15580 : :
15581 : 1299491 : tree name = DECL_NAME (t);
15582 : 1299491 : if (IDENTIFIER_CONV_OP_P (name)
15583 : 1299491 : && PACK_EXPANSION_P (TREE_TYPE (name)))
15584 : : {
15585 : 33 : name = tsubst_pack_expansion (TREE_TYPE (name), args,
15586 : : complain, in_decl);
15587 : 33 : if (name == error_mark_node)
15588 : : {
15589 : 0 : r = error_mark_node;
15590 : 0 : break;
15591 : : }
15592 : 84 : for (tree& elt : tree_vec_range (name))
15593 : 51 : elt = make_conv_op_name (elt);
15594 : 33 : variadic_p = true;
15595 : : }
15596 : : else
15597 : 2598916 : name = tsubst_name (name, args, complain, in_decl);
15598 : :
15599 : 1299491 : int len;
15600 : 1299491 : if (!variadic_p)
15601 : : len = 1;
15602 : 273 : else if (TREE_CODE (scope) == TREE_VEC
15603 : 264 : && TREE_CODE (name) == TREE_VEC)
15604 : : {
15605 : 24 : if (TREE_VEC_LENGTH (scope) != TREE_VEC_LENGTH (name))
15606 : : {
15607 : 3 : error ("mismatched argument pack lengths (%d vs %d)",
15608 : 3 : TREE_VEC_LENGTH (scope), TREE_VEC_LENGTH (name));
15609 : 3 : r = error_mark_node;
15610 : 3 : break;
15611 : : }
15612 : : len = TREE_VEC_LENGTH (scope);
15613 : : }
15614 : 249 : else if (TREE_CODE (scope) == TREE_VEC)
15615 : 240 : len = TREE_VEC_LENGTH (scope);
15616 : : else /* TREE_CODE (name) == TREE_VEC */
15617 : 9 : len = TREE_VEC_LENGTH (name);
15618 : :
15619 : 1299488 : r = make_tree_vec (len);
15620 : 2599353 : for (int i = 0; i < len; ++i)
15621 : : {
15622 : 1299895 : tree escope = (TREE_CODE (scope) == TREE_VEC
15623 : 1299895 : ? TREE_VEC_ELT (scope, i)
15624 : 1299895 : : scope);
15625 : 1299895 : tree ename = (TREE_CODE (name) == TREE_VEC
15626 : 1299895 : ? TREE_VEC_ELT (name, i)
15627 : 1299895 : : name);
15628 : 1299895 : tree elt = do_class_using_decl (escope, ename);
15629 : 1299895 : if (!elt)
15630 : : {
15631 : 30 : r = error_mark_node;
15632 : 30 : break;
15633 : : }
15634 : 1299865 : TREE_PROTECTED (elt) = TREE_PROTECTED (t);
15635 : 1299865 : TREE_PRIVATE (elt) = TREE_PRIVATE (t);
15636 : 1299865 : TREE_VEC_ELT (r, i) = elt;
15637 : : }
15638 : :
15639 : 1299488 : if (!variadic_p && r != error_mark_node)
15640 : 1299188 : r = TREE_VEC_ELT (r, 0);
15641 : : }
15642 : : else
15643 : : {
15644 : 226 : r = copy_node (t);
15645 : 226 : DECL_CHAIN (r) = NULL_TREE;
15646 : : }
15647 : : break;
15648 : :
15649 : 169812731 : case TYPE_DECL:
15650 : 169812731 : case VAR_DECL:
15651 : 169812731 : {
15652 : 169812731 : tree argvec = NULL_TREE;
15653 : 169812731 : tree gen_tmpl = NULL_TREE;
15654 : 169812731 : tree tmpl = NULL_TREE;
15655 : 169812731 : tree type = NULL_TREE;
15656 : :
15657 : 169812731 : if (TREE_TYPE (t) == error_mark_node)
15658 : 5 : RETURN (error_mark_node);
15659 : :
15660 : 169812726 : if (TREE_CODE (t) == TYPE_DECL
15661 : 169812726 : && (TREE_CODE (TREE_TYPE (t)) == TU_LOCAL_ENTITY
15662 : 141023622 : || t == TYPE_MAIN_DECL (TREE_TYPE (t))))
15663 : : {
15664 : : /* If this is the canonical decl, we don't have to
15665 : : mess with instantiations, and often we can't (for
15666 : : typename, template type parms and such). Note that
15667 : : TYPE_NAME is not correct for the above test if
15668 : : we've copied the type for a typedef. */
15669 : 32490002 : type = tsubst (TREE_TYPE (t), args, complain, in_decl);
15670 : 32489957 : if (type == error_mark_node)
15671 : 9 : RETURN (error_mark_node);
15672 : 32489948 : r = TYPE_NAME (type);
15673 : 32489948 : break;
15674 : : }
15675 : :
15676 : : /* Check to see if we already have the specialization we
15677 : : need. */
15678 : 137322724 : tree spec = NULL_TREE;
15679 : 137322724 : bool local_p = false;
15680 : 137322724 : tree ctx = DECL_CONTEXT (t);
15681 : 28789101 : if (!(VAR_P (t) && DECL_LOCAL_DECL_P (t))
15682 : 166111734 : && (DECL_CLASS_SCOPE_P (t) || DECL_NAMESPACE_SCOPE_P (t)))
15683 : : {
15684 : 116841321 : local_p = false;
15685 : 116841321 : if (DECL_CLASS_SCOPE_P (t))
15686 : : {
15687 : 82541636 : ctx = tsubst_entering_scope (ctx, args, complain, in_decl);
15688 : 82541636 : if (DECL_SELF_REFERENCE_P (t))
15689 : : /* The context and type of an injected-class-name are
15690 : : the same, so we don't need to substitute both. */
15691 : : type = ctx;
15692 : : /* If CTX is unchanged, then T is in fact the
15693 : : specialization we want. That situation occurs when
15694 : : referencing a static data member within in its own
15695 : : class. We can use pointer equality, rather than
15696 : : same_type_p, because DECL_CONTEXT is always
15697 : : canonical... */
15698 : 82541636 : if (ctx == DECL_CONTEXT (t)
15699 : : /* ... unless T is a member template; in which
15700 : : case our caller can be willing to create a
15701 : : specialization of that template represented
15702 : : by T. */
15703 : 82541636 : && !(DECL_TI_TEMPLATE (t)
15704 : 16378927 : && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
15705 : : spec = t;
15706 : : }
15707 : :
15708 : : if (!spec)
15709 : : {
15710 : 114920336 : tmpl = DECL_TI_TEMPLATE (t);
15711 : 114920336 : if (use_spec_table)
15712 : : {
15713 : 62238805 : argvec = tsubst (DECL_TI_ARGS (t), args, complain, in_decl);
15714 : 62238805 : if (argvec == error_mark_node)
15715 : 0 : RETURN (error_mark_node);
15716 : 62238805 : gen_tmpl = most_general_template (tmpl);
15717 : 62238805 : hash = spec_hasher::hash (gen_tmpl, argvec);
15718 : 62238805 : spec = retrieve_specialization (gen_tmpl, argvec, hash);
15719 : : }
15720 : : else
15721 : : argvec = args;
15722 : : }
15723 : : }
15724 : : else
15725 : : {
15726 : 20481403 : if (!(VAR_P (t) && DECL_LOCAL_DECL_P (t)))
15727 : : /* Subsequent calls to pushdecl will fill this in. */
15728 : : ctx = NULL_TREE;
15729 : : /* A local variable. */
15730 : 20481403 : local_p = true;
15731 : : /* Unless this is a reference to a static variable from an
15732 : : enclosing function, in which case we need to fill it in now. */
15733 : 20481403 : if (TREE_STATIC (t))
15734 : : {
15735 : 98372 : tree fn = enclosing_instantiation_of (DECL_CONTEXT (t));
15736 : 98372 : if (fn != current_function_decl)
15737 : 20481403 : ctx = fn;
15738 : : }
15739 : 20481403 : spec = retrieve_local_specialization (t);
15740 : : }
15741 : : /* If we already have the specialization we need, there is
15742 : : nothing more to do. */
15743 : 135401739 : if (spec)
15744 : : {
15745 : 3738279 : r = spec;
15746 : 3738279 : break;
15747 : : }
15748 : :
15749 : : /* Create a new node for the specialization we need. */
15750 : 133584445 : if (type == NULL_TREE)
15751 : : {
15752 : 106939665 : if (is_typedef_decl (t))
15753 : : type = DECL_ORIGINAL_TYPE (t);
15754 : : else
15755 : 25050963 : type = TREE_TYPE (t);
15756 : 106939665 : if (VAR_P (t)
15757 : 25050825 : && VAR_HAD_UNKNOWN_BOUND (t)
15758 : 106939901 : && type != error_mark_node)
15759 : 236 : type = strip_array_domain (type);
15760 : 106939665 : tsubst_flags_t tcomplain = complain;
15761 : 106939665 : if (VAR_P (t))
15762 : 25050825 : tcomplain |= tf_tst_ok;
15763 : 106939665 : type = tsubst (type, args, tcomplain, in_decl);
15764 : : /* Substituting the type might have recursively instantiated this
15765 : : same alias (c++/86171). */
15766 : 33777051 : if (use_spec_table && gen_tmpl && DECL_ALIAS_TEMPLATE_P (gen_tmpl)
15767 : 138303539 : && (spec = retrieve_specialization (gen_tmpl, argvec, hash)))
15768 : : {
15769 : 0 : r = spec;
15770 : 0 : break;
15771 : : }
15772 : : }
15773 : 133584445 : if (type == error_mark_node && !(complain & tf_error))
15774 : 25939672 : RETURN (error_mark_node);
15775 : 107644773 : r = copy_decl (t);
15776 : 107644773 : if (VAR_P (r))
15777 : : {
15778 : 25050825 : DECL_INITIALIZED_P (r) = 0;
15779 : 25050825 : DECL_TEMPLATE_INSTANTIATED (r) = 0;
15780 : 25050825 : if (TREE_CODE (type) == FUNCTION_TYPE)
15781 : : {
15782 : : /* It may seem that this case cannot occur, since:
15783 : :
15784 : : typedef void f();
15785 : : void g() { f x; }
15786 : :
15787 : : declares a function, not a variable. However:
15788 : :
15789 : : typedef void f();
15790 : : template <typename T> void g() { T t; }
15791 : : template void g<f>();
15792 : :
15793 : : is an attempt to declare a variable with function
15794 : : type. */
15795 : 3 : error ("variable %qD has function type",
15796 : : /* R is not yet sufficiently initialized, so we
15797 : : just use its name. */
15798 : 3 : DECL_NAME (r));
15799 : 3 : RETURN (error_mark_node);
15800 : : }
15801 : 25050822 : type = complete_type (type);
15802 : : /* Wait until cp_finish_decl to set this again, to handle
15803 : : circular dependency (template/instantiate6.C). */
15804 : 25050819 : DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r) = 0;
15805 : 25050819 : type = check_var_type (DECL_NAME (r), type,
15806 : 25050819 : DECL_SOURCE_LOCATION (r));
15807 : 25050819 : if (DECL_HAS_VALUE_EXPR_P (t))
15808 : : {
15809 : 166780 : tree ve = DECL_VALUE_EXPR (t);
15810 : : /* If the DECL_VALUE_EXPR is converted to the declared type,
15811 : : preserve the identity so that gimplify_type_sizes works. */
15812 : 166780 : bool nop = (TREE_CODE (ve) == NOP_EXPR);
15813 : 166780 : if (nop)
15814 : 3 : ve = TREE_OPERAND (ve, 0);
15815 : 166780 : ve = tsubst_expr (ve, args, complain, in_decl);
15816 : 166780 : if (REFERENCE_REF_P (ve))
15817 : : {
15818 : 88250 : gcc_assert (TYPE_REF_P (type));
15819 : 88250 : ve = TREE_OPERAND (ve, 0);
15820 : : }
15821 : 166780 : if (nop)
15822 : 3 : ve = build_nop (type, ve);
15823 : 166777 : else if (DECL_LANG_SPECIFIC (t)
15824 : 166577 : && DECL_OMP_PRIVATIZED_MEMBER (t)
15825 : 183 : && TREE_CODE (ve) == COMPONENT_REF
15826 : 183 : && TREE_CODE (TREE_OPERAND (ve, 1)) == FIELD_DECL
15827 : 166960 : && DECL_BIT_FIELD_TYPE (TREE_OPERAND (ve, 1)) == type)
15828 : 6 : type = TREE_TYPE (ve);
15829 : : else
15830 : 166771 : gcc_checking_assert (TYPE_MAIN_VARIANT (TREE_TYPE (ve))
15831 : : == TYPE_MAIN_VARIANT (type));
15832 : 166780 : SET_DECL_VALUE_EXPR (r, ve);
15833 : : }
15834 : 25050819 : if (CP_DECL_THREAD_LOCAL_P (r)
15835 : 25050819 : && !processing_template_decl)
15836 : 40 : set_decl_tls_model (r, decl_default_tls_model (r));
15837 : : }
15838 : 82593948 : else if (DECL_SELF_REFERENCE_P (t))
15839 : 26644780 : SET_DECL_SELF_REFERENCE_P (r);
15840 : 107644767 : TREE_TYPE (r) = type;
15841 : 107644767 : cp_apply_type_quals_to_decl (cp_type_quals (type), r);
15842 : 107644767 : DECL_CONTEXT (r) = ctx;
15843 : : /* Clear out the mangled name and RTL for the instantiation. */
15844 : 107644767 : SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
15845 : 107644767 : if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
15846 : 107644767 : SET_DECL_RTL (r, NULL);
15847 : 107644767 : set_instantiating_module (r);
15848 : :
15849 : : /* The initializer must not be expanded until it is required;
15850 : : see [temp.inst]. */
15851 : 107644767 : DECL_INITIAL (r) = NULL_TREE;
15852 : 107644767 : DECL_SIZE (r) = DECL_SIZE_UNIT (r) = 0;
15853 : 107644767 : if (VAR_P (r))
15854 : : {
15855 : 25050819 : if (DECL_LANG_SPECIFIC (r))
15856 : 6771440 : SET_DECL_DEPENDENT_INIT_P (r, false);
15857 : :
15858 : 25050819 : SET_DECL_MODE (r, VOIDmode);
15859 : :
15860 : : /* Possibly limit visibility based on template args. */
15861 : 25050819 : DECL_VISIBILITY (r) = VISIBILITY_DEFAULT;
15862 : 25050819 : if (DECL_VISIBILITY_SPECIFIED (t))
15863 : : {
15864 : 0 : DECL_VISIBILITY_SPECIFIED (r) = 0;
15865 : 0 : DECL_ATTRIBUTES (r)
15866 : 0 : = remove_attribute ("visibility", DECL_ATTRIBUTES (r));
15867 : : }
15868 : 25050819 : determine_visibility (r);
15869 : 25050819 : if ((!local_p || TREE_STATIC (t)) && DECL_SECTION_NAME (t))
15870 : 9 : set_decl_section_name (r, t);
15871 : : }
15872 : :
15873 : 107644767 : if (!local_p)
15874 : : {
15875 : : /* A static data member declaration is always marked
15876 : : external when it is declared in-class, even if an
15877 : : initializer is present. We mimic the non-template
15878 : : processing here. */
15879 : 87163690 : DECL_EXTERNAL (r) = 1;
15880 : 87163690 : if (DECL_NAMESPACE_SCOPE_P (t))
15881 : 20663976 : DECL_NOT_REALLY_EXTERN (r) = 1;
15882 : :
15883 : 87163690 : DECL_TEMPLATE_INFO (r) = build_template_info (tmpl, argvec);
15884 : 87163690 : SET_DECL_IMPLICIT_INSTANTIATION (r);
15885 : 87163690 : if (use_spec_table)
15886 : 60421831 : register_specialization (r, gen_tmpl, argvec, false, hash);
15887 : : }
15888 : : else
15889 : : {
15890 : 20481077 : if (DECL_LANG_SPECIFIC (r))
15891 : 797303 : DECL_TEMPLATE_INFO (r) = NULL_TREE;
15892 : 20481077 : if (!cp_unevaluated_operand)
15893 : 20481077 : register_local_specialization (r, t);
15894 : : }
15895 : :
15896 : 107644767 : DECL_CHAIN (r) = NULL_TREE;
15897 : :
15898 : 107644767 : if (!apply_late_template_attributes (&r, DECL_ATTRIBUTES (r),
15899 : : /*flags=*/0,
15900 : : args, complain, in_decl))
15901 : 3 : return error_mark_node;
15902 : :
15903 : : /* Preserve a typedef that names a type. */
15904 : 190238571 : if (is_typedef_decl (r) && type != error_mark_node)
15905 : : {
15906 : 82593445 : DECL_ORIGINAL_TYPE (r) = NULL_TREE;
15907 : 82593445 : set_underlying_type (r);
15908 : :
15909 : : /* common_handle_aligned_attribute doesn't apply the alignment
15910 : : to DECL_ORIGINAL_TYPE. */
15911 : 82593445 : if (TYPE_USER_ALIGN (TREE_TYPE (t)))
15912 : 79 : TREE_TYPE (r) = build_aligned_type (TREE_TYPE (r),
15913 : 79 : TYPE_ALIGN (TREE_TYPE (t)));
15914 : : }
15915 : :
15916 : 107644764 : layout_decl (r, 0);
15917 : : }
15918 : 107644764 : break;
15919 : :
15920 : 0 : default:
15921 : 0 : gcc_unreachable ();
15922 : : }
15923 : : #undef RETURN
15924 : :
15925 : 542713618 : out:
15926 : : /* Restore the file and line information. */
15927 : 542713618 : input_location = saved_loc;
15928 : :
15929 : 542713618 : return r;
15930 : : }
15931 : :
15932 : : /* Substitute into the complete parameter type list PARMS. */
15933 : :
15934 : : tree
15935 : 1527520 : tsubst_function_parms (tree parms,
15936 : : tree args,
15937 : : tsubst_flags_t complain,
15938 : : tree in_decl)
15939 : : {
15940 : 1527520 : return tsubst_arg_types (parms, args, NULL_TREE, complain, in_decl);
15941 : : }
15942 : :
15943 : : /* Substitute into the ARG_TYPES of a function type.
15944 : : If END is a TREE_CHAIN, leave it and any following types
15945 : : un-substituted. */
15946 : :
15947 : : static tree
15948 : 369946977 : tsubst_arg_types (tree arg_types,
15949 : : tree args,
15950 : : tree end,
15951 : : tsubst_flags_t complain,
15952 : : tree in_decl)
15953 : : {
15954 : 369946977 : tree type = NULL_TREE;
15955 : 369946977 : int len = 1;
15956 : 369946977 : tree expanded_args = NULL_TREE;
15957 : :
15958 : 369946977 : if (!arg_types || arg_types == void_list_node || arg_types == end)
15959 : : return arg_types;
15960 : :
15961 : 241819148 : if (PACK_EXPANSION_P (TREE_VALUE (arg_types)))
15962 : : {
15963 : : /* For a pack expansion, perform substitution on the
15964 : : entire expression. Later on, we'll handle the arguments
15965 : : one-by-one. */
15966 : 5647390 : expanded_args = tsubst_pack_expansion (TREE_VALUE (arg_types),
15967 : : args, complain, in_decl);
15968 : :
15969 : 5647390 : if (TREE_CODE (expanded_args) == TREE_VEC)
15970 : : /* So that we'll spin through the parameters, one by one. */
15971 : 3337856 : len = TREE_VEC_LENGTH (expanded_args);
15972 : : else
15973 : : {
15974 : : /* We only partially substituted into the parameter
15975 : : pack. Our type is TYPE_PACK_EXPANSION. */
15976 : : type = expanded_args;
15977 : : expanded_args = NULL_TREE;
15978 : : }
15979 : : }
15980 : : else
15981 : 236171758 : type = tsubst (TREE_VALUE (arg_types), args, complain, in_decl);
15982 : :
15983 : : /* Check if a substituted type is erroneous before substituting into
15984 : : the rest of the chain. */
15985 : 482036593 : for (int i = 0; i < len; i++)
15986 : : {
15987 : 240222755 : if (expanded_args)
15988 : 1741463 : type = TREE_VEC_ELT (expanded_args, i);
15989 : :
15990 : 240222755 : if (type == error_mark_node)
15991 : : return error_mark_node;
15992 : 240217476 : if (VOID_TYPE_P (type))
15993 : : {
15994 : 31 : if (complain & tf_error)
15995 : : {
15996 : 6 : error ("invalid parameter type %qT", type);
15997 : 6 : if (in_decl)
15998 : 3 : error ("in declaration %q+D", in_decl);
15999 : : }
16000 : 31 : return error_mark_node;
16001 : : }
16002 : : }
16003 : :
16004 : : /* We do not substitute into default arguments here. The standard
16005 : : mandates that they be instantiated only when needed, which is
16006 : : done in build_over_call. */
16007 : 241813838 : tree default_arg = TREE_PURPOSE (arg_types);
16008 : :
16009 : : /* Except that we do substitute default arguments under tsubst_lambda_expr,
16010 : : since the new op() won't have any associated template arguments for us
16011 : : to refer to later. */
16012 : 241813838 : if (lambda_fn_in_template_p (in_decl)
16013 : 241813838 : || (in_decl && TREE_CODE (in_decl) == FUNCTION_DECL
16014 : 225985968 : && DECL_LOCAL_DECL_P (in_decl)))
16015 : 122445 : default_arg = tsubst_expr (default_arg, args, complain, in_decl);
16016 : :
16017 : 241813838 : tree remaining_arg_types = tsubst_arg_types (TREE_CHAIN (arg_types),
16018 : 241813838 : args, end, complain, in_decl);
16019 : 241813838 : if (remaining_arg_types == error_mark_node)
16020 : : return error_mark_node;
16021 : :
16022 : 482016729 : for (int i = len-1; i >= 0; i--)
16023 : : {
16024 : 240210168 : if (expanded_args)
16025 : 1741460 : type = TREE_VEC_ELT (expanded_args, i);
16026 : :
16027 : : /* Do array-to-pointer, function-to-pointer conversion, and ignore
16028 : : top-level qualifiers as required. */
16029 : 240210168 : type = cv_unqualified (type_decays_to (type));
16030 : :
16031 : 240210168 : if (default_arg && TREE_CODE (default_arg) == DEFERRED_PARSE)
16032 : : {
16033 : : /* We've instantiated a template before its default arguments
16034 : : have been parsed. This can happen for a nested template
16035 : : class, and is not an error unless we require the default
16036 : : argument in a call of this function. */
16037 : 3 : remaining_arg_types
16038 : 3 : = tree_cons (default_arg, type, remaining_arg_types);
16039 : 3 : vec_safe_push (DEFPARSE_INSTANTIATIONS (default_arg),
16040 : : remaining_arg_types);
16041 : : }
16042 : : else
16043 : 240210165 : remaining_arg_types
16044 : 240210165 : = hash_tree_cons (default_arg, type, remaining_arg_types);
16045 : : }
16046 : :
16047 : 241806561 : return remaining_arg_types;
16048 : : }
16049 : :
16050 : : /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
16051 : : *not* handle the exception-specification for FNTYPE, because the
16052 : : initial substitution of explicitly provided template parameters
16053 : : during argument deduction forbids substitution into the
16054 : : exception-specification:
16055 : :
16056 : : [temp.deduct]
16057 : :
16058 : : All references in the function type of the function template to the
16059 : : corresponding template parameters are replaced by the specified tem-
16060 : : plate argument values. If a substitution in a template parameter or
16061 : : in the function type of the function template results in an invalid
16062 : : type, type deduction fails. [Note: The equivalent substitution in
16063 : : exception specifications is done only when the function is instanti-
16064 : : ated, at which point a program is ill-formed if the substitution
16065 : : results in an invalid type.] */
16066 : :
16067 : : static tree
16068 : 125366208 : tsubst_function_type (tree t,
16069 : : tree args,
16070 : : tsubst_flags_t complain,
16071 : : tree in_decl)
16072 : : {
16073 : 125366208 : tree return_type;
16074 : 125366208 : tree arg_types = NULL_TREE;
16075 : :
16076 : : /* The TYPE_CONTEXT is not used for function/method types. */
16077 : 125366208 : gcc_assert (TYPE_CONTEXT (t) == NULL_TREE);
16078 : :
16079 : : /* DR 1227: Mixing immediate and non-immediate contexts in deduction
16080 : : failure. */
16081 : 125366208 : bool late_return_type_p = TYPE_HAS_LATE_RETURN_TYPE (t);
16082 : :
16083 : 125366208 : if (late_return_type_p)
16084 : : {
16085 : : /* Substitute the argument types. */
16086 : 12246338 : arg_types = tsubst_arg_types (TYPE_ARG_TYPES (t), args, NULL_TREE,
16087 : : complain, in_decl);
16088 : 12246338 : if (arg_types == error_mark_node)
16089 : : return error_mark_node;
16090 : :
16091 : 12246323 : tree save_ccp = current_class_ptr;
16092 : 12246323 : tree save_ccr = current_class_ref;
16093 : 12246323 : tree this_type = (TREE_CODE (t) == METHOD_TYPE
16094 : 13443941 : ? TREE_TYPE (TREE_VALUE (arg_types)) : NULL_TREE);
16095 : 1197618 : bool do_inject = this_type && CLASS_TYPE_P (this_type);
16096 : 1197618 : if (do_inject)
16097 : : {
16098 : : /* DR 1207: 'this' is in scope in the trailing return type. */
16099 : 1197618 : inject_this_parameter (this_type, cp_type_quals (this_type));
16100 : : }
16101 : :
16102 : : /* Substitute the return type. */
16103 : 12246323 : return_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
16104 : :
16105 : 12243623 : if (do_inject)
16106 : : {
16107 : 1197618 : current_class_ptr = save_ccp;
16108 : 1197618 : current_class_ref = save_ccr;
16109 : : }
16110 : : }
16111 : : else
16112 : : /* Substitute the return type. */
16113 : 113119870 : return_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
16114 : :
16115 : 125355360 : if (return_type == error_mark_node)
16116 : : return error_mark_node;
16117 : : /* DR 486 clarifies that creation of a function type with an
16118 : : invalid return type is a deduction failure. */
16119 : 123974389 : if (TREE_CODE (return_type) == ARRAY_TYPE
16120 : 123974329 : || TREE_CODE (return_type) == FUNCTION_TYPE)
16121 : : {
16122 : 177 : if (complain & tf_error)
16123 : : {
16124 : 26 : if (TREE_CODE (return_type) == ARRAY_TYPE)
16125 : 12 : error ("function returning an array");
16126 : : else
16127 : 14 : error ("function returning a function");
16128 : : }
16129 : 177 : return error_mark_node;
16130 : : }
16131 : :
16132 : 123974212 : if (!late_return_type_p)
16133 : : {
16134 : : /* Substitute the argument types. */
16135 : 112532380 : arg_types = tsubst_arg_types (TYPE_ARG_TYPES (t), args, NULL_TREE,
16136 : : complain, in_decl);
16137 : 112532380 : if (arg_types == error_mark_node)
16138 : : return error_mark_node;
16139 : : }
16140 : :
16141 : : /* Construct a new type node and return it. */
16142 : 123968997 : return rebuild_function_or_method_type (t, args, return_type, arg_types,
16143 : 123968997 : /*raises=*/NULL_TREE, complain);
16144 : : }
16145 : :
16146 : : /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
16147 : : ARGS into that specification, and return the substituted
16148 : : specification. If there is no specification, return NULL_TREE. */
16149 : :
16150 : : static tree
16151 : 123968974 : tsubst_exception_specification (tree fntype,
16152 : : tree args,
16153 : : tsubst_flags_t complain,
16154 : : tree in_decl,
16155 : : bool defer_ok)
16156 : : {
16157 : 123968974 : tree specs;
16158 : 123968974 : tree new_specs;
16159 : :
16160 : 123968974 : specs = TYPE_RAISES_EXCEPTIONS (fntype);
16161 : 123968974 : new_specs = NULL_TREE;
16162 : 168378496 : if (specs && TREE_PURPOSE (specs))
16163 : : {
16164 : : /* A noexcept-specifier. */
16165 : 44379310 : tree expr = TREE_PURPOSE (specs);
16166 : 44379310 : if (TREE_CODE (expr) == INTEGER_CST)
16167 : 39691040 : new_specs = expr;
16168 : 4688270 : else if (defer_ok)
16169 : : {
16170 : : /* Defer instantiation of noexcept-specifiers to avoid
16171 : : excessive instantiations (c++/49107). */
16172 : 4649936 : new_specs = make_node (DEFERRED_NOEXCEPT);
16173 : 4649936 : if (DEFERRED_NOEXCEPT_SPEC_P (specs))
16174 : : {
16175 : : /* We already partially instantiated this member template,
16176 : : so combine the new args with the old. */
16177 : 18 : DEFERRED_NOEXCEPT_PATTERN (new_specs)
16178 : 18 : = DEFERRED_NOEXCEPT_PATTERN (expr);
16179 : 36 : DEFERRED_NOEXCEPT_ARGS (new_specs)
16180 : 36 : = add_to_template_args (DEFERRED_NOEXCEPT_ARGS (expr), args);
16181 : : }
16182 : : else
16183 : : {
16184 : 4649918 : DEFERRED_NOEXCEPT_PATTERN (new_specs) = expr;
16185 : 4649918 : DEFERRED_NOEXCEPT_ARGS (new_specs) = args;
16186 : : }
16187 : : }
16188 : : else
16189 : : {
16190 : 38334 : if (DEFERRED_NOEXCEPT_SPEC_P (specs))
16191 : : {
16192 : 0 : args = add_to_template_args (DEFERRED_NOEXCEPT_ARGS (expr),
16193 : : args);
16194 : 0 : expr = DEFERRED_NOEXCEPT_PATTERN (expr);
16195 : : }
16196 : 38334 : new_specs = tsubst_expr (expr, args, complain, in_decl);
16197 : : }
16198 : 44379310 : new_specs = build_noexcept_spec (new_specs, complain);
16199 : : /* We've instantiated a template before a noexcept-specifier
16200 : : contained therein has been parsed. This can happen for
16201 : : a nested template class:
16202 : :
16203 : : struct S {
16204 : : template<typename> struct B { B() noexcept(...); };
16205 : : struct A : B<int> { ... use B() ... };
16206 : : };
16207 : :
16208 : : where completing B<int> will trigger instantiating the
16209 : : noexcept, even though we only parse it at the end of S. */
16210 : 44379310 : if (UNPARSED_NOEXCEPT_SPEC_P (specs))
16211 : : {
16212 : 9 : gcc_checking_assert (defer_ok);
16213 : 9 : vec_safe_push (DEFPARSE_INSTANTIATIONS (expr), new_specs);
16214 : : }
16215 : : }
16216 : 79589664 : else if (specs)
16217 : : {
16218 : 30212 : if (! TREE_VALUE (specs))
16219 : 30151 : new_specs = specs;
16220 : : else
16221 : 118 : while (specs)
16222 : : {
16223 : 61 : tree spec;
16224 : 61 : int i, len = 1;
16225 : 61 : tree expanded_specs = NULL_TREE;
16226 : :
16227 : 61 : if (PACK_EXPANSION_P (TREE_VALUE (specs)))
16228 : : {
16229 : : /* Expand the pack expansion type. */
16230 : 13 : expanded_specs = tsubst_pack_expansion (TREE_VALUE (specs),
16231 : : args, complain,
16232 : : in_decl);
16233 : :
16234 : 13 : if (expanded_specs == error_mark_node)
16235 : : return error_mark_node;
16236 : 11 : else if (TREE_CODE (expanded_specs) == TREE_VEC)
16237 : 4 : len = TREE_VEC_LENGTH (expanded_specs);
16238 : : else
16239 : : {
16240 : : /* We're substituting into a member template, so
16241 : : we got a TYPE_PACK_EXPANSION back. Add that
16242 : : expansion and move on. */
16243 : 7 : gcc_assert (TREE_CODE (expanded_specs)
16244 : : == TYPE_PACK_EXPANSION);
16245 : 7 : new_specs = add_exception_specifier (new_specs,
16246 : : expanded_specs,
16247 : : complain);
16248 : 7 : specs = TREE_CHAIN (specs);
16249 : 7 : continue;
16250 : : }
16251 : : }
16252 : :
16253 : 110 : for (i = 0; i < len; ++i)
16254 : : {
16255 : 60 : if (expanded_specs)
16256 : 12 : spec = TREE_VEC_ELT (expanded_specs, i);
16257 : : else
16258 : 48 : spec = tsubst (TREE_VALUE (specs), args, complain, in_decl);
16259 : 60 : if (spec == error_mark_node)
16260 : : return spec;
16261 : 58 : new_specs = add_exception_specifier (new_specs, spec,
16262 : : complain);
16263 : : }
16264 : :
16265 : 50 : specs = TREE_CHAIN (specs);
16266 : : }
16267 : : }
16268 : 123968970 : return new_specs;
16269 : : }
16270 : :
16271 : : /* Substitute through a TREE_LIST of types or expressions, handling pack
16272 : : expansions. */
16273 : :
16274 : : tree
16275 : 28920191 : tsubst_tree_list (tree t, tree args, tsubst_flags_t complain, tree in_decl)
16276 : : {
16277 : 28920191 : if (t == void_list_node)
16278 : : return t;
16279 : :
16280 : 28920173 : tree purpose = TREE_PURPOSE (t);
16281 : 28920173 : tree purposevec = NULL_TREE;
16282 : 28920173 : if (!purpose)
16283 : : ;
16284 : 2 : else if (PACK_EXPANSION_P (purpose))
16285 : : {
16286 : 0 : purpose = tsubst_pack_expansion (purpose, args, complain, in_decl);
16287 : 0 : if (TREE_CODE (purpose) == TREE_VEC)
16288 : 0 : purposevec = purpose;
16289 : : }
16290 : 2 : else if (TYPE_P (purpose))
16291 : 0 : purpose = tsubst (purpose, args, complain, in_decl);
16292 : : else
16293 : 2 : purpose = tsubst_expr (purpose, args, complain, in_decl);
16294 : 28920173 : if (purpose == error_mark_node || purposevec == error_mark_node)
16295 : : return error_mark_node;
16296 : :
16297 : 28920173 : tree value = TREE_VALUE (t);
16298 : 28920173 : tree valuevec = NULL_TREE;
16299 : 28920173 : if (!value)
16300 : : ;
16301 : 28920173 : else if (PACK_EXPANSION_P (value))
16302 : : {
16303 : 273150 : value = tsubst_pack_expansion (value, args, complain, in_decl);
16304 : 273150 : if (TREE_CODE (value) == TREE_VEC)
16305 : 260045 : valuevec = value;
16306 : : }
16307 : 28647023 : else if (TYPE_P (value))
16308 : 20 : value = tsubst (value, args, complain, in_decl);
16309 : : else
16310 : 28647003 : value = tsubst_expr (value, args, complain, in_decl);
16311 : 28920173 : if (value == error_mark_node || valuevec == error_mark_node)
16312 : : return error_mark_node;
16313 : :
16314 : 28919692 : tree chain = TREE_CHAIN (t);
16315 : 28919692 : if (!chain)
16316 : : ;
16317 : 546853 : else if (TREE_CODE (chain) == TREE_LIST)
16318 : 546853 : chain = tsubst_tree_list (chain, args, complain, in_decl);
16319 : 0 : else if (TYPE_P (chain))
16320 : 0 : chain = tsubst (chain, args, complain, in_decl);
16321 : : else
16322 : 0 : chain = tsubst_expr (chain, args, complain, in_decl);
16323 : 28919692 : if (chain == error_mark_node)
16324 : : return error_mark_node;
16325 : :
16326 : 28919692 : if (purpose == TREE_PURPOSE (t)
16327 : 28919690 : && value == TREE_VALUE (t)
16328 : 29415703 : && chain == TREE_CHAIN (t))
16329 : : return t;
16330 : :
16331 : 28423885 : int len;
16332 : : /* Determine the number of arguments. */
16333 : 28423885 : if (purposevec)
16334 : : {
16335 : 0 : len = TREE_VEC_LENGTH (purposevec);
16336 : 0 : gcc_assert (!valuevec || len == TREE_VEC_LENGTH (valuevec));
16337 : : }
16338 : 28423885 : else if (valuevec)
16339 : 260045 : len = TREE_VEC_LENGTH (valuevec);
16340 : : else
16341 : : len = 1;
16342 : :
16343 : 56727578 : for (int i = len; i-- > 0; )
16344 : : {
16345 : 28303693 : if (purposevec)
16346 : 0 : purpose = TREE_VEC_ELT (purposevec, i);
16347 : 28303693 : if (valuevec)
16348 : 139853 : value = TREE_VEC_ELT (valuevec, i);
16349 : :
16350 : 28303693 : if (value && TYPE_P (value))
16351 : 22 : chain = hash_tree_cons (purpose, value, chain);
16352 : : else
16353 : 28303671 : chain = tree_cons (purpose, value, chain);
16354 : : }
16355 : :
16356 : : return chain;
16357 : : }
16358 : :
16359 : : /* Take the tree structure T and replace template parameters used
16360 : : therein with the argument vector ARGS. IN_DECL is an associated
16361 : : decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
16362 : : Issue error and warning messages under control of COMPLAIN. Note
16363 : : that we must be relatively non-tolerant of extensions here, in
16364 : : order to preserve conformance; if we allow substitutions that
16365 : : should not be allowed, we may allow argument deductions that should
16366 : : not succeed, and therefore report ambiguous overload situations
16367 : : where there are none. In theory, we could allow the substitution,
16368 : : but indicate that it should have failed, and allow our caller to
16369 : : make sure that the right thing happens, but we don't try to do this
16370 : : yet.
16371 : :
16372 : : This function is used for dealing with types, decls and the like;
16373 : : for expressions, use tsubst_expr or tsubst_copy. */
16374 : :
16375 : : tree
16376 : 5412178749 : tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
16377 : : {
16378 : 5412212229 : enum tree_code code;
16379 : 5412212229 : tree type, r = NULL_TREE;
16380 : :
16381 : 5412212229 : if (t == NULL_TREE || t == error_mark_node
16382 : 5378437588 : || t == integer_type_node
16383 : 5315390143 : || t == void_type_node
16384 : 5251401380 : || t == char_type_node
16385 : 5235344974 : || t == unknown_type_node
16386 : 5235344959 : || TREE_CODE (t) == NAMESPACE_DECL
16387 : 5152125368 : || TREE_CODE (t) == TRANSLATION_UNIT_DECL)
16388 : : return t;
16389 : :
16390 : : /* Any instantiation of a template containing a TU-local entity is an
16391 : : exposure, so always issue a hard error irrespective of complain. */
16392 : 5151941381 : if (TREE_CODE (t) == TU_LOCAL_ENTITY)
16393 : : {
16394 : 27 : complain_about_tu_local_entity (t);
16395 : 27 : return error_mark_node;
16396 : : }
16397 : :
16398 : 5151941354 : tsubst_flags_t tst_ok_flag = (complain & tf_tst_ok);
16399 : 5151941354 : complain &= ~tf_tst_ok;
16400 : :
16401 : 5151941354 : tsubst_flags_t qualifying_scope_flag = (complain & tf_qualifying_scope);
16402 : 5151941354 : complain &= ~tf_qualifying_scope;
16403 : :
16404 : 5151941354 : if (DECL_P (t))
16405 : 452339001 : return tsubst_decl (t, args, complain);
16406 : :
16407 : 4699602353 : if (args == NULL_TREE)
16408 : : return t;
16409 : :
16410 : 4639337789 : code = TREE_CODE (t);
16411 : :
16412 : 4639337789 : gcc_assert (code != IDENTIFIER_NODE);
16413 : 4639337789 : type = TREE_TYPE (t);
16414 : :
16415 : 4639337789 : gcc_assert (type != unknown_type_node);
16416 : :
16417 : 4639337789 : if (tree d = maybe_dependent_member_ref (t, args, complain, in_decl))
16418 : : return d;
16419 : :
16420 : : /* Reuse typedefs. We need to do this to handle dependent attributes,
16421 : : such as attribute aligned. */
16422 : 4639331944 : if (TYPE_P (t)
16423 : 4639331944 : && typedef_variant_p (t))
16424 : : {
16425 : 237441960 : tree decl = TYPE_NAME (t);
16426 : :
16427 : 237441960 : if (alias_template_specialization_p (t, nt_opaque))
16428 : : {
16429 : : /* DECL represents an alias template and we want to
16430 : : instantiate it. */
16431 : 67905107 : tree tmpl = most_general_template (DECL_TI_TEMPLATE (decl));
16432 : 67905107 : tree gen_args = tsubst (DECL_TI_ARGS (decl), args, complain, in_decl);
16433 : 67905107 : r = instantiate_alias_template (tmpl, gen_args, complain);
16434 : : }
16435 : 339073706 : else if (DECL_CLASS_SCOPE_P (decl)
16436 : 140994528 : && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl))
16437 : 305767268 : && uses_template_parms (DECL_CONTEXT (decl)))
16438 : : {
16439 : 136037266 : tree tmpl = most_general_template (DECL_TI_TEMPLATE (decl));
16440 : 136037266 : tree gen_args = tsubst (DECL_TI_ARGS (decl), args, complain, in_decl);
16441 : 136037266 : r = retrieve_specialization (tmpl, gen_args, 0);
16442 : : }
16443 : 66999174 : else if (DECL_FUNCTION_SCOPE_P (decl)
16444 : 1574888 : && DECL_TEMPLATE_INFO (DECL_CONTEXT (decl))
16445 : 35074475 : && uses_template_parms (DECL_TI_ARGS (DECL_CONTEXT (decl))))
16446 : 1574020 : r = retrieve_local_specialization (decl);
16447 : : else
16448 : : /* The typedef is from a non-template context. */
16449 : 31925567 : return t;
16450 : :
16451 : 205516390 : if (r)
16452 : : {
16453 : 205299085 : r = TREE_TYPE (r);
16454 : 205299085 : r = cp_build_qualified_type
16455 : 205299085 : (r, cp_type_quals (t) | cp_type_quals (r),
16456 : : complain | tf_ignore_bad_quals);
16457 : 205299085 : return r;
16458 : : }
16459 : : else
16460 : : {
16461 : : /* We don't have an instantiation yet, so drop the typedef. */
16462 : 217305 : int quals = cp_type_quals (t);
16463 : 217305 : t = DECL_ORIGINAL_TYPE (decl);
16464 : 217305 : t = cp_build_qualified_type (t, quals,
16465 : : complain | tf_ignore_bad_quals);
16466 : : }
16467 : : }
16468 : :
16469 : 4402107289 : bool fndecl_type = (complain & tf_fndecl_type);
16470 : 4402107289 : complain &= ~tf_fndecl_type;
16471 : :
16472 : 4402107289 : if (type
16473 : 4402107289 : && code != TYPENAME_TYPE
16474 : 729817635 : && code != TEMPLATE_TYPE_PARM
16475 : 729817635 : && code != TEMPLATE_PARM_INDEX
16476 : : && code != IDENTIFIER_NODE
16477 : 589563794 : && code != FUNCTION_TYPE
16478 : 546634977 : && code != METHOD_TYPE
16479 : 546634977 : && code != PACK_INDEX_TYPE)
16480 : 464197573 : type = tsubst (type, args, complain, in_decl);
16481 : 4402107289 : if (type == error_mark_node)
16482 : : return error_mark_node;
16483 : :
16484 : 4402102401 : switch (code)
16485 : : {
16486 : 743083578 : case RECORD_TYPE:
16487 : 743083578 : if (TYPE_PTRMEMFUNC_P (t))
16488 : 33480 : return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t), args, complain, in_decl);
16489 : : /* Fall through. */
16490 : 764823822 : case UNION_TYPE:
16491 : 764823822 : case ENUMERAL_TYPE:
16492 : 764823822 : if (TYPE_TEMPLATE_INFO (t) && uses_template_parms (t))
16493 : : {
16494 : : /* Figure out what arguments are appropriate for the
16495 : : type we are trying to find. For example, given:
16496 : :
16497 : : template <class T> struct S;
16498 : : template <class T, class U> void f(T, U) { S<U> su; }
16499 : :
16500 : : and supposing that we are instantiating f<int, double>,
16501 : : then our ARGS will be {int, double}, but, when looking up
16502 : : S we only want {double}. */
16503 : 1344879588 : tree argvec = tsubst_template_args (TYPE_TI_ARGS (t), args,
16504 : : complain, in_decl);
16505 : 672439758 : if (argvec == error_mark_node)
16506 : : return error_mark_node;
16507 : :
16508 : 672408398 : tree r = lookup_template_class (t, argvec, in_decl, NULL_TREE,
16509 : : complain);
16510 : 672408353 : return cp_build_qualified_type (r, cp_type_quals (t), complain);
16511 : : }
16512 : : else
16513 : : /* This is not a template type, so there's nothing to do. */
16514 : 92384028 : return t;
16515 : :
16516 : : case ERROR_MARK:
16517 : : case IDENTIFIER_NODE:
16518 : : case VOID_TYPE:
16519 : : case OPAQUE_TYPE:
16520 : : case REAL_TYPE:
16521 : : case COMPLEX_TYPE:
16522 : : case VECTOR_TYPE:
16523 : : case BOOLEAN_TYPE:
16524 : : case NULLPTR_TYPE:
16525 : : case LANG_TYPE:
16526 : : return t;
16527 : :
16528 : 79598236 : case INTEGER_TYPE:
16529 : 79598236 : if (t == integer_type_node)
16530 : : return t;
16531 : :
16532 : 79598218 : if (TREE_CODE (TYPE_MIN_VALUE (t)) == INTEGER_CST
16533 : 79598218 : && TREE_CODE (TYPE_MAX_VALUE (t)) == INTEGER_CST)
16534 : : return t;
16535 : :
16536 : 252262 : {
16537 : 252262 : tree max, omax = TREE_OPERAND (TYPE_MAX_VALUE (t), 0);
16538 : :
16539 : 252262 : max = tsubst_expr (omax, args, complain, in_decl);
16540 : :
16541 : : /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
16542 : : needed. */
16543 : 252262 : if (TREE_CODE (max) == NOP_EXPR
16544 : 12656 : && TREE_SIDE_EFFECTS (omax)
16545 : 252267 : && !TREE_TYPE (max))
16546 : 0 : TREE_TYPE (max) = TREE_TYPE (TREE_OPERAND (max, 0));
16547 : :
16548 : : /* If we're in a partial instantiation, preserve the magic NOP_EXPR
16549 : : with TREE_SIDE_EFFECTS that indicates this is not an integral
16550 : : constant expression. */
16551 : 252262 : if (processing_template_decl
16552 : 252262 : && TREE_SIDE_EFFECTS (omax) && TREE_CODE (omax) == NOP_EXPR)
16553 : : {
16554 : 0 : gcc_assert (TREE_CODE (max) == NOP_EXPR);
16555 : 0 : TREE_SIDE_EFFECTS (max) = 1;
16556 : : }
16557 : :
16558 : 252262 : return compute_array_index_type (NULL_TREE, max, complain);
16559 : : }
16560 : :
16561 : 2246997445 : case TEMPLATE_TYPE_PARM:
16562 : 2246997445 : if (TEMPLATE_TYPE_LEVEL (t) == 0)
16563 : : {
16564 : : /* This is either an ordinary level-less auto or a CTAD placeholder
16565 : : auto. These get replaced only via do_auto_deduction which, in the
16566 : : ordinary case, temporarily overrides its level to 1 before calling
16567 : : tsubst. CTAD placeholders are replaced via do_class_deduction. */
16568 : 11677 : gcc_checking_assert (is_auto (t));
16569 : 11677 : tree tmpl = CLASS_PLACEHOLDER_TEMPLATE (t);
16570 : 11677 : if (!tmpl)
16571 : : /* Ordinary level-less auto has nothing to substitute. */
16572 : : return t;
16573 : :
16574 : : /* Substitute the template of this CTAD placeholder. */
16575 : 11606 : tmpl = tsubst_expr (tmpl, args, complain, in_decl);
16576 : 11606 : if (TREE_CODE (tmpl) == TEMPLATE_TEMPLATE_PARM)
16577 : 3552 : tmpl = TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (tmpl);
16578 : :
16579 : 11606 : if (tmpl != CLASS_PLACEHOLDER_TEMPLATE (t))
16580 : 3733 : return make_template_placeholder (tmpl);
16581 : : else
16582 : : return t;
16583 : : }
16584 : : /* Fall through. */
16585 : 2389328281 : case TEMPLATE_TEMPLATE_PARM:
16586 : 2389328281 : case BOUND_TEMPLATE_TEMPLATE_PARM:
16587 : 2389328281 : case TEMPLATE_PARM_INDEX:
16588 : 2389328281 : {
16589 : 2389328281 : int idx;
16590 : 2389328281 : int level;
16591 : 2389328281 : int levels;
16592 : 2389328281 : tree arg = NULL_TREE;
16593 : :
16594 : 2389328281 : r = NULL_TREE;
16595 : :
16596 : 2389328281 : gcc_assert (TREE_VEC_LENGTH (args) > 0);
16597 : 2389328281 : template_parm_level_and_index (t, &level, &idx);
16598 : :
16599 : 2389328281 : levels = TMPL_ARGS_DEPTH (args);
16600 : 2389328281 : if (level <= levels
16601 : 6859203323 : && TREE_VEC_LENGTH (TMPL_ARGS_LEVEL (args, level)) > 0)
16602 : : {
16603 : 2234937478 : arg = TMPL_ARG (args, level, idx);
16604 : :
16605 : : /* See through ARGUMENT_PACK_SELECT arguments. */
16606 : 2234937478 : if (arg && TREE_CODE (arg) == ARGUMENT_PACK_SELECT)
16607 : 9799184 : arg = argument_pack_select_arg (arg);
16608 : : }
16609 : :
16610 : 2389328281 : if (arg == error_mark_node)
16611 : : return error_mark_node;
16612 : 2389328230 : else if (arg != NULL_TREE)
16613 : : {
16614 : 2224260084 : if (ARGUMENT_PACK_P (arg))
16615 : : /* If ARG is an argument pack, we don't actually want to
16616 : : perform a substitution here, because substitutions
16617 : : for argument packs are only done
16618 : : element-by-element. We can get to this point when
16619 : : substituting the type of a non-type template
16620 : : parameter pack, when that type actually contains
16621 : : template parameter packs from an outer template, e.g.,
16622 : :
16623 : : template<typename... Types> struct A {
16624 : : template<Types... Values> struct B { };
16625 : : }; */
16626 : : return t;
16627 : :
16628 : 2224259732 : if (code == TEMPLATE_TYPE_PARM)
16629 : : {
16630 : 2091393193 : int quals;
16631 : :
16632 : 2091393193 : gcc_assert (TYPE_P (arg));
16633 : :
16634 : 2091393193 : quals = cp_type_quals (arg) | cp_type_quals (t);
16635 : :
16636 : 2091393193 : return cp_build_qualified_type
16637 : 2091393193 : (arg, quals, complain | tf_ignore_bad_quals);
16638 : : }
16639 : 132866539 : else if (code == BOUND_TEMPLATE_TEMPLATE_PARM)
16640 : : {
16641 : : /* We are processing a type constructed from a
16642 : : template template parameter. */
16643 : 656668 : tree argvec = tsubst (TYPE_TI_ARGS (t),
16644 : : args, complain, in_decl);
16645 : 328334 : if (argvec == error_mark_node)
16646 : : return error_mark_node;
16647 : :
16648 : 328334 : gcc_assert (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
16649 : : || TREE_CODE (arg) == TEMPLATE_DECL
16650 : : || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE);
16651 : :
16652 : 328334 : if (TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
16653 : : /* Consider this code:
16654 : :
16655 : : template <template <class> class Template>
16656 : : struct Internal {
16657 : : template <class Arg> using Bind = Template<Arg>;
16658 : : };
16659 : :
16660 : : template <template <class> class Template, class Arg>
16661 : : using Instantiate = Template<Arg>; //#0
16662 : :
16663 : : template <template <class> class Template,
16664 : : class Argument>
16665 : : using Bind =
16666 : : Instantiate<Internal<Template>::template Bind,
16667 : : Argument>; //#1
16668 : :
16669 : : When #1 is parsed, the
16670 : : BOUND_TEMPLATE_TEMPLATE_PARM representing the
16671 : : parameter `Template' in #0 matches the
16672 : : UNBOUND_CLASS_TEMPLATE representing the argument
16673 : : `Internal<Template>::template Bind'; We then want
16674 : : to assemble the type `Bind<Argument>' that can't
16675 : : be fully created right now, because
16676 : : `Internal<Template>' not being complete, the Bind
16677 : : template cannot be looked up in that context. So
16678 : : we need to "store" `Bind<Argument>' for later
16679 : : when the context of Bind becomes complete. Let's
16680 : : store that in a TYPENAME_TYPE. */
16681 : 6 : return make_typename_type (TYPE_CONTEXT (arg),
16682 : : build_nt (TEMPLATE_ID_EXPR,
16683 : 6 : TYPE_IDENTIFIER (arg),
16684 : : argvec),
16685 : : typename_type,
16686 : 6 : complain);
16687 : :
16688 : : /* We can get a TEMPLATE_TEMPLATE_PARM here when we
16689 : : are resolving nested-types in the signature of a
16690 : : member function templates. Otherwise ARG is a
16691 : : TEMPLATE_DECL and is the real template to be
16692 : : instantiated. */
16693 : 328328 : if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
16694 : 127 : arg = TYPE_NAME (arg);
16695 : :
16696 : 328328 : r = lookup_template_class (arg,
16697 : : argvec, in_decl,
16698 : 328328 : DECL_CONTEXT (arg),
16699 : : complain);
16700 : 328328 : return cp_build_qualified_type
16701 : 328328 : (r, cp_type_quals (t) | cp_type_quals (r), complain);
16702 : : }
16703 : 132538205 : else if (code == TEMPLATE_TEMPLATE_PARM)
16704 : : return arg;
16705 : : else
16706 : : /* TEMPLATE_PARM_INDEX. */
16707 : 130828467 : return convert_from_reference (unshare_expr (arg));
16708 : : }
16709 : :
16710 : 165068146 : if (level == 1)
16711 : : /* This can happen during the attempted tsubst'ing in
16712 : : unify. This means that we don't yet have any information
16713 : : about the template parameter in question. */
16714 : : return t;
16715 : :
16716 : : /* Early in template argument deduction substitution, we don't
16717 : : want to reduce the level of 'auto', or it will be confused
16718 : : with a normal template parm in subsequent deduction.
16719 : : Similarly, don't reduce the level of template parameters to
16720 : : avoid mismatches when deducing their types. */
16721 : 154390763 : if (complain & tf_partial)
16722 : : return t;
16723 : :
16724 : : /* If we get here, we must have been looking at a parm for a
16725 : : more deeply nested template. Make a new version of this
16726 : : template parameter, but with a lower level. */
16727 : 154206035 : int quals;
16728 : 154206035 : switch (code)
16729 : : {
16730 : 145633499 : case TEMPLATE_TYPE_PARM:
16731 : 145633499 : case TEMPLATE_TEMPLATE_PARM:
16732 : 145633499 : quals = cp_type_quals (t);
16733 : 145633499 : if (quals)
16734 : : {
16735 : 10188904 : gcc_checking_assert (code == TEMPLATE_TYPE_PARM);
16736 : 10188904 : t = TYPE_MAIN_VARIANT (t);
16737 : : }
16738 : :
16739 : 145633499 : if (tree d = TEMPLATE_TYPE_DESCENDANTS (t))
16740 : 134086677 : if (TEMPLATE_PARM_LEVEL (d) == TEMPLATE_TYPE_LEVEL (t) - levels
16741 : 134086677 : && (code == TEMPLATE_TYPE_PARM
16742 : 39682 : || TEMPLATE_TEMPLATE_PARM_SIMPLE_P (t)))
16743 : : /* Cache lowering a type parameter or a simple template
16744 : : template parameter. */
16745 : 134059554 : r = TREE_TYPE (d);
16746 : :
16747 : 134059554 : if (!r)
16748 : : {
16749 : 11573945 : r = copy_type (t);
16750 : 11573945 : TEMPLATE_TYPE_PARM_INDEX (r)
16751 : 11573945 : = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t),
16752 : : r, levels, args, complain);
16753 : 11573945 : TYPE_STUB_DECL (r) = TYPE_NAME (r) = TEMPLATE_TYPE_DECL (r);
16754 : 11573945 : TYPE_MAIN_VARIANT (r) = r;
16755 : 11573945 : TYPE_POINTER_TO (r) = NULL_TREE;
16756 : 11573945 : TYPE_REFERENCE_TO (r) = NULL_TREE;
16757 : :
16758 : 11573945 : if (code == TEMPLATE_TYPE_PARM)
16759 : 11572142 : if (tree ci = PLACEHOLDER_TYPE_CONSTRAINTS_INFO (t))
16760 : : /* Propagate constraints on placeholders since they are
16761 : : only instantiated during satisfaction. */
16762 : 112951 : PLACEHOLDER_TYPE_CONSTRAINTS_INFO (r) = ci;
16763 : :
16764 : 11573945 : if (TYPE_STRUCTURAL_EQUALITY_P (t))
16765 : 0 : SET_TYPE_STRUCTURAL_EQUALITY (r);
16766 : : else
16767 : 11573945 : TYPE_CANONICAL (r) = canonical_type_parameter (r);
16768 : : }
16769 : :
16770 : 145633499 : if (quals)
16771 : 10188904 : r = cp_build_qualified_type (r, quals,
16772 : : complain | tf_ignore_bad_quals);
16773 : : break;
16774 : :
16775 : 9252 : case BOUND_TEMPLATE_TEMPLATE_PARM:
16776 : 9252 : {
16777 : 9252 : tree tinfo = TYPE_TEMPLATE_INFO (t);
16778 : : /* We might need to substitute into the types of non-type
16779 : : template parameters. This also lowers the level of
16780 : : the ttp appropriately. */
16781 : 9252 : tree tmpl = tsubst (TI_TEMPLATE (tinfo), args,
16782 : : complain, in_decl);
16783 : 9252 : if (tmpl == error_mark_node)
16784 : : return error_mark_node;
16785 : 9252 : tree argvec = tsubst (TI_ARGS (tinfo), args,
16786 : : complain, in_decl);
16787 : 9252 : if (argvec == error_mark_node)
16788 : : return error_mark_node;
16789 : 9252 : r = lookup_template_class (tmpl, argvec, in_decl, NULL_TREE,
16790 : : complain);
16791 : 9252 : r = cp_build_qualified_type (r, cp_type_quals (t), complain);
16792 : 9252 : break;
16793 : : }
16794 : :
16795 : 8563284 : case TEMPLATE_PARM_INDEX:
16796 : : /* OK, now substitute the type of the non-type parameter. We
16797 : : couldn't do it earlier because it might be an auto parameter,
16798 : : and we wouldn't need to if we had an argument. */
16799 : 8563284 : type = tsubst (type, args, complain, in_decl);
16800 : 8563284 : if (type == error_mark_node)
16801 : : return error_mark_node;
16802 : 8563278 : r = reduce_template_parm_level (t, type, levels, args, complain);
16803 : 8563278 : break;
16804 : :
16805 : 0 : default:
16806 : 0 : gcc_unreachable ();
16807 : : }
16808 : :
16809 : : return r;
16810 : : }
16811 : :
16812 : 22 : case TREE_LIST:
16813 : 22 : return tsubst_tree_list (t, args, complain, in_decl);
16814 : :
16815 : 0 : case TREE_BINFO:
16816 : : /* We should never be tsubsting a binfo. */
16817 : 0 : gcc_unreachable ();
16818 : :
16819 : 282260573 : case TREE_VEC:
16820 : : /* A vector of template arguments. */
16821 : 282260573 : gcc_assert (!type);
16822 : 282260573 : return tsubst_template_args (t, args, complain, in_decl);
16823 : :
16824 : 432618957 : case POINTER_TYPE:
16825 : 432618957 : case REFERENCE_TYPE:
16826 : 432618957 : {
16827 : 432618957 : if (type == TREE_TYPE (t) && TREE_CODE (type) != METHOD_TYPE)
16828 : : return t;
16829 : :
16830 : : /* [temp.deduct]
16831 : :
16832 : : Type deduction may fail for any of the following
16833 : : reasons:
16834 : :
16835 : : -- Attempting to create a pointer to reference type.
16836 : : -- Attempting to create a reference to a reference type or
16837 : : a reference to void.
16838 : :
16839 : : Core issue 106 says that creating a reference to a reference
16840 : : during instantiation is no longer a cause for failure. We
16841 : : only enforce this check in strict C++98 mode. */
16842 : 402693584 : if ((TYPE_REF_P (type)
16843 : 12193179 : && (((cxx_dialect == cxx98) && flag_iso) || code != REFERENCE_TYPE))
16844 : 402693468 : || (code == REFERENCE_TYPE && VOID_TYPE_P (type)))
16845 : : {
16846 : 779 : static location_t last_loc;
16847 : :
16848 : : /* We keep track of the last time we issued this error
16849 : : message to avoid spewing a ton of messages during a
16850 : : single bad template instantiation. */
16851 : 779 : if (complain & tf_error
16852 : 34 : && last_loc != input_location)
16853 : : {
16854 : 34 : if (VOID_TYPE_P (type))
16855 : 16 : error ("forming reference to void");
16856 : 18 : else if (code == POINTER_TYPE)
16857 : 18 : error ("forming pointer to reference type %qT", type);
16858 : : else
16859 : 0 : error ("forming reference to reference type %qT", type);
16860 : 34 : last_loc = input_location;
16861 : : }
16862 : :
16863 : 779 : return error_mark_node;
16864 : : }
16865 : 402692805 : else if (TREE_CODE (type) == FUNCTION_TYPE
16866 : 402692805 : && (type_memfn_quals (type) != TYPE_UNQUALIFIED
16867 : 1931298 : || type_memfn_rqual (type) != REF_QUAL_NONE))
16868 : : {
16869 : 55 : if (complain & tf_error)
16870 : : {
16871 : 11 : if (code == POINTER_TYPE)
16872 : 6 : error ("forming pointer to qualified function type %qT",
16873 : : type);
16874 : : else
16875 : 5 : error ("forming reference to qualified function type %qT",
16876 : : type);
16877 : : }
16878 : 55 : return error_mark_node;
16879 : : }
16880 : 402692750 : else if (code == POINTER_TYPE)
16881 : : {
16882 : 215485453 : r = build_pointer_type (type);
16883 : 215485453 : if (TREE_CODE (type) == METHOD_TYPE)
16884 : 33474 : r = build_ptrmemfunc_type (r);
16885 : : }
16886 : 187207297 : else if (TYPE_REF_P (type))
16887 : : /* In C++0x, during template argument substitution, when there is an
16888 : : attempt to create a reference to a reference type, reference
16889 : : collapsing is applied as described in [14.3.1/4 temp.arg.type]:
16890 : :
16891 : : "If a template-argument for a template-parameter T names a type
16892 : : that is a reference to a type A, an attempt to create the type
16893 : : 'lvalue reference to cv T' creates the type 'lvalue reference to
16894 : : A,' while an attempt to create the type type rvalue reference to
16895 : : cv T' creates the type T"
16896 : : */
16897 : 12193063 : r = cp_build_reference_type
16898 : 12193063 : (TREE_TYPE (type),
16899 : 12193063 : TYPE_REF_IS_RVALUE (t) && TYPE_REF_IS_RVALUE (type));
16900 : : else
16901 : 175014234 : r = cp_build_reference_type (type, TYPE_REF_IS_RVALUE (t));
16902 : 402692750 : r = cp_build_qualified_type (r, cp_type_quals (t), complain);
16903 : :
16904 : 402692750 : if (r != error_mark_node)
16905 : : /* Will this ever be needed for TYPE_..._TO values? */
16906 : 402692750 : layout_type (r);
16907 : :
16908 : : return r;
16909 : : }
16910 : 203672 : case OFFSET_TYPE:
16911 : 203672 : {
16912 : 203672 : r = tsubst (TYPE_OFFSET_BASETYPE (t), args, complain, in_decl);
16913 : 203672 : if (r == error_mark_node || !MAYBE_CLASS_TYPE_P (r))
16914 : : {
16915 : : /* [temp.deduct]
16916 : :
16917 : : Type deduction may fail for any of the following
16918 : : reasons:
16919 : :
16920 : : -- Attempting to create "pointer to member of T" when T
16921 : : is not a class type. */
16922 : 0 : if (complain & tf_error)
16923 : 0 : error ("creating pointer to member of non-class type %qT", r);
16924 : 0 : return error_mark_node;
16925 : : }
16926 : 203672 : if (TYPE_REF_P (type))
16927 : : {
16928 : 6 : if (complain & tf_error)
16929 : 3 : error ("creating pointer to member reference type %qT", type);
16930 : 6 : return error_mark_node;
16931 : : }
16932 : 203666 : if (VOID_TYPE_P (type))
16933 : : {
16934 : 3 : if (complain & tf_error)
16935 : 3 : error ("creating pointer to member of type void");
16936 : 3 : return error_mark_node;
16937 : : }
16938 : 203663 : gcc_assert (TREE_CODE (type) != METHOD_TYPE);
16939 : 203663 : if (TREE_CODE (type) == FUNCTION_TYPE)
16940 : : {
16941 : : /* The type of the implicit object parameter gets its
16942 : : cv-qualifiers from the FUNCTION_TYPE. */
16943 : 152880 : tree memptr;
16944 : 152880 : tree method_type
16945 : 152880 : = build_memfn_type (type, r, type_memfn_quals (type),
16946 : : type_memfn_rqual (type));
16947 : 152880 : memptr = build_ptrmemfunc_type (build_pointer_type (method_type));
16948 : 152880 : return cp_build_qualified_type (memptr, cp_type_quals (t),
16949 : 152880 : complain);
16950 : : }
16951 : : else
16952 : 50783 : return cp_build_qualified_type (build_ptrmem_type (r, type),
16953 : : cp_type_quals (t),
16954 : 50783 : complain);
16955 : : }
16956 : 125366163 : case FUNCTION_TYPE:
16957 : 125366163 : case METHOD_TYPE:
16958 : 125366163 : {
16959 : 125366163 : tree fntype;
16960 : 125366163 : tree specs;
16961 : 125366163 : fntype = tsubst_function_type (t, args, complain, in_decl);
16962 : 125355330 : if (fntype == error_mark_node)
16963 : : return error_mark_node;
16964 : :
16965 : : /* Substitute the exception specification. */
16966 : 123968952 : specs = tsubst_exception_specification (t, args, complain, in_decl,
16967 : : /*defer_ok*/fndecl_type);
16968 : 123968952 : if (specs == error_mark_node)
16969 : : return error_mark_node;
16970 : 123968939 : if (specs)
16971 : 44409485 : fntype = build_exception_variant (fntype, specs);
16972 : : return fntype;
16973 : : }
16974 : 6637469 : case ARRAY_TYPE:
16975 : 6637469 : {
16976 : 6637469 : tree domain = tsubst (TYPE_DOMAIN (t), args, complain, in_decl);
16977 : 6637469 : if (domain == error_mark_node)
16978 : : return error_mark_node;
16979 : :
16980 : : /* As an optimization, we avoid regenerating the array type if
16981 : : it will obviously be the same as T. */
16982 : 12850386 : if (type == TREE_TYPE (t) && domain == TYPE_DOMAIN (t))
16983 : : return t;
16984 : :
16985 : : /* These checks should match the ones in create_array_type_for_decl.
16986 : :
16987 : : [temp.deduct]
16988 : :
16989 : : The deduction may fail for any of the following reasons:
16990 : :
16991 : : -- Attempting to create an array with an element type that
16992 : : is void, a function type, or a reference type, or [DR337]
16993 : : an abstract class type. */
16994 : 496339 : if (VOID_TYPE_P (type)
16995 : 496339 : || TREE_CODE (type) == FUNCTION_TYPE
16996 : 496329 : || (TREE_CODE (type) == ARRAY_TYPE
16997 : 1138 : && TYPE_DOMAIN (type) == NULL_TREE)
16998 : 992660 : || TYPE_REF_P (type))
16999 : : {
17000 : 18 : if (complain & tf_error)
17001 : 3 : error ("creating array of %qT", type);
17002 : 18 : return error_mark_node;
17003 : : }
17004 : :
17005 : 496321 : if (!verify_type_context (input_location, TCTX_ARRAY_ELEMENT, type,
17006 : : !(complain & tf_error)))
17007 : 0 : return error_mark_node;
17008 : :
17009 : 496321 : r = build_cplus_array_type (type, domain);
17010 : :
17011 : 496321 : if (!valid_array_size_p (input_location, r, in_decl,
17012 : : (complain & tf_error)))
17013 : 15 : return error_mark_node;
17014 : :
17015 : 496306 : if (TYPE_USER_ALIGN (t))
17016 : : {
17017 : 6 : SET_TYPE_ALIGN (r, TYPE_ALIGN (t));
17018 : 6 : TYPE_USER_ALIGN (r) = 1;
17019 : : }
17020 : :
17021 : : return r;
17022 : : }
17023 : :
17024 : 130065798 : case TYPENAME_TYPE:
17025 : 130065798 : {
17026 : 130065798 : tree ctx = TYPE_CONTEXT (t);
17027 : 130065798 : if (TREE_CODE (ctx) == TYPE_PACK_EXPANSION)
17028 : : {
17029 : 6 : ctx = tsubst_pack_expansion (ctx, args,
17030 : : complain | tf_qualifying_scope,
17031 : : in_decl);
17032 : 6 : if (ctx == error_mark_node)
17033 : : return error_mark_node;
17034 : 6 : if (TREE_VEC_LENGTH (ctx) > 1)
17035 : : {
17036 : 0 : if (complain & tf_error)
17037 : 0 : error ("%qD expanded to more than one element",
17038 : 0 : TYPENAME_TYPE_FULLNAME (t));
17039 : 0 : return error_mark_node;
17040 : : }
17041 : 6 : if (TREE_VEC_LENGTH (ctx) == 0)
17042 : : {
17043 : 3 : if (complain & tf_error)
17044 : 6 : error ("%qD is instantiated for an empty pack",
17045 : 3 : TYPENAME_TYPE_FULLNAME (t));
17046 : 3 : return error_mark_node;
17047 : : }
17048 : 3 : ctx = TREE_VEC_ELT (ctx, 0);
17049 : : }
17050 : : else
17051 : 130065792 : ctx = tsubst_entering_scope (ctx, args,
17052 : : complain | tf_qualifying_scope,
17053 : : in_decl);
17054 : 130065795 : if (ctx == error_mark_node)
17055 : : return error_mark_node;
17056 : :
17057 : 130044645 : tree f = tsubst_name (TYPENAME_TYPE_FULLNAME (t), args,
17058 : : complain, in_decl);
17059 : 130044645 : if (f == error_mark_node)
17060 : : return error_mark_node;
17061 : :
17062 : 130044612 : if (!MAYBE_CLASS_TYPE_P (ctx))
17063 : : {
17064 : 11735 : if (complain & tf_error)
17065 : 60 : error ("%qT is not a class, struct, or union type", ctx);
17066 : 11735 : return error_mark_node;
17067 : : }
17068 : 130032877 : else if (!uses_template_parms (ctx) && !TYPE_BEING_DEFINED (ctx))
17069 : : {
17070 : : /* Normally, make_typename_type does not require that the CTX
17071 : : have complete type in order to allow things like:
17072 : :
17073 : : template <class T> struct S { typename S<T>::X Y; };
17074 : :
17075 : : But, such constructs have already been resolved by this
17076 : : point, so here CTX really should have complete type, unless
17077 : : it's a partial instantiation. */
17078 : 108417407 : if (!complete_type_or_maybe_complain (ctx, NULL_TREE, complain))
17079 : 3073 : return error_mark_node;
17080 : : }
17081 : :
17082 : : /* FIXME: TYPENAME_IS_CLASS_P conflates 'class' vs 'struct' vs 'union'
17083 : : tags. TYPENAME_TYPE should probably remember the exact tag that
17084 : : was written. */
17085 : 130029804 : enum tag_types tag_type
17086 : 130029804 : = TYPENAME_IS_CLASS_P (t) ? class_type
17087 : 130029721 : : TYPENAME_IS_ENUM_P (t) ? enum_type
17088 : 130029804 : : typename_type;
17089 : 130029804 : tsubst_flags_t tcomplain = complain | tf_keep_type_decl;
17090 : 130029804 : tcomplain |= tst_ok_flag | qualifying_scope_flag;
17091 : 130029804 : f = make_typename_type (ctx, f, tag_type, tcomplain);
17092 : 130029804 : if (f == error_mark_node)
17093 : : return f;
17094 : 114250390 : if (TREE_CODE (f) == TYPE_DECL)
17095 : : {
17096 : 91196862 : complain |= tf_ignore_bad_quals;
17097 : 91196862 : f = TREE_TYPE (f);
17098 : : }
17099 : :
17100 : 114250390 : if (TREE_CODE (f) != TYPENAME_TYPE)
17101 : : {
17102 : 93249180 : if (TYPENAME_IS_ENUM_P (t) && TREE_CODE (f) != ENUMERAL_TYPE)
17103 : : {
17104 : 3 : if (complain & tf_error)
17105 : 3 : error ("%qT resolves to %qT, which is not an enumeration type",
17106 : : t, f);
17107 : : else
17108 : : return error_mark_node;
17109 : : }
17110 : 93249177 : else if (TYPENAME_IS_CLASS_P (t) && !CLASS_TYPE_P (f))
17111 : : {
17112 : 6 : if (complain & tf_error)
17113 : 3 : error ("%qT resolves to %qT, which is not a class type",
17114 : : t, f);
17115 : : else
17116 : : return error_mark_node;
17117 : : }
17118 : : }
17119 : :
17120 : 114250387 : return cp_build_qualified_type
17121 : 114250387 : (f, cp_type_quals (f) | cp_type_quals (t), complain);
17122 : : }
17123 : :
17124 : 29537 : case UNBOUND_CLASS_TEMPLATE:
17125 : 29537 : {
17126 : 29537 : ++processing_template_decl;
17127 : 29537 : tree ctx = tsubst_entering_scope (TYPE_CONTEXT (t), args,
17128 : : complain, in_decl);
17129 : 29537 : --processing_template_decl;
17130 : 29537 : tree name = TYPE_IDENTIFIER (t);
17131 : 29537 : tree parm_list = DECL_TEMPLATE_PARMS (TYPE_NAME (t));
17132 : :
17133 : 29537 : if (ctx == error_mark_node || name == error_mark_node)
17134 : : return error_mark_node;
17135 : :
17136 : 29537 : if (parm_list)
17137 : 12 : parm_list = tsubst_template_parms (parm_list, args, complain);
17138 : 29537 : return make_unbound_class_template (ctx, name, parm_list, complain);
17139 : : }
17140 : :
17141 : 221 : case TYPEOF_TYPE:
17142 : 221 : {
17143 : 221 : tree type;
17144 : :
17145 : 221 : ++cp_unevaluated_operand;
17146 : 221 : ++c_inhibit_evaluation_warnings;
17147 : :
17148 : 221 : type = tsubst_expr (TYPEOF_TYPE_EXPR (t), args, complain, in_decl);
17149 : :
17150 : 221 : --cp_unevaluated_operand;
17151 : 221 : --c_inhibit_evaluation_warnings;
17152 : :
17153 : 221 : type = finish_typeof (type);
17154 : 221 : return cp_build_qualified_type (type,
17155 : 221 : cp_type_quals (t)
17156 : 221 : | cp_type_quals (type),
17157 : 221 : complain);
17158 : : }
17159 : :
17160 : 13267567 : case DECLTYPE_TYPE:
17161 : 13267567 : {
17162 : 13267567 : tree type;
17163 : :
17164 : 13267567 : ++cp_unevaluated_operand;
17165 : 13267567 : ++c_inhibit_evaluation_warnings;
17166 : :
17167 : 13267567 : type = tsubst_expr (DECLTYPE_TYPE_EXPR (t), args,
17168 : : complain|tf_decltype, in_decl);
17169 : :
17170 : 13256767 : --cp_unevaluated_operand;
17171 : 13256767 : --c_inhibit_evaluation_warnings;
17172 : :
17173 : 13256767 : if (DECLTYPE_FOR_LAMBDA_CAPTURE (t))
17174 : 259410 : type = lambda_capture_field_type (type,
17175 : : false /*explicit_init*/,
17176 : 129705 : DECLTYPE_FOR_REF_CAPTURE (t));
17177 : 13127062 : else if (DECLTYPE_FOR_LAMBDA_PROXY (t))
17178 : 159 : type = lambda_proxy_type (type);
17179 : : else
17180 : : {
17181 : 13126903 : bool id = DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t);
17182 : 752624 : if (id && TREE_CODE (DECLTYPE_TYPE_EXPR (t)) == BIT_NOT_EXPR
17183 : 13126903 : && EXPR_P (type))
17184 : : /* In a template ~id could be either a complement expression
17185 : : or an unqualified-id naming a destructor; if instantiating
17186 : : it produces an expression, it's not an id-expression or
17187 : : member access. */
17188 : : id = false;
17189 : 13126903 : type = finish_decltype_type (type, id, complain);
17190 : : }
17191 : 13256767 : return cp_build_qualified_type (type,
17192 : 13256767 : cp_type_quals (t)
17193 : 13256767 : | cp_type_quals (type),
17194 : 13256767 : complain | tf_ignore_bad_quals);
17195 : : }
17196 : :
17197 : 3855364 : case TRAIT_TYPE:
17198 : 3855364 : {
17199 : 3855364 : tree type1 = TRAIT_TYPE_TYPE1 (t);
17200 : 3855364 : if (TYPE_P (type1))
17201 : 3773431 : type1 = tsubst (type1, args, complain, in_decl);
17202 : : else
17203 : 81933 : type1 = tsubst_expr (type1, args, complain, in_decl);
17204 : 3855364 : tree type2 = tsubst (TRAIT_TYPE_TYPE2 (t), args, complain, in_decl);
17205 : 3855364 : type = finish_trait_type (TRAIT_TYPE_KIND (t), type1, type2, complain);
17206 : 3855364 : return cp_build_qualified_type (type,
17207 : 3855364 : cp_type_quals (t) | cp_type_quals (type),
17208 : 3855364 : complain | tf_ignore_bad_quals);
17209 : : }
17210 : :
17211 : 0 : case TYPE_ARGUMENT_PACK:
17212 : 0 : case NONTYPE_ARGUMENT_PACK:
17213 : 0 : return tsubst_argument_pack (t, args, complain, in_decl);
17214 : :
17215 : 58 : case PACK_INDEX_TYPE:
17216 : 58 : return tsubst_pack_index (t, args, complain, in_decl);
17217 : :
17218 : 0 : case VOID_CST:
17219 : 0 : case INTEGER_CST:
17220 : 0 : case REAL_CST:
17221 : 0 : case STRING_CST:
17222 : 0 : case PLUS_EXPR:
17223 : 0 : case MINUS_EXPR:
17224 : 0 : case NEGATE_EXPR:
17225 : 0 : case NOP_EXPR:
17226 : 0 : case INDIRECT_REF:
17227 : 0 : case ADDR_EXPR:
17228 : 0 : case CALL_EXPR:
17229 : 0 : case ARRAY_REF:
17230 : 0 : case SCOPE_REF:
17231 : 0 : case OMP_ARRAY_SECTION:
17232 : : /* We should use one of the expression tsubsts for these codes. */
17233 : 0 : gcc_unreachable ();
17234 : :
17235 : 0 : default:
17236 : 0 : sorry ("use of %qs in template", get_tree_code_name (code));
17237 : 0 : return error_mark_node;
17238 : : }
17239 : : }
17240 : :
17241 : : /* Convenience wrapper over tsubst for substituting into the LHS
17242 : : of the :: scope resolution operator. */
17243 : :
17244 : : static tree
17245 : 61319501 : tsubst_scope (tree t, tree args, tsubst_flags_t complain, tree in_decl)
17246 : : {
17247 : 61319501 : gcc_checking_assert (TYPE_P (t));
17248 : 61319501 : return tsubst (t, args, complain | tf_qualifying_scope, in_decl);
17249 : : }
17250 : :
17251 : : /* Convenience wrapper over tsubst for substituting into an id-expression
17252 : : without resolving its terminal name. */
17253 : :
17254 : : static tree
17255 : 210432031 : tsubst_name (tree t, tree args, tsubst_flags_t complain, tree in_decl)
17256 : : {
17257 : 150412514 : return tsubst_expr (t, args, complain | tf_no_name_lookup, in_decl);
17258 : : }
17259 : :
17260 : : /* OLDFNS is a lookup set of member functions from some class template, and
17261 : : NEWFNS is a lookup set of member functions from NEWTYPE, a specialization
17262 : : of that class template. Return the subset of NEWFNS which are
17263 : : specializations of a function from OLDFNS. */
17264 : :
17265 : : static tree
17266 : 2509317 : filter_memfn_lookup (tree oldfns, tree newfns, tree newtype)
17267 : : {
17268 : : /* Record all member functions from the old lookup set OLDFNS into
17269 : : VISIBLE_SET. */
17270 : 2509317 : hash_set<tree> visible_set;
17271 : 2509317 : bool seen_dep_using = false;
17272 : 5066669 : for (tree fn : lkp_range (oldfns))
17273 : : {
17274 : 2557352 : if (TREE_CODE (fn) == USING_DECL)
17275 : : {
17276 : : /* Imprecisely handle dependent using-decl by keeping all members
17277 : : in the new lookup set that are defined in a base class, i.e.
17278 : : members that could plausibly have been introduced by this
17279 : : dependent using-decl.
17280 : : FIXME: Track which members are introduced by a dependent
17281 : : using-decl precisely, perhaps by performing another lookup
17282 : : from the substituted USING_DECL_SCOPE. */
17283 : 0 : gcc_checking_assert (DECL_DEPENDENT_P (fn));
17284 : : seen_dep_using = true;
17285 : : }
17286 : : else
17287 : 2557352 : visible_set.add (fn);
17288 : : }
17289 : :
17290 : : /* Returns true iff (a less specialized version of) FN appeared in
17291 : : the old lookup set OLDFNS. */
17292 : 5069624 : auto visible_p = [newtype, seen_dep_using, &visible_set] (tree fn) {
17293 : 2560307 : if (DECL_CONTEXT (fn) != newtype)
17294 : : /* FN is a member function from a base class, introduced via a
17295 : : using-decl; if it might have been introduced by a dependent
17296 : : using-decl then just conservatively keep it, otherwise look
17297 : : in the old lookup set for FN exactly. */
17298 : 33 : return seen_dep_using || visible_set.contains (fn);
17299 : 2560274 : else if (TREE_CODE (fn) == TEMPLATE_DECL)
17300 : : /* FN is a member function template from the current class;
17301 : : look in the old lookup set for the TEMPLATE_DECL from which
17302 : : it was specialized. */
17303 : 1226347 : return visible_set.contains (DECL_TI_TEMPLATE (fn));
17304 : : else
17305 : : /* FN is a non-template member function from the current class;
17306 : : look in the old lookup set for the FUNCTION_DECL from which
17307 : : it was specialized. */
17308 : 1333927 : return visible_set.contains (DECL_TEMPLATE_RESULT
17309 : 1333927 : (DECL_TI_TEMPLATE (fn)));
17310 : 2509317 : };
17311 : :
17312 : 2509317 : bool lookup_changed_p = false;
17313 : 5066510 : for (tree fn : lkp_range (newfns))
17314 : 2557355 : if (!visible_p (fn))
17315 : : {
17316 : : lookup_changed_p = true;
17317 : : break;
17318 : : }
17319 : 2509317 : if (!lookup_changed_p)
17320 : : return newfns;
17321 : :
17322 : : /* Filter out from NEWFNS the member functions that weren't
17323 : : previously visible according to OLDFNS. */
17324 : 162 : tree filtered_fns = NULL_TREE;
17325 : 162 : unsigned filtered_size = 0;
17326 : 3114 : for (tree fn : lkp_range (newfns))
17327 : 2952 : if (visible_p (fn))
17328 : : {
17329 : 162 : filtered_fns = lookup_add (fn, filtered_fns);
17330 : 162 : filtered_size++;
17331 : : }
17332 : 162 : gcc_checking_assert (seen_dep_using
17333 : : ? filtered_size >= visible_set.elements ()
17334 : : : filtered_size == visible_set.elements ());
17335 : :
17336 : : return filtered_fns;
17337 : 2509317 : }
17338 : :
17339 : : /* tsubst a BASELINK. OBJECT_TYPE, if non-NULL, is the type of the
17340 : : expression on the left-hand side of the "." or "->" operator. We
17341 : : only do the lookup if we had a dependent BASELINK. Otherwise we
17342 : : adjust it onto the instantiated heirarchy. */
17343 : :
17344 : : static tree
17345 : 17905758 : tsubst_baselink (tree baselink, tree object_type,
17346 : : tree args, tsubst_flags_t complain, tree in_decl)
17347 : : {
17348 : 17905758 : bool qualified_p = BASELINK_QUALIFIED_P (baselink);
17349 : 17905758 : tree qualifying_scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink));
17350 : 17905758 : qualifying_scope = tsubst (qualifying_scope, args, complain, in_decl);
17351 : :
17352 : 17905758 : tree optype = BASELINK_OPTYPE (baselink);
17353 : 17905758 : optype = tsubst (optype, args, complain, in_decl);
17354 : :
17355 : 17905758 : tree template_args = NULL_TREE;
17356 : 17905758 : bool template_id_p = false;
17357 : 17905758 : tree fns = BASELINK_FUNCTIONS (baselink);
17358 : 17905758 : if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
17359 : : {
17360 : 7003132 : template_id_p = true;
17361 : 7003132 : template_args = TREE_OPERAND (fns, 1);
17362 : 7003132 : fns = TREE_OPERAND (fns, 0);
17363 : 7003132 : if (template_args)
17364 : 7003132 : template_args = tsubst_template_args (template_args, args,
17365 : : complain, in_decl);
17366 : : }
17367 : :
17368 : 17905758 : tree binfo_type = BINFO_TYPE (BASELINK_BINFO (baselink));
17369 : 17905758 : binfo_type = tsubst (binfo_type, args, complain, in_decl);
17370 : 17905758 : bool dependent_p = (binfo_type != BINFO_TYPE (BASELINK_BINFO (baselink))
17371 : 31798170 : || optype != BASELINK_OPTYPE (baselink));
17372 : :
17373 : 8173947 : if (dependent_p)
17374 : : {
17375 : 9731811 : tree name = OVL_NAME (fns);
17376 : 9731811 : if (IDENTIFIER_CONV_OP_P (name))
17377 : 9 : name = make_conv_op_name (optype);
17378 : :
17379 : : /* See maybe_dependent_member_ref. */
17380 : 9731811 : if ((complain & tf_dguide) && dependent_scope_p (qualifying_scope))
17381 : : {
17382 : 129092 : if (template_id_p)
17383 : 128914 : name = build2 (TEMPLATE_ID_EXPR, unknown_type_node, name,
17384 : : template_args);
17385 : 129092 : return build_qualified_name (NULL_TREE, qualifying_scope, name,
17386 : 129092 : /* ::template */false);
17387 : : }
17388 : :
17389 : 9602719 : if (name == complete_dtor_identifier)
17390 : : /* Treat as-if non-dependent below. */
17391 : 0 : dependent_p = false;
17392 : :
17393 : 9602719 : bool maybe_incomplete = BASELINK_FUNCTIONS_MAYBE_INCOMPLETE_P (baselink);
17394 : 9602719 : baselink = lookup_fnfields (qualifying_scope, name, /*protect=*/1,
17395 : : complain);
17396 : 9602719 : if (maybe_incomplete)
17397 : : {
17398 : : /* Filter out from the new lookup set those functions which didn't
17399 : : appear in the original lookup set (in a less specialized form).
17400 : : This is needed to preserve the consistency of member lookup
17401 : : performed in an incomplete-class context, within which
17402 : : later-declared members ought to remain invisible. */
17403 : 2509317 : BASELINK_FUNCTIONS (baselink)
17404 : 2509317 : = filter_memfn_lookup (fns, BASELINK_FUNCTIONS (baselink),
17405 : : binfo_type);
17406 : 2509317 : BASELINK_FUNCTIONS_MAYBE_INCOMPLETE_P (baselink) = true;
17407 : : }
17408 : :
17409 : 9602719 : if (!baselink)
17410 : : {
17411 : 0 : if ((complain & tf_error)
17412 : 0 : && constructor_name_p (name, qualifying_scope))
17413 : 0 : error ("cannot call constructor %<%T::%D%> directly",
17414 : : qualifying_scope, name);
17415 : 0 : return error_mark_node;
17416 : : }
17417 : :
17418 : 9602719 : fns = BASELINK_FUNCTIONS (baselink);
17419 : : }
17420 : : else
17421 : : {
17422 : : /* We're going to overwrite pieces below, make a duplicate. */
17423 : 8173947 : baselink = copy_node (baselink);
17424 : :
17425 : 8173947 : if (qualifying_scope != BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink)))
17426 : : {
17427 : : /* The decl we found was from non-dependent scope, but we still need
17428 : : to update the binfos for the instantiated qualifying_scope. */
17429 : 265062 : BASELINK_ACCESS_BINFO (baselink) = TYPE_BINFO (qualifying_scope);
17430 : 265062 : BASELINK_BINFO (baselink) = lookup_base (qualifying_scope, binfo_type,
17431 : : ba_unique, nullptr, complain);
17432 : : }
17433 : : }
17434 : :
17435 : : /* If lookup found a single function, mark it as used at this point.
17436 : : (If lookup found multiple functions the one selected later by
17437 : : overload resolution will be marked as used at that point.) */
17438 : 17776666 : if (!template_id_p && !really_overloaded_fn (fns))
17439 : : {
17440 : 7916065 : tree fn = OVL_FIRST (fns);
17441 : 7916065 : bool ok = mark_used (fn, complain);
17442 : 7916065 : if (!ok && !(complain & tf_error))
17443 : 6 : return error_mark_node;
17444 : 7916056 : if (ok && BASELINK_P (baselink))
17445 : : /* We might have instantiated an auto function. */
17446 : 7916056 : TREE_TYPE (baselink) = TREE_TYPE (fn);
17447 : : }
17448 : :
17449 : 17776660 : if (BASELINK_P (baselink))
17450 : : {
17451 : : /* Add back the template arguments, if present. */
17452 : 17776660 : if (template_id_p)
17453 : 13748436 : BASELINK_FUNCTIONS (baselink)
17454 : 6874218 : = build2 (TEMPLATE_ID_EXPR, unknown_type_node, fns, template_args);
17455 : :
17456 : : /* Update the conversion operator type. */
17457 : 17776660 : BASELINK_OPTYPE (baselink) = optype;
17458 : : }
17459 : :
17460 : 17776660 : if (!object_type)
17461 : 328699 : object_type = current_class_type;
17462 : :
17463 : 17776660 : if (qualified_p || !dependent_p)
17464 : : {
17465 : 8186343 : baselink = adjust_result_of_qualified_name_lookup (baselink,
17466 : : qualifying_scope,
17467 : : object_type);
17468 : 8186343 : if (!qualified_p)
17469 : : /* We need to call adjust_result_of_qualified_name_lookup in case the
17470 : : destructor names a base class, but we unset BASELINK_QUALIFIED_P
17471 : : so that we still get virtual function binding. */
17472 : 3082089 : BASELINK_QUALIFIED_P (baselink) = false;
17473 : : }
17474 : :
17475 : : return baselink;
17476 : : }
17477 : :
17478 : : /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
17479 : : true if the qualified-id will be a postfix-expression in-and-of
17480 : : itself; false if more of the postfix-expression follows the
17481 : : QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
17482 : : of "&". */
17483 : :
17484 : : static tree
17485 : 62048270 : tsubst_qualified_id (tree qualified_id, tree args,
17486 : : tsubst_flags_t complain, tree in_decl,
17487 : : bool done, bool address_p)
17488 : : {
17489 : 62048270 : tree expr;
17490 : 62048270 : tree scope;
17491 : 62048270 : tree name;
17492 : 62048270 : bool is_template;
17493 : 62048270 : tree template_args;
17494 : 62048270 : location_t loc = EXPR_LOCATION (qualified_id);
17495 : :
17496 : 62048270 : gcc_assert (TREE_CODE (qualified_id) == SCOPE_REF);
17497 : :
17498 : : /* Figure out what name to look up. */
17499 : 62048270 : name = TREE_OPERAND (qualified_id, 1);
17500 : 62048270 : if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
17501 : : {
17502 : 4615820 : is_template = true;
17503 : 4615820 : template_args = TREE_OPERAND (name, 1);
17504 : 4615820 : if (template_args)
17505 : 4615820 : template_args = tsubst_template_args (template_args, args,
17506 : : complain, in_decl);
17507 : 4615820 : if (template_args == error_mark_node)
17508 : : return error_mark_node;
17509 : 4615814 : name = TREE_OPERAND (name, 0);
17510 : : }
17511 : : else
17512 : : {
17513 : : is_template = false;
17514 : : template_args = NULL_TREE;
17515 : : }
17516 : :
17517 : : /* Substitute into the qualifying scope. When there are no ARGS, we
17518 : : are just trying to simplify a non-dependent expression. In that
17519 : : case the qualifying scope may be dependent, and, in any case,
17520 : : substituting will not help. */
17521 : 62048264 : scope = TREE_OPERAND (qualified_id, 0);
17522 : 62048264 : if (args)
17523 : : {
17524 : 60019517 : scope = tsubst_scope (scope, args, complain, in_decl);
17525 : 60019517 : expr = tsubst_name (name, args, complain, in_decl);
17526 : : }
17527 : : else
17528 : : expr = name;
17529 : :
17530 : 62048264 : if (dependent_scope_p (scope))
17531 : : {
17532 : 14899643 : if (TREE_CODE (expr) == SCOPE_REF)
17533 : : /* We built one in tsubst_baselink. */
17534 : 6 : gcc_checking_assert (same_type_p (scope, TREE_OPERAND (expr, 0)));
17535 : : else
17536 : : {
17537 : 14899637 : if (is_template)
17538 : 1860829 : expr = build_min_nt_loc (loc, TEMPLATE_ID_EXPR, expr,
17539 : : template_args);
17540 : 14899637 : expr = build_qualified_name (NULL_TREE, scope, expr,
17541 : 14899637 : QUALIFIED_NAME_IS_TEMPLATE
17542 : : (qualified_id));
17543 : : }
17544 : 14899643 : REF_PARENTHESIZED_P (expr) = REF_PARENTHESIZED_P (qualified_id);
17545 : 14899643 : return expr;
17546 : : }
17547 : :
17548 : 47148621 : if (!BASELINK_P (name) && !DECL_P (expr))
17549 : : {
17550 : 43092245 : if (TREE_CODE (expr) == BIT_NOT_EXPR)
17551 : : {
17552 : : /* A BIT_NOT_EXPR is used to represent a destructor. */
17553 : 3 : if (!check_dtor_name (scope, TREE_OPERAND (expr, 0)))
17554 : : {
17555 : 0 : error ("qualifying type %qT does not match destructor name ~%qT",
17556 : 0 : scope, TREE_OPERAND (expr, 0));
17557 : 0 : expr = error_mark_node;
17558 : : }
17559 : : else
17560 : 3 : expr = lookup_qualified_name (scope, complete_dtor_identifier,
17561 : : LOOK_want::NORMAL, false);
17562 : : }
17563 : : else
17564 : 43092242 : expr = lookup_qualified_name (scope, expr, LOOK_want::NORMAL, false);
17565 : 43092191 : if (TREE_CODE (TREE_CODE (expr) == TEMPLATE_DECL
17566 : : ? DECL_TEMPLATE_RESULT (expr) : expr) == TYPE_DECL)
17567 : : {
17568 : 30 : if (complain & tf_error)
17569 : : {
17570 : 24 : auto_diagnostic_group d;
17571 : 24 : error ("dependent-name %qE is parsed as a non-type, but "
17572 : : "instantiation yields a type", qualified_id);
17573 : 24 : inform (input_location, "say %<typename %E%> if a type is meant", qualified_id);
17574 : 24 : }
17575 : 30 : return error_mark_node;
17576 : : }
17577 : : }
17578 : :
17579 : 47148537 : if (DECL_P (expr))
17580 : : {
17581 : 40061196 : if (!check_accessibility_of_qualified_id (expr, /*object_type=*/NULL_TREE,
17582 : : scope, complain))
17583 : 5 : return error_mark_node;
17584 : : /* Remember that there was a reference to this entity. */
17585 : 40061191 : if (!mark_used (expr, complain) && !(complain & tf_error))
17586 : 0 : return error_mark_node;
17587 : : }
17588 : :
17589 : 47140441 : if (expr == error_mark_node || TREE_CODE (expr) == TREE_LIST)
17590 : : {
17591 : 21180 : if (complain & tf_error)
17592 : 130 : qualified_name_lookup_error (scope,
17593 : 130 : TREE_OPERAND (qualified_id, 1),
17594 : : expr, input_location);
17595 : 21180 : return error_mark_node;
17596 : : }
17597 : :
17598 : 47119261 : if (is_template)
17599 : : {
17600 : 2751035 : if (variable_template_p (expr))
17601 : 9924 : expr = lookup_and_finish_template_variable (expr, template_args,
17602 : : complain);
17603 : : else
17604 : 2741111 : expr = lookup_template_function (expr, template_args);
17605 : : }
17606 : :
17607 : 47119261 : if (expr == error_mark_node && complain & tf_error)
17608 : 3 : qualified_name_lookup_error (scope, TREE_OPERAND (qualified_id, 1),
17609 : : expr, input_location);
17610 : 47119258 : else if (TYPE_P (scope))
17611 : : {
17612 : 47119258 : expr = (adjust_result_of_qualified_name_lookup
17613 : 47119258 : (expr, scope, current_nonlambda_class_type ()));
17614 : 47119258 : expr = (finish_qualified_id_expr
17615 : 47119264 : (scope, expr, done, address_p && PTRMEM_OK_P (qualified_id),
17616 : 47119258 : QUALIFIED_NAME_IS_TEMPLATE (qualified_id),
17617 : : /*template_arg_p=*/false, complain));
17618 : : }
17619 : :
17620 : : /* Expressions do not generally have reference type. */
17621 : 47119261 : if (TREE_CODE (expr) != SCOPE_REF
17622 : : /* However, if we're about to form a pointer-to-member, we just
17623 : : want the referenced member referenced. */
17624 : 43852091 : && TREE_CODE (expr) != OFFSET_REF)
17625 : 43821500 : expr = convert_from_reference (expr);
17626 : :
17627 : 47119261 : if (REF_PARENTHESIZED_P (qualified_id))
17628 : 123 : expr = force_paren_expr (expr);
17629 : :
17630 : 47119261 : expr = maybe_wrap_with_location (expr, loc);
17631 : :
17632 : 47119261 : return expr;
17633 : : }
17634 : :
17635 : : /* tsubst the initializer for a VAR_DECL. INIT is the unsubstituted
17636 : : initializer, DECL is the substituted VAR_DECL. Other arguments are as
17637 : : for tsubst. */
17638 : :
17639 : : static tree
17640 : 25239466 : tsubst_init (tree init, tree decl, tree args,
17641 : : tsubst_flags_t complain, tree in_decl)
17642 : : {
17643 : 25239466 : if (!init)
17644 : : return NULL_TREE;
17645 : :
17646 : 20287697 : init = tsubst_expr (init, args, complain, in_decl);
17647 : :
17648 : 20287697 : tree type = TREE_TYPE (decl);
17649 : :
17650 : 20287697 : if (!init && type != error_mark_node)
17651 : : {
17652 : 51 : if (tree auto_node = type_uses_auto (type))
17653 : : {
17654 : 6 : if (!CLASS_PLACEHOLDER_TEMPLATE (auto_node))
17655 : : {
17656 : 6 : if (complain & tf_error)
17657 : 6 : error ("initializer for %q#D expands to an empty list "
17658 : : "of expressions", decl);
17659 : 6 : return error_mark_node;
17660 : : }
17661 : : }
17662 : 45 : else if (!dependent_type_p (type))
17663 : : {
17664 : : /* If we had an initializer but it
17665 : : instantiated to nothing,
17666 : : value-initialize the object. This will
17667 : : only occur when the initializer was a
17668 : : pack expansion where the parameter packs
17669 : : used in that expansion were of length
17670 : : zero. */
17671 : 45 : init = build_value_init (type, complain);
17672 : 45 : if (TREE_CODE (init) == AGGR_INIT_EXPR)
17673 : 21 : init = get_target_expr (init, complain);
17674 : 45 : if (TREE_CODE (init) == TARGET_EXPR)
17675 : 21 : TARGET_EXPR_DIRECT_INIT_P (init) = true;
17676 : : }
17677 : : }
17678 : :
17679 : : return init;
17680 : : }
17681 : :
17682 : : /* If T is a reference to a dependent member of the current instantiation C and
17683 : : we are trying to refer to that member in a partial instantiation of C,
17684 : : return a SCOPE_REF; otherwise, return NULL_TREE.
17685 : :
17686 : : This can happen when forming a C++17 deduction guide, as in PR96199. */
17687 : :
17688 : : static tree
17689 : 5714414222 : maybe_dependent_member_ref (tree t, tree args, tsubst_flags_t complain,
17690 : : tree in_decl)
17691 : : {
17692 : 5714414222 : if (!(complain & tf_dguide))
17693 : : return NULL_TREE;
17694 : :
17695 : 5716726057 : tree decl = (t && TYPE_P (t)) ? TYPE_NAME (t) : t;
17696 : 2324002 : if (!decl || !DECL_P (decl))
17697 : : return NULL_TREE;
17698 : :
17699 : 1200377 : tree ctx = context_for_name_lookup (decl);
17700 : 1200377 : if (!CLASS_TYPE_P (ctx))
17701 : : return NULL_TREE;
17702 : :
17703 : 50205 : ctx = tsubst (ctx, args, complain, in_decl);
17704 : 50205 : if (!dependent_scope_p (ctx))
17705 : : return NULL_TREE;
17706 : :
17707 : 50019 : if (TYPE_P (t))
17708 : : {
17709 : 31692 : if (typedef_variant_p (t))
17710 : 19556 : t = strip_typedefs (t);
17711 : 31692 : tree decl = TYPE_NAME (t);
17712 : 31692 : if (decl)
17713 : 31132 : decl = maybe_dependent_member_ref (decl, args, complain, in_decl);
17714 : 31132 : if (!decl)
17715 : 25847 : return NULL_TREE;
17716 : 5845 : return cp_build_qualified_type (TREE_TYPE (decl), cp_type_quals (t),
17717 : 5845 : complain);
17718 : : }
17719 : :
17720 : 18327 : tree name = DECL_NAME (t);
17721 : 18327 : tree fullname = name;
17722 : 18327 : if (instantiates_primary_template_p (t))
17723 : : {
17724 : 5118 : tree tinfo = get_template_info (t);
17725 : 5118 : name = DECL_NAME (TI_TEMPLATE (tinfo));
17726 : 5118 : tree targs = INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo));
17727 : 5118 : targs = tsubst_template_args (targs, args, complain, in_decl);
17728 : 5118 : fullname = build_nt (TEMPLATE_ID_EXPR, name, targs);
17729 : : }
17730 : :
17731 : 18327 : if (TREE_CODE (t) == TYPE_DECL)
17732 : : {
17733 : 17850 : if (TREE_CODE (TREE_TYPE (t)) == TYPENAME_TYPE
17734 : 17850 : && TYPE_NAME (TREE_TYPE (t)) == t)
17735 : : /* The TYPE_DECL for a typename has DECL_CONTEXT of the typename
17736 : : scope, but it doesn't need to be rewritten again. */
17737 : : return NULL_TREE;
17738 : 5845 : tree type = build_typename_type (ctx, name, fullname, typename_type);
17739 : 5845 : return TYPE_NAME (type);
17740 : : }
17741 : 477 : else if (DECL_TYPE_TEMPLATE_P (t))
17742 : 12 : return make_unbound_class_template (ctx, name,
17743 : 12 : NULL_TREE, complain);
17744 : : else
17745 : 465 : return build_qualified_name (NULL_TREE, ctx, fullname,
17746 : 465 : TREE_CODE (t) == TEMPLATE_DECL);
17747 : : }
17748 : :
17749 : : /* Helper function for tsubst_omp_clauses, used for instantiation of
17750 : : OMP_CLAUSE_DECL of clauses. */
17751 : :
17752 : : static tree
17753 : 6212 : tsubst_omp_clause_decl (tree decl, tree args, tsubst_flags_t complain,
17754 : : tree in_decl, tree *iterator_cache)
17755 : : {
17756 : 6212 : if (decl == NULL_TREE || decl == ridpointers[RID_OMP_ALL_MEMORY])
17757 : : return decl;
17758 : :
17759 : : /* Handle OpenMP iterators. */
17760 : 6167 : if (TREE_CODE (decl) == TREE_LIST
17761 : 162 : && TREE_PURPOSE (decl)
17762 : 6329 : && TREE_CODE (TREE_PURPOSE (decl)) == TREE_VEC)
17763 : : {
17764 : 135 : tree ret;
17765 : 135 : if (iterator_cache[0] == TREE_PURPOSE (decl))
17766 : 20 : ret = iterator_cache[1];
17767 : : else
17768 : : {
17769 : 115 : tree *tp = &ret;
17770 : 115 : begin_scope (sk_omp, NULL);
17771 : 254 : for (tree it = TREE_PURPOSE (decl); it; it = TREE_CHAIN (it))
17772 : : {
17773 : 139 : *tp = copy_node (it);
17774 : 139 : TREE_VEC_ELT (*tp, 0)
17775 : 139 : = tsubst_decl (TREE_VEC_ELT (it, 0), args, complain);
17776 : 139 : DECL_CONTEXT (TREE_VEC_ELT (*tp, 0)) = current_function_decl;
17777 : 139 : pushdecl (TREE_VEC_ELT (*tp, 0));
17778 : 139 : TREE_VEC_ELT (*tp, 1)
17779 : 139 : = tsubst_stmt (TREE_VEC_ELT (it, 1), args, complain, in_decl);
17780 : 139 : TREE_VEC_ELT (*tp, 2)
17781 : 139 : = tsubst_stmt (TREE_VEC_ELT (it, 2), args, complain, in_decl);
17782 : 139 : TREE_VEC_ELT (*tp, 3)
17783 : 139 : = tsubst_stmt (TREE_VEC_ELT (it, 3), args, complain, in_decl);
17784 : 139 : TREE_CHAIN (*tp) = NULL_TREE;
17785 : 139 : tp = &TREE_CHAIN (*tp);
17786 : : }
17787 : 115 : TREE_VEC_ELT (ret, 5) = poplevel (1, 1, 0);
17788 : 115 : iterator_cache[0] = TREE_PURPOSE (decl);
17789 : 115 : iterator_cache[1] = ret;
17790 : : }
17791 : 135 : return build_tree_list (ret, tsubst_omp_clause_decl (TREE_VALUE (decl),
17792 : : args, complain,
17793 : : in_decl, NULL));
17794 : : }
17795 : :
17796 : : /* Handle an OpenMP array section represented as a TREE_LIST (or
17797 : : OMP_CLAUSE_DOACROSS_KIND). An OMP_CLAUSE_DOACROSS (with a depend
17798 : : kind of OMP_CLAUSE_DOACROSS_SINK) can also be represented as a
17799 : : TREE_LIST. We can handle it exactly the same as an array section
17800 : : (purpose, value, and a chain), even though the nomenclature
17801 : : (low_bound, length, etc) is different. */
17802 : 6032 : if (TREE_CODE (decl) == TREE_LIST)
17803 : : {
17804 : 27 : tree low_bound
17805 : 27 : = tsubst_stmt (TREE_PURPOSE (decl), args, complain, in_decl);
17806 : 27 : tree length = tsubst_stmt (TREE_VALUE (decl), args, complain, in_decl);
17807 : 27 : tree chain = tsubst_omp_clause_decl (TREE_CHAIN (decl), args, complain,
17808 : : in_decl, NULL);
17809 : 27 : if (TREE_PURPOSE (decl) == low_bound
17810 : 27 : && TREE_VALUE (decl) == length
17811 : 36 : && TREE_CHAIN (decl) == chain)
17812 : : return decl;
17813 : 18 : tree ret = tree_cons (low_bound, length, chain);
17814 : 18 : OMP_CLAUSE_DOACROSS_SINK_NEGATIVE (ret)
17815 : 18 : = OMP_CLAUSE_DOACROSS_SINK_NEGATIVE (decl);
17816 : 18 : return ret;
17817 : : }
17818 : 6005 : else if (TREE_CODE (decl) == OMP_ARRAY_SECTION)
17819 : : {
17820 : 1849 : tree low_bound
17821 : 1849 : = tsubst_stmt (TREE_OPERAND (decl, 1), args, complain, in_decl);
17822 : 1849 : tree length = tsubst_stmt (TREE_OPERAND (decl, 2), args, complain,
17823 : : in_decl);
17824 : 1849 : tree base = tsubst_omp_clause_decl (TREE_OPERAND (decl, 0), args,
17825 : : complain, in_decl, NULL);
17826 : 1849 : if (TREE_OPERAND (decl, 0) == base
17827 : 594 : && TREE_OPERAND (decl, 1) == low_bound
17828 : 2331 : && TREE_OPERAND (decl, 2) == length)
17829 : : return decl;
17830 : 1376 : return build3 (OMP_ARRAY_SECTION, TREE_TYPE (base), base, low_bound,
17831 : 1376 : length);
17832 : : }
17833 : 4156 : tree ret = tsubst_stmt (decl, args, complain, in_decl);
17834 : : /* Undo convert_from_reference tsubst_expr could have called. */
17835 : 4156 : if (decl
17836 : 4156 : && REFERENCE_REF_P (ret)
17837 : 561 : && !REFERENCE_REF_P (decl))
17838 : 551 : ret = TREE_OPERAND (ret, 0);
17839 : : return ret;
17840 : : }
17841 : :
17842 : : /* Like tsubst_copy, but specifically for OpenMP clauses. */
17843 : :
17844 : : static tree
17845 : 4808 : tsubst_omp_clauses (tree clauses, enum c_omp_region_type ort,
17846 : : tree args, tsubst_flags_t complain, tree in_decl)
17847 : : {
17848 : 4808 : tree new_clauses = NULL_TREE, nc, oc;
17849 : 4808 : tree linear_no_step = NULL_TREE;
17850 : 4808 : tree iterator_cache[2] = { NULL_TREE, NULL_TREE };
17851 : :
17852 : 10763 : for (oc = clauses; oc ; oc = OMP_CLAUSE_CHAIN (oc))
17853 : : {
17854 : 5955 : nc = copy_node (oc);
17855 : 5955 : OMP_CLAUSE_CHAIN (nc) = new_clauses;
17856 : 5955 : new_clauses = nc;
17857 : :
17858 : 5955 : switch (OMP_CLAUSE_CODE (nc))
17859 : : {
17860 : 190 : case OMP_CLAUSE_LASTPRIVATE:
17861 : 190 : if (OMP_CLAUSE_LASTPRIVATE_STMT (oc))
17862 : : {
17863 : 38 : OMP_CLAUSE_LASTPRIVATE_STMT (nc) = push_stmt_list ();
17864 : 38 : tsubst_stmt (OMP_CLAUSE_LASTPRIVATE_STMT (oc), args,
17865 : : complain, in_decl);
17866 : 38 : OMP_CLAUSE_LASTPRIVATE_STMT (nc)
17867 : 76 : = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (nc));
17868 : : }
17869 : : /* FALLTHRU */
17870 : 2770 : case OMP_CLAUSE_PRIVATE:
17871 : 2770 : case OMP_CLAUSE_SHARED:
17872 : 2770 : case OMP_CLAUSE_FIRSTPRIVATE:
17873 : 2770 : case OMP_CLAUSE_COPYIN:
17874 : 2770 : case OMP_CLAUSE_COPYPRIVATE:
17875 : 2770 : case OMP_CLAUSE_UNIFORM:
17876 : 2770 : case OMP_CLAUSE_DEPEND:
17877 : 2770 : case OMP_CLAUSE_DOACROSS:
17878 : 2770 : case OMP_CLAUSE_AFFINITY:
17879 : 2770 : case OMP_CLAUSE_FROM:
17880 : 2770 : case OMP_CLAUSE_TO:
17881 : 2770 : case OMP_CLAUSE_MAP:
17882 : 2770 : case OMP_CLAUSE__CACHE_:
17883 : 2770 : case OMP_CLAUSE_NONTEMPORAL:
17884 : 2770 : case OMP_CLAUSE_USE_DEVICE_PTR:
17885 : 2770 : case OMP_CLAUSE_USE_DEVICE_ADDR:
17886 : 2770 : case OMP_CLAUSE_IS_DEVICE_PTR:
17887 : 2770 : case OMP_CLAUSE_HAS_DEVICE_ADDR:
17888 : 2770 : case OMP_CLAUSE_INCLUSIVE:
17889 : 2770 : case OMP_CLAUSE_EXCLUSIVE:
17890 : 5540 : OMP_CLAUSE_DECL (nc)
17891 : 2770 : = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc), args, complain,
17892 : : in_decl, iterator_cache);
17893 : 2770 : break;
17894 : 150 : case OMP_CLAUSE_NUM_TEAMS:
17895 : 150 : if (OMP_CLAUSE_NUM_TEAMS_LOWER_EXPR (oc))
17896 : 66 : OMP_CLAUSE_NUM_TEAMS_LOWER_EXPR (nc)
17897 : 132 : = tsubst_stmt (OMP_CLAUSE_NUM_TEAMS_LOWER_EXPR (oc), args,
17898 : : complain, in_decl);
17899 : : /* FALLTHRU */
17900 : 735 : case OMP_CLAUSE_TILE:
17901 : 735 : case OMP_CLAUSE_IF:
17902 : 735 : case OMP_CLAUSE_SELF:
17903 : 735 : case OMP_CLAUSE_NUM_THREADS:
17904 : 735 : case OMP_CLAUSE_SCHEDULE:
17905 : 735 : case OMP_CLAUSE_COLLAPSE:
17906 : 735 : case OMP_CLAUSE_FINAL:
17907 : 735 : case OMP_CLAUSE_DEVICE:
17908 : 735 : case OMP_CLAUSE_DIST_SCHEDULE:
17909 : 735 : case OMP_CLAUSE_THREAD_LIMIT:
17910 : 735 : case OMP_CLAUSE_SAFELEN:
17911 : 735 : case OMP_CLAUSE_SIMDLEN:
17912 : 735 : case OMP_CLAUSE_NUM_TASKS:
17913 : 735 : case OMP_CLAUSE_GRAINSIZE:
17914 : 735 : case OMP_CLAUSE_PRIORITY:
17915 : 735 : case OMP_CLAUSE_ORDERED:
17916 : 735 : case OMP_CLAUSE_HINT:
17917 : 735 : case OMP_CLAUSE_FILTER:
17918 : 735 : case OMP_CLAUSE_NUM_GANGS:
17919 : 735 : case OMP_CLAUSE_NUM_WORKERS:
17920 : 735 : case OMP_CLAUSE_VECTOR_LENGTH:
17921 : 735 : case OMP_CLAUSE_WORKER:
17922 : 735 : case OMP_CLAUSE_VECTOR:
17923 : 735 : case OMP_CLAUSE_ASYNC:
17924 : 735 : case OMP_CLAUSE_WAIT:
17925 : 735 : case OMP_CLAUSE_DETACH:
17926 : 735 : OMP_CLAUSE_OPERAND (nc, 0)
17927 : 735 : = tsubst_stmt (OMP_CLAUSE_OPERAND (oc, 0), args, complain, in_decl);
17928 : 735 : break;
17929 : 18 : case OMP_CLAUSE_PARTIAL:
17930 : 18 : OMP_CLAUSE_PARTIAL_EXPR (nc)
17931 : 18 : = tsubst_expr (OMP_CLAUSE_PARTIAL_EXPR (oc), args, complain,
17932 : : in_decl);
17933 : 18 : break;
17934 : 36 : case OMP_CLAUSE_SIZES:
17935 : 36 : OMP_CLAUSE_SIZES_LIST (nc)
17936 : 36 : = tsubst_expr (OMP_CLAUSE_SIZES_LIST (oc), args, complain,
17937 : : in_decl);
17938 : 36 : break;
17939 : 6 : case OMP_CLAUSE_NOCONTEXT:
17940 : 6 : OMP_CLAUSE_NOCONTEXT_EXPR (nc)
17941 : 6 : = tsubst_expr (OMP_CLAUSE_NOCONTEXT_EXPR (oc), args, complain,
17942 : : in_decl);
17943 : 6 : break;
17944 : 6 : case OMP_CLAUSE_NOVARIANTS:
17945 : 6 : OMP_CLAUSE_NOVARIANTS_EXPR (nc)
17946 : 6 : = tsubst_expr (OMP_CLAUSE_NOVARIANTS_EXPR (oc), args, complain,
17947 : : in_decl);
17948 : 6 : break;
17949 : 948 : case OMP_CLAUSE_REDUCTION:
17950 : 948 : case OMP_CLAUSE_IN_REDUCTION:
17951 : 948 : case OMP_CLAUSE_TASK_REDUCTION:
17952 : 948 : if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc))
17953 : : {
17954 : 42 : tree placeholder = OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc);
17955 : 42 : if (TREE_CODE (placeholder) == SCOPE_REF)
17956 : : {
17957 : 5 : tree scope = tsubst (TREE_OPERAND (placeholder, 0), args,
17958 : : complain, in_decl);
17959 : 5 : OMP_CLAUSE_REDUCTION_PLACEHOLDER (nc)
17960 : 10 : = build_qualified_name (NULL_TREE, scope,
17961 : 5 : TREE_OPERAND (placeholder, 1),
17962 : : false);
17963 : : }
17964 : : else
17965 : 37 : gcc_assert (identifier_p (placeholder));
17966 : : }
17967 : 1896 : OMP_CLAUSE_DECL (nc)
17968 : 948 : = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc), args, complain,
17969 : : in_decl, NULL);
17970 : 948 : break;
17971 : 63 : case OMP_CLAUSE_GANG:
17972 : 63 : case OMP_CLAUSE_ALIGNED:
17973 : 126 : OMP_CLAUSE_DECL (nc)
17974 : 63 : = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc), args, complain,
17975 : : in_decl, NULL);
17976 : 63 : OMP_CLAUSE_OPERAND (nc, 1)
17977 : 63 : = tsubst_stmt (OMP_CLAUSE_OPERAND (oc, 1), args, complain, in_decl);
17978 : 63 : break;
17979 : 293 : case OMP_CLAUSE_ALLOCATE:
17980 : 586 : OMP_CLAUSE_DECL (nc)
17981 : 293 : = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc), args, complain,
17982 : : in_decl, NULL);
17983 : 293 : OMP_CLAUSE_OPERAND (nc, 1)
17984 : 293 : = tsubst_stmt (OMP_CLAUSE_OPERAND (oc, 1), args, complain, in_decl);
17985 : 293 : OMP_CLAUSE_OPERAND (nc, 2)
17986 : 293 : = tsubst_stmt (OMP_CLAUSE_OPERAND (oc, 2), args, complain, in_decl);
17987 : 293 : break;
17988 : 127 : case OMP_CLAUSE_LINEAR:
17989 : 254 : OMP_CLAUSE_DECL (nc)
17990 : 127 : = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc), args, complain,
17991 : : in_decl, NULL);
17992 : 127 : if (OMP_CLAUSE_LINEAR_STEP (oc) == NULL_TREE)
17993 : : {
17994 : 2 : gcc_assert (!linear_no_step);
17995 : : linear_no_step = nc;
17996 : : }
17997 : 125 : else if (OMP_CLAUSE_LINEAR_VARIABLE_STRIDE (oc))
17998 : 0 : OMP_CLAUSE_LINEAR_STEP (nc)
17999 : 0 : = tsubst_omp_clause_decl (OMP_CLAUSE_LINEAR_STEP (oc), args,
18000 : : complain, in_decl, NULL);
18001 : : else
18002 : 125 : OMP_CLAUSE_LINEAR_STEP (nc)
18003 : 250 : = tsubst_stmt (OMP_CLAUSE_LINEAR_STEP (oc), args,
18004 : : complain, in_decl);
18005 : : break;
18006 : 204 : case OMP_CLAUSE_INIT:
18007 : 204 : if ((ort == C_ORT_OMP_INTEROP || ort == C_ORT_OMP_DECLARE_SIMD)
18008 : 204 : && OMP_CLAUSE_INIT_PREFER_TYPE (nc)
18009 : 99 : && TREE_CODE (OMP_CLAUSE_INIT_PREFER_TYPE (nc)) == TREE_LIST
18010 : 288 : && (OMP_CLAUSE_CHAIN (nc) == NULL_TREE
18011 : 51 : || OMP_CLAUSE_CODE (OMP_CLAUSE_CHAIN (nc) ) != OMP_CLAUSE_INIT
18012 : 45 : || (OMP_CLAUSE_INIT_PREFER_TYPE (nc)
18013 : 45 : != OMP_CLAUSE_INIT_PREFER_TYPE (OMP_CLAUSE_CHAIN (nc) ))))
18014 : : {
18015 : 60 : tree pref_list = OMP_CLAUSE_INIT_PREFER_TYPE (nc);
18016 : 60 : tree fr_list = TREE_VALUE (pref_list);
18017 : 60 : int len = TREE_VEC_LENGTH (fr_list);
18018 : 234 : for (int i = 0; i < len; i++)
18019 : : {
18020 : 174 : tree *fr_expr = &TREE_VEC_ELT (fr_list, i);
18021 : : /* Preserve NOP_EXPR to have a location. */
18022 : 174 : if (*fr_expr && TREE_CODE (*fr_expr) == NOP_EXPR)
18023 : 42 : TREE_OPERAND (*fr_expr, 0)
18024 : 84 : = tsubst_expr (TREE_OPERAND (*fr_expr, 0), args, complain,
18025 : : in_decl);
18026 : : else
18027 : 132 : *fr_expr = tsubst_expr (*fr_expr, args, complain, in_decl);
18028 : : }
18029 : : }
18030 : : /* FALLTHRU */
18031 : 258 : case OMP_CLAUSE_DESTROY:
18032 : 258 : case OMP_CLAUSE_USE:
18033 : 258 : case OMP_CLAUSE_INTEROP:
18034 : 258 : OMP_CLAUSE_OPERAND (nc, 0)
18035 : 258 : = tsubst_stmt (OMP_CLAUSE_OPERAND (oc, 0), args, complain, in_decl);
18036 : 258 : break;
18037 : : case OMP_CLAUSE_NOWAIT:
18038 : : case OMP_CLAUSE_DEFAULT:
18039 : : case OMP_CLAUSE_UNTIED:
18040 : : case OMP_CLAUSE_MERGEABLE:
18041 : : case OMP_CLAUSE_INBRANCH:
18042 : : case OMP_CLAUSE_NOTINBRANCH:
18043 : : case OMP_CLAUSE_PROC_BIND:
18044 : : case OMP_CLAUSE_FOR:
18045 : : case OMP_CLAUSE_PARALLEL:
18046 : : case OMP_CLAUSE_SECTIONS:
18047 : : case OMP_CLAUSE_TASKGROUP:
18048 : : case OMP_CLAUSE_NOGROUP:
18049 : : case OMP_CLAUSE_THREADS:
18050 : : case OMP_CLAUSE_SIMD:
18051 : : case OMP_CLAUSE_DEFAULTMAP:
18052 : : case OMP_CLAUSE_ORDER:
18053 : : case OMP_CLAUSE_BIND:
18054 : : case OMP_CLAUSE_INDEPENDENT:
18055 : : case OMP_CLAUSE_AUTO:
18056 : : case OMP_CLAUSE_SEQ:
18057 : : case OMP_CLAUSE_IF_PRESENT:
18058 : : case OMP_CLAUSE_FINALIZE:
18059 : : case OMP_CLAUSE_NOHOST:
18060 : : case OMP_CLAUSE_FULL:
18061 : : break;
18062 : 0 : default:
18063 : 0 : gcc_unreachable ();
18064 : : }
18065 : 5955 : if ((ort & C_ORT_OMP_DECLARE_SIMD) == C_ORT_OMP)
18066 : 5085 : switch (OMP_CLAUSE_CODE (nc))
18067 : : {
18068 : 1993 : case OMP_CLAUSE_SHARED:
18069 : 1993 : case OMP_CLAUSE_PRIVATE:
18070 : 1993 : case OMP_CLAUSE_FIRSTPRIVATE:
18071 : 1993 : case OMP_CLAUSE_LASTPRIVATE:
18072 : 1993 : case OMP_CLAUSE_COPYPRIVATE:
18073 : 1993 : case OMP_CLAUSE_LINEAR:
18074 : 1993 : case OMP_CLAUSE_REDUCTION:
18075 : 1993 : case OMP_CLAUSE_IN_REDUCTION:
18076 : 1993 : case OMP_CLAUSE_TASK_REDUCTION:
18077 : 1993 : case OMP_CLAUSE_USE_DEVICE_PTR:
18078 : 1993 : case OMP_CLAUSE_USE_DEVICE_ADDR:
18079 : 1993 : case OMP_CLAUSE_IS_DEVICE_PTR:
18080 : 1993 : case OMP_CLAUSE_HAS_DEVICE_ADDR:
18081 : 1993 : case OMP_CLAUSE_INCLUSIVE:
18082 : 1993 : case OMP_CLAUSE_EXCLUSIVE:
18083 : 1993 : case OMP_CLAUSE_ALLOCATE:
18084 : : /* tsubst_expr on SCOPE_REF results in returning
18085 : : finish_non_static_data_member result. Undo that here. */
18086 : 1993 : if (TREE_CODE (OMP_CLAUSE_DECL (oc)) == SCOPE_REF
18087 : 1993 : && (TREE_CODE (TREE_OPERAND (OMP_CLAUSE_DECL (oc), 1))
18088 : : == IDENTIFIER_NODE))
18089 : : {
18090 : 79 : tree t = OMP_CLAUSE_DECL (nc);
18091 : 79 : tree v = t;
18092 : 464 : while (v)
18093 : 464 : switch (TREE_CODE (v))
18094 : : {
18095 : 385 : case COMPONENT_REF:
18096 : 385 : case MEM_REF:
18097 : 385 : case INDIRECT_REF:
18098 : 385 : CASE_CONVERT:
18099 : 385 : case POINTER_PLUS_EXPR:
18100 : 385 : v = TREE_OPERAND (v, 0);
18101 : 385 : continue;
18102 : 77 : case PARM_DECL:
18103 : 77 : if (DECL_CONTEXT (v) == current_function_decl
18104 : 77 : && DECL_ARTIFICIAL (v)
18105 : 154 : && DECL_NAME (v) == this_identifier)
18106 : 77 : OMP_CLAUSE_DECL (nc) = TREE_OPERAND (t, 1);
18107 : : /* FALLTHRU */
18108 : : default:
18109 : : v = NULL_TREE;
18110 : : break;
18111 : : }
18112 : : }
18113 : 1914 : else if (VAR_P (OMP_CLAUSE_DECL (oc))
18114 : 948 : && DECL_HAS_VALUE_EXPR_P (OMP_CLAUSE_DECL (oc))
18115 : 197 : && DECL_ARTIFICIAL (OMP_CLAUSE_DECL (oc))
18116 : 197 : && DECL_LANG_SPECIFIC (OMP_CLAUSE_DECL (oc))
18117 : 2111 : && DECL_OMP_PRIVATIZED_MEMBER (OMP_CLAUSE_DECL (oc)))
18118 : : {
18119 : 197 : tree decl = OMP_CLAUSE_DECL (nc);
18120 : 197 : if (VAR_P (decl))
18121 : : {
18122 : 197 : retrofit_lang_decl (decl);
18123 : 197 : DECL_OMP_PRIVATIZED_MEMBER (decl) = 1;
18124 : : }
18125 : : }
18126 : : break;
18127 : : default:
18128 : : break;
18129 : : }
18130 : : }
18131 : :
18132 : 4808 : new_clauses = nreverse (new_clauses);
18133 : 4808 : if (ort != C_ORT_OMP_DECLARE_SIMD)
18134 : : {
18135 : 4658 : new_clauses = finish_omp_clauses (new_clauses, ort);
18136 : 4658 : if (linear_no_step)
18137 : 2 : for (nc = new_clauses; nc; nc = OMP_CLAUSE_CHAIN (nc))
18138 : 2 : if (nc == linear_no_step)
18139 : : {
18140 : 2 : OMP_CLAUSE_LINEAR_STEP (nc) = NULL_TREE;
18141 : 2 : break;
18142 : : }
18143 : : }
18144 : 4808 : return new_clauses;
18145 : : }
18146 : :
18147 : : /* Like tsubst_expr, but unshare TREE_LIST nodes. */
18148 : :
18149 : : static tree
18150 : 3216 : tsubst_copy_asm_operands (tree t, tree args, tsubst_flags_t complain,
18151 : : tree in_decl)
18152 : : {
18153 : : #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
18154 : :
18155 : 3216 : tree purpose, value, chain;
18156 : :
18157 : 3216 : if (t == NULL)
18158 : : return t;
18159 : :
18160 : 2707 : if (TREE_CODE (t) != TREE_LIST)
18161 : 1370 : return tsubst_expr (t, args, complain, in_decl);
18162 : :
18163 : 1337 : if (t == void_list_node)
18164 : : return t;
18165 : :
18166 : 1337 : purpose = TREE_PURPOSE (t);
18167 : 1337 : if (purpose)
18168 : 565 : purpose = RECUR (purpose);
18169 : 1337 : value = TREE_VALUE (t);
18170 : 1337 : if (value)
18171 : : {
18172 : 1337 : if (TREE_CODE (value) != LABEL_DECL)
18173 : 1334 : value = RECUR (value);
18174 : : else
18175 : : {
18176 : 3 : value = lookup_label (DECL_NAME (value));
18177 : 3 : gcc_assert (TREE_CODE (value) == LABEL_DECL);
18178 : 3 : TREE_USED (value) = 1;
18179 : : }
18180 : : }
18181 : 1337 : chain = TREE_CHAIN (t);
18182 : 1337 : if (chain && chain != void_type_node)
18183 : 485 : chain = RECUR (chain);
18184 : 1337 : return tree_cons (purpose, value, chain);
18185 : : #undef RECUR
18186 : : }
18187 : :
18188 : : /* Used to temporarily communicate the list of #pragma omp parallel
18189 : : clauses to #pragma omp for instantiation if they are combined
18190 : : together. */
18191 : :
18192 : : static tree *omp_parallel_combined_clauses;
18193 : :
18194 : : static tree tsubst_decomp_names (tree, tree, tree, tsubst_flags_t, tree,
18195 : : cp_decomp *);
18196 : :
18197 : : /* Substitute one OMP_FOR iterator. */
18198 : :
18199 : : static bool
18200 : 1240 : tsubst_omp_for_iterator (tree t, int i, tree declv, tree &orig_declv,
18201 : : tree initv, tree condv, tree incrv, tree *clauses,
18202 : : tree args, tsubst_flags_t complain, tree in_decl)
18203 : : {
18204 : : #define RECUR(NODE) \
18205 : : tsubst_stmt ((NODE), args, complain, in_decl)
18206 : 1240 : tree decl, init, cond = NULL_TREE, incr = NULL_TREE;
18207 : 1240 : bool ret = false;
18208 : :
18209 : 1240 : init = TREE_VEC_ELT (OMP_FOR_INIT (t), i);
18210 : 1240 : gcc_assert (TREE_CODE (init) == MODIFY_EXPR);
18211 : :
18212 : 1240 : decl = TREE_OPERAND (init, 0);
18213 : 1240 : init = TREE_OPERAND (init, 1);
18214 : 1240 : tree decl_expr = NULL_TREE;
18215 : 1240 : bool range_for = TREE_VEC_ELT (OMP_FOR_COND (t), i) == global_namespace;
18216 : 1240 : if (range_for)
18217 : : {
18218 : 164 : bool decomp = false;
18219 : 164 : if (decl != error_mark_node && DECL_HAS_VALUE_EXPR_P (decl))
18220 : : {
18221 : 41 : tree v = DECL_VALUE_EXPR (decl);
18222 : 41 : if (TREE_CODE (v) == ARRAY_REF
18223 : 41 : && DECL_DECOMPOSITION_P (TREE_OPERAND (v, 0)))
18224 : : {
18225 : 41 : cp_decomp decomp_d = { NULL_TREE, 0 };
18226 : 41 : tree d = tsubst_decl (TREE_OPERAND (v, 0), args, complain);
18227 : 41 : maybe_push_decl (d);
18228 : 41 : d = tsubst_decomp_names (d, TREE_OPERAND (v, 0), args, complain,
18229 : : in_decl, &decomp_d);
18230 : 41 : decomp = true;
18231 : 41 : if (d == error_mark_node)
18232 : 0 : decl = error_mark_node;
18233 : : else
18234 : 155 : for (unsigned int i = 0; i < decomp_d.count; i++)
18235 : : {
18236 : 114 : if (!DECL_HAS_VALUE_EXPR_P (decomp_d.decl))
18237 : : {
18238 : 114 : tree v = build_nt (ARRAY_REF, d,
18239 : 114 : size_int (decomp_d.count - i - 1),
18240 : : NULL_TREE, NULL_TREE);
18241 : 114 : SET_DECL_VALUE_EXPR (decomp_d.decl, v);
18242 : 114 : DECL_HAS_VALUE_EXPR_P (decomp_d.decl) = 1;
18243 : : }
18244 : 114 : fit_decomposition_lang_decl (decomp_d.decl, d);
18245 : 114 : decomp_d.decl = DECL_CHAIN (decomp_d.decl);
18246 : : }
18247 : : }
18248 : : }
18249 : 164 : decl = tsubst_decl (decl, args, complain);
18250 : 164 : if (!decomp)
18251 : 123 : maybe_push_decl (decl);
18252 : : }
18253 : 1076 : else if (init && TREE_CODE (init) == DECL_EXPR)
18254 : : {
18255 : : /* We need to jump through some hoops to handle declarations in the
18256 : : init-statement, since we might need to handle auto deduction,
18257 : : but we need to keep control of initialization. */
18258 : 223 : decl_expr = init;
18259 : 223 : init = DECL_INITIAL (DECL_EXPR_DECL (init));
18260 : 223 : decl = tsubst_decl (decl, args, complain);
18261 : : }
18262 : : else
18263 : : {
18264 : 853 : if (TREE_CODE (decl) == SCOPE_REF)
18265 : : {
18266 : 8 : decl = RECUR (decl);
18267 : 8 : if (TREE_CODE (decl) == COMPONENT_REF)
18268 : : {
18269 : : tree v = decl;
18270 : 24 : while (v)
18271 : 24 : switch (TREE_CODE (v))
18272 : : {
18273 : 20 : case COMPONENT_REF:
18274 : 20 : case MEM_REF:
18275 : 20 : case INDIRECT_REF:
18276 : 20 : CASE_CONVERT:
18277 : 20 : case POINTER_PLUS_EXPR:
18278 : 20 : v = TREE_OPERAND (v, 0);
18279 : 20 : continue;
18280 : 4 : case PARM_DECL:
18281 : 4 : if (DECL_CONTEXT (v) == current_function_decl
18282 : 4 : && DECL_ARTIFICIAL (v)
18283 : 8 : && DECL_NAME (v) == this_identifier)
18284 : : {
18285 : 4 : decl = TREE_OPERAND (decl, 1);
18286 : 4 : decl = omp_privatize_field (decl, false);
18287 : : }
18288 : : /* FALLTHRU */
18289 : : default:
18290 : : v = NULL_TREE;
18291 : : break;
18292 : : }
18293 : : }
18294 : : }
18295 : : else
18296 : 845 : decl = RECUR (decl);
18297 : : }
18298 : 1240 : if (init && TREE_CODE (init) == TREE_VEC)
18299 : : {
18300 : 12 : init = copy_node (init);
18301 : 12 : TREE_VEC_ELT (init, 0)
18302 : 12 : = tsubst_decl (TREE_VEC_ELT (init, 0), args, complain);
18303 : 12 : TREE_VEC_ELT (init, 1) = RECUR (TREE_VEC_ELT (init, 1));
18304 : 12 : TREE_VEC_ELT (init, 2) = RECUR (TREE_VEC_ELT (init, 2));
18305 : : }
18306 : : else
18307 : 1228 : init = RECUR (init);
18308 : :
18309 : 1240 : if (orig_declv && OMP_FOR_ORIG_DECLS (t))
18310 : : {
18311 : 620 : tree o = TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (t), i);
18312 : 620 : if (TREE_CODE (o) == TREE_LIST)
18313 : 92 : TREE_VEC_ELT (orig_declv, i)
18314 : 184 : = tree_cons (RECUR (TREE_PURPOSE (o)),
18315 : 92 : RECUR (TREE_VALUE (o)),
18316 : : NULL_TREE);
18317 : : else
18318 : 528 : TREE_VEC_ELT (orig_declv, i) = RECUR (o);
18319 : : }
18320 : :
18321 : 1240 : if (range_for)
18322 : : {
18323 : 164 : tree this_pre_body = NULL_TREE;
18324 : 164 : tree orig_init = NULL_TREE;
18325 : 164 : tree orig_decl = NULL_TREE;
18326 : 164 : tree init_sl = NULL_TREE;
18327 : 164 : cp_convert_omp_range_for (this_pre_body, init_sl, decl, orig_decl, init,
18328 : : orig_init, cond, incr, true);
18329 : 164 : if (orig_decl)
18330 : : {
18331 : 159 : if (orig_declv == NULL_TREE)
18332 : 143 : orig_declv = copy_node (declv);
18333 : 159 : TREE_VEC_ELT (orig_declv, i) = orig_decl;
18334 : 159 : ret = true;
18335 : : }
18336 : 5 : else if (orig_declv)
18337 : 0 : TREE_VEC_ELT (orig_declv, i) = decl;
18338 : : }
18339 : :
18340 : 1240 : tree auto_node = type_uses_auto (TREE_TYPE (decl));
18341 : 1240 : if (!range_for && auto_node && init)
18342 : 2 : TREE_TYPE (decl)
18343 : 4 : = do_auto_deduction (TREE_TYPE (decl), init, auto_node, complain);
18344 : :
18345 : 1240 : gcc_assert (!type_dependent_expression_p (decl));
18346 : :
18347 : 1240 : if (!CLASS_TYPE_P (TREE_TYPE (decl)) || range_for)
18348 : : {
18349 : 1045 : if (decl_expr)
18350 : : {
18351 : : /* Declare the variable, but don't let that initialize it. */
18352 : 172 : tree init_sav = DECL_INITIAL (DECL_EXPR_DECL (decl_expr));
18353 : 172 : DECL_INITIAL (DECL_EXPR_DECL (decl_expr)) = NULL_TREE;
18354 : 172 : RECUR (decl_expr);
18355 : 172 : DECL_INITIAL (DECL_EXPR_DECL (decl_expr)) = init_sav;
18356 : : }
18357 : :
18358 : 1045 : if (!range_for)
18359 : : {
18360 : 881 : cond = TREE_VEC_ELT (OMP_FOR_COND (t), i);
18361 : 881 : if (COMPARISON_CLASS_P (cond)
18362 : 881 : && TREE_CODE (TREE_OPERAND (cond, 1)) == TREE_VEC)
18363 : : {
18364 : 12 : tree lhs = RECUR (TREE_OPERAND (cond, 0));
18365 : 12 : tree rhs = copy_node (TREE_OPERAND (cond, 1));
18366 : 12 : TREE_VEC_ELT (rhs, 0)
18367 : 12 : = tsubst_decl (TREE_VEC_ELT (rhs, 0), args, complain);
18368 : 12 : TREE_VEC_ELT (rhs, 1) = RECUR (TREE_VEC_ELT (rhs, 1));
18369 : 12 : TREE_VEC_ELT (rhs, 2) = RECUR (TREE_VEC_ELT (rhs, 2));
18370 : 12 : cond = build2 (TREE_CODE (cond), TREE_TYPE (cond),
18371 : : lhs, rhs);
18372 : : }
18373 : : else
18374 : 869 : cond = RECUR (cond);
18375 : 881 : incr = TREE_VEC_ELT (OMP_FOR_INCR (t), i);
18376 : 881 : if (TREE_CODE (incr) == MODIFY_EXPR)
18377 : : {
18378 : 211 : tree lhs = RECUR (TREE_OPERAND (incr, 0));
18379 : 211 : tree rhs = RECUR (TREE_OPERAND (incr, 1));
18380 : 211 : incr = build_x_modify_expr (EXPR_LOCATION (incr), lhs,
18381 : : NOP_EXPR, rhs, NULL_TREE, complain);
18382 : : }
18383 : : else
18384 : 670 : incr = RECUR (incr);
18385 : 881 : if (orig_declv && !OMP_FOR_ORIG_DECLS (t))
18386 : 18 : TREE_VEC_ELT (orig_declv, i) = decl;
18387 : : }
18388 : 1045 : TREE_VEC_ELT (declv, i) = decl;
18389 : 1045 : TREE_VEC_ELT (initv, i) = init;
18390 : 1045 : TREE_VEC_ELT (condv, i) = cond;
18391 : 1045 : TREE_VEC_ELT (incrv, i) = incr;
18392 : 1045 : return ret;
18393 : : }
18394 : :
18395 : 195 : if (decl_expr)
18396 : : {
18397 : : /* Declare and initialize the variable. */
18398 : 51 : RECUR (decl_expr);
18399 : 51 : init = NULL_TREE;
18400 : : }
18401 : 144 : else if (init)
18402 : : {
18403 : 61 : tree *pc;
18404 : 61 : int j;
18405 : 48 : for (j = ((omp_parallel_combined_clauses == NULL
18406 : 170 : || TREE_CODE (t) == OMP_LOOP) ? 1 : 0); j < 2; j++)
18407 : : {
18408 : 210 : for (pc = j ? clauses : omp_parallel_combined_clauses; *pc; )
18409 : : {
18410 : 80 : if (OMP_CLAUSE_CODE (*pc) == OMP_CLAUSE_PRIVATE
18411 : 80 : && OMP_CLAUSE_DECL (*pc) == decl)
18412 : : break;
18413 : 76 : else if (OMP_CLAUSE_CODE (*pc) == OMP_CLAUSE_LASTPRIVATE
18414 : 76 : && OMP_CLAUSE_DECL (*pc) == decl)
18415 : : {
18416 : 31 : if (j)
18417 : : break;
18418 : : /* Move lastprivate (decl) clause to OMP_FOR_CLAUSES. */
18419 : 1 : tree c = *pc;
18420 : 1 : *pc = OMP_CLAUSE_CHAIN (c);
18421 : 1 : OMP_CLAUSE_CHAIN (c) = *clauses;
18422 : 1 : *clauses = c;
18423 : : }
18424 : 45 : else if (OMP_CLAUSE_CODE (*pc) == OMP_CLAUSE_FIRSTPRIVATE
18425 : 45 : && OMP_CLAUSE_DECL (*pc) == decl)
18426 : : {
18427 : 0 : error ("iteration variable %qD should not be firstprivate",
18428 : : decl);
18429 : 0 : *pc = OMP_CLAUSE_CHAIN (*pc);
18430 : : }
18431 : 45 : else if (OMP_CLAUSE_CODE (*pc) == OMP_CLAUSE_REDUCTION
18432 : 45 : && OMP_CLAUSE_DECL (*pc) == decl)
18433 : : {
18434 : 0 : error ("iteration variable %qD should not be reduction",
18435 : : decl);
18436 : 0 : *pc = OMP_CLAUSE_CHAIN (*pc);
18437 : : }
18438 : : else
18439 : 45 : pc = &OMP_CLAUSE_CHAIN (*pc);
18440 : : }
18441 : 82 : if (*pc)
18442 : : break;
18443 : : }
18444 : 61 : if (*pc == NULL_TREE)
18445 : : {
18446 : 27 : tree c = build_omp_clause (input_location,
18447 : 27 : TREE_CODE (t) == OMP_LOOP
18448 : : ? OMP_CLAUSE_LASTPRIVATE
18449 : : : OMP_CLAUSE_PRIVATE);
18450 : 27 : OMP_CLAUSE_DECL (c) = decl;
18451 : 27 : c = finish_omp_clauses (c, C_ORT_OMP);
18452 : 27 : if (c)
18453 : : {
18454 : 27 : OMP_CLAUSE_CHAIN (c) = *clauses;
18455 : 27 : *clauses = c;
18456 : : }
18457 : : }
18458 : : }
18459 : 195 : cond = TREE_VEC_ELT (OMP_FOR_COND (t), i);
18460 : 195 : if (COMPARISON_CLASS_P (cond))
18461 : : {
18462 : 195 : tree op0 = RECUR (TREE_OPERAND (cond, 0));
18463 : 195 : tree op1 = RECUR (TREE_OPERAND (cond, 1));
18464 : 195 : cond = build2 (TREE_CODE (cond), boolean_type_node, op0, op1);
18465 : : }
18466 : : else
18467 : 0 : cond = RECUR (cond);
18468 : 195 : incr = TREE_VEC_ELT (OMP_FOR_INCR (t), i);
18469 : 195 : switch (TREE_CODE (incr))
18470 : : {
18471 : 85 : case PREINCREMENT_EXPR:
18472 : 85 : case PREDECREMENT_EXPR:
18473 : 85 : case POSTINCREMENT_EXPR:
18474 : 85 : case POSTDECREMENT_EXPR:
18475 : 85 : incr = build2 (TREE_CODE (incr), TREE_TYPE (decl),
18476 : 85 : RECUR (TREE_OPERAND (incr, 0)), NULL_TREE);
18477 : 85 : break;
18478 : 110 : case MODIFY_EXPR:
18479 : 110 : if (TREE_CODE (TREE_OPERAND (incr, 1)) == PLUS_EXPR
18480 : 110 : || TREE_CODE (TREE_OPERAND (incr, 1)) == MINUS_EXPR)
18481 : : {
18482 : 110 : tree rhs = TREE_OPERAND (incr, 1);
18483 : 110 : tree lhs = RECUR (TREE_OPERAND (incr, 0));
18484 : 110 : tree rhs0 = RECUR (TREE_OPERAND (rhs, 0));
18485 : 110 : tree rhs1 = RECUR (TREE_OPERAND (rhs, 1));
18486 : 110 : incr = build2 (MODIFY_EXPR, TREE_TYPE (decl), lhs,
18487 : 110 : build2 (TREE_CODE (rhs), TREE_TYPE (decl),
18488 : : rhs0, rhs1));
18489 : : }
18490 : : else
18491 : 0 : incr = RECUR (incr);
18492 : : break;
18493 : 0 : case MODOP_EXPR:
18494 : 0 : if (TREE_CODE (TREE_OPERAND (incr, 1)) == PLUS_EXPR
18495 : 0 : || TREE_CODE (TREE_OPERAND (incr, 1)) == MINUS_EXPR)
18496 : : {
18497 : 0 : tree lhs = RECUR (TREE_OPERAND (incr, 0));
18498 : 0 : incr = build2 (MODIFY_EXPR, TREE_TYPE (decl), lhs,
18499 : 0 : build2 (TREE_CODE (TREE_OPERAND (incr, 1)),
18500 : 0 : TREE_TYPE (decl), lhs,
18501 : 0 : RECUR (TREE_OPERAND (incr, 2))));
18502 : : }
18503 : 0 : else if (TREE_CODE (TREE_OPERAND (incr, 1)) == NOP_EXPR
18504 : 0 : && (TREE_CODE (TREE_OPERAND (incr, 2)) == PLUS_EXPR
18505 : 0 : || (TREE_CODE (TREE_OPERAND (incr, 2)) == MINUS_EXPR)))
18506 : : {
18507 : 0 : tree rhs = TREE_OPERAND (incr, 2);
18508 : 0 : tree lhs = RECUR (TREE_OPERAND (incr, 0));
18509 : 0 : tree rhs0 = RECUR (TREE_OPERAND (rhs, 0));
18510 : 0 : tree rhs1 = RECUR (TREE_OPERAND (rhs, 1));
18511 : 0 : incr = build2 (MODIFY_EXPR, TREE_TYPE (decl), lhs,
18512 : 0 : build2 (TREE_CODE (rhs), TREE_TYPE (decl),
18513 : : rhs0, rhs1));
18514 : : }
18515 : : else
18516 : 0 : incr = RECUR (incr);
18517 : : break;
18518 : 0 : default:
18519 : 0 : incr = RECUR (incr);
18520 : 0 : break;
18521 : : }
18522 : :
18523 : 195 : if (orig_declv && !OMP_FOR_ORIG_DECLS (t))
18524 : 5 : TREE_VEC_ELT (orig_declv, i) = decl;
18525 : 195 : TREE_VEC_ELT (declv, i) = decl;
18526 : 195 : TREE_VEC_ELT (initv, i) = init;
18527 : 195 : TREE_VEC_ELT (condv, i) = cond;
18528 : 195 : TREE_VEC_ELT (incrv, i) = incr;
18529 : 195 : return false;
18530 : : #undef RECUR
18531 : : }
18532 : :
18533 : : /* Helper function of tsubst_expr, find OMP_TEAMS inside
18534 : : of OMP_TARGET's body. */
18535 : :
18536 : : static tree
18537 : 164 : tsubst_find_omp_teams (tree *tp, int *walk_subtrees, void *)
18538 : : {
18539 : 164 : *walk_subtrees = 0;
18540 : 164 : switch (TREE_CODE (*tp))
18541 : : {
18542 : : case OMP_TEAMS:
18543 : : return *tp;
18544 : 82 : case BIND_EXPR:
18545 : 82 : case STATEMENT_LIST:
18546 : 82 : *walk_subtrees = 1;
18547 : 82 : break;
18548 : : default:
18549 : : break;
18550 : : }
18551 : : return NULL_TREE;
18552 : : }
18553 : :
18554 : : /* Helper function for tsubst_expr. For decomposition declaration
18555 : : artificial base DECL, which is tsubsted PATTERN_DECL, tsubst
18556 : : also the corresponding decls representing the identifiers
18557 : : of the decomposition declaration. Return DECL if successful
18558 : : or error_mark_node otherwise, set *FIRST to the first decl
18559 : : in the list chained through DECL_CHAIN and *CNT to the number
18560 : : of such decls. */
18561 : :
18562 : : static tree
18563 : 25441 : tsubst_decomp_names (tree decl, tree pattern_decl, tree args,
18564 : : tsubst_flags_t complain, tree in_decl, cp_decomp *decomp)
18565 : : {
18566 : 25441 : tree decl2, decl3, prev = decl;
18567 : 25441 : decomp->count = 0;
18568 : 25441 : gcc_assert (DECL_NAME (decl) == NULL_TREE);
18569 : 25441 : for (decl2 = DECL_CHAIN (pattern_decl);
18570 : : decl2
18571 : 55591 : && DECL_DECOMPOSITION_P (decl2)
18572 : 127455 : && DECL_NAME (decl2);
18573 : 50974 : decl2 = DECL_CHAIN (decl2))
18574 : : {
18575 : 50977 : if (TREE_TYPE (decl2) == error_mark_node && decomp->count == 0)
18576 : : {
18577 : 3 : gcc_assert (errorcount);
18578 : : return error_mark_node;
18579 : : }
18580 : 50974 : decomp->count++;
18581 : 50974 : gcc_assert (DECL_DECOMP_BASE (decl2) == pattern_decl);
18582 : 50974 : gcc_assert (DECL_HAS_VALUE_EXPR_P (decl2));
18583 : 50974 : tree v = DECL_VALUE_EXPR (decl2);
18584 : 50974 : DECL_HAS_VALUE_EXPR_P (decl2) = 0;
18585 : 50974 : SET_DECL_VALUE_EXPR (decl2, NULL_TREE);
18586 : 50974 : decl3 = tsubst (decl2, args, complain, in_decl);
18587 : 50974 : SET_DECL_VALUE_EXPR (decl2, v);
18588 : 50974 : DECL_HAS_VALUE_EXPR_P (decl2) = 1;
18589 : 50974 : if (VAR_P (decl3))
18590 : 50974 : DECL_TEMPLATE_INSTANTIATED (decl3) = 1;
18591 : : else
18592 : : {
18593 : 0 : gcc_assert (errorcount);
18594 : 0 : decl = error_mark_node;
18595 : 0 : continue;
18596 : : }
18597 : 50974 : maybe_push_decl (decl3);
18598 : 50974 : if (error_operand_p (decl3))
18599 : 0 : decl = error_mark_node;
18600 : 50974 : else if (decl != error_mark_node
18601 : 50974 : && DECL_CHAIN (decl3) != prev
18602 : 50974 : && decl != prev)
18603 : : {
18604 : 0 : gcc_assert (errorcount);
18605 : : decl = error_mark_node;
18606 : : }
18607 : : else
18608 : : prev = decl3;
18609 : : }
18610 : 25438 : decomp->decl = prev;
18611 : 25438 : return decl;
18612 : : }
18613 : :
18614 : : /* Return the proper local_specialization for init-capture pack DECL. */
18615 : :
18616 : : static tree
18617 : 32 : lookup_init_capture_pack (tree decl)
18618 : : {
18619 : : /* We handle normal pack captures by forwarding to the specialization of the
18620 : : captured parameter. We can't do that for pack init-captures; we need them
18621 : : to have their own local_specialization. We created the individual
18622 : : VAR_DECLs (if any) under build_capture_proxy, and we need to collect them
18623 : : when we process the DECL_EXPR for the pack init-capture in the template.
18624 : : So, how do we find them? We don't know the capture proxy pack when
18625 : : building the individual resulting proxies, and we don't know the
18626 : : individual proxies when instantiating the pack. What we have in common is
18627 : : the FIELD_DECL.
18628 : :
18629 : : So...when we instantiate the FIELD_DECL, we stick the result in
18630 : : local_specializations. Then at the DECL_EXPR we look up that result, see
18631 : : how many elements it has, synthesize the names, and look them up. */
18632 : :
18633 : 32 : tree cname = DECL_NAME (decl);
18634 : 32 : tree val = DECL_VALUE_EXPR (decl);
18635 : 32 : tree field = TREE_OPERAND (val, 1);
18636 : 32 : gcc_assert (TREE_CODE (field) == FIELD_DECL);
18637 : 32 : tree fpack = retrieve_local_specialization (field);
18638 : 32 : if (fpack == error_mark_node)
18639 : : return error_mark_node;
18640 : :
18641 : 32 : int len = 1;
18642 : 32 : tree vec = NULL_TREE;
18643 : 32 : tree r = NULL_TREE;
18644 : 32 : if (TREE_CODE (fpack) == TREE_VEC)
18645 : : {
18646 : 29 : len = TREE_VEC_LENGTH (fpack);
18647 : 29 : vec = make_tree_vec (len);
18648 : 29 : r = make_node (NONTYPE_ARGUMENT_PACK);
18649 : 29 : ARGUMENT_PACK_ARGS (r) = vec;
18650 : : }
18651 : 78 : for (int i = 0; i < len; ++i)
18652 : : {
18653 : 46 : tree ename = vec ? make_ith_pack_parameter_name (cname, i) : cname;
18654 : 46 : tree elt = lookup_name (ename);
18655 : 46 : if (vec)
18656 : 43 : TREE_VEC_ELT (vec, i) = elt;
18657 : : else
18658 : : r = elt;
18659 : : }
18660 : : return r;
18661 : : }
18662 : :
18663 : : /* T is an operand of a template tree being substituted. Return whether
18664 : : T is dependent such that we should suppress some warnings that would
18665 : : make sense if the substituted expression were written directly, like
18666 : : template <int I> bool f() { return I == 2; }
18667 : : We don't want to warn when instantiating f that comparing two constants
18668 : : always has the same value.
18669 : :
18670 : : This is a more limited concept of dependence than instantiation-dependent;
18671 : : here we don't care whether substitution could fail. */
18672 : :
18673 : : static bool
18674 : 91929482 : dependent_operand_p (tree t)
18675 : : {
18676 : 92364275 : while (TREE_CODE (t) == IMPLICIT_CONV_EXPR)
18677 : 434793 : t = TREE_OPERAND (t, 0);
18678 : :
18679 : : /* If we contain a TU_LOCAL_ENTITY assume we're non-dependent; we'll error
18680 : : later when instantiating. */
18681 : 91929482 : if (expr_contains_tu_local_entity (t))
18682 : : return false;
18683 : :
18684 : 91929476 : ++processing_template_decl;
18685 : 91929476 : bool r = (potential_constant_expression (t)
18686 : 91929476 : ? value_dependent_expression_p (t)
18687 : 5046628 : : type_dependent_expression_p (t));
18688 : 91929476 : --processing_template_decl;
18689 : 91929476 : return r;
18690 : : }
18691 : :
18692 : : /* A superset of tsubst_expr that also handles statement trees. */
18693 : :
18694 : : static tree
18695 : 284169960 : tsubst_stmt (tree t, tree args, tsubst_flags_t complain, tree in_decl)
18696 : : {
18697 : : #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
18698 : : #define RECUR(NODE) \
18699 : : tsubst_stmt ((NODE), args, complain, in_decl)
18700 : :
18701 : 284169960 : tree stmt, tmp;
18702 : 284169960 : tree r;
18703 : 284169960 : location_t loc;
18704 : :
18705 : 284169960 : if (t == NULL_TREE || t == error_mark_node)
18706 : : return t;
18707 : :
18708 : 281879276 : loc = input_location;
18709 : 281879276 : if (location_t eloc = cp_expr_location (t))
18710 : 244867772 : input_location = eloc;
18711 : 281879276 : if (STATEMENT_CODE_P (TREE_CODE (t)))
18712 : 41468272 : current_stmt_tree ()->stmts_are_full_exprs_p = STMT_IS_FULL_EXPR_P (t);
18713 : :
18714 : 281879276 : switch (TREE_CODE (t))
18715 : : {
18716 : 34296414 : case STATEMENT_LIST:
18717 : 34296414 : {
18718 : 185029670 : for (tree stmt : tsi_range (t))
18719 : 150733259 : RECUR (stmt);
18720 : : break;
18721 : : }
18722 : :
18723 : 2361307 : case CTOR_INITIALIZER:
18724 : 2361307 : finish_mem_initializers (tsubst_initializer_list
18725 : 2361307 : (TREE_OPERAND (t, 0), args));
18726 : 2361307 : break;
18727 : :
18728 : 15445688 : case RETURN_EXPR:
18729 : 15445688 : finish_return_stmt (RECUR (TREE_OPERAND (t, 0)));
18730 : 15445685 : break;
18731 : :
18732 : 162 : case CO_RETURN_EXPR:
18733 : 162 : finish_co_return_stmt (input_location, RECUR (TREE_OPERAND (t, 0)));
18734 : 162 : break;
18735 : :
18736 : 22209867 : case EXPR_STMT:
18737 : 22209867 : tmp = RECUR (EXPR_STMT_EXPR (t));
18738 : 22209864 : if (EXPR_STMT_STMT_EXPR_RESULT (t))
18739 : 124 : finish_stmt_expr_expr (tmp, cur_stmt_expr);
18740 : : else
18741 : 22209740 : finish_expr_stmt (tmp);
18742 : : break;
18743 : :
18744 : 33787 : case USING_STMT:
18745 : 33787 : finish_using_directive (USING_STMT_NAMESPACE (t), /*attribs=*/NULL_TREE);
18746 : 33787 : break;
18747 : :
18748 : 0 : case PRECONDITION_STMT:
18749 : 0 : case POSTCONDITION_STMT:
18750 : 0 : gcc_unreachable ();
18751 : :
18752 : 21 : case ASSERTION_STMT:
18753 : 21 : {
18754 : 21 : r = tsubst_contract (NULL_TREE, t, args, complain, in_decl);
18755 : 21 : if (r != error_mark_node)
18756 : 21 : add_stmt (r);
18757 : 21 : RETURN (r);
18758 : : }
18759 : : break;
18760 : :
18761 : 21499565 : case DECL_EXPR:
18762 : 21499565 : {
18763 : 21499565 : tree decl, pattern_decl;
18764 : 21499565 : tree init;
18765 : :
18766 : 21499565 : pattern_decl = decl = DECL_EXPR_DECL (t);
18767 : 21499565 : if (TREE_CODE (decl) == LABEL_DECL)
18768 : 39 : finish_label_decl (DECL_NAME (decl));
18769 : 21499526 : else if (TREE_CODE (decl) == USING_DECL)
18770 : : {
18771 : 135099 : tree scope = USING_DECL_SCOPE (decl);
18772 : 135099 : if (DECL_DEPENDENT_P (decl))
18773 : : {
18774 : 9 : scope = tsubst (scope, args, complain, in_decl);
18775 : 9 : if (!MAYBE_CLASS_TYPE_P (scope)
18776 : 6 : && TREE_CODE (scope) != ENUMERAL_TYPE)
18777 : : {
18778 : 3 : if (complain & tf_error)
18779 : 3 : error_at (DECL_SOURCE_LOCATION (decl), "%qT is not a "
18780 : : "class, namespace, or enumeration", scope);
18781 : 3 : return error_mark_node;
18782 : : }
18783 : 6 : finish_nonmember_using_decl (scope, DECL_NAME (decl));
18784 : : }
18785 : : else
18786 : : {
18787 : : /* This is a non-dependent using-decl, and we'll have
18788 : : used the names it found during template parsing. We do
18789 : : not want to do the lookup again, because we might not
18790 : : find the things we found then. */
18791 : 135090 : gcc_checking_assert (scope == tsubst (scope, args,
18792 : : complain, in_decl));
18793 : : /* We still need to push the bindings so that we can look up
18794 : : this name later. */
18795 : 270180 : push_using_decl_bindings (DECL_NAME (decl),
18796 : 135090 : USING_DECL_DECLS (decl));
18797 : : }
18798 : : }
18799 : 21364427 : else if (is_capture_proxy (decl)
18800 : 21364427 : && !DECL_TEMPLATE_INSTANTIATION (current_function_decl))
18801 : : {
18802 : : /* We're in tsubst_lambda_expr, we've already inserted a new
18803 : : capture proxy, so look it up and register it. */
18804 : 288370 : tree inst;
18805 : 288370 : if (!DECL_PACK_P (decl))
18806 : : {
18807 : 288287 : inst = lookup_name (DECL_NAME (decl), LOOK_where::BLOCK,
18808 : : LOOK_want::HIDDEN_LAMBDA);
18809 : 288287 : gcc_assert (inst != decl && is_capture_proxy (inst));
18810 : : }
18811 : 83 : else if (is_normal_capture_proxy (decl))
18812 : : {
18813 : 51 : inst = (retrieve_local_specialization
18814 : 51 : (DECL_CAPTURED_VARIABLE (decl)));
18815 : 51 : gcc_assert (TREE_CODE (inst) == NONTYPE_ARGUMENT_PACK
18816 : : || DECL_PACK_P (inst));
18817 : : }
18818 : : else
18819 : 32 : inst = lookup_init_capture_pack (decl);
18820 : :
18821 : 288370 : register_local_specialization (inst, decl);
18822 : 288370 : break;
18823 : : }
18824 : 21076057 : else if (DECL_PRETTY_FUNCTION_P (decl))
18825 : 14141 : decl = make_fname_decl (DECL_SOURCE_LOCATION (decl),
18826 : 14141 : DECL_NAME (decl),
18827 : : true/*DECL_PRETTY_FUNCTION_P (decl)*/);
18828 : 2091521 : else if (DECL_IMPLICIT_TYPEDEF_P (decl)
18829 : 22428460 : && LAMBDA_TYPE_P (TREE_TYPE (decl)))
18830 : : /* Don't copy the old closure; we'll create a new one in
18831 : : tsubst_lambda_expr. */
18832 : : break;
18833 : : else
18834 : : {
18835 : 20907642 : init = DECL_INITIAL (decl);
18836 : 20907642 : decl = tsubst (decl, args, complain, in_decl);
18837 : 20907639 : if (decl != error_mark_node)
18838 : : {
18839 : : /* By marking the declaration as instantiated, we avoid
18840 : : trying to instantiate it. Since instantiate_decl can't
18841 : : handle local variables, and since we've already done
18842 : : all that needs to be done, that's the right thing to
18843 : : do. */
18844 : 20907627 : if (VAR_P (decl))
18845 : 18969778 : DECL_TEMPLATE_INSTANTIATED (decl) = 1;
18846 : 18969778 : if (VAR_P (decl) && !DECL_NAME (decl)
18847 : 20933400 : && ANON_AGGR_TYPE_P (TREE_TYPE (decl)))
18848 : : /* Anonymous aggregates are a special case. */
18849 : 30 : finish_anon_union (decl);
18850 : 20907597 : else if (is_capture_proxy (DECL_EXPR_DECL (t)))
18851 : : {
18852 : 166467 : DECL_CONTEXT (decl) = current_function_decl;
18853 : 166467 : if (DECL_NAME (decl) == this_identifier)
18854 : : {
18855 : 77091 : tree lam = DECL_CONTEXT (current_function_decl);
18856 : 77091 : lam = CLASSTYPE_LAMBDA_EXPR (lam);
18857 : 77091 : LAMBDA_EXPR_THIS_CAPTURE (lam) = decl;
18858 : : }
18859 : 166467 : insert_capture_proxy (decl);
18860 : : }
18861 : 20741130 : else if (DECL_IMPLICIT_TYPEDEF_P (t))
18862 : : /* We already did a pushtag. */;
18863 : 1937849 : else if (VAR_OR_FUNCTION_DECL_P (decl)
18864 : 20741741 : && DECL_LOCAL_DECL_P (decl))
18865 : : {
18866 : 702 : if (TREE_CODE (DECL_CONTEXT (decl)) == FUNCTION_DECL)
18867 : 130 : DECL_CONTEXT (decl) = NULL_TREE;
18868 : 702 : decl = pushdecl (decl);
18869 : 702 : if (TREE_CODE (decl) == FUNCTION_DECL
18870 : 602 : && DECL_OMP_DECLARE_REDUCTION_P (decl)
18871 : 823 : && cp_check_omp_declare_reduction (decl))
18872 : 85 : instantiate_body (pattern_decl, args, decl, true);
18873 : : }
18874 : : else
18875 : : {
18876 : 20740428 : bool const_init = false;
18877 : 20740428 : cp_decomp decomp_d, *decomp = NULL;
18878 : 20740428 : tree asmspec_tree = NULL_TREE;
18879 : 20740428 : maybe_push_decl (decl);
18880 : :
18881 : 20740428 : if (VAR_P (decl)
18882 : 18803190 : && DECL_LANG_SPECIFIC (decl)
18883 : 21316165 : && DECL_OMP_PRIVATIZED_MEMBER (decl))
18884 : : break;
18885 : :
18886 : 18803007 : if (DECL_DECOMPOSITION_P (decl)
18887 : 20765583 : && TREE_TYPE (pattern_decl) != error_mark_node)
18888 : : {
18889 : 25338 : decomp = &decomp_d;
18890 : 25338 : if (tsubst_decomp_names (decl, pattern_decl, args,
18891 : : complain, in_decl, decomp)
18892 : 25338 : == error_mark_node)
18893 : 20714910 : decomp = NULL;
18894 : : }
18895 : :
18896 : 20740245 : init = tsubst_init (init, decl, args, complain, in_decl);
18897 : :
18898 : 20740245 : if (VAR_P (decl))
18899 : 18803007 : const_init = (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P
18900 : : (pattern_decl));
18901 : :
18902 : : /* In a non-template function, VLA type declarations are
18903 : : handled in grokdeclarator; for templates, handle them
18904 : : now. */
18905 : 20740245 : predeclare_vla (decl);
18906 : :
18907 : 39543252 : if (VAR_P (decl) && DECL_HARD_REGISTER (pattern_decl))
18908 : : {
18909 : 3 : tree id = DECL_ASSEMBLER_NAME (pattern_decl);
18910 : 3 : const char *asmspec = IDENTIFIER_POINTER (id);
18911 : 3 : gcc_assert (asmspec[0] == '*');
18912 : 3 : asmspec_tree
18913 : 3 : = build_string (IDENTIFIER_LENGTH (id) - 1,
18914 : : asmspec + 1);
18915 : 3 : TREE_TYPE (asmspec_tree) = char_array_type_node;
18916 : : }
18917 : :
18918 : 20740245 : cp_finish_decl (decl, init, const_init, asmspec_tree, 0,
18919 : : decomp);
18920 : : }
18921 : : }
18922 : : }
18923 : :
18924 : : break;
18925 : : }
18926 : :
18927 : 1070051 : case FOR_STMT:
18928 : 1070051 : stmt = begin_for_stmt (NULL_TREE, NULL_TREE);
18929 : 1070051 : RECUR (FOR_INIT_STMT (t));
18930 : 1070051 : finish_init_stmt (stmt);
18931 : 1070051 : tmp = RECUR (FOR_COND (t));
18932 : 1070051 : finish_for_cond (tmp, stmt, false, 0, false);
18933 : 1070051 : tmp = RECUR (FOR_EXPR (t));
18934 : 1070051 : finish_for_expr (tmp, stmt);
18935 : 1070051 : {
18936 : 1070051 : bool prev = note_iteration_stmt_body_start ();
18937 : 1070051 : RECUR (FOR_BODY (t));
18938 : 1070051 : note_iteration_stmt_body_end (prev);
18939 : : }
18940 : 1070051 : finish_for_stmt (stmt);
18941 : 1070051 : break;
18942 : :
18943 : 50018 : case RANGE_FOR_STMT:
18944 : 50018 : {
18945 : : /* Construct another range_for, if this is not a final
18946 : : substitution (for inside a generic lambda of a
18947 : : template). Otherwise convert to a regular for. */
18948 : 50018 : tree decl, expr;
18949 : 100036 : stmt = (processing_template_decl
18950 : 50018 : ? begin_range_for_stmt (NULL_TREE, NULL_TREE)
18951 : 50012 : : begin_for_stmt (NULL_TREE, NULL_TREE));
18952 : 50018 : RECUR (RANGE_FOR_INIT_STMT (t));
18953 : 50018 : decl = RANGE_FOR_DECL (t);
18954 : 50018 : decl = tsubst (decl, args, complain, in_decl);
18955 : 50018 : maybe_push_decl (decl);
18956 : 50018 : expr = RECUR (RANGE_FOR_EXPR (t));
18957 : :
18958 : 50018 : cp_decomp decomp_d, *decomp = NULL;
18959 : 50018 : if (DECL_DECOMPOSITION_P (decl))
18960 : : {
18961 : 62 : decomp = &decomp_d;
18962 : 62 : decl = tsubst_decomp_names (decl, RANGE_FOR_DECL (t), args,
18963 : : complain, in_decl, decomp);
18964 : : }
18965 : :
18966 : 50018 : tree unroll = RECUR (RANGE_FOR_UNROLL (t));
18967 : 50018 : if (unroll)
18968 : 33 : unroll
18969 : 33 : = cp_check_pragma_unroll (EXPR_LOCATION (RANGE_FOR_UNROLL (t)),
18970 : : unroll);
18971 : 50018 : if (processing_template_decl)
18972 : : {
18973 : 6 : RANGE_FOR_IVDEP (stmt) = RANGE_FOR_IVDEP (t);
18974 : 6 : RANGE_FOR_UNROLL (stmt) = unroll;
18975 : 6 : RANGE_FOR_NOVECTOR (stmt) = RANGE_FOR_NOVECTOR (t);
18976 : 6 : finish_range_for_decl (stmt, decl, expr);
18977 : 6 : if (decomp && decl != error_mark_node)
18978 : 3 : cp_finish_decomp (decl, decomp);
18979 : : }
18980 : : else
18981 : 100024 : stmt = cp_convert_range_for (stmt, decl, expr, decomp,
18982 : 50012 : RANGE_FOR_IVDEP (t), unroll,
18983 : 50012 : RANGE_FOR_NOVECTOR (t));
18984 : :
18985 : 50018 : bool prev = note_iteration_stmt_body_start ();
18986 : 50018 : RECUR (RANGE_FOR_BODY (t));
18987 : 50018 : note_iteration_stmt_body_end (prev);
18988 : 50018 : finish_for_stmt (stmt);
18989 : : }
18990 : 50018 : break;
18991 : :
18992 : 329405 : case WHILE_STMT:
18993 : 329405 : stmt = begin_while_stmt ();
18994 : 329405 : tmp = RECUR (WHILE_COND (t));
18995 : 329405 : finish_while_stmt_cond (tmp, stmt, false, 0, false);
18996 : 329405 : {
18997 : 329405 : bool prev = note_iteration_stmt_body_start ();
18998 : 329405 : RECUR (WHILE_BODY (t));
18999 : 329405 : note_iteration_stmt_body_end (prev);
19000 : : }
19001 : 329405 : finish_while_stmt (stmt);
19002 : 329405 : break;
19003 : :
19004 : 628734 : case DO_STMT:
19005 : 628734 : stmt = begin_do_stmt ();
19006 : 628734 : {
19007 : 628734 : bool prev = note_iteration_stmt_body_start ();
19008 : 628734 : RECUR (DO_BODY (t));
19009 : 628734 : note_iteration_stmt_body_end (prev);
19010 : : }
19011 : 628734 : finish_do_body (stmt);
19012 : 628734 : tmp = RECUR (DO_COND (t));
19013 : 628734 : finish_do_stmt (tmp, stmt, false, 0, false);
19014 : 628734 : break;
19015 : :
19016 : 12774296 : case IF_STMT:
19017 : 12774296 : stmt = begin_if_stmt ();
19018 : 12774296 : IF_STMT_CONSTEXPR_P (stmt) = IF_STMT_CONSTEXPR_P (t);
19019 : 12774296 : IF_STMT_CONSTEVAL_P (stmt) = IF_STMT_CONSTEVAL_P (t);
19020 : 12774296 : if (IF_STMT_CONSTEXPR_P (t))
19021 : 2541284 : args = add_extra_args (IF_STMT_EXTRA_ARGS (t), args, complain, in_decl);
19022 : 12774296 : {
19023 : 12774296 : tree cond = IF_COND (t);
19024 : 12774296 : bool was_dep = dependent_operand_p (cond);
19025 : 12774296 : cond = RECUR (cond);
19026 : 12774296 : warning_sentinel s1(warn_address, was_dep);
19027 : 12774296 : tmp = finish_if_stmt_cond (cond, stmt);
19028 : 12774296 : }
19029 : 12774296 : if (IF_STMT_CONSTEXPR_P (t)
19030 : 12774296 : && instantiation_dependent_expression_p (tmp))
19031 : : {
19032 : : /* We're partially instantiating a generic lambda, but the condition
19033 : : of the constexpr if is still dependent. Don't substitute into the
19034 : : branches now, just remember the template arguments. */
19035 : 7285 : do_poplevel (IF_SCOPE (stmt));
19036 : 7285 : IF_SCOPE (stmt) = NULL_TREE;
19037 : 7285 : IF_COND (stmt) = IF_COND (t);
19038 : 7285 : THEN_CLAUSE (stmt) = THEN_CLAUSE (t);
19039 : 7285 : ELSE_CLAUSE (stmt) = ELSE_CLAUSE (t);
19040 : 7285 : IF_STMT_EXTRA_ARGS (stmt) = build_extra_args (stmt, args, complain);
19041 : 7285 : add_stmt (stmt);
19042 : 7285 : break;
19043 : : }
19044 : 12767011 : if (IF_STMT_CONSTEXPR_P (t) && integer_zerop (tmp))
19045 : : /* Don't instantiate the THEN_CLAUSE. */;
19046 : 11229570 : else if (IF_STMT_CONSTEVAL_P (t))
19047 : : {
19048 : 2461 : bool save_in_consteval_if_p = in_consteval_if_p;
19049 : 2461 : in_consteval_if_p = true;
19050 : 2461 : RECUR (THEN_CLAUSE (t));
19051 : 2461 : in_consteval_if_p = save_in_consteval_if_p;
19052 : : }
19053 : : else
19054 : : {
19055 : 11227109 : tree folded = fold_non_dependent_expr (tmp, complain);
19056 : 11227109 : bool inhibit = integer_zerop (folded);
19057 : 11227109 : if (inhibit)
19058 : 182610 : ++c_inhibit_evaluation_warnings;
19059 : 11227109 : RECUR (THEN_CLAUSE (t));
19060 : 11227109 : if (inhibit)
19061 : 182610 : --c_inhibit_evaluation_warnings;
19062 : : }
19063 : 12767011 : finish_then_clause (stmt);
19064 : :
19065 : 12767011 : if (IF_STMT_CONSTEXPR_P (t) && integer_nonzerop (tmp))
19066 : : /* Don't instantiate the ELSE_CLAUSE. */;
19067 : 11770468 : else if (ELSE_CLAUSE (t))
19068 : : {
19069 : 5174319 : tree folded = fold_non_dependent_expr (tmp, complain);
19070 : 5174319 : bool inhibit = integer_nonzerop (folded);
19071 : 5174319 : begin_else_clause (stmt);
19072 : 5174319 : if (inhibit)
19073 : 24622 : ++c_inhibit_evaluation_warnings;
19074 : 5174319 : RECUR (ELSE_CLAUSE (t));
19075 : 5174319 : if (inhibit)
19076 : 24622 : --c_inhibit_evaluation_warnings;
19077 : 5174319 : finish_else_clause (stmt);
19078 : : }
19079 : :
19080 : 12767011 : finish_if_stmt (stmt);
19081 : 12767011 : break;
19082 : :
19083 : 35526693 : case BIND_EXPR:
19084 : 35526693 : if (BIND_EXPR_BODY_BLOCK (t))
19085 : 3314728 : stmt = begin_function_body ();
19086 : : else
19087 : 64329461 : stmt = begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t)
19088 : : ? BCS_TRY_BLOCK : 0);
19089 : :
19090 : 35526693 : RECUR (BIND_EXPR_BODY (t));
19091 : :
19092 : 35526684 : if (BIND_EXPR_BODY_BLOCK (t))
19093 : 3314728 : finish_function_body (stmt);
19094 : : else
19095 : 32211956 : finish_compound_stmt (stmt);
19096 : : break;
19097 : :
19098 : 1036324 : case BREAK_STMT:
19099 : 1036324 : finish_break_stmt ();
19100 : 1036324 : break;
19101 : :
19102 : 1641 : case CONTINUE_STMT:
19103 : 1641 : finish_continue_stmt ();
19104 : 1641 : break;
19105 : :
19106 : 253855 : case SWITCH_STMT:
19107 : 253855 : stmt = begin_switch_stmt ();
19108 : 253855 : tmp = RECUR (SWITCH_STMT_COND (t));
19109 : 253855 : finish_switch_cond (tmp, stmt);
19110 : 253855 : RECUR (SWITCH_STMT_BODY (t));
19111 : 253855 : finish_switch_stmt (stmt);
19112 : 253855 : break;
19113 : :
19114 : 1571880 : case CASE_LABEL_EXPR:
19115 : 1571880 : {
19116 : 1571880 : tree decl = CASE_LABEL (t);
19117 : 1571880 : tree low = RECUR (CASE_LOW (t));
19118 : 1571880 : tree high = RECUR (CASE_HIGH (t));
19119 : 1571880 : tree l = finish_case_label (EXPR_LOCATION (t), low, high);
19120 : 1571880 : if (l && TREE_CODE (l) == CASE_LABEL_EXPR)
19121 : : {
19122 : 1571871 : tree label = CASE_LABEL (l);
19123 : 1571871 : FALLTHROUGH_LABEL_P (label) = FALLTHROUGH_LABEL_P (decl);
19124 : 1571871 : if (DECL_ATTRIBUTES (decl) != NULL_TREE)
19125 : 6 : cplus_decl_attributes (&label, DECL_ATTRIBUTES (decl), 0);
19126 : : }
19127 : : }
19128 : : break;
19129 : :
19130 : 212 : case LABEL_EXPR:
19131 : 212 : {
19132 : 212 : tree decl = LABEL_EXPR_LABEL (t);
19133 : 212 : tree label = finish_label_stmt (DECL_NAME (decl));
19134 : 212 : if (TREE_CODE (label) == LABEL_DECL)
19135 : : {
19136 : 212 : FALLTHROUGH_LABEL_P (label) = FALLTHROUGH_LABEL_P (decl);
19137 : 212 : copy_warning (label, decl);
19138 : : }
19139 : 212 : if (DECL_ATTRIBUTES (decl) != NULL_TREE)
19140 : 18 : cplus_decl_attributes (&label, DECL_ATTRIBUTES (decl), 0);
19141 : : }
19142 : 212 : break;
19143 : :
19144 : 189 : case GOTO_EXPR:
19145 : 189 : tmp = GOTO_DESTINATION (t);
19146 : 189 : if (TREE_CODE (tmp) != LABEL_DECL)
19147 : : /* Computed goto's must be tsubst'd into. On the other hand,
19148 : : non-computed gotos must not be; the identifier in question
19149 : : will have no binding. */
19150 : 23 : tmp = RECUR (tmp);
19151 : : else
19152 : 166 : tmp = DECL_NAME (tmp);
19153 : 189 : finish_goto_stmt (tmp);
19154 : 189 : break;
19155 : :
19156 : 208 : case ASM_EXPR:
19157 : 208 : {
19158 : 208 : tree string = RECUR (ASM_STRING (t));
19159 : 208 : tree outputs = tsubst_copy_asm_operands (ASM_OUTPUTS (t), args,
19160 : : complain, in_decl);
19161 : 208 : tree inputs = tsubst_copy_asm_operands (ASM_INPUTS (t), args,
19162 : : complain, in_decl);
19163 : 208 : tree clobbers = tsubst_copy_asm_operands (ASM_CLOBBERS (t), args,
19164 : : complain, in_decl);
19165 : 208 : tree labels = tsubst_copy_asm_operands (ASM_LABELS (t), args,
19166 : : complain, in_decl);
19167 : 416 : tmp = finish_asm_stmt (EXPR_LOCATION (t), ASM_VOLATILE_P (t), string,
19168 : : outputs, inputs, clobbers, labels,
19169 : 208 : ASM_INLINE_P (t), false);
19170 : 208 : tree asm_expr = tmp;
19171 : 208 : if (TREE_CODE (asm_expr) == CLEANUP_POINT_EXPR)
19172 : 208 : asm_expr = TREE_OPERAND (asm_expr, 0);
19173 : 208 : ASM_BASIC_P (asm_expr) = ASM_BASIC_P (t);
19174 : : }
19175 : 208 : break;
19176 : :
19177 : 94469 : case TRY_BLOCK:
19178 : 94469 : if (CLEANUP_P (t))
19179 : : {
19180 : 0 : stmt = begin_try_block ();
19181 : 0 : RECUR (TRY_STMTS (t));
19182 : 0 : finish_cleanup_try_block (stmt);
19183 : 0 : finish_cleanup (RECUR (TRY_HANDLERS (t)), stmt);
19184 : : }
19185 : : else
19186 : : {
19187 : 94469 : tree compound_stmt = NULL_TREE;
19188 : :
19189 : 94469 : if (FN_TRY_BLOCK_P (t))
19190 : 48 : stmt = begin_function_try_block (&compound_stmt);
19191 : : else
19192 : 94421 : stmt = begin_try_block ();
19193 : :
19194 : 94469 : RECUR (TRY_STMTS (t));
19195 : :
19196 : 94469 : if (FN_TRY_BLOCK_P (t))
19197 : 48 : finish_function_try_block (stmt);
19198 : : else
19199 : 94421 : finish_try_block (stmt);
19200 : :
19201 : 94469 : RECUR (TRY_HANDLERS (t));
19202 : 94469 : if (FN_TRY_BLOCK_P (t))
19203 : 48 : finish_function_handler_sequence (stmt, compound_stmt);
19204 : : else
19205 : 94421 : finish_handler_sequence (stmt);
19206 : : }
19207 : : break;
19208 : :
19209 : 95234 : case HANDLER:
19210 : 95234 : {
19211 : 95234 : tree decl = HANDLER_PARMS (t);
19212 : :
19213 : 95234 : if (decl)
19214 : : {
19215 : 1687 : decl = tsubst (decl, args, complain, in_decl);
19216 : : /* Prevent instantiate_decl from trying to instantiate
19217 : : this variable. We've already done all that needs to be
19218 : : done. */
19219 : 1687 : if (decl != error_mark_node)
19220 : 1684 : DECL_TEMPLATE_INSTANTIATED (decl) = 1;
19221 : : }
19222 : 95234 : stmt = begin_handler ();
19223 : 95234 : finish_handler_parms (decl, stmt);
19224 : 95234 : RECUR (HANDLER_BODY (t));
19225 : 95234 : finish_handler (stmt);
19226 : : }
19227 : 95234 : break;
19228 : :
19229 : 529170 : case TAG_DEFN:
19230 : 529170 : tmp = tsubst (TREE_TYPE (t), args, complain, NULL_TREE);
19231 : 529170 : if (dependent_type_p (tmp))
19232 : : /* This is a partial instantiation, try again when full. */
19233 : 21 : add_stmt (build_min (TAG_DEFN, tmp));
19234 : 529149 : else if (CLASS_TYPE_P (tmp))
19235 : : {
19236 : : /* Local classes are not independent templates; they are
19237 : : instantiated along with their containing function. And this
19238 : : way we don't have to deal with pushing out of one local class
19239 : : to instantiate a member of another local class. */
19240 : : /* Closures are handled by the LAMBDA_EXPR. */
19241 : 1057573 : gcc_assert (!LAMBDA_TYPE_P (TREE_TYPE (t)));
19242 : 528822 : complete_type (tmp);
19243 : 528822 : tree save_ccp = current_class_ptr;
19244 : 528822 : tree save_ccr = current_class_ref;
19245 : 3670131 : for (tree fld = TYPE_FIELDS (tmp); fld; fld = DECL_CHAIN (fld))
19246 : 3141309 : if ((VAR_P (fld)
19247 : 3141306 : || (TREE_CODE (fld) == FUNCTION_DECL
19248 : 2163669 : && !DECL_ARTIFICIAL (fld)))
19249 : 5304978 : && DECL_TEMPLATE_INSTANTIATION (fld))
19250 : 2163672 : instantiate_decl (fld, /*defer_ok=*/false,
19251 : : /*expl_inst_class=*/false);
19252 : 977637 : else if (TREE_CODE (fld) == FIELD_DECL)
19253 : 448605 : maybe_instantiate_nsdmi_init (fld, tf_warning_or_error);
19254 : 528822 : current_class_ptr = save_ccp;
19255 : 528822 : current_class_ref = save_ccr;
19256 : : }
19257 : : break;
19258 : :
19259 : 4395929 : case STATIC_ASSERT:
19260 : 4395929 : {
19261 : 4395929 : tree condition, message;
19262 : :
19263 : 4395929 : ++c_inhibit_evaluation_warnings;
19264 : 4395929 : condition = tsubst_expr (STATIC_ASSERT_CONDITION (t), args,
19265 : : complain, in_decl);
19266 : 4395929 : message = tsubst_expr (STATIC_ASSERT_MESSAGE (t), args,
19267 : : complain, in_decl);
19268 : 4395929 : if (TREE_CODE (STATIC_ASSERT_MESSAGE (t)) != STRING_CST
19269 : 4395929 : && TREE_CODE (message) == STRING_CST)
19270 : 0 : message = build1_loc (STATIC_ASSERT_SOURCE_LOCATION (t),
19271 : 0 : PAREN_EXPR, TREE_TYPE (message), message);
19272 : 4395929 : --c_inhibit_evaluation_warnings;
19273 : :
19274 : 4395929 : finish_static_assert (condition, message,
19275 : 4395929 : STATIC_ASSERT_SOURCE_LOCATION (t),
19276 : : /*member_p=*/false, /*show_expr_p=*/true);
19277 : : }
19278 : 4395929 : break;
19279 : :
19280 : 242 : case OACC_KERNELS:
19281 : 242 : case OACC_PARALLEL:
19282 : 242 : case OACC_SERIAL:
19283 : 242 : tmp = tsubst_omp_clauses (OMP_CLAUSES (t), C_ORT_ACC_TARGET, args,
19284 : : complain, in_decl);
19285 : 242 : stmt = begin_omp_parallel ();
19286 : 242 : RECUR (OMP_BODY (t));
19287 : 242 : finish_omp_construct (TREE_CODE (t), stmt, tmp);
19288 : 242 : break;
19289 : :
19290 : 847 : case OMP_PARALLEL:
19291 : 847 : r = push_omp_privatization_clauses (OMP_PARALLEL_COMBINED (t));
19292 : 847 : tmp = tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t), C_ORT_OMP, args,
19293 : : complain, in_decl);
19294 : 847 : if (OMP_PARALLEL_COMBINED (t))
19295 : 437 : omp_parallel_combined_clauses = &tmp;
19296 : 847 : stmt = begin_omp_parallel ();
19297 : 847 : RECUR (OMP_PARALLEL_BODY (t));
19298 : 847 : gcc_assert (omp_parallel_combined_clauses == NULL);
19299 : 1694 : OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp, stmt))
19300 : 847 : = OMP_PARALLEL_COMBINED (t);
19301 : 847 : pop_omp_privatization_clauses (r);
19302 : 847 : break;
19303 : :
19304 : 349 : case OMP_TASK:
19305 : 349 : if (OMP_TASK_BODY (t) == NULL_TREE)
19306 : : {
19307 : 0 : tmp = tsubst_omp_clauses (OMP_TASK_CLAUSES (t), C_ORT_OMP, args,
19308 : : complain, in_decl);
19309 : 0 : t = copy_node (t);
19310 : 0 : OMP_TASK_CLAUSES (t) = tmp;
19311 : 0 : add_stmt (t);
19312 : 0 : break;
19313 : : }
19314 : 349 : r = push_omp_privatization_clauses (false);
19315 : 349 : tmp = tsubst_omp_clauses (OMP_TASK_CLAUSES (t), C_ORT_OMP, args,
19316 : : complain, in_decl);
19317 : 349 : stmt = begin_omp_task ();
19318 : 349 : RECUR (OMP_TASK_BODY (t));
19319 : 349 : finish_omp_task (tmp, stmt);
19320 : 349 : pop_omp_privatization_clauses (r);
19321 : 349 : break;
19322 : :
19323 : 1234 : case OMP_FOR:
19324 : 1234 : case OMP_LOOP:
19325 : 1234 : case OMP_SIMD:
19326 : 1234 : case OMP_DISTRIBUTE:
19327 : 1234 : case OMP_TASKLOOP:
19328 : 1234 : case OMP_TILE:
19329 : 1234 : case OMP_UNROLL:
19330 : 1234 : case OACC_LOOP:
19331 : 1234 : {
19332 : 1234 : tree clauses, body, pre_body;
19333 : 1234 : tree declv = NULL_TREE, initv = NULL_TREE, condv = NULL_TREE;
19334 : 1234 : tree orig_declv = NULL_TREE;
19335 : 1234 : tree incrv = NULL_TREE;
19336 : 1234 : enum c_omp_region_type ort = C_ORT_OMP;
19337 : 1234 : bool any_range_for = false;
19338 : 1234 : int i;
19339 : :
19340 : 1234 : if (TREE_CODE (t) == OACC_LOOP)
19341 : 33 : ort = C_ORT_ACC;
19342 : :
19343 : 1234 : r = push_omp_privatization_clauses (OMP_FOR_INIT (t) == NULL_TREE);
19344 : 1234 : clauses = tsubst_omp_clauses (OMP_FOR_CLAUSES (t), ort, args, complain,
19345 : : in_decl);
19346 : 1234 : if (OMP_FOR_INIT (t) != NULL_TREE)
19347 : : {
19348 : 1055 : declv = make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t)));
19349 : 1055 : if (OMP_FOR_ORIG_DECLS (t))
19350 : 546 : orig_declv = make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t)));
19351 : 1055 : initv = make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t)));
19352 : 1055 : condv = make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t)));
19353 : 1055 : incrv = make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t)));
19354 : : }
19355 : :
19356 : 1234 : keep_next_level (true);
19357 : 1234 : stmt = begin_omp_structured_block ();
19358 : :
19359 : 1234 : pre_body = push_stmt_list ();
19360 : 1234 : RECUR (OMP_FOR_PRE_BODY (t));
19361 : 1234 : pre_body = pop_stmt_list (pre_body);
19362 : :
19363 : 1234 : tree sl = NULL_TREE;
19364 : 1234 : if (flag_range_for_ext_temps
19365 : 719 : && OMP_FOR_INIT (t) != NULL_TREE
19366 : 1877 : && !processing_template_decl)
19367 : 1334 : for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (t)); i++)
19368 : 744 : if (TREE_VEC_ELT (OMP_FOR_INIT (t), i)
19369 : 744 : && TREE_VEC_ELT (OMP_FOR_COND (t), i) == global_namespace)
19370 : : {
19371 : 48 : sl = push_stmt_list ();
19372 : 48 : break;
19373 : : }
19374 : :
19375 : 1234 : if (OMP_FOR_INIT (t) != NULL_TREE)
19376 : 2334 : for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (t)); i++)
19377 : : {
19378 : 1279 : if (TREE_VEC_ELT (OMP_FOR_INIT (t), i))
19379 : 1240 : any_range_for
19380 : 1240 : |= tsubst_omp_for_iterator (t, i, declv, orig_declv, initv,
19381 : : condv, incrv, &clauses, args,
19382 : : complain, in_decl);
19383 : : else
19384 : : {
19385 : 39 : TREE_VEC_ELT (declv, i) = global_namespace;
19386 : 39 : TREE_VEC_ELT (initv, i) = NULL_TREE;
19387 : 39 : TREE_VEC_ELT (condv, i) = NULL_TREE;
19388 : 39 : TREE_VEC_ELT (incrv, i) = NULL_TREE;
19389 : 39 : if (orig_declv)
19390 : 30 : TREE_VEC_ELT (orig_declv, i) = NULL_TREE;
19391 : : }
19392 : : }
19393 : 1234 : omp_parallel_combined_clauses = NULL;
19394 : :
19395 : 1234 : if (any_range_for)
19396 : : {
19397 : 143 : gcc_assert (orig_declv);
19398 : 143 : body = begin_omp_structured_block ();
19399 : 468 : for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (t)); i++)
19400 : 182 : if (TREE_VEC_ELT (declv, i) != global_namespace
19401 : 182 : && TREE_VEC_ELT (orig_declv, i) != TREE_VEC_ELT (declv, i)
19402 : 159 : && TREE_CODE (TREE_VEC_ELT (orig_declv, i)) == TREE_LIST
19403 : 341 : && TREE_CHAIN (TREE_VEC_ELT (orig_declv, i)))
19404 : 159 : cp_finish_omp_range_for (TREE_VEC_ELT (orig_declv, i),
19405 : 159 : TREE_VEC_ELT (declv, i));
19406 : : }
19407 : : else
19408 : 1091 : body = push_stmt_list ();
19409 : 1234 : RECUR (OMP_FOR_BODY (t));
19410 : 1234 : if (any_range_for)
19411 : 143 : body = finish_omp_structured_block (body);
19412 : : else
19413 : 1091 : body = pop_stmt_list (body);
19414 : :
19415 : 1234 : if (OMP_FOR_INIT (t) != NULL_TREE)
19416 : 1055 : t = finish_omp_for (EXPR_LOCATION (t), TREE_CODE (t), declv,
19417 : : orig_declv, initv, condv, incrv, body, pre_body,
19418 : : NULL, clauses);
19419 : : else
19420 : : {
19421 : 179 : t = make_node (TREE_CODE (t));
19422 : 179 : TREE_TYPE (t) = void_type_node;
19423 : 179 : OMP_FOR_BODY (t) = body;
19424 : 179 : OMP_FOR_PRE_BODY (t) = pre_body;
19425 : 179 : OMP_FOR_CLAUSES (t) = clauses;
19426 : 179 : SET_EXPR_LOCATION (t, EXPR_LOCATION (t));
19427 : 179 : add_stmt (t);
19428 : : }
19429 : :
19430 : 1234 : if (sl)
19431 : : {
19432 : : /* P2718R0 - Add CLEANUP_POINT_EXPR so that temporaries in
19433 : : for-range-initializer whose lifetime is extended are destructed
19434 : : here. */
19435 : 48 : sl = pop_stmt_list (sl);
19436 : 48 : sl = maybe_cleanup_point_expr_void (sl);
19437 : 48 : add_stmt (sl);
19438 : : }
19439 : :
19440 : 1234 : add_stmt (finish_omp_for_block (finish_omp_structured_block (stmt),
19441 : : t));
19442 : 1234 : pop_omp_privatization_clauses (r);
19443 : :
19444 : 1234 : if (any_range_for && !processing_template_decl && t)
19445 : 267 : for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (t)); i++)
19446 : 144 : if (TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (t), i)
19447 : 144 : && TREE_CODE (TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (t),
19448 : : i)) == TREE_LIST)
19449 : : {
19450 : 144 : tree v = TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (t), i);
19451 : 144 : if (TREE_CHAIN (v) == NULL_TREE
19452 : 144 : || TREE_CODE (TREE_CHAIN (v)) != TREE_VEC)
19453 : 5 : continue;
19454 : 139 : v = TREE_VEC_ELT (TREE_CHAIN (v), 0);
19455 : 139 : gcc_assert (VAR_P (v) && DECL_NAME (v) == NULL_TREE);
19456 : 139 : DECL_NAME (v) = for_range_identifier;
19457 : : }
19458 : : }
19459 : 1234 : break;
19460 : :
19461 : 19 : case OMP_SECTIONS:
19462 : 19 : case OMP_MASKED:
19463 : 19 : omp_parallel_combined_clauses = NULL;
19464 : : /* FALLTHRU */
19465 : 485 : case OMP_SINGLE:
19466 : 485 : case OMP_SCOPE:
19467 : 485 : case OMP_TEAMS:
19468 : 485 : case OMP_CRITICAL:
19469 : 485 : case OMP_TASKGROUP:
19470 : 485 : case OMP_SCAN:
19471 : 485 : r = push_omp_privatization_clauses (TREE_CODE (t) == OMP_TEAMS
19472 : 485 : && OMP_TEAMS_COMBINED (t));
19473 : 485 : tmp = tsubst_omp_clauses (OMP_CLAUSES (t), C_ORT_OMP, args, complain,
19474 : : in_decl);
19475 : 485 : if (TREE_CODE (t) == OMP_TEAMS)
19476 : : {
19477 : 255 : keep_next_level (true);
19478 : 255 : stmt = begin_omp_structured_block ();
19479 : 255 : RECUR (OMP_BODY (t));
19480 : 255 : stmt = finish_omp_structured_block (stmt);
19481 : : }
19482 : : else
19483 : : {
19484 : 230 : stmt = push_stmt_list ();
19485 : 230 : RECUR (OMP_BODY (t));
19486 : 230 : stmt = pop_stmt_list (stmt);
19487 : : }
19488 : :
19489 : 485 : if (TREE_CODE (t) == OMP_CRITICAL
19490 : 18 : && tmp != NULL_TREE
19491 : 497 : && integer_nonzerop (OMP_CLAUSE_HINT_EXPR (tmp)))
19492 : : {
19493 : 6 : error_at (OMP_CLAUSE_LOCATION (tmp),
19494 : : "%<#pragma omp critical%> with %<hint%> clause requires "
19495 : : "a name, except when %<omp_sync_hint_none%> is used");
19496 : 6 : RETURN (error_mark_node);
19497 : : }
19498 : 479 : t = copy_node (t);
19499 : 479 : OMP_BODY (t) = stmt;
19500 : 479 : OMP_CLAUSES (t) = tmp;
19501 : 479 : add_stmt (t);
19502 : 479 : pop_omp_privatization_clauses (r);
19503 : 479 : break;
19504 : :
19505 : 114 : case OMP_DEPOBJ:
19506 : 114 : r = RECUR (OMP_DEPOBJ_DEPOBJ (t));
19507 : 114 : if (OMP_DEPOBJ_CLAUSES (t) && OMP_DEPOBJ_CLAUSES (t) != error_mark_node)
19508 : : {
19509 : 105 : enum omp_clause_depend_kind kind = OMP_CLAUSE_DEPEND_INVALID;
19510 : 105 : if (TREE_CODE (OMP_DEPOBJ_CLAUSES (t)) == OMP_CLAUSE)
19511 : : {
19512 : 58 : tmp = tsubst_omp_clauses (OMP_DEPOBJ_CLAUSES (t), C_ORT_OMP,
19513 : : args, complain, in_decl);
19514 : 58 : if (tmp == NULL_TREE)
19515 : 6 : tmp = error_mark_node;
19516 : : }
19517 : : else
19518 : : {
19519 : 94 : kind = (enum omp_clause_depend_kind)
19520 : 47 : tree_to_uhwi (OMP_DEPOBJ_CLAUSES (t));
19521 : 47 : tmp = NULL_TREE;
19522 : : }
19523 : 105 : finish_omp_depobj (EXPR_LOCATION (t), r, kind, tmp);
19524 : : }
19525 : : else
19526 : 9 : finish_omp_depobj (EXPR_LOCATION (t), r,
19527 : : OMP_CLAUSE_DEPEND_INVALID,
19528 : 9 : OMP_DEPOBJ_CLAUSES (t));
19529 : : break;
19530 : :
19531 : 792 : case OACC_DATA:
19532 : 792 : case OMP_TARGET_DATA:
19533 : 792 : case OMP_TARGET:
19534 : 1572 : tmp = tsubst_omp_clauses (OMP_CLAUSES (t),
19535 : : TREE_CODE (t) == OACC_DATA
19536 : : ? C_ORT_ACC
19537 : : : TREE_CODE (t) == OMP_TARGET
19538 : 780 : ? C_ORT_OMP_TARGET : C_ORT_OMP,
19539 : : args, complain, in_decl);
19540 : 792 : keep_next_level (true);
19541 : 792 : stmt = begin_omp_structured_block ();
19542 : :
19543 : 792 : RECUR (OMP_BODY (t));
19544 : 792 : stmt = finish_omp_structured_block (stmt);
19545 : :
19546 : 792 : t = copy_node (t);
19547 : 792 : OMP_BODY (t) = stmt;
19548 : 792 : OMP_CLAUSES (t) = tmp;
19549 : :
19550 : 792 : if (TREE_CODE (t) == OMP_TARGET)
19551 : 769 : finish_omp_target_clauses (EXPR_LOCATION (t), OMP_BODY (t),
19552 : : &OMP_CLAUSES (t));
19553 : :
19554 : 792 : if (TREE_CODE (t) == OMP_TARGET && OMP_TARGET_COMBINED (t))
19555 : : {
19556 : 82 : tree teams = cp_walk_tree (&stmt, tsubst_find_omp_teams, NULL, NULL);
19557 : 82 : if (teams)
19558 : : /* For combined target teams, ensure the num_teams and
19559 : : thread_limit clause expressions are evaluated on the host,
19560 : : before entering the target construct. */
19561 : 160 : for (tree c = OMP_TEAMS_CLAUSES (teams);
19562 : 160 : c; c = OMP_CLAUSE_CHAIN (c))
19563 : 78 : if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_NUM_TEAMS
19564 : 78 : || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_THREAD_LIMIT)
19565 : 141 : for (int i = 0;
19566 : 219 : i <= (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_NUM_TEAMS); ++i)
19567 : 141 : if (OMP_CLAUSE_OPERAND (c, i)
19568 : 141 : && TREE_CODE (OMP_CLAUSE_OPERAND (c, i)) != INTEGER_CST)
19569 : : {
19570 : 42 : tree expr = OMP_CLAUSE_OPERAND (c, i);
19571 : 42 : expr = force_target_expr (TREE_TYPE (expr), expr,
19572 : : tf_none);
19573 : 42 : if (expr == error_mark_node)
19574 : 0 : continue;
19575 : 42 : tmp = TARGET_EXPR_SLOT (expr);
19576 : 42 : add_stmt (expr);
19577 : 42 : OMP_CLAUSE_OPERAND (c, i) = expr;
19578 : 42 : tree tc = build_omp_clause (OMP_CLAUSE_LOCATION (c),
19579 : : OMP_CLAUSE_FIRSTPRIVATE);
19580 : 42 : OMP_CLAUSE_DECL (tc) = tmp;
19581 : 42 : OMP_CLAUSE_CHAIN (tc) = OMP_TARGET_CLAUSES (t);
19582 : 42 : OMP_TARGET_CLAUSES (t) = tc;
19583 : : }
19584 : : }
19585 : 792 : add_stmt (t);
19586 : 792 : break;
19587 : :
19588 : 1 : case OACC_DECLARE:
19589 : 1 : t = copy_node (t);
19590 : 1 : tmp = tsubst_omp_clauses (OACC_DECLARE_CLAUSES (t), C_ORT_ACC, args,
19591 : : complain, in_decl);
19592 : 1 : OACC_DECLARE_CLAUSES (t) = tmp;
19593 : 1 : add_stmt (t);
19594 : 1 : break;
19595 : :
19596 : 168 : case OMP_TARGET_UPDATE:
19597 : 168 : case OMP_TARGET_ENTER_DATA:
19598 : 168 : case OMP_TARGET_EXIT_DATA:
19599 : 168 : tmp = tsubst_omp_clauses (OMP_STANDALONE_CLAUSES (t), C_ORT_OMP, args,
19600 : : complain, in_decl);
19601 : 168 : t = copy_node (t);
19602 : 168 : OMP_STANDALONE_CLAUSES (t) = tmp;
19603 : 168 : add_stmt (t);
19604 : 168 : break;
19605 : :
19606 : 371 : case OACC_CACHE:
19607 : 371 : case OACC_ENTER_DATA:
19608 : 371 : case OACC_EXIT_DATA:
19609 : 371 : case OACC_UPDATE:
19610 : 371 : tmp = tsubst_omp_clauses (OMP_STANDALONE_CLAUSES (t), C_ORT_ACC, args,
19611 : : complain, in_decl);
19612 : 371 : t = copy_node (t);
19613 : 371 : OMP_STANDALONE_CLAUSES (t) = tmp;
19614 : 371 : add_stmt (t);
19615 : 371 : break;
19616 : :
19617 : 33 : case OMP_ORDERED:
19618 : 33 : tmp = tsubst_omp_clauses (OMP_ORDERED_CLAUSES (t), C_ORT_OMP, args,
19619 : : complain, in_decl);
19620 : 33 : if (OMP_BODY (t))
19621 : : {
19622 : 3 : stmt = push_stmt_list ();
19623 : 3 : RECUR (OMP_BODY (t));
19624 : 3 : stmt = pop_stmt_list (stmt);
19625 : : }
19626 : : else
19627 : 30 : stmt = NULL_TREE;
19628 : :
19629 : 33 : t = copy_node (t);
19630 : 33 : OMP_BODY (t) = stmt;
19631 : 33 : OMP_ORDERED_CLAUSES (t) = tmp;
19632 : 33 : add_stmt (t);
19633 : 33 : break;
19634 : :
19635 : 73 : case OMP_MASTER:
19636 : 73 : case OMP_STRUCTURED_BLOCK:
19637 : 73 : omp_parallel_combined_clauses = NULL;
19638 : : /* FALLTHRU */
19639 : 92 : case OMP_SECTION:
19640 : 92 : stmt = push_stmt_list ();
19641 : 92 : RECUR (OMP_BODY (t));
19642 : 92 : stmt = pop_stmt_list (stmt);
19643 : :
19644 : 92 : t = copy_node (t);
19645 : 92 : OMP_BODY (t) = stmt;
19646 : 92 : add_stmt (t);
19647 : 92 : break;
19648 : :
19649 : 12 : case OMP_DISPATCH:
19650 : 12 : tmp = tsubst_omp_clauses (OMP_DISPATCH_CLAUSES (t), C_ORT_OMP, args,
19651 : : complain, in_decl);
19652 : 12 : stmt = RECUR (OMP_DISPATCH_BODY (t));
19653 : 12 : t = copy_node (t);
19654 : 12 : OMP_DISPATCH_BODY (t) = stmt;
19655 : 12 : OMP_DISPATCH_CLAUSES (t) = tmp;
19656 : 12 : add_stmt (t);
19657 : 12 : break;
19658 : :
19659 : 600 : case OMP_ATOMIC:
19660 : 600 : gcc_assert (OMP_ATOMIC_DEPENDENT_P (t));
19661 : 600 : tmp = NULL_TREE;
19662 : 600 : if (TREE_CODE (TREE_OPERAND (t, 0)) == OMP_CLAUSE)
19663 : 30 : tmp = tsubst_omp_clauses (TREE_OPERAND (t, 0), C_ORT_OMP, args,
19664 : : complain, in_decl);
19665 : 600 : if (TREE_CODE (TREE_OPERAND (t, 1)) != MODIFY_EXPR)
19666 : : {
19667 : 184 : tree op1 = TREE_OPERAND (t, 1);
19668 : 184 : tree rhs1 = NULL_TREE;
19669 : 184 : tree r = NULL_TREE;
19670 : 184 : tree lhs, rhs;
19671 : 184 : if (TREE_CODE (op1) == COMPOUND_EXPR)
19672 : : {
19673 : 99 : rhs1 = RECUR (TREE_OPERAND (op1, 0));
19674 : 99 : op1 = TREE_OPERAND (op1, 1);
19675 : : }
19676 : 184 : if (TREE_CODE (op1) == COND_EXPR)
19677 : : {
19678 : 46 : gcc_assert (rhs1 == NULL_TREE);
19679 : 46 : tree c = TREE_OPERAND (op1, 0);
19680 : 46 : if (TREE_CODE (c) == MODIFY_EXPR)
19681 : : {
19682 : 14 : r = RECUR (TREE_OPERAND (c, 0));
19683 : 14 : c = TREE_OPERAND (c, 1);
19684 : : }
19685 : 46 : gcc_assert (TREE_CODE (c) == EQ_EXPR);
19686 : 46 : rhs = RECUR (TREE_OPERAND (c, 1));
19687 : 46 : lhs = RECUR (TREE_OPERAND (op1, 2));
19688 : 46 : rhs1 = RECUR (TREE_OPERAND (op1, 1));
19689 : : }
19690 : : else
19691 : : {
19692 : 138 : lhs = RECUR (TREE_OPERAND (op1, 0));
19693 : 138 : rhs = RECUR (TREE_OPERAND (op1, 1));
19694 : : }
19695 : 184 : finish_omp_atomic (EXPR_LOCATION (t), OMP_ATOMIC, TREE_CODE (op1),
19696 : : lhs, rhs, NULL_TREE, NULL_TREE, rhs1, r,
19697 : 184 : tmp, OMP_ATOMIC_MEMORY_ORDER (t),
19698 : 184 : OMP_ATOMIC_WEAK (t));
19699 : : }
19700 : : else
19701 : : {
19702 : 416 : tree op1 = TREE_OPERAND (t, 1);
19703 : 416 : tree v = NULL_TREE, lhs, rhs = NULL_TREE, lhs1 = NULL_TREE;
19704 : 416 : tree rhs1 = NULL_TREE, r = NULL_TREE;
19705 : 416 : enum tree_code code = TREE_CODE (TREE_OPERAND (op1, 1));
19706 : 416 : enum tree_code opcode = NOP_EXPR;
19707 : 416 : if (code == OMP_ATOMIC_READ)
19708 : : {
19709 : 163 : v = RECUR (TREE_OPERAND (op1, 0));
19710 : 163 : lhs = RECUR (TREE_OPERAND (TREE_OPERAND (op1, 1), 0));
19711 : : }
19712 : 253 : else if (code == OMP_ATOMIC_CAPTURE_OLD
19713 : 253 : || code == OMP_ATOMIC_CAPTURE_NEW)
19714 : : {
19715 : 230 : tree op11 = TREE_OPERAND (TREE_OPERAND (op1, 1), 1);
19716 : 230 : v = RECUR (TREE_OPERAND (op1, 0));
19717 : 230 : lhs1 = RECUR (TREE_OPERAND (TREE_OPERAND (op1, 1), 0));
19718 : 230 : if (TREE_CODE (op11) == COMPOUND_EXPR)
19719 : : {
19720 : 91 : rhs1 = RECUR (TREE_OPERAND (op11, 0));
19721 : 91 : op11 = TREE_OPERAND (op11, 1);
19722 : : }
19723 : 230 : if (TREE_CODE (op11) == COND_EXPR)
19724 : : {
19725 : 78 : gcc_assert (rhs1 == NULL_TREE);
19726 : 78 : tree c = TREE_OPERAND (op11, 0);
19727 : 78 : if (TREE_CODE (c) == MODIFY_EXPR)
19728 : : {
19729 : 36 : r = RECUR (TREE_OPERAND (c, 0));
19730 : 36 : c = TREE_OPERAND (c, 1);
19731 : : }
19732 : 78 : gcc_assert (TREE_CODE (c) == EQ_EXPR);
19733 : 78 : rhs = RECUR (TREE_OPERAND (c, 1));
19734 : 78 : lhs = RECUR (TREE_OPERAND (op11, 2));
19735 : 78 : rhs1 = RECUR (TREE_OPERAND (op11, 1));
19736 : : }
19737 : : else
19738 : : {
19739 : 152 : lhs = RECUR (TREE_OPERAND (op11, 0));
19740 : 152 : rhs = RECUR (TREE_OPERAND (op11, 1));
19741 : : }
19742 : 230 : opcode = TREE_CODE (op11);
19743 : 230 : if (opcode == MODIFY_EXPR)
19744 : 11 : opcode = NOP_EXPR;
19745 : : }
19746 : : else
19747 : : {
19748 : 23 : code = OMP_ATOMIC;
19749 : 23 : lhs = RECUR (TREE_OPERAND (op1, 0));
19750 : 23 : rhs = RECUR (TREE_OPERAND (op1, 1));
19751 : : }
19752 : 416 : finish_omp_atomic (EXPR_LOCATION (t), code, opcode, lhs, rhs, v,
19753 : : lhs1, rhs1, r, tmp,
19754 : 416 : OMP_ATOMIC_MEMORY_ORDER (t), OMP_ATOMIC_WEAK (t));
19755 : : }
19756 : : break;
19757 : :
19758 : 80 : case TRANSACTION_EXPR:
19759 : 80 : {
19760 : 80 : int flags = 0;
19761 : 80 : flags |= (TRANSACTION_EXPR_OUTER (t) ? TM_STMT_ATTR_OUTER : 0);
19762 : 80 : flags |= (TRANSACTION_EXPR_RELAXED (t) ? TM_STMT_ATTR_RELAXED : 0);
19763 : :
19764 : 80 : if (TRANSACTION_EXPR_IS_STMT (t))
19765 : : {
19766 : 47 : tree body = TRANSACTION_EXPR_BODY (t);
19767 : 47 : tree noex = NULL_TREE;
19768 : 47 : if (TREE_CODE (body) == MUST_NOT_THROW_EXPR)
19769 : : {
19770 : 12 : noex = MUST_NOT_THROW_COND (body);
19771 : 12 : if (noex == NULL_TREE)
19772 : 3 : noex = boolean_true_node;
19773 : 12 : body = TREE_OPERAND (body, 0);
19774 : : }
19775 : 47 : stmt = begin_transaction_stmt (input_location, NULL, flags);
19776 : 47 : RECUR (body);
19777 : 47 : finish_transaction_stmt (stmt, NULL, flags, RECUR (noex));
19778 : : }
19779 : : else
19780 : : {
19781 : 33 : stmt = build_transaction_expr (EXPR_LOCATION (t),
19782 : 33 : RECUR (TRANSACTION_EXPR_BODY (t)),
19783 : : flags, NULL_TREE);
19784 : 33 : RETURN (stmt);
19785 : : }
19786 : : }
19787 : 47 : break;
19788 : :
19789 : 36 : case OMP_INTEROP:
19790 : 36 : tmp = tsubst_omp_clauses (OMP_INTEROP_CLAUSES (t), C_ORT_OMP_INTEROP,
19791 : : args, complain, in_decl);
19792 : 36 : t = copy_node (t);
19793 : 36 : OMP_INTEROP_CLAUSES (t) = tmp;
19794 : 36 : add_stmt (t);
19795 : 36 : break;
19796 : :
19797 : 21 : case MUST_NOT_THROW_EXPR:
19798 : 21 : {
19799 : 21 : tree op0 = RECUR (TREE_OPERAND (t, 0));
19800 : 21 : tree cond = RECUR (MUST_NOT_THROW_COND (t));
19801 : 21 : RETURN (build_must_not_throw_expr (op0, cond));
19802 : : }
19803 : :
19804 : 0 : case EXPR_PACK_EXPANSION:
19805 : 0 : error ("invalid use of pack expansion expression");
19806 : 0 : RETURN (error_mark_node);
19807 : :
19808 : 0 : case NONTYPE_ARGUMENT_PACK:
19809 : 0 : error ("use %<...%> to expand argument pack");
19810 : 0 : RETURN (error_mark_node);
19811 : :
19812 : 188191 : case COMPOUND_EXPR:
19813 : 188191 : tmp = RECUR (TREE_OPERAND (t, 0));
19814 : 188191 : if (tmp == NULL_TREE)
19815 : : /* If the first operand was a statement, we're done with it. */
19816 : 126312 : RETURN (RECUR (TREE_OPERAND (t, 1)));
19817 : 61879 : RETURN (build_x_compound_expr (EXPR_LOCATION (t), tmp,
19818 : : RECUR (TREE_OPERAND (t, 1)),
19819 : : templated_operator_saved_lookups (t),
19820 : : complain));
19821 : :
19822 : 218748 : case PREDICT_EXPR:
19823 : 218748 : RETURN (add_stmt (copy_node (t)));
19824 : :
19825 : 2833 : case ANNOTATE_EXPR:
19826 : 2833 : {
19827 : : /* Although ANNOTATE_EXPR is an expression, it can only appear in
19828 : : WHILE_COND, DO_COND or FOR_COND expressions, which are tsubsted
19829 : : using tsubst_stmt rather than tsubst_expr and can contain
19830 : : DECL_EXPRs. */
19831 : 2833 : tree op1 = RECUR (TREE_OPERAND (t, 0));
19832 : 2833 : tree op2 = tsubst_expr (TREE_OPERAND (t, 1), args, complain, in_decl);
19833 : 2833 : tree op3 = tsubst_expr (TREE_OPERAND (t, 2), args, complain, in_decl);
19834 : 2833 : if (TREE_CODE (op2) == INTEGER_CST
19835 : 2833 : && wi::to_widest (op2) == (int) annot_expr_unroll_kind)
19836 : 2821 : op3 = cp_check_pragma_unroll (EXPR_LOCATION (TREE_OPERAND (t, 2)),
19837 : : op3);
19838 : 2833 : RETURN (build3_loc (EXPR_LOCATION (t), ANNOTATE_EXPR,
19839 : : TREE_TYPE (op1), op1, op2, op3));
19840 : : }
19841 : :
19842 : 127258908 : default:
19843 : 127258908 : gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t)));
19844 : :
19845 : 127258908 : RETURN (tsubst_expr (t, args, complain, in_decl));
19846 : : }
19847 : :
19848 : 154210491 : RETURN (NULL_TREE);
19849 : 281879246 : out:
19850 : 281879246 : input_location = loc;
19851 : 281879246 : return r;
19852 : : #undef RECUR
19853 : : #undef RETURN
19854 : : }
19855 : :
19856 : : /* Instantiate the special body of the artificial DECL_OMP_DECLARE_REDUCTION
19857 : : function. For description of the body see comment above
19858 : : cp_parser_omp_declare_reduction_exprs. */
19859 : :
19860 : : static void
19861 : 101 : tsubst_omp_udr (tree t, tree args, tsubst_flags_t complain, tree in_decl)
19862 : : {
19863 : 101 : if (t == NULL_TREE || t == error_mark_node)
19864 : 0 : return;
19865 : :
19866 : 101 : gcc_assert (TREE_CODE (t) == STATEMENT_LIST && current_function_decl);
19867 : :
19868 : 101 : tree_stmt_iterator tsi;
19869 : 101 : int i;
19870 : 101 : tree stmts[7];
19871 : 101 : memset (stmts, 0, sizeof stmts);
19872 : 101 : for (i = 0, tsi = tsi_start (t);
19873 : 595 : i < 7 && !tsi_end_p (tsi);
19874 : 494 : i++, tsi_next (&tsi))
19875 : 494 : stmts[i] = tsi_stmt (tsi);
19876 : 101 : gcc_assert (tsi_end_p (tsi));
19877 : :
19878 : 101 : if (i >= 3)
19879 : : {
19880 : 101 : gcc_assert (TREE_CODE (stmts[0]) == DECL_EXPR
19881 : : && TREE_CODE (stmts[1]) == DECL_EXPR);
19882 : 101 : tree omp_out = tsubst (DECL_EXPR_DECL (stmts[0]),
19883 : : args, complain, in_decl);
19884 : 101 : tree omp_in = tsubst (DECL_EXPR_DECL (stmts[1]),
19885 : : args, complain, in_decl);
19886 : : /* tsubsting a local var_decl leaves DECL_CONTEXT null, as we
19887 : : expect to be pushing it. */
19888 : 101 : DECL_CONTEXT (omp_out) = current_function_decl;
19889 : 101 : DECL_CONTEXT (omp_in) = current_function_decl;
19890 : 101 : keep_next_level (true);
19891 : 101 : tree block = begin_omp_structured_block ();
19892 : 101 : tsubst_stmt (stmts[2], args, complain, in_decl);
19893 : 101 : block = finish_omp_structured_block (block);
19894 : 101 : block = maybe_cleanup_point_expr_void (block);
19895 : 101 : add_decl_expr (omp_out);
19896 : 101 : copy_warning (omp_out, DECL_EXPR_DECL (stmts[0]));
19897 : 101 : add_decl_expr (omp_in);
19898 : 101 : finish_expr_stmt (block);
19899 : : }
19900 : 101 : if (i >= 6)
19901 : : {
19902 : 54 : gcc_assert (TREE_CODE (stmts[3]) == DECL_EXPR
19903 : : && TREE_CODE (stmts[4]) == DECL_EXPR);
19904 : 54 : tree omp_priv = tsubst (DECL_EXPR_DECL (stmts[3]),
19905 : : args, complain, in_decl);
19906 : 54 : tree omp_orig = tsubst (DECL_EXPR_DECL (stmts[4]),
19907 : : args, complain, in_decl);
19908 : 54 : DECL_CONTEXT (omp_priv) = current_function_decl;
19909 : 54 : DECL_CONTEXT (omp_orig) = current_function_decl;
19910 : 54 : keep_next_level (true);
19911 : 54 : tree block = begin_omp_structured_block ();
19912 : 54 : tsubst_stmt (stmts[5], args, complain, in_decl);
19913 : 54 : block = finish_omp_structured_block (block);
19914 : 54 : block = maybe_cleanup_point_expr_void (block);
19915 : 54 : cp_walk_tree (&block, cp_remove_omp_priv_cleanup_stmt, omp_priv, NULL);
19916 : 54 : add_decl_expr (omp_priv);
19917 : 54 : add_decl_expr (omp_orig);
19918 : 54 : finish_expr_stmt (block);
19919 : 54 : if (i == 7)
19920 : 29 : add_decl_expr (omp_orig);
19921 : : }
19922 : : }
19923 : :
19924 : : /* T is a postfix-expression that is not being used in a function
19925 : : call. Return the substituted version of T. */
19926 : :
19927 : : static tree
19928 : 27491817 : tsubst_non_call_postfix_expression (tree t, tree args,
19929 : : tsubst_flags_t complain,
19930 : : tree in_decl)
19931 : : {
19932 : 27491817 : if (TREE_CODE (t) == SCOPE_REF)
19933 : 9385 : t = tsubst_qualified_id (t, args, complain, in_decl,
19934 : : /*done=*/false, /*address_p=*/false);
19935 : : else
19936 : 27482432 : t = tsubst_expr (t, args, complain, in_decl);
19937 : :
19938 : 27491817 : return t;
19939 : : }
19940 : :
19941 : : /* Subroutine of tsubst_lambda_expr: add the FIELD/INIT capture pair to the
19942 : : LAMBDA_EXPR_CAPTURE_LIST passed in LIST. Do deduction for a previously
19943 : : dependent init-capture. EXPLICIT_P is true if the original list had
19944 : : explicit captures. */
19945 : :
19946 : : static void
19947 : 288396 : prepend_one_capture (tree field, tree init, tree &list, bool explicit_p,
19948 : : tsubst_flags_t complain)
19949 : : {
19950 : 288396 : if (tree auto_node = type_uses_auto (TREE_TYPE (field)))
19951 : : {
19952 : 90 : tree type = NULL_TREE;
19953 : 90 : if (!init)
19954 : : {
19955 : 3 : if (complain & tf_error)
19956 : 3 : error ("empty initializer in lambda init-capture");
19957 : 3 : init = error_mark_node;
19958 : : }
19959 : 87 : else if (TREE_CODE (init) == TREE_LIST)
19960 : 0 : init = build_x_compound_expr_from_list (init, ELK_INIT, complain);
19961 : 90 : if (!type)
19962 : 90 : type = do_auto_deduction (TREE_TYPE (field), init, auto_node, complain);
19963 : 90 : TREE_TYPE (field) = type;
19964 : 90 : cp_apply_type_quals_to_decl (cp_type_quals (type), field);
19965 : : }
19966 : 288396 : list = tree_cons (field, init, list);
19967 : 288396 : LAMBDA_CAPTURE_EXPLICIT_P (list) = explicit_p;
19968 : 288396 : }
19969 : :
19970 : : /* T is a LAMBDA_EXPR. Generate a new LAMBDA_EXPR for the current
19971 : : instantiation context. Instantiating a pack expansion containing a lambda
19972 : : might result in multiple lambdas all based on the same lambda in the
19973 : : template. */
19974 : :
19975 : : tree
19976 : 154960 : tsubst_lambda_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl)
19977 : : {
19978 : 154960 : tree oldfn = lambda_function (t);
19979 : 154960 : in_decl = oldfn;
19980 : :
19981 : 154960 : args = add_extra_args (LAMBDA_EXPR_EXTRA_ARGS (t), args, complain, in_decl);
19982 : 154960 : if (processing_template_decl
19983 : 263 : && (!in_template_context || (complain & tf_partial)))
19984 : : {
19985 : : /* Defer templated substitution into a lambda-expr if we lost the
19986 : : necessary template context. This may happen for a lambda-expr
19987 : : used as a default template argument.
19988 : :
19989 : : Defer dependent substitution as well so that we don't prematurely
19990 : : lower the level of a deduced return type or any other auto or
19991 : : template parameter belonging to the lambda. */
19992 : 66 : t = copy_node (t);
19993 : 66 : LAMBDA_EXPR_EXTRA_ARGS (t) = NULL_TREE;
19994 : 66 : LAMBDA_EXPR_EXTRA_ARGS (t) = build_extra_args (t, args, complain);
19995 : 66 : return t;
19996 : : }
19997 : :
19998 : 154894 : tree r = build_lambda_expr ();
19999 : :
20000 : 154894 : LAMBDA_EXPR_LOCATION (r)
20001 : 154894 : = LAMBDA_EXPR_LOCATION (t);
20002 : 154894 : LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (r)
20003 : 154894 : = LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (t);
20004 : 154894 : if (tree ti = LAMBDA_EXPR_REGEN_INFO (t))
20005 : 458 : LAMBDA_EXPR_REGEN_INFO (r)
20006 : 229 : = build_template_info (t, add_to_template_args (TI_ARGS (ti),
20007 : : preserve_args (args)));
20008 : : else
20009 : 309330 : LAMBDA_EXPR_REGEN_INFO (r)
20010 : 154665 : = build_template_info (t, preserve_args (args));
20011 : :
20012 : 154894 : gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (t) == NULL_TREE
20013 : : && LAMBDA_EXPR_PENDING_PROXIES (t) == NULL);
20014 : :
20015 : 154894 : vec<tree,va_gc>* field_packs = NULL;
20016 : 154894 : unsigned name_independent_cnt = 0;
20017 : 443264 : for (tree cap = LAMBDA_EXPR_CAPTURE_LIST (t); cap;
20018 : 288370 : cap = TREE_CHAIN (cap))
20019 : : {
20020 : 288376 : tree ofield = TREE_PURPOSE (cap);
20021 : 288376 : tree init = TREE_VALUE (cap);
20022 : 288376 : if (PACK_EXPANSION_P (init))
20023 : 83 : init = tsubst_pack_expansion (init, args, complain, in_decl);
20024 : : else
20025 : 288293 : init = tsubst_expr (init, args, complain, in_decl);
20026 : :
20027 : 288376 : if (init == error_mark_node)
20028 : 6 : return error_mark_node;
20029 : :
20030 : 288370 : if (init && TREE_CODE (init) == TREE_LIST)
20031 : 6 : init = build_x_compound_expr_from_list (init, ELK_INIT, complain);
20032 : :
20033 : 288370 : if (!processing_template_decl
20034 : 288231 : && init && TREE_CODE (init) != TREE_VEC
20035 : 576524 : && variably_modified_type_p (TREE_TYPE (init), NULL_TREE))
20036 : : {
20037 : : /* For a VLA, simply tsubsting the field type won't work, we need to
20038 : : go through add_capture again. XXX do we want to do this for all
20039 : : captures? */
20040 : 9 : tree name = (get_identifier
20041 : : (IDENTIFIER_POINTER (DECL_NAME (ofield)) + 2));
20042 : 9 : tree ftype = TREE_TYPE (ofield);
20043 : 9 : bool by_ref = (TYPE_REF_P (ftype)
20044 : 9 : || (TREE_CODE (ftype) == DECLTYPE_TYPE
20045 : 0 : && DECLTYPE_FOR_REF_CAPTURE (ftype)));
20046 : 9 : add_capture (r, name, init, by_ref, !DECL_NORMAL_CAPTURE_P (ofield),
20047 : : &name_independent_cnt);
20048 : 9 : continue;
20049 : 9 : }
20050 : :
20051 : 288361 : if (PACK_EXPANSION_P (ofield))
20052 : 71 : ofield = PACK_EXPANSION_PATTERN (ofield);
20053 : 288361 : tree field = tsubst_decl (ofield, args, complain);
20054 : :
20055 : 288361 : if (DECL_PACK_P (ofield) && !DECL_NORMAL_CAPTURE_P (ofield))
20056 : : {
20057 : : /* Remember these for when we've pushed local_specializations. */
20058 : 32 : vec_safe_push (field_packs, ofield);
20059 : 32 : vec_safe_push (field_packs, field);
20060 : : }
20061 : :
20062 : 288361 : if (field == error_mark_node)
20063 : : return error_mark_node;
20064 : :
20065 : 288361 : if (TREE_CODE (field) == TREE_VEC)
20066 : : {
20067 : 74 : int len = TREE_VEC_LENGTH (field);
20068 : 74 : gcc_assert (TREE_CODE (init) == TREE_VEC
20069 : : && TREE_VEC_LENGTH (init) == len);
20070 : 183 : for (int i = 0; i < len; ++i)
20071 : 218 : prepend_one_capture (TREE_VEC_ELT (field, i),
20072 : 109 : TREE_VEC_ELT (init, i),
20073 : 109 : LAMBDA_EXPR_CAPTURE_LIST (r),
20074 : 109 : LAMBDA_CAPTURE_EXPLICIT_P (cap),
20075 : : complain);
20076 : : }
20077 : : else
20078 : : {
20079 : 576574 : prepend_one_capture (field, init, LAMBDA_EXPR_CAPTURE_LIST (r),
20080 : 288287 : LAMBDA_CAPTURE_EXPLICIT_P (cap), complain);
20081 : :
20082 : 288287 : if (id_equal (DECL_NAME (field), "__this"))
20083 : 28277 : LAMBDA_EXPR_THIS_CAPTURE (r) = field;
20084 : : }
20085 : : }
20086 : :
20087 : 154888 : tree type = begin_lambda_type (r);
20088 : 154888 : if (type == error_mark_node)
20089 : : {
20090 : 0 : gcc_checking_assert (!(complain & tf_error) || seen_error ());
20091 : 0 : return error_mark_node;
20092 : : }
20093 : :
20094 : 154888 : if (LAMBDA_EXPR_EXTRA_SCOPE (t))
20095 : 154467 : record_lambda_scope (r);
20096 : 421 : else if (TYPE_NAMESPACE_SCOPE_P (TREE_TYPE (t)))
20097 : : /* If we're pushed into another scope (PR105652), fix it. */
20098 : 636 : TYPE_CONTEXT (type) = DECL_CONTEXT (TYPE_NAME (type))
20099 : 636 : = TYPE_CONTEXT (TREE_TYPE (t));
20100 : 154888 : record_lambda_scope_discriminator (r);
20101 : :
20102 : : /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
20103 : 154888 : determine_visibility (TYPE_NAME (type));
20104 : :
20105 : 154888 : register_capture_members (LAMBDA_EXPR_CAPTURE_LIST (r));
20106 : :
20107 : 154888 : tree oldtmpl = (generic_lambda_fn_p (oldfn)
20108 : 154888 : ? DECL_TI_TEMPLATE (oldfn)
20109 : 172817 : : NULL_TREE);
20110 : :
20111 : 17929 : tree tparms = NULL_TREE;
20112 : 17929 : if (oldtmpl)
20113 : 17929 : tparms = tsubst_template_parms (DECL_TEMPLATE_PARMS (oldtmpl), args, complain);
20114 : :
20115 : 154888 : tree fntype = static_fn_type (oldfn);
20116 : :
20117 : 154888 : tree saved_ctp = current_template_parms;
20118 : 154888 : if (oldtmpl)
20119 : : {
20120 : 17929 : ++processing_template_decl;
20121 : 17929 : current_template_parms = tparms;
20122 : : }
20123 : 154888 : fntype = tsubst (fntype, args, complain, in_decl);
20124 : 154888 : if (oldtmpl)
20125 : : {
20126 : 17929 : current_template_parms = saved_ctp;
20127 : 17929 : --processing_template_decl;
20128 : : }
20129 : :
20130 : 154888 : if (fntype == error_mark_node)
20131 : : r = error_mark_node;
20132 : : else
20133 : : {
20134 : : /* The body of a lambda-expression is not a subexpression of the
20135 : : enclosing expression. Parms are to have DECL_CHAIN tsubsted,
20136 : : which would be skipped if cp_unevaluated_operand. */
20137 : 154876 : cp_evaluated ev;
20138 : :
20139 : : /* Fix the type of 'this'.
20140 : : For static and xobj member functions we use this to transport the
20141 : : lambda's closure type. It appears that in the regular case the
20142 : : object parameter is still pulled off, and then re-added again anyway.
20143 : : So perhaps we could do something better here? */
20144 : 154876 : fntype = build_memfn_type (fntype, type,
20145 : : type_memfn_quals (fntype),
20146 : : type_memfn_rqual (fntype));
20147 : 154876 : tree inst = (oldtmpl
20148 : 154876 : ? tsubst_template_decl (oldtmpl, args, complain,
20149 : : fntype, tparms)
20150 : 136947 : : tsubst_function_decl (oldfn, args, complain, fntype));
20151 : 154876 : if (inst == error_mark_node)
20152 : : {
20153 : 0 : r = error_mark_node;
20154 : 0 : goto out;
20155 : : }
20156 : 154876 : finish_member_declaration (inst);
20157 : 154876 : record_lambda_scope_sig_discriminator (r, inst);
20158 : :
20159 : 172805 : tree fn = oldtmpl ? DECL_TEMPLATE_RESULT (inst) : inst;
20160 : :
20161 : : /* Let finish_function set this. */
20162 : 154876 : DECL_DECLARED_CONSTEXPR_P (fn) = false;
20163 : :
20164 : 154876 : bool nested = cfun;
20165 : 154876 : if (nested)
20166 : 154328 : push_function_context ();
20167 : : else
20168 : : /* Still increment function_depth so that we don't GC in the
20169 : : middle of an expression. */
20170 : 548 : ++function_depth;
20171 : :
20172 : 154876 : local_specialization_stack s (lss_copy);
20173 : :
20174 : 154876 : bool save_in_consteval_if_p = in_consteval_if_p;
20175 : 154876 : in_consteval_if_p = false;
20176 : :
20177 : 154876 : tree body = start_lambda_function (fn, r);
20178 : :
20179 : : /* Now record them for lookup_init_capture_pack. */
20180 : 154876 : int fplen = vec_safe_length (field_packs);
20181 : 154908 : for (int i = 0; i < fplen; )
20182 : : {
20183 : 32 : tree pack = (*field_packs)[i++];
20184 : 32 : tree inst = (*field_packs)[i++];
20185 : 32 : register_local_specialization (inst, pack);
20186 : : }
20187 : 154876 : release_tree_vector (field_packs);
20188 : :
20189 : 154876 : register_parameter_specializations (oldfn, fn);
20190 : :
20191 : 154876 : if (oldtmpl)
20192 : : {
20193 : : /* We might not partially instantiate some parts of the function, so
20194 : : copy these flags from the original template. */
20195 : 17929 : language_function *ol = DECL_STRUCT_FUNCTION (oldfn)->language;
20196 : 17929 : current_function_returns_value = ol->returns_value;
20197 : 17929 : current_function_returns_null = ol->returns_null;
20198 : 17929 : current_function_returns_abnormally = ol->returns_abnormally;
20199 : 17929 : current_function_infinite_loop = ol->infinite_loop;
20200 : : }
20201 : :
20202 : : /* [temp.deduct] A lambda-expression appearing in a function type or a
20203 : : template parameter is not considered part of the immediate context for
20204 : : the purposes of template argument deduction. */
20205 : 154876 : complain = tf_warning_or_error;
20206 : :
20207 : 154876 : tree saved = DECL_SAVED_TREE (oldfn);
20208 : 154876 : if (TREE_CODE (saved) == BIND_EXPR && BIND_EXPR_BODY_BLOCK (saved))
20209 : : /* We already have a body block from start_lambda_function, we don't
20210 : : need another to confuse NRV (91217). */
20211 : 154876 : saved = BIND_EXPR_BODY (saved);
20212 : :
20213 : 154876 : tsubst_stmt (saved, args, complain, r);
20214 : :
20215 : 154876 : finish_lambda_function (body);
20216 : :
20217 : 154876 : in_consteval_if_p = save_in_consteval_if_p;
20218 : :
20219 : 154876 : if (nested)
20220 : 154328 : pop_function_context ();
20221 : : else
20222 : 548 : --function_depth;
20223 : :
20224 : : /* The capture list was built up in reverse order; fix that now. */
20225 : 154876 : LAMBDA_EXPR_CAPTURE_LIST (r)
20226 : 154876 : = nreverse (LAMBDA_EXPR_CAPTURE_LIST (r));
20227 : :
20228 : 154876 : LAMBDA_EXPR_THIS_CAPTURE (r) = NULL_TREE;
20229 : :
20230 : 154876 : maybe_add_lambda_conv_op (type);
20231 : 154876 : }
20232 : :
20233 : 154888 : out:
20234 : 154888 : finish_struct (type, /*attr*/NULL_TREE);
20235 : :
20236 : 154888 : insert_pending_capture_proxies ();
20237 : :
20238 : 154888 : return r;
20239 : : }
20240 : :
20241 : : /* Subroutine of maybe_fold_fn_template_args. */
20242 : :
20243 : : static bool
20244 : 18113295 : fold_targs_r (tree targs, tsubst_flags_t complain)
20245 : : {
20246 : 18113295 : int len = TREE_VEC_LENGTH (targs);
20247 : 45105327 : for (int i = 0; i < len; ++i)
20248 : : {
20249 : 26992035 : tree &elt = TREE_VEC_ELT (targs, i);
20250 : 26992035 : if (!elt || TYPE_P (elt)
20251 : 438320 : || TREE_CODE (elt) == TEMPLATE_DECL)
20252 : 26553919 : continue;
20253 : 438116 : if (TREE_CODE (elt) == NONTYPE_ARGUMENT_PACK)
20254 : : {
20255 : 0 : if (!fold_targs_r (ARGUMENT_PACK_ARGS (elt), complain))
20256 : : return false;
20257 : : }
20258 : 438116 : else if (/* We can only safely preevaluate scalar prvalues. */
20259 : 876226 : SCALAR_TYPE_P (TREE_TYPE (elt))
20260 : 437908 : && !glvalue_p (elt)
20261 : 873487 : && !TREE_CONSTANT (elt))
20262 : : {
20263 : 2828 : elt = cxx_constant_value (elt, complain);
20264 : 2828 : if (elt == error_mark_node)
20265 : : return false;
20266 : : }
20267 : : }
20268 : :
20269 : : return true;
20270 : : }
20271 : :
20272 : : /* Try to do constant evaluation of any explicit template arguments in FN
20273 : : before overload resolution, to get any errors only once. Return true iff
20274 : : we didn't have any problems folding. */
20275 : :
20276 : : static bool
20277 : 75023849 : maybe_fold_fn_template_args (tree fn, tsubst_flags_t complain)
20278 : : {
20279 : 75023849 : if (processing_template_decl || fn == NULL_TREE)
20280 : : return true;
20281 : 62682970 : if (fn == error_mark_node)
20282 : : return false;
20283 : 62603913 : if (TREE_CODE (fn) == OFFSET_REF
20284 : 62518493 : || TREE_CODE (fn) == COMPONENT_REF)
20285 : 11875004 : fn = TREE_OPERAND (fn, 1);
20286 : 62603913 : if (BASELINK_P (fn))
20287 : 21764145 : fn = BASELINK_FUNCTIONS (fn);
20288 : 62603913 : if (TREE_CODE (fn) != TEMPLATE_ID_EXPR)
20289 : : return true;
20290 : 18113301 : tree targs = TREE_OPERAND (fn, 1);
20291 : 18113301 : if (targs == NULL_TREE)
20292 : : return true;
20293 : 18113301 : if (targs == error_mark_node)
20294 : : return false;
20295 : 18113295 : return fold_targs_r (targs, complain);
20296 : : }
20297 : :
20298 : : /* Helper function for tsubst_expr CALL_EXPR and ARRAY_REF handling. */
20299 : :
20300 : : static void
20301 : 75080432 : tsubst_call_args (tree t, tree args, tsubst_flags_t complain,
20302 : : tree in_decl, releasing_vec &call_args)
20303 : : {
20304 : 75080432 : unsigned int nargs = call_expr_nargs (t);
20305 : 131051547 : for (unsigned int i = 0; i < nargs; ++i)
20306 : : {
20307 : 55971118 : tree arg = CALL_EXPR_ARG (t, i);
20308 : :
20309 : 55971118 : if (!PACK_EXPANSION_P (arg))
20310 : 55308995 : vec_safe_push (call_args, tsubst_expr (arg, args, complain, in_decl));
20311 : : else
20312 : : {
20313 : : /* Expand the pack expansion and push each entry onto CALL_ARGS. */
20314 : 662123 : arg = tsubst_pack_expansion (arg, args, complain, in_decl);
20315 : 662123 : if (TREE_CODE (arg) == TREE_VEC)
20316 : : {
20317 : 554283 : unsigned int len, j;
20318 : :
20319 : 554283 : len = TREE_VEC_LENGTH (arg);
20320 : 956949 : for (j = 0; j < len; ++j)
20321 : : {
20322 : 402666 : tree value = TREE_VEC_ELT (arg, j);
20323 : 402666 : if (value != NULL_TREE)
20324 : 402666 : value = convert_from_reference (value);
20325 : 402666 : vec_safe_push (call_args, value);
20326 : : }
20327 : : }
20328 : : else
20329 : : /* A partial substitution. Add one entry. */
20330 : 107840 : vec_safe_push (call_args, arg);
20331 : : }
20332 : : }
20333 : 75080429 : }
20334 : :
20335 : : /* Like tsubst but deals with expressions and performs semantic
20336 : : analysis. */
20337 : :
20338 : : tree
20339 : 1287913544 : tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl)
20340 : : {
20341 : : #define RETURN(EXP) do { retval = (EXP); goto out; } while(0)
20342 : : #define RECUR(NODE) \
20343 : : tsubst_expr (NODE, args, complain, in_decl)
20344 : :
20345 : 1287913544 : tree retval, op1;
20346 : 1287913544 : location_t save_loc;
20347 : :
20348 : 1287913544 : if (t == NULL_TREE || t == error_mark_node)
20349 : : return t;
20350 : :
20351 : 1285477332 : save_loc = input_location;
20352 : 1285477332 : if (location_t eloc = cp_expr_location (t))
20353 : 532383345 : input_location = eloc;
20354 : :
20355 : : /* N3276 decltype magic only applies to calls at the top level or on the
20356 : : right side of a comma. */
20357 : 1285477332 : tsubst_flags_t decltype_flag = (complain & tf_decltype);
20358 : 1285477332 : complain &= ~tf_decltype;
20359 : :
20360 : : /* This flag only applies to id-expressions at the top level, and
20361 : : controls resolution thereof. */
20362 : 1285477332 : tsubst_flags_t no_name_lookup_flag = (complain & tf_no_name_lookup);
20363 : 1285477332 : complain &= ~tf_no_name_lookup;
20364 : :
20365 : 1285477332 : if (!no_name_lookup_flag)
20366 : 1075045301 : if (tree d = maybe_dependent_member_ref (t, args, complain, in_decl))
20367 : : return d;
20368 : :
20369 : 1285476855 : switch (TREE_CODE (t))
20370 : : {
20371 : 142335 : case USING_DECL:
20372 : 142335 : t = DECL_NAME (t);
20373 : : /* Fall through. */
20374 : 198097995 : case IDENTIFIER_NODE:
20375 : 198097995 : {
20376 : 198097995 : tree decl;
20377 : 198097995 : cp_id_kind idk;
20378 : 198097995 : const char *error_msg;
20379 : :
20380 : 198097995 : if (IDENTIFIER_CONV_OP_P (t))
20381 : : {
20382 : 1430 : tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
20383 : 1430 : t = make_conv_op_name (new_type);
20384 : : }
20385 : :
20386 : 198097995 : if (no_name_lookup_flag)
20387 : 197924407 : RETURN (t);
20388 : :
20389 : : /* Look up the name. */
20390 : 173588 : decl = lookup_name (t);
20391 : :
20392 : : /* By convention, expressions use ERROR_MARK_NODE to indicate
20393 : : failure, not NULL_TREE. */
20394 : 173588 : if (decl == NULL_TREE)
20395 : 45 : decl = error_mark_node;
20396 : :
20397 : 173588 : decl = finish_id_expression (t, decl, NULL_TREE,
20398 : : &idk,
20399 : : /*i_c_e_p=*/false,
20400 : : /*allow_i_c_e_p=*/true,
20401 : : /*non_i_c_e_p=*/nullptr,
20402 : : /*template_p=*/false,
20403 : : /*done=*/true,
20404 : : /*address_p=*/false,
20405 : : /*template_arg_p=*/false,
20406 : : &error_msg,
20407 : : input_location);
20408 : 173588 : if (error_msg)
20409 : 0 : error (error_msg);
20410 : 173588 : if (identifier_p (decl))
20411 : : {
20412 : 45 : if (complain & tf_error)
20413 : 42 : unqualified_name_lookup_error (decl);
20414 : 45 : decl = error_mark_node;
20415 : : }
20416 : 198097995 : RETURN (decl);
20417 : : }
20418 : :
20419 : 27874709 : case TEMPLATE_ID_EXPR:
20420 : 27874709 : {
20421 : 27874709 : tree object;
20422 : 27874709 : tree templ = TREE_OPERAND (t, 0);
20423 : 27874709 : tree targs = TREE_OPERAND (t, 1);
20424 : :
20425 : 27874709 : if (no_name_lookup_flag)
20426 : 4952133 : templ = tsubst_name (templ, args, complain, in_decl);
20427 : : else
20428 : 22922576 : templ = tsubst_expr (templ, args, complain, in_decl);
20429 : :
20430 : 27874709 : if (targs)
20431 : 27874709 : targs = tsubst_template_args (targs, args, complain, in_decl);
20432 : 27874709 : if (targs == error_mark_node)
20433 : 206 : RETURN (error_mark_node);
20434 : :
20435 : 27874503 : if (TREE_CODE (templ) == SCOPE_REF)
20436 : : {
20437 : 56 : tree name = TREE_OPERAND (templ, 1);
20438 : 56 : tree tid = lookup_template_function (name, targs);
20439 : 56 : TREE_OPERAND (templ, 1) = tid;
20440 : 56 : RETURN (templ);
20441 : : }
20442 : :
20443 : 35510384 : if (concept_definition_p (templ))
20444 : : {
20445 : 817164 : tree check = build_concept_check (templ, targs, complain);
20446 : 817164 : if (check == error_mark_node)
20447 : : RETURN (error_mark_node);
20448 : 27057283 : RETURN (check);
20449 : : }
20450 : :
20451 : 27057283 : if (variable_template_p (templ))
20452 : : {
20453 : 6818773 : if (no_name_lookup_flag)
20454 : 9 : RETURN (lookup_template_variable (templ, targs, complain));
20455 : :
20456 : 6818764 : tree r = lookup_and_finish_template_variable (templ, targs,
20457 : : complain);
20458 : 6818764 : r = convert_from_reference (r);
20459 : 6818764 : r = maybe_wrap_with_location (r, EXPR_LOCATION (t));
20460 : 6818764 : RETURN (r);
20461 : : }
20462 : :
20463 : 20238510 : if (TREE_CODE (templ) == COMPONENT_REF)
20464 : : {
20465 : 0 : object = TREE_OPERAND (templ, 0);
20466 : 0 : templ = TREE_OPERAND (templ, 1);
20467 : : }
20468 : : else
20469 : : object = NULL_TREE;
20470 : :
20471 : 20238510 : if (function_contains_tu_local_entity (templ))
20472 : 9 : RETURN (error_mark_node);
20473 : :
20474 : 20238501 : tree tid = lookup_template_function (templ, targs);
20475 : 20238501 : protected_set_expr_location (tid, EXPR_LOCATION (t));
20476 : :
20477 : 20238501 : if (object)
20478 : 0 : RETURN (build3 (COMPONENT_REF, TREE_TYPE (tid),
20479 : : object, tid, NULL_TREE));
20480 : 20238501 : else if (no_name_lookup_flag)
20481 : 4952088 : RETURN (tid);
20482 : 15286413 : else if (identifier_p (templ))
20483 : : {
20484 : : /* C++20 P0846: we can encounter an IDENTIFIER_NODE here when
20485 : : name lookup found nothing when parsing the template name. */
20486 : 0 : gcc_assert (cxx_dialect >= cxx20 || seen_error ());
20487 : 0 : RETURN (tid);
20488 : : }
20489 : : else
20490 : 15286413 : RETURN (baselink_for_fns (tid));
20491 : : }
20492 : :
20493 : 30908020 : case INDIRECT_REF:
20494 : 30908020 : {
20495 : 30908020 : tree r = RECUR (TREE_OPERAND (t, 0));
20496 : :
20497 : 30908020 : if (REFERENCE_REF_P (t))
20498 : : {
20499 : : /* A type conversion to reference type will be enclosed in
20500 : : such an indirect ref, but the substitution of the cast
20501 : : will have also added such an indirect ref. */
20502 : 17571180 : r = convert_from_reference (r);
20503 : : }
20504 : : else
20505 : 13336840 : r = build_x_indirect_ref (input_location, r, RO_UNARY_STAR,
20506 : : templated_operator_saved_lookups (t),
20507 : : complain|decltype_flag);
20508 : :
20509 : 30908020 : if (REF_PARENTHESIZED_P (t))
20510 : 287 : r = force_paren_expr (r);
20511 : :
20512 : 30908020 : RETURN (r);
20513 : : }
20514 : :
20515 : 9 : case MEM_REF:
20516 : 9 : {
20517 : 9 : tree op0 = RECUR (TREE_OPERAND (t, 0));
20518 : 9 : tree op1 = RECUR (TREE_OPERAND (t, 0));
20519 : 9 : tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
20520 : 9 : RETURN (build2_loc (EXPR_LOCATION (t), MEM_REF, new_type, op0, op1));
20521 : : }
20522 : :
20523 : 12866671 : case NOP_EXPR:
20524 : 12866671 : {
20525 : 12866671 : tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
20526 : 12866671 : tree op0 = RECUR (TREE_OPERAND (t, 0));
20527 : 12866668 : RETURN (build_nop (type, op0));
20528 : : }
20529 : :
20530 : 20479914 : case IMPLICIT_CONV_EXPR:
20531 : 20479914 : {
20532 : 20479914 : tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
20533 : 20479914 : if (type == error_mark_node)
20534 : 3 : RETURN (error_mark_node);
20535 : 20479911 : tree expr = RECUR (TREE_OPERAND (t, 0));
20536 : 20479911 : if (dependent_type_p (type) || type_dependent_expression_p (expr))
20537 : : {
20538 : 4637540 : retval = copy_node (t);
20539 : 4637540 : TREE_TYPE (retval) = type;
20540 : 4637540 : TREE_OPERAND (retval, 0) = expr;
20541 : 4637540 : RETURN (retval);
20542 : : }
20543 : 15842371 : if (IMPLICIT_CONV_EXPR_NONTYPE_ARG (t))
20544 : : {
20545 : 14922184 : tree r = convert_nontype_argument (type, expr, complain);
20546 : 14922184 : if (r == NULL_TREE)
20547 : 37 : r = error_mark_node;
20548 : 14922184 : RETURN (r);
20549 : : }
20550 : 920187 : int flags = LOOKUP_IMPLICIT;
20551 : 920187 : if (IMPLICIT_CONV_EXPR_DIRECT_INIT (t))
20552 : 163453 : flags = LOOKUP_NORMAL;
20553 : 920187 : if (IMPLICIT_CONV_EXPR_BRACED_INIT (t))
20554 : 5202 : flags |= LOOKUP_NO_NARROWING;
20555 : 920187 : RETURN (perform_implicit_conversion_flags (type, expr, complain,
20556 : : flags));
20557 : : }
20558 : :
20559 : 10067 : case CONVERT_EXPR:
20560 : 10067 : {
20561 : 10067 : tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
20562 : 10067 : tree op0 = RECUR (TREE_OPERAND (t, 0));
20563 : 10067 : if (op0 == error_mark_node)
20564 : 24 : RETURN (error_mark_node);
20565 : 10043 : RETURN (build1 (CONVERT_EXPR, type, op0));
20566 : : }
20567 : :
20568 : 29371652 : case CAST_EXPR:
20569 : 29371652 : case REINTERPRET_CAST_EXPR:
20570 : 29371652 : case CONST_CAST_EXPR:
20571 : 29371652 : case DYNAMIC_CAST_EXPR:
20572 : 29371652 : case STATIC_CAST_EXPR:
20573 : 29371652 : {
20574 : 29371652 : tree type;
20575 : 29371652 : tree op, r = NULL_TREE;
20576 : :
20577 : 29371652 : tsubst_flags_t tcomplain = complain;
20578 : 29371652 : if (TREE_CODE (t) == CAST_EXPR)
20579 : 26025119 : tcomplain |= tf_tst_ok;
20580 : 29371652 : type = tsubst (TREE_TYPE (t), args, tcomplain, in_decl);
20581 : :
20582 : 29371652 : op = RECUR (TREE_OPERAND (t, 0));
20583 : :
20584 : 29371652 : warning_sentinel s(warn_useless_cast);
20585 : 29371652 : warning_sentinel s2(warn_ignored_qualifiers);
20586 : 29371652 : warning_sentinel s3(warn_int_in_bool_context);
20587 : 29371652 : switch (TREE_CODE (t))
20588 : : {
20589 : 26025119 : case CAST_EXPR:
20590 : 26025119 : r = build_functional_cast (input_location, type, op, complain);
20591 : 26025119 : break;
20592 : 49647 : case REINTERPRET_CAST_EXPR:
20593 : 49647 : r = build_reinterpret_cast (input_location, type, op, complain);
20594 : 49647 : break;
20595 : 108048 : case CONST_CAST_EXPR:
20596 : 108048 : r = build_const_cast (input_location, type, op, complain);
20597 : 108048 : break;
20598 : 7117 : case DYNAMIC_CAST_EXPR:
20599 : 7117 : r = build_dynamic_cast (input_location, type, op, complain);
20600 : 7117 : break;
20601 : 3181721 : case STATIC_CAST_EXPR:
20602 : 3181721 : r = build_static_cast (input_location, type, op, complain);
20603 : 3181721 : if (IMPLICIT_RVALUE_P (t))
20604 : 0 : set_implicit_rvalue_p (r);
20605 : : break;
20606 : 0 : default:
20607 : 0 : gcc_unreachable ();
20608 : : }
20609 : :
20610 : 29371649 : RETURN (r);
20611 : 29371649 : }
20612 : :
20613 : 259 : case BIT_CAST_EXPR:
20614 : 259 : {
20615 : 259 : tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
20616 : 259 : tree op0 = RECUR (TREE_OPERAND (t, 0));
20617 : 259 : RETURN (cp_build_bit_cast (EXPR_LOCATION (t), type, op0, complain));
20618 : : }
20619 : :
20620 : 455600 : case POSTDECREMENT_EXPR:
20621 : 455600 : case POSTINCREMENT_EXPR:
20622 : 455600 : op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
20623 : : args, complain, in_decl);
20624 : 455600 : RETURN (build_x_unary_op (input_location, TREE_CODE (t), op1,
20625 : : templated_operator_saved_lookups (t),
20626 : : complain|decltype_flag));
20627 : :
20628 : 378055 : case BIT_NOT_EXPR:
20629 : 378055 : if (identifier_p (TREE_OPERAND (t, 0)))
20630 : : {
20631 : 23 : gcc_checking_assert (no_name_lookup_flag);
20632 : 23 : RETURN (t);
20633 : : }
20634 : 378032 : else if (TYPE_P (TREE_OPERAND (t, 0)))
20635 : : {
20636 : 178711 : gcc_checking_assert (no_name_lookup_flag);
20637 : 178711 : tree op0 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
20638 : 178711 : RETURN (build_min_nt_loc (EXPR_LOCATION (t), BIT_NOT_EXPR, op0));
20639 : : }
20640 : : /* Fall through. */
20641 : 14413831 : case PREDECREMENT_EXPR:
20642 : 14413831 : case PREINCREMENT_EXPR:
20643 : 14413831 : case NEGATE_EXPR:
20644 : 14413831 : case ABS_EXPR:
20645 : 14413831 : case TRUTH_NOT_EXPR:
20646 : 14413831 : case UNARY_PLUS_EXPR: /* Unary + */
20647 : 14413831 : case REALPART_EXPR:
20648 : 14413831 : case IMAGPART_EXPR:
20649 : 14413831 : RETURN (build_x_unary_op (input_location, TREE_CODE (t),
20650 : : RECUR (TREE_OPERAND (t, 0)),
20651 : : templated_operator_saved_lookups (t),
20652 : : complain|decltype_flag));
20653 : :
20654 : 4033 : case EXCESS_PRECISION_EXPR:
20655 : 4033 : {
20656 : 4033 : tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
20657 : 4033 : tree op0 = RECUR (TREE_OPERAND (t, 0));
20658 : 4033 : if (TREE_CODE (op0) == EXCESS_PRECISION_EXPR)
20659 : 0 : RETURN (op0);
20660 : 4033 : RETURN (build1_loc (EXPR_LOCATION (t), EXCESS_PRECISION_EXPR,
20661 : : type, op0));
20662 : : }
20663 : :
20664 : 0 : case FIX_TRUNC_EXPR:
20665 : : /* convert_like should have created an IMPLICIT_CONV_EXPR. */
20666 : 0 : gcc_unreachable ();
20667 : :
20668 : 914160 : case ADDR_EXPR:
20669 : 914160 : op1 = TREE_OPERAND (t, 0);
20670 : 914160 : if (TREE_CODE (op1) == LABEL_DECL)
20671 : 31 : RETURN (finish_label_address_expr (DECL_NAME (op1),
20672 : : EXPR_LOCATION (op1)));
20673 : 914129 : if (TREE_CODE (op1) == SCOPE_REF)
20674 : 74449 : op1 = tsubst_qualified_id (op1, args, complain, in_decl,
20675 : : /*done=*/true, /*address_p=*/true);
20676 : : else
20677 : 839680 : op1 = tsubst_non_call_postfix_expression (op1, args, complain,
20678 : : in_decl);
20679 : 914129 : RETURN (build_x_unary_op (input_location, ADDR_EXPR, op1,
20680 : : templated_operator_saved_lookups (t),
20681 : : complain|decltype_flag));
20682 : :
20683 : 66536935 : case PLUS_EXPR:
20684 : 66536935 : case MINUS_EXPR:
20685 : 66536935 : case MULT_EXPR:
20686 : 66536935 : case TRUNC_DIV_EXPR:
20687 : 66536935 : case CEIL_DIV_EXPR:
20688 : 66536935 : case FLOOR_DIV_EXPR:
20689 : 66536935 : case ROUND_DIV_EXPR:
20690 : 66536935 : case EXACT_DIV_EXPR:
20691 : 66536935 : case BIT_AND_EXPR:
20692 : 66536935 : case BIT_IOR_EXPR:
20693 : 66536935 : case BIT_XOR_EXPR:
20694 : 66536935 : case TRUNC_MOD_EXPR:
20695 : 66536935 : case FLOOR_MOD_EXPR:
20696 : 66536935 : case TRUTH_ANDIF_EXPR:
20697 : 66536935 : case TRUTH_ORIF_EXPR:
20698 : 66536935 : case TRUTH_AND_EXPR:
20699 : 66536935 : case TRUTH_OR_EXPR:
20700 : 66536935 : case RSHIFT_EXPR:
20701 : 66536935 : case LSHIFT_EXPR:
20702 : 66536935 : case EQ_EXPR:
20703 : 66536935 : case NE_EXPR:
20704 : 66536935 : case MAX_EXPR:
20705 : 66536935 : case MIN_EXPR:
20706 : 66536935 : case LE_EXPR:
20707 : 66536935 : case GE_EXPR:
20708 : 66536935 : case LT_EXPR:
20709 : 66536935 : case GT_EXPR:
20710 : 66536935 : case SPACESHIP_EXPR:
20711 : 66536935 : case MEMBER_REF:
20712 : 66536935 : case DOTSTAR_EXPR:
20713 : 66536935 : {
20714 : : /* If either OP0 or OP1 was value- or type-dependent, suppress
20715 : : warnings that depend on the range of the types involved. */
20716 : 66536935 : tree op0 = TREE_OPERAND (t, 0);
20717 : 66536935 : tree op1 = TREE_OPERAND (t, 1);
20718 : 66536935 : const bool was_dep = (dependent_operand_p (op0)
20719 : 66536935 : || dependent_operand_p (op1));
20720 : 66536935 : op0 = RECUR (op0);
20721 : 66536935 : op1 = RECUR (op1);
20722 : :
20723 : 66536890 : warning_sentinel s1(warn_type_limits, was_dep);
20724 : 66536890 : warning_sentinel s2(warn_div_by_zero, was_dep);
20725 : 66536890 : warning_sentinel s3(warn_logical_op, was_dep);
20726 : 66536890 : warning_sentinel s4(warn_tautological_compare, was_dep);
20727 : 66536890 : warning_sentinel s5(warn_address, was_dep);
20728 : :
20729 : 66536890 : tree r = build_x_binary_op
20730 : 255550356 : (input_location, TREE_CODE (t),
20731 : : op0,
20732 : 66536890 : (warning_suppressed_p (TREE_OPERAND (t, 0))
20733 : : ? ERROR_MARK
20734 : 55939686 : : TREE_CODE (TREE_OPERAND (t, 0))),
20735 : : op1,
20736 : 66536890 : (warning_suppressed_p (TREE_OPERAND (t, 1))
20737 : : ? ERROR_MARK
20738 : 55714799 : : TREE_CODE (TREE_OPERAND (t, 1))),
20739 : : templated_operator_saved_lookups (t),
20740 : : /*overload=*/NULL,
20741 : : complain|decltype_flag);
20742 : 66536860 : if (EXPR_P (r))
20743 : 66511679 : copy_warning (r, t);
20744 : :
20745 : 66536860 : RETURN (r);
20746 : 66536860 : }
20747 : :
20748 : 6 : case POINTER_PLUS_EXPR:
20749 : 6 : {
20750 : 6 : tree op0 = RECUR (TREE_OPERAND (t, 0));
20751 : 6 : if (op0 == error_mark_node)
20752 : 0 : RETURN (error_mark_node);
20753 : 6 : tree op1 = RECUR (TREE_OPERAND (t, 1));
20754 : 6 : if (op1 == error_mark_node)
20755 : 0 : RETURN (error_mark_node);
20756 : 6 : RETURN (fold_build_pointer_plus (op0, op1));
20757 : : }
20758 : :
20759 : 52583818 : case SCOPE_REF:
20760 : 52583818 : if (no_name_lookup_flag)
20761 : : {
20762 : 757 : tree op0 = tsubst_scope (TREE_OPERAND (t, 0), args, complain, in_decl);
20763 : 757 : tree op1 = tsubst_name (TREE_OPERAND (t, 1), args, complain, in_decl);
20764 : 757 : RETURN (build_qualified_name (/*type=*/NULL_TREE, op0, op1,
20765 : : QUALIFIED_NAME_IS_TEMPLATE (t)));
20766 : : }
20767 : : else
20768 : 52583061 : RETURN (tsubst_qualified_id (t, args, complain, in_decl, /*done=*/true,
20769 : : /*address_p=*/false));
20770 : :
20771 : 10027392 : case BASELINK:
20772 : 10027392 : RETURN (tsubst_baselink (t, current_nonlambda_class_type (),
20773 : : args, complain, in_decl));
20774 : :
20775 : 1715997 : case ARRAY_REF:
20776 : 1715997 : op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
20777 : : args, complain, in_decl);
20778 : 1715997 : if (TREE_CODE (TREE_OPERAND (t, 1)) == CALL_EXPR
20779 : 1715997 : && (CALL_EXPR_FN (TREE_OPERAND (t, 1))
20780 : 2070 : == ovl_op_identifier (ARRAY_REF)))
20781 : : {
20782 : 106 : tree c = TREE_OPERAND (t, 1);
20783 : 106 : releasing_vec index_exp_list;
20784 : 106 : tsubst_call_args (c, args, complain, in_decl, index_exp_list);
20785 : :
20786 : 106 : tree r;
20787 : 106 : if (vec_safe_length (index_exp_list) == 1
20788 : 119 : && !PACK_EXPANSION_P (index_exp_list[0]))
20789 : 13 : r = grok_array_decl (EXPR_LOCATION (t), op1,
20790 : 13 : index_exp_list[0], NULL,
20791 : : complain | decltype_flag);
20792 : : else
20793 : 93 : r = grok_array_decl (EXPR_LOCATION (t), op1,
20794 : : NULL_TREE, &index_exp_list,
20795 : : complain | decltype_flag);
20796 : 106 : RETURN (r);
20797 : 106 : }
20798 : 1715891 : RETURN (build_x_array_ref (EXPR_LOCATION (t), op1,
20799 : : RECUR (TREE_OPERAND (t, 1)),
20800 : : complain|decltype_flag));
20801 : :
20802 : 30 : case OMP_ARRAY_SECTION:
20803 : 30 : {
20804 : 30 : tree op0 = RECUR (TREE_OPERAND (t, 0));
20805 : 30 : tree op1 = NULL_TREE, op2 = NULL_TREE;
20806 : 30 : if (op0 == error_mark_node)
20807 : 0 : RETURN (error_mark_node);
20808 : 30 : if (TREE_OPERAND (t, 1))
20809 : : {
20810 : 27 : op1 = RECUR (TREE_OPERAND (t, 1));
20811 : 27 : if (op1 == error_mark_node)
20812 : 0 : RETURN (error_mark_node);
20813 : : }
20814 : 30 : if (TREE_OPERAND (t, 2))
20815 : : {
20816 : 30 : op2 = RECUR (TREE_OPERAND (t, 2));
20817 : 30 : if (op2 == error_mark_node)
20818 : 0 : RETURN (error_mark_node);
20819 : : }
20820 : 30 : RETURN (build_omp_array_section (EXPR_LOCATION (t), op0, op1, op2));
20821 : : }
20822 : :
20823 : 5379315 : case SIZEOF_EXPR:
20824 : 9627628 : if (PACK_EXPANSION_P (TREE_OPERAND (t, 0))
20825 : 9626710 : || ARGUMENT_PACK_P (TREE_OPERAND (t, 0)))
20826 : : {
20827 : 1131932 : tree expanded, op = TREE_OPERAND (t, 0);
20828 : 1131932 : int len = 0;
20829 : :
20830 : 1131932 : if (SIZEOF_EXPR_TYPE_P (t))
20831 : 0 : op = TREE_TYPE (op);
20832 : :
20833 : 1131932 : ++cp_unevaluated_operand;
20834 : 1131932 : ++c_inhibit_evaluation_warnings;
20835 : : /* We only want to compute the number of arguments. */
20836 : 1131932 : if (PACK_EXPANSION_P (op))
20837 : 1131920 : expanded = tsubst_pack_expansion (op, args, complain, in_decl);
20838 : : else
20839 : 12 : expanded = tsubst_template_args (ARGUMENT_PACK_ARGS (op),
20840 : : args, complain, in_decl);
20841 : 1131932 : --cp_unevaluated_operand;
20842 : 1131932 : --c_inhibit_evaluation_warnings;
20843 : :
20844 : 1131932 : if (TREE_CODE (expanded) == TREE_VEC)
20845 : : {
20846 : 605414 : len = TREE_VEC_LENGTH (expanded);
20847 : : /* Set TREE_USED for the benefit of -Wunused. */
20848 : 1738662 : for (int i = 0; i < len; i++)
20849 : 1133248 : if (DECL_P (TREE_VEC_ELT (expanded, i)))
20850 : 530 : TREE_USED (TREE_VEC_ELT (expanded, i)) = true;
20851 : : }
20852 : :
20853 : 1131932 : if (expanded == error_mark_node)
20854 : 0 : RETURN (error_mark_node);
20855 : 1131932 : else if (PACK_EXPANSION_P (expanded)
20856 : 1131932 : || (TREE_CODE (expanded) == TREE_VEC
20857 : 605414 : && pack_expansion_args_count (expanded)))
20858 : :
20859 : : {
20860 : 526545 : if (PACK_EXPANSION_P (expanded))
20861 : : /* OK. */;
20862 : : else
20863 : 27 : expanded = make_argument_pack (expanded);
20864 : :
20865 : 526545 : if (TYPE_P (expanded))
20866 : 526306 : RETURN (cxx_sizeof_or_alignof_type (input_location,
20867 : : expanded, SIZEOF_EXPR,
20868 : : false,
20869 : : complain & tf_error));
20870 : : else
20871 : 239 : RETURN (cxx_sizeof_or_alignof_expr (input_location,
20872 : : expanded, SIZEOF_EXPR,
20873 : : false,
20874 : : complain & tf_error));
20875 : : }
20876 : : else
20877 : 605387 : RETURN (build_int_cst (size_type_node, len));
20878 : : }
20879 : : /* Fall through */
20880 : :
20881 : 4992319 : case ALIGNOF_EXPR:
20882 : 4992319 : {
20883 : 4992319 : tree r;
20884 : :
20885 : 4992319 : op1 = TREE_OPERAND (t, 0);
20886 : 4992319 : if (TREE_CODE (t) == SIZEOF_EXPR && SIZEOF_EXPR_TYPE_P (t))
20887 : 0 : op1 = TREE_TYPE (op1);
20888 : 4992319 : bool std_alignof = (TREE_CODE (t) == ALIGNOF_EXPR
20889 : 4992319 : && ALIGNOF_EXPR_STD_P (t));
20890 : 4992319 : if (!args)
20891 : : {
20892 : : /* When there are no ARGS, we are trying to evaluate a
20893 : : non-dependent expression from the parser. Trying to do
20894 : : the substitutions may not work. */
20895 : 136957 : if (!TYPE_P (op1))
20896 : 2487 : op1 = TREE_TYPE (op1);
20897 : : }
20898 : : else
20899 : : {
20900 : 4855362 : ++cp_unevaluated_operand;
20901 : 4855362 : ++c_inhibit_evaluation_warnings;
20902 : 4855362 : if (TYPE_P (op1))
20903 : 4668634 : op1 = tsubst (op1, args, complain, in_decl);
20904 : : else
20905 : 186728 : op1 = tsubst_expr (op1, args, complain, in_decl);
20906 : 4855362 : --cp_unevaluated_operand;
20907 : 4855362 : --c_inhibit_evaluation_warnings;
20908 : : }
20909 : 4992319 : if (TYPE_P (op1))
20910 : 4805573 : r = cxx_sizeof_or_alignof_type (input_location,
20911 : 4805573 : op1, TREE_CODE (t), std_alignof,
20912 : : complain & tf_error);
20913 : : else
20914 : 186746 : r = cxx_sizeof_or_alignof_expr (input_location,
20915 : 186746 : op1, TREE_CODE (t), std_alignof,
20916 : : complain & tf_error);
20917 : 4992319 : if (TREE_CODE (t) == SIZEOF_EXPR && r != error_mark_node)
20918 : : {
20919 : 4244455 : if (TREE_CODE (r) != SIZEOF_EXPR || TYPE_P (op1))
20920 : : {
20921 : 4244350 : if (!processing_template_decl && TYPE_P (op1))
20922 : : {
20923 : 3822574 : r = build_min (SIZEOF_EXPR, size_type_node,
20924 : : build1 (NOP_EXPR, op1, error_mark_node));
20925 : 3822574 : SIZEOF_EXPR_TYPE_P (r) = 1;
20926 : : }
20927 : : else
20928 : 421776 : r = build_min (SIZEOF_EXPR, size_type_node, op1);
20929 : 4244350 : TREE_SIDE_EFFECTS (r) = 0;
20930 : 4244350 : TREE_READONLY (r) = 1;
20931 : : }
20932 : 4244455 : SET_EXPR_LOCATION (r, EXPR_LOCATION (t));
20933 : 4244455 : copy_warning (r, t);
20934 : : }
20935 : 4992319 : RETURN (r);
20936 : : }
20937 : :
20938 : 0 : case AT_ENCODE_EXPR:
20939 : 0 : {
20940 : 0 : op1 = TREE_OPERAND (t, 0);
20941 : 0 : ++cp_unevaluated_operand;
20942 : 0 : ++c_inhibit_evaluation_warnings;
20943 : 0 : op1 = tsubst (op1, args, complain, in_decl);
20944 : 0 : --cp_unevaluated_operand;
20945 : 0 : --c_inhibit_evaluation_warnings;
20946 : 0 : RETURN (objc_build_encode_expr (op1));
20947 : : }
20948 : :
20949 : 420870 : case NOEXCEPT_EXPR:
20950 : 420870 : op1 = TREE_OPERAND (t, 0);
20951 : 420870 : ++cp_unevaluated_operand;
20952 : 420870 : ++c_inhibit_evaluation_warnings;
20953 : 420870 : ++cp_noexcept_operand;
20954 : 420870 : op1 = tsubst_expr (op1, args, complain, in_decl);
20955 : 420870 : --cp_unevaluated_operand;
20956 : 420870 : --c_inhibit_evaluation_warnings;
20957 : 420870 : --cp_noexcept_operand;
20958 : 420870 : RETURN (finish_noexcept_expr (op1, complain));
20959 : :
20960 : 14181173 : case MODOP_EXPR:
20961 : 14181173 : {
20962 : 14181173 : warning_sentinel s(warn_div_by_zero);
20963 : 14181173 : tree lhs = RECUR (TREE_OPERAND (t, 0));
20964 : 14181173 : tree rhs = RECUR (TREE_OPERAND (t, 2));
20965 : :
20966 : 14181173 : tree r = build_x_modify_expr
20967 : 14181173 : (EXPR_LOCATION (t), lhs, TREE_CODE (TREE_OPERAND (t, 1)), rhs,
20968 : : templated_operator_saved_lookups (t),
20969 : : complain|decltype_flag);
20970 : : /* TREE_NO_WARNING must be set if either the expression was
20971 : : parenthesized or it uses an operator such as >>= rather
20972 : : than plain assignment. In the former case, it was already
20973 : : set and must be copied. In the latter case,
20974 : : build_x_modify_expr sets it and it must not be reset
20975 : : here. */
20976 : 14181173 : if (warning_suppressed_p (t, OPT_Wparentheses))
20977 : 778 : suppress_warning (STRIP_REFERENCE_REF (r), OPT_Wparentheses);
20978 : :
20979 : 14181173 : RETURN (r);
20980 : 14181173 : }
20981 : :
20982 : 2489377 : case ARROW_EXPR:
20983 : 2489377 : op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
20984 : : args, complain, in_decl);
20985 : : /* Remember that there was a reference to this entity. */
20986 : 2489377 : if (DECL_P (op1)
20987 : 2489377 : && !mark_used (op1, complain) && !(complain & tf_error))
20988 : 0 : RETURN (error_mark_node);
20989 : 2489377 : RETURN (build_x_arrow (input_location, op1, complain));
20990 : :
20991 : 304042 : case NEW_EXPR:
20992 : 304042 : {
20993 : 304042 : tree placement = RECUR (TREE_OPERAND (t, 0));
20994 : 304042 : tree init = RECUR (TREE_OPERAND (t, 3));
20995 : 304042 : vec<tree, va_gc> *placement_vec;
20996 : 304042 : vec<tree, va_gc> *init_vec;
20997 : 304042 : tree ret;
20998 : 304042 : location_t loc = EXPR_LOCATION (t);
20999 : :
21000 : 304042 : if (placement == NULL_TREE)
21001 : 61478 : placement_vec = NULL;
21002 : 242564 : else if (placement == error_mark_node)
21003 : 3 : RETURN (error_mark_node);
21004 : : else
21005 : : {
21006 : 242561 : placement_vec = make_tree_vector ();
21007 : 485122 : for (; placement != NULL_TREE; placement = TREE_CHAIN (placement))
21008 : 242561 : vec_safe_push (placement_vec, TREE_VALUE (placement));
21009 : : }
21010 : :
21011 : : /* If there was an initializer in the original tree, but it
21012 : : instantiated to an empty list, then we should pass a
21013 : : non-NULL empty vector to tell build_new that it was an
21014 : : empty initializer() rather than no initializer. This can
21015 : : only happen when the initializer is a pack expansion whose
21016 : : parameter packs are of length zero. */
21017 : 304039 : if (init == NULL_TREE && TREE_OPERAND (t, 3) == NULL_TREE)
21018 : 60472 : init_vec = NULL;
21019 : 243567 : else if (init == error_mark_node)
21020 : 6 : RETURN (error_mark_node);
21021 : : else
21022 : : {
21023 : 243561 : init_vec = make_tree_vector ();
21024 : 243561 : if (init == void_node)
21025 : 692 : gcc_assert (init_vec != NULL);
21026 : : else
21027 : : {
21028 : 433985 : for (; init != NULL_TREE; init = TREE_CHAIN (init))
21029 : 191116 : vec_safe_push (init_vec, TREE_VALUE (init));
21030 : : }
21031 : : }
21032 : :
21033 : : /* Avoid passing an enclosing decl to valid_array_size_p. */
21034 : 304033 : in_decl = NULL_TREE;
21035 : :
21036 : 304033 : tree op1 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
21037 : 304033 : tree op2 = RECUR (TREE_OPERAND (t, 2));
21038 : 304033 : ret = build_new (loc, &placement_vec, op1, op2,
21039 : 304033 : &init_vec, NEW_EXPR_USE_GLOBAL (t),
21040 : : complain);
21041 : :
21042 : 304033 : if (placement_vec != NULL)
21043 : 303806 : release_tree_vector (placement_vec);
21044 : 304033 : if (init_vec != NULL)
21045 : 185262 : release_tree_vector (init_vec);
21046 : :
21047 : 304042 : RETURN (ret);
21048 : : }
21049 : :
21050 : 42176 : case DELETE_EXPR:
21051 : 42176 : {
21052 : 42176 : tree op0 = RECUR (TREE_OPERAND (t, 0));
21053 : 42176 : tree op1 = RECUR (TREE_OPERAND (t, 1));
21054 : 42176 : RETURN (delete_sanity (input_location, op0, op1,
21055 : : DELETE_EXPR_USE_VEC (t),
21056 : : DELETE_EXPR_USE_GLOBAL (t),
21057 : : complain));
21058 : : }
21059 : :
21060 : 37344 : case COMPOUND_EXPR:
21061 : 37344 : {
21062 : 37344 : tree op0 = tsubst_expr (TREE_OPERAND (t, 0), args,
21063 : : complain & ~tf_decltype, in_decl);
21064 : 37344 : RETURN (build_x_compound_expr (EXPR_LOCATION (t),
21065 : : op0,
21066 : : RECUR (TREE_OPERAND (t, 1)),
21067 : : templated_operator_saved_lookups (t),
21068 : : complain|decltype_flag));
21069 : : }
21070 : :
21071 : 75183336 : case CALL_EXPR:
21072 : 75183336 : {
21073 : 75183336 : tree function;
21074 : 75183336 : unsigned int nargs;
21075 : 75183336 : bool qualified_p;
21076 : 75183336 : bool koenig_p;
21077 : 75183336 : tree ret;
21078 : :
21079 : 75183336 : function = CALL_EXPR_FN (t);
21080 : : /* Internal function with no arguments. */
21081 : 75183336 : if (function == NULL_TREE && call_expr_nargs (t) == 0)
21082 : 75090764 : RETURN (t);
21083 : :
21084 : : /* When we parsed the expression, we determined whether or
21085 : : not Koenig lookup should be performed. */
21086 : 75080428 : koenig_p = KOENIG_LOOKUP_P (t);
21087 : 75080428 : if (function == NULL_TREE)
21088 : : {
21089 : : koenig_p = false;
21090 : : qualified_p = false;
21091 : : }
21092 : 75080255 : else if (TREE_CODE (function) == SCOPE_REF)
21093 : : {
21094 : 9381375 : qualified_p = true;
21095 : 9381375 : function = tsubst_qualified_id (function, args, complain, in_decl,
21096 : : /*done=*/false,
21097 : : /*address_p=*/false);
21098 : : }
21099 : 65698880 : else if (CALL_EXPR_STATIC_CHAIN (t)
21100 : 99 : && TREE_CODE (function) == FUNCTION_DECL
21101 : 65698979 : && fndecl_built_in_p (function, BUILT_IN_CLASSIFY_TYPE))
21102 : : {
21103 : 99 : tree type = tsubst (CALL_EXPR_STATIC_CHAIN (t), args, complain,
21104 : : in_decl);
21105 : 99 : if (dependent_type_p (type))
21106 : : {
21107 : 0 : ret = build_vl_exp (CALL_EXPR, 4);
21108 : 0 : CALL_EXPR_FN (ret) = function;
21109 : 0 : CALL_EXPR_STATIC_CHAIN (ret) = type;
21110 : 0 : CALL_EXPR_ARG (ret, 0)
21111 : 0 : = build_min (SIZEOF_EXPR, size_type_node, type);
21112 : 0 : TREE_TYPE (ret) = integer_type_node;
21113 : : }
21114 : : else
21115 : 99 : ret = build_int_cst (integer_type_node, type_to_class (type));
21116 : 99 : RETURN (ret);
21117 : : }
21118 : 65698781 : else if (koenig_p
21119 : 65698781 : && (identifier_p (function)
21120 : 5387255 : || (TREE_CODE (function) == TEMPLATE_ID_EXPR
21121 : 968444 : && identifier_p (TREE_OPERAND (function, 0)))))
21122 : : {
21123 : : /* Do nothing; calling tsubst_expr on an identifier
21124 : : would incorrectly perform unqualified lookup again.
21125 : :
21126 : : Note that we can also have an IDENTIFIER_NODE if the earlier
21127 : : unqualified lookup found a dependent local extern declaration
21128 : : (as per finish_call_expr); in that case koenig_p will be false
21129 : : and we do want to do the lookup again to find the substituted
21130 : : declaration. */
21131 : 129952 : qualified_p = false;
21132 : :
21133 : 129952 : if (TREE_CODE (function) == TEMPLATE_ID_EXPR)
21134 : 2724 : function = tsubst_name (function, args, complain, in_decl);
21135 : : }
21136 : : else
21137 : : {
21138 : 65568829 : if (TREE_CODE (function) == COMPONENT_REF)
21139 : : {
21140 : 12490754 : tree op = TREE_OPERAND (function, 1);
21141 : :
21142 : 12490754 : qualified_p = (TREE_CODE (op) == SCOPE_REF
21143 : 12490754 : || (BASELINK_P (op)
21144 : 7878316 : && BASELINK_QUALIFIED_P (op)));
21145 : : }
21146 : : else
21147 : : qualified_p = false;
21148 : :
21149 : 65568829 : if (TREE_CODE (function) == ADDR_EXPR
21150 : 65568829 : && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
21151 : : /* Avoid error about taking the address of a constructor. */
21152 : 18179 : function = TREE_OPERAND (function, 0);
21153 : :
21154 : 65568829 : tsubst_flags_t subcomplain = complain;
21155 : 65568829 : if (koenig_p && TREE_CODE (function) == FUNCTION_DECL)
21156 : : /* When KOENIG_P, we don't want to mark_used the callee before
21157 : : augmenting the overload set via ADL, so during this initial
21158 : : substitution we disable mark_used by setting tf_conv (68942). */
21159 : 1396645 : subcomplain |= tf_conv;
21160 : 65568829 : function = tsubst_expr (function, args, subcomplain, in_decl);
21161 : :
21162 : 65568829 : if (BASELINK_P (function))
21163 : 9897099 : qualified_p = true;
21164 : : }
21165 : :
21166 : 75080329 : if (function_contains_tu_local_entity (function))
21167 : 3 : RETURN (error_mark_node);
21168 : :
21169 : 75080326 : nargs = call_expr_nargs (t);
21170 : 75080326 : releasing_vec call_args;
21171 : 75080326 : tsubst_call_args (t, args, complain, in_decl, call_args);
21172 : :
21173 : : /* Stripped-down processing for a call in a thunk. Specifically, in
21174 : : the thunk template for a generic lambda. */
21175 : 75080323 : if (call_from_lambda_thunk_p (t))
21176 : : {
21177 : : /* Now that we've expanded any packs, the number of call args
21178 : : might be different. */
21179 : 105 : unsigned int cargs = call_args->length ();
21180 : 105 : tree thisarg = NULL_TREE;
21181 : 105 : if (TREE_CODE (function) == COMPONENT_REF)
21182 : : {
21183 : 105 : thisarg = TREE_OPERAND (function, 0);
21184 : 105 : if (TREE_CODE (thisarg) == INDIRECT_REF)
21185 : 105 : thisarg = TREE_OPERAND (thisarg, 0);
21186 : 105 : function = TREE_OPERAND (function, 1);
21187 : 105 : if (TREE_CODE (function) == BASELINK)
21188 : 105 : function = BASELINK_FUNCTIONS (function);
21189 : : }
21190 : : /* We aren't going to do normal overload resolution, so force the
21191 : : template-id to resolve. */
21192 : 105 : function = resolve_nondeduced_context (function, complain);
21193 : 327 : for (unsigned i = 0; i < cargs; ++i)
21194 : : {
21195 : : /* In a thunk, pass through args directly, without any
21196 : : conversions. */
21197 : 222 : tree arg = (*call_args)[i];
21198 : 222 : while (TREE_CODE (arg) != PARM_DECL)
21199 : 0 : arg = TREE_OPERAND (arg, 0);
21200 : 222 : (*call_args)[i] = arg;
21201 : : }
21202 : 105 : if (thisarg)
21203 : : {
21204 : : /* If there are no other args, just push 'this'. */
21205 : 105 : if (cargs == 0)
21206 : 9 : vec_safe_push (call_args, thisarg);
21207 : : else
21208 : : {
21209 : : /* Otherwise, shift the other args over to make room. */
21210 : 96 : tree last = (*call_args)[cargs - 1];
21211 : 96 : vec_safe_push (call_args, last);
21212 : 222 : for (int i = cargs - 1; i > 0; --i)
21213 : 126 : (*call_args)[i] = (*call_args)[i - 1];
21214 : 96 : (*call_args)[0] = thisarg;
21215 : : }
21216 : : }
21217 : 105 : ret = build_call_a (function, call_args->length (),
21218 : : call_args->address ());
21219 : : /* The thunk location is not interesting. */
21220 : 105 : SET_EXPR_LOCATION (ret, UNKNOWN_LOCATION);
21221 : 105 : CALL_FROM_THUNK_P (ret) = true;
21222 : 105 : if (CLASS_TYPE_P (TREE_TYPE (ret)))
21223 : 9 : CALL_EXPR_RETURN_SLOT_OPT (ret) = true;
21224 : :
21225 : 105 : RETURN (ret);
21226 : : }
21227 : :
21228 : : /* We do not perform argument-dependent lookup if normal
21229 : : lookup finds a non-function, in accordance with the
21230 : : resolution of DR 218. */
21231 : 75080218 : if (koenig_p
21232 : 5514477 : && ((is_overloaded_fn (function)
21233 : : /* If lookup found a member function, the Koenig lookup is
21234 : : not appropriate, even if an unqualified-name was used
21235 : : to denote the function. */
21236 : 5384513 : && !DECL_FUNCTION_MEMBER_P (get_first_fn (function)))
21237 : 5517201 : || identifier_p (function)
21238 : : /* C++20 P0846: Lookup found nothing. */
21239 : 2736 : || (TREE_CODE (function) == TEMPLATE_ID_EXPR
21240 : 2724 : && identifier_p (TREE_OPERAND (function, 0))))
21241 : : /* Only do this when substitution turns a dependent call
21242 : : into a non-dependent call. */
21243 : 5514465 : && type_dependent_expression_p_push (t)
21244 : 79763930 : && !any_type_dependent_arguments_p (call_args))
21245 : 4582141 : function = perform_koenig_lookup (function, call_args, tf_none);
21246 : :
21247 : 75080218 : if (function != NULL_TREE
21248 : 119184 : && (identifier_p (function)
21249 : 74960867 : || (TREE_CODE (function) == TEMPLATE_ID_EXPR
21250 : 15279666 : && identifier_p (TREE_OPERAND (function, 0))
21251 : 9 : && !any_dependent_template_arguments_p (TREE_OPERAND
21252 : : (function, 1))))
21253 : 75199402 : && !any_type_dependent_arguments_p (call_args))
21254 : : {
21255 : 21487 : bool template_id_p = (TREE_CODE (function) == TEMPLATE_ID_EXPR);
21256 : 21487 : if (template_id_p)
21257 : 6 : function = TREE_OPERAND (function, 0);
21258 : 21487 : if (koenig_p && (complain & tf_warning_or_error))
21259 : : {
21260 : : /* For backwards compatibility and good diagnostics, try
21261 : : the unqualified lookup again if we aren't in SFINAE
21262 : : context. */
21263 : 45 : tree unq = tsubst_expr (function, args, complain, in_decl);
21264 : 45 : if (unq == error_mark_node)
21265 : 21 : RETURN (error_mark_node);
21266 : :
21267 : 24 : if (unq != function)
21268 : : {
21269 : 24 : auto_diagnostic_group d;
21270 : 24 : char const *const msg
21271 : : = G_("%qD was not declared in this scope, "
21272 : : "and no declarations were found by "
21273 : : "argument-dependent lookup at the point "
21274 : : "of instantiation");
21275 : :
21276 : 24 : bool in_lambda = (current_class_type
21277 : 36 : && LAMBDA_TYPE_P (current_class_type));
21278 : : /* In a lambda fn, we have to be careful to not
21279 : : introduce new this captures. Legacy code can't
21280 : : be using lambdas anyway, so it's ok to be
21281 : : stricter. Be strict with C++20 template-id ADL too.
21282 : : And be strict if we're already failing anyway. */
21283 : 24 : bool strict = in_lambda || template_id_p || seen_error ();
21284 : 24 : bool diag = true;
21285 : 24 : if (strict)
21286 : 15 : error_at (cp_expr_loc_or_input_loc (t),
21287 : : msg, function);
21288 : : else
21289 : 9 : diag = permerror (cp_expr_loc_or_input_loc (t),
21290 : : msg, function);
21291 : 24 : if (diag)
21292 : : {
21293 : 24 : tree fn = unq;
21294 : :
21295 : 24 : if (INDIRECT_REF_P (fn))
21296 : 3 : fn = TREE_OPERAND (fn, 0);
21297 : 24 : if (is_overloaded_fn (fn))
21298 : 21 : fn = get_first_fn (fn);
21299 : :
21300 : 24 : if (!DECL_P (fn))
21301 : : /* Can't say anything more. */;
21302 : 21 : else if (DECL_CLASS_SCOPE_P (fn))
21303 : : {
21304 : 9 : location_t loc = cp_expr_loc_or_input_loc (t);
21305 : 9 : inform (loc,
21306 : : "declarations in dependent base %qT are "
21307 : : "not found by unqualified lookup",
21308 : 9 : DECL_CLASS_CONTEXT (fn));
21309 : 9 : if (current_class_ptr)
21310 : 6 : inform (loc,
21311 : : "use %<this->%D%> instead", function);
21312 : : else
21313 : 3 : inform (loc,
21314 : : "use %<%T::%D%> instead",
21315 : : current_class_name, function);
21316 : : }
21317 : : else
21318 : 12 : inform (DECL_SOURCE_LOCATION (fn),
21319 : : "%qD declared here, later in the "
21320 : : "translation unit", fn);
21321 : 24 : if (strict)
21322 : 15 : RETURN (error_mark_node);
21323 : : }
21324 : :
21325 : 9 : function = unq;
21326 : 24 : }
21327 : : }
21328 : 21451 : if (identifier_p (function))
21329 : : {
21330 : 21442 : if (complain & tf_error)
21331 : 0 : unqualified_name_lookup_error (function);
21332 : 21442 : RETURN (error_mark_node);
21333 : : }
21334 : : }
21335 : :
21336 : : /* Remember that there was a reference to this entity. */
21337 : 75058740 : if (function != NULL_TREE
21338 : 75058567 : && DECL_P (function)
21339 : 82080198 : && !mark_used (function, complain) && !(complain & tf_error))
21340 : 34891 : RETURN (error_mark_node);
21341 : :
21342 : 75023849 : if (!maybe_fold_fn_template_args (function, complain))
21343 : 79066 : return error_mark_node;
21344 : :
21345 : : /* Put back tf_decltype for the actual call. */
21346 : 74944783 : complain |= decltype_flag;
21347 : :
21348 : 74944783 : if (function == NULL_TREE)
21349 : 173 : switch (CALL_EXPR_IFN (t))
21350 : : {
21351 : 45 : case IFN_LAUNDER:
21352 : 45 : gcc_assert (nargs == 1);
21353 : 45 : if (vec_safe_length (call_args) != 1)
21354 : : {
21355 : 6 : error_at (cp_expr_loc_or_input_loc (t),
21356 : : "wrong number of arguments to "
21357 : : "%<__builtin_launder%>");
21358 : 6 : ret = error_mark_node;
21359 : : }
21360 : : else
21361 : 39 : ret = finish_builtin_launder (cp_expr_loc_or_input_loc (t),
21362 : 39 : (*call_args)[0], complain);
21363 : : break;
21364 : :
21365 : 27 : case IFN_VEC_CONVERT:
21366 : 27 : gcc_assert (nargs == 1);
21367 : 27 : if (vec_safe_length (call_args) != 1)
21368 : : {
21369 : 0 : error_at (cp_expr_loc_or_input_loc (t),
21370 : : "wrong number of arguments to "
21371 : : "%<__builtin_convertvector%>");
21372 : 0 : ret = error_mark_node;
21373 : 0 : break;
21374 : : }
21375 : 27 : ret = cp_build_vec_convert ((*call_args)[0], input_location,
21376 : 27 : tsubst (TREE_TYPE (t), args,
21377 : : complain, in_decl),
21378 : : complain);
21379 : 27 : if (TREE_CODE (ret) == VIEW_CONVERT_EXPR)
21380 : 3 : RETURN (ret);
21381 : : break;
21382 : :
21383 : 24 : case IFN_SHUFFLEVECTOR:
21384 : 24 : {
21385 : 24 : ret = build_x_shufflevector (input_location, call_args,
21386 : : complain);
21387 : 24 : if (ret != error_mark_node)
21388 : 21 : RETURN (ret);
21389 : : break;
21390 : : }
21391 : :
21392 : 65 : case IFN_ASSUME:
21393 : 65 : gcc_assert (nargs == 1);
21394 : 65 : if (vec_safe_length (call_args) != 1)
21395 : : {
21396 : 0 : error_at (cp_expr_loc_or_input_loc (t),
21397 : : "wrong number of arguments to "
21398 : : "%<assume%> attribute");
21399 : 0 : ret = error_mark_node;
21400 : : }
21401 : : else
21402 : : {
21403 : 65 : tree &arg = (*call_args)[0];
21404 : 65 : if (!type_dependent_expression_p (arg))
21405 : 65 : arg = contextual_conv_bool (arg, tf_warning_or_error);
21406 : 65 : if (error_operand_p (arg))
21407 : : {
21408 : 6 : ret = error_mark_node;
21409 : 6 : break;
21410 : : }
21411 : 59 : ret = build_assume_call (EXPR_LOCATION (t), arg);
21412 : 59 : RETURN (ret);
21413 : : }
21414 : 0 : break;
21415 : :
21416 : 12 : case IFN_GOMP_DISPATCH:
21417 : 24 : ret = build_call_expr_internal_loc (EXPR_LOCATION (t),
21418 : : IFN_GOMP_DISPATCH,
21419 : 12 : TREE_TYPE (call_args[0]), 1,
21420 : 12 : call_args[0]);
21421 : 12 : RETURN (ret);
21422 : : break;
21423 : :
21424 : 0 : default:
21425 : : /* Unsupported internal function with arguments. */
21426 : 0 : gcc_unreachable ();
21427 : : }
21428 : 74944610 : else if (TREE_CODE (function) == OFFSET_REF
21429 : : || TREE_CODE (function) == DOTSTAR_EXPR
21430 : : || TREE_CODE (function) == MEMBER_REF)
21431 : 104446 : ret = build_offset_ref_call_from_tree (function, &call_args,
21432 : : complain);
21433 : 74840164 : else if (concept_check_p (function))
21434 : : /* Calls to concepts should have been previously diagnosed. */
21435 : 0 : gcc_assert (false);
21436 : : else
21437 : 74840164 : ret = finish_call_expr (function, &call_args,
21438 : : /*disallow_virtual=*/qualified_p,
21439 : : koenig_p,
21440 : : complain);
21441 : :
21442 : 74931185 : if (ret != error_mark_node)
21443 : : {
21444 : 74828518 : bool op = CALL_EXPR_OPERATOR_SYNTAX (t);
21445 : 74828518 : bool ord = CALL_EXPR_ORDERED_ARGS (t);
21446 : 74828518 : bool rev = CALL_EXPR_REVERSE_ARGS (t);
21447 : 74828518 : bool mtc = false;
21448 : 74828518 : if (TREE_CODE (t) == CALL_EXPR)
21449 : 74828518 : mtc = CALL_EXPR_MUST_TAIL_CALL (t);
21450 : 74828518 : if (op || ord || rev || mtc)
21451 : 274136 : if (tree call = extract_call_expr (ret))
21452 : : {
21453 : 274136 : CALL_EXPR_OPERATOR_SYNTAX (call) = op;
21454 : 274136 : CALL_EXPR_ORDERED_ARGS (call) = ord;
21455 : 274136 : CALL_EXPR_REVERSE_ARGS (call) = rev;
21456 : 274136 : if (TREE_CODE (call) == CALL_EXPR)
21457 : 273972 : CALL_EXPR_MUST_TAIL_CALL (call) = mtc;
21458 : 164 : else if (TREE_CODE (call) == AGGR_INIT_EXPR)
21459 : 164 : AGGR_INIT_EXPR_MUST_TAIL (call) = mtc;
21460 : : }
21461 : 74828518 : if (CALL_FROM_NEW_OR_DELETE_P (t))
21462 : : {
21463 : 294242 : tree call = extract_call_expr (ret);
21464 : 294242 : tree fn = cp_get_callee_fndecl_nofold (call);
21465 : 588484 : if (fn ? !DECL_IS_REPLACEABLE_OPERATOR (fn)
21466 : 0 : : !processing_template_decl)
21467 : : {
21468 : 9 : auto_diagnostic_group d;
21469 : 9 : location_t loc = cp_expr_loc_or_input_loc (t);
21470 : 9 : if (!fn || IDENTIFIER_NEW_OP_P (DECL_NAME (fn)))
21471 : 6 : error_at (loc, "call to %<__builtin_operator_new%> "
21472 : : "does not select replaceable global "
21473 : : "allocation function");
21474 : : else
21475 : 3 : error_at (loc, "call to %<__builtin_operator_delete%> "
21476 : : "does not select replaceable global "
21477 : : "deallocation function");
21478 : 9 : if (fn)
21479 : 9 : inform (DECL_SOURCE_LOCATION (fn),
21480 : : "selected function declared here");
21481 : 9 : }
21482 : 294233 : else if (call && TREE_CODE (call) == CALL_EXPR)
21483 : 294233 : CALL_FROM_NEW_OR_DELETE_P (call) = 1;
21484 : : }
21485 : 74828518 : if (warning_suppressed_p (t, OPT_Wpessimizing_move))
21486 : : /* This also suppresses -Wredundant-move. */
21487 : 67590286 : suppress_warning (ret, OPT_Wpessimizing_move);
21488 : : }
21489 : :
21490 : 74987754 : RETURN (ret);
21491 : 75066820 : }
21492 : :
21493 : 1852366 : case COND_EXPR:
21494 : 1852366 : {
21495 : 1852366 : tree cond = RECUR (TREE_OPERAND (t, 0));
21496 : 1852366 : cond = mark_rvalue_use (cond);
21497 : 1852366 : tree folded_cond = fold_non_dependent_expr (cond, complain);
21498 : 1852366 : tree exp1, exp2;
21499 : :
21500 : 1852366 : if (TREE_CODE (folded_cond) == INTEGER_CST)
21501 : : {
21502 : 1136504 : if (integer_zerop (folded_cond))
21503 : : {
21504 : 748045 : ++c_inhibit_evaluation_warnings;
21505 : 748045 : exp1 = RECUR (TREE_OPERAND (t, 1));
21506 : 748045 : --c_inhibit_evaluation_warnings;
21507 : 748045 : exp2 = RECUR (TREE_OPERAND (t, 2));
21508 : : }
21509 : : else
21510 : : {
21511 : 388459 : exp1 = RECUR (TREE_OPERAND (t, 1));
21512 : 388459 : ++c_inhibit_evaluation_warnings;
21513 : 388459 : exp2 = RECUR (TREE_OPERAND (t, 2));
21514 : 388459 : --c_inhibit_evaluation_warnings;
21515 : : }
21516 : : cond = folded_cond;
21517 : : }
21518 : : else
21519 : : {
21520 : 715862 : exp1 = RECUR (TREE_OPERAND (t, 1));
21521 : 715862 : exp2 = RECUR (TREE_OPERAND (t, 2));
21522 : : }
21523 : :
21524 : 1852366 : warning_sentinel s(warn_duplicated_branches);
21525 : 1852366 : RETURN (build_x_conditional_expr (EXPR_LOCATION (t),
21526 : : cond, exp1, exp2, complain));
21527 : 1852366 : }
21528 : :
21529 : 18 : case PSEUDO_DTOR_EXPR:
21530 : 18 : {
21531 : 18 : tree op0 = RECUR (TREE_OPERAND (t, 0));
21532 : 18 : tree op1 = RECUR (TREE_OPERAND (t, 1));
21533 : 18 : tree op2 = tsubst (TREE_OPERAND (t, 2), args, complain, in_decl);
21534 : 18 : RETURN (finish_pseudo_destructor_expr (op0, op1, op2,
21535 : : input_location));
21536 : : }
21537 : :
21538 : 28373316 : case TREE_LIST:
21539 : 28373316 : RETURN (tsubst_tree_list (t, args, complain, in_decl));
21540 : :
21541 : 21991163 : case COMPONENT_REF:
21542 : 21991163 : {
21543 : 21991163 : tree object;
21544 : 21991163 : tree object_type;
21545 : 21991163 : tree member;
21546 : 21991163 : tree r;
21547 : :
21548 : 21991163 : object = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
21549 : : args, complain, in_decl);
21550 : : /* Remember that there was a reference to this entity. */
21551 : 21991163 : if (DECL_P (object)
21552 : 21991163 : && !mark_used (object, complain) && !(complain & tf_error))
21553 : 0 : RETURN (error_mark_node);
21554 : 21991163 : object_type = TREE_TYPE (object);
21555 : :
21556 : 21991163 : member = TREE_OPERAND (t, 1);
21557 : 21991163 : if (BASELINK_P (member))
21558 : 7878366 : member = tsubst_baselink (member,
21559 : 7878366 : non_reference (TREE_TYPE (object)),
21560 : : args, complain, in_decl);
21561 : : else
21562 : 14112797 : member = tsubst_name (member, args, complain, in_decl);
21563 : 21991163 : if (member == error_mark_node)
21564 : 9 : RETURN (error_mark_node);
21565 : :
21566 : 21443779 : if (object_type && TYPE_PTRMEMFUNC_P (object_type)
21567 : 21991175 : && TREE_CODE (member) == FIELD_DECL)
21568 : : {
21569 : 3 : r = build_ptrmemfunc_access_expr (object, DECL_NAME (member));
21570 : 3 : RETURN (r);
21571 : : }
21572 : 21991151 : else if (TREE_CODE (member) == FIELD_DECL)
21573 : : {
21574 : 5321132 : r = finish_non_static_data_member (member, object, NULL_TREE,
21575 : : complain);
21576 : 5321132 : if (TREE_CODE (r) == COMPONENT_REF)
21577 : 5140619 : REF_PARENTHESIZED_P (r) = REF_PARENTHESIZED_P (t);
21578 : 5321132 : RETURN (r);
21579 : : }
21580 : 16670019 : else if (type_dependent_expression_p (object))
21581 : : /* We can't do much here. */;
21582 : 16121183 : else if (!CLASS_TYPE_P (object_type))
21583 : : {
21584 : 90760 : if (scalarish_type_p (object_type))
21585 : : {
21586 : 43880 : tree s = NULL_TREE;
21587 : 43880 : tree dtor = member;
21588 : :
21589 : 43880 : if (TREE_CODE (dtor) == SCOPE_REF)
21590 : : {
21591 : 15 : s = TREE_OPERAND (dtor, 0);
21592 : 15 : dtor = TREE_OPERAND (dtor, 1);
21593 : : }
21594 : 43880 : if (TREE_CODE (dtor) == BIT_NOT_EXPR)
21595 : : {
21596 : 37412 : dtor = TREE_OPERAND (dtor, 0);
21597 : 37412 : if (TYPE_P (dtor))
21598 : 37412 : RETURN (finish_pseudo_destructor_expr
21599 : : (object, s, dtor, input_location));
21600 : : }
21601 : : }
21602 : : }
21603 : 16030423 : else if (TREE_CODE (member) == SCOPE_REF
21604 : 16030423 : && TREE_CODE (TREE_OPERAND (member, 1)) == TEMPLATE_ID_EXPR)
21605 : : {
21606 : : /* Lookup the template functions now that we know what the
21607 : : scope is. */
21608 : 15 : tree scope = TREE_OPERAND (member, 0);
21609 : 15 : tree tmpl = TREE_OPERAND (TREE_OPERAND (member, 1), 0);
21610 : 15 : tree args = TREE_OPERAND (TREE_OPERAND (member, 1), 1);
21611 : 15 : member = lookup_qualified_name (scope, tmpl, LOOK_want::NORMAL,
21612 : : /*complain=*/false);
21613 : 15 : if (BASELINK_P (member))
21614 : : {
21615 : 30 : BASELINK_FUNCTIONS (member)
21616 : 15 : = build_nt (TEMPLATE_ID_EXPR, BASELINK_FUNCTIONS (member),
21617 : : args);
21618 : 15 : member = (adjust_result_of_qualified_name_lookup
21619 : 15 : (member, BINFO_TYPE (BASELINK_BINFO (member)),
21620 : : object_type));
21621 : : }
21622 : : else
21623 : : {
21624 : 0 : qualified_name_lookup_error (scope, tmpl, member,
21625 : : input_location);
21626 : 15 : RETURN (error_mark_node);
21627 : : }
21628 : : }
21629 : 16030408 : else if (TREE_CODE (member) == SCOPE_REF
21630 : 727 : && !CLASS_TYPE_P (TREE_OPERAND (member, 0))
21631 : 16030411 : && TREE_CODE (TREE_OPERAND (member, 0)) != NAMESPACE_DECL)
21632 : : {
21633 : 3 : if (complain & tf_error)
21634 : : {
21635 : 3 : if (TYPE_P (TREE_OPERAND (member, 0)))
21636 : 3 : error ("%qT is not a class or namespace",
21637 : 3 : TREE_OPERAND (member, 0));
21638 : : else
21639 : 0 : error ("%qD is not a class or namespace",
21640 : 0 : TREE_OPERAND (member, 0));
21641 : : }
21642 : 3 : RETURN (error_mark_node);
21643 : : }
21644 : :
21645 : 16632604 : r = finish_class_member_access_expr (object, member,
21646 : : /*template_p=*/false,
21647 : : complain);
21648 : 16632604 : if (REF_PARENTHESIZED_P (t))
21649 : 983 : r = force_paren_expr (r);
21650 : 16632604 : RETURN (r);
21651 : : }
21652 : :
21653 : 11305 : case THROW_EXPR:
21654 : 11305 : RETURN (build_throw
21655 : : (input_location, RECUR (TREE_OPERAND (t, 0)), complain));
21656 : :
21657 : 4384705 : case CONSTRUCTOR:
21658 : 4384705 : {
21659 : 4384705 : vec<constructor_elt, va_gc> *n;
21660 : 4384705 : constructor_elt *ce;
21661 : 4384705 : unsigned HOST_WIDE_INT idx;
21662 : 4384705 : bool process_index_p;
21663 : 4384705 : int newlen;
21664 : 4384705 : bool need_copy_p = false;
21665 : 4384705 : tree r;
21666 : :
21667 : 4384705 : tsubst_flags_t tcomplain = complain;
21668 : 4384705 : if (COMPOUND_LITERAL_P (t))
21669 : 2562743 : tcomplain |= tf_tst_ok;
21670 : 4384705 : tree type = tsubst (TREE_TYPE (t), args, tcomplain, in_decl);
21671 : 4384705 : if (type == error_mark_node)
21672 : 20 : RETURN (error_mark_node);
21673 : :
21674 : : /* We do not want to process the index of aggregate
21675 : : initializers as they are identifier nodes which will be
21676 : : looked up by digest_init. */
21677 : 4384685 : process_index_p = !(type && MAYBE_CLASS_TYPE_P (type));
21678 : :
21679 : 4384685 : if (null_member_pointer_value_p (t))
21680 : : {
21681 : 18 : gcc_assert (same_type_p (type, TREE_TYPE (t)));
21682 : 18 : RETURN (t);
21683 : : }
21684 : :
21685 : 4384667 : n = vec_safe_copy (CONSTRUCTOR_ELTS (t));
21686 : 4384667 : newlen = vec_safe_length (n);
21687 : 6989373 : FOR_EACH_VEC_SAFE_ELT (n, idx, ce)
21688 : : {
21689 : 2604706 : if (ce->index && process_index_p
21690 : : /* An identifier index is looked up in the type
21691 : : being initialized, not the current scope. */
21692 : 311 : && TREE_CODE (ce->index) != IDENTIFIER_NODE)
21693 : 290 : ce->index = RECUR (ce->index);
21694 : :
21695 : 2604706 : if (PACK_EXPANSION_P (ce->value))
21696 : : {
21697 : : /* Substitute into the pack expansion. */
21698 : 6806 : ce->value = tsubst_pack_expansion (ce->value, args, complain,
21699 : : in_decl);
21700 : :
21701 : 6806 : if (ce->value == error_mark_node
21702 : 6803 : || PACK_EXPANSION_P (ce->value))
21703 : : ;
21704 : 6640 : else if (TREE_VEC_LENGTH (ce->value) == 1)
21705 : : /* Just move the argument into place. */
21706 : 2671 : ce->value = TREE_VEC_ELT (ce->value, 0);
21707 : : else
21708 : : {
21709 : : /* Update the length of the final CONSTRUCTOR
21710 : : arguments vector, and note that we will need to
21711 : : copy.*/
21712 : 3969 : newlen = newlen + TREE_VEC_LENGTH (ce->value) - 1;
21713 : 3969 : need_copy_p = true;
21714 : : }
21715 : : }
21716 : : else
21717 : 2597900 : ce->value = RECUR (ce->value);
21718 : : }
21719 : :
21720 : 4384667 : if (need_copy_p)
21721 : : {
21722 : 3947 : vec<constructor_elt, va_gc> *old_n = n;
21723 : :
21724 : 3947 : vec_alloc (n, newlen);
21725 : 8090 : FOR_EACH_VEC_ELT (*old_n, idx, ce)
21726 : : {
21727 : 4143 : if (TREE_CODE (ce->value) == TREE_VEC)
21728 : : {
21729 : 3969 : int i, len = TREE_VEC_LENGTH (ce->value);
21730 : 19851 : for (i = 0; i < len; ++i)
21731 : 15882 : CONSTRUCTOR_APPEND_ELT (n, 0,
21732 : : TREE_VEC_ELT (ce->value, i));
21733 : : }
21734 : : else
21735 : 4317 : CONSTRUCTOR_APPEND_ELT (n, 0, ce->value);
21736 : : }
21737 : : }
21738 : :
21739 : 4384667 : r = build_constructor (init_list_type_node, n);
21740 : 4384667 : CONSTRUCTOR_IS_DIRECT_INIT (r) = CONSTRUCTOR_IS_DIRECT_INIT (t);
21741 : 8769334 : CONSTRUCTOR_IS_DESIGNATED_INIT (r)
21742 : 4384667 : = CONSTRUCTOR_IS_DESIGNATED_INIT (t);
21743 : :
21744 : 4384667 : if (TREE_HAS_CONSTRUCTOR (t))
21745 : : {
21746 : 2562723 : fcl_t cl = fcl_functional;
21747 : 2562723 : if (CONSTRUCTOR_C99_COMPOUND_LITERAL (t))
21748 : 208 : cl = fcl_c99;
21749 : 2562723 : RETURN (finish_compound_literal (type, r, complain, cl));
21750 : : }
21751 : :
21752 : 1821944 : TREE_TYPE (r) = type;
21753 : 4384705 : RETURN (r);
21754 : : }
21755 : :
21756 : 73673 : case TYPEID_EXPR:
21757 : 73673 : {
21758 : 73673 : tree operand_0 = TREE_OPERAND (t, 0);
21759 : 73673 : if (TYPE_P (operand_0))
21760 : : {
21761 : 73535 : operand_0 = tsubst (operand_0, args, complain, in_decl);
21762 : 73535 : RETURN (get_typeid (operand_0, complain));
21763 : : }
21764 : : else
21765 : : {
21766 : 138 : operand_0 = RECUR (operand_0);
21767 : 138 : RETURN (build_typeid (operand_0, complain));
21768 : : }
21769 : : }
21770 : :
21771 : 133274921 : case FUNCTION_DECL:
21772 : 133274921 : case PARM_DECL:
21773 : 133274921 : case VAR_DECL:
21774 : 133274921 : if (!args)
21775 : 1540459 : RETURN (t);
21776 : 131734462 : tree r;
21777 : 67484054 : if (VAR_OR_FUNCTION_DECL_P (t)
21778 : 137736337 : && DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t))
21779 : 4114857 : r = tsubst_decl (t, args, complain);
21780 : 127619605 : else if (VAR_OR_FUNCTION_DECL_P (t) && DECL_LOCAL_DECL_P (t))
21781 : : {
21782 : : /* Local specialization will usually have been created when
21783 : : we instantiated the DECL_EXPR_DECL. */
21784 : 387 : r = retrieve_local_specialization (t);
21785 : 387 : if (!r)
21786 : : {
21787 : : /* We're in a generic lambda referencing a local extern
21788 : : from an outer block-scope of a non-template. */
21789 : 18 : gcc_checking_assert (LAMBDA_FUNCTION_P (current_function_decl));
21790 : : r = t;
21791 : : }
21792 : : }
21793 : 127619218 : else if (local_variable_p (t)
21794 : 127619218 : && ((r = retrieve_local_specialization (t))
21795 : 615198 : || TREE_CODE (t) == PARM_DECL
21796 : 485 : || uses_template_parms (DECL_CONTEXT (t))))
21797 : : {
21798 : 120708969 : if (r == NULL_TREE && TREE_CODE (t) == PARM_DECL)
21799 : : {
21800 : : /* We get here for a use of 'this' in an NSDMI. */
21801 : 614713 : if (DECL_NAME (t) == this_identifier && current_class_ptr)
21802 : 151514 : RETURN (current_class_ptr);
21803 : :
21804 : : /* This can happen for a parameter name used later in a function
21805 : : declaration (such as in a late-specified return type). Just
21806 : : make a dummy decl, since it's only used for its type. */
21807 : 463199 : gcc_assert (cp_unevaluated_operand);
21808 : 463199 : r = tsubst_decl (t, args, complain);
21809 : : /* Give it the template pattern as its context; its true context
21810 : : hasn't been instantiated yet and this is good enough for
21811 : : mangling. */
21812 : 463199 : DECL_CONTEXT (r) = DECL_CONTEXT (t);
21813 : : }
21814 : 48 : else if (r == NULL_TREE)
21815 : : {
21816 : : /* First try name lookup to find the instantiation. */
21817 : 48 : r = lookup_name (DECL_NAME (t));
21818 : 48 : if (r)
21819 : : {
21820 : 48 : if (!VAR_P (r))
21821 : : {
21822 : : /* During error-recovery we may find a non-variable,
21823 : : even an OVERLOAD: just bail out and avoid ICEs and
21824 : : duplicate diagnostics (c++/62207). */
21825 : 3 : gcc_assert (seen_error ());
21826 : 3 : RETURN (error_mark_node);
21827 : : }
21828 : 45 : if (!is_capture_proxy (r))
21829 : : {
21830 : : /* Make sure the one we found is the one we want. */
21831 : 45 : tree ctx = enclosing_instantiation_of (DECL_CONTEXT (t));
21832 : 45 : if (ctx != DECL_CONTEXT (r))
21833 : : r = NULL_TREE;
21834 : : }
21835 : : }
21836 : :
21837 : : if (r)
21838 : : /* OK */;
21839 : : else
21840 : : {
21841 : : /* This can happen for a variable used in a
21842 : : late-specified return type of a local lambda, or for a
21843 : : local static or constant. Building a new VAR_DECL
21844 : : should be OK in all those cases. */
21845 : 0 : r = tsubst_decl (t, args, complain);
21846 : 0 : if (local_specializations)
21847 : : /* Avoid infinite recursion (79640). */
21848 : 0 : register_local_specialization (r, t);
21849 : 0 : if (decl_maybe_constant_var_p (r))
21850 : : {
21851 : : /* We can't call cp_finish_decl, so handle the
21852 : : initializer by hand. */
21853 : 0 : tree init = tsubst_init (DECL_INITIAL (t), r, args,
21854 : : complain, in_decl);
21855 : 0 : if (!processing_template_decl)
21856 : 0 : init = maybe_constant_init (init);
21857 : 0 : if (processing_template_decl
21858 : 0 : ? potential_constant_expression (init)
21859 : 0 : : reduced_constant_expression_p (init))
21860 : 0 : DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r)
21861 : 0 : = TREE_CONSTANT (r) = true;
21862 : 0 : DECL_INITIAL (r) = init;
21863 : 0 : if (tree auto_node = type_uses_auto (TREE_TYPE (r)))
21864 : 0 : TREE_TYPE (r)
21865 : 0 : = do_auto_deduction (TREE_TYPE (r), init, auto_node,
21866 : : complain, adc_variable_type);
21867 : : }
21868 : 0 : gcc_assert (cp_unevaluated_operand
21869 : : || processing_contract_condition
21870 : : || TREE_STATIC (r)
21871 : : || decl_constant_var_p (r)
21872 : : || seen_error ());
21873 : 0 : if (!processing_template_decl
21874 : 0 : && !TREE_STATIC (r))
21875 : 0 : r = process_outer_var_ref (r, complain);
21876 : : }
21877 : : /* Remember this for subsequent uses. */
21878 : 45 : if (local_specializations)
21879 : 45 : register_local_specialization (r, t);
21880 : : }
21881 : 120557452 : if (TREE_CODE (r) == ARGUMENT_PACK_SELECT)
21882 : 346779 : r = argument_pack_select_arg (r);
21883 : : }
21884 : : else
21885 : : r = t;
21886 : 131582945 : if (!mark_used (r, complain))
21887 : 15 : RETURN (error_mark_node);
21888 : :
21889 : 131582927 : if (!no_name_lookup_flag
21890 : 129630065 : && (TREE_CODE (t) == PARM_DECL || TREE_CODE (t) == VAR_DECL))
21891 : : {
21892 : : /* ??? We're doing a subset of finish_id_expression here. */
21893 : 123628196 : if (tree wrap = maybe_get_tls_wrapper_call (r))
21894 : : /* Replace an evaluated use of the thread_local variable with
21895 : : a call to its wrapper. */
21896 : : r = wrap;
21897 : 123628070 : else if (outer_automatic_var_p (r))
21898 : 385160 : r = process_outer_var_ref (r, complain);
21899 : :
21900 : 123628196 : if (!TYPE_REF_P (TREE_TYPE (t)))
21901 : : /* If the original type was a reference, we'll be wrapped in
21902 : : the appropriate INDIRECT_REF. */
21903 : 108225791 : r = convert_from_reference (r);
21904 : : }
21905 : 131582927 : RETURN (r);
21906 : :
21907 : 2571542 : case CONST_DECL:
21908 : 2571542 : {
21909 : 2571542 : tree enum_type;
21910 : 2571542 : tree v;
21911 : :
21912 : 2571542 : if (DECL_TEMPLATE_PARM_P (t))
21913 : 6 : RETURN (RECUR (DECL_INITIAL (t)));
21914 : 2571536 : if (!args || !uses_template_parms (DECL_CONTEXT (t)))
21915 : 2296349 : RETURN (t);
21916 : :
21917 : : /* Unfortunately, we cannot just call lookup_name here.
21918 : : Consider:
21919 : :
21920 : : template <int I> int f() {
21921 : : enum E { a = I };
21922 : : struct S { void g() { E e = a; } };
21923 : : };
21924 : :
21925 : : When we instantiate f<7>::S::g(), say, lookup_name is not
21926 : : clever enough to find f<7>::a. */
21927 : 275187 : enum_type = tsubst (DECL_CONTEXT (t), args, complain, in_decl);
21928 : :
21929 : 275187 : for (v = TYPE_VALUES (enum_type);
21930 : 306965 : v != NULL_TREE;
21931 : 31778 : v = TREE_CHAIN (v))
21932 : 306965 : if (TREE_PURPOSE (v) == DECL_NAME (t))
21933 : 306965 : RETURN (TREE_VALUE (v));
21934 : :
21935 : : /* We didn't find the name. That should never happen; if
21936 : : name-lookup found it during preliminary parsing, we
21937 : : should find it again here during instantiation. */
21938 : 0 : gcc_unreachable ();
21939 : 7493054 : RETURN (t);
21940 : : }
21941 : :
21942 : 7493054 : case FIELD_DECL:
21943 : 7493054 : if (DECL_CONTEXT (t))
21944 : : {
21945 : 7493054 : tree ctx;
21946 : :
21947 : 7493054 : ctx = tsubst_entering_scope (DECL_CONTEXT (t), args,
21948 : : complain, in_decl);
21949 : 7493054 : if (ctx != DECL_CONTEXT (t))
21950 : : {
21951 : 7099075 : tree r = lookup_field (ctx, DECL_NAME (t), 0, false);
21952 : 7099075 : if (!r)
21953 : : {
21954 : 0 : if (complain & tf_error)
21955 : 0 : error ("using invalid field %qD", t);
21956 : 0 : RETURN (error_mark_node);
21957 : : }
21958 : 7099075 : RETURN (r);
21959 : : }
21960 : : }
21961 : 393979 : RETURN (t);
21962 : :
21963 : 34019652 : case NAMESPACE_DECL:
21964 : 34019652 : case OVERLOAD:
21965 : 34019652 : RETURN (t);
21966 : :
21967 : 8075190 : case TEMPLATE_DECL:
21968 : 8075190 : if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
21969 : 4080 : RETURN (tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
21970 : : args, complain, in_decl));
21971 : 8071110 : else if (DECL_FUNCTION_TEMPLATE_P (t) && DECL_MEMBER_TEMPLATE_P (t))
21972 : 0 : RETURN (tsubst (t, args, complain, in_decl));
21973 : 16142220 : else if (DECL_CLASS_SCOPE_P (t)
21974 : 8233341 : && uses_template_parms (DECL_CONTEXT (t)))
21975 : : {
21976 : : /* Template template argument like the following example need
21977 : : special treatment:
21978 : :
21979 : : template <template <class> class TT> struct C {};
21980 : : template <class T> struct D {
21981 : : template <class U> struct E {};
21982 : : C<E> c; // #1
21983 : : };
21984 : : D<int> d; // #2
21985 : :
21986 : : We are processing the template argument `E' in #1 for
21987 : : the template instantiation #2. Originally, `E' is a
21988 : : TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
21989 : : have to substitute this with one having context `D<int>'. */
21990 : :
21991 : 133732 : tree context = tsubst_entering_scope (DECL_CONTEXT (t), args,
21992 : : complain, in_decl);
21993 : 133732 : RETURN (lookup_field (context, DECL_NAME(t), 0, false));
21994 : : }
21995 : : else
21996 : : /* Ordinary template template argument. */
21997 : 7937378 : RETURN (t);
21998 : :
21999 : 137145124 : case TEMPLATE_PARM_INDEX:
22000 : 137145124 : case TYPE_DECL:
22001 : 137145124 : RETURN (tsubst (t, args, complain, in_decl));
22002 : :
22003 : 0 : case CLEANUP_POINT_EXPR:
22004 : : /* We shouldn't have built any of these during initial template
22005 : : generation. Instead, they should be built during instantiation
22006 : : in response to the saved STMT_IS_FULL_EXPR_P setting. */
22007 : 0 : gcc_unreachable ();
22008 : :
22009 : 126 : case OFFSET_REF:
22010 : 126 : {
22011 : 126 : tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
22012 : 126 : tree op0 = RECUR (TREE_OPERAND (t, 0));
22013 : 126 : tree op1 = RECUR (TREE_OPERAND (t, 1));
22014 : 126 : r = build2 (OFFSET_REF, type, op0, op1);
22015 : 126 : PTRMEM_OK_P (r) = PTRMEM_OK_P (t);
22016 : 126 : if (!mark_used (TREE_OPERAND (r, 1), complain)
22017 : 126 : && !(complain & tf_error))
22018 : 0 : RETURN (error_mark_node);
22019 : 126 : RETURN (r);
22020 : : }
22021 : :
22022 : 78 : case PACK_INDEX_EXPR:
22023 : 78 : RETURN (tsubst_pack_index (t, args, complain, in_decl));
22024 : :
22025 : 0 : case EXPR_PACK_EXPANSION:
22026 : 0 : error ("invalid use of pack expansion expression");
22027 : 0 : RETURN (error_mark_node);
22028 : :
22029 : 0 : case NONTYPE_ARGUMENT_PACK:
22030 : 0 : error ("use %<...%> to expand argument pack");
22031 : 0 : RETURN (error_mark_node);
22032 : :
22033 : 3994 : case VOID_CST:
22034 : 3994 : gcc_checking_assert (t == void_node && VOID_TYPE_P (TREE_TYPE (t)));
22035 : 3994 : RETURN (t);
22036 : :
22037 : 116917958 : case INTEGER_CST:
22038 : 116917958 : case REAL_CST:
22039 : 116917958 : case COMPLEX_CST:
22040 : 116917958 : case VECTOR_CST:
22041 : 116917958 : {
22042 : : /* Instantiate any typedefs in the type. */
22043 : 116917958 : tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
22044 : 116917958 : r = fold_convert (type, t);
22045 : 116917958 : gcc_assert (TREE_CODE (r) == TREE_CODE (t));
22046 : 116917958 : RETURN (r);
22047 : : }
22048 : :
22049 : 5937325 : case STRING_CST:
22050 : 5937325 : {
22051 : 5937325 : tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
22052 : 5937325 : r = t;
22053 : 5937325 : if (type != TREE_TYPE (t))
22054 : : {
22055 : 3 : r = copy_node (t);
22056 : 3 : TREE_TYPE (r) = type;
22057 : : }
22058 : 5937325 : RETURN (r);
22059 : : }
22060 : :
22061 : 30 : case RAW_DATA_CST:
22062 : 30 : {
22063 : 30 : tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
22064 : 30 : r = copy_node (t);
22065 : 30 : TREE_TYPE (r) = type;
22066 : 30 : RETURN (r);
22067 : : }
22068 : :
22069 : 24 : case PTRMEM_CST:
22070 : : /* These can sometimes show up in a partial instantiation, but never
22071 : : involve template parms. */
22072 : 24 : gcc_assert (!uses_template_parms (t));
22073 : 24 : RETURN (t);
22074 : :
22075 : 1835 : case UNARY_LEFT_FOLD_EXPR:
22076 : 1835 : RETURN (tsubst_unary_left_fold (t, args, complain, in_decl));
22077 : 186756 : case UNARY_RIGHT_FOLD_EXPR:
22078 : 186756 : RETURN (tsubst_unary_right_fold (t, args, complain, in_decl));
22079 : 866 : case BINARY_LEFT_FOLD_EXPR:
22080 : 866 : RETURN (tsubst_binary_left_fold (t, args, complain, in_decl));
22081 : 459 : case BINARY_RIGHT_FOLD_EXPR:
22082 : 459 : RETURN (tsubst_binary_right_fold (t, args, complain, in_decl));
22083 : 0 : case PREDICT_EXPR:
22084 : 0 : RETURN (t);
22085 : :
22086 : 72443704 : case DEBUG_BEGIN_STMT:
22087 : : /* ??? There's no point in copying it for now, but maybe some
22088 : : day it will contain more information, such as a pointer back
22089 : : to the containing function, inlined copy or so. */
22090 : 72443704 : RETURN (t);
22091 : :
22092 : 95 : case CO_YIELD_EXPR:
22093 : 95 : RETURN (finish_co_yield_expr (input_location,
22094 : : RECUR (TREE_OPERAND (t, 0))));
22095 : :
22096 : 99 : case CO_AWAIT_EXPR:
22097 : 99 : RETURN (finish_co_await_expr (input_location,
22098 : : RECUR (TREE_OPERAND (t, 0))));
22099 : :
22100 : 42 : case VA_ARG_EXPR:
22101 : 42 : {
22102 : 42 : tree op0 = RECUR (TREE_OPERAND (t, 0));
22103 : 42 : tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
22104 : 42 : RETURN (build_x_va_arg (EXPR_LOCATION (t), op0, type));
22105 : : }
22106 : :
22107 : 48 : case OFFSETOF_EXPR:
22108 : 48 : {
22109 : 48 : tree object_ptr
22110 : 48 : = tsubst_expr (TREE_OPERAND (t, 1), args, complain, in_decl);
22111 : 48 : RETURN (finish_offsetof (object_ptr,
22112 : : RECUR (TREE_OPERAND (t, 0)),
22113 : : EXPR_LOCATION (t)));
22114 : : }
22115 : :
22116 : 249722 : case ADDRESSOF_EXPR:
22117 : 249722 : RETURN (cp_build_addressof (EXPR_LOCATION (t),
22118 : : RECUR (TREE_OPERAND (t, 0)), complain));
22119 : :
22120 : 9165699 : case TRAIT_EXPR:
22121 : 9165699 : {
22122 : 9165699 : tree type1 = TRAIT_EXPR_TYPE1 (t);
22123 : 9165699 : if (TYPE_P (type1))
22124 : 9165601 : type1 = tsubst (type1, args, complain, in_decl);
22125 : : else
22126 : 98 : type1 = tsubst_expr (type1, args, complain, in_decl);
22127 : 9165699 : tree type2 = tsubst (TRAIT_EXPR_TYPE2 (t), args,
22128 : : complain, in_decl);
22129 : 9165699 : RETURN (finish_trait_expr (TRAIT_EXPR_LOCATION (t),
22130 : : TRAIT_EXPR_KIND (t), type1, type2));
22131 : : }
22132 : :
22133 : 136 : case STMT_EXPR:
22134 : 136 : {
22135 : 136 : tree old_stmt_expr = cur_stmt_expr;
22136 : 136 : tree stmt_expr = begin_stmt_expr ();
22137 : :
22138 : 136 : cur_stmt_expr = stmt_expr;
22139 : 136 : tsubst_stmt (STMT_EXPR_STMT (t), args, complain, in_decl);
22140 : 136 : stmt_expr = finish_stmt_expr (stmt_expr, false);
22141 : 136 : cur_stmt_expr = old_stmt_expr;
22142 : :
22143 : : /* If the resulting list of expression statement is empty,
22144 : : fold it further into void_node. */
22145 : 136 : if (empty_expr_stmt_p (stmt_expr))
22146 : 9 : stmt_expr = void_node;
22147 : :
22148 : 136 : RETURN (stmt_expr);
22149 : : }
22150 : :
22151 : 154960 : case LAMBDA_EXPR:
22152 : 154960 : {
22153 : 154960 : tree r = tsubst_lambda_expr (t, args, complain, in_decl);
22154 : :
22155 : 154960 : RETURN (build_lambda_object (r));
22156 : : }
22157 : :
22158 : 12 : case TRANSACTION_EXPR:
22159 : 12 : gcc_checking_assert (!TRANSACTION_EXPR_IS_STMT (t));
22160 : 12 : RETURN (tsubst_stmt (t, args, complain, in_decl));
22161 : :
22162 : 402218 : case PAREN_EXPR:
22163 : 402218 : if (REF_PARENTHESIZED_P (t))
22164 : 402217 : RETURN (finish_parenthesized_expr (RECUR (TREE_OPERAND (t, 0))));
22165 : : else
22166 : : /* Recreate the PAREN_EXPR from __builtin_assoc_barrier. */
22167 : : {
22168 : 1 : tree op0 = RECUR (TREE_OPERAND (t, 0));
22169 : 1 : RETURN (build1_loc (input_location, PAREN_EXPR,
22170 : : TREE_TYPE (op0), op0));
22171 : : }
22172 : :
22173 : 23 : case VEC_PERM_EXPR:
22174 : 23 : {
22175 : 23 : tree op0 = RECUR (TREE_OPERAND (t, 0));
22176 : 23 : tree op1 = RECUR (TREE_OPERAND (t, 1));
22177 : 23 : tree op2 = RECUR (TREE_OPERAND (t, 2));
22178 : 23 : RETURN (build_x_vec_perm_expr (input_location, op0, op1, op2,
22179 : : complain));
22180 : : }
22181 : :
22182 : 2772461 : case REQUIRES_EXPR:
22183 : 2772461 : {
22184 : 2772461 : complain &= ~tf_warning_or_error;
22185 : 2772461 : tree r = tsubst_requires_expr (t, args, complain, in_decl);
22186 : 2769761 : RETURN (r);
22187 : : }
22188 : :
22189 : 6 : case RANGE_EXPR:
22190 : : /* No need to substitute further, a RANGE_EXPR will always be built
22191 : : with constant operands. */
22192 : 6 : RETURN (t);
22193 : :
22194 : 132749707 : case NON_LVALUE_EXPR:
22195 : 132749707 : case VIEW_CONVERT_EXPR:
22196 : 132749707 : {
22197 : 132749707 : tree op = RECUR (TREE_OPERAND (t, 0));
22198 : :
22199 : 132749707 : if (location_wrapper_p (t))
22200 : : /* We need to do this here as well as in tsubst_copy so we get the
22201 : : other tsubst_copy_and_build semantics for a PARM_DECL operand. */
22202 : 132745235 : RETURN (maybe_wrap_with_location (op, EXPR_LOCATION (t)));
22203 : :
22204 : 4472 : gcc_checking_assert (TREE_CODE (t) == VIEW_CONVERT_EXPR);
22205 : 4472 : if (REF_PARENTHESIZED_P (t))
22206 : : /* force_paren_expr can also create a VIEW_CONVERT_EXPR. */
22207 : 0 : RETURN (finish_parenthesized_expr (op));
22208 : :
22209 : : /* Otherwise, we're dealing with a wrapper to make a C++20 template
22210 : : parameter object const. */
22211 : 4472 : if (TREE_TYPE (op) == NULL_TREE
22212 : 4472 : || !CP_TYPE_CONST_P (TREE_TYPE (op)))
22213 : : {
22214 : : /* The template argument is not const, presumably because
22215 : : it is still dependent, and so not the const template parm
22216 : : object. */
22217 : 4331 : tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
22218 : 4331 : if (TREE_CODE (op) == CONSTRUCTOR
22219 : 4328 : || TREE_CODE (op) == IMPLICIT_CONV_EXPR)
22220 : : {
22221 : : /* Don't add a wrapper to these. */
22222 : 12 : op = copy_node (op);
22223 : 12 : TREE_TYPE (op) = type;
22224 : : }
22225 : : else
22226 : : /* Do add a wrapper otherwise (in particular, if op is
22227 : : another TEMPLATE_PARM_INDEX). */
22228 : 4319 : op = build1 (VIEW_CONVERT_EXPR, type, op);
22229 : : }
22230 : 4472 : RETURN (op);
22231 : : }
22232 : :
22233 : 42 : case TU_LOCAL_ENTITY:
22234 : 42 : complain_about_tu_local_entity (t);
22235 : 42 : RETURN (error_mark_node);
22236 : :
22237 : 0 : default:
22238 : : /* Handle Objective-C++ constructs, if appropriate. */
22239 : 0 : if (tree subst = objcp_tsubst_expr (t, args, complain, in_decl))
22240 : 0 : RETURN (subst);
22241 : :
22242 : : /* We shouldn't get here, but keep going if !flag_checking. */
22243 : 0 : if (flag_checking)
22244 : 0 : gcc_unreachable ();
22245 : 0 : RETURN (t);
22246 : : }
22247 : :
22248 : : #undef RECUR
22249 : : #undef RETURN
22250 : 1285373354 : out:
22251 : 1285373354 : input_location = save_loc;
22252 : 1285373354 : return retval;
22253 : : }
22254 : :
22255 : : /* Verify that the instantiated ARGS are valid. For type arguments,
22256 : : make sure that the type's linkage is ok. For non-type arguments,
22257 : : make sure they are constants if they are integral or enumerations.
22258 : : Emit an error under control of COMPLAIN, and return TRUE on error. */
22259 : :
22260 : : static bool
22261 : 197183476 : check_instantiated_arg (tree tmpl, tree t, tsubst_flags_t complain)
22262 : : {
22263 : 197183476 : if (dependent_template_arg_p (t))
22264 : : return false;
22265 : 176716202 : if (ARGUMENT_PACK_P (t))
22266 : : {
22267 : 14213442 : tree vec = ARGUMENT_PACK_ARGS (t);
22268 : 14213442 : int len = TREE_VEC_LENGTH (vec);
22269 : 14213442 : bool result = false;
22270 : 14213442 : int i;
22271 : :
22272 : 45967388 : for (i = 0; i < len; ++i)
22273 : 31753946 : if (check_instantiated_arg (tmpl, TREE_VEC_ELT (vec, i), complain))
22274 : 0 : result = true;
22275 : : return result;
22276 : : }
22277 : 162502760 : else if (TYPE_P (t))
22278 : : {
22279 : : /* [basic.link]: A name with no linkage (notably, the name
22280 : : of a class or enumeration declared in a local scope)
22281 : : shall not be used to declare an entity with linkage.
22282 : : This implies that names with no linkage cannot be used as
22283 : : template arguments
22284 : :
22285 : : DR 757 relaxes this restriction for C++0x. */
22286 : 138113577 : tree nt = (cxx_dialect > cxx98 ? NULL_TREE
22287 : 153191 : : no_linkage_check (t, /*relaxed_p=*/false));
22288 : :
22289 : 153191 : if (nt)
22290 : : {
22291 : : /* DR 488 makes use of a type with no linkage cause
22292 : : type deduction to fail. */
22293 : 8 : if (complain & tf_error)
22294 : : {
22295 : 10 : if (TYPE_UNNAMED_P (nt))
22296 : 0 : error ("%qT is/uses unnamed type", t);
22297 : : else
22298 : 5 : error ("template argument for %qD uses local type %qT",
22299 : : tmpl, t);
22300 : : }
22301 : 8 : return true;
22302 : : }
22303 : : /* In order to avoid all sorts of complications, we do not
22304 : : allow variably-modified types as template arguments. */
22305 : 138113569 : else if (variably_modified_type_p (t, NULL_TREE))
22306 : : {
22307 : 6 : if (complain & tf_error)
22308 : 3 : error ("%qT is a variably modified type", t);
22309 : 6 : return true;
22310 : : }
22311 : : }
22312 : : /* Class template and alias template arguments should be OK. */
22313 : 24389183 : else if (DECL_TYPE_TEMPLATE_P (t))
22314 : : ;
22315 : : /* A non-type argument of integral or enumerated type must be a
22316 : : constant. */
22317 : 23958548 : else if (TREE_TYPE (t)
22318 : 23958548 : && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t))
22319 : 23956386 : && !REFERENCE_REF_P (t)
22320 : 47914829 : && !TREE_CONSTANT (t))
22321 : : {
22322 : 0 : if (complain & tf_error)
22323 : 0 : error ("integral expression %qE is not constant", t);
22324 : 0 : return true;
22325 : : }
22326 : : return false;
22327 : : }
22328 : :
22329 : : static bool
22330 : 107121800 : check_instantiated_args (tree tmpl, tree args, tsubst_flags_t complain)
22331 : : {
22332 : 107121800 : int ix, len = DECL_NTPARMS (tmpl);
22333 : 107121800 : bool result = false;
22334 : :
22335 : 272551330 : for (ix = 0; ix != len; ix++)
22336 : : {
22337 : 165429530 : if (check_instantiated_arg (tmpl, TREE_VEC_ELT (args, ix), complain))
22338 : 14 : result = true;
22339 : : }
22340 : 107121800 : if (result && (complain & tf_error))
22341 : 8 : error (" trying to instantiate %qD", tmpl);
22342 : 107121800 : return result;
22343 : : }
22344 : :
22345 : : /* Call mark_used on each entity within the non-type template arguments in
22346 : : ARGS for an instantiation of TMPL, to ensure that each such entity is
22347 : : considered odr-used (and therefore marked for instantiation) regardless of
22348 : : whether the specialization was first formed in a template context (which
22349 : : inhibits mark_used).
22350 : :
22351 : : This function assumes push_to_top_level has been called beforehand. */
22352 : :
22353 : : static void
22354 : 47608071 : mark_template_arguments_used (tree tmpl, tree args)
22355 : : {
22356 : : /* It suffices to do this only when instantiating a primary template. */
22357 : 47608071 : if (TREE_CODE (tmpl) != TEMPLATE_DECL || !PRIMARY_TEMPLATE_P (tmpl))
22358 : : return;
22359 : :
22360 : : /* We already marked outer arguments when specializing the context. */
22361 : 36910304 : args = INNERMOST_TEMPLATE_ARGS (args);
22362 : :
22363 : 94152935 : for (tree arg : tree_vec_range (args))
22364 : : {
22365 : : /* A (pointer/reference to) function or variable NTTP argument. */
22366 : 57242631 : if (TREE_CODE (arg) == ADDR_EXPR
22367 : 57242105 : || TREE_CODE (arg) == INDIRECT_REF)
22368 : : {
22369 : 1836 : while (TREE_CODE (arg) == ADDR_EXPR
22370 : 1114 : || REFERENCE_REF_P (arg)
22371 : 2754 : || CONVERT_EXPR_P (arg))
22372 : 1114 : arg = TREE_OPERAND (arg, 0);
22373 : 722 : if (VAR_OR_FUNCTION_DECL_P (arg))
22374 : : {
22375 : : /* Pass tf_none to avoid duplicate diagnostics: if this call
22376 : : fails then an earlier call to mark_used for this argument
22377 : : must have also failed and emitted a diagnostic. */
22378 : 711 : bool ok = mark_used (arg, tf_none);
22379 : 711 : gcc_checking_assert (ok || seen_error ());
22380 : : }
22381 : : }
22382 : : /* A class NTTP argument. */
22383 : 57241909 : else if (VAR_P (arg)
22384 : 57241909 : && DECL_NTTP_OBJECT_P (arg))
22385 : : {
22386 : 1377 : auto mark_used_r = [](tree *tp, int *, void *) {
22387 : 967 : if (VAR_OR_FUNCTION_DECL_P (*tp))
22388 : : {
22389 : 15 : bool ok = mark_used (*tp, tf_none);
22390 : 15 : gcc_checking_assert (ok || seen_error ());
22391 : : }
22392 : 967 : return NULL_TREE;
22393 : : };
22394 : 410 : cp_walk_tree_without_duplicates (&DECL_INITIAL (arg),
22395 : : mark_used_r, nullptr);
22396 : : }
22397 : : }
22398 : : }
22399 : :
22400 : : /* We're out of SFINAE context now, so generate diagnostics for the access
22401 : : errors we saw earlier when instantiating D from TMPL and ARGS. */
22402 : :
22403 : : static void
22404 : 9 : recheck_decl_substitution (tree d, tree tmpl, tree args)
22405 : : {
22406 : 9 : tree pattern = DECL_TEMPLATE_RESULT (tmpl);
22407 : 9 : tree type = TREE_TYPE (pattern);
22408 : 9 : location_t loc = input_location;
22409 : :
22410 : 9 : push_access_scope (d);
22411 : 9 : push_deferring_access_checks (dk_no_deferred);
22412 : 9 : input_location = DECL_SOURCE_LOCATION (pattern);
22413 : 9 : tsubst (type, args, tf_warning_or_error, d);
22414 : 9 : input_location = loc;
22415 : 9 : pop_deferring_access_checks ();
22416 : 9 : pop_access_scope (d);
22417 : 9 : }
22418 : :
22419 : : /* Instantiate the indicated variable, function, or alias template TMPL with
22420 : : the template arguments in TARG_PTR. */
22421 : :
22422 : : tree
22423 : 157545069 : instantiate_template (tree tmpl, tree orig_args, tsubst_flags_t complain)
22424 : : {
22425 : 157545069 : auto_timevar tv (TV_TEMPLATE_INST);
22426 : :
22427 : 157545069 : tree targ_ptr = orig_args;
22428 : 157545069 : tree fndecl;
22429 : 157545069 : tree gen_tmpl;
22430 : 157545069 : bool access_ok = true;
22431 : :
22432 : 157545069 : if (tmpl == error_mark_node)
22433 : : return error_mark_node;
22434 : :
22435 : : /* The other flags are not relevant anymore here, especially tf_partial
22436 : : shouldn't be set. For instance, we may be called while doing a partial
22437 : : substitution of a template variable, but the type of the variable
22438 : : template may be auto, in which case we will call do_auto_deduction
22439 : : in mark_used (which clears tf_partial) and the auto must be properly
22440 : : reduced at that time for the deduction to work. */
22441 : 157545060 : complain &= tf_warning_or_error;
22442 : :
22443 : 157545060 : gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
22444 : :
22445 : 157545060 : if (modules_p ())
22446 : 834379 : lazy_load_pendings (tmpl);
22447 : :
22448 : : /* If this function is a clone, handle it specially. */
22449 : 157545060 : if (DECL_CLONED_FUNCTION_P (tmpl))
22450 : : {
22451 : 3417864 : tree spec;
22452 : 3417864 : tree clone;
22453 : :
22454 : : /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
22455 : : DECL_CLONED_FUNCTION. */
22456 : 3417864 : spec = instantiate_template (DECL_ABSTRACT_ORIGIN (tmpl),
22457 : : targ_ptr, complain);
22458 : 3417864 : if (spec == error_mark_node)
22459 : : return error_mark_node;
22460 : :
22461 : : /* Look for the clone. */
22462 : 6620322 : FOR_EACH_CLONE (clone, spec)
22463 : 6620322 : if (DECL_NAME (clone) == DECL_NAME (tmpl))
22464 : : return clone;
22465 : : /* We should always have found the clone by now. */
22466 : 0 : gcc_unreachable ();
22467 : : return NULL_TREE;
22468 : : }
22469 : :
22470 : 154127196 : if (targ_ptr == error_mark_node)
22471 : : return error_mark_node;
22472 : :
22473 : : /* Check to see if we already have this specialization. */
22474 : 154127196 : gen_tmpl = most_general_template (tmpl);
22475 : 308254392 : if (TMPL_ARGS_DEPTH (targ_ptr)
22476 : 154127196 : < TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl)))
22477 : : /* targ_ptr only has the innermost template args, so add the outer ones
22478 : : from tmpl, which could be either a partial instantiation or gen_tmpl (in
22479 : : the case of a non-dependent call within a template definition). */
22480 : 11083456 : targ_ptr = (add_outermost_template_args
22481 : 11083456 : (DECL_TI_ARGS (DECL_TEMPLATE_RESULT (tmpl)),
22482 : : targ_ptr));
22483 : :
22484 : 154127196 : hashval_t hash = spec_hasher::hash (gen_tmpl, targ_ptr);
22485 : 154127196 : tree spec = retrieve_specialization (gen_tmpl, targ_ptr, hash);
22486 : :
22487 : 154127196 : gcc_checking_assert (tmpl == gen_tmpl
22488 : : || ((fndecl
22489 : : = retrieve_specialization (tmpl, orig_args, 0))
22490 : : == spec)
22491 : : || fndecl == NULL_TREE);
22492 : :
22493 : 154127196 : if (spec != NULL_TREE)
22494 : : {
22495 : 82157087 : if (FNDECL_HAS_ACCESS_ERRORS (spec))
22496 : : {
22497 : 15 : if (complain & tf_error)
22498 : 9 : recheck_decl_substitution (spec, gen_tmpl, targ_ptr);
22499 : 15 : return error_mark_node;
22500 : : }
22501 : : return spec;
22502 : : }
22503 : :
22504 : 71970109 : if (check_instantiated_args (gen_tmpl, INNERMOST_TEMPLATE_ARGS (targ_ptr),
22505 : : complain))
22506 : 6 : return error_mark_node;
22507 : :
22508 : : /* We are building a FUNCTION_DECL, during which the access of its
22509 : : parameters and return types have to be checked. However this
22510 : : FUNCTION_DECL which is the desired context for access checking
22511 : : is not built yet. We solve this chicken-and-egg problem by
22512 : : deferring all checks until we have the FUNCTION_DECL. */
22513 : 71970103 : push_deferring_access_checks (dk_deferred);
22514 : :
22515 : : /* Instantiation of the function happens in the context of the function
22516 : : template, not the context of the overload resolution we're doing. */
22517 : 71970103 : push_to_top_level ();
22518 : : /* If there are dependent arguments, e.g. because we're doing partial
22519 : : ordering, make sure processing_template_decl stays set. */
22520 : 71970103 : if (uses_template_parms (targ_ptr))
22521 : 14725254 : ++processing_template_decl;
22522 : 71970103 : if (DECL_CLASS_SCOPE_P (gen_tmpl))
22523 : : {
22524 : 20597542 : tree ctx;
22525 : 20597542 : if (!uses_template_parms (DECL_CONTEXT (tmpl)))
22526 : : /* If the context of the partially instantiated template is
22527 : : already non-dependent, then we might as well use it. */
22528 : 17232910 : ctx = DECL_CONTEXT (tmpl);
22529 : : else
22530 : 3364632 : ctx = tsubst_entering_scope (DECL_CONTEXT (gen_tmpl), targ_ptr,
22531 : : complain, gen_tmpl);
22532 : 20597542 : push_nested_class (ctx);
22533 : : }
22534 : :
22535 : 71970103 : tree pattern = DECL_TEMPLATE_RESULT (gen_tmpl);
22536 : :
22537 : 71970103 : tree partial_ti = NULL_TREE;
22538 : 71970103 : fndecl = NULL_TREE;
22539 : 71970103 : if (VAR_P (pattern))
22540 : : {
22541 : : /* We need to determine if we're using a partial or explicit
22542 : : specialization now, because the type of the variable could be
22543 : : different. */
22544 : 3497494 : tree tid = build2 (TEMPLATE_ID_EXPR, NULL_TREE, tmpl, targ_ptr);
22545 : 3497494 : partial_ti = most_specialized_partial_spec (tid, complain);
22546 : 3497494 : if (partial_ti == error_mark_node)
22547 : : pattern = error_mark_node;
22548 : 3497491 : else if (partial_ti)
22549 : : {
22550 : 236615 : tree partial_tmpl = TI_TEMPLATE (partial_ti);
22551 : 236615 : tree partial_args = TI_ARGS (partial_ti);
22552 : 236615 : tree partial_pat = DECL_TEMPLATE_RESULT (partial_tmpl);
22553 : 236615 : fndecl = tsubst_decl (partial_pat, partial_args, complain,
22554 : : /*use_spec_table=*/false);
22555 : : }
22556 : : }
22557 : :
22558 : : /* Substitute template parameters to obtain the specialization. */
22559 : 236615 : if (fndecl == NULL_TREE)
22560 : 71733488 : fndecl = tsubst_decl (pattern, targ_ptr, complain, /*use_spec_table=*/false);
22561 : 71961967 : if (DECL_CLASS_SCOPE_P (gen_tmpl))
22562 : 20597542 : pop_nested_class ();
22563 : 71961967 : pop_from_top_level ();
22564 : :
22565 : 71961967 : if (fndecl == error_mark_node)
22566 : : {
22567 : 27325283 : pop_deferring_access_checks ();
22568 : 27325283 : return error_mark_node;
22569 : : }
22570 : :
22571 : : /* The DECL_TI_TEMPLATE should always be the immediate parent
22572 : : template, not the most general template. */
22573 : 44636684 : DECL_TI_TEMPLATE (fndecl) = tmpl;
22574 : 44636684 : DECL_TI_ARGS (fndecl) = targ_ptr;
22575 : 44636684 : if (VAR_P (pattern))
22576 : : {
22577 : : /* Now that we we've formed this variable template specialization,
22578 : : remember the result of most_specialized_partial_spec for it. */
22579 : 3497491 : TI_PARTIAL_INFO (DECL_TEMPLATE_INFO (fndecl)) = partial_ti;
22580 : :
22581 : : /* And remember if the variable was declared with []. */
22582 : 3497491 : if (TREE_CODE (TREE_TYPE (fndecl)) == ARRAY_TYPE
22583 : 3497491 : && TYPE_DOMAIN (TREE_TYPE (fndecl)) == NULL_TREE)
22584 : 12 : SET_VAR_HAD_UNKNOWN_BOUND (fndecl);
22585 : : }
22586 : :
22587 : 44636684 : fndecl = register_specialization (fndecl, gen_tmpl, targ_ptr, false, hash);
22588 : 44636684 : if (fndecl == error_mark_node)
22589 : : return error_mark_node;
22590 : :
22591 : 44636681 : set_instantiating_module (fndecl);
22592 : :
22593 : : /* Now we know the specialization, compute access previously
22594 : : deferred. Do no access control for inheriting constructors,
22595 : : as we already checked access for the inherited constructor. */
22596 : 44636681 : if (!(flag_new_inheriting_ctors
22597 : 64707261 : && DECL_INHERITED_CTOR (fndecl)))
22598 : : {
22599 : 44625818 : push_access_scope (fndecl);
22600 : 44625818 : if (!perform_deferred_access_checks (complain))
22601 : : access_ok = false;
22602 : 44625818 : pop_access_scope (fndecl);
22603 : : }
22604 : 44636681 : pop_deferring_access_checks ();
22605 : :
22606 : : /* If we've just instantiated the main entry point for a function,
22607 : : instantiate all the alternate entry points as well. We do this
22608 : : by cloning the instantiation of the main entry point, not by
22609 : : instantiating the template clones. */
22610 : 44636681 : if (tree chain = DECL_CHAIN (gen_tmpl))
22611 : 44325273 : if (DECL_P (chain) && DECL_CLONED_FUNCTION_P (chain))
22612 : 89308 : clone_cdtor (fndecl, /*update_methods=*/false);
22613 : :
22614 : 44636681 : if (!access_ok)
22615 : : {
22616 : 89 : if (!(complain & tf_error))
22617 : : {
22618 : : /* Remember to reinstantiate when we're out of SFINAE so the user
22619 : : can see the errors. */
22620 : 89 : FNDECL_HAS_ACCESS_ERRORS (fndecl) = true;
22621 : : }
22622 : 89 : return error_mark_node;
22623 : : }
22624 : :
22625 : : return fndecl;
22626 : 157536933 : }
22627 : :
22628 : : /* Instantiate the alias template TMPL with ARGS. Also push a template
22629 : : instantiation level, which instantiate_template doesn't do because
22630 : : functions and variables have sufficient context established by the
22631 : : callers. */
22632 : :
22633 : : static tree
22634 : 92199444 : instantiate_alias_template (tree tmpl, tree args, tsubst_flags_t complain)
22635 : : {
22636 : 92199444 : if (tmpl == error_mark_node || args == error_mark_node)
22637 : : return error_mark_node;
22638 : :
22639 : 91183351 : args = coerce_template_parms (DECL_TEMPLATE_PARMS (tmpl),
22640 : : args, tmpl, complain);
22641 : 91183351 : if (args == error_mark_node)
22642 : : return error_mark_node;
22643 : :
22644 : : /* FIXME check for satisfaction in check_instantiated_args. */
22645 : 91182624 : if (!constraints_satisfied_p (tmpl, args))
22646 : : {
22647 : 55776 : if (complain & tf_error)
22648 : : {
22649 : 31 : auto_diagnostic_group d;
22650 : 31 : error ("template constraint failure for %qD", tmpl);
22651 : 31 : diagnose_constraints (input_location, tmpl, args);
22652 : 31 : }
22653 : 55776 : return error_mark_node;
22654 : : }
22655 : :
22656 : 91126848 : if (!push_tinst_level (tmpl, args))
22657 : 0 : return error_mark_node;
22658 : 91126845 : tree r = instantiate_template (tmpl, args, complain);
22659 : 91126845 : pop_tinst_level ();
22660 : :
22661 : 91126845 : if (tree d = dependent_alias_template_spec_p (TREE_TYPE (r), nt_opaque))
22662 : : {
22663 : : /* Note this is also done at parse time from push_template_decl. */
22664 : : /* An alias template specialization can be dependent
22665 : : even if its underlying type is not. */
22666 : 6971145 : TYPE_DEPENDENT_P (d) = true;
22667 : 6971145 : TYPE_DEPENDENT_P_VALID (d) = true;
22668 : : /* Sometimes a dependent alias spec is equivalent to its expansion,
22669 : : sometimes not. So always use structural_comptypes. */
22670 : 6971145 : SET_TYPE_STRUCTURAL_EQUALITY (d);
22671 : : }
22672 : :
22673 : : return r;
22674 : : }
22675 : :
22676 : : /* PARM is a template parameter pack for FN. Returns true iff
22677 : : PARM is used in a deducible way in the argument list of FN. */
22678 : :
22679 : : static bool
22680 : 5622541 : pack_deducible_p (tree parm, tree fn)
22681 : : {
22682 : 5622541 : tree t = FUNCTION_FIRST_USER_PARMTYPE (fn);
22683 : 11281690 : for (; t; t = TREE_CHAIN (t))
22684 : : {
22685 : 5659411 : tree type = TREE_VALUE (t);
22686 : 5659411 : tree packs;
22687 : 5659411 : if (!PACK_EXPANSION_P (type))
22688 : 5659115 : continue;
22689 : 592 : for (packs = PACK_EXPANSION_PARAMETER_PACKS (type);
22690 : 333 : packs; packs = TREE_CHAIN (packs))
22691 : 299 : if (template_args_equal (TREE_VALUE (packs), parm))
22692 : : {
22693 : : /* The template parameter pack is used in a function parameter
22694 : : pack. If this is the end of the parameter list, the
22695 : : template parameter pack is deducible. */
22696 : 262 : if (TREE_CHAIN (t) == void_list_node)
22697 : : return true;
22698 : : else
22699 : : /* Otherwise, not. Well, it could be deduced from
22700 : : a non-pack parameter, but doing so would end up with
22701 : : a deduction mismatch, so don't bother. */
22702 : : return false;
22703 : : }
22704 : : }
22705 : : /* The template parameter pack isn't used in any function parameter
22706 : : packs, but it might be used deeper, e.g. tuple<Args...>. */
22707 : : return true;
22708 : : }
22709 : :
22710 : : /* Subroutine of fn_type_unification: check non-dependent parms for
22711 : : convertibility. */
22712 : :
22713 : : static int
22714 : 71909285 : check_non_deducible_conversions (tree parms, const tree *args, unsigned nargs,
22715 : : tree fn, unification_kind_t strict, int flags,
22716 : : struct conversion **convs, bool explain_p,
22717 : : bool noninst_only_p)
22718 : : {
22719 : : /* Non-constructor methods need to leave a conversion for 'this', which
22720 : : isn't included in nargs here. */
22721 : 71909285 : unsigned offset = (DECL_IOBJ_MEMBER_FUNCTION_P (fn)
22722 : 84516972 : && !DECL_CONSTRUCTOR_P (fn));
22723 : :
22724 : 71909285 : for (unsigned ia = 0;
22725 : 165729716 : parms && parms != void_list_node && ia < nargs; )
22726 : : {
22727 : 96548129 : tree parm = TREE_VALUE (parms);
22728 : :
22729 : 96548129 : if (TREE_CODE (parm) == TYPE_PACK_EXPANSION
22730 : 96548129 : && (!TREE_CHAIN (parms)
22731 : 706782 : || TREE_CHAIN (parms) == void_list_node))
22732 : : /* For a function parameter pack that occurs at the end of the
22733 : : parameter-declaration-list, the type A of each remaining
22734 : : argument of the call is compared with the type P of the
22735 : : declarator-id of the function parameter pack. */
22736 : : break;
22737 : :
22738 : 95841437 : parms = TREE_CHAIN (parms);
22739 : :
22740 : 95841437 : if (TREE_CODE (parm) == TYPE_PACK_EXPANSION)
22741 : : /* For a function parameter pack that does not occur at the
22742 : : end of the parameter-declaration-list, the type of the
22743 : : parameter pack is a non-deduced context. */
22744 : 96 : continue;
22745 : :
22746 : 95841341 : if (!uses_template_parms (parm))
22747 : : {
22748 : 22433836 : tree arg = args[ia];
22749 : 22433836 : conversion **conv_p = convs ? &convs[ia+offset] : NULL;
22750 : 22433836 : int lflags = conv_flags (ia, nargs, fn, arg, flags);
22751 : :
22752 : 22433836 : if (check_non_deducible_conversion (parm, arg, strict, lflags,
22753 : : conv_p, explain_p, noninst_only_p))
22754 : : return 1;
22755 : : }
22756 : :
22757 : 93820335 : ++ia;
22758 : : }
22759 : :
22760 : : return 0;
22761 : : }
22762 : :
22763 : : /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
22764 : : NARGS elements of the arguments that are being used when calling
22765 : : it. TARGS is a vector into which the deduced template arguments
22766 : : are placed.
22767 : :
22768 : : Returns either a FUNCTION_DECL for the matching specialization of FN or
22769 : : NULL_TREE if no suitable specialization can be found. If EXPLAIN_P is
22770 : : true, diagnostics will be printed to explain why it failed.
22771 : :
22772 : : If FN is a conversion operator, or we are trying to produce a specific
22773 : : specialization, RETURN_TYPE is the return type desired.
22774 : :
22775 : : The EXPLICIT_TARGS are explicit template arguments provided via a
22776 : : template-id.
22777 : :
22778 : : The parameter STRICT is one of:
22779 : :
22780 : : DEDUCE_CALL:
22781 : : We are deducing arguments for a function call, as in
22782 : : [temp.deduct.call]. If RETURN_TYPE is non-null, we are
22783 : : deducing arguments for a call to the result of a conversion
22784 : : function template, as in [over.call.object].
22785 : :
22786 : : DEDUCE_CONV:
22787 : : We are deducing arguments for a conversion function, as in
22788 : : [temp.deduct.conv].
22789 : :
22790 : : DEDUCE_EXACT:
22791 : : We are deducing arguments when doing an explicit instantiation
22792 : : as in [temp.explicit], when determining an explicit specialization
22793 : : as in [temp.expl.spec], or when taking the address of a function
22794 : : template, as in [temp.deduct.funcaddr]. */
22795 : :
22796 : : tree
22797 : 307095332 : fn_type_unification (tree fn,
22798 : : tree explicit_targs,
22799 : : tree targs,
22800 : : const tree *args,
22801 : : unsigned int nargs,
22802 : : tree return_type,
22803 : : unification_kind_t strict,
22804 : : int flags,
22805 : : struct conversion **convs,
22806 : : bool explain_p,
22807 : : bool decltype_p)
22808 : : {
22809 : 307095332 : tree parms;
22810 : 307095332 : tree fntype;
22811 : 307095332 : tree decl = NULL_TREE;
22812 : 307095332 : tsubst_flags_t complain = (explain_p ? tf_warning_or_error : tf_none);
22813 : 307095332 : bool ok;
22814 : 307095332 : static int deduction_depth;
22815 : : /* type_unification_real will pass back any access checks from default
22816 : : template argument substitution. */
22817 : 307095332 : vec<deferred_access_check, va_gc> *checks = NULL;
22818 : : /* We don't have all the template args yet. */
22819 : 307095332 : bool incomplete = true;
22820 : :
22821 : 307095332 : tree orig_fn = fn;
22822 : 307095332 : if (flag_new_inheriting_ctors)
22823 : 307093534 : fn = strip_inheriting_ctors (fn);
22824 : :
22825 : 307095332 : tree tparms = DECL_INNERMOST_TEMPLATE_PARMS (fn);
22826 : 307095332 : tree r = error_mark_node;
22827 : :
22828 : 307095332 : tree full_targs = targs;
22829 : 614190664 : if (TMPL_ARGS_DEPTH (targs)
22830 : 307095332 : < TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (fn)))
22831 : 48489 : full_targs = (add_outermost_template_args
22832 : 48489 : (DECL_TI_ARGS (DECL_TEMPLATE_RESULT (fn)),
22833 : : targs));
22834 : :
22835 : 307095332 : if (decltype_p)
22836 : 14382587 : complain |= tf_decltype;
22837 : :
22838 : : /* In C++0x, it's possible to have a function template whose type depends
22839 : : on itself recursively. This is most obvious with decltype, but can also
22840 : : occur with enumeration scope (c++/48969). So we need to catch infinite
22841 : : recursion and reject the substitution at deduction time; this function
22842 : : will return error_mark_node for any repeated substitution.
22843 : :
22844 : : This also catches excessive recursion such as when f<N> depends on
22845 : : f<N-1> across all integers, and returns error_mark_node for all the
22846 : : substitutions back up to the initial one.
22847 : :
22848 : : This is, of course, not reentrant. */
22849 : 307095332 : if (excessive_deduction_depth)
22850 : 0 : return error_mark_node;
22851 : 307095332 : ++deduction_depth;
22852 : :
22853 : 307095332 : gcc_assert (TREE_CODE (fn) == TEMPLATE_DECL);
22854 : :
22855 : 307095332 : fntype = TREE_TYPE (fn);
22856 : 307095332 : if (explicit_targs)
22857 : : {
22858 : : /* [temp.deduct]
22859 : :
22860 : : The specified template arguments must match the template
22861 : : parameters in kind (i.e., type, nontype, template), and there
22862 : : must not be more arguments than there are parameters;
22863 : : otherwise type deduction fails.
22864 : :
22865 : : Nontype arguments must match the types of the corresponding
22866 : : nontype template parameters, or must be convertible to the
22867 : : types of the corresponding nontype parameters as specified in
22868 : : _temp.arg.nontype_, otherwise type deduction fails.
22869 : :
22870 : : All references in the function type of the function template
22871 : : to the corresponding template parameters are replaced by the
22872 : : specified template argument values. If a substitution in a
22873 : : template parameter or in the function type of the function
22874 : : template results in an invalid type, type deduction fails. */
22875 : 32268170 : int i, len = TREE_VEC_LENGTH (tparms);
22876 : 32268170 : location_t loc = input_location;
22877 : 32268170 : incomplete = false;
22878 : :
22879 : 32268170 : if (explicit_targs == error_mark_node)
22880 : 13 : goto fail;
22881 : :
22882 : 64536314 : if (TMPL_ARGS_DEPTH (explicit_targs)
22883 : 64536314 : < TMPL_ARGS_DEPTH (full_targs))
22884 : 19579 : explicit_targs = add_outermost_template_args (full_targs,
22885 : : explicit_targs);
22886 : :
22887 : : /* Adjust any explicit template arguments before entering the
22888 : : substitution context. */
22889 : 32268157 : explicit_targs
22890 : 32268157 : = (coerce_template_parms (tparms, explicit_targs, fn,
22891 : : complain|tf_partial,
22892 : : /*require_all_args=*/false));
22893 : 32268157 : if (explicit_targs == error_mark_node)
22894 : 2158758 : goto fail;
22895 : :
22896 : : /* Substitute the explicit args into the function type. This is
22897 : : necessary so that, for instance, explicitly declared function
22898 : : arguments can match null pointed constants. If we were given
22899 : : an incomplete set of explicit args, we must not do semantic
22900 : : processing during substitution as we could create partial
22901 : : instantiations. */
22902 : 73189415 : for (i = 0; i < len; i++)
22903 : : {
22904 : 43080016 : tree parm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
22905 : 43080016 : bool parameter_pack = false;
22906 : 43080016 : tree targ = TREE_VEC_ELT (explicit_targs, i);
22907 : :
22908 : : /* Dig out the actual parm. */
22909 : 43080016 : if (TREE_CODE (parm) == TYPE_DECL
22910 : 3988778 : || TREE_CODE (parm) == TEMPLATE_DECL)
22911 : : {
22912 : 39094301 : parm = TREE_TYPE (parm);
22913 : 39094301 : parameter_pack = TEMPLATE_TYPE_PARAMETER_PACK (parm);
22914 : : }
22915 : 3985715 : else if (TREE_CODE (parm) == PARM_DECL)
22916 : : {
22917 : 3985715 : parm = DECL_INITIAL (parm);
22918 : 3985715 : parameter_pack = TEMPLATE_PARM_PARAMETER_PACK (parm);
22919 : : }
22920 : :
22921 : 43080016 : if (targ == NULL_TREE)
22922 : : /* No explicit argument for this template parameter. */
22923 : : incomplete = true;
22924 : 36015179 : else if (parameter_pack && pack_deducible_p (parm, fn))
22925 : : {
22926 : : /* Mark the argument pack as "incomplete". We could
22927 : : still deduce more arguments during unification.
22928 : : We remove this mark in type_unification_real. */
22929 : 5622520 : ARGUMENT_PACK_INCOMPLETE_P(targ) = 1;
22930 : 5622520 : ARGUMENT_PACK_EXPLICIT_ARGS (targ)
22931 : 5622520 : = ARGUMENT_PACK_ARGS (targ);
22932 : :
22933 : : /* We have some incomplete argument packs. */
22934 : 5622520 : incomplete = true;
22935 : : }
22936 : : }
22937 : :
22938 : 30109399 : if (incomplete)
22939 : : {
22940 : 10219458 : if (!push_tinst_level (fn, explicit_targs))
22941 : : {
22942 : 0 : excessive_deduction_depth = true;
22943 : 0 : goto fail;
22944 : : }
22945 : 10219452 : ++processing_template_decl;
22946 : 10219452 : input_location = DECL_SOURCE_LOCATION (fn);
22947 : : /* Ignore any access checks; we'll see them again in
22948 : : instantiate_template and they might have the wrong
22949 : : access path at this point. */
22950 : 10219452 : push_deferring_access_checks (dk_deferred);
22951 : 10219452 : tsubst_flags_t ecomplain = complain | tf_partial | tf_fndecl_type;
22952 : 10219452 : fntype = tsubst (TREE_TYPE (fn), explicit_targs, ecomplain, NULL_TREE);
22953 : 10216755 : pop_deferring_access_checks ();
22954 : 10216755 : input_location = loc;
22955 : 10216755 : --processing_template_decl;
22956 : 10216755 : pop_tinst_level ();
22957 : :
22958 : 10216755 : if (fntype == error_mark_node)
22959 : 684 : goto fail;
22960 : : }
22961 : :
22962 : : /* Place the explicitly specified arguments in TARGS. */
22963 : 30106012 : explicit_targs = INNERMOST_TEMPLATE_ARGS (explicit_targs);
22964 : 73179134 : for (i = NUM_TMPL_ARGS (explicit_targs); i--;)
22965 : 43073122 : TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (explicit_targs, i);
22966 : 30106012 : if (!incomplete && CHECKING_P
22967 : 49995953 : && !NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs))
22968 : 19889941 : SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
22969 : : (targs, NUM_TMPL_ARGS (explicit_targs));
22970 : : }
22971 : :
22972 : 304933174 : if (return_type && strict != DEDUCE_CALL)
22973 : : {
22974 : 11788187 : tree *new_args = XALLOCAVEC (tree, nargs + 1);
22975 : 11788187 : new_args[0] = return_type;
22976 : 11788187 : memcpy (new_args + 1, args, nargs * sizeof (tree));
22977 : 11788187 : args = new_args;
22978 : 11788187 : ++nargs;
22979 : : }
22980 : :
22981 : 304933174 : if (!incomplete)
22982 : 19889941 : goto deduced;
22983 : :
22984 : : /* Never do unification on the 'this' parameter. */
22985 : 285043233 : parms = skip_artificial_parms_for (fn, TYPE_ARG_TYPES (fntype));
22986 : :
22987 : 285043233 : if (return_type && strict == DEDUCE_CALL)
22988 : : {
22989 : : /* We're deducing for a call to the result of a template conversion
22990 : : function. The parms we really want are in return_type. */
22991 : 15 : if (INDIRECT_TYPE_P (return_type))
22992 : 15 : return_type = TREE_TYPE (return_type);
22993 : 15 : parms = TYPE_ARG_TYPES (return_type);
22994 : : }
22995 : 285043218 : else if (return_type)
22996 : : {
22997 : 10920683 : parms = tree_cons (NULL_TREE, TREE_TYPE (fntype), parms);
22998 : : }
22999 : :
23000 : : /* We allow incomplete unification without an error message here
23001 : : because the standard doesn't seem to explicitly prohibit it. Our
23002 : : callers must be ready to deal with unification failures in any
23003 : : event. */
23004 : :
23005 : : /* If we aren't explaining yet, push tinst context so we can see where
23006 : : any errors (e.g. from class instantiations triggered by instantiation
23007 : : of default template arguments) come from. If we are explaining, this
23008 : : context is redundant. */
23009 : 285043233 : if (!explain_p && !push_tinst_level (fn, targs))
23010 : : {
23011 : 0 : excessive_deduction_depth = true;
23012 : 0 : goto fail;
23013 : : }
23014 : :
23015 : 285043227 : ok = !type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn),
23016 : : full_targs, parms, args, nargs, /*subr=*/0,
23017 : : strict, &checks, explain_p);
23018 : 285043227 : if (!explain_p)
23019 : 285040173 : pop_tinst_level ();
23020 : 285043227 : if (!ok)
23021 : 247404276 : goto fail;
23022 : :
23023 : : /* Now that we have bindings for all of the template arguments,
23024 : : ensure that the arguments deduced for the template template
23025 : : parameters have compatible template parameter lists. We cannot
23026 : : check this property before we have deduced all template
23027 : : arguments, because the template parameter types of a template
23028 : : template parameter might depend on prior template parameters
23029 : : deduced after the template template parameter. The following
23030 : : ill-formed example illustrates this issue:
23031 : :
23032 : : template<typename T, template<T> class C> void f(C<5>, T);
23033 : :
23034 : : template<int N> struct X {};
23035 : :
23036 : : void g() {
23037 : : f(X<5>(), 5l); // error: template argument deduction fails
23038 : : }
23039 : :
23040 : : The template parameter list of 'C' depends on the template type
23041 : : parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
23042 : : 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
23043 : : time that we deduce 'C'. */
23044 : 75277902 : if (!template_template_parm_bindings_ok_p
23045 : 37638951 : (DECL_INNERMOST_TEMPLATE_PARMS (fn), targs))
23046 : : {
23047 : 24 : unify_inconsistent_template_template_parameters (explain_p);
23048 : 24 : goto fail;
23049 : : }
23050 : :
23051 : 37638927 : deduced:
23052 : :
23053 : : /* As a refinement of CWG2369, check first and foremost non-dependent
23054 : : conversions that we know are not going to induce template instantiation
23055 : : (PR99599). */
23056 : 57528868 : if (strict == DEDUCE_CALL
23057 : 57528868 : && incomplete
23058 : 57528868 : && check_non_deducible_conversions (parms, args, nargs, fn, strict, flags,
23059 : : convs, explain_p,
23060 : : /*noninst_only_p=*/true))
23061 : 1275123 : goto fail;
23062 : :
23063 : : /* CWG2369: Check satisfaction before non-deducible conversions. */
23064 : 56253745 : if (!constraints_satisfied_p (fn, targs))
23065 : : {
23066 : 563284 : if (explain_p)
23067 : 625 : diagnose_constraints (DECL_SOURCE_LOCATION (fn), fn, targs);
23068 : 563284 : goto fail;
23069 : : }
23070 : :
23071 : : /* DR 1391: All parameters have args, now check non-dependent parms for
23072 : : convertibility. We don't do this if all args were explicitly specified,
23073 : : as the standard says that we substitute explicit args immediately. */
23074 : 55687761 : if (incomplete
23075 : 55687761 : && check_non_deducible_conversions (parms, args, nargs, fn, strict, flags,
23076 : : convs, explain_p,
23077 : : /*noninst_only_p=*/false))
23078 : 745883 : goto fail;
23079 : :
23080 : : /* All is well so far. Now, check:
23081 : :
23082 : : [temp.deduct]
23083 : :
23084 : : When all template arguments have been deduced, all uses of
23085 : : template parameters in nondeduced contexts are replaced with
23086 : : the corresponding deduced argument values. If the
23087 : : substitution results in an invalid type, as described above,
23088 : : type deduction fails. */
23089 : 54941878 : if (!push_tinst_level (fn, targs))
23090 : : {
23091 : 0 : excessive_deduction_depth = true;
23092 : 0 : goto fail;
23093 : : }
23094 : :
23095 : : /* Also collect access checks from the instantiation. */
23096 : 54941872 : reopen_deferring_access_checks (checks);
23097 : :
23098 : 54941872 : decl = instantiate_template (fn, targs, complain);
23099 : :
23100 : 54933736 : checks = get_deferred_access_checks ();
23101 : 54933736 : pop_deferring_access_checks ();
23102 : :
23103 : 54933736 : pop_tinst_level ();
23104 : :
23105 : 54933736 : if (decl == error_mark_node)
23106 : 1385669 : goto fail;
23107 : :
23108 : : /* Now perform any access checks encountered during substitution. */
23109 : 53548067 : push_access_scope (decl);
23110 : 53548067 : ok = perform_access_checks (checks, complain);
23111 : 53548067 : pop_access_scope (decl);
23112 : 53548067 : if (!ok)
23113 : 22 : goto fail;
23114 : :
23115 : : /* If we're looking for an exact match, check that what we got
23116 : : is indeed an exact match. It might not be if some template
23117 : : parameters are used in non-deduced contexts. But don't check
23118 : : for an exact match if we have dependent template arguments;
23119 : : in that case we're doing partial ordering, and we already know
23120 : : that we have two candidates that will provide the actual type. */
23121 : 53548045 : if (strict == DEDUCE_EXACT && !any_dependent_template_arguments_p (targs))
23122 : : {
23123 : 2138566 : tree substed = TREE_TYPE (decl);
23124 : 2138566 : unsigned int i;
23125 : :
23126 : 2138566 : tree sarg
23127 : 2138566 : = skip_artificial_parms_for (decl, TYPE_ARG_TYPES (substed));
23128 : 2138566 : if (return_type)
23129 : 2138374 : sarg = tree_cons (NULL_TREE, TREE_TYPE (substed), sarg);
23130 : 9516226 : for (i = 0; i < nargs && sarg; ++i, sarg = TREE_CHAIN (sarg))
23131 : 7382701 : if (!same_type_p (args[i], TREE_VALUE (sarg)))
23132 : : {
23133 : 5041 : unify_type_mismatch (explain_p, args[i],
23134 : 5041 : TREE_VALUE (sarg));
23135 : 5041 : goto fail;
23136 : : }
23137 : 2133525 : if ((i < nargs || sarg)
23138 : : /* add_candidates uses DEDUCE_EXACT for x.operator foo(), but args
23139 : : doesn't contain the trailing void, and conv fns are always (). */
23140 : 2133525 : && !DECL_CONV_FN_P (decl))
23141 : : {
23142 : 6 : unsigned nsargs = i + list_length (sarg);
23143 : 6 : unify_arity (explain_p, nargs, nsargs);
23144 : 6 : goto fail;
23145 : : }
23146 : : }
23147 : :
23148 : : /* After doing deduction with the inherited constructor, actually return an
23149 : : instantiation of the inheriting constructor. */
23150 : 53542998 : if (orig_fn != fn)
23151 : 16383 : decl = instantiate_template (orig_fn, targs, complain);
23152 : :
23153 : : r = decl;
23154 : :
23155 : 307081781 : fail:
23156 : 307081781 : --deduction_depth;
23157 : 307081781 : if (excessive_deduction_depth)
23158 : : {
23159 : 0 : if (deduction_depth == 0)
23160 : : /* Reset once we're all the way out. */
23161 : 0 : excessive_deduction_depth = false;
23162 : : }
23163 : :
23164 : : return r;
23165 : : }
23166 : :
23167 : : /* Returns true iff PARM is a forwarding reference in the context of
23168 : : template argument deduction for TMPL. */
23169 : :
23170 : : static bool
23171 : 313308367 : forwarding_reference_p (tree parm, tree tmpl)
23172 : : {
23173 : : /* [temp.deduct.call], "A forwarding reference is an rvalue reference to a
23174 : : cv-unqualified template parameter ..." */
23175 : 313308367 : if (TYPE_REF_P (parm)
23176 : 265541109 : && TYPE_REF_IS_RVALUE (parm)
23177 : 12055589 : && TREE_CODE (TREE_TYPE (parm)) == TEMPLATE_TYPE_PARM
23178 : 320633880 : && cp_type_quals (TREE_TYPE (parm)) == TYPE_UNQUALIFIED)
23179 : : {
23180 : 7220207 : parm = TREE_TYPE (parm);
23181 : : /* [temp.deduct.call], "... that does not represent a template parameter
23182 : : of a class template (during class template argument deduction)." */
23183 : 7220207 : if (tmpl
23184 : 7118319 : && deduction_guide_p (tmpl)
23185 : 7235273 : && DECL_ARTIFICIAL (tmpl))
23186 : : {
23187 : : /* Since the template parameters of a synthesized guide consist of
23188 : : the template parameters of the class template followed by those of
23189 : : the constructor (if any), we can tell if PARM represents a template
23190 : : parameter of the class template by comparing its index with the
23191 : : arity of the class template. */
23192 : 8167 : tree ctmpl = CLASSTYPE_TI_TEMPLATE (TREE_TYPE (TREE_TYPE (tmpl)));
23193 : 8167 : if (TEMPLATE_TYPE_IDX (parm)
23194 : 8167 : < TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (ctmpl)))
23195 : : return false;
23196 : : }
23197 : 7219835 : return true;
23198 : : }
23199 : : return false;
23200 : : }
23201 : :
23202 : : /* Adjust types before performing type deduction, as described in
23203 : : [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
23204 : : sections are symmetric. PARM is the type of a function parameter
23205 : : or the return type of the conversion function. ARG is the type of
23206 : : the argument passed to the call, or the type of the value
23207 : : initialized with the result of the conversion function.
23208 : : ARG_EXPR is the original argument expression, which may be null. */
23209 : :
23210 : : static int
23211 : 313308367 : maybe_adjust_types_for_deduction (tree tparms,
23212 : : unification_kind_t strict,
23213 : : tree* parm,
23214 : : tree* arg,
23215 : : tree arg_expr)
23216 : : {
23217 : 313308367 : int result = 0;
23218 : :
23219 : 313308367 : switch (strict)
23220 : : {
23221 : : case DEDUCE_CALL:
23222 : : break;
23223 : :
23224 : 72749 : case DEDUCE_CONV:
23225 : : /* [temp.deduct.conv] First remove a reference type on parm.
23226 : : DRs 322 & 976 affected this. */
23227 : 72749 : if (TYPE_REF_P (*parm))
23228 : 89 : *parm = TREE_TYPE (*parm);
23229 : :
23230 : : /* Swap PARM and ARG throughout the remainder of this
23231 : : function; the handling is precisely symmetric since PARM
23232 : : will initialize ARG rather than vice versa. */
23233 : : std::swap (parm, arg);
23234 : :
23235 : : break;
23236 : :
23237 : 28382039 : case DEDUCE_EXACT:
23238 : : /* Core issue #873: Do the DR606 thing (see below) for these cases,
23239 : : too, but here handle it by stripping the reference from PARM
23240 : : rather than by adding it to ARG. */
23241 : 28382039 : if (forwarding_reference_p (*parm, TPARMS_PRIMARY_TEMPLATE (tparms))
23242 : 1170317 : && TYPE_REF_P (*arg)
23243 : 29439517 : && !TYPE_REF_IS_RVALUE (*arg))
23244 : 1057439 : *parm = TREE_TYPE (*parm);
23245 : : /* Nothing else to do in this case. */
23246 : : return 0;
23247 : :
23248 : 0 : default:
23249 : 0 : gcc_unreachable ();
23250 : : }
23251 : :
23252 : 284926328 : if (!TYPE_REF_P (*parm))
23253 : : {
23254 : : /* [temp.deduct.call]
23255 : :
23256 : : If P is not a reference type:
23257 : :
23258 : : --If A is an array type, the pointer type produced by the
23259 : : array-to-pointer standard conversion (_conv.array_) is
23260 : : used in place of A for type deduction; otherwise,
23261 : :
23262 : : --If A is a function type, the pointer type produced by
23263 : : the function-to-pointer standard conversion
23264 : : (_conv.func_) is used in place of A for type deduction;
23265 : : otherwise,
23266 : :
23267 : : --If A is a cv-qualified type, the top level
23268 : : cv-qualifiers of A's type are ignored for type
23269 : : deduction. */
23270 : 41232443 : if (TREE_CODE (*arg) == ARRAY_TYPE)
23271 : 357177 : *arg = build_pointer_type (TREE_TYPE (*arg));
23272 : 40875266 : else if (TREE_CODE (*arg) == FUNCTION_TYPE)
23273 : 4273 : *arg = build_pointer_type (*arg);
23274 : : else
23275 : 40870993 : *arg = TYPE_MAIN_VARIANT (*arg);
23276 : : }
23277 : :
23278 : : /* [temp.deduct.call], "If P is a forwarding reference and the argument is
23279 : : an lvalue, the type 'lvalue reference to A' is used in place of A for
23280 : : type deduction." */
23281 : 284926328 : if (forwarding_reference_p (*parm, TPARMS_PRIMARY_TEMPLATE (tparms))
23282 : 284926328 : && (arg_expr ? lvalue_p (arg_expr)
23283 : : /* try_one_overload doesn't provide an arg_expr, but
23284 : : functions are always lvalues. */
23285 : 47 : : TREE_CODE (*arg) == FUNCTION_TYPE))
23286 : 2229500 : *arg = build_reference_type (*arg);
23287 : :
23288 : : /* [temp.deduct.call]
23289 : :
23290 : : If P is a cv-qualified type, the top level cv-qualifiers
23291 : : of P's type are ignored for type deduction. If P is a
23292 : : reference type, the type referred to by P is used for
23293 : : type deduction. */
23294 : 284926328 : *parm = TYPE_MAIN_VARIANT (*parm);
23295 : 284926328 : if (TYPE_REF_P (*parm))
23296 : : {
23297 : 243693885 : *parm = TREE_TYPE (*parm);
23298 : 243693885 : result |= UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
23299 : : }
23300 : :
23301 : : return result;
23302 : : }
23303 : :
23304 : : /* Return true if computing a conversion from FROM to TO might induce template
23305 : : instantiation. Conversely, if this predicate returns false then computing
23306 : : the conversion definitely won't induce template instantiation. */
23307 : :
23308 : : static bool
23309 : 4620552 : conversion_may_instantiate_p (tree to, tree from)
23310 : : {
23311 : 4620552 : to = non_reference (to);
23312 : 4620552 : from = non_reference (from);
23313 : :
23314 : 4620552 : bool ptr_conv_p = false;
23315 : 4620552 : if (TYPE_PTR_P (to)
23316 : 1335233 : && TYPE_PTR_P (from))
23317 : : {
23318 : 204168 : to = TREE_TYPE (to);
23319 : 204168 : from = TREE_TYPE (from);
23320 : 204168 : ptr_conv_p = true;
23321 : : }
23322 : :
23323 : : /* If one of the types is a not-yet-instantiated class template
23324 : : specialization, then computing the conversion might instantiate
23325 : : it in order to inspect bases, conversion functions and/or
23326 : : converting constructors. */
23327 : 1866956 : if ((CLASS_TYPE_P (to)
23328 : 1866884 : && !COMPLETE_TYPE_P (to)
23329 : 9833 : && CLASSTYPE_TEMPLATE_INSTANTIATION (to))
23330 : 6477681 : || (CLASS_TYPE_P (from)
23331 : 2256830 : && !COMPLETE_TYPE_P (from)
23332 : 11 : && CLASSTYPE_TEMPLATE_INSTANTIATION (from)))
23333 : : return true;
23334 : :
23335 : : /* Converting from one pointer type to another, or between
23336 : : reference-related types, always yields a standard conversion. */
23337 : 4610725 : if (ptr_conv_p || reference_related_p (to, from))
23338 : 1723265 : return false;
23339 : :
23340 : : /* Converting to a non-aggregate class type will consider its
23341 : : user-declared constructors, which might induce instantiation. */
23342 : 945896 : if (CLASS_TYPE_P (to)
23343 : 3833356 : && CLASSTYPE_NON_AGGREGATE (to))
23344 : : return true;
23345 : :
23346 : : /* Similarly, converting from a class type will consider its conversion
23347 : : functions. */
23348 : 1052858 : if (CLASS_TYPE_P (from)
23349 : 3445365 : && TYPE_HAS_CONVERSION (from))
23350 : : return true;
23351 : :
23352 : : /* Otherwise, computing this conversion definitely won't induce
23353 : : template instantiation. */
23354 : : return false;
23355 : : }
23356 : :
23357 : : /* Subroutine of fn_type_unification. PARM is a function parameter of a
23358 : : template which doesn't contain any deducible template parameters; check if
23359 : : ARG is a suitable match for it. STRICT, FLAGS and EXPLAIN_P are as in
23360 : : unify_one_argument. */
23361 : :
23362 : : static int
23363 : 22433836 : check_non_deducible_conversion (tree parm, tree arg, unification_kind_t strict,
23364 : : int flags, struct conversion **conv_p,
23365 : : bool explain_p, bool noninst_only_p)
23366 : : {
23367 : 22433836 : tree type;
23368 : :
23369 : 22433836 : if (!TYPE_P (arg))
23370 : 21420029 : type = TREE_TYPE (arg);
23371 : : else
23372 : : type = arg;
23373 : :
23374 : 22433836 : if (same_type_p (parm, type))
23375 : 20412830 : return unify_success (explain_p);
23376 : :
23377 : 7768611 : tsubst_flags_t complain = (explain_p ? tf_warning_or_error : tf_none);
23378 : 7768611 : if (strict == DEDUCE_CONV)
23379 : : {
23380 : 27 : if (can_convert_arg (type, parm, NULL_TREE, flags, complain))
23381 : 20412830 : return unify_success (explain_p);
23382 : : }
23383 : 7768584 : else if (strict == DEDUCE_CALL)
23384 : : {
23385 : 7768584 : if (conv_p && *conv_p)
23386 : : {
23387 : : /* This conversion was already computed earlier (when
23388 : : computing only non-instantiating conversions). */
23389 : 2296237 : gcc_checking_assert (!noninst_only_p);
23390 : 20412830 : return unify_success (explain_p);
23391 : : }
23392 : :
23393 : 5472347 : if (noninst_only_p
23394 : 5472347 : && conversion_may_instantiate_p (parm, type))
23395 : 20412830 : return unify_success (explain_p);
23396 : :
23397 : 4511858 : bool ok = false;
23398 : 4511858 : tree conv_arg = TYPE_P (arg) ? NULL_TREE : arg;
23399 : 4511858 : if (conv_p)
23400 : : /* Avoid recalculating this in add_function_candidate. */
23401 : 9023114 : ok = (*conv_p
23402 : 4511557 : = good_conversion (parm, type, conv_arg, flags, complain));
23403 : : else
23404 : 301 : ok = can_convert_arg (parm, type, conv_arg, flags, complain);
23405 : 4511858 : if (ok)
23406 : 20412830 : return unify_success (explain_p);
23407 : : }
23408 : :
23409 : 2021006 : if (strict == DEDUCE_EXACT)
23410 : 0 : return unify_type_mismatch (explain_p, parm, arg);
23411 : : else
23412 : 2021006 : return unify_arg_conversion (explain_p, parm, type, arg);
23413 : : }
23414 : :
23415 : : static bool uses_deducible_template_parms (tree type);
23416 : :
23417 : : /* Returns true iff the expression EXPR is one from which a template
23418 : : argument can be deduced. In other words, if it's an undecorated
23419 : : use of a template non-type parameter. */
23420 : :
23421 : : static bool
23422 : 921602 : deducible_expression (tree expr)
23423 : : {
23424 : : /* Strip implicit conversions and implicit INDIRECT_REFs. */
23425 : 1843240 : while (CONVERT_EXPR_P (expr)
23426 : 921620 : || TREE_CODE (expr) == VIEW_CONVERT_EXPR
23427 : 921611 : || TREE_CODE (expr) == IMPLICIT_CONV_EXPR
23428 : 1843521 : || REFERENCE_REF_P (expr))
23429 : 311 : expr = TREE_OPERAND (expr, 0);
23430 : 921602 : return (TREE_CODE (expr) == TEMPLATE_PARM_INDEX);
23431 : : }
23432 : :
23433 : : /* Returns true iff the array domain DOMAIN uses a template parameter in a
23434 : : deducible way; that is, if it has a max value of <PARM> - 1. */
23435 : :
23436 : : static bool
23437 : 37902 : deducible_array_bound (tree domain)
23438 : : {
23439 : 37902 : if (domain == NULL_TREE)
23440 : : return false;
23441 : :
23442 : 37833 : tree max = TYPE_MAX_VALUE (domain);
23443 : 37833 : if (TREE_CODE (max) != MINUS_EXPR)
23444 : : return false;
23445 : :
23446 : 37589 : return deducible_expression (TREE_OPERAND (max, 0));
23447 : : }
23448 : :
23449 : : /* Returns true iff the template arguments ARGS use a template parameter
23450 : : in a deducible way. */
23451 : :
23452 : : static bool
23453 : 246709303 : deducible_template_args (tree args)
23454 : : {
23455 : 254572886 : for (tree elt : tree_vec_range (args))
23456 : : {
23457 : 249584231 : bool deducible;
23458 : 249584231 : if (ARGUMENT_PACK_P (elt))
23459 : 11366900 : deducible = deducible_template_args (ARGUMENT_PACK_ARGS (elt));
23460 : : else
23461 : : {
23462 : 238217331 : if (PACK_EXPANSION_P (elt))
23463 : 11042589 : elt = PACK_EXPANSION_PATTERN (elt);
23464 : 238217331 : if (TREE_CODE (elt) == TEMPLATE_TEMPLATE_PARM)
23465 : : deducible = true;
23466 : 238217277 : else if (TYPE_P (elt))
23467 : 237333282 : deducible = uses_deducible_template_parms (elt);
23468 : : else
23469 : 883995 : deducible = deducible_expression (elt);
23470 : : }
23471 : 249584177 : if (deducible)
23472 : 241720648 : return true;
23473 : : }
23474 : 4988655 : return false;
23475 : : }
23476 : :
23477 : : /* Returns true iff TYPE contains any deducible references to template
23478 : : parameters, as per 14.8.2.5. */
23479 : :
23480 : : static bool
23481 : 564195708 : uses_deducible_template_parms (tree type)
23482 : : {
23483 : 829372965 : if (PACK_EXPANSION_P (type))
23484 : 90 : type = PACK_EXPANSION_PATTERN (type);
23485 : :
23486 : : /* T
23487 : : cv-list T
23488 : : TT<T>
23489 : : TT<i>
23490 : : TT<> */
23491 : 829372965 : if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
23492 : 544529457 : || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
23493 : : return true;
23494 : :
23495 : : /* T*
23496 : : T&
23497 : : T&& */
23498 : 544528643 : if (INDIRECT_TYPE_P (type))
23499 : 265177257 : return uses_deducible_template_parms (TREE_TYPE (type));
23500 : :
23501 : : /* T[integer-constant ]
23502 : : type [i] */
23503 : 279351386 : if (TREE_CODE (type) == ARRAY_TYPE)
23504 : 534577 : return (uses_deducible_template_parms (TREE_TYPE (type))
23505 : 572406 : || deducible_array_bound (TYPE_DOMAIN (type)));
23506 : :
23507 : : /* T type ::*
23508 : : type T::*
23509 : : T T::*
23510 : : T (type ::*)()
23511 : : type (T::*)()
23512 : : type (type ::*)(T)
23513 : : type (T::*)(T)
23514 : : T (type ::*)(T)
23515 : : T (T::*)()
23516 : : T (T::*)(T) */
23517 : 278816809 : if (TYPE_PTRMEM_P (type))
23518 : 23518 : return (uses_deducible_template_parms (TYPE_PTRMEM_CLASS_TYPE (type))
23519 : 23858 : || (uses_deducible_template_parms
23520 : 340 : (TYPE_PTRMEM_POINTED_TO_TYPE (type))));
23521 : :
23522 : : /* template-name <T> (where template-name refers to a class template)
23523 : : template-name <i> (where template-name refers to a class template) */
23524 : 239841464 : if (CLASS_TYPE_P (type)
23525 : 239841452 : && CLASSTYPE_TEMPLATE_INFO (type)
23526 : 515113487 : && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)))
23527 : 235342403 : return deducible_template_args (INNERMOST_TEMPLATE_ARGS
23528 : 235342403 : (CLASSTYPE_TI_ARGS (type)));
23529 : :
23530 : : /* type (T)
23531 : : T()
23532 : : T(T) */
23533 : 43450888 : if (FUNC_OR_METHOD_TYPE_P (type))
23534 : : {
23535 : 5953581 : if (uses_deducible_template_parms (TREE_TYPE (type)))
23536 : : return true;
23537 : 56886 : tree parm = TYPE_ARG_TYPES (type);
23538 : 56886 : if (TREE_CODE (type) == METHOD_TYPE)
23539 : 252 : parm = TREE_CHAIN (parm);
23540 : 59400 : for (; parm; parm = TREE_CHAIN (parm))
23541 : 57792 : if (uses_deducible_template_parms (TREE_VALUE (parm)))
23542 : : return true;
23543 : 1608 : if (flag_noexcept_type
23544 : 1591 : && TYPE_RAISES_EXCEPTIONS (type)
23545 : 18 : && TREE_PURPOSE (TYPE_RAISES_EXCEPTIONS (type))
23546 : 1626 : && deducible_expression (TREE_PURPOSE (TYPE_RAISES_EXCEPTIONS (type))))
23547 : : return true;
23548 : : }
23549 : :
23550 : : return false;
23551 : : }
23552 : :
23553 : : /* Subroutine of type_unification_real and unify_pack_expansion to
23554 : : handle unification of a single P/A pair. Parameters are as
23555 : : for those functions. */
23556 : :
23557 : : static int
23558 : 355388778 : unify_one_argument (tree tparms, tree targs, tree parm, tree arg,
23559 : : int subr, unification_kind_t strict,
23560 : : bool explain_p)
23561 : : {
23562 : 355388778 : tree arg_expr = NULL_TREE;
23563 : 355388778 : int arg_strict;
23564 : :
23565 : 355388778 : if (arg == error_mark_node || parm == error_mark_node)
23566 : 13 : return unify_invalid (explain_p);
23567 : 355388766 : if (arg == unknown_type_node)
23568 : : /* We can't deduce anything from this, but we might get all the
23569 : : template args from other function args. */
23570 : 35369395 : return unify_success (explain_p);
23571 : :
23572 : : /* Implicit conversions (Clause 4) will be performed on a function
23573 : : argument to convert it to the type of the corresponding function
23574 : : parameter if the parameter type contains no template-parameters that
23575 : : participate in template argument deduction. */
23576 : 355388766 : if (strict != DEDUCE_EXACT
23577 : 355388766 : && TYPE_P (parm) && !uses_deducible_template_parms (parm))
23578 : : /* For function parameters with no deducible template parameters,
23579 : : just return. We'll check non-dependent conversions later. */
23580 : 35369395 : return unify_success (explain_p);
23581 : :
23582 : 320100264 : switch (strict)
23583 : : {
23584 : : case DEDUCE_CALL:
23585 : : arg_strict = (UNIFY_ALLOW_OUTER_LEVEL
23586 : : | UNIFY_ALLOW_MORE_CV_QUAL
23587 : : | UNIFY_ALLOW_DERIVED);
23588 : : break;
23589 : :
23590 : : case DEDUCE_CONV:
23591 : : arg_strict = UNIFY_ALLOW_LESS_CV_QUAL;
23592 : : break;
23593 : :
23594 : : case DEDUCE_EXACT:
23595 : : arg_strict = UNIFY_ALLOW_NONE;
23596 : : break;
23597 : :
23598 : 0 : default:
23599 : 0 : gcc_unreachable ();
23600 : : }
23601 : :
23602 : : /* We only do these transformations if this is the top-level
23603 : : parameter_type_list in a call or declaration matching; in other
23604 : : situations (nested function declarators, template argument lists) we
23605 : : won't be comparing a type to an expression, and we don't do any type
23606 : : adjustments. */
23607 : 320100264 : if (!subr)
23608 : : {
23609 : 313384639 : if (!TYPE_P (arg))
23610 : : {
23611 : 284929851 : gcc_assert (TREE_TYPE (arg) != NULL_TREE);
23612 : 284929851 : if (type_unknown_p (arg))
23613 : : {
23614 : : /* [temp.deduct.type] A template-argument can be
23615 : : deduced from a pointer to function or pointer
23616 : : to member function argument if the set of
23617 : : overloaded functions does not contain function
23618 : : templates and at most one of a set of
23619 : : overloaded functions provides a unique
23620 : : match. */
23621 : 80893 : resolve_overloaded_unification (tparms, targs, parm,
23622 : : arg, strict,
23623 : : arg_strict, explain_p);
23624 : : /* If a unique match was not found, this is a
23625 : : non-deduced context, so we still succeed. */
23626 : 80893 : return unify_success (explain_p);
23627 : : }
23628 : :
23629 : 284848958 : arg_expr = arg;
23630 : 284848958 : arg = unlowered_expr_type (arg);
23631 : 284848958 : if (arg == error_mark_node)
23632 : 13 : return unify_invalid (explain_p);
23633 : : }
23634 : :
23635 : 313303746 : arg_strict |= maybe_adjust_types_for_deduction (tparms, strict,
23636 : : &parm, &arg, arg_expr);
23637 : : }
23638 : : else
23639 : 13431250 : if ((TYPE_P (parm) || TREE_CODE (parm) == TEMPLATE_DECL)
23640 : 6715625 : != (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL))
23641 : 1 : return unify_template_argument_mismatch (explain_p, parm, arg);
23642 : :
23643 : : /* For deduction from an init-list we need the actual list. */
23644 : 313303746 : if (arg_expr && BRACE_ENCLOSED_INITIALIZER_P (arg_expr))
23645 : 6181 : arg = arg_expr;
23646 : 320019370 : return unify (tparms, targs, parm, arg, arg_strict, explain_p);
23647 : : }
23648 : :
23649 : : /* for_each_template_parm callback that always returns 0. */
23650 : :
23651 : : static int
23652 : 18510026 : zero_r (tree, void *)
23653 : : {
23654 : 18510026 : return 0;
23655 : : }
23656 : :
23657 : : /* for_each_template_parm any_fn callback to handle deduction of a template
23658 : : type argument from the type of an array bound. */
23659 : :
23660 : : static int
23661 : 110132697 : array_deduction_r (tree t, void *data)
23662 : : {
23663 : 110132697 : tree_pair_p d = (tree_pair_p)data;
23664 : 110132697 : tree &tparms = d->purpose;
23665 : 110132697 : tree &targs = d->value;
23666 : :
23667 : 110132697 : if (TREE_CODE (t) == ARRAY_TYPE)
23668 : 160 : if (tree dom = TYPE_DOMAIN (t))
23669 : 57 : if (tree max = TYPE_MAX_VALUE (dom))
23670 : : {
23671 : 57 : if (TREE_CODE (max) == MINUS_EXPR)
23672 : 20 : max = TREE_OPERAND (max, 0);
23673 : 57 : if (TREE_CODE (max) == TEMPLATE_PARM_INDEX)
23674 : 20 : unify (tparms, targs, TREE_TYPE (max), size_type_node,
23675 : : UNIFY_ALLOW_NONE, /*explain*/false);
23676 : : }
23677 : :
23678 : : /* Keep walking. */
23679 : 110132697 : return 0;
23680 : : }
23681 : :
23682 : : /* Try to deduce any not-yet-deduced template type arguments from the type of
23683 : : an array bound. This is handled separately from unify because 14.8.2.5 says
23684 : : "The type of a type parameter is only deduced from an array bound if it is
23685 : : not otherwise deduced." */
23686 : :
23687 : : static void
23688 : 19182685 : try_array_deduction (tree tparms, tree targs, tree parm)
23689 : : {
23690 : 19182685 : tree_pair_s data = { tparms, targs };
23691 : 19182685 : hash_set<tree> visited;
23692 : 19182685 : for_each_template_parm (parm, zero_r, &data, &visited,
23693 : : /*nondeduced*/false, array_deduction_r);
23694 : 19182685 : }
23695 : :
23696 : : /* Most parms like fn_type_unification.
23697 : :
23698 : : If SUBR is 1, we're being called recursively (to unify the
23699 : : arguments of a function or method parameter of a function
23700 : : template).
23701 : :
23702 : : CHECKS is a pointer to a vector of access checks encountered while
23703 : : substituting default template arguments. */
23704 : :
23705 : : static int
23706 : 288179738 : type_unification_real (tree tparms,
23707 : : tree full_targs,
23708 : : tree xparms,
23709 : : const tree *xargs,
23710 : : unsigned int xnargs,
23711 : : int subr,
23712 : : unification_kind_t strict,
23713 : : vec<deferred_access_check, va_gc> **checks,
23714 : : bool explain_p)
23715 : : {
23716 : 288179738 : tree parm, arg;
23717 : 288179738 : int i;
23718 : 288179738 : int ntparms = TREE_VEC_LENGTH (tparms);
23719 : 288179738 : int saw_undeduced = 0;
23720 : 288179738 : tree parms;
23721 : 288179738 : const tree *args;
23722 : 288179738 : unsigned int nargs;
23723 : 288179738 : unsigned int ia;
23724 : :
23725 : 288179738 : gcc_assert (TREE_CODE (tparms) == TREE_VEC);
23726 : 288179738 : gcc_assert (xparms == NULL_TREE || TREE_CODE (xparms) == TREE_LIST);
23727 : 288179738 : gcc_assert (ntparms > 0);
23728 : :
23729 : 288179738 : tree targs = INNERMOST_TEMPLATE_ARGS (full_targs);
23730 : :
23731 : : /* Reset the number of non-defaulted template arguments contained
23732 : : in TARGS. */
23733 : 288179738 : NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs) = NULL_TREE;
23734 : :
23735 : 288769401 : again:
23736 : 288769401 : parms = xparms;
23737 : 288769401 : args = xargs;
23738 : 288769401 : nargs = xnargs;
23739 : :
23740 : : /* Only fn_type_unification cares about terminal void. */
23741 : 288769401 : if (nargs && args[nargs-1] == void_type_node)
23742 : 10848053 : --nargs;
23743 : :
23744 : 288769401 : ia = 0;
23745 : 686766867 : while (parms && parms != void_list_node
23746 : 756279451 : && ia < nargs)
23747 : : {
23748 : 349154691 : parm = TREE_VALUE (parms);
23749 : :
23750 : 349154691 : if (TREE_CODE (parm) == TYPE_PACK_EXPANSION
23751 : 349154691 : && (!TREE_CHAIN (parms) || TREE_CHAIN (parms) == void_list_node))
23752 : : /* For a function parameter pack that occurs at the end of the
23753 : : parameter-declaration-list, the type A of each remaining
23754 : : argument of the call is compared with the type P of the
23755 : : declarator-id of the function parameter pack. */
23756 : : break;
23757 : :
23758 : 348619863 : parms = TREE_CHAIN (parms);
23759 : :
23760 : 348619863 : if (TREE_CODE (parm) == TYPE_PACK_EXPANSION)
23761 : : /* For a function parameter pack that does not occur at the
23762 : : end of the parameter-declaration-list, the type of the
23763 : : parameter pack is a non-deduced context. */
23764 : 54 : continue;
23765 : :
23766 : : /* [temp.deduct.conv] only applies to the deduction of the return
23767 : : type, which is always the first argument here. Other arguments
23768 : : (notably, explicit object parameters) should undergo normal
23769 : : call-like unification. */
23770 : 348619809 : unification_kind_t kind = strict;
23771 : 348619809 : if (strict == DEDUCE_CONV && ia > 0)
23772 : 24 : kind = DEDUCE_CALL;
23773 : :
23774 : 348619809 : arg = args[ia];
23775 : 348619809 : ++ia;
23776 : :
23777 : 348619809 : if (unify_one_argument (tparms, full_targs, parm, arg, subr, kind,
23778 : : explain_p))
23779 : : return 1;
23780 : : }
23781 : :
23782 : 55911819 : if (parms
23783 : 49377603 : && parms != void_list_node
23784 : 59039725 : && TREE_CODE (TREE_VALUE (parms)) == TYPE_PACK_EXPANSION)
23785 : : {
23786 : 1050342 : gcc_assert (strict != DEDUCE_CONV);
23787 : :
23788 : : /* Unify the remaining arguments with the pack expansion type. */
23789 : 1050342 : tree argvec;
23790 : 1050342 : tree parmvec = make_tree_vec (1);
23791 : :
23792 : : /* Allocate a TREE_VEC and copy in all of the arguments */
23793 : 1050342 : argvec = make_tree_vec (nargs - ia);
23794 : 2781089 : for (i = 0; ia < nargs; ++ia, ++i)
23795 : 680405 : TREE_VEC_ELT (argvec, i) = args[ia];
23796 : :
23797 : : /* Copy the parameter into parmvec. */
23798 : 1050342 : TREE_VEC_ELT (parmvec, 0) = TREE_VALUE (parms);
23799 : 1050342 : if (unify_pack_expansion (tparms, full_targs, parmvec, argvec, strict,
23800 : : /*subr=*/subr, explain_p))
23801 : : return 1;
23802 : :
23803 : : /* Advance to the end of the list of parameters. */
23804 : 1050193 : parms = TREE_CHAIN (parms);
23805 : : }
23806 : :
23807 : : /* Fail if we've reached the end of the parm list, and more args
23808 : : are present, and the parm list isn't variadic. */
23809 : 55911670 : if (ia < nargs && parms == void_list_node)
23810 : 45922 : return unify_too_many_arguments (explain_p, nargs, ia);
23811 : : /* Fail if parms are left and they don't have default values and
23812 : : they aren't all deduced as empty packs (c++/57397). This is
23813 : : consistent with sufficient_parms_p. */
23814 : 49331347 : if (parms && parms != void_list_node
23815 : 57943318 : && TREE_PURPOSE (parms) == NULL_TREE)
23816 : : {
23817 : : unsigned int count = nargs;
23818 : : tree p = parms;
23819 : 23108 : bool type_pack_p;
23820 : 23108 : do
23821 : : {
23822 : 23108 : type_pack_p = TREE_CODE (TREE_VALUE (p)) == TYPE_PACK_EXPANSION;
23823 : 23108 : if (!type_pack_p)
23824 : 23102 : count++;
23825 : 23108 : p = TREE_CHAIN (p);
23826 : : }
23827 : 23108 : while (p && p != void_list_node);
23828 : 23084 : if (count != nargs)
23829 : 23078 : return unify_too_few_arguments (explain_p, ia, count,
23830 : 23078 : type_pack_p);
23831 : : }
23832 : :
23833 : 55842670 : if (!subr)
23834 : : {
23835 : 111164912 : tsubst_flags_t complain = (explain_p
23836 : 55582456 : ? tf_warning_or_error
23837 : : : tf_none);
23838 : 55582456 : bool tried_array_deduction = (cxx_dialect < cxx17);
23839 : :
23840 : 145377168 : for (i = 0; i < ntparms; i++)
23841 : : {
23842 : 89958481 : tree targ = TREE_VEC_ELT (targs, i);
23843 : 89958481 : tree tparm = TREE_VEC_ELT (tparms, i);
23844 : :
23845 : : /* Clear the "incomplete" flags on all argument packs now so that
23846 : : substituting them into later default arguments works. */
23847 : 89958481 : if (targ && ARGUMENT_PACK_P (targ))
23848 : : {
23849 : 7361823 : ARGUMENT_PACK_INCOMPLETE_P (targ) = 0;
23850 : 7361823 : ARGUMENT_PACK_EXPLICIT_ARGS (targ) = NULL_TREE;
23851 : : }
23852 : :
23853 : 32138168 : if (targ || tparm == error_mark_node)
23854 : 65182136 : continue;
23855 : 24776345 : tparm = TREE_VALUE (tparm);
23856 : :
23857 : 24776345 : if (TREE_CODE (tparm) == TYPE_DECL
23858 : 20003212 : && !tried_array_deduction)
23859 : : {
23860 : 19182636 : try_array_deduction (tparms, targs, xparms);
23861 : 19182636 : tried_array_deduction = true;
23862 : 19182636 : if (TREE_VEC_ELT (targs, i))
23863 : 3 : continue;
23864 : : }
23865 : :
23866 : : /* If this is an undeduced nontype parameter that depends on
23867 : : a type parameter, try another pass; its type may have been
23868 : : deduced from a later argument than the one from which
23869 : : this parameter can be deduced. */
23870 : 26932011 : if (TREE_CODE (tparm) == PARM_DECL
23871 : 4773118 : && !is_auto (TREE_TYPE (tparm))
23872 : 4773052 : && uses_template_parms (TREE_TYPE (tparm))
23873 : 27531852 : && saw_undeduced < 2)
23874 : : {
23875 : 2155669 : saw_undeduced = 1;
23876 : 2155669 : continue;
23877 : : }
23878 : :
23879 : : /* Core issue #226 (C++0x) [temp.deduct]:
23880 : :
23881 : : If a template argument has not been deduced, its
23882 : : default template argument, if any, is used.
23883 : :
23884 : : When we are in C++98 mode, TREE_PURPOSE will either
23885 : : be NULL_TREE or ERROR_MARK_NODE, so we do not need
23886 : : to explicitly check cxx_dialect here. */
23887 : 22620673 : if (TREE_PURPOSE (TREE_VEC_ELT (tparms, i)))
23888 : : /* OK, there is a default argument. Wait until after the
23889 : : conversion check to do substitution. */
23890 : 22342971 : continue;
23891 : :
23892 : : /* If the type parameter is a parameter pack, then it will
23893 : : be deduced to an empty parameter pack. */
23894 : 277702 : if (template_parameter_pack_p (tparm))
23895 : : {
23896 : 113933 : tree arg;
23897 : :
23898 : 113933 : if (TREE_CODE (tparm) == PARM_DECL)
23899 : : {
23900 : 99 : arg = make_node (NONTYPE_ARGUMENT_PACK);
23901 : 99 : TREE_CONSTANT (arg) = 1;
23902 : : }
23903 : : else
23904 : 113834 : arg = cxx_make_type (TYPE_ARGUMENT_PACK);
23905 : :
23906 : 113933 : ARGUMENT_PACK_ARGS (arg) = make_tree_vec (0);
23907 : :
23908 : 113933 : TREE_VEC_ELT (targs, i) = arg;
23909 : 113933 : continue;
23910 : 113933 : }
23911 : :
23912 : 163769 : return unify_parameter_deduction_failure (explain_p, tparm);
23913 : : }
23914 : :
23915 : : /* During partial ordering, we deduce dependent template args. */
23916 : : bool any_dependent_targs = false;
23917 : :
23918 : : /* Now substitute into the default template arguments. */
23919 : 130786929 : for (i = 0; i < ntparms; i++)
23920 : : {
23921 : 89682372 : tree targ = TREE_VEC_ELT (targs, i);
23922 : 89682372 : tree tparm = TREE_VEC_ELT (tparms, i);
23923 : :
23924 : 89682372 : if (targ)
23925 : : {
23926 : 65187602 : if (!any_dependent_targs && dependent_template_arg_p (targ))
23927 : : any_dependent_targs = true;
23928 : 65187602 : continue;
23929 : : }
23930 : 24494770 : if (tparm == error_mark_node)
23931 : 0 : continue;
23932 : :
23933 : 24494770 : tree parm = TREE_VALUE (tparm);
23934 : 24494770 : tree arg = TREE_PURPOSE (tparm);
23935 : 24494770 : reopen_deferring_access_checks (*checks);
23936 : 24494770 : location_t save_loc = input_location;
23937 : 24494770 : if (DECL_P (parm))
23938 : 24494766 : input_location = DECL_SOURCE_LOCATION (parm);
23939 : :
23940 : 24494770 : if (saw_undeduced == 1
23941 : 3269039 : && TREE_CODE (parm) == PARM_DECL
23942 : 2302964 : && !is_auto (TREE_TYPE (parm))
23943 : 26797734 : && uses_template_parms (TREE_TYPE (parm)))
23944 : : {
23945 : : /* The type of this non-type parameter depends on undeduced
23946 : : parameters. Don't try to use its default argument yet,
23947 : : since we might deduce an argument for it on the next pass,
23948 : : but do check whether the arguments we already have cause
23949 : : substitution failure, so that that happens before we try
23950 : : later default arguments (78489). */
23951 : 2155129 : ++processing_template_decl;
23952 : 2155129 : tree type = tsubst (TREE_TYPE (parm), full_targs, complain,
23953 : : NULL_TREE);
23954 : 2155129 : --processing_template_decl;
23955 : 2155129 : if (type == error_mark_node)
23956 : 1555270 : arg = error_mark_node;
23957 : : else
23958 : : arg = NULL_TREE;
23959 : : }
23960 : : else
23961 : : {
23962 : : /* Even if the call is happening in template context, getting
23963 : : here means it's non-dependent, and a default argument is
23964 : : considered a separate definition under [temp.decls], so we can
23965 : : do this substitution without processing_template_decl. This
23966 : : is important if the default argument contains something that
23967 : : might be instantiation-dependent like access (87480). */
23968 : 22339641 : processing_template_decl_sentinel s (!any_dependent_targs);
23969 : :
23970 : 22339641 : tree used_tparms = NULL_TREE;
23971 : 22339641 : if (saw_undeduced == 1)
23972 : : {
23973 : 1113910 : tree tparms_list = build_tree_list (size_int (1), tparms);
23974 : 1113910 : used_tparms = find_template_parameters (arg, tparms_list);
23975 : 2239035 : for (; used_tparms; used_tparms = TREE_CHAIN (used_tparms))
23976 : : {
23977 : 11221 : int level, index;
23978 : 11221 : template_parm_level_and_index (TREE_VALUE (used_tparms),
23979 : : &level, &index);
23980 : 11221 : if (TREE_VEC_ELT (targs, index) == NULL_TREE)
23981 : : break;
23982 : : }
23983 : : }
23984 : :
23985 : 1113910 : if (!used_tparms)
23986 : : {
23987 : : /* All template parameters within this default argument are
23988 : : deduced, so we can use it. */
23989 : 22339635 : arg = tsubst_template_arg (arg, full_targs, complain,
23990 : : NULL_TREE);
23991 : 22339635 : arg = convert_template_argument (parm, arg, full_targs,
23992 : : complain, i, NULL_TREE);
23993 : : }
23994 : : else if (saw_undeduced == 1)
23995 : : arg = NULL_TREE;
23996 : : else if (!any_dependent_targs)
23997 : : arg = error_mark_node;
23998 : 22339641 : }
23999 : :
24000 : 24494770 : input_location = save_loc;
24001 : 24494770 : *checks = get_deferred_access_checks ();
24002 : 24494770 : pop_deferring_access_checks ();
24003 : :
24004 : 24494770 : if (arg == error_mark_node)
24005 : : return 1;
24006 : 10180640 : else if (arg)
24007 : : {
24008 : 9580775 : TREE_VEC_ELT (targs, i) = arg;
24009 : : /* The position of the first default template argument,
24010 : : is also the number of non-defaulted arguments in TARGS.
24011 : : Record that. */
24012 : 9580775 : if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs))
24013 : 8247943 : SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs, i);
24014 : : }
24015 : : }
24016 : :
24017 : 41104557 : if (saw_undeduced++ == 1)
24018 : 589663 : goto again;
24019 : : }
24020 : :
24021 : 40775108 : if (CHECKING_P && !NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs))
24022 : 32630341 : SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs, TREE_VEC_LENGTH (targs));
24023 : :
24024 : 40775108 : return unify_success (explain_p);
24025 : : }
24026 : :
24027 : : /* Subroutine of type_unification_real. Args are like the variables
24028 : : at the call site. ARG is an overloaded function (or template-id);
24029 : : we try deducing template args from each of the overloads, and if
24030 : : only one succeeds, we go with that. Modifies TARGS and returns
24031 : : true on success. */
24032 : :
24033 : : static bool
24034 : 80893 : resolve_overloaded_unification (tree tparms,
24035 : : tree targs,
24036 : : tree parm,
24037 : : tree arg,
24038 : : unification_kind_t strict,
24039 : : int sub_strict,
24040 : : bool explain_p)
24041 : : {
24042 : 80893 : tree tempargs = copy_node (targs);
24043 : 80893 : int good = 0;
24044 : 80893 : tree goodfn = NULL_TREE;
24045 : 80893 : bool addr_p;
24046 : :
24047 : 80893 : if (TREE_CODE (arg) == ADDR_EXPR)
24048 : : {
24049 : 640 : arg = TREE_OPERAND (arg, 0);
24050 : 640 : addr_p = true;
24051 : : }
24052 : : else
24053 : : addr_p = false;
24054 : :
24055 : 80893 : if (TREE_CODE (arg) == COMPONENT_REF)
24056 : : /* Handle `&x' where `x' is some static or non-static member
24057 : : function name. */
24058 : 159 : arg = TREE_OPERAND (arg, 1);
24059 : :
24060 : 80893 : if (TREE_CODE (arg) == OFFSET_REF)
24061 : 408 : arg = TREE_OPERAND (arg, 1);
24062 : :
24063 : : /* Strip baselink information. */
24064 : 80893 : if (BASELINK_P (arg))
24065 : 573 : arg = BASELINK_FUNCTIONS (arg);
24066 : :
24067 : 80893 : if (TREE_CODE (arg) == TEMPLATE_ID_EXPR)
24068 : : {
24069 : : /* If we got some explicit template args, we need to plug them into
24070 : : the affected templates before we try to unify, in case the
24071 : : explicit args will completely resolve the templates in question. */
24072 : :
24073 : 410 : int ok = 0;
24074 : 410 : tree expl_subargs = TREE_OPERAND (arg, 1);
24075 : 410 : arg = TREE_OPERAND (arg, 0);
24076 : :
24077 : 877 : for (lkp_iterator iter (arg); iter; ++iter)
24078 : : {
24079 : 467 : tree fn = *iter;
24080 : 467 : tree subargs, elem;
24081 : :
24082 : 467 : if (TREE_CODE (fn) != TEMPLATE_DECL)
24083 : 0 : continue;
24084 : :
24085 : 467 : subargs = coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn),
24086 : : expl_subargs, NULL_TREE, tf_none);
24087 : 467 : if (subargs != error_mark_node
24088 : 467 : && !any_dependent_template_arguments_p (subargs))
24089 : : {
24090 : 443 : fn = instantiate_template (fn, subargs, tf_none);
24091 : 443 : if (!constraints_satisfied_p (fn))
24092 : 40 : continue;
24093 : 403 : if (undeduced_auto_decl (fn))
24094 : : {
24095 : : /* Instantiate the function to deduce its return type. */
24096 : 12 : ++function_depth;
24097 : 12 : instantiate_decl (fn, /*defer*/false, /*class*/false);
24098 : 12 : --function_depth;
24099 : : }
24100 : :
24101 : 403 : if (flag_noexcept_type)
24102 : 359 : maybe_instantiate_noexcept (fn, tf_none);
24103 : :
24104 : 403 : elem = TREE_TYPE (fn);
24105 : 403 : if (try_one_overload (tparms, targs, tempargs, parm,
24106 : : elem, strict, sub_strict, addr_p, explain_p)
24107 : 403 : && (!goodfn || !same_type_p (goodfn, elem)))
24108 : : {
24109 : 375 : goodfn = elem;
24110 : 375 : ++good;
24111 : : }
24112 : : }
24113 : 24 : else if (subargs)
24114 : 24 : ++ok;
24115 : : }
24116 : : /* If no templates (or more than one) are fully resolved by the
24117 : : explicit arguments, this template-id is a non-deduced context; it
24118 : : could still be OK if we deduce all template arguments for the
24119 : : enclosing call through other arguments. */
24120 : 410 : if (good != 1)
24121 : : good = ok;
24122 : : }
24123 : 80483 : else if (!OVL_P (arg))
24124 : : /* If ARG is, for example, "(0, &f)" then its type will be unknown
24125 : : -- but the deduction does not succeed because the expression is
24126 : : not just the function on its own. */
24127 : : return false;
24128 : : else
24129 : 161388 : for (lkp_iterator iter (arg); iter; ++iter)
24130 : : {
24131 : 80905 : tree fn = *iter;
24132 : 80905 : if (flag_noexcept_type)
24133 : 80176 : maybe_instantiate_noexcept (fn, tf_none);
24134 : 80905 : if (TREE_CODE (fn) == FUNCTION_DECL && !constraints_satisfied_p (fn))
24135 : 6 : continue;
24136 : 80899 : tree elem = TREE_TYPE (fn);
24137 : 80899 : if (try_one_overload (tparms, targs, tempargs, parm, elem,
24138 : : strict, sub_strict, addr_p, explain_p)
24139 : 80899 : && (!goodfn || !same_type_p (goodfn, elem)))
24140 : : {
24141 : 80655 : goodfn = elem;
24142 : 80655 : ++good;
24143 : : }
24144 : : }
24145 : :
24146 : : /* [temp.deduct.type] A template-argument can be deduced from a pointer
24147 : : to function or pointer to member function argument if the set of
24148 : : overloaded functions does not contain function templates and at most
24149 : : one of a set of overloaded functions provides a unique match.
24150 : :
24151 : : CWG2918 allows multiple functions to match if they all have the same type,
24152 : : so that we can choose the most constrained later.
24153 : :
24154 : : So if we found multiple possibilities, we return success but don't
24155 : : deduce anything. */
24156 : :
24157 : 80554 : if (good == 1)
24158 : : {
24159 : 80626 : int i = TREE_VEC_LENGTH (targs);
24160 : 313459 : for (; i--; )
24161 : 232833 : if (TREE_VEC_ELT (tempargs, i))
24162 : : {
24163 : 130639 : tree old = TREE_VEC_ELT (targs, i);
24164 : 130639 : tree new_ = TREE_VEC_ELT (tempargs, i);
24165 : 130006 : if (new_ && old && ARGUMENT_PACK_P (old)
24166 : 130648 : && ARGUMENT_PACK_EXPLICIT_ARGS (old))
24167 : : /* Don't forget explicit template arguments in a pack. */
24168 : 6 : ARGUMENT_PACK_EXPLICIT_ARGS (new_)
24169 : 12 : = ARGUMENT_PACK_EXPLICIT_ARGS (old);
24170 : 130639 : TREE_VEC_ELT (targs, i) = new_;
24171 : : }
24172 : : }
24173 : 80893 : if (good)
24174 : : return true;
24175 : :
24176 : : return false;
24177 : : }
24178 : :
24179 : : /* Core DR 115: In contexts where deduction is done and fails, or in
24180 : : contexts where deduction is not done, if a template argument list is
24181 : : specified and it, along with any default template arguments, identifies
24182 : : a single function template specialization, then the template-id is an
24183 : : lvalue for the function template specialization. */
24184 : :
24185 : : tree
24186 : 1185881886 : resolve_nondeduced_context (tree orig_expr, tsubst_flags_t complain)
24187 : : {
24188 : 1185881886 : tree expr, offset, baselink;
24189 : 1185881886 : bool addr;
24190 : :
24191 : 1185881886 : if (!type_unknown_p (orig_expr))
24192 : : return orig_expr;
24193 : :
24194 : 8647 : expr = orig_expr;
24195 : 8647 : addr = false;
24196 : 8647 : offset = NULL_TREE;
24197 : 8647 : baselink = NULL_TREE;
24198 : :
24199 : 8647 : if (TREE_CODE (expr) == ADDR_EXPR)
24200 : : {
24201 : 397 : expr = TREE_OPERAND (expr, 0);
24202 : 397 : addr = true;
24203 : : }
24204 : 8647 : if (TREE_CODE (expr) == OFFSET_REF)
24205 : : {
24206 : 102 : offset = expr;
24207 : 102 : expr = TREE_OPERAND (expr, 1);
24208 : : }
24209 : 8647 : if (BASELINK_P (expr))
24210 : : {
24211 : 3092 : baselink = expr;
24212 : 3092 : expr = BASELINK_FUNCTIONS (expr);
24213 : : }
24214 : :
24215 : 8647 : if (TREE_CODE (expr) == TEMPLATE_ID_EXPR)
24216 : : {
24217 : 3759 : int good = 0;
24218 : 3759 : tree goodfn = NULL_TREE;
24219 : :
24220 : : /* If we got some explicit template args, we need to plug them into
24221 : : the affected templates before we try to unify, in case the
24222 : : explicit args will completely resolve the templates in question. */
24223 : :
24224 : 3759 : tree expl_subargs = TREE_OPERAND (expr, 1);
24225 : 3759 : tree arg = TREE_OPERAND (expr, 0);
24226 : 3759 : tree badfn = NULL_TREE;
24227 : 3759 : tree badargs = NULL_TREE;
24228 : :
24229 : 7629 : for (lkp_iterator iter (arg); iter; ++iter)
24230 : : {
24231 : 3870 : tree fn = *iter;
24232 : 3870 : tree subargs, elem;
24233 : :
24234 : 3870 : if (TREE_CODE (fn) != TEMPLATE_DECL)
24235 : 0 : continue;
24236 : :
24237 : 3870 : subargs = coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn),
24238 : : expl_subargs, NULL_TREE, tf_none);
24239 : 3870 : if (subargs != error_mark_node
24240 : 3870 : && !any_dependent_template_arguments_p (subargs))
24241 : : {
24242 : 1526 : elem = instantiate_template (fn, subargs, tf_none);
24243 : 1526 : if (elem == error_mark_node)
24244 : : {
24245 : : badfn = fn;
24246 : : badargs = subargs;
24247 : : }
24248 : 1487 : else if (elem && (!goodfn || !decls_match (goodfn, elem))
24249 : 2974 : && constraints_satisfied_p (elem))
24250 : : {
24251 : 1445 : goodfn = elem;
24252 : 1445 : ++good;
24253 : : }
24254 : : }
24255 : : }
24256 : 3759 : if (good == 1)
24257 : : {
24258 : 1367 : mark_used (goodfn);
24259 : 1367 : expr = goodfn;
24260 : 1367 : if (baselink)
24261 : 797 : expr = build_baselink (BASELINK_BINFO (baselink),
24262 : 797 : BASELINK_ACCESS_BINFO (baselink),
24263 : 797 : expr, BASELINK_OPTYPE (baselink));
24264 : 1367 : if (offset)
24265 : : {
24266 : 51 : tree base
24267 : 51 : = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (offset, 0)));
24268 : 51 : expr = build_offset_ref (base, expr, addr, complain);
24269 : : }
24270 : 1367 : if (addr)
24271 : 265 : expr = cp_build_addr_expr (expr, complain);
24272 : 1367 : return expr;
24273 : : }
24274 : 2392 : else if (good == 0 && badargs && (complain & tf_error))
24275 : : /* There were no good options and at least one bad one, so let the
24276 : : user know what the problem is. */
24277 : 3 : instantiate_template (badfn, badargs, complain);
24278 : : }
24279 : : return orig_expr;
24280 : : }
24281 : :
24282 : : /* As above, but error out if the expression remains overloaded. */
24283 : :
24284 : : tree
24285 : 853817979 : resolve_nondeduced_context_or_error (tree exp, tsubst_flags_t complain)
24286 : : {
24287 : 853817979 : exp = resolve_nondeduced_context (exp, complain);
24288 : 853817979 : if (type_unknown_p (exp))
24289 : : {
24290 : 90 : if (complain & tf_error)
24291 : 90 : cxx_incomplete_type_error (exp, TREE_TYPE (exp));
24292 : 90 : return error_mark_node;
24293 : : }
24294 : : return exp;
24295 : : }
24296 : :
24297 : : /* Subroutine of resolve_overloaded_unification; does deduction for a single
24298 : : overload. Fills TARGS with any deduced arguments, or error_mark_node if
24299 : : different overloads deduce different arguments for a given parm.
24300 : : ADDR_P is true if the expression for which deduction is being
24301 : : performed was of the form "& fn" rather than simply "fn".
24302 : :
24303 : : Returns 1 on success. */
24304 : :
24305 : : static int
24306 : 81302 : try_one_overload (tree tparms,
24307 : : tree orig_targs,
24308 : : tree targs,
24309 : : tree parm,
24310 : : tree arg,
24311 : : unification_kind_t strict,
24312 : : int sub_strict,
24313 : : bool addr_p,
24314 : : bool explain_p)
24315 : : {
24316 : 81302 : int nargs;
24317 : 81302 : tree tempargs;
24318 : 81302 : int i;
24319 : :
24320 : 81302 : if (arg == error_mark_node)
24321 : : return 0;
24322 : :
24323 : : /* [temp.deduct.type] A template-argument can be deduced from a pointer
24324 : : to function or pointer to member function argument if the set of
24325 : : overloaded functions does not contain function templates and at most
24326 : : one of a set of overloaded functions provides a unique match.
24327 : :
24328 : : So if this is a template, just return success. */
24329 : :
24330 : 81300 : if (uses_template_parms (arg))
24331 : : return 1;
24332 : :
24333 : 1202 : if (TREE_CODE (arg) == METHOD_TYPE)
24334 : 372 : arg = build_ptrmemfunc_type (build_pointer_type (arg));
24335 : 830 : else if (addr_p)
24336 : 605 : arg = build_pointer_type (arg);
24337 : :
24338 : 1202 : sub_strict |= maybe_adjust_types_for_deduction (tparms, strict,
24339 : : &parm, &arg, NULL_TREE);
24340 : :
24341 : : /* We don't copy orig_targs for this because if we have already deduced
24342 : : some template args from previous args, unify would complain when we
24343 : : try to deduce a template parameter for the same argument, even though
24344 : : there isn't really a conflict. */
24345 : 1202 : nargs = TREE_VEC_LENGTH (targs);
24346 : 1202 : tempargs = make_tree_vec (nargs);
24347 : :
24348 : 1202 : if (unify (tparms, tempargs, parm, arg, sub_strict, explain_p))
24349 : : return 0;
24350 : :
24351 : : /* First make sure we didn't deduce anything that conflicts with
24352 : : explicitly specified args. */
24353 : 2618 : for (i = nargs; i--; )
24354 : : {
24355 : 1668 : tree elt = TREE_VEC_ELT (tempargs, i);
24356 : 1668 : tree oldelt = TREE_VEC_ELT (orig_targs, i);
24357 : :
24358 : 1668 : if (!elt)
24359 : : /*NOP*/;
24360 : 1114 : else if (uses_template_parms (elt))
24361 : : /* Since we're unifying against ourselves, we will fill in
24362 : : template args used in the function parm list with our own
24363 : : template parms. Discard them. */
24364 : 0 : TREE_VEC_ELT (tempargs, i) = NULL_TREE;
24365 : 1114 : else if (oldelt && ARGUMENT_PACK_P (oldelt))
24366 : : {
24367 : : /* Check that the argument at each index of the deduced argument pack
24368 : : is equivalent to the corresponding explicitly specified argument.
24369 : : We may have deduced more arguments than were explicitly specified,
24370 : : and that's OK. */
24371 : :
24372 : : /* We used to assert ARGUMENT_PACK_INCOMPLETE_P (oldelt) here, but
24373 : : that's wrong if we deduce the same argument pack from multiple
24374 : : function arguments: it's only incomplete the first time. */
24375 : :
24376 : 24 : tree explicit_pack = ARGUMENT_PACK_ARGS (oldelt);
24377 : 24 : tree deduced_pack = ARGUMENT_PACK_ARGS (elt);
24378 : :
24379 : 24 : if (TREE_VEC_LENGTH (deduced_pack)
24380 : 24 : < TREE_VEC_LENGTH (explicit_pack))
24381 : : return 0;
24382 : :
24383 : 30 : for (int j = 0; j < TREE_VEC_LENGTH (explicit_pack); j++)
24384 : 21 : if (!template_args_equal (TREE_VEC_ELT (explicit_pack, j),
24385 : 21 : TREE_VEC_ELT (deduced_pack, j)))
24386 : : return 0;
24387 : : }
24388 : 23 : else if (oldelt && !template_args_equal (oldelt, elt))
24389 : : return 0;
24390 : : }
24391 : :
24392 : 2565 : for (i = nargs; i--; )
24393 : : {
24394 : 1615 : tree elt = TREE_VEC_ELT (tempargs, i);
24395 : :
24396 : 1615 : if (elt)
24397 : 1079 : TREE_VEC_ELT (targs, i) = elt;
24398 : : }
24399 : :
24400 : : return 1;
24401 : : }
24402 : :
24403 : : /* PARM is a template class (perhaps with unbound template
24404 : : parameters). ARG is a fully instantiated type. If ARG can be
24405 : : bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
24406 : : TARGS are as for unify. */
24407 : :
24408 : : static tree
24409 : 99761030 : try_class_unification (tree tparms, tree targs, tree parm, tree arg,
24410 : : bool explain_p)
24411 : : {
24412 : 99761030 : if (!CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg))
24413 : : return NULL_TREE;
24414 : 74302718 : else if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
24415 : : /* Matches anything. */;
24416 : 74301950 : else if (CLASSTYPE_TI_TEMPLATE (arg) != CLASSTYPE_TI_TEMPLATE (parm))
24417 : : return NULL_TREE;
24418 : :
24419 : : /* We need to make a new template argument vector for the call to
24420 : : unify. If we used TARGS, we'd clutter it up with the result of
24421 : : the attempted unification, even if this class didn't work out.
24422 : : We also don't want to commit ourselves to all the unifications
24423 : : we've already done, since unification is supposed to be done on
24424 : : an argument-by-argument basis. In other words, consider the
24425 : : following pathological case:
24426 : :
24427 : : template <int I, int J, int K>
24428 : : struct S {};
24429 : :
24430 : : template <int I, int J>
24431 : : struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
24432 : :
24433 : : template <int I, int J, int K>
24434 : : void f(S<I, J, K>, S<I, I, I>);
24435 : :
24436 : : void g() {
24437 : : S<0, 0, 0> s0;
24438 : : S<0, 1, 2> s2;
24439 : :
24440 : : f(s0, s2);
24441 : : }
24442 : :
24443 : : Now, by the time we consider the unification involving `s2', we
24444 : : already know that we must have `f<0, 0, 0>'. But, even though
24445 : : `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
24446 : : because there are two ways to unify base classes of S<0, 1, 2>
24447 : : with S<I, I, I>. If we kept the already deduced knowledge, we
24448 : : would reject the possibility I=1. */
24449 : 10324042 : targs = copy_template_args (targs);
24450 : 36386217 : for (tree& targ : tree_vec_range (INNERMOST_TEMPLATE_ARGS (targs)))
24451 : 26062175 : targ = NULL_TREE;
24452 : :
24453 : 10324042 : int err;
24454 : 10324042 : if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
24455 : 768 : err = unify_bound_ttp_args (tparms, targs, parm, arg, explain_p);
24456 : : else
24457 : 10323274 : err = unify (tparms, targs,
24458 : 10323274 : INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (parm)),
24459 : 10323274 : INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (arg)),
24460 : : UNIFY_ALLOW_NONE, explain_p);
24461 : :
24462 : 10324042 : return err ? NULL_TREE : arg;
24463 : : }
24464 : :
24465 : : /* Given a template type PARM and a class type ARG, find the unique
24466 : : base type in ARG that is an instance of PARM. We do not examine
24467 : : ARG itself; only its base-classes. If there is not exactly one
24468 : : appropriate base class, return NULL_TREE. PARM may be the type of
24469 : : a partial specialization, as well as a plain template type. Used
24470 : : by unify. */
24471 : :
24472 : : static enum template_base_result
24473 : 72745151 : get_template_base (tree tparms, tree targs, tree parm, tree arg,
24474 : : bool explain_p, tree *result)
24475 : : {
24476 : 72745151 : tree rval = NULL_TREE;
24477 : 72745151 : tree binfo;
24478 : :
24479 : 72745151 : gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (arg)));
24480 : :
24481 : 72745151 : binfo = TYPE_BINFO (complete_type (arg));
24482 : 72745151 : if (!binfo)
24483 : : {
24484 : : /* The type could not be completed. */
24485 : 8 : *result = NULL_TREE;
24486 : 8 : return tbr_incomplete_type;
24487 : : }
24488 : :
24489 : : /* Walk in inheritance graph order. The search order is not
24490 : : important, and this avoids multiple walks of virtual bases. */
24491 : 90456335 : for (binfo = TREE_CHAIN (binfo); binfo; binfo = TREE_CHAIN (binfo))
24492 : : {
24493 : 35422412 : tree r = try_class_unification (tparms, targs, parm,
24494 : 17711206 : BINFO_TYPE (binfo), explain_p);
24495 : :
24496 : 17711206 : if (r)
24497 : : {
24498 : : /* If there is more than one satisfactory baseclass, then:
24499 : :
24500 : : [temp.deduct.call]
24501 : :
24502 : : If they yield more than one possible deduced A, the type
24503 : : deduction fails.
24504 : :
24505 : : applies. */
24506 : 706179 : if (rval && !same_type_p (r, rval))
24507 : : {
24508 : : /* [temp.deduct.call]/4.3: If there is a class C that is a
24509 : : (direct or indirect) base class of D and derived (directly or
24510 : : indirectly) from a class B and that would be a valid deduced
24511 : : A, the deduced A cannot be B or pointer to B, respectively. */
24512 : 44 : if (DERIVED_FROM_P (r, rval))
24513 : : /* Ignore r. */
24514 : 27 : continue;
24515 : 17 : else if (DERIVED_FROM_P (rval, r))
24516 : : /* Ignore rval. */;
24517 : : else
24518 : : {
24519 : 14 : *result = NULL_TREE;
24520 : 14 : return tbr_ambiguous_baseclass;
24521 : : }
24522 : : }
24523 : :
24524 : : rval = r;
24525 : : }
24526 : : }
24527 : :
24528 : 72745129 : *result = rval;
24529 : 72745129 : return tbr_success;
24530 : : }
24531 : :
24532 : : /* Returns the level of DECL, which declares a template parameter. */
24533 : :
24534 : : static int
24535 : 176393204 : template_decl_level (tree decl)
24536 : : {
24537 : 176393204 : switch (TREE_CODE (decl))
24538 : : {
24539 : 164628340 : case TYPE_DECL:
24540 : 164628340 : case TEMPLATE_DECL:
24541 : 164628340 : return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl));
24542 : :
24543 : 11764864 : case PARM_DECL:
24544 : 11764864 : return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl));
24545 : :
24546 : 0 : default:
24547 : 0 : gcc_unreachable ();
24548 : : }
24549 : : return 0;
24550 : : }
24551 : :
24552 : : /* Decide whether ARG can be unified with PARM, considering only the
24553 : : cv-qualifiers of each type, given STRICT as documented for unify.
24554 : : Returns nonzero iff the unification is OK on that basis. */
24555 : :
24556 : : static int
24557 : 313206685 : check_cv_quals_for_unify (int strict, tree arg, tree parm)
24558 : : {
24559 : 313206685 : int arg_quals = cp_type_quals (arg);
24560 : 313206685 : int parm_quals = cp_type_quals (parm);
24561 : :
24562 : 313206685 : if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
24563 : 169062628 : && !(strict & UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
24564 : : {
24565 : : /* Although a CVR qualifier is ignored when being applied to a
24566 : : substituted template parameter ([8.3.2]/1 for example), that
24567 : : does not allow us to unify "const T" with "int&" because both
24568 : : types are not of the form "cv-list T" [14.8.2.5 temp.deduct.type].
24569 : : It is ok when we're allowing additional CV qualifiers
24570 : : at the outer level [14.8.2.1]/3,1st bullet. */
24571 : 145071414 : if ((TYPE_REF_P (arg)
24572 : 140635430 : || FUNC_OR_METHOD_TYPE_P (arg))
24573 : 4645816 : && (parm_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)))
24574 : : return 0;
24575 : :
24576 : 145071163 : if ((!INDIRECT_TYPE_P (arg) && TREE_CODE (arg) != TEMPLATE_TYPE_PARM)
24577 : 100364760 : && (parm_quals & TYPE_QUAL_RESTRICT))
24578 : : return 0;
24579 : : }
24580 : :
24581 : 289215220 : if (!(strict & (UNIFY_ALLOW_MORE_CV_QUAL | UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
24582 : 177303981 : && (arg_quals & parm_quals) != parm_quals)
24583 : : return 0;
24584 : :
24585 : 311988368 : if (!(strict & (UNIFY_ALLOW_LESS_CV_QUAL | UNIFY_ALLOW_OUTER_LESS_CV_QUAL))
24586 : 144091755 : && (parm_quals & arg_quals) != arg_quals)
24587 : 929962 : return 0;
24588 : :
24589 : : return 1;
24590 : : }
24591 : :
24592 : : /* Determines the LEVEL and INDEX for the template parameter PARM. */
24593 : : void
24594 : 4971464167 : template_parm_level_and_index (tree parm, int* level, int* index)
24595 : : {
24596 : 4971464167 : if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
24597 : 4971464167 : || TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
24598 : 216110056 : || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
24599 : : {
24600 : 4755749065 : *index = TEMPLATE_TYPE_IDX (parm);
24601 : 4755749065 : *level = TEMPLATE_TYPE_LEVEL (parm);
24602 : : }
24603 : : else
24604 : : {
24605 : 215715102 : *index = TEMPLATE_PARM_IDX (parm);
24606 : 215715102 : *level = TEMPLATE_PARM_LEVEL (parm);
24607 : : }
24608 : 4971464167 : }
24609 : :
24610 : : #define RECUR_AND_CHECK_FAILURE(TP, TA, P, A, S, EP) \
24611 : : do { \
24612 : : if (unify (TP, TA, P, A, S, EP)) \
24613 : : return 1; \
24614 : : } while (0)
24615 : :
24616 : : /* Unifies the remaining arguments in PACKED_ARGS with the pack
24617 : : expansion at the end of PACKED_PARMS. Returns 0 if the type
24618 : : deduction succeeds, 1 otherwise. STRICT is the same as in
24619 : : fn_type_unification. CALL_ARGS_P is true iff PACKED_ARGS is actually a
24620 : : function call argument list. We'll need to adjust the arguments to make them
24621 : : types. SUBR tells us if this is from a recursive call to
24622 : : type_unification_real, or for comparing two template argument
24623 : : lists. */
24624 : :
24625 : : static int
24626 : 5260298 : unify_pack_expansion (tree tparms, tree targs, tree packed_parms,
24627 : : tree packed_args, unification_kind_t strict,
24628 : : bool subr, bool explain_p)
24629 : : {
24630 : 5260298 : tree parm
24631 : 5260298 : = TREE_VEC_ELT (packed_parms, TREE_VEC_LENGTH (packed_parms) - 1);
24632 : 5260298 : tree pattern = PACK_EXPANSION_PATTERN (parm);
24633 : 5260298 : tree pack, packs = NULL_TREE;
24634 : 5260298 : int i, start = TREE_VEC_LENGTH (packed_parms) - 1;
24635 : :
24636 : : /* Add in any args remembered from an earlier partial instantiation. */
24637 : 5260298 : targs = add_to_template_args (PACK_EXPANSION_EXTRA_ARGS (parm), targs);
24638 : 10520596 : int levels = TMPL_ARGS_DEPTH (targs);
24639 : :
24640 : 5260298 : packed_args = expand_template_argument_pack (packed_args);
24641 : :
24642 : 5260298 : int len = TREE_VEC_LENGTH (packed_args);
24643 : :
24644 : : /* Determine the parameter packs we will be deducing from the
24645 : : pattern, and record their current deductions. */
24646 : 10383826 : for (pack = PACK_EXPANSION_PARAMETER_PACKS (parm);
24647 : 10520617 : pack; pack = TREE_CHAIN (pack))
24648 : : {
24649 : 5260319 : tree parm_pack = TREE_VALUE (pack);
24650 : 5260319 : int idx, level;
24651 : :
24652 : : /* Only template parameter packs can be deduced, not e.g. function
24653 : : parameter packs or __bases or __integer_pack. */
24654 : 5260319 : if (!TEMPLATE_PARM_P (parm_pack))
24655 : 276499 : continue;
24656 : :
24657 : : /* Determine the index and level of this parameter pack. */
24658 : 5260313 : template_parm_level_and_index (parm_pack, &level, &idx);
24659 : 5260313 : if (level > levels)
24660 : 276493 : continue;
24661 : :
24662 : : /* Keep track of the parameter packs and their corresponding
24663 : : argument packs. */
24664 : 9967640 : packs = tree_cons (parm_pack, TMPL_ARG (targs, level, idx), packs);
24665 : 4983820 : TREE_TYPE (packs) = make_tree_vec (len - start);
24666 : : }
24667 : :
24668 : : /* Loop through all of the arguments that have not yet been
24669 : : unified and unify each with the pattern. */
24670 : 12027745 : for (i = start; i < len; i++)
24671 : : {
24672 : 6768969 : tree parm;
24673 : 6768969 : bool any_explicit = false;
24674 : 6768969 : tree arg = TREE_VEC_ELT (packed_args, i);
24675 : :
24676 : : /* For each parameter pack, set its TMPL_ARG to either NULL_TREE
24677 : : or the element of its argument pack at the current index if
24678 : : this argument was explicitly specified. */
24679 : 13261478 : for (pack = packs; pack; pack = TREE_CHAIN (pack))
24680 : : {
24681 : 6492509 : int idx, level;
24682 : 6492509 : tree arg, pargs;
24683 : 6492509 : template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
24684 : :
24685 : 6492509 : arg = NULL_TREE;
24686 : 6492509 : if (TREE_VALUE (pack)
24687 : 122371 : && (pargs = ARGUMENT_PACK_EXPLICIT_ARGS (TREE_VALUE (pack)))
24688 : 6493090 : && (i - start < TREE_VEC_LENGTH (pargs)))
24689 : : {
24690 : 518 : any_explicit = true;
24691 : 518 : arg = TREE_VEC_ELT (pargs, i - start);
24692 : : }
24693 : 12985018 : TMPL_ARG (targs, level, idx) = arg;
24694 : : }
24695 : :
24696 : : /* If we had explicit template arguments, substitute them into the
24697 : : pattern before deduction. */
24698 : 6768969 : if (any_explicit)
24699 : : {
24700 : : /* Some arguments might still be unspecified or dependent. */
24701 : 518 : bool dependent;
24702 : 518 : ++processing_template_decl;
24703 : 518 : dependent = any_dependent_template_arguments_p (targs);
24704 : 518 : if (!dependent)
24705 : 503 : --processing_template_decl;
24706 : 1036 : parm = tsubst (pattern, targs,
24707 : : explain_p ? tf_warning_or_error : tf_none,
24708 : : NULL_TREE);
24709 : 518 : if (dependent)
24710 : 15 : --processing_template_decl;
24711 : 518 : if (parm == error_mark_node)
24712 : : return 1;
24713 : : }
24714 : : else
24715 : : parm = pattern;
24716 : :
24717 : : /* Unify the pattern with the current argument. */
24718 : 6768969 : if (unify_one_argument (tparms, targs, parm, arg, subr, strict,
24719 : : explain_p))
24720 : : return 1;
24721 : :
24722 : : /* For each parameter pack, collect the deduced value. */
24723 : 13258431 : for (pack = packs; pack; pack = TREE_CHAIN (pack))
24724 : : {
24725 : 6490984 : int idx, level;
24726 : 6490984 : template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
24727 : :
24728 : 6490984 : TREE_VEC_ELT (TREE_TYPE (pack), i - start) =
24729 : 12981968 : TMPL_ARG (targs, level, idx);
24730 : : }
24731 : : }
24732 : :
24733 : : /* Verify that the results of unification with the parameter packs
24734 : : produce results consistent with what we've seen before, and make
24735 : : the deduced argument packs available. */
24736 : 10241053 : for (pack = packs; pack; pack = TREE_CHAIN (pack))
24737 : : {
24738 : 4982295 : tree old_pack = TREE_VALUE (pack);
24739 : 4982295 : tree new_args = TREE_TYPE (pack);
24740 : 4982295 : int i, len = TREE_VEC_LENGTH (new_args);
24741 : 4982295 : int idx, level;
24742 : 4982295 : bool nondeduced_p = false;
24743 : :
24744 : : /* By default keep the original deduced argument pack.
24745 : : If necessary, more specific code is going to update the
24746 : : resulting deduced argument later down in this function. */
24747 : 4982295 : template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
24748 : 9964590 : TMPL_ARG (targs, level, idx) = old_pack;
24749 : :
24750 : : /* If NEW_ARGS contains any NULL_TREE entries, we didn't
24751 : : actually deduce anything. */
24752 : 11472881 : for (i = 0; i < len && !nondeduced_p; ++i)
24753 : 6490586 : if (TREE_VEC_ELT (new_args, i) == NULL_TREE)
24754 : 207 : nondeduced_p = true;
24755 : 4982295 : if (nondeduced_p)
24756 : 207 : continue;
24757 : :
24758 : 4982088 : if (old_pack && ARGUMENT_PACK_INCOMPLETE_P (old_pack))
24759 : : {
24760 : : /* If we had fewer function args than explicit template args,
24761 : : just use the explicits. */
24762 : 235 : tree explicit_args = ARGUMENT_PACK_EXPLICIT_ARGS (old_pack);
24763 : 235 : int explicit_len = TREE_VEC_LENGTH (explicit_args);
24764 : 235 : if (len < explicit_len)
24765 : 4982088 : new_args = explicit_args;
24766 : : }
24767 : :
24768 : 4982088 : if (!old_pack)
24769 : : {
24770 : 4788532 : tree result;
24771 : : /* Build the deduced *_ARGUMENT_PACK. */
24772 : 4788532 : if (TREE_CODE (TREE_PURPOSE (pack)) == TEMPLATE_PARM_INDEX)
24773 : : {
24774 : 136752 : result = make_node (NONTYPE_ARGUMENT_PACK);
24775 : 136752 : TREE_CONSTANT (result) = 1;
24776 : : }
24777 : : else
24778 : 4651780 : result = cxx_make_type (TYPE_ARGUMENT_PACK);
24779 : :
24780 : 4788532 : ARGUMENT_PACK_ARGS (result) = new_args;
24781 : :
24782 : : /* Note the deduced argument packs for this parameter
24783 : : pack. */
24784 : 9577064 : TMPL_ARG (targs, level, idx) = result;
24785 : : }
24786 : 193556 : else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack)
24787 : 193556 : && (ARGUMENT_PACK_ARGS (old_pack)
24788 : 235 : == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack)))
24789 : : {
24790 : : /* We only had the explicitly-provided arguments before, but
24791 : : now we have a complete set of arguments. */
24792 : 235 : tree explicit_args = ARGUMENT_PACK_EXPLICIT_ARGS (old_pack);
24793 : :
24794 : 235 : ARGUMENT_PACK_ARGS (old_pack) = new_args;
24795 : 235 : ARGUMENT_PACK_INCOMPLETE_P (old_pack) = 1;
24796 : 235 : ARGUMENT_PACK_EXPLICIT_ARGS (old_pack) = explicit_args;
24797 : : }
24798 : : else
24799 : : {
24800 : 193321 : tree bad_old_arg = NULL_TREE, bad_new_arg = NULL_TREE;
24801 : 193321 : tree old_args = ARGUMENT_PACK_ARGS (old_pack);
24802 : 193321 : temp_override<int> ovl (TREE_VEC_LENGTH (old_args));
24803 : : /* During template argument deduction for the aggregate deduction
24804 : : candidate, the number of elements in a trailing parameter pack
24805 : : is only deduced from the number of remaining function
24806 : : arguments if it is not otherwise deduced. */
24807 : 193321 : if (cxx_dialect >= cxx20
24808 : 46884 : && TREE_VEC_LENGTH (new_args) < TREE_VEC_LENGTH (old_args)
24809 : : /* FIXME This isn't set properly for partial instantiations. */
24810 : 13 : && TPARMS_PRIMARY_TEMPLATE (tparms)
24811 : 193333 : && builtin_guide_p (TPARMS_PRIMARY_TEMPLATE (tparms)))
24812 : 12 : TREE_VEC_LENGTH (old_args) = TREE_VEC_LENGTH (new_args);
24813 : 193321 : if (!comp_template_args (old_args, new_args,
24814 : : &bad_old_arg, &bad_new_arg))
24815 : : /* Inconsistent unification of this parameter pack. */
24816 : 21 : return unify_parameter_pack_inconsistent (explain_p,
24817 : : bad_old_arg,
24818 : : bad_new_arg);
24819 : 193321 : }
24820 : : }
24821 : :
24822 : 5260298 : return unify_success (explain_p);
24823 : : }
24824 : :
24825 : : /* Handle unification of the domain of an array. PARM_DOM and ARG_DOM are
24826 : : INTEGER_TYPEs representing the TYPE_DOMAIN of ARRAY_TYPEs. The other
24827 : : parameters and return value are as for unify. */
24828 : :
24829 : : static int
24830 : 61204 : unify_array_domain (tree tparms, tree targs,
24831 : : tree parm_dom, tree arg_dom,
24832 : : bool explain_p)
24833 : : {
24834 : 61204 : tree parm_max;
24835 : 61204 : tree arg_max;
24836 : 61204 : bool parm_cst;
24837 : 61204 : bool arg_cst;
24838 : :
24839 : : /* Our representation of array types uses "N - 1" as the
24840 : : TYPE_MAX_VALUE for an array with "N" elements, if "N" is
24841 : : not an integer constant. We cannot unify arbitrarily
24842 : : complex expressions, so we eliminate the MINUS_EXPRs
24843 : : here. */
24844 : 61204 : parm_max = TYPE_MAX_VALUE (parm_dom);
24845 : 61204 : parm_cst = TREE_CODE (parm_max) == INTEGER_CST;
24846 : 61204 : if (!parm_cst)
24847 : : {
24848 : 61120 : gcc_assert (TREE_CODE (parm_max) == MINUS_EXPR);
24849 : 61120 : parm_max = TREE_OPERAND (parm_max, 0);
24850 : : }
24851 : 61204 : arg_max = TYPE_MAX_VALUE (arg_dom);
24852 : 61204 : arg_cst = TREE_CODE (arg_max) == INTEGER_CST;
24853 : 61204 : if (!arg_cst)
24854 : : {
24855 : : /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
24856 : : trying to unify the type of a variable with the type
24857 : : of a template parameter. For example:
24858 : :
24859 : : template <unsigned int N>
24860 : : void f (char (&) [N]);
24861 : : int g();
24862 : : void h(int i) {
24863 : : char a[g(i)];
24864 : : f(a);
24865 : : }
24866 : :
24867 : : Here, the type of the ARG will be "int [g(i)]", and
24868 : : may be a SAVE_EXPR, etc. */
24869 : 6416 : if (TREE_CODE (arg_max) != MINUS_EXPR)
24870 : 6 : return unify_vla_arg (explain_p, arg_dom);
24871 : 6410 : arg_max = TREE_OPERAND (arg_max, 0);
24872 : : }
24873 : :
24874 : : /* If only one of the bounds used a MINUS_EXPR, compensate
24875 : : by adding one to the other bound. */
24876 : 61198 : if (parm_cst && !arg_cst)
24877 : 0 : parm_max = fold_build2_loc (input_location, PLUS_EXPR,
24878 : : integer_type_node,
24879 : : parm_max,
24880 : : integer_one_node);
24881 : 61198 : else if (arg_cst && !parm_cst)
24882 : 54704 : arg_max = fold_build2_loc (input_location, PLUS_EXPR,
24883 : : integer_type_node,
24884 : : arg_max,
24885 : : integer_one_node);
24886 : :
24887 : 61198 : return unify (tparms, targs, parm_max, arg_max,
24888 : 61198 : UNIFY_ALLOW_INTEGER, explain_p);
24889 : : }
24890 : :
24891 : : /* Returns whether T, a P or A in unify, is a type, template or expression. */
24892 : :
24893 : : enum pa_kind_t { pa_type, pa_tmpl, pa_expr };
24894 : :
24895 : : static pa_kind_t
24896 : 1148099900 : pa_kind (tree t)
24897 : : {
24898 : 1148099900 : if (PACK_EXPANSION_P (t))
24899 : 1170681 : t = PACK_EXPANSION_PATTERN (t);
24900 : 1148099900 : if (TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM
24901 : 1147625198 : || TREE_CODE (t) == UNBOUND_CLASS_TEMPLATE
24902 : 2295725077 : || DECL_TYPE_TEMPLATE_P (t))
24903 : : return pa_tmpl;
24904 : 1147294397 : else if (TYPE_P (t))
24905 : : return pa_type;
24906 : : else
24907 : 195313251 : return pa_expr;
24908 : : }
24909 : :
24910 : : /* Deduce the value of template parameters. TPARMS is the (innermost)
24911 : : set of template parameters to a template. TARGS is the bindings
24912 : : for those template parameters, as determined thus far; TARGS may
24913 : : include template arguments for outer levels of template parameters
24914 : : as well. PARM is a parameter to a template function, or a
24915 : : subcomponent of that parameter; ARG is the corresponding argument.
24916 : : This function attempts to match PARM with ARG in a manner
24917 : : consistent with the existing assignments in TARGS. If more values
24918 : : are deduced, then TARGS is updated.
24919 : :
24920 : : Returns 0 if the type deduction succeeds, 1 otherwise. The
24921 : : parameter STRICT is a bitwise or of the following flags:
24922 : :
24923 : : UNIFY_ALLOW_NONE:
24924 : : Require an exact match between PARM and ARG.
24925 : : UNIFY_ALLOW_MORE_CV_QUAL:
24926 : : Allow the deduced ARG to be more cv-qualified (by qualification
24927 : : conversion) than ARG.
24928 : : UNIFY_ALLOW_LESS_CV_QUAL:
24929 : : Allow the deduced ARG to be less cv-qualified than ARG.
24930 : : UNIFY_ALLOW_DERIVED:
24931 : : Allow the deduced ARG to be a template base class of ARG,
24932 : : or a pointer to a template base class of the type pointed to by
24933 : : ARG.
24934 : : UNIFY_ALLOW_INTEGER:
24935 : : Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
24936 : : case for more information.
24937 : : UNIFY_ALLOW_OUTER_LEVEL:
24938 : : This is the outermost level of a deduction. Used to determine validity
24939 : : of qualification conversions. A valid qualification conversion must
24940 : : have const qualified pointers leading up to the inner type which
24941 : : requires additional CV quals, except at the outer level, where const
24942 : : is not required [conv.qual]. It would be normal to set this flag in
24943 : : addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
24944 : : UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
24945 : : This is the outermost level of a deduction, and PARM can be more CV
24946 : : qualified at this point.
24947 : : UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
24948 : : This is the outermost level of a deduction, and PARM can be less CV
24949 : : qualified at this point. */
24950 : :
24951 : : static int
24952 : 584586418 : unify (tree tparms, tree targs, tree parm, tree arg, int strict,
24953 : : bool explain_p)
24954 : : {
24955 : 584586418 : int idx;
24956 : 584586418 : tree targ;
24957 : 584586418 : tree tparm;
24958 : 584586418 : int strict_in = strict;
24959 : 1169172836 : tsubst_flags_t complain = (explain_p
24960 : 584586418 : ? tf_warning_or_error
24961 : : : tf_none);
24962 : :
24963 : : /* I don't think this will do the right thing with respect to types.
24964 : : But the only case I've seen it in so far has been array bounds, where
24965 : : signedness is the only information lost, and I think that will be
24966 : : okay. VIEW_CONVERT_EXPR can appear with class NTTP, thanks to
24967 : : finish_id_expression_1, and are also OK. */
24968 : 1169173071 : while (CONVERT_EXPR_P (parm) || TREE_CODE (parm) == VIEW_CONVERT_EXPR
24969 : 1169175405 : || TREE_CODE (parm) == IMPLICIT_CONV_EXPR)
24970 : 2379 : parm = TREE_OPERAND (parm, 0);
24971 : :
24972 : 584586418 : if (arg == error_mark_node)
24973 : 194900685 : return unify_invalid (explain_p);
24974 : 584586418 : if (arg == unknown_type_node
24975 : 584586418 : || arg == init_list_type_node)
24976 : : /* We can't deduce anything from this, but we might get all the
24977 : : template args from other function args. */
24978 : 247944992 : return unify_success (explain_p);
24979 : :
24980 : 584586418 : if (parm == any_targ_node || arg == any_targ_node)
24981 : 247944992 : return unify_success (explain_p);
24982 : :
24983 : : /* Stripping IMPLICIT_CONV_EXPR above can produce this mismatch
24984 : : (g++.dg/abi/mangle57.C). */
24985 : 584586410 : if (TREE_CODE (parm) == FUNCTION_DECL
24986 : 21 : && TREE_CODE (arg) == ADDR_EXPR)
24987 : 9 : arg = TREE_OPERAND (arg, 0);
24988 : :
24989 : : /* If PARM uses template parameters, then we can't bail out here,
24990 : : even if ARG == PARM, since we won't record unifications for the
24991 : : template parameters. We might need them if we're trying to
24992 : : figure out which of two things is more specialized. */
24993 : 584586410 : if (arg == parm
24994 : 584586410 : && (DECL_P (parm) || !uses_template_parms (parm)))
24995 : 10529747 : return unify_success (explain_p);
24996 : :
24997 : : /* Handle init lists early, so the rest of the function can assume
24998 : : we're dealing with a type. */
24999 : 574056663 : if (BRACE_ENCLOSED_INITIALIZER_P (arg))
25000 : : {
25001 : 6713 : tree elttype;
25002 : 6713 : tree orig_parm = parm;
25003 : :
25004 : 6713 : if (!is_std_init_list (parm)
25005 : 6713 : && TREE_CODE (parm) != ARRAY_TYPE)
25006 : : /* We can only deduce from an initializer list argument if the
25007 : : parameter is std::initializer_list or an array; otherwise this
25008 : : is a non-deduced context. */
25009 : 6218 : return unify_success (explain_p);
25010 : :
25011 : 1519 : if (TREE_CODE (parm) == ARRAY_TYPE)
25012 : 94 : elttype = TREE_TYPE (parm);
25013 : : else
25014 : : {
25015 : 1425 : elttype = TREE_VEC_ELT (CLASSTYPE_TI_ARGS (parm), 0);
25016 : : /* Deduction is defined in terms of a single type, so just punt
25017 : : on the (bizarre) std::initializer_list<T...>. */
25018 : 1425 : if (PACK_EXPANSION_P (elttype))
25019 : 6218 : return unify_success (explain_p);
25020 : : }
25021 : :
25022 : 1516 : if (strict != DEDUCE_EXACT
25023 : 1516 : && TYPE_P (elttype)
25024 : 3032 : && !uses_deducible_template_parms (elttype))
25025 : : /* If ELTTYPE has no deducible template parms, skip deduction from
25026 : : the list elements. */;
25027 : : else
25028 : 7913 : for (auto &e: CONSTRUCTOR_ELTS (arg))
25029 : : {
25030 : 3963 : tree elt = e.value;
25031 : 3963 : int elt_strict = strict;
25032 : :
25033 : 3963 : if (elt == error_mark_node)
25034 : 446 : return unify_invalid (explain_p);
25035 : :
25036 : 3957 : if (!BRACE_ENCLOSED_INITIALIZER_P (elt))
25037 : : {
25038 : 3425 : tree type = TREE_TYPE (elt);
25039 : 3425 : if (type == error_mark_node)
25040 : 6 : return unify_invalid (explain_p);
25041 : : /* It should only be possible to get here for a call. */
25042 : 3419 : gcc_assert (elt_strict & UNIFY_ALLOW_OUTER_LEVEL);
25043 : 6838 : elt_strict |= maybe_adjust_types_for_deduction
25044 : 3419 : (tparms, DEDUCE_CALL, &elttype, &type, elt);
25045 : 3419 : elt = type;
25046 : : }
25047 : :
25048 : 3951 : RECUR_AND_CHECK_FAILURE (tparms, targs, elttype, elt, elt_strict,
25049 : : explain_p);
25050 : : }
25051 : :
25052 : 1070 : if (TREE_CODE (parm) == ARRAY_TYPE
25053 : 1070 : && deducible_array_bound (TYPE_DOMAIN (parm)))
25054 : : {
25055 : : /* Also deduce from the length of the initializer list. */
25056 : 98 : tree max = size_int (CONSTRUCTOR_NELTS (arg));
25057 : 49 : tree idx = compute_array_index_type (NULL_TREE, max, tf_none);
25058 : 49 : if (idx == error_mark_node)
25059 : 446 : return unify_invalid (explain_p);
25060 : 49 : return unify_array_domain (tparms, targs, TYPE_DOMAIN (parm),
25061 : 49 : idx, explain_p);
25062 : : }
25063 : :
25064 : : /* If the std::initializer_list<T> deduction worked, replace the
25065 : : deduced A with std::initializer_list<A>. */
25066 : : if (orig_parm != parm)
25067 : : {
25068 : : idx = TEMPLATE_TYPE_IDX (orig_parm);
25069 : : targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
25070 : : targ = listify (targ);
25071 : : TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = targ;
25072 : : }
25073 : 6218 : return unify_success (explain_p);
25074 : : }
25075 : :
25076 : : /* If parm and arg aren't the same kind of thing (template, type, or
25077 : : expression), fail early. */
25078 : 574049950 : if (pa_kind (parm) != pa_kind (arg))
25079 : 194900685 : return unify_invalid (explain_p);
25080 : :
25081 : : /* Immediately reject some pairs that won't unify because of
25082 : : cv-qualification mismatches. */
25083 : 574049934 : if (TREE_CODE (arg) == TREE_CODE (parm)
25084 : 266092482 : && TYPE_P (arg)
25085 : : /* It is the elements of the array which hold the cv quals of an array
25086 : : type, and the elements might be template type parms. We'll check
25087 : : when we recurse. */
25088 : 174033062 : && TREE_CODE (arg) != ARRAY_TYPE
25089 : : /* We check the cv-qualifiers when unifying with template type
25090 : : parameters below. We want to allow ARG `const T' to unify with
25091 : : PARM `T' for example, when computing which of two templates
25092 : : is more specialized, for example. */
25093 : 173963247 : && TREE_CODE (arg) != TEMPLATE_TYPE_PARM
25094 : 718174440 : && !check_cv_quals_for_unify (strict_in, arg, parm))
25095 : 971420 : return unify_cv_qual_mismatch (explain_p, parm, arg);
25096 : :
25097 : 573078514 : if (!(strict & UNIFY_ALLOW_OUTER_LEVEL)
25098 : 289152499 : && TYPE_P (parm) && !CP_TYPE_CONST_P (parm)
25099 : 762078485 : && !FUNC_OR_METHOD_TYPE_P (parm))
25100 : 188733210 : strict &= ~UNIFY_ALLOW_MORE_CV_QUAL;
25101 : : /* PMFs recurse at the same level, so don't strip this yet. */
25102 : 573078514 : if (!TYPE_PTRMEMFUNC_P (parm))
25103 : 573074546 : strict &= ~UNIFY_ALLOW_OUTER_LEVEL;
25104 : 573078514 : strict &= ~UNIFY_ALLOW_DERIVED;
25105 : 573078514 : strict &= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
25106 : 573078514 : strict &= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL;
25107 : :
25108 : 573078514 : switch (TREE_CODE (parm))
25109 : : {
25110 : : case TYPENAME_TYPE:
25111 : : case SCOPE_REF:
25112 : : case UNBOUND_CLASS_TEMPLATE:
25113 : : /* In a type which contains a nested-name-specifier, template
25114 : : argument values cannot be deduced for template parameters used
25115 : : within the nested-name-specifier. */
25116 : 247944992 : return unify_success (explain_p);
25117 : :
25118 : 169506534 : case TEMPLATE_TYPE_PARM:
25119 : 169506534 : case TEMPLATE_TEMPLATE_PARM:
25120 : 169506534 : case BOUND_TEMPLATE_TEMPLATE_PARM:
25121 : 169506534 : tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
25122 : 169506534 : if (error_operand_p (tparm))
25123 : 194900685 : return unify_invalid (explain_p);
25124 : :
25125 : 339013060 : if (TEMPLATE_TYPE_LEVEL (parm)
25126 : 169506530 : != template_decl_level (tparm))
25127 : : /* The PARM is not one we're trying to unify. Just check
25128 : : to see if it matches ARG. */
25129 : : {
25130 : 69 : if (TREE_CODE (arg) == TREE_CODE (parm)
25131 : 78 : && (is_auto (parm) ? is_auto (arg)
25132 : 9 : : same_type_p (parm, arg)))
25133 : 39 : return unify_success (explain_p);
25134 : : else
25135 : 30 : return unify_type_mismatch (explain_p, parm, arg);
25136 : : }
25137 : 169506461 : idx = TEMPLATE_TYPE_IDX (parm);
25138 : 169506461 : targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
25139 : 169506461 : tparm = TREE_VALUE (TREE_VEC_ELT (tparms, idx));
25140 : 169506461 : if (error_operand_p (tparm))
25141 : 194900685 : return unify_invalid (explain_p);
25142 : :
25143 : : /* Check for mixed types and values. */
25144 : 169506461 : if ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
25145 : 169059410 : && TREE_CODE (tparm) != TYPE_DECL)
25146 : 169506461 : || (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
25147 : 400489 : && TREE_CODE (tparm) != TEMPLATE_DECL))
25148 : 0 : gcc_unreachable ();
25149 : :
25150 : 169506461 : if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
25151 : : {
25152 : 46562 : if ((strict_in & UNIFY_ALLOW_DERIVED)
25153 : 46562 : && CLASS_TYPE_P (arg))
25154 : : {
25155 : : /* First try to match ARG directly. */
25156 : 768 : tree t = try_class_unification (tparms, targs, parm, arg,
25157 : 768 : explain_p);
25158 : 768 : if (!t)
25159 : : {
25160 : : /* Otherwise, look for a suitable base of ARG, as below. */
25161 : 40 : enum template_base_result r;
25162 : 40 : r = get_template_base (tparms, targs, parm, arg,
25163 : : explain_p, &t);
25164 : 40 : if (!t)
25165 : 34 : return unify_no_common_base (explain_p, r, parm, arg);
25166 : 6 : arg = t;
25167 : : }
25168 : : }
25169 : : /* ARG must be constructed from a template class or a template
25170 : : template parameter. */
25171 : 45794 : else if (TREE_CODE (arg) != BOUND_TEMPLATE_TEMPLATE_PARM
25172 : 45794 : && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg))
25173 : 1027 : return unify_template_deduction_failure (explain_p, parm, arg);
25174 : :
25175 : : /* Deduce arguments T, i from TT<T> or TT<i>. */
25176 : 45501 : if (unify_bound_ttp_args (tparms, targs, parm, arg, explain_p))
25177 : : return 1;
25178 : :
25179 : 45454 : arg = TYPE_TI_TEMPLATE (arg);
25180 : 45454 : if (DECL_TEMPLATE_TEMPLATE_PARM_P (arg))
25181 : : /* If the template is a template template parameter, use the
25182 : : TEMPLATE_TEMPLATE_PARM for matching. */
25183 : 41 : arg = TREE_TYPE (arg);
25184 : :
25185 : : /* Fall through to deduce template name. */
25186 : : }
25187 : :
25188 : 169505353 : if (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
25189 : 169104864 : || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
25190 : : {
25191 : : /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
25192 : :
25193 : : /* Simple cases: Value already set, does match or doesn't. */
25194 : 445943 : if (targ != NULL_TREE && template_args_equal (targ, arg))
25195 : 247944992 : return unify_success (explain_p);
25196 : 441062 : else if (targ)
25197 : 5537 : return unify_inconsistency (explain_p, parm, targ, arg);
25198 : : }
25199 : : else
25200 : : {
25201 : : /* If PARM is `const T' and ARG is only `int', we don't have
25202 : : a match unless we are allowing additional qualification.
25203 : : If ARG is `const int' and PARM is just `T' that's OK;
25204 : : that binds `const int' to `T'. */
25205 : 169059410 : if (!check_cv_quals_for_unify (strict_in | UNIFY_ALLOW_LESS_CV_QUAL,
25206 : : arg, parm))
25207 : 1174611 : return unify_cv_qual_mismatch (explain_p, parm, arg);
25208 : :
25209 : : /* Consider the case where ARG is `const volatile int' and
25210 : : PARM is `const T'. Then, T should be `volatile int'. */
25211 : 335769598 : arg = cp_build_qualified_type
25212 : 167884799 : (arg, cp_type_quals (arg) & ~cp_type_quals (parm), tf_none);
25213 : 167884799 : if (arg == error_mark_node)
25214 : 194900685 : return unify_invalid (explain_p);
25215 : :
25216 : : /* Simple cases: Value already set, does match or doesn't. */
25217 : 167884799 : if (targ != NULL_TREE && same_type_p (targ, arg))
25218 : 247944992 : return unify_success (explain_p);
25219 : 144741327 : else if (targ)
25220 : 1290248 : return unify_inconsistency (explain_p, parm, targ, arg);
25221 : :
25222 : : /* Make sure that ARG is not a variable-sized array. (Note
25223 : : that were talking about variable-sized arrays (like
25224 : : `int[n]'), rather than arrays of unknown size (like
25225 : : `int[]').) We'll get very confused by such a type since
25226 : : the bound of the array is not constant, and therefore
25227 : : not mangleable. Besides, such types are not allowed in
25228 : : ISO C++, so we can do as we please here. We do allow
25229 : : them for 'auto' deduction, since that isn't ABI-exposed. */
25230 : 143451079 : if (!is_auto (parm) && variably_modified_type_p (arg, NULL_TREE))
25231 : 14 : return unify_vla_arg (explain_p, arg);
25232 : :
25233 : : /* Strip typedefs as in convert_template_argument. */
25234 : 143451065 : arg = canonicalize_type_argument (arg, tf_none);
25235 : : }
25236 : :
25237 : : /* If ARG is a parameter pack or an expansion, we cannot unify
25238 : : against it unless PARM is also a parameter pack. */
25239 : 287772700 : if ((template_parameter_pack_p (arg) || PACK_EXPANSION_P (arg))
25240 : 144987553 : && !template_parameter_pack_p (parm))
25241 : 460376 : return unify_parameter_pack_mismatch (explain_p, parm, arg);
25242 : :
25243 : : /* If the argument deduction results is a METHOD_TYPE,
25244 : : then there is a problem.
25245 : : METHOD_TYPE doesn't map to any real C++ type the result of
25246 : : the deduction cannot be of that type. */
25247 : 143426214 : if (TREE_CODE (arg) == METHOD_TYPE)
25248 : 6 : return unify_method_type_error (explain_p, arg);
25249 : :
25250 : 143426208 : TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
25251 : 143426208 : return unify_success (explain_p);
25252 : :
25253 : 6886674 : case TEMPLATE_PARM_INDEX:
25254 : 6886674 : tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
25255 : 6886674 : if (error_operand_p (tparm))
25256 : 194900685 : return unify_invalid (explain_p);
25257 : :
25258 : 6886674 : if (TEMPLATE_PARM_LEVEL (parm)
25259 : 6886674 : != template_decl_level (tparm))
25260 : : {
25261 : : /* The PARM is not one we're trying to unify. Just check
25262 : : to see if it matches ARG. */
25263 : 0 : int result = !(TREE_CODE (arg) == TREE_CODE (parm)
25264 : 0 : && cp_tree_equal (parm, arg));
25265 : 0 : if (result)
25266 : 0 : unify_expression_unequal (explain_p, parm, arg);
25267 : 0 : return result;
25268 : : }
25269 : :
25270 : 6886674 : idx = TEMPLATE_PARM_IDX (parm);
25271 : 6886674 : targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
25272 : :
25273 : 6886674 : if (targ)
25274 : : {
25275 : 5861 : if ((strict & UNIFY_ALLOW_INTEGER)
25276 : 374 : && TREE_TYPE (targ) && TREE_TYPE (arg)
25277 : 6235 : && CP_INTEGRAL_TYPE_P (TREE_TYPE (targ)))
25278 : : /* We're deducing from an array bound, the type doesn't matter.
25279 : : This conversion should match the one below. */
25280 : 374 : arg = fold (build_nop (TREE_TYPE (targ), arg));
25281 : 5861 : int x = !cp_tree_equal (targ, arg);
25282 : 5861 : if (x)
25283 : 482 : unify_inconsistency (explain_p, parm, targ, arg);
25284 : 5861 : return x;
25285 : : }
25286 : :
25287 : : /* [temp.deduct.type] If, in the declaration of a function template
25288 : : with a non-type template-parameter, the non-type
25289 : : template-parameter is used in an expression in the function
25290 : : parameter-list and, if the corresponding template-argument is
25291 : : deduced, the template-argument type shall match the type of the
25292 : : template-parameter exactly, except that a template-argument
25293 : : deduced from an array bound may be of any integral type.
25294 : : The non-type parameter might use already deduced type parameters. */
25295 : 6880813 : tparm = TREE_TYPE (parm);
25296 : 20642385 : if (TEMPLATE_PARM_LEVEL (parm) > TMPL_ARGS_DEPTH (targs))
25297 : : /* We don't have enough levels of args to do any substitution. This
25298 : : can happen in the context of -fnew-ttp-matching. */;
25299 : : else
25300 : : {
25301 : 6875089 : ++processing_template_decl;
25302 : 6875089 : tparm = tsubst (tparm, targs, tf_none, NULL_TREE);
25303 : 6875089 : --processing_template_decl;
25304 : :
25305 : 6875089 : if (tree a = type_uses_auto (tparm))
25306 : : {
25307 : 1394 : tparm = do_auto_deduction (tparm, arg, a,
25308 : : complain, adc_unify, targs,
25309 : : LOOKUP_NORMAL,
25310 : 697 : TPARMS_PRIMARY_TEMPLATE (tparms));
25311 : 697 : if (tparm == error_mark_node)
25312 : : return 1;
25313 : : }
25314 : : }
25315 : :
25316 : 6880792 : if (!TREE_TYPE (arg)
25317 : 6880792 : || TREE_CODE (TREE_TYPE (arg)) == DEPENDENT_OPERATOR_TYPE)
25318 : : /* Template-parameter dependent expression. Just accept it for now.
25319 : : It will later be processed in convert_template_argument. */
25320 : : ;
25321 : 6880778 : else if (same_type_ignoring_top_level_qualifiers_p
25322 : 6880778 : (non_reference (TREE_TYPE (arg)),
25323 : : non_reference (tparm)))
25324 : : /* OK. Ignore top-level quals here because a class-type template
25325 : : parameter object is const. */;
25326 : 54347 : else if ((strict & UNIFY_ALLOW_INTEGER)
25327 : 54075 : && CP_INTEGRAL_TYPE_P (tparm))
25328 : : /* Convert the ARG to the type of PARM; the deduced non-type
25329 : : template argument must exactly match the types of the
25330 : : corresponding parameter. This conversion should match the
25331 : : one above. */
25332 : 54060 : arg = fold (build_nop (tparm, arg));
25333 : 287 : else if (uses_template_parms (tparm))
25334 : : {
25335 : : /* We haven't deduced the type of this parameter yet. */
25336 : 188 : if (cxx_dialect >= cxx17
25337 : : /* We deduce from array bounds in try_array_deduction. */
25338 : 160 : && !(strict & UNIFY_ALLOW_INTEGER)
25339 : 623 : && TEMPLATE_PARM_LEVEL (parm) <= TMPL_ARGS_DEPTH (targs))
25340 : : {
25341 : : /* Deduce it from the non-type argument. As above, ignore
25342 : : top-level quals here too. */
25343 : 108 : tree atype = cv_unqualified (TREE_TYPE (arg));
25344 : 108 : RECUR_AND_CHECK_FAILURE (tparms, targs,
25345 : : tparm, atype,
25346 : : UNIFY_ALLOW_NONE, explain_p);
25347 : : /* Now check whether the type of this parameter is still
25348 : : dependent, and give up if so. */
25349 : 99 : ++processing_template_decl;
25350 : 99 : tparm = tsubst (TREE_TYPE (parm), targs, tf_none, NULL_TREE);
25351 : 99 : --processing_template_decl;
25352 : 99 : if (uses_template_parms (tparm))
25353 : : return unify_success (explain_p);
25354 : : }
25355 : : else
25356 : : /* Try again later. */
25357 : 247944992 : return unify_success (explain_p);
25358 : : }
25359 : : else
25360 : 99 : return unify_type_mismatch (explain_p, tparm, TREE_TYPE (arg));
25361 : :
25362 : : /* If ARG is a parameter pack or an expansion, we cannot unify
25363 : : against it unless PARM is also a parameter pack. */
25364 : 13761084 : if ((template_parameter_pack_p (arg) || PACK_EXPANSION_P (arg))
25365 : 6950140 : && !TEMPLATE_PARM_PARAMETER_PACK (parm))
25366 : 7 : return unify_parameter_pack_mismatch (explain_p, parm, arg);
25367 : :
25368 : 6880535 : {
25369 : 6880535 : bool removed_attr = false;
25370 : 6880535 : arg = strip_typedefs_expr (arg, &removed_attr);
25371 : : }
25372 : 6880535 : TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
25373 : 6880535 : return unify_success (explain_p);
25374 : :
25375 : 18 : case PTRMEM_CST:
25376 : 18 : {
25377 : : /* A pointer-to-member constant can be unified only with
25378 : : another constant. */
25379 : 18 : if (TREE_CODE (arg) != PTRMEM_CST)
25380 : 3 : return unify_ptrmem_cst_mismatch (explain_p, parm, arg);
25381 : :
25382 : : /* Just unify the class member. It would be useless (and possibly
25383 : : wrong, depending on the strict flags) to unify also
25384 : : PTRMEM_CST_CLASS, because we want to be sure that both parm and
25385 : : arg refer to the same variable, even if through different
25386 : : classes. For instance:
25387 : :
25388 : : struct A { int x; };
25389 : : struct B : A { };
25390 : :
25391 : : Unification of &A::x and &B::x must succeed. */
25392 : 15 : return unify (tparms, targs, PTRMEM_CST_MEMBER (parm),
25393 : 15 : PTRMEM_CST_MEMBER (arg), strict, explain_p);
25394 : : }
25395 : :
25396 : 7795205 : case POINTER_TYPE:
25397 : 7795205 : {
25398 : 7795205 : if (!TYPE_PTR_P (arg))
25399 : 4519149 : return unify_type_mismatch (explain_p, parm, arg);
25400 : :
25401 : : /* [temp.deduct.call]
25402 : :
25403 : : A can be another pointer or pointer to member type that can
25404 : : be converted to the deduced A via a qualification
25405 : : conversion (_conv.qual_).
25406 : :
25407 : : We pass down STRICT here rather than UNIFY_ALLOW_NONE.
25408 : : This will allow for additional cv-qualification of the
25409 : : pointed-to types if appropriate. */
25410 : :
25411 : 3276056 : if (TREE_CODE (TREE_TYPE (arg)) == RECORD_TYPE)
25412 : : /* The derived-to-base conversion only persists through one
25413 : : level of pointers. */
25414 : 595640 : strict |= (strict_in & UNIFY_ALLOW_DERIVED);
25415 : :
25416 : 3276056 : return unify (tparms, targs, TREE_TYPE (parm),
25417 : 6552112 : TREE_TYPE (arg), strict, explain_p);
25418 : : }
25419 : :
25420 : 23092984 : case REFERENCE_TYPE:
25421 : 23092984 : if (!TYPE_REF_P (arg)
25422 : 23092984 : || TYPE_REF_IS_RVALUE (parm) != TYPE_REF_IS_RVALUE (arg))
25423 : 3303345 : return unify_type_mismatch (explain_p, parm, arg);
25424 : 19789639 : return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
25425 : 19789639 : strict & UNIFY_ALLOW_MORE_CV_QUAL, explain_p);
25426 : :
25427 : 1308944 : case ARRAY_TYPE:
25428 : 1308944 : if (TREE_CODE (arg) != ARRAY_TYPE)
25429 : 1239129 : return unify_type_mismatch (explain_p, parm, arg);
25430 : 69815 : if ((TYPE_DOMAIN (parm) == NULL_TREE)
25431 : 69815 : != (TYPE_DOMAIN (arg) == NULL_TREE))
25432 : 7423 : return unify_type_mismatch (explain_p, parm, arg);
25433 : 62392 : RECUR_AND_CHECK_FAILURE (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
25434 : : strict & UNIFY_ALLOW_MORE_CV_QUAL, explain_p);
25435 : 62264 : if (TYPE_DOMAIN (parm) != NULL_TREE)
25436 : 122310 : return unify_array_domain (tparms, targs, TYPE_DOMAIN (parm),
25437 : 61155 : TYPE_DOMAIN (arg), explain_p);
25438 : : return unify_success (explain_p);
25439 : :
25440 : 4509346 : case REAL_TYPE:
25441 : 4509346 : case COMPLEX_TYPE:
25442 : 4509346 : case VECTOR_TYPE:
25443 : 4509346 : case INTEGER_TYPE:
25444 : 4509346 : case BOOLEAN_TYPE:
25445 : 4509346 : case ENUMERAL_TYPE:
25446 : 4509346 : case VOID_TYPE:
25447 : 4509346 : case OPAQUE_TYPE:
25448 : 4509346 : case NULLPTR_TYPE:
25449 : 4509346 : if (TREE_CODE (arg) != TREE_CODE (parm))
25450 : 1732031 : return unify_type_mismatch (explain_p, parm, arg);
25451 : :
25452 : : /* We have already checked cv-qualification at the top of the
25453 : : function. */
25454 : 2777315 : if (!same_type_ignoring_top_level_qualifiers_p (arg, parm))
25455 : 2031419 : return unify_type_mismatch (explain_p, parm, arg);
25456 : :
25457 : : /* As far as unification is concerned, this wins. Later checks
25458 : : will invalidate it if necessary. */
25459 : 247944992 : return unify_success (explain_p);
25460 : :
25461 : : /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
25462 : : /* Type INTEGER_CST can come from ordinary constant template args. */
25463 : 4134395 : case INTEGER_CST:
25464 : 4134395 : case REAL_CST:
25465 : 4134395 : if (TREE_TYPE (arg) == NULL_TREE
25466 : 4134395 : || !same_type_p (TREE_TYPE (parm), TREE_TYPE (arg)))
25467 : 12 : return unify_template_argument_mismatch (explain_p, parm, arg);
25468 : 4134383 : while (CONVERT_EXPR_P (arg))
25469 : 0 : arg = TREE_OPERAND (arg, 0);
25470 : :
25471 : 4134383 : if (TREE_CODE (arg) != TREE_CODE (parm))
25472 : 4940 : return unify_template_argument_mismatch (explain_p, parm, arg);
25473 : 4129443 : return (simple_cst_equal (parm, arg)
25474 : 4129443 : ? unify_success (explain_p)
25475 : 4129437 : : unify_template_argument_mismatch (explain_p, parm, arg));
25476 : :
25477 : 86248366 : case TREE_VEC:
25478 : 86248366 : {
25479 : 86248366 : int i, len, argslen;
25480 : 86248366 : int parm_variadic_p = 0;
25481 : :
25482 : 86248366 : if (TREE_CODE (arg) != TREE_VEC)
25483 : 0 : return unify_template_argument_mismatch (explain_p, parm, arg);
25484 : :
25485 : 86248366 : len = TREE_VEC_LENGTH (parm);
25486 : 86248366 : argslen = TREE_VEC_LENGTH (arg);
25487 : :
25488 : : /* Check for pack expansions in the parameters. */
25489 : 251371841 : for (i = 0; i < len; ++i)
25490 : : {
25491 : 165123488 : if (PACK_EXPANSION_P (TREE_VEC_ELT (parm, i)))
25492 : : {
25493 : 4358274 : if (i == len - 1)
25494 : : /* We can unify against something with a trailing
25495 : : parameter pack. */
25496 : : parm_variadic_p = 1;
25497 : : else
25498 : : /* [temp.deduct.type]/9: If the template argument list of
25499 : : P contains a pack expansion that is not the last
25500 : : template argument, the entire template argument list
25501 : : is a non-deduced context. */
25502 : 247944992 : return unify_success (explain_p);
25503 : : }
25504 : : }
25505 : :
25506 : : /* If we don't have enough arguments to satisfy the parameters
25507 : : (not counting the pack expression at the end), or we have
25508 : : too many arguments for a parameter list that doesn't end in
25509 : : a pack expression, we can't unify. */
25510 : 86248353 : if (parm_variadic_p
25511 : 86248353 : ? argslen < len - parm_variadic_p
25512 : : : argslen != len)
25513 : 1333973 : return unify_arity (explain_p, TREE_VEC_LENGTH (arg), len);
25514 : :
25515 : : /* Unify all of the parameters that precede the (optional)
25516 : : pack expression. */
25517 : 212732237 : for (i = 0; i < len - parm_variadic_p; ++i)
25518 : : {
25519 : 146195253 : RECUR_AND_CHECK_FAILURE (tparms, targs,
25520 : : TREE_VEC_ELT (parm, i),
25521 : : TREE_VEC_ELT (arg, i),
25522 : : UNIFY_ALLOW_NONE, explain_p);
25523 : : }
25524 : 66536984 : if (parm_variadic_p)
25525 : 4208390 : return unify_pack_expansion (tparms, targs, parm, arg,
25526 : : DEDUCE_EXACT,
25527 : 4208390 : /*subr=*/true, explain_p);
25528 : 247944992 : return unify_success (explain_p);
25529 : : }
25530 : :
25531 : 262210036 : case RECORD_TYPE:
25532 : 262210036 : case UNION_TYPE:
25533 : 262210036 : if (TREE_CODE (arg) != TREE_CODE (parm))
25534 : 152510807 : return unify_type_mismatch (explain_p, parm, arg);
25535 : :
25536 : 109699229 : if (TYPE_PTRMEMFUNC_P (parm))
25537 : : {
25538 : 3592 : if (!TYPE_PTRMEMFUNC_P (arg))
25539 : 264 : return unify_type_mismatch (explain_p, parm, arg);
25540 : :
25541 : 9984 : return unify (tparms, targs,
25542 : 3328 : TYPE_PTRMEMFUNC_FN_TYPE (parm),
25543 : 3328 : TYPE_PTRMEMFUNC_FN_TYPE (arg),
25544 : 3328 : strict, explain_p);
25545 : : }
25546 : 109695637 : else if (TYPE_PTRMEMFUNC_P (arg))
25547 : 264 : return unify_type_mismatch (explain_p, parm, arg);
25548 : :
25549 : 109695373 : if (CLASSTYPE_TEMPLATE_INFO (parm))
25550 : : {
25551 : 107918759 : tree t = NULL_TREE;
25552 : :
25553 : 107918759 : if (strict_in & UNIFY_ALLOW_DERIVED)
25554 : : {
25555 : : /* First, we try to unify the PARM and ARG directly. */
25556 : 82049056 : t = try_class_unification (tparms, targs,
25557 : : parm, arg, explain_p);
25558 : :
25559 : 82049056 : if (!t)
25560 : : {
25561 : : /* Fallback to the special case allowed in
25562 : : [temp.deduct.call]:
25563 : :
25564 : : If P is a class, and P has the form
25565 : : template-id, then A can be a derived class of
25566 : : the deduced A. Likewise, if P is a pointer to
25567 : : a class of the form template-id, A can be a
25568 : : pointer to a derived class pointed to by the
25569 : : deduced A. */
25570 : 72745111 : enum template_base_result r;
25571 : 72745111 : r = get_template_base (tparms, targs, parm, arg,
25572 : : explain_p, &t);
25573 : :
25574 : 72745111 : if (!t)
25575 : : {
25576 : : /* Don't give the derived diagnostic if we're
25577 : : already dealing with the same template. */
25578 : 72038996 : bool same_template
25579 : 72038996 : = (CLASSTYPE_TEMPLATE_INFO (arg)
25580 : 72038996 : && (CLASSTYPE_TI_TEMPLATE (parm)
25581 : 49985520 : == CLASSTYPE_TI_TEMPLATE (arg)));
25582 : 72038996 : return unify_no_common_base (explain_p && !same_template,
25583 : 72038996 : r, parm, arg);
25584 : : }
25585 : : }
25586 : : }
25587 : 25869703 : else if (CLASSTYPE_TEMPLATE_INFO (arg)
25588 : 25869703 : && (CLASSTYPE_TI_TEMPLATE (parm)
25589 : 24912095 : == CLASSTYPE_TI_TEMPLATE (arg)))
25590 : : /* Perhaps PARM is something like S<U> and ARG is S<int>.
25591 : : Then, we should unify `int' and `U'. */
25592 : 23572219 : t = arg;
25593 : : else
25594 : : /* There's no chance of unification succeeding. */
25595 : 2297484 : return unify_type_mismatch (explain_p, parm, arg);
25596 : :
25597 : 33582279 : if (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
25598 : 33582279 : return unify (tparms, targs,
25599 : 33582279 : INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (parm)),
25600 : 33582279 : INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (t)),
25601 : 33582279 : UNIFY_ALLOW_NONE, explain_p);
25602 : : else
25603 : 107918759 : return unify_success (explain_p);
25604 : : }
25605 : 1776614 : else if (!same_type_ignoring_top_level_qualifiers_p (parm, arg))
25606 : 1776351 : return unify_type_mismatch (explain_p, parm, arg);
25607 : 247944992 : return unify_success (explain_p);
25608 : :
25609 : 266764 : case METHOD_TYPE:
25610 : 266764 : case FUNCTION_TYPE:
25611 : 266764 : {
25612 : 266764 : unsigned int nargs;
25613 : 266764 : tree *args;
25614 : 266764 : tree a;
25615 : 266764 : unsigned int i;
25616 : :
25617 : 266764 : if (TREE_CODE (arg) != TREE_CODE (parm))
25618 : 2509 : return unify_type_mismatch (explain_p, parm, arg);
25619 : :
25620 : : /* CV qualifications for methods can never be deduced, they must
25621 : : match exactly. We need to check them explicitly here,
25622 : : because type_unification_real treats them as any other
25623 : : cv-qualified parameter. */
25624 : 264255 : if (TREE_CODE (parm) == METHOD_TYPE
25625 : 267583 : && (!check_cv_quals_for_unify
25626 : 3328 : (UNIFY_ALLOW_NONE,
25627 : : class_of_this_parm (arg),
25628 : : class_of_this_parm (parm))))
25629 : 2224 : return unify_cv_qual_mismatch (explain_p, parm, arg);
25630 : 262031 : if (TREE_CODE (arg) == FUNCTION_TYPE
25631 : 262031 : && type_memfn_quals (parm) != type_memfn_quals (arg))
25632 : 396 : return unify_cv_qual_mismatch (explain_p, parm, arg);
25633 : 261635 : if (type_memfn_rqual (parm) != type_memfn_rqual (arg))
25634 : 540 : return unify_type_mismatch (explain_p, parm, arg);
25635 : :
25636 : 261095 : RECUR_AND_CHECK_FAILURE (tparms, targs, TREE_TYPE (parm),
25637 : : TREE_TYPE (arg), UNIFY_ALLOW_NONE, explain_p);
25638 : :
25639 : 260436 : nargs = list_length (TYPE_ARG_TYPES (arg));
25640 : 260436 : args = XALLOCAVEC (tree, nargs);
25641 : 260436 : for (a = TYPE_ARG_TYPES (arg), i = 0;
25642 : 887469 : a != NULL_TREE && a != void_list_node;
25643 : 627033 : a = TREE_CHAIN (a), ++i)
25644 : 627033 : args[i] = TREE_VALUE (a);
25645 : 260436 : nargs = i;
25646 : :
25647 : 260436 : if (type_unification_real (tparms, targs, TYPE_ARG_TYPES (parm),
25648 : : args, nargs, 1, DEDUCE_EXACT,
25649 : : NULL, explain_p))
25650 : : return 1;
25651 : :
25652 : 260214 : if (flag_noexcept_type)
25653 : : {
25654 : 256695 : tree pspec = TYPE_RAISES_EXCEPTIONS (parm);
25655 : 256695 : tree aspec = canonical_eh_spec (TYPE_RAISES_EXCEPTIONS (arg));
25656 : 256695 : if (pspec == NULL_TREE) pspec = noexcept_false_spec;
25657 : 256695 : if (aspec == NULL_TREE) aspec = noexcept_false_spec;
25658 : 513390 : if (TREE_PURPOSE (pspec) && TREE_PURPOSE (aspec)
25659 : 513390 : && uses_template_parms (TREE_PURPOSE (pspec)))
25660 : 184 : RECUR_AND_CHECK_FAILURE (tparms, targs, TREE_PURPOSE (pspec),
25661 : : TREE_PURPOSE (aspec),
25662 : : UNIFY_ALLOW_NONE, explain_p);
25663 : : else
25664 : : {
25665 : 256511 : bool pn = nothrow_spec_p (pspec);
25666 : 256511 : bool an = nothrow_spec_p (aspec);
25667 : : /* Here "less cv-qual" means the deduced arg (i.e. parm) has
25668 : : /more/ noexcept, since function pointer conversions are the
25669 : : reverse of qualification conversions. */
25670 : 256511 : if (an == pn
25671 : 210050 : || (an < pn && (strict & UNIFY_ALLOW_LESS_CV_QUAL))
25672 : 210044 : || (an > pn && (strict & UNIFY_ALLOW_MORE_CV_QUAL)))
25673 : : /* OK. */;
25674 : : else
25675 : 108 : return unify_type_mismatch (explain_p, parm, arg);
25676 : : }
25677 : : }
25678 : 260106 : if (flag_tm)
25679 : : {
25680 : : /* As for noexcept. */
25681 : 62 : bool pn = tx_safe_fn_type_p (parm);
25682 : 62 : bool an = tx_safe_fn_type_p (arg);
25683 : 62 : if (an == pn
25684 : 4 : || (an < pn && (strict & UNIFY_ALLOW_LESS_CV_QUAL))
25685 : 4 : || (an > pn && (strict & UNIFY_ALLOW_MORE_CV_QUAL)))
25686 : : /* OK. */;
25687 : : else
25688 : 1 : return unify_type_mismatch (explain_p, parm, arg);
25689 : : }
25690 : :
25691 : : return 0;
25692 : : }
25693 : :
25694 : 43194 : case OFFSET_TYPE:
25695 : : /* Unify a pointer to member with a pointer to member function, which
25696 : : deduces the type of the member as a function type. */
25697 : 43194 : if (TYPE_PTRMEMFUNC_P (arg))
25698 : : {
25699 : : /* Check top-level cv qualifiers */
25700 : 19441 : if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE, arg, parm))
25701 : 24 : return unify_cv_qual_mismatch (explain_p, parm, arg);
25702 : :
25703 : 19417 : RECUR_AND_CHECK_FAILURE (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
25704 : : TYPE_PTRMEMFUNC_OBJECT_TYPE (arg),
25705 : : UNIFY_ALLOW_NONE, explain_p);
25706 : :
25707 : : /* Determine the type of the function we are unifying against. */
25708 : 19417 : tree fntype = static_fn_type (arg);
25709 : :
25710 : 19417 : return unify (tparms, targs, TREE_TYPE (parm), fntype, strict, explain_p);
25711 : : }
25712 : :
25713 : 23753 : if (TREE_CODE (arg) != OFFSET_TYPE)
25714 : 22132 : return unify_type_mismatch (explain_p, parm, arg);
25715 : 1621 : RECUR_AND_CHECK_FAILURE (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
25716 : : TYPE_OFFSET_BASETYPE (arg),
25717 : : UNIFY_ALLOW_NONE, explain_p);
25718 : 1621 : return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
25719 : 1621 : strict, explain_p);
25720 : :
25721 : 0 : case CONST_DECL:
25722 : : /* CONST_DECL should already have been folded to its DECL_INITIAL. */
25723 : 0 : gcc_unreachable ();
25724 : :
25725 : 2261 : case FIELD_DECL:
25726 : 2261 : case FUNCTION_DECL:
25727 : 2261 : case TEMPLATE_DECL:
25728 : : /* Matched cases are handled by the ARG == PARM test above. */
25729 : 2261 : return unify_template_argument_mismatch (explain_p, parm, arg);
25730 : :
25731 : 24 : case VAR_DECL:
25732 : : /* We might get a variable as a non-type template argument in parm if the
25733 : : corresponding parameter is type-dependent. Make any necessary
25734 : : adjustments based on whether arg is a reference. */
25735 : 24 : if (CONSTANT_CLASS_P (arg))
25736 : 6 : parm = fold_non_dependent_expr (parm, complain);
25737 : 18 : else if (REFERENCE_REF_P (arg))
25738 : : {
25739 : 12 : tree sub = TREE_OPERAND (arg, 0);
25740 : 12 : STRIP_NOPS (sub);
25741 : 12 : if (TREE_CODE (sub) == ADDR_EXPR)
25742 : 12 : arg = TREE_OPERAND (sub, 0);
25743 : : }
25744 : : /* Now use the normal expression code to check whether they match. */
25745 : 24 : goto expr;
25746 : :
25747 : 6449729 : case TYPE_ARGUMENT_PACK:
25748 : 6449729 : case NONTYPE_ARGUMENT_PACK:
25749 : 6449729 : return unify (tparms, targs, ARGUMENT_PACK_ARGS (parm),
25750 : 12899458 : ARGUMENT_PACK_ARGS (arg), strict, explain_p);
25751 : :
25752 : : case TYPEOF_TYPE:
25753 : : case DECLTYPE_TYPE:
25754 : : case TRAIT_TYPE:
25755 : : /* Cannot deduce anything from TYPEOF_TYPE, DECLTYPE_TYPE,
25756 : : or TRAIT_TYPE nodes. */
25757 : 247944992 : return unify_success (explain_p);
25758 : :
25759 : : case ERROR_MARK:
25760 : : /* Unification fails if we hit an error node. */
25761 : 194900685 : return unify_invalid (explain_p);
25762 : :
25763 : 58 : case INDIRECT_REF:
25764 : 58 : if (REFERENCE_REF_P (parm))
25765 : : {
25766 : 58 : bool pexp = PACK_EXPANSION_P (arg);
25767 : 58 : if (pexp)
25768 : 3 : arg = PACK_EXPANSION_PATTERN (arg);
25769 : 58 : if (REFERENCE_REF_P (arg))
25770 : 58 : arg = TREE_OPERAND (arg, 0);
25771 : 58 : if (pexp)
25772 : 3 : arg = make_pack_expansion (arg, complain);
25773 : 58 : return unify (tparms, targs, TREE_OPERAND (parm, 0), arg,
25774 : 58 : strict, explain_p);
25775 : : }
25776 : : /* FALLTHRU */
25777 : :
25778 : 267 : default:
25779 : : /* An unresolved overload is a nondeduced context. */
25780 : 267 : if (is_overloaded_fn (parm) || type_unknown_p (parm))
25781 : 247944992 : return unify_success (explain_p);
25782 : 201 : gcc_assert (EXPR_P (parm)
25783 : : || TREE_CODE (parm) == CONSTRUCTOR
25784 : : || TREE_CODE (parm) == TRAIT_EXPR);
25785 : 201 : expr:
25786 : : /* We must be looking at an expression. This can happen with
25787 : : something like:
25788 : :
25789 : : template <int I>
25790 : : void foo(S<I>, S<I + 2>);
25791 : :
25792 : : or
25793 : :
25794 : : template<typename T>
25795 : : void foo(A<T, T{}>);
25796 : :
25797 : : This is a "non-deduced context":
25798 : :
25799 : : [deduct.type]
25800 : :
25801 : : The non-deduced contexts are:
25802 : :
25803 : : --A non-type template argument or an array bound in which
25804 : : a subexpression references a template parameter.
25805 : :
25806 : : In these cases, we assume deduction succeeded, but don't
25807 : : actually infer any unifications. */
25808 : :
25809 : 225 : if (!uses_template_parms (parm)
25810 : 225 : && !template_args_equal (parm, arg))
25811 : 11 : return unify_expression_unequal (explain_p, parm, arg);
25812 : : else
25813 : 214 : return unify_success (explain_p);
25814 : : }
25815 : : }
25816 : : #undef RECUR_AND_CHECK_FAILURE
25817 : :
25818 : : /* Note that DECL can be defined in this translation unit, if
25819 : : required. */
25820 : :
25821 : : static void
25822 : 15579175 : mark_definable (tree decl)
25823 : : {
25824 : 15579175 : tree clone;
25825 : 15579175 : DECL_NOT_REALLY_EXTERN (decl) = 1;
25826 : 20479100 : FOR_EACH_CLONE (clone, decl)
25827 : 4899925 : DECL_NOT_REALLY_EXTERN (clone) = 1;
25828 : 15579175 : }
25829 : :
25830 : : /* Called if RESULT is explicitly instantiated, or is a member of an
25831 : : explicitly instantiated class. */
25832 : :
25833 : : void
25834 : 22083994 : mark_decl_instantiated (tree result, int extern_p)
25835 : : {
25836 : 22083994 : SET_DECL_EXPLICIT_INSTANTIATION (result);
25837 : :
25838 : : /* If this entity has already been written out, it's too late to
25839 : : make any modifications. */
25840 : 22083994 : if (TREE_ASM_WRITTEN (result))
25841 : : return;
25842 : :
25843 : : /* consteval functions are never emitted. */
25844 : 22065312 : if (TREE_CODE (result) == FUNCTION_DECL
25845 : 43780967 : && DECL_IMMEDIATE_FUNCTION_P (result))
25846 : : return;
25847 : :
25848 : : /* For anonymous namespace we don't need to do anything. */
25849 : 22065306 : if (decl_internal_context_p (result))
25850 : : {
25851 : 955 : gcc_assert (!TREE_PUBLIC (result));
25852 : : return;
25853 : : }
25854 : :
25855 : 22064351 : if (TREE_CODE (result) != FUNCTION_DECL)
25856 : : /* The TREE_PUBLIC flag for function declarations will have been
25857 : : set correctly by tsubst. */
25858 : 349649 : TREE_PUBLIC (result) = 1;
25859 : :
25860 : 22064351 : if (extern_p)
25861 : : {
25862 : 22032191 : DECL_EXTERNAL (result) = 1;
25863 : 22032191 : DECL_NOT_REALLY_EXTERN (result) = 0;
25864 : : }
25865 : : else
25866 : : {
25867 : 32160 : mark_definable (result);
25868 : 32160 : mark_needed (result);
25869 : : /* Always make artificials weak. */
25870 : 32160 : if (DECL_ARTIFICIAL (result) && flag_weak)
25871 : 0 : comdat_linkage (result);
25872 : : /* For WIN32 we also want to put explicit instantiations in
25873 : : linkonce sections. */
25874 : 32160 : else if (TREE_PUBLIC (result))
25875 : 32143 : maybe_make_one_only (result);
25876 : 32160 : if (TREE_CODE (result) == FUNCTION_DECL
25877 : 32160 : && DECL_TEMPLATE_INSTANTIATED (result))
25878 : : /* If the function has already been instantiated, clear DECL_EXTERNAL,
25879 : : since start_preparsed_function wouldn't have if we had an earlier
25880 : : extern explicit instantiation. */
25881 : 22 : DECL_EXTERNAL (result) = 0;
25882 : : }
25883 : :
25884 : : /* If EXTERN_P, then this function will not be emitted -- unless
25885 : : followed by an explicit instantiation, at which point its linkage
25886 : : will be adjusted. If !EXTERN_P, then this function will be
25887 : : emitted here. In neither circumstance do we want
25888 : : import_export_decl to adjust the linkage. */
25889 : 22064351 : DECL_INTERFACE_KNOWN (result) = 1;
25890 : : }
25891 : :
25892 : : /* Subroutine of more_specialized_fn: check whether TARGS is missing any
25893 : : important template arguments. If any are missing, we check whether
25894 : : they're important by using error_mark_node for substituting into any
25895 : : args that were used for partial ordering (the ones between ARGS and END)
25896 : : and seeing if it bubbles up. */
25897 : :
25898 : : static bool
25899 : 3541018 : check_undeduced_parms (tree targs, tree args, tree end)
25900 : : {
25901 : 3541018 : bool found = false;
25902 : 12753459 : for (tree& targ : tree_vec_range (targs))
25903 : 9212441 : if (targ == NULL_TREE)
25904 : : {
25905 : 1744504 : found = true;
25906 : 1744504 : targ = error_mark_node;
25907 : : }
25908 : 3541018 : if (found)
25909 : : {
25910 : 1743094 : tree substed = tsubst_arg_types (args, targs, end, tf_none, NULL_TREE);
25911 : 1743094 : if (substed == error_mark_node)
25912 : : return true;
25913 : : }
25914 : : return false;
25915 : : }
25916 : :
25917 : : /* Given two function templates PAT1 and PAT2, return:
25918 : :
25919 : : 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
25920 : : -1 if PAT2 is more specialized than PAT1.
25921 : : 0 if neither is more specialized.
25922 : :
25923 : : LEN indicates the number of parameters we should consider
25924 : : (defaulted parameters should not be considered).
25925 : :
25926 : : The 1998 std underspecified function template partial ordering, and
25927 : : DR214 addresses the issue. We take pairs of arguments, one from
25928 : : each of the templates, and deduce them against each other. One of
25929 : : the templates will be more specialized if all the *other*
25930 : : template's arguments deduce against its arguments and at least one
25931 : : of its arguments *does* *not* deduce against the other template's
25932 : : corresponding argument. Deduction is done as for class templates.
25933 : : The arguments used in deduction have reference and top level cv
25934 : : qualifiers removed. Iff both arguments were originally reference
25935 : : types *and* deduction succeeds in both directions, an lvalue reference
25936 : : wins against an rvalue reference and otherwise the template
25937 : : with the more cv-qualified argument wins for that pairing (if
25938 : : neither is more cv-qualified, they both are equal). Unlike regular
25939 : : deduction, after all the arguments have been deduced in this way,
25940 : : we do *not* verify the deduced template argument values can be
25941 : : substituted into non-deduced contexts.
25942 : :
25943 : : The logic can be a bit confusing here, because we look at deduce1 and
25944 : : targs1 to see if pat2 is at least as specialized, and vice versa; if we
25945 : : can find template arguments for pat1 to make arg1 look like arg2, that
25946 : : means that arg2 is at least as specialized as arg1. */
25947 : :
25948 : : int
25949 : 2953894 : more_specialized_fn (tree pat1, tree pat2, int len)
25950 : : {
25951 : 2953894 : tree decl1 = DECL_TEMPLATE_RESULT (pat1);
25952 : 2953894 : tree decl2 = DECL_TEMPLATE_RESULT (pat2);
25953 : 2953894 : tree targs1 = make_tree_vec (DECL_NTPARMS (pat1));
25954 : 2953894 : tree targs2 = make_tree_vec (DECL_NTPARMS (pat2));
25955 : 2953894 : tree tparms1 = DECL_INNERMOST_TEMPLATE_PARMS (pat1);
25956 : 2953894 : tree tparms2 = DECL_INNERMOST_TEMPLATE_PARMS (pat2);
25957 : 2953894 : tree args1 = TYPE_ARG_TYPES (TREE_TYPE (decl1));
25958 : 2953894 : tree args2 = TYPE_ARG_TYPES (TREE_TYPE (decl2));
25959 : 2953894 : tree origs1, origs2;
25960 : 2953894 : bool lose1 = false;
25961 : 2953894 : bool lose2 = false;
25962 : :
25963 : : /* C++17 [temp.func.order]/3 (CWG532)
25964 : :
25965 : : If only one of the function templates M is a non-static member of some
25966 : : class A, M is considered to have a new first parameter inserted in its
25967 : : function parameter list. Given cv as the cv-qualifiers of M (if any), the
25968 : : new parameter is of type "rvalue reference to cv A" if the optional
25969 : : ref-qualifier of M is && or if M has no ref-qualifier and the first
25970 : : parameter of the other template has rvalue reference type. Otherwise, the
25971 : : new parameter is of type "lvalue reference to cv A". */
25972 : :
25973 : 2953894 : if (DECL_STATIC_FUNCTION_P (decl1) || DECL_STATIC_FUNCTION_P (decl2))
25974 : : {
25975 : : /* Note C++20 DR2445 extended the above to static member functions, but
25976 : : I think the old G++ behavior of just skipping the object
25977 : : parameter when comparing to a static member function was better, so
25978 : : let's stick with that for now. This is CWG2834. --jason 2023-12 */
25979 : 524 : if (DECL_OBJECT_MEMBER_FUNCTION_P (decl1))
25980 : : {
25981 : 32 : len--; /* LEN is the number of significant arguments for DECL1 */
25982 : 32 : args1 = TREE_CHAIN (args1);
25983 : : }
25984 : 492 : else if (DECL_OBJECT_MEMBER_FUNCTION_P (decl2))
25985 : 20 : args2 = TREE_CHAIN (args2);
25986 : : }
25987 : 2953370 : else if (DECL_IOBJ_MEMBER_FUNCTION_P (decl1)
25988 : 2953370 : && DECL_IOBJ_MEMBER_FUNCTION_P (decl2))
25989 : : {
25990 : : /* Note DR2445 also (IMO wrongly) removed the "only one" above, which
25991 : : would break e.g. cpp1y/lambda-generic-variadic5.C. */
25992 : 11926 : len--;
25993 : 11926 : args1 = TREE_CHAIN (args1);
25994 : 11926 : args2 = TREE_CHAIN (args2);
25995 : : }
25996 : 2941444 : else if (DECL_IOBJ_MEMBER_FUNCTION_P (decl1)
25997 : 2941444 : || DECL_IOBJ_MEMBER_FUNCTION_P (decl2))
25998 : : {
25999 : : /* The other is a non-member or explicit object member function;
26000 : : rewrite the implicit object parameter to a reference. */
26001 : 113 : tree ns = DECL_IOBJ_MEMBER_FUNCTION_P (decl2) ? decl2 : decl1;
26002 : 113 : tree &nsargs = ns == decl2 ? args2 : args1;
26003 : 113 : tree obtype = TREE_TYPE (TREE_VALUE (nsargs));
26004 : :
26005 : 113 : nsargs = TREE_CHAIN (nsargs);
26006 : :
26007 : 113 : cp_ref_qualifier rqual = type_memfn_rqual (TREE_TYPE (ns));
26008 : 113 : if (rqual == REF_QUAL_NONE)
26009 : : {
26010 : 81 : tree otherfirst = ns == decl1 ? args2 : args1;
26011 : 81 : otherfirst = TREE_VALUE (otherfirst);
26012 : 81 : if (TREE_CODE (otherfirst) == REFERENCE_TYPE
26013 : 81 : && TYPE_REF_IS_RVALUE (otherfirst))
26014 : : rqual = REF_QUAL_RVALUE;
26015 : : }
26016 : 113 : obtype = cp_build_reference_type (obtype, rqual == REF_QUAL_RVALUE);
26017 : 113 : nsargs = tree_cons (NULL_TREE, obtype, nsargs);
26018 : : }
26019 : :
26020 : : /* If only one is a conversion operator, they are unordered. */
26021 : 2953894 : if (DECL_CONV_FN_P (decl1) != DECL_CONV_FN_P (decl2))
26022 : : return 0;
26023 : :
26024 : : /* Consider the return type for a conversion function */
26025 : 2953882 : if (DECL_CONV_FN_P (decl1))
26026 : : {
26027 : 9 : args1 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl1)), args1);
26028 : 9 : args2 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl2)), args2);
26029 : 9 : len++;
26030 : : }
26031 : :
26032 : 2953882 : processing_template_decl++;
26033 : :
26034 : 2953882 : origs1 = args1;
26035 : 2953882 : origs2 = args2;
26036 : :
26037 : 2953882 : while (len--
26038 : : /* Stop when an ellipsis is seen. */
26039 : 7050225 : && args1 != NULL_TREE && args2 != NULL_TREE)
26040 : : {
26041 : 4114643 : tree arg1 = TREE_VALUE (args1);
26042 : 4114643 : tree arg2 = TREE_VALUE (args2);
26043 : 4114643 : int deduce1, deduce2;
26044 : 4114643 : int quals1 = -1;
26045 : 4114643 : int quals2 = -1;
26046 : 4114643 : int ref1 = 0;
26047 : 4114643 : int ref2 = 0;
26048 : :
26049 : 4114643 : if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION
26050 : 1366 : && TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
26051 : : {
26052 : : /* When both arguments are pack expansions, we need only
26053 : : unify the patterns themselves. */
26054 : 243 : arg1 = PACK_EXPANSION_PATTERN (arg1);
26055 : 243 : arg2 = PACK_EXPANSION_PATTERN (arg2);
26056 : :
26057 : : /* This is the last comparison we need to do. */
26058 : : len = 0;
26059 : : }
26060 : :
26061 : 4114643 : if (TYPE_REF_P (arg1))
26062 : : {
26063 : 2176316 : ref1 = TYPE_REF_IS_RVALUE (arg1) + 1;
26064 : 2176316 : arg1 = TREE_TYPE (arg1);
26065 : 2176316 : quals1 = cp_type_quals (arg1);
26066 : : }
26067 : :
26068 : 4114643 : if (TYPE_REF_P (arg2))
26069 : : {
26070 : 2237773 : ref2 = TYPE_REF_IS_RVALUE (arg2) + 1;
26071 : 2237773 : arg2 = TREE_TYPE (arg2);
26072 : 2237773 : quals2 = cp_type_quals (arg2);
26073 : : }
26074 : :
26075 : 4114643 : arg1 = TYPE_MAIN_VARIANT (arg1);
26076 : 4114643 : arg2 = TYPE_MAIN_VARIANT (arg2);
26077 : :
26078 : 4114643 : if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION)
26079 : : {
26080 : 1123 : int i, len2 = remaining_arguments (args2);
26081 : 1123 : tree parmvec = make_tree_vec (1);
26082 : 1123 : tree argvec = make_tree_vec (len2);
26083 : 1123 : tree ta = args2;
26084 : :
26085 : : /* Setup the parameter vector, which contains only ARG1. */
26086 : 1123 : TREE_VEC_ELT (parmvec, 0) = arg1;
26087 : :
26088 : : /* Setup the argument vector, which contains the remaining
26089 : : arguments. */
26090 : 2524 : for (i = 0; i < len2; i++, ta = TREE_CHAIN (ta))
26091 : 1401 : TREE_VEC_ELT (argvec, i) = TREE_VALUE (ta);
26092 : :
26093 : 1123 : deduce1 = (unify_pack_expansion (tparms1, targs1, parmvec,
26094 : : argvec, DEDUCE_EXACT,
26095 : : /*subr=*/true, /*explain_p=*/false)
26096 : : == 0);
26097 : :
26098 : : /* We cannot deduce in the other direction, because ARG1 is
26099 : : a pack expansion but ARG2 is not. */
26100 : 1123 : deduce2 = 0;
26101 : : }
26102 : 4113520 : else if (TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
26103 : : {
26104 : 407 : int i, len1 = remaining_arguments (args1);
26105 : 407 : tree parmvec = make_tree_vec (1);
26106 : 407 : tree argvec = make_tree_vec (len1);
26107 : 407 : tree ta = args1;
26108 : :
26109 : : /* Setup the parameter vector, which contains only ARG1. */
26110 : 407 : TREE_VEC_ELT (parmvec, 0) = arg2;
26111 : :
26112 : : /* Setup the argument vector, which contains the remaining
26113 : : arguments. */
26114 : 1037 : for (i = 0; i < len1; i++, ta = TREE_CHAIN (ta))
26115 : 630 : TREE_VEC_ELT (argvec, i) = TREE_VALUE (ta);
26116 : :
26117 : 407 : deduce2 = (unify_pack_expansion (tparms2, targs2, parmvec,
26118 : : argvec, DEDUCE_EXACT,
26119 : : /*subr=*/true, /*explain_p=*/false)
26120 : : == 0);
26121 : :
26122 : : /* We cannot deduce in the other direction, because ARG2 is
26123 : : a pack expansion but ARG1 is not.*/
26124 : 407 : deduce1 = 0;
26125 : : }
26126 : :
26127 : : else
26128 : : {
26129 : : /* The normal case, where neither argument is a pack
26130 : : expansion. */
26131 : 4113113 : deduce1 = (unify (tparms1, targs1, arg1, arg2,
26132 : : UNIFY_ALLOW_NONE, /*explain_p=*/false)
26133 : 4113113 : == 0);
26134 : 4113113 : deduce2 = (unify (tparms2, targs2, arg2, arg1,
26135 : : UNIFY_ALLOW_NONE, /*explain_p=*/false)
26136 : 4113113 : == 0);
26137 : : }
26138 : :
26139 : : /* If we couldn't deduce arguments for tparms1 to make arg1 match
26140 : : arg2, then arg2 is not as specialized as arg1. */
26141 : 4114643 : if (!deduce1)
26142 : : lose2 = true;
26143 : 4114643 : if (!deduce2)
26144 : 338374 : lose1 = true;
26145 : :
26146 : : /* "If, for a given type, deduction succeeds in both directions
26147 : : (i.e., the types are identical after the transformations above)
26148 : : and both P and A were reference types (before being replaced with
26149 : : the type referred to above):
26150 : : - if the type from the argument template was an lvalue reference and
26151 : : the type from the parameter template was not, the argument type is
26152 : : considered to be more specialized than the other; otherwise,
26153 : : - if the type from the argument template is more cv-qualified
26154 : : than the type from the parameter template (as described above),
26155 : : the argument type is considered to be more specialized than the other;
26156 : : otherwise,
26157 : : - neither type is more specialized than the other." */
26158 : :
26159 : 4114643 : if (deduce1 && deduce2)
26160 : : {
26161 : 1748275 : if (ref1 && ref2 && ref1 != ref2)
26162 : : {
26163 : 3 : if (ref1 > ref2)
26164 : : lose1 = true;
26165 : : else
26166 : 3 : lose2 = true;
26167 : : }
26168 : 1748272 : else if (quals1 != quals2 && quals1 >= 0 && quals2 >= 0)
26169 : : {
26170 : 951 : if ((quals1 & quals2) == quals2)
26171 : 6 : lose2 = true;
26172 : 951 : if ((quals1 & quals2) == quals1)
26173 : 945 : lose1 = true;
26174 : : }
26175 : : }
26176 : :
26177 : 4114643 : if (lose1 && lose2)
26178 : : /* We've failed to deduce something in either direction.
26179 : : These must be unordered. */
26180 : : break;
26181 : :
26182 : 4096343 : if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION
26183 : 4096292 : || TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
26184 : : /* We have already processed all of the arguments in our
26185 : : handing of the pack expansion type. */
26186 : 182 : len = 0;
26187 : :
26188 : 4096343 : args1 = TREE_CHAIN (args1);
26189 : 4096343 : args2 = TREE_CHAIN (args2);
26190 : : }
26191 : :
26192 : : /* "In most cases, all template parameters must have values in order for
26193 : : deduction to succeed, but for partial ordering purposes a template
26194 : : parameter may remain without a value provided it is not used in the
26195 : : types being used for partial ordering."
26196 : :
26197 : : Thus, if we are missing any of the targs1 we need to substitute into
26198 : : origs1, then pat2 is not as specialized as pat1. This can happen when
26199 : : there is a nondeduced context. */
26200 : 2953882 : if (!lose2 && check_undeduced_parms (targs1, origs1, args1))
26201 : : lose2 = true;
26202 : 2953882 : if (!lose1 && check_undeduced_parms (targs2, origs2, args2))
26203 : : lose1 = true;
26204 : :
26205 : 2953882 : processing_template_decl--;
26206 : :
26207 : : /* If both deductions succeed, the partial ordering selects the more
26208 : : constrained template. */
26209 : : /* P2113: If the corresponding template-parameters of the
26210 : : template-parameter-lists are not equivalent ([temp.over.link]) or if
26211 : : the function parameters that positionally correspond between the two
26212 : : templates are not of the same type, neither template is more
26213 : : specialized than the other. */
26214 : 2953882 : if (!lose1 && !lose2
26215 : 605421 : && comp_template_parms (DECL_TEMPLATE_PARMS (pat1),
26216 : 605421 : DECL_TEMPLATE_PARMS (pat2))
26217 : 3559108 : && compparms (origs1, origs2))
26218 : : {
26219 : 598611 : int winner = more_constrained (decl1, decl2);
26220 : 598611 : if (winner > 0)
26221 : : lose2 = true;
26222 : 461453 : else if (winner < 0)
26223 : 140 : lose1 = true;
26224 : : }
26225 : :
26226 : : /* All things being equal, if the next argument is a pack expansion
26227 : : for one function but not for the other, prefer the
26228 : : non-variadic function. FIXME this is bogus; see c++/41958. */
26229 : 2953882 : if (lose1 == lose2
26230 : 486435 : && args1 && TREE_VALUE (args1)
26231 : 3440311 : && args2 && TREE_VALUE (args2))
26232 : : {
26233 : 486423 : lose1 = TREE_CODE (TREE_VALUE (args1)) == TYPE_PACK_EXPANSION;
26234 : 486423 : lose2 = TREE_CODE (TREE_VALUE (args2)) == TYPE_PACK_EXPANSION;
26235 : : }
26236 : :
26237 : 2953882 : if (lose1 == lose2)
26238 : : return 0;
26239 : 2470056 : else if (!lose1)
26240 : : return 1;
26241 : : else
26242 : 315317 : return -1;
26243 : : }
26244 : :
26245 : : /* Determine which of two partial specializations of TMPL is more
26246 : : specialized.
26247 : :
26248 : : PAT1 is a TREE_LIST whose TREE_VALUE is the TEMPLATE_DECL corresponding
26249 : : to the first partial specialization. The TREE_PURPOSE is the
26250 : : innermost set of template parameters for the partial
26251 : : specialization. PAT2 is similar, but for the second template.
26252 : :
26253 : : Return 1 if the first partial specialization is more specialized;
26254 : : -1 if the second is more specialized; 0 if neither is more
26255 : : specialized.
26256 : :
26257 : : See [temp.class.order] for information about determining which of
26258 : : two templates is more specialized. */
26259 : :
26260 : : static int
26261 : 574636 : more_specialized_partial_spec (tree tmpl, tree pat1, tree pat2)
26262 : : {
26263 : 574636 : tree targs;
26264 : 574636 : int winner = 0;
26265 : 574636 : bool any_deductions = false;
26266 : :
26267 : 574636 : tree tmpl1 = TREE_VALUE (pat1);
26268 : 574636 : tree tmpl2 = TREE_VALUE (pat2);
26269 : 574636 : tree specargs1 = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl1)));
26270 : 574636 : tree specargs2 = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl2)));
26271 : :
26272 : : /* Just like what happens for functions, if we are ordering between
26273 : : different template specializations, we may encounter dependent
26274 : : types in the arguments, and we need our dependency check functions
26275 : : to behave correctly. */
26276 : 574636 : ++processing_template_decl;
26277 : 574636 : targs = get_partial_spec_bindings (tmpl, tmpl1, specargs2);
26278 : 574636 : if (targs)
26279 : : {
26280 : 147607 : --winner;
26281 : 147607 : any_deductions = true;
26282 : : }
26283 : :
26284 : 574636 : targs = get_partial_spec_bindings (tmpl, tmpl2, specargs1);
26285 : 574636 : if (targs)
26286 : : {
26287 : 433083 : ++winner;
26288 : 433083 : any_deductions = true;
26289 : : }
26290 : 574636 : --processing_template_decl;
26291 : :
26292 : : /* If both deductions succeed, the partial ordering selects the more
26293 : : constrained template. */
26294 : 574636 : if (!winner && any_deductions)
26295 : 6134 : winner = more_constrained (tmpl1, tmpl2);
26296 : :
26297 : : /* In the case of a tie where at least one of the templates
26298 : : has a parameter pack at the end, the template with the most
26299 : : non-packed parameters wins. */
26300 : 574636 : if (winner == 0
26301 : 574636 : && any_deductions
26302 : 574640 : && (template_args_variadic_p (TREE_PURPOSE (pat1))
26303 : 4 : || template_args_variadic_p (TREE_PURPOSE (pat2))))
26304 : : {
26305 : 0 : tree args1 = INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1));
26306 : 0 : tree args2 = INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2));
26307 : 0 : int len1 = TREE_VEC_LENGTH (args1);
26308 : 0 : int len2 = TREE_VEC_LENGTH (args2);
26309 : :
26310 : : /* We don't count the pack expansion at the end. */
26311 : 0 : if (template_args_variadic_p (TREE_PURPOSE (pat1)))
26312 : 0 : --len1;
26313 : 0 : if (template_args_variadic_p (TREE_PURPOSE (pat2)))
26314 : 0 : --len2;
26315 : :
26316 : 0 : if (len1 > len2)
26317 : : return 1;
26318 : 0 : else if (len1 < len2)
26319 : : return -1;
26320 : : }
26321 : :
26322 : : return winner;
26323 : : }
26324 : :
26325 : : /* Return the template arguments that will produce the function signature
26326 : : DECL from the function template FN, with the explicit template
26327 : : arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
26328 : : also match. Return NULL_TREE if no satisfactory arguments could be
26329 : : found. */
26330 : :
26331 : : static tree
26332 : 11672223 : get_bindings (tree fn, tree decl, tree explicit_args, bool check_rettype)
26333 : : {
26334 : 11672223 : int ntparms = DECL_NTPARMS (fn);
26335 : 11672223 : tree targs = make_tree_vec (ntparms);
26336 : 11672223 : tree decl_type = TREE_TYPE (decl);
26337 : 11672223 : tree decl_arg_types;
26338 : 11672223 : tree *args;
26339 : 11672223 : unsigned int nargs, ix;
26340 : 11672223 : tree arg;
26341 : :
26342 : 11672223 : gcc_assert (decl != DECL_TEMPLATE_RESULT (fn));
26343 : :
26344 : : /* Never do unification on the 'this' parameter. */
26345 : 11672223 : decl_arg_types = skip_artificial_parms_for (decl,
26346 : 11672223 : TYPE_ARG_TYPES (decl_type));
26347 : :
26348 : 11672223 : nargs = list_length (decl_arg_types);
26349 : 11672223 : args = XALLOCAVEC (tree, nargs);
26350 : 11672223 : for (arg = decl_arg_types, ix = 0;
26351 : 45690853 : arg != NULL_TREE;
26352 : 34018630 : arg = TREE_CHAIN (arg), ++ix)
26353 : 34018630 : args[ix] = TREE_VALUE (arg);
26354 : :
26355 : 23344446 : if (fn_type_unification (fn, explicit_args, targs,
26356 : : args, ix,
26357 : 0 : (check_rettype || DECL_CONV_FN_P (fn)
26358 : 11672223 : ? TREE_TYPE (decl_type) : NULL_TREE),
26359 : : DEDUCE_EXACT, LOOKUP_NORMAL, NULL,
26360 : : /*explain_p=*/false,
26361 : : /*decltype*/false)
26362 : 11672223 : == error_mark_node)
26363 : 9530354 : return NULL_TREE;
26364 : :
26365 : : return targs;
26366 : : }
26367 : :
26368 : : /* Return the innermost template arguments that, when applied to a partial
26369 : : specialization SPEC_TMPL of TMPL, yield the ARGS.
26370 : :
26371 : : For example, suppose we have:
26372 : :
26373 : : template <class T, class U> struct S {};
26374 : : template <class T> struct S<T*, int> {};
26375 : :
26376 : : Then, suppose we want to get `S<double*, int>'. SPEC_TMPL will be the
26377 : : partial specialization and the ARGS will be {double*, int}. The resulting
26378 : : vector will be {double}, indicating that `T' is bound to `double'. */
26379 : :
26380 : : static tree
26381 : 27269844 : get_partial_spec_bindings (tree tmpl, tree spec_tmpl, tree args)
26382 : : {
26383 : 27269844 : tree tparms = DECL_INNERMOST_TEMPLATE_PARMS (spec_tmpl);
26384 : 27269844 : tree spec_args
26385 : 27269844 : = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (spec_tmpl)));
26386 : 27269844 : int i, ntparms = TREE_VEC_LENGTH (tparms);
26387 : 27269844 : tree deduced_args;
26388 : 27269844 : tree innermost_deduced_args;
26389 : :
26390 : 27269844 : innermost_deduced_args = make_tree_vec (ntparms);
26391 : 54539688 : if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
26392 : : {
26393 : 252 : deduced_args = copy_node (args);
26394 : 504 : SET_TMPL_ARGS_LEVEL (deduced_args,
26395 : : TMPL_ARGS_DEPTH (deduced_args),
26396 : : innermost_deduced_args);
26397 : : }
26398 : : else
26399 : : deduced_args = innermost_deduced_args;
26400 : :
26401 : 27269844 : bool tried_array_deduction = (cxx_dialect < cxx17);
26402 : 27269847 : again:
26403 : 27269847 : if (unify (tparms, deduced_args,
26404 : : INNERMOST_TEMPLATE_ARGS (spec_args),
26405 : : INNERMOST_TEMPLATE_ARGS (args),
26406 : : UNIFY_ALLOW_NONE, /*explain_p=*/false))
26407 : : return NULL_TREE;
26408 : :
26409 : 37132609 : for (i = 0; i < ntparms; ++i)
26410 : 24531380 : if (! TREE_VEC_ELT (innermost_deduced_args, i))
26411 : : {
26412 : 26 : if (!tried_array_deduction)
26413 : : {
26414 : 19 : try_array_deduction (tparms, innermost_deduced_args,
26415 : : INNERMOST_TEMPLATE_ARGS (spec_args));
26416 : 19 : tried_array_deduction = true;
26417 : 19 : if (TREE_VEC_ELT (innermost_deduced_args, i))
26418 : 3 : goto again;
26419 : : }
26420 : 23 : return NULL_TREE;
26421 : : }
26422 : :
26423 : 12601229 : if (!push_tinst_level (spec_tmpl, deduced_args))
26424 : : {
26425 : 0 : excessive_deduction_depth = true;
26426 : 0 : return NULL_TREE;
26427 : : }
26428 : :
26429 : : /* Verify that nondeduced template arguments agree with the type
26430 : : obtained from argument deduction.
26431 : :
26432 : : For example:
26433 : :
26434 : : struct A { typedef int X; };
26435 : : template <class T, class U> struct C {};
26436 : : template <class T> struct C<T, typename T::X> {};
26437 : :
26438 : : Then with the instantiation `C<A, int>', we can deduce that
26439 : : `T' is `A' but unify () does not check whether `typename T::X'
26440 : : is `int'. */
26441 : 12601229 : spec_args = tsubst (spec_args, deduced_args, tf_none, NULL_TREE);
26442 : :
26443 : 12601229 : if (spec_args != error_mark_node)
26444 : 12465147 : spec_args = coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
26445 : : INNERMOST_TEMPLATE_ARGS (spec_args),
26446 : : tmpl, tf_none, false);
26447 : :
26448 : 12601229 : pop_tinst_level ();
26449 : :
26450 : 12601229 : if (spec_args == error_mark_node
26451 : : /* We only need to check the innermost arguments; the other
26452 : : arguments will always agree. */
26453 : 12601229 : || !comp_template_args_porder (INNERMOST_TEMPLATE_ARGS (spec_args),
26454 : : INNERMOST_TEMPLATE_ARGS (args)))
26455 : 136263 : return NULL_TREE;
26456 : :
26457 : : /* Now that we have bindings for all of the template arguments,
26458 : : ensure that the arguments deduced for the template template
26459 : : parameters have compatible template parameter lists. See the use
26460 : : of template_template_parm_bindings_ok_p in fn_type_unification
26461 : : for more information. */
26462 : 12464966 : if (!template_template_parm_bindings_ok_p (tparms, deduced_args))
26463 : : return NULL_TREE;
26464 : :
26465 : : return deduced_args;
26466 : : }
26467 : :
26468 : : // Compare two function templates T1 and T2 by deducing bindings
26469 : : // from one against the other. If both deductions succeed, compare
26470 : : // constraints to see which is more constrained.
26471 : : static int
26472 : 62735 : more_specialized_inst (tree t1, tree t2)
26473 : : {
26474 : 62735 : int fate = 0;
26475 : 62735 : int count = 0;
26476 : :
26477 : 62735 : if (get_bindings (t1, DECL_TEMPLATE_RESULT (t2), NULL_TREE, true))
26478 : : {
26479 : 193 : --fate;
26480 : 193 : ++count;
26481 : : }
26482 : :
26483 : 62735 : if (get_bindings (t2, DECL_TEMPLATE_RESULT (t1), NULL_TREE, true))
26484 : : {
26485 : 41832 : ++fate;
26486 : 41832 : ++count;
26487 : : }
26488 : :
26489 : : // If both deductions succeed, then one may be more constrained.
26490 : 62735 : if (count == 2 && fate == 0)
26491 : 126 : fate = more_constrained (t1, t2);
26492 : :
26493 : 62735 : return fate;
26494 : : }
26495 : :
26496 : : /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
26497 : : Return the TREE_LIST node with the most specialized template, if
26498 : : any. If there is no most specialized template, the error_mark_node
26499 : : is returned.
26500 : :
26501 : : Note that this function does not look at, or modify, the
26502 : : TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
26503 : : returned is one of the elements of INSTANTIATIONS, callers may
26504 : : store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
26505 : : and retrieve it from the value returned. */
26506 : :
26507 : : tree
26508 : 54360 : most_specialized_instantiation (tree templates)
26509 : : {
26510 : 54360 : tree fn, champ;
26511 : :
26512 : 54360 : ++processing_template_decl;
26513 : :
26514 : 54360 : champ = templates;
26515 : 75323 : for (fn = TREE_CHAIN (templates); fn; fn = TREE_CHAIN (fn))
26516 : : {
26517 : 20993 : gcc_assert (TREE_VALUE (champ) != TREE_VALUE (fn));
26518 : 20993 : int fate = more_specialized_inst (TREE_VALUE (champ), TREE_VALUE (fn));
26519 : 20993 : if (fate == -1)
26520 : : champ = fn;
26521 : 20863 : else if (!fate)
26522 : : {
26523 : : /* Equally specialized, move to next function. If there
26524 : : is no next function, nothing's most specialized. */
26525 : 20836 : fn = TREE_CHAIN (fn);
26526 : 20836 : champ = fn;
26527 : 20836 : if (!fn)
26528 : : break;
26529 : : }
26530 : : }
26531 : :
26532 : 54360 : if (champ)
26533 : : /* Now verify that champ is better than everything earlier in the
26534 : : instantiation list. */
26535 : 96072 : for (fn = templates; fn != champ; fn = TREE_CHAIN (fn)) {
26536 : 41742 : if (more_specialized_inst (TREE_VALUE (champ), TREE_VALUE (fn)) != 1)
26537 : : {
26538 : : champ = NULL_TREE;
26539 : : break;
26540 : : }
26541 : : }
26542 : :
26543 : 54360 : processing_template_decl--;
26544 : :
26545 : 54360 : if (!champ)
26546 : 30 : return error_mark_node;
26547 : :
26548 : : return champ;
26549 : : }
26550 : :
26551 : : /* If DECL is a specialization of some template, return the most
26552 : : general such template. Otherwise, returns NULL_TREE.
26553 : :
26554 : : For example, given:
26555 : :
26556 : : template <class T> struct S { template <class U> void f(U); };
26557 : :
26558 : : if TMPL is `template <class U> void S<int>::f(U)' this will return
26559 : : the full template. This function will not trace past partial
26560 : : specializations, however. For example, given in addition:
26561 : :
26562 : : template <class T> struct S<T*> { template <class U> void f(U); };
26563 : :
26564 : : if TMPL is `template <class U> void S<int*>::f(U)' this will return
26565 : : `template <class T> template <class U> S<T*>::f(U)'. */
26566 : :
26567 : : tree
26568 : 2895949505 : most_general_template (const_tree decl)
26569 : : {
26570 : 2895949505 : if (TREE_CODE (decl) != TEMPLATE_DECL)
26571 : : {
26572 : 549688010 : if (tree tinfo = get_template_info (decl))
26573 : 353681721 : decl = TI_TEMPLATE (tinfo);
26574 : : /* The TI_TEMPLATE can be an IDENTIFIER_NODE for a
26575 : : template friend, or a FIELD_DECL for a capture pack. */
26576 : 549688010 : if (TREE_CODE (decl) != TEMPLATE_DECL)
26577 : : return NULL_TREE;
26578 : : }
26579 : :
26580 : 2699943010 : if (DECL_TEMPLATE_TEMPLATE_PARM_P (decl))
26581 : 362277 : return DECL_TI_TEMPLATE (DECL_TEMPLATE_RESULT (decl));
26582 : :
26583 : : /* Look for more and more general templates. */
26584 : 2731717788 : while (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
26585 : : {
26586 : : /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
26587 : : (See cp-tree.h for details.) */
26588 : 32137365 : if (TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
26589 : : break;
26590 : :
26591 : 64274730 : if (CLASS_TYPE_P (TREE_TYPE (decl))
26592 : 7340341 : && !TYPE_DECL_ALIAS_P (TYPE_NAME (TREE_TYPE (decl)))
26593 : 38856451 : && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)))
26594 : : break;
26595 : :
26596 : : /* Stop if we run into an explicitly specialized class template. */
26597 : 64274110 : if (!DECL_NAMESPACE_SCOPE_P (decl)
26598 : 32046860 : && DECL_CONTEXT (decl)
26599 : 64183915 : && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl)))
26600 : : break;
26601 : :
26602 : 32137055 : decl = DECL_TI_TEMPLATE (decl);
26603 : : }
26604 : :
26605 : : return CONST_CAST_TREE (decl);
26606 : : }
26607 : :
26608 : : /* Return the most specialized of the template partial specializations
26609 : : which can produce TARGET, a specialization of some class or variable
26610 : : template. The value returned is a TEMPLATE_INFO; the TI_TEMPLATE is a
26611 : : TEMPLATE_DECL node corresponding to the partial specialization, while
26612 : : the TI_ARGS is the set of template arguments that must be substituted
26613 : : into the template pattern in order to generate TARGET. The result is
26614 : : cached in the TI_PARTIAL_INFO of the corresponding TEMPLATE_INFO unless
26615 : : RECHECKING is true.
26616 : :
26617 : : If the choice of partial specialization is ambiguous, a diagnostic
26618 : : is issued, and the error_mark_node is returned. If there are no
26619 : : partial specializations matching TARGET, then NULL_TREE is
26620 : : returned, indicating that the primary template should be used. */
26621 : :
26622 : : tree
26623 : 34359458 : most_specialized_partial_spec (tree target, tsubst_flags_t complain,
26624 : : bool rechecking /* = false */)
26625 : : {
26626 : 34359458 : tree tinfo = NULL_TREE;
26627 : 34359458 : tree tmpl, args, decl;
26628 : 34359458 : if (TYPE_P (target))
26629 : : {
26630 : 27373317 : tinfo = CLASSTYPE_TEMPLATE_INFO (target);
26631 : 27373317 : tmpl = TI_TEMPLATE (tinfo);
26632 : 27373317 : args = TI_ARGS (tinfo);
26633 : 27373317 : decl = TYPE_NAME (target);
26634 : : }
26635 : 6986141 : else if (TREE_CODE (target) == TEMPLATE_ID_EXPR)
26636 : : {
26637 : 3497494 : tmpl = TREE_OPERAND (target, 0);
26638 : 3497494 : args = TREE_OPERAND (target, 1);
26639 : 3497494 : decl = DECL_TEMPLATE_RESULT (tmpl);
26640 : : }
26641 : 3488647 : else if (VAR_P (target))
26642 : : {
26643 : 3488647 : tinfo = DECL_TEMPLATE_INFO (target);
26644 : 3488647 : tmpl = TI_TEMPLATE (tinfo);
26645 : 3488647 : args = TI_ARGS (tinfo);
26646 : 3488647 : decl = target;
26647 : : }
26648 : : else
26649 : 0 : gcc_unreachable ();
26650 : :
26651 : 34359458 : if (!PRIMARY_TEMPLATE_P (tmpl))
26652 : : return NULL_TREE;
26653 : :
26654 : 32883069 : if (!rechecking
26655 : 32883069 : && tinfo
26656 : 32883069 : && (VAR_P (target) || COMPLETE_TYPE_P (target)))
26657 : 3488650 : return TI_PARTIAL_INFO (tinfo);
26658 : :
26659 : 29394419 : tree main_tmpl = most_general_template (tmpl);
26660 : 29394419 : tree specs = DECL_TEMPLATE_SPECIALIZATIONS (main_tmpl);
26661 : 29394419 : if (!specs)
26662 : : /* There are no partial specializations of this template. */
26663 : : return NULL_TREE;
26664 : :
26665 : 7107463 : push_access_scope_guard pas (decl);
26666 : 7107463 : deferring_access_check_sentinel acs (dk_no_deferred);
26667 : :
26668 : : /* For determining which partial specialization to use, only the
26669 : : innermost args are interesting. */
26670 : 7107463 : tree outer_args = NULL_TREE;
26671 : 14214926 : if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
26672 : : {
26673 : 157699 : outer_args = strip_innermost_template_args (args, 1);
26674 : 157699 : args = INNERMOST_TEMPLATE_ARGS (args);
26675 : : }
26676 : :
26677 : : /* The caller hasn't called push_to_top_level yet, but we need
26678 : : get_partial_spec_bindings to be done in non-template context so that we'll
26679 : : fully resolve everything. */
26680 : 7107463 : processing_template_decl_sentinel ptds;
26681 : :
26682 : 7107463 : tree list = NULL_TREE;
26683 : 26703051 : for (tree t = specs; t; t = TREE_CHAIN (t))
26684 : : {
26685 : 19595594 : const tree ospec_tmpl = TREE_VALUE (t);
26686 : :
26687 : 19595594 : tree spec_tmpl;
26688 : 19595594 : if (outer_args)
26689 : : {
26690 : : /* Substitute in the template args from the enclosing class. */
26691 : 182471 : ++processing_template_decl;
26692 : 182471 : spec_tmpl = tsubst (ospec_tmpl, outer_args, tf_none, NULL_TREE);
26693 : 182471 : --processing_template_decl;
26694 : 182471 : if (spec_tmpl == error_mark_node)
26695 : : return error_mark_node;
26696 : : }
26697 : : else
26698 : : spec_tmpl = ospec_tmpl;
26699 : :
26700 : 19595588 : tree spec_args = get_partial_spec_bindings (tmpl, spec_tmpl, args);
26701 : 19595588 : if (spec_args)
26702 : : {
26703 : 5359297 : if (outer_args)
26704 : 111908 : spec_args = add_to_template_args (outer_args, spec_args);
26705 : :
26706 : : /* Keep the candidate only if its constraints are satisfied. */
26707 : 5359297 : if (constraints_satisfied_p (ospec_tmpl, spec_args))
26708 : 4700646 : list = tree_cons (spec_args, ospec_tmpl, list);
26709 : : }
26710 : : }
26711 : :
26712 : 7107457 : if (! list)
26713 : : return NULL_TREE;
26714 : :
26715 : 4311328 : tree champ = list;
26716 : 4311328 : bool ambiguous_p = false;
26717 : 4700562 : for (tree t = TREE_CHAIN (list); t; t = TREE_CHAIN (t))
26718 : : {
26719 : 389246 : int fate = more_specialized_partial_spec (tmpl, champ, t);
26720 : 389246 : if (fate == 1)
26721 : : ;
26722 : : else
26723 : : {
26724 : 142021 : if (fate == 0)
26725 : : {
26726 : 84 : t = TREE_CHAIN (t);
26727 : 84 : if (! t)
26728 : : {
26729 : : ambiguous_p = true;
26730 : : break;
26731 : : }
26732 : : }
26733 : : champ = t;
26734 : : }
26735 : : }
26736 : :
26737 : 4311328 : if (!ambiguous_p)
26738 : 4496703 : for (tree t = list; t && t != champ; t = TREE_CHAIN (t))
26739 : : {
26740 : 185390 : int fate = more_specialized_partial_spec (tmpl, champ, t);
26741 : 185390 : if (fate != 1)
26742 : : {
26743 : : ambiguous_p = true;
26744 : : break;
26745 : : }
26746 : : }
26747 : :
26748 : 4311316 : if (ambiguous_p)
26749 : : {
26750 : 15 : const char *str;
26751 : 15 : char *spaces = NULL;
26752 : 15 : if (!(complain & tf_error))
26753 : 3 : return error_mark_node;
26754 : 12 : auto_diagnostic_group d;
26755 : 12 : if (TYPE_P (target))
26756 : 9 : error ("ambiguous template instantiation for %q#T", target);
26757 : : else
26758 : 3 : error ("ambiguous template instantiation for %q#D", target);
26759 : 12 : str = ngettext ("candidate is:", "candidates are:", list_length (list));
26760 : 45 : for (tree t = list; t; t = TREE_CHAIN (t))
26761 : : {
26762 : 33 : tree subst = build_tree_list (TREE_VALUE (t), TREE_PURPOSE (t));
26763 : 66 : inform (DECL_SOURCE_LOCATION (TREE_VALUE (t)),
26764 : : "%s %#qS", spaces ? spaces : str, subst);
26765 : 33 : spaces = spaces ? spaces : get_spaces (str);
26766 : : }
26767 : 12 : free (spaces);
26768 : 12 : return error_mark_node;
26769 : 12 : }
26770 : :
26771 : 4311313 : tree result = build_template_info (TREE_VALUE (champ), TREE_PURPOSE (champ));
26772 : 4311313 : if (!rechecking && tinfo)
26773 : 4026882 : TI_PARTIAL_INFO (tinfo) = result;
26774 : : return result;
26775 : 14214926 : }
26776 : :
26777 : : /* Explicitly instantiate DECL. */
26778 : :
26779 : : void
26780 : 1949761 : do_decl_instantiation (tree decl, tree storage)
26781 : : {
26782 : 1949761 : tree result = NULL_TREE;
26783 : 1949761 : int extern_p = 0;
26784 : :
26785 : 1949761 : if (!decl || decl == error_mark_node)
26786 : : /* An error occurred, for which grokdeclarator has already issued
26787 : : an appropriate message. */
26788 : : return;
26789 : 1949599 : else if (! DECL_LANG_SPECIFIC (decl))
26790 : : {
26791 : 0 : error ("explicit instantiation of non-template %q#D", decl);
26792 : 0 : return;
26793 : : }
26794 : :
26795 : 1949599 : bool var_templ = (DECL_TEMPLATE_INFO (decl)
26796 : 1949599 : && variable_template_p (DECL_TI_TEMPLATE (decl)));
26797 : :
26798 : 1949599 : if (VAR_P (decl) && !var_templ)
26799 : : {
26800 : : /* There is an asymmetry here in the way VAR_DECLs and
26801 : : FUNCTION_DECLs are handled by grokdeclarator. In the case of
26802 : : the latter, the DECL we get back will be marked as a
26803 : : template instantiation, and the appropriate
26804 : : DECL_TEMPLATE_INFO will be set up. This does not happen for
26805 : : VAR_DECLs so we do the lookup here. Probably, grokdeclarator
26806 : : should handle VAR_DECLs as it currently handles
26807 : : FUNCTION_DECLs. */
26808 : 51 : if (!DECL_CLASS_SCOPE_P (decl))
26809 : : {
26810 : 0 : error ("%qD is not a static data member of a class template", decl);
26811 : 0 : return;
26812 : : }
26813 : 51 : result = lookup_field (DECL_CONTEXT (decl), DECL_NAME (decl), 0, false);
26814 : 51 : if (!result || !VAR_P (result))
26815 : : {
26816 : 0 : error ("no matching template for %qD found", decl);
26817 : 0 : return;
26818 : : }
26819 : 51 : if (!same_type_p (TREE_TYPE (result), TREE_TYPE (decl)))
26820 : : {
26821 : 9 : error ("type %qT for explicit instantiation %qD does not match "
26822 : 3 : "declared type %qT", TREE_TYPE (result), decl,
26823 : 3 : TREE_TYPE (decl));
26824 : 3 : return;
26825 : : }
26826 : : }
26827 : 1949548 : else if (TREE_CODE (decl) != FUNCTION_DECL && !var_templ)
26828 : : {
26829 : 0 : error ("explicit instantiation of %q#D", decl);
26830 : 0 : return;
26831 : : }
26832 : : else
26833 : : result = decl;
26834 : :
26835 : : /* Check for various error cases. Note that if the explicit
26836 : : instantiation is valid the RESULT will currently be marked as an
26837 : : *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
26838 : : until we get here. */
26839 : :
26840 : 1949596 : if (DECL_TEMPLATE_SPECIALIZATION (result))
26841 : : {
26842 : : /* DR 259 [temp.spec].
26843 : :
26844 : : Both an explicit instantiation and a declaration of an explicit
26845 : : specialization shall not appear in a program unless the explicit
26846 : : instantiation follows a declaration of the explicit specialization.
26847 : :
26848 : : For a given set of template parameters, if an explicit
26849 : : instantiation of a template appears after a declaration of an
26850 : : explicit specialization for that template, the explicit
26851 : : instantiation has no effect. */
26852 : : return;
26853 : : }
26854 : 1915309 : else if (DECL_EXPLICIT_INSTANTIATION (result))
26855 : : {
26856 : : /* [temp.spec]
26857 : :
26858 : : No program shall explicitly instantiate any template more
26859 : : than once.
26860 : :
26861 : : We check DECL_NOT_REALLY_EXTERN so as not to complain when
26862 : : the first instantiation was `extern' and the second is not,
26863 : : and EXTERN_P for the opposite case. */
26864 : 770 : if (DECL_NOT_REALLY_EXTERN (result) && !extern_p)
26865 : 6 : permerror (input_location, "duplicate explicit instantiation of %q#D", result);
26866 : : /* If an "extern" explicit instantiation follows an ordinary
26867 : : explicit instantiation, the template is instantiated. */
26868 : : if (extern_p)
26869 : : return;
26870 : : }
26871 : 1914539 : else if (!DECL_IMPLICIT_INSTANTIATION (result))
26872 : : {
26873 : 0 : error ("no matching template for %qD found", result);
26874 : 0 : return;
26875 : : }
26876 : 1914539 : else if (!DECL_TEMPLATE_INFO (result))
26877 : : {
26878 : 0 : permerror (input_location, "explicit instantiation of non-template %q#D", result);
26879 : 0 : return;
26880 : : }
26881 : :
26882 : 1915309 : if (storage == NULL_TREE)
26883 : : ;
26884 : 1912226 : else if (storage == ridpointers[(int) RID_EXTERN])
26885 : : {
26886 : 1912226 : if (cxx_dialect == cxx98 && pedantic)
26887 : 7371 : pedwarn (input_location, OPT_Wc__11_extensions,
26888 : : "ISO C++ 1998 forbids the use of %<extern%> on explicit "
26889 : : "instantiations");
26890 : : extern_p = 1;
26891 : : }
26892 : : else
26893 : 0 : error ("storage class %qD applied to template instantiation", storage);
26894 : :
26895 : 1915309 : check_explicit_instantiation_namespace (result);
26896 : 1915309 : mark_decl_instantiated (result, extern_p);
26897 : 1915309 : if (! extern_p)
26898 : 3083 : instantiate_decl (result, /*defer_ok=*/true,
26899 : : /*expl_inst_class_mem_p=*/false);
26900 : : }
26901 : :
26902 : : static void
26903 : 859341 : mark_class_instantiated (tree t, int extern_p)
26904 : : {
26905 : 859341 : SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t);
26906 : 859341 : SET_CLASSTYPE_INTERFACE_KNOWN (t);
26907 : 859341 : CLASSTYPE_INTERFACE_ONLY (t) = extern_p;
26908 : 859341 : TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = extern_p;
26909 : 859341 : if (! extern_p)
26910 : : {
26911 : 2629 : CLASSTYPE_DEBUG_REQUESTED (t) = 1;
26912 : 2629 : rest_of_type_compilation (t, 1);
26913 : : }
26914 : 859341 : }
26915 : :
26916 : : /* Perform an explicit instantiation of template class T. STORAGE, if
26917 : : non-null, is the RID for extern, inline or static. COMPLAIN is
26918 : : nonzero if this is called from the parser, zero if called recursively,
26919 : : since the standard is unclear (as detailed below). */
26920 : :
26921 : : void
26922 : 906194 : do_type_instantiation (tree t, tree storage, tsubst_flags_t complain)
26923 : : {
26924 : 906194 : if (!(CLASS_TYPE_P (t) && CLASSTYPE_TEMPLATE_INFO (t)))
26925 : : {
26926 : 3 : if (tree ti = TYPE_TEMPLATE_INFO (t))
26927 : 0 : error ("explicit instantiation of non-class template %qD",
26928 : 0 : TI_TEMPLATE (ti));
26929 : : else
26930 : 3 : error ("explicit instantiation of non-template type %qT", t);
26931 : 3 : return;
26932 : : }
26933 : :
26934 : 906191 : complete_type (t);
26935 : :
26936 : 906191 : if (!COMPLETE_TYPE_P (t))
26937 : : {
26938 : 202 : if (complain & tf_error)
26939 : 0 : error ("explicit instantiation of %q#T before definition of template",
26940 : : t);
26941 : 202 : return;
26942 : : }
26943 : :
26944 : : /* At most one of these will be true. */
26945 : 905989 : bool extern_p = false;
26946 : 905989 : bool nomem_p = false;
26947 : 905989 : bool static_p = false;
26948 : :
26949 : 905989 : if (storage != NULL_TREE)
26950 : : {
26951 : 903321 : if (storage == ridpointers[(int) RID_EXTERN])
26952 : : {
26953 : 903296 : if (cxx_dialect == cxx98 && pedantic)
26954 : 2387 : pedwarn (input_location, OPT_Wc__11_extensions,
26955 : : "ISO C++ 1998 forbids the use of %<extern%> on "
26956 : : "explicit instantiations");
26957 : : }
26958 : : else
26959 : 25 : pedwarn (input_location, OPT_Wpedantic,
26960 : : "ISO C++ forbids the use of %qE"
26961 : : " on explicit instantiations", storage);
26962 : :
26963 : 903321 : if (storage == ridpointers[(int) RID_INLINE])
26964 : : nomem_p = true;
26965 : 903299 : else if (storage == ridpointers[(int) RID_EXTERN])
26966 : : extern_p = true;
26967 : 3 : else if (storage == ridpointers[(int) RID_STATIC])
26968 : : static_p = true;
26969 : : else
26970 : 0 : error ("storage class %qD applied to template instantiation",
26971 : : storage);
26972 : : }
26973 : :
26974 : 905989 : if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
26975 : : /* DR 259 [temp.spec].
26976 : :
26977 : : Both an explicit instantiation and a declaration of an explicit
26978 : : specialization shall not appear in a program unless the
26979 : : explicit instantiation follows a declaration of the explicit
26980 : : specialization.
26981 : :
26982 : : For a given set of template parameters, if an explicit
26983 : : instantiation of a template appears after a declaration of an
26984 : : explicit specialization for that template, the explicit
26985 : : instantiation has no effect. */
26986 : : return;
26987 : :
26988 : 859344 : if (CLASSTYPE_EXPLICIT_INSTANTIATION (t) && !CLASSTYPE_INTERFACE_ONLY (t))
26989 : : {
26990 : : /* We've already instantiated the template. */
26991 : :
26992 : : /* [temp.spec]
26993 : :
26994 : : No program shall explicitly instantiate any template more
26995 : : than once.
26996 : :
26997 : : If EXTERN_P then this is ok. */
26998 : 3 : if (!extern_p && (complain & tf_error))
26999 : 3 : permerror (input_location,
27000 : : "duplicate explicit instantiation of %q#T", t);
27001 : :
27002 : 3 : return;
27003 : : }
27004 : :
27005 : 859341 : check_explicit_instantiation_namespace (TYPE_NAME (t));
27006 : 859341 : mark_class_instantiated (t, extern_p);
27007 : :
27008 : 859341 : if (nomem_p)
27009 : : return;
27010 : :
27011 : : /* In contrast to implicit instantiation, where only the
27012 : : declarations, and not the definitions, of members are
27013 : : instantiated, we have here:
27014 : :
27015 : : [temp.explicit]
27016 : :
27017 : : An explicit instantiation that names a class template
27018 : : specialization is also an explicit instantiation of the same
27019 : : kind (declaration or definition) of each of its members (not
27020 : : including members inherited from base classes and members
27021 : : that are templates) that has not been previously explicitly
27022 : : specialized in the translation unit containing the explicit
27023 : : instantiation, provided that the associated constraints, if
27024 : : any, of that member are satisfied by the template arguments
27025 : : of the explicit instantiation. */
27026 : 33038031 : for (tree fld = TYPE_FIELDS (t); fld; fld = DECL_CHAIN (fld))
27027 : 32178715 : if ((VAR_P (fld)
27028 : 31829166 : || (TREE_CODE (fld) == FUNCTION_DECL
27029 : 21547569 : && !static_p
27030 : 21547569 : && user_provided_p (fld)))
27031 : 20501641 : && DECL_TEMPLATE_INSTANTIATION (fld)
27032 : 52347401 : && constraints_satisfied_p (fld))
27033 : : {
27034 : 20168685 : mark_decl_instantiated (fld, extern_p);
27035 : 20168685 : if (! extern_p)
27036 : 30056 : instantiate_decl (fld, /*defer_ok=*/true,
27037 : : /*expl_inst_class_mem_p=*/true);
27038 : : }
27039 : 12010030 : else if (DECL_IMPLICIT_TYPEDEF_P (fld))
27040 : : {
27041 : 129863 : tree type = TREE_TYPE (fld);
27042 : :
27043 : 112683 : if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INFO (type)
27044 : 242543 : && !uses_template_parms (CLASSTYPE_TI_ARGS (type)))
27045 : 112680 : do_type_instantiation (type, storage, 0);
27046 : : }
27047 : : }
27048 : :
27049 : : /* Given a function DECL, which is a specialization of TMPL, modify
27050 : : DECL to be a re-instantiation of TMPL with the same template
27051 : : arguments. TMPL should be the template into which tsubst'ing
27052 : : should occur for DECL, not the most general template.
27053 : :
27054 : : One reason for doing this is a scenario like this:
27055 : :
27056 : : template <class T>
27057 : : void f(const T&, int i);
27058 : :
27059 : : void g() { f(3, 7); }
27060 : :
27061 : : template <class T>
27062 : : void f(const T& t, const int i) { }
27063 : :
27064 : : Note that when the template is first instantiated, with
27065 : : instantiate_template, the resulting DECL will have no name for the
27066 : : first parameter, and the wrong type for the second. So, when we go
27067 : : to instantiate the DECL, we regenerate it. */
27068 : :
27069 : : static void
27070 : 20963203 : regenerate_decl_from_template (tree decl, tree tmpl, tree args)
27071 : : {
27072 : : /* The arguments used to instantiate DECL, from the most general
27073 : : template. */
27074 : 20963203 : tree code_pattern = DECL_TEMPLATE_RESULT (tmpl);
27075 : :
27076 : : /* Make sure that we can see identifiers, and compute access correctly. */
27077 : 20963203 : push_access_scope (decl);
27078 : :
27079 : 20963203 : if (TREE_CODE (decl) == FUNCTION_DECL)
27080 : : {
27081 : 16463982 : tree specs;
27082 : 16463982 : int args_depth;
27083 : 16463982 : int parms_depth;
27084 : :
27085 : : /* Don't bother with this for unique friends that can't be redeclared and
27086 : : might change type if regenerated (PR69836). */
27087 : 16463982 : if (DECL_UNIQUE_FRIEND_P (decl))
27088 : 35689 : goto done;
27089 : :
27090 : : /* Use the source location of the definition. */
27091 : 16428293 : DECL_SOURCE_LOCATION (decl) = DECL_SOURCE_LOCATION (tmpl);
27092 : :
27093 : 32856586 : args_depth = TMPL_ARGS_DEPTH (args);
27094 : 16428293 : parms_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
27095 : 16428293 : if (args_depth > parms_depth)
27096 : 0 : args = get_innermost_template_args (args, parms_depth);
27097 : :
27098 : : /* Instantiate a dynamic exception-specification. noexcept will be
27099 : : handled below. */
27100 : 16428293 : if (tree raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (code_pattern)))
27101 : 6814537 : if (TREE_VALUE (raises))
27102 : : {
27103 : 22 : specs = tsubst_exception_specification (TREE_TYPE (code_pattern),
27104 : : args, tf_error, NULL_TREE,
27105 : : /*defer_ok*/false);
27106 : 22 : if (specs && specs != error_mark_node)
27107 : 21 : TREE_TYPE (decl) = build_exception_variant (TREE_TYPE (decl),
27108 : : specs);
27109 : : }
27110 : :
27111 : : /* Merge parameter declarations. */
27112 : 16428293 : if (tree pattern_parm
27113 : 16428293 : = skip_artificial_parms_for (code_pattern,
27114 : 16428293 : DECL_ARGUMENTS (code_pattern)))
27115 : : {
27116 : 11363695 : tree *p = &DECL_ARGUMENTS (decl);
27117 : 15719803 : for (int skip = num_artificial_parms_for (decl); skip; --skip)
27118 : 4356108 : p = &DECL_CHAIN (*p);
27119 : 11363695 : *p = tsubst_decl (pattern_parm, args, tf_error);
27120 : 31851794 : for (tree t = *p; t; t = DECL_CHAIN (t))
27121 : 20488099 : DECL_CONTEXT (t) = decl;
27122 : : }
27123 : :
27124 : 16428293 : if (DECL_CONTRACTS (decl))
27125 : : {
27126 : : /* If we're regenerating a specialization, the contracts will have
27127 : : been copied from the most general template. Replace those with
27128 : : the ones from the actual specialization. */
27129 : 150 : tree tmpl = DECL_TI_TEMPLATE (decl);
27130 : 150 : if (DECL_TEMPLATE_SPECIALIZATION (tmpl))
27131 : : {
27132 : 4 : remove_contract_attributes (decl);
27133 : 4 : copy_contract_attributes (decl, code_pattern);
27134 : : }
27135 : :
27136 : 150 : tsubst_contract_attributes (decl, args, tf_warning_or_error, code_pattern);
27137 : : }
27138 : :
27139 : : /* Merge additional specifiers from the CODE_PATTERN. */
27140 : 16428293 : if (DECL_DECLARED_INLINE_P (code_pattern)
27141 : 31124506 : && !DECL_DECLARED_INLINE_P (decl))
27142 : 57880 : DECL_DECLARED_INLINE_P (decl) = 1;
27143 : :
27144 : 16428293 : maybe_instantiate_noexcept (decl, tf_error);
27145 : : }
27146 : 4499221 : else if (VAR_P (decl))
27147 : : {
27148 : 4499221 : start_lambda_scope (decl);
27149 : 4499221 : DECL_INITIAL (decl) =
27150 : 4499221 : tsubst_init (DECL_INITIAL (code_pattern), decl, args,
27151 : 4499221 : tf_error, DECL_TI_TEMPLATE (decl));
27152 : 4499221 : finish_lambda_scope ();
27153 : 4499221 : if (VAR_HAD_UNKNOWN_BOUND (decl))
27154 : 81 : TREE_TYPE (decl) = tsubst (TREE_TYPE (code_pattern), args,
27155 : 81 : tf_error, DECL_TI_TEMPLATE (decl));
27156 : : }
27157 : : else
27158 : 0 : gcc_unreachable ();
27159 : :
27160 : 20963203 : done:
27161 : 20963203 : pop_access_scope (decl);
27162 : 20963203 : }
27163 : :
27164 : : /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
27165 : : substituted to get DECL. */
27166 : :
27167 : : tree
27168 : 69731078 : template_for_substitution (tree decl)
27169 : : {
27170 : 69731078 : tree tmpl = DECL_TI_TEMPLATE (decl);
27171 : :
27172 : : /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
27173 : : for the instantiation. This is not always the most general
27174 : : template. Consider, for example:
27175 : :
27176 : : template <class T>
27177 : : struct S { template <class U> void f();
27178 : : template <> void f<int>(); };
27179 : :
27180 : : and an instantiation of S<double>::f<int>. We want TD to be the
27181 : : specialization S<T>::f<int>, not the more general S<T>::f<U>. */
27182 : 69731078 : while (/* An instantiation cannot have a definition, so we need a
27183 : : more general template. */
27184 : 153717910 : DECL_TEMPLATE_INSTANTIATION (tmpl)
27185 : : /* We must also deal with friend templates. Given:
27186 : :
27187 : : template <class T> struct S {
27188 : : template <class U> friend void f() {};
27189 : : };
27190 : :
27191 : : S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
27192 : : so far as the language is concerned, but that's still
27193 : : where we get the pattern for the instantiation from. On
27194 : : other hand, if the definition comes outside the class, say:
27195 : :
27196 : : template <class T> struct S {
27197 : : template <class U> friend void f();
27198 : : };
27199 : : template <class U> friend void f() {}
27200 : :
27201 : : we don't need to look any further. That's what the check for
27202 : : DECL_INITIAL is for. */
27203 : 76858955 : || (TREE_CODE (decl) == FUNCTION_DECL
27204 : 61176731 : && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl)
27205 : 636786 : && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl))))
27206 : : {
27207 : : /* The present template, TD, should not be a definition. If it
27208 : : were a definition, we should be using it! Note that we
27209 : : cannot restructure the loop to just keep going until we find
27210 : : a template with a definition, since that might go too far if
27211 : : a specialization was declared, but not defined. */
27212 : :
27213 : : /* Fetch the more general template. */
27214 : 7127877 : tmpl = DECL_TI_TEMPLATE (tmpl);
27215 : : }
27216 : :
27217 : 69731078 : return tmpl;
27218 : : }
27219 : :
27220 : : /* Returns true if we need to instantiate this template instance even if we
27221 : : know we aren't going to emit it. */
27222 : :
27223 : : bool
27224 : 2752362 : always_instantiate_p (tree decl)
27225 : : {
27226 : : /* We always instantiate inline functions so that we can inline them. An
27227 : : explicit instantiation declaration prohibits implicit instantiation of
27228 : : non-inline functions. With high levels of optimization, we would
27229 : : normally inline non-inline functions -- but we're not allowed to do
27230 : : that for "extern template" functions. Therefore, we check
27231 : : DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
27232 : 2752362 : return ((TREE_CODE (decl) == FUNCTION_DECL
27233 : 2691017 : && (DECL_DECLARED_INLINE_P (decl)
27234 : 123244 : || type_uses_auto (TREE_TYPE (TREE_TYPE (decl)))))
27235 : : /* And we need to instantiate static data members so that
27236 : : their initializers are available in integral constant
27237 : : expressions. */
27238 : 2875606 : || (VAR_P (decl)
27239 : 61345 : && decl_maybe_constant_var_p (decl)));
27240 : : }
27241 : :
27242 : : /* If FN has a noexcept-specifier that hasn't been instantiated yet,
27243 : : instantiate it now, modifying TREE_TYPE (fn). Returns false on
27244 : : error, true otherwise. */
27245 : :
27246 : : bool
27247 : 310214060 : maybe_instantiate_noexcept (tree fn, tsubst_flags_t complain)
27248 : : {
27249 : 310214060 : if (fn == error_mark_node)
27250 : : return false;
27251 : :
27252 : : /* Don't instantiate a noexcept-specification from template context. */
27253 : 310214059 : if (processing_template_decl
27254 : 310214059 : && (!flag_noexcept_type || type_dependent_expression_p (fn)))
27255 : 150108 : return true;
27256 : :
27257 : 310063951 : tree fntype = TREE_TYPE (fn);
27258 : 310063951 : tree spec = TYPE_RAISES_EXCEPTIONS (fntype);
27259 : :
27260 : 152419559 : if ((!spec || UNEVALUATED_NOEXCEPT_SPEC_P (spec))
27261 : 316858925 : && DECL_MAYBE_DELETED (fn))
27262 : : {
27263 : 10155 : if (fn == current_function_decl)
27264 : : /* We're in start_preparsed_function, keep going. */
27265 : : return true;
27266 : :
27267 : 15 : ++function_depth;
27268 : 15 : maybe_synthesize_method (fn);
27269 : 15 : --function_depth;
27270 : 15 : return !DECL_DELETED_FN (fn);
27271 : : }
27272 : :
27273 : 462473355 : if (!spec || !TREE_PURPOSE (spec))
27274 : : return true;
27275 : :
27276 : 151505294 : tree noex = TREE_PURPOSE (spec);
27277 : 151505294 : if (TREE_CODE (noex) != DEFERRED_NOEXCEPT
27278 : 151505294 : && TREE_CODE (noex) != DEFERRED_PARSE)
27279 : : return true;
27280 : :
27281 : 7925278 : tree orig_fn = NULL_TREE;
27282 : : /* For a member friend template we can get a TEMPLATE_DECL. Let's use
27283 : : its FUNCTION_DECL for the rest of this function -- push_access_scope
27284 : : doesn't accept TEMPLATE_DECLs. */
27285 : 7925278 : if (DECL_FUNCTION_TEMPLATE_P (fn))
27286 : : {
27287 : 68 : orig_fn = fn;
27288 : 68 : fn = DECL_TEMPLATE_RESULT (fn);
27289 : : }
27290 : :
27291 : 7925278 : if (DECL_CLONED_FUNCTION_P (fn))
27292 : : {
27293 : 3783570 : tree prime = DECL_CLONED_FUNCTION (fn);
27294 : 3783570 : if (!maybe_instantiate_noexcept (prime, complain))
27295 : : return false;
27296 : 3783468 : spec = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (prime));
27297 : : }
27298 : 4141708 : else if (TREE_CODE (noex) == DEFERRED_NOEXCEPT)
27299 : : {
27300 : 4141708 : static hash_set<tree>* fns = new hash_set<tree>;
27301 : 4141708 : bool added = false;
27302 : 4141708 : if (DEFERRED_NOEXCEPT_PATTERN (noex) == NULL_TREE)
27303 : : {
27304 : 3357491 : spec = get_defaulted_eh_spec (fn, complain);
27305 : 3357491 : if (spec == error_mark_node)
27306 : : /* This might have failed because of an unparsed DMI, so
27307 : : let's try again later. */
27308 : : return false;
27309 : : }
27310 : 784217 : else if (!(added = !fns->add (fn)))
27311 : : {
27312 : : /* If hash_set::add returns true, the element was already there. */
27313 : 3 : location_t loc = cp_expr_loc_or_loc (DEFERRED_NOEXCEPT_PATTERN (noex),
27314 : 3 : DECL_SOURCE_LOCATION (fn));
27315 : 3 : error_at (loc,
27316 : : "exception specification of %qD depends on itself",
27317 : : fn);
27318 : 3 : spec = noexcept_false_spec;
27319 : : }
27320 : 784214 : else if (push_tinst_level (fn))
27321 : : {
27322 : 784147 : const bool push_to_top = maybe_push_to_top_level (fn);
27323 : 784147 : push_access_scope (fn);
27324 : 784147 : push_deferring_access_checks (dk_no_deferred);
27325 : 784147 : input_location = DECL_SOURCE_LOCATION (fn);
27326 : :
27327 : 784147 : if (DECL_IOBJ_MEMBER_FUNCTION_P (fn)
27328 : 784147 : && !DECL_LOCAL_DECL_P (fn))
27329 : : {
27330 : : /* If needed, set current_class_ptr for the benefit of
27331 : : tsubst_copy/PARM_DECL. */
27332 : 383843 : tree this_parm = DECL_ARGUMENTS (fn);
27333 : 383843 : current_class_ptr = NULL_TREE;
27334 : 383843 : current_class_ref = cp_build_fold_indirect_ref (this_parm);
27335 : 383843 : current_class_ptr = this_parm;
27336 : : }
27337 : :
27338 : : /* If this function is represented by a TEMPLATE_DECL, then
27339 : : the deferred noexcept-specification might still contain
27340 : : dependent types, even after substitution. And we need the
27341 : : dependency check functions to work in build_noexcept_spec. */
27342 : 784147 : if (orig_fn)
27343 : 68 : ++processing_template_decl;
27344 : :
27345 : : /* Do deferred instantiation of the noexcept-specifier. */
27346 : 784147 : noex = tsubst_expr (DEFERRED_NOEXCEPT_PATTERN (noex),
27347 : 784147 : DEFERRED_NOEXCEPT_ARGS (noex),
27348 : : tf_warning_or_error, fn);
27349 : : /* Build up the noexcept-specification. */
27350 : 784147 : spec = build_noexcept_spec (noex, tf_warning_or_error);
27351 : :
27352 : 784147 : if (orig_fn)
27353 : 68 : --processing_template_decl;
27354 : :
27355 : 784147 : pop_deferring_access_checks ();
27356 : 784147 : pop_access_scope (fn);
27357 : 784147 : pop_tinst_level ();
27358 : 784147 : maybe_pop_from_top_level (push_to_top);
27359 : : }
27360 : : else
27361 : 67 : spec = noexcept_false_spec;
27362 : :
27363 : 784217 : if (added)
27364 : 784214 : fns->remove (fn);
27365 : : }
27366 : :
27367 : 7925074 : if (spec == error_mark_node)
27368 : : {
27369 : : /* This failed with a hard error, so let's go with false. */
27370 : 18 : gcc_assert (seen_error ());
27371 : 18 : spec = noexcept_false_spec;
27372 : : }
27373 : :
27374 : 7925074 : TREE_TYPE (fn) = build_exception_variant (fntype, spec);
27375 : 7925074 : if (orig_fn)
27376 : 68 : TREE_TYPE (orig_fn) = TREE_TYPE (fn);
27377 : :
27378 : : return true;
27379 : : }
27380 : :
27381 : : /* We're starting to process the function INST, an instantiation of PATTERN;
27382 : : add their parameters to local_specializations. */
27383 : :
27384 : : void
27385 : 16619104 : register_parameter_specializations (tree pattern, tree inst)
27386 : : {
27387 : 16619104 : tree tmpl_parm = DECL_ARGUMENTS (pattern);
27388 : 16619104 : tree spec_parm = DECL_ARGUMENTS (inst);
27389 : 16619104 : if (DECL_IOBJ_MEMBER_FUNCTION_P (inst))
27390 : : {
27391 : 8450016 : register_local_specialization (spec_parm, tmpl_parm);
27392 : 8450016 : spec_parm = skip_artificial_parms_for (inst, spec_parm);
27393 : 8450016 : tmpl_parm = skip_artificial_parms_for (pattern, tmpl_parm);
27394 : : }
27395 : 37508755 : for (; tmpl_parm; tmpl_parm = DECL_CHAIN (tmpl_parm))
27396 : : {
27397 : 20889651 : if (!DECL_PACK_P (tmpl_parm))
27398 : : {
27399 : 20346503 : register_local_specialization (spec_parm, tmpl_parm);
27400 : 20346503 : spec_parm = DECL_CHAIN (spec_parm);
27401 : : }
27402 : : else
27403 : : {
27404 : : /* Register the (value) argument pack as a specialization of
27405 : : TMPL_PARM, then move on. */
27406 : 543148 : tree argpack = extract_fnparm_pack (tmpl_parm, &spec_parm);
27407 : 543148 : register_local_specialization (argpack, tmpl_parm);
27408 : : }
27409 : : }
27410 : 16619104 : gcc_assert (!spec_parm);
27411 : 16619104 : }
27412 : :
27413 : : /* Instantiate the body of D using PATTERN with ARGS. We have
27414 : : already determined PATTERN is the correct template to use.
27415 : : NESTED_P is true if this is a nested function, in which case
27416 : : PATTERN will be a FUNCTION_DECL not a TEMPLATE_DECL. */
27417 : :
27418 : : static void
27419 : 20963288 : instantiate_body (tree pattern, tree args, tree d, bool nested_p)
27420 : : {
27421 : 20963288 : tree td = NULL_TREE;
27422 : 20963288 : tree code_pattern = pattern;
27423 : :
27424 : 20963288 : if (!nested_p)
27425 : : {
27426 : 20963203 : td = pattern;
27427 : 20963203 : code_pattern = DECL_TEMPLATE_RESULT (td);
27428 : : }
27429 : : else
27430 : : /* Only OMP reductions are nested. */
27431 : 85 : gcc_checking_assert (DECL_OMP_DECLARE_REDUCTION_P (code_pattern));
27432 : :
27433 : 20963288 : vec<tree> omp_privatization_save;
27434 : 20963288 : if (current_function_decl)
27435 : 6711445 : save_omp_privatization_clauses (omp_privatization_save);
27436 : :
27437 : 20963288 : bool push_to_top = maybe_push_to_top_level (d);
27438 : :
27439 : 20963288 : mark_template_arguments_used (pattern, args);
27440 : :
27441 : 20963288 : if (VAR_P (d))
27442 : : {
27443 : : /* The variable might be a lambda's extra scope, and that
27444 : : lambda's visibility depends on D's. */
27445 : 4499221 : maybe_commonize_var (d);
27446 : 4499221 : determine_visibility (d);
27447 : : }
27448 : :
27449 : : /* Mark D as instantiated so that recursive calls to
27450 : : instantiate_decl do not try to instantiate it again. */
27451 : 20963288 : DECL_TEMPLATE_INSTANTIATED (d) = 1;
27452 : :
27453 : 20963288 : if (td)
27454 : : /* Regenerate the declaration in case the template has been modified
27455 : : by a subsequent redeclaration. */
27456 : 20963203 : regenerate_decl_from_template (d, td, args);
27457 : :
27458 : : /* We already set the file and line above. Reset them now in case
27459 : : they changed as a result of calling regenerate_decl_from_template. */
27460 : 20963288 : input_location = DECL_SOURCE_LOCATION (d);
27461 : :
27462 : 20963288 : if (VAR_P (d))
27463 : : {
27464 : : /* Clear out DECL_RTL; whatever was there before may not be right
27465 : : since we've reset the type of the declaration. */
27466 : 4499221 : SET_DECL_RTL (d, NULL);
27467 : 4499221 : DECL_IN_AGGR_P (d) = 0;
27468 : :
27469 : : /* The initializer is placed in DECL_INITIAL by
27470 : : regenerate_decl_from_template so we don't need to
27471 : : push/pop_access_scope again here. Pull it out so that
27472 : : cp_finish_decl can process it. */
27473 : 4499221 : bool const_init = false;
27474 : 4499221 : tree init = DECL_INITIAL (d);
27475 : 4499221 : DECL_INITIAL (d) = NULL_TREE;
27476 : 4499221 : DECL_INITIALIZED_P (d) = 0;
27477 : :
27478 : : /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
27479 : : initializer. That function will defer actual emission until
27480 : : we have a chance to determine linkage. */
27481 : 4499221 : DECL_EXTERNAL (d) = 0;
27482 : :
27483 : : /* Enter the scope of D so that access-checking works correctly. */
27484 : 4499221 : bool enter_context = DECL_CLASS_SCOPE_P (d);
27485 : 1027944 : if (enter_context)
27486 : 1027944 : push_nested_class (DECL_CONTEXT (d));
27487 : :
27488 : 4499221 : const_init = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern);
27489 : 4499221 : cp_finish_decl (d, init, const_init, NULL_TREE, 0);
27490 : :
27491 : 4499221 : if (enter_context)
27492 : 1027944 : pop_nested_class ();
27493 : : }
27494 : 16464067 : else if (TREE_CODE (d) == FUNCTION_DECL && DECL_DEFAULTED_FN (code_pattern))
27495 : 62 : synthesize_method (d);
27496 : 16464005 : else if (TREE_CODE (d) == FUNCTION_DECL)
27497 : : {
27498 : : /* Set up the list of local specializations. */
27499 : 17423077 : local_specialization_stack lss (push_to_top ? lss_blank : lss_copy);
27500 : 16464005 : tree block = NULL_TREE;
27501 : :
27502 : : /* Set up context. */
27503 : 16464005 : if (nested_p)
27504 : 85 : block = push_stmt_list ();
27505 : : else
27506 : : {
27507 : 16463920 : start_preparsed_function (d, NULL_TREE, SF_PRE_PARSED);
27508 : :
27509 : 16463920 : perform_instantiation_time_access_checks (code_pattern, args);
27510 : : }
27511 : :
27512 : : /* Create substitution entries for the parameters. */
27513 : 16464005 : register_parameter_specializations (code_pattern, d);
27514 : :
27515 : : /* Substitute into the body of the function. */
27516 : 16464005 : if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern))
27517 : 101 : tsubst_omp_udr (DECL_SAVED_TREE (code_pattern), args,
27518 : : tf_warning_or_error, d);
27519 : : else
27520 : : {
27521 : 16463904 : tsubst_stmt (DECL_SAVED_TREE (code_pattern), args,
27522 : 16463904 : tf_warning_or_error, DECL_TI_TEMPLATE (d));
27523 : :
27524 : : /* Set the current input_location to the end of the function
27525 : : so that finish_function knows where we are. */
27526 : 16463895 : input_location
27527 : 16463895 : = DECL_STRUCT_FUNCTION (code_pattern)->function_end_locus;
27528 : :
27529 : : /* Remember if we saw an infinite loop in the template. */
27530 : 16463895 : current_function_infinite_loop
27531 : 16463895 : = DECL_STRUCT_FUNCTION (code_pattern)->language->infinite_loop;
27532 : : }
27533 : :
27534 : : /* Finish the function. */
27535 : 16463996 : if (nested_p)
27536 : 85 : DECL_SAVED_TREE (d) = pop_stmt_list (block);
27537 : : else
27538 : : {
27539 : 16463911 : d = finish_function (/*inline_p=*/false);
27540 : 16463911 : expand_or_defer_fn (d);
27541 : : }
27542 : :
27543 : 16463996 : if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern))
27544 : 101 : cp_check_omp_declare_reduction (d);
27545 : 16463996 : }
27546 : :
27547 : : /* We're not deferring instantiation any more. */
27548 : 20963279 : if (!nested_p)
27549 : 20963194 : TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d)) = 0;
27550 : :
27551 : 20963279 : maybe_pop_from_top_level (push_to_top);
27552 : :
27553 : 20963279 : if (current_function_decl)
27554 : 6711445 : restore_omp_privatization_clauses (omp_privatization_save);
27555 : 20963279 : }
27556 : :
27557 : : /* Produce the definition of D, a _DECL generated from a template. If
27558 : : DEFER_OK is true, then we don't have to actually do the
27559 : : instantiation now; we just have to do it sometime. Normally it is
27560 : : an error if this is an explicit instantiation but D is undefined.
27561 : : EXPL_INST_CLASS_MEM_P is true iff D is a member of an explicitly
27562 : : instantiated class template. */
27563 : :
27564 : : tree
27565 : 98577381 : instantiate_decl (tree d, bool defer_ok, bool expl_inst_class_mem_p)
27566 : : {
27567 : 98577381 : tree tmpl = DECL_TI_TEMPLATE (d);
27568 : 98577381 : tree gen_args;
27569 : 98577381 : tree args;
27570 : 98577381 : tree td;
27571 : 98577381 : tree code_pattern;
27572 : 98577381 : tree spec;
27573 : 98577381 : tree gen_tmpl;
27574 : 98577381 : bool pattern_defined;
27575 : 98577381 : location_t saved_loc = input_location;
27576 : 98577381 : bool external_p;
27577 : 98577381 : bool deleted_p;
27578 : :
27579 : : /* This function should only be used to instantiate templates for
27580 : : functions and static member variables. */
27581 : 98577381 : gcc_assert (VAR_OR_FUNCTION_DECL_P (d));
27582 : :
27583 : 98577381 : gcc_checking_assert (!DECL_FUNCTION_SCOPE_P (d));
27584 : :
27585 : 98577381 : if (modules_p ())
27586 : : /* We may have a pending instantiation of D itself. */
27587 : 439699 : lazy_load_pendings (d);
27588 : :
27589 : : /* Variables are never deferred; if instantiation is required, they
27590 : : are instantiated right away. That allows for better code in the
27591 : : case that an expression refers to the value of the variable --
27592 : : if the variable has a constant value the referring expression can
27593 : : take advantage of that fact. */
27594 : 98577381 : if (VAR_P (d))
27595 : 63938100 : defer_ok = false;
27596 : :
27597 : : /* Don't instantiate cloned functions. Instead, instantiate the
27598 : : functions they cloned. */
27599 : 98577381 : if (TREE_CODE (d) == FUNCTION_DECL && DECL_CLONED_FUNCTION_P (d))
27600 : 4592678 : d = DECL_CLONED_FUNCTION (d);
27601 : :
27602 : 98577381 : if (DECL_TEMPLATE_INSTANTIATED (d)
27603 : 40442072 : || TREE_TYPE (d) == error_mark_node
27604 : 40442066 : || (TREE_CODE (d) == FUNCTION_DECL
27605 : 32222036 : && DECL_DEFAULTED_FN (d) && DECL_INITIAL (d))
27606 : 139000115 : || DECL_TEMPLATE_SPECIALIZATION (d))
27607 : : /* D has already been instantiated or explicitly specialized, so
27608 : : there's nothing for us to do here.
27609 : :
27610 : : It might seem reasonable to check whether or not D is an explicit
27611 : : instantiation, and, if so, stop here. But when an explicit
27612 : : instantiation is deferred until the end of the compilation,
27613 : : DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
27614 : : the instantiation. */
27615 : : return d;
27616 : :
27617 : : /* Check to see whether we know that this template will be
27618 : : instantiated in some other file, as with "extern template"
27619 : : extension. */
27620 : 40355020 : external_p = (DECL_INTERFACE_KNOWN (d) && DECL_REALLY_EXTERN (d));
27621 : :
27622 : : /* In general, we do not instantiate such templates. */
27623 : 1781561 : if (external_p && !always_instantiate_p (d))
27624 : : return d;
27625 : :
27626 : 40339140 : gen_tmpl = most_general_template (tmpl);
27627 : 40339140 : gen_args = DECL_TI_ARGS (d);
27628 : :
27629 : : /* We should already have the extra args. */
27630 : 47372490 : gcc_checking_assert (tmpl == gen_tmpl
27631 : : || (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl))
27632 : : == TMPL_ARGS_DEPTH (gen_args)));
27633 : : /* And what's in the hash table should match D. */
27634 : 40339140 : gcc_checking_assert ((spec = retrieve_specialization (gen_tmpl, gen_args, 0))
27635 : : == d
27636 : : || spec == NULL_TREE);
27637 : :
27638 : : /* This needs to happen before any tsubsting. */
27639 : 40339140 : if (! push_tinst_level (d))
27640 : : return d;
27641 : :
27642 : 40337925 : auto_timevar tv (TV_TEMPLATE_INST);
27643 : :
27644 : : /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
27645 : : for the instantiation. */
27646 : 40337925 : td = template_for_substitution (d);
27647 : 40337925 : args = gen_args;
27648 : :
27649 : 40337925 : if (variable_template_specialization_p (d))
27650 : : {
27651 : : /* Look up an explicit specialization, if any. */
27652 : 3488644 : tree partial_ti = most_specialized_partial_spec (d, tf_warning_or_error);
27653 : 3488644 : if (partial_ti && partial_ti != error_mark_node)
27654 : : {
27655 : 237355 : td = TI_TEMPLATE (partial_ti);
27656 : 237355 : args = TI_ARGS (partial_ti);
27657 : : }
27658 : : }
27659 : :
27660 : 40337925 : maybe_diagnose_erroneous_template (td);
27661 : :
27662 : 40337925 : code_pattern = DECL_TEMPLATE_RESULT (td);
27663 : :
27664 : : /* We should never be trying to instantiate a member of a class
27665 : : template or partial specialization. */
27666 : 40337925 : gcc_assert (d != code_pattern);
27667 : :
27668 : 80675850 : if ((DECL_NAMESPACE_SCOPE_P (d) && !DECL_INITIALIZED_IN_CLASS_P (d))
27669 : 66655943 : || DECL_TEMPLATE_SPECIALIZATION (td))
27670 : : /* In the case of a friend template whose definition is provided
27671 : : outside the class, we may have too many arguments. Drop the
27672 : : ones we don't need. The same is true for specializations. */
27673 : 14022997 : args = get_innermost_template_args
27674 : 14022997 : (args, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td)));
27675 : :
27676 : 40337925 : if (TREE_CODE (d) == FUNCTION_DECL)
27677 : : {
27678 : 32173438 : deleted_p = DECL_DELETED_FN (code_pattern);
27679 : 32173438 : pattern_defined = ((DECL_SAVED_TREE (code_pattern) != NULL_TREE
27680 : 31312957 : && DECL_INITIAL (code_pattern) != error_mark_node)
27681 : 860493 : || DECL_DEFAULTED_FN (code_pattern)
27682 : 33033785 : || deleted_p);
27683 : : }
27684 : : else
27685 : : {
27686 : 8164487 : deleted_p = false;
27687 : 8164487 : if (DECL_CLASS_SCOPE_P (code_pattern))
27688 : 4692400 : pattern_defined = ! DECL_IN_AGGR_P (code_pattern);
27689 : : else
27690 : 3472087 : pattern_defined = ! DECL_EXTERNAL (code_pattern);
27691 : : }
27692 : :
27693 : : /* We may be in the middle of deferred access check. Disable it now. */
27694 : 40337925 : push_deferring_access_checks (dk_no_deferred);
27695 : :
27696 : : /* Unless an explicit instantiation directive has already determined
27697 : : the linkage of D, remember that a definition is available for
27698 : : this entity. */
27699 : 40337925 : if (pattern_defined
27700 : 35860503 : && !DECL_INTERFACE_KNOWN (d)
27701 : 73203236 : && !DECL_NOT_REALLY_EXTERN (d))
27702 : 15547015 : mark_definable (d);
27703 : :
27704 : 40337925 : DECL_SOURCE_LOCATION (td) = DECL_SOURCE_LOCATION (code_pattern);
27705 : 40337925 : DECL_SOURCE_LOCATION (d) = DECL_SOURCE_LOCATION (code_pattern);
27706 : 40337925 : input_location = DECL_SOURCE_LOCATION (d);
27707 : :
27708 : : /* If D is a member of an explicitly instantiated class template,
27709 : : and no definition is available, treat it like an implicit
27710 : : instantiation. */
27711 : 40337925 : if (!pattern_defined && expl_inst_class_mem_p
27712 : 40337925 : && DECL_EXPLICIT_INSTANTIATION (d))
27713 : : {
27714 : : /* Leave linkage flags alone on instantiations with anonymous
27715 : : visibility. */
27716 : 356 : if (TREE_PUBLIC (d))
27717 : : {
27718 : 347 : DECL_NOT_REALLY_EXTERN (d) = 0;
27719 : 347 : DECL_INTERFACE_KNOWN (d) = 0;
27720 : : }
27721 : 356 : SET_DECL_IMPLICIT_INSTANTIATION (d);
27722 : : }
27723 : :
27724 : : /* Defer all other templates, unless we have been explicitly
27725 : : forbidden from doing so. */
27726 : 40337925 : if (/* If there is no definition, we cannot instantiate the
27727 : : template. */
27728 : : ! pattern_defined
27729 : : /* If it's OK to postpone instantiation, do so. */
27730 : 40337925 : || defer_ok
27731 : : /* If this is a static data member that will be defined
27732 : : elsewhere, we don't want to instantiate the entire data
27733 : : member, but we do want to instantiate the initializer so that
27734 : : we can substitute that elsewhere. */
27735 : 21011385 : || (external_p && VAR_P (d))
27736 : : /* Handle here a deleted function too, avoid generating
27737 : : its body (c++/61080). */
27738 : 20963716 : || deleted_p)
27739 : : {
27740 : : /* The definition of the static data member is now required so
27741 : : we must substitute the initializer. */
27742 : 19374722 : if (VAR_P (d)
27743 : 3665266 : && !DECL_INITIAL (d)
27744 : 19715360 : && DECL_INITIAL (code_pattern))
27745 : : {
27746 : 340122 : tree ns;
27747 : 340122 : tree init;
27748 : 340122 : bool const_init = false;
27749 : 340122 : bool enter_context = DECL_CLASS_SCOPE_P (d);
27750 : :
27751 : 340122 : ns = decl_namespace_context (d);
27752 : 340122 : push_nested_namespace (ns);
27753 : 340122 : if (enter_context)
27754 : 339992 : push_nested_class (DECL_CONTEXT (d));
27755 : 340122 : init = tsubst_expr (DECL_INITIAL (code_pattern),
27756 : : args,
27757 : : tf_warning_or_error, NULL_TREE);
27758 : : /* If instantiating the initializer involved instantiating this
27759 : : again, don't call cp_finish_decl twice. */
27760 : 332025 : if (!DECL_INITIAL (d))
27761 : : {
27762 : : /* Make sure the initializer is still constant, in case of
27763 : : circular dependency (template/instantiate6.C). */
27764 : 332022 : const_init
27765 : 332022 : = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern);
27766 : 332022 : cp_finish_decl (d, init, /*init_const_expr_p=*/const_init,
27767 : : /*asmspec_tree=*/NULL_TREE, 0);
27768 : : }
27769 : 329328 : if (enter_context)
27770 : 329198 : pop_nested_class ();
27771 : 329328 : pop_nested_namespace (ns);
27772 : : }
27773 : :
27774 : : /* We restore the source position here because it's used by
27775 : : add_pending_template. */
27776 : 19363928 : input_location = saved_loc;
27777 : :
27778 : 13817874 : if (at_eof && !pattern_defined
27779 : 3951153 : && DECL_EXPLICIT_INSTANTIATION (d)
27780 : 19363943 : && DECL_NOT_REALLY_EXTERN (d))
27781 : : /* [temp.explicit]
27782 : :
27783 : : The definition of a non-exported function template, a
27784 : : non-exported member function template, or a non-exported
27785 : : member function or static data member of a class template
27786 : : shall be present in every translation unit in which it is
27787 : : explicitly instantiated. */
27788 : 15 : permerror (input_location, "explicit instantiation of %qD "
27789 : : "but no definition available", d);
27790 : :
27791 : : /* If we're in unevaluated context, we just wanted to get the
27792 : : constant value; this isn't an odr use, so don't queue
27793 : : a full instantiation. */
27794 : 19363928 : if (!cp_unevaluated_operand
27795 : : /* ??? Historically, we have instantiated inline functions, even
27796 : : when marked as "extern template". */
27797 : 19363814 : && !(external_p && VAR_P (d)))
27798 : 19316145 : add_pending_template (d);
27799 : : }
27800 : : else
27801 : : {
27802 : 20963203 : set_instantiating_module (d);
27803 : 20963203 : if (variable_template_p (gen_tmpl))
27804 : 3487493 : note_vague_linkage_variable (d);
27805 : 20963203 : instantiate_body (td, args, d, false);
27806 : : }
27807 : :
27808 : 40327122 : pop_deferring_access_checks ();
27809 : 40327122 : pop_tinst_level ();
27810 : 40327122 : input_location = saved_loc;
27811 : :
27812 : 40327122 : return d;
27813 : 40327122 : }
27814 : :
27815 : : /* Run through the list of templates that we wish we could
27816 : : instantiate, and instantiate any we can. RETRIES is the
27817 : : number of times we retry pending template instantiation. */
27818 : :
27819 : : void
27820 : 136222 : instantiate_pending_templates (int retries)
27821 : : {
27822 : 136222 : int reconsider;
27823 : 136222 : location_t saved_loc = input_location;
27824 : :
27825 : : /* Instantiating templates may trigger vtable generation. This in turn
27826 : : may require further template instantiations. We place a limit here
27827 : : to avoid infinite loop. */
27828 : 136222 : if (pending_templates && retries >= max_tinst_depth)
27829 : : {
27830 : 3 : tree decl = pending_templates->tinst->maybe_get_node ();
27831 : :
27832 : 3 : fatal_error (input_location,
27833 : : "template instantiation depth exceeds maximum of %d"
27834 : : " instantiating %q+D, possibly from virtual table generation"
27835 : : " (use %<-ftemplate-depth=%> to increase the maximum)",
27836 : : max_tinst_depth, decl);
27837 : : if (TREE_CODE (decl) == FUNCTION_DECL)
27838 : : /* Pretend that we defined it. */
27839 : : DECL_INITIAL (decl) = error_mark_node;
27840 : : return;
27841 : : }
27842 : :
27843 : 171454 : do
27844 : : {
27845 : 171454 : struct pending_template **t = &pending_templates;
27846 : 171454 : struct pending_template *last = NULL;
27847 : 171454 : reconsider = 0;
27848 : 17607851 : while (*t)
27849 : : {
27850 : 17436406 : tree instantiation = reopen_tinst_level ((*t)->tinst);
27851 : 17436406 : bool complete = false;
27852 : :
27853 : 17436406 : if (TYPE_P (instantiation))
27854 : : {
27855 : 0 : if (!COMPLETE_TYPE_P (instantiation))
27856 : : {
27857 : 0 : instantiate_class_template (instantiation);
27858 : 0 : if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation))
27859 : 0 : for (tree fld = TYPE_FIELDS (instantiation);
27860 : 0 : fld; fld = TREE_CHAIN (fld))
27861 : 0 : if ((VAR_P (fld)
27862 : 0 : || (TREE_CODE (fld) == FUNCTION_DECL
27863 : 0 : && !DECL_ARTIFICIAL (fld)))
27864 : 0 : && DECL_TEMPLATE_INSTANTIATION (fld))
27865 : 0 : instantiate_decl (fld,
27866 : : /*defer_ok=*/false,
27867 : : /*expl_inst_class_mem_p=*/false);
27868 : :
27869 : 0 : if (COMPLETE_TYPE_P (instantiation))
27870 : 0 : reconsider = 1;
27871 : : }
27872 : :
27873 : 0 : complete = COMPLETE_TYPE_P (instantiation);
27874 : : }
27875 : : else
27876 : : {
27877 : 17436406 : if (!DECL_TEMPLATE_SPECIALIZATION (instantiation)
27878 : 17436406 : && !DECL_TEMPLATE_INSTANTIATED (instantiation))
27879 : : {
27880 : 13469003 : instantiation
27881 : 13469003 : = instantiate_decl (instantiation,
27882 : : /*defer_ok=*/false,
27883 : : /*expl_inst_class_mem_p=*/false);
27884 : 13468994 : if (DECL_TEMPLATE_INSTANTIATED (instantiation))
27885 : 10972642 : reconsider = 1;
27886 : : }
27887 : :
27888 : 17436397 : complete = (DECL_TEMPLATE_SPECIALIZATION (instantiation)
27889 : 17436397 : || DECL_TEMPLATE_INSTANTIATED (instantiation));
27890 : : }
27891 : :
27892 : 0 : if (complete)
27893 : : {
27894 : : /* If INSTANTIATION has been instantiated, then we don't
27895 : : need to consider it again in the future. */
27896 : 14940045 : struct pending_template *drop = *t;
27897 : 14940045 : *t = (*t)->next;
27898 : 14940045 : set_refcount_ptr (drop->tinst);
27899 : 14940045 : pending_template_freelist ().free (drop);
27900 : : }
27901 : : else
27902 : : {
27903 : 2496352 : last = *t;
27904 : 2496352 : t = &(*t)->next;
27905 : : }
27906 : 17436397 : tinst_depth = 0;
27907 : 17436397 : set_refcount_ptr (current_tinst_level);
27908 : : }
27909 : 171445 : last_pending_template = last;
27910 : : }
27911 : 171445 : while (reconsider);
27912 : :
27913 : 136210 : input_location = saved_loc;
27914 : : }
27915 : :
27916 : : /* Substitute ARGVEC into T, which is a list of initializers for
27917 : : either base class or a non-static data member. The TREE_PURPOSEs
27918 : : are DECLs, and the TREE_VALUEs are the initializer values. Used by
27919 : : instantiate_decl. */
27920 : :
27921 : : static tree
27922 : 2361307 : tsubst_initializer_list (tree t, tree argvec)
27923 : : {
27924 : 2361307 : tree inits = NULL_TREE;
27925 : 2361307 : tree target_ctor = error_mark_node;
27926 : :
27927 : 5040914 : for (; t; t = TREE_CHAIN (t))
27928 : : {
27929 : 2679610 : tree decl;
27930 : 2679610 : tree init;
27931 : 2679610 : tree expanded_bases = NULL_TREE;
27932 : 2679610 : tree expanded_arguments = NULL_TREE;
27933 : 2679610 : int i, len = 1;
27934 : :
27935 : 2679610 : if (TREE_CODE (TREE_PURPOSE (t)) == TYPE_PACK_EXPANSION)
27936 : : {
27937 : 30 : tree expr;
27938 : 30 : tree arg;
27939 : :
27940 : : /* Expand the base class expansion type into separate base
27941 : : classes. */
27942 : 30 : expanded_bases = tsubst_pack_expansion (TREE_PURPOSE (t), argvec,
27943 : : tf_warning_or_error,
27944 : : NULL_TREE);
27945 : 30 : if (expanded_bases == error_mark_node)
27946 : 0 : continue;
27947 : :
27948 : : /* We'll be building separate TREE_LISTs of arguments for
27949 : : each base. */
27950 : 30 : len = TREE_VEC_LENGTH (expanded_bases);
27951 : 30 : expanded_arguments = make_tree_vec (len);
27952 : 105 : for (i = 0; i < len; i++)
27953 : 45 : TREE_VEC_ELT (expanded_arguments, i) = NULL_TREE;
27954 : :
27955 : : /* Build a dummy EXPR_PACK_EXPANSION that will be used to
27956 : : expand each argument in the TREE_VALUE of t. */
27957 : 30 : expr = make_node (EXPR_PACK_EXPANSION);
27958 : 30 : PACK_EXPANSION_LOCAL_P (expr) = true;
27959 : 60 : PACK_EXPANSION_PARAMETER_PACKS (expr) =
27960 : 30 : PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t));
27961 : :
27962 : 30 : if (TREE_VALUE (t) == void_type_node)
27963 : : /* VOID_TYPE_NODE is used to indicate
27964 : : value-initialization. */
27965 : : {
27966 : 9 : for (i = 0; i < len; i++)
27967 : 3 : TREE_VEC_ELT (expanded_arguments, i) = void_type_node;
27968 : : }
27969 : : else
27970 : : {
27971 : : /* Substitute parameter packs into each argument in the
27972 : : TREE_LIST. */
27973 : 24 : in_base_initializer = 1;
27974 : 57 : for (arg = TREE_VALUE (t); arg; arg = TREE_CHAIN (arg))
27975 : : {
27976 : 33 : tree expanded_exprs;
27977 : :
27978 : : /* Expand the argument. */
27979 : 33 : tree value;
27980 : 33 : if (TREE_CODE (TREE_VALUE (arg)) == EXPR_PACK_EXPANSION)
27981 : : value = TREE_VALUE (arg);
27982 : : else
27983 : : {
27984 : 30 : value = expr;
27985 : 30 : PACK_EXPANSION_PATTERN (value) = TREE_VALUE (arg);
27986 : : }
27987 : 33 : expanded_exprs
27988 : 33 : = tsubst_pack_expansion (value, argvec,
27989 : : tf_warning_or_error,
27990 : : NULL_TREE);
27991 : 33 : if (expanded_exprs == error_mark_node)
27992 : 3 : continue;
27993 : :
27994 : : /* Prepend each of the expanded expressions to the
27995 : : corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
27996 : 93 : for (i = 0; i < len; i++)
27997 : 63 : if (TREE_CODE (TREE_VALUE (arg)) == EXPR_PACK_EXPANSION)
27998 : 36 : for (int j = 0; j < TREE_VEC_LENGTH (expanded_exprs); j++)
27999 : 27 : TREE_VEC_ELT (expanded_arguments, i)
28000 : 54 : = tree_cons (NULL_TREE,
28001 : 27 : TREE_VEC_ELT (expanded_exprs, j),
28002 : 27 : TREE_VEC_ELT (expanded_arguments, i));
28003 : : else
28004 : 54 : TREE_VEC_ELT (expanded_arguments, i)
28005 : 108 : = tree_cons (NULL_TREE,
28006 : 54 : TREE_VEC_ELT (expanded_exprs, i),
28007 : 54 : TREE_VEC_ELT (expanded_arguments, i));
28008 : : }
28009 : 24 : in_base_initializer = 0;
28010 : :
28011 : : /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
28012 : : since we built them backwards. */
28013 : 66 : for (i = 0; i < len; i++)
28014 : : {
28015 : 42 : TREE_VEC_ELT (expanded_arguments, i) =
28016 : 42 : nreverse (TREE_VEC_ELT (expanded_arguments, i));
28017 : : }
28018 : : }
28019 : : }
28020 : :
28021 : 5359232 : for (i = 0; i < len; ++i)
28022 : : {
28023 : 2679625 : if (expanded_bases)
28024 : : {
28025 : 45 : decl = TREE_VEC_ELT (expanded_bases, i);
28026 : 45 : decl = expand_member_init (decl);
28027 : 45 : init = TREE_VEC_ELT (expanded_arguments, i);
28028 : : }
28029 : : else
28030 : : {
28031 : 2679580 : tree tmp;
28032 : 2679580 : if (TYPE_P (TREE_PURPOSE (t)))
28033 : 520555 : decl = tsubst (TREE_PURPOSE (t), argvec,
28034 : : tf_warning_or_error, NULL_TREE);
28035 : : else
28036 : 2159025 : decl = tsubst_expr (TREE_PURPOSE (t), argvec,
28037 : : tf_warning_or_error, NULL_TREE);
28038 : :
28039 : 2679580 : decl = expand_member_init (decl);
28040 : 2679580 : if (decl && !DECL_P (decl))
28041 : 520549 : in_base_initializer = 1;
28042 : :
28043 : 2679580 : init = TREE_VALUE (t);
28044 : 2679580 : tmp = init;
28045 : 2679580 : if (init != void_type_node)
28046 : 2253673 : init = tsubst_expr (init, argvec,
28047 : : tf_warning_or_error, NULL_TREE);
28048 : 2679580 : if (init == NULL_TREE && tmp != NULL_TREE)
28049 : : /* If we had an initializer but it instantiated to nothing,
28050 : : value-initialize the object. This will only occur when
28051 : : the initializer was a pack expansion where the parameter
28052 : : packs used in that expansion were of length zero. */
28053 : 608 : init = void_type_node;
28054 : 2679580 : in_base_initializer = 0;
28055 : : }
28056 : :
28057 : 2679625 : if (target_ctor != error_mark_node
28058 : 3 : && init != error_mark_node)
28059 : : {
28060 : 3 : error ("mem-initializer for %qD follows constructor delegation",
28061 : : decl);
28062 : 3 : return inits;
28063 : : }
28064 : : /* Look for a target constructor. */
28065 : 2679622 : if (init != error_mark_node
28066 : 2679610 : && decl && CLASS_TYPE_P (decl)
28067 : 2684564 : && same_type_p (decl, current_class_type))
28068 : : {
28069 : 4942 : maybe_warn_cpp0x (CPP0X_DELEGATING_CTORS);
28070 : 4942 : if (inits)
28071 : : {
28072 : 0 : error ("constructor delegation follows mem-initializer for %qD",
28073 : 0 : TREE_PURPOSE (inits));
28074 : 0 : continue;
28075 : : }
28076 : : target_ctor = init;
28077 : : }
28078 : :
28079 : 2679622 : if (decl)
28080 : : {
28081 : 2679616 : init = build_tree_list (decl, init);
28082 : : /* Carry over the dummy TREE_TYPE node containing the source
28083 : : location. */
28084 : 2679616 : TREE_TYPE (init) = TREE_TYPE (t);
28085 : 2679616 : TREE_CHAIN (init) = inits;
28086 : 2679616 : inits = init;
28087 : : }
28088 : : }
28089 : : }
28090 : : return inits;
28091 : : }
28092 : :
28093 : : /* Instantiate an enumerated type. TAG is the template type, NEWTAG
28094 : : is the instantiation (which should have been created with
28095 : : start_enum) and ARGS are the template arguments to use. */
28096 : :
28097 : : static void
28098 : 326422 : tsubst_enum (tree tag, tree newtag, tree args)
28099 : : {
28100 : 326422 : tree e;
28101 : :
28102 : 326422 : if (SCOPED_ENUM_P (newtag))
28103 : 351 : begin_scope (sk_scoped_enum, newtag);
28104 : :
28105 : 673610 : for (e = TYPE_VALUES (tag); e; e = TREE_CHAIN (e))
28106 : : {
28107 : 347233 : tree value;
28108 : 347233 : tree decl = TREE_VALUE (e);
28109 : :
28110 : : /* Note that in a template enum, the TREE_VALUE is the
28111 : : CONST_DECL, not the corresponding INTEGER_CST. */
28112 : 347233 : value = tsubst_expr (DECL_INITIAL (decl),
28113 : : args, tf_warning_or_error, NULL_TREE);
28114 : :
28115 : : /* Give this enumeration constant the correct access. */
28116 : 347188 : set_current_access_from_decl (decl);
28117 : :
28118 : : /* Actually build the enumerator itself. Here we're assuming that
28119 : : enumerators can't have dependent attributes. */
28120 : 347188 : tree newdecl = build_enumerator (DECL_NAME (decl), value, newtag,
28121 : 347188 : DECL_ATTRIBUTES (decl),
28122 : 347188 : DECL_SOURCE_LOCATION (decl));
28123 : : /* Attribute deprecated without an argument isn't sticky: it'll
28124 : : melt into a tree flag, so we need to propagate the flag here,
28125 : : since we just created a new enumerator. */
28126 : 347188 : TREE_DEPRECATED (newdecl) = TREE_DEPRECATED (decl);
28127 : 347188 : TREE_UNAVAILABLE (newdecl) = TREE_UNAVAILABLE (decl);
28128 : : }
28129 : :
28130 : 326377 : if (SCOPED_ENUM_P (newtag))
28131 : 351 : finish_scope ();
28132 : :
28133 : 326377 : finish_enum_value_list (newtag);
28134 : 326377 : finish_enum (newtag);
28135 : :
28136 : 326377 : DECL_SOURCE_LOCATION (TYPE_NAME (newtag))
28137 : 326377 : = DECL_SOURCE_LOCATION (TYPE_NAME (tag));
28138 : 326377 : TREE_DEPRECATED (newtag) = TREE_DEPRECATED (tag);
28139 : 326377 : TREE_UNAVAILABLE (newtag) = TREE_UNAVAILABLE (tag);
28140 : 326377 : }
28141 : :
28142 : : /* DECL is a FUNCTION_DECL that is a template specialization. Return
28143 : : its type -- but without substituting the innermost set of template
28144 : : arguments. So, innermost set of template parameters will appear in
28145 : : the type. */
28146 : :
28147 : : tree
28148 : 12358771 : get_mostly_instantiated_function_type (tree decl)
28149 : : {
28150 : : /* For a function, DECL_TI_TEMPLATE is partially instantiated. */
28151 : 12358771 : return TREE_TYPE (DECL_TI_TEMPLATE (decl));
28152 : : }
28153 : :
28154 : : /* Return truthvalue if we're processing a template different from
28155 : : the last one involved in diagnostics. */
28156 : : bool
28157 : 204219 : problematic_instantiation_changed (void)
28158 : : {
28159 : 204219 : return current_tinst_level != last_error_tinst_level;
28160 : : }
28161 : :
28162 : : /* Remember current template involved in diagnostics. */
28163 : : void
28164 : 4851 : record_last_problematic_instantiation (void)
28165 : : {
28166 : 4851 : set_refcount_ptr (last_error_tinst_level, current_tinst_level);
28167 : 4851 : }
28168 : :
28169 : : struct tinst_level *
28170 : 272290593 : current_instantiation (void)
28171 : : {
28172 : 272290593 : return current_tinst_level;
28173 : : }
28174 : :
28175 : : /* Return TRUE if current_function_decl is being instantiated, false
28176 : : otherwise. */
28177 : :
28178 : : bool
28179 : 192295009 : instantiating_current_function_p (void)
28180 : : {
28181 : 192295009 : return (current_instantiation ()
28182 : 192295009 : && (current_instantiation ()->maybe_get_node ()
28183 : 1983278 : == current_function_decl));
28184 : : }
28185 : :
28186 : : /* [temp.param] Check that template non-type parm TYPE is of an allowable
28187 : : type. Return false for ok, true for disallowed. Issue error and
28188 : : inform messages under control of COMPLAIN. */
28189 : :
28190 : : static bool
28191 : 148111153 : invalid_nontype_parm_type_p (tree type, tsubst_flags_t complain)
28192 : : {
28193 : 148111153 : if (INTEGRAL_OR_ENUMERATION_TYPE_P (type))
28194 : : return false;
28195 : 4595490 : else if (TYPE_PTR_P (type))
28196 : : return false;
28197 : 4593283 : else if (TYPE_REF_P (type)
28198 : 4593283 : && !TYPE_REF_IS_RVALUE (type))
28199 : : return false;
28200 : 4592452 : else if (TYPE_PTRMEM_P (type))
28201 : : return false;
28202 : 4589178 : else if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
28203 : : {
28204 : 2412206 : if (CLASS_PLACEHOLDER_TEMPLATE (type) && cxx_dialect < cxx20)
28205 : : {
28206 : 1 : if (complain & tf_error)
28207 : 1 : error ("non-type template parameters of deduced class type only "
28208 : : "available with %<-std=c++20%> or %<-std=gnu++20%>");
28209 : 1 : return true;
28210 : : }
28211 : : return false;
28212 : : }
28213 : 2176972 : else if (TREE_CODE (type) == NULLPTR_TYPE)
28214 : : return false;
28215 : 2176939 : else if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM
28216 : 15 : && cxx_dialect < cxx11)
28217 : : /* Fall through; before C++11 alias templates, a bound ttp
28218 : : always instantiates into a class type. */;
28219 : 2176939 : else if (WILDCARD_TYPE_P (type))
28220 : : /* Any other wildcard type not already handled above is allowed. */
28221 : : return false;
28222 : : else if (TREE_CODE (type) == COMPLEX_TYPE)
28223 : : /* Fall through. */;
28224 : : else if (VOID_TYPE_P (type))
28225 : : /* Fall through. */;
28226 : 2309 : else if (cxx_dialect >= cxx20)
28227 : : {
28228 : 2236 : if (dependent_type_p (type))
28229 : : return false;
28230 : 2181 : if (!complete_type_or_maybe_complain (type, NULL_TREE, complain))
28231 : : return true;
28232 : 2151 : if (structural_type_p (type))
28233 : : return false;
28234 : 11 : if (complain & tf_error)
28235 : : {
28236 : 7 : auto_diagnostic_group d;
28237 : 7 : error ("%qT is not a valid type for a template non-type "
28238 : : "parameter because it is not structural", type);
28239 : 7 : structural_type_p (type, true);
28240 : 7 : }
28241 : 11 : return true;
28242 : : }
28243 : 73 : else if (CLASS_TYPE_P (type))
28244 : : {
28245 : 16 : if (complain & tf_error)
28246 : 12 : error ("non-type template parameters of class type only available "
28247 : : "with %<-std=c++20%> or %<-std=gnu++20%>");
28248 : 16 : return true;
28249 : : }
28250 : :
28251 : 143 : if (complain & tf_error)
28252 : : {
28253 : 137 : if (type == error_mark_node)
28254 : 15 : inform (input_location, "invalid template non-type parameter");
28255 : : else
28256 : 122 : error ("%q#T is not a valid type for a template non-type parameter",
28257 : : type);
28258 : : }
28259 : : return true;
28260 : : }
28261 : :
28262 : : /* Returns true iff the noexcept-specifier for TYPE is value-dependent. */
28263 : :
28264 : : static bool
28265 : 7034760 : value_dependent_noexcept_spec_p (tree type)
28266 : : {
28267 : 7034760 : if (tree spec = TYPE_RAISES_EXCEPTIONS (type))
28268 : 2915867 : if (tree noex = TREE_PURPOSE (spec))
28269 : : /* Treat DEFERRED_NOEXCEPT as non-dependent, since it doesn't
28270 : : affect overload resolution and treating it as dependent breaks
28271 : : things. Same for an unparsed noexcept expression. */
28272 : 2915560 : if (TREE_CODE (noex) != DEFERRED_NOEXCEPT
28273 : 2915560 : && TREE_CODE (noex) != DEFERRED_PARSE
28274 : 2915560 : && value_dependent_expression_p (noex))
28275 : : return true;
28276 : :
28277 : : return false;
28278 : : }
28279 : :
28280 : : /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
28281 : : Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
28282 : :
28283 : : static bool
28284 : 453065926 : dependent_type_p_r (tree type)
28285 : : {
28286 : 453065926 : tree scope;
28287 : :
28288 : : /* [temp.dep.type]
28289 : :
28290 : : A type is dependent if it is:
28291 : :
28292 : : -- a template parameter. Template template parameters are types
28293 : : for us (since TYPE_P holds true for them) so we handle
28294 : : them here. */
28295 : 453065926 : if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
28296 : 453065926 : || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM)
28297 : : return true;
28298 : : /* -- a qualified-id with a nested-name-specifier which contains a
28299 : : class-name that names a dependent type or whose unqualified-id
28300 : : names a dependent type. */
28301 : 357881915 : if (TREE_CODE (type) == TYPENAME_TYPE)
28302 : : return true;
28303 : :
28304 : : /* -- a cv-qualified type where the cv-unqualified type is
28305 : : dependent.
28306 : : No code is necessary for this bullet; the code below handles
28307 : : cv-qualified types, and we don't want to strip aliases with
28308 : : TYPE_MAIN_VARIANT because of DR 1558. */
28309 : : /* -- a compound type constructed from any dependent type. */
28310 : 337601949 : if (TYPE_PTRMEM_P (type))
28311 : 982645 : return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type))
28312 : 982645 : || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
28313 : : (type)));
28314 : 336619304 : else if (INDIRECT_TYPE_P (type))
28315 : 64681419 : return dependent_type_p (TREE_TYPE (type));
28316 : 271937885 : else if (FUNC_OR_METHOD_TYPE_P (type))
28317 : : {
28318 : 67502130 : tree arg_type;
28319 : :
28320 : 67502130 : if (dependent_type_p (TREE_TYPE (type)))
28321 : : return true;
28322 : 38521286 : for (arg_type = TYPE_ARG_TYPES (type);
28323 : 59216226 : arg_type;
28324 : 20694940 : arg_type = TREE_CHAIN (arg_type))
28325 : 52120440 : if (dependent_type_p (TREE_VALUE (arg_type)))
28326 : : return true;
28327 : 7095786 : if (cxx_dialect >= cxx17
28328 : 7095786 : && value_dependent_noexcept_spec_p (type))
28329 : : /* A value-dependent noexcept-specifier makes the type dependent. */
28330 : : return true;
28331 : 7095750 : return false;
28332 : : }
28333 : : /* -- an array type constructed from any dependent type or whose
28334 : : size is specified by a constant expression that is
28335 : : value-dependent.
28336 : :
28337 : : We checked for type- and value-dependence of the bounds in
28338 : : compute_array_index_type, so TYPE_DEPENDENT_P is already set. */
28339 : 204435755 : if (TREE_CODE (type) == ARRAY_TYPE)
28340 : : {
28341 : 11342 : if (TYPE_DOMAIN (type)
28342 : 11342 : && dependent_type_p (TYPE_DOMAIN (type)))
28343 : : return true;
28344 : 11342 : return dependent_type_p (TREE_TYPE (type));
28345 : : }
28346 : :
28347 : : /* -- a template-id in which either the template name is a template
28348 : : parameter ... */
28349 : 204424413 : if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
28350 : : return true;
28351 : : /* ... or any of the template arguments is a dependent type or
28352 : : an expression that is type-dependent or value-dependent. */
28353 : 101275912 : else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INFO (type)
28354 : 301002929 : && (any_dependent_template_arguments_p
28355 : 96800197 : (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type)))))
28356 : : return true;
28357 : :
28358 : : /* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and TRAIT_TYPEs are
28359 : : dependent; if the argument of the `typeof' expression is not
28360 : : type-dependent, then it should already been have resolved. */
28361 : 139377297 : if (TREE_CODE (type) == TYPEOF_TYPE
28362 : 120872962 : || TREE_CODE (type) == DECLTYPE_TYPE
28363 : 117265373 : || TREE_CODE (type) == TRAIT_TYPE)
28364 : : return true;
28365 : :
28366 : : /* A template argument pack is dependent if any of its packed
28367 : : arguments are. */
28368 : 117026145 : if (TREE_CODE (type) == TYPE_ARGUMENT_PACK)
28369 : : {
28370 : 246 : tree args = ARGUMENT_PACK_ARGS (type);
28371 : 294 : for (tree arg : tree_vec_range (args))
28372 : 237 : if (dependent_template_arg_p (arg))
28373 : 189 : return true;
28374 : : }
28375 : :
28376 : : /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
28377 : : be template parameters. This includes pack-index-specifiers. */
28378 : 117025956 : if (TREE_CODE (type) == TYPE_PACK_EXPANSION
28379 : 106803724 : || TREE_CODE (type) == PACK_INDEX_TYPE)
28380 : : return true;
28381 : :
28382 : 106803683 : if (TREE_CODE (type) == DEPENDENT_OPERATOR_TYPE)
28383 : : return true;
28384 : :
28385 : 39583680 : if (any_dependent_type_attributes_p (TYPE_ATTRIBUTES (type)))
28386 : : return true;
28387 : :
28388 : : /* The standard does not specifically mention types that are local
28389 : : to template functions or local classes, but they should be
28390 : : considered dependent too. For example:
28391 : :
28392 : : template <int I> void f() {
28393 : : enum E { a = I };
28394 : : S<sizeof (E)> s;
28395 : : }
28396 : :
28397 : : The size of `E' cannot be known until the value of `I' has been
28398 : : determined. Therefore, `E' must be considered dependent. */
28399 : 39583680 : scope = TYPE_CONTEXT (type);
28400 : 39583680 : if (scope && TYPE_P (scope))
28401 : 2282338 : return dependent_type_p (scope);
28402 : : /* Don't use type_dependent_expression_p here, as it can lead
28403 : : to infinite recursion trying to determine whether a lambda
28404 : : nested in a lambda is dependent (c++/47687). */
28405 : 34908557 : else if (scope && TREE_CODE (scope) == FUNCTION_DECL
28406 : 816851 : && DECL_LANG_SPECIFIC (scope)
28407 : 816851 : && DECL_TEMPLATE_INFO (scope)
28408 : 705555 : && (any_dependent_template_arguments_p
28409 : 705555 : (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (scope)))))
28410 : : return true;
28411 : :
28412 : : /* Other types are non-dependent. */
28413 : : return false;
28414 : : }
28415 : :
28416 : : /* Returns TRUE if TYPE is dependent, in the sense of
28417 : : [temp.dep.type]. Note that a NULL type is considered dependent. */
28418 : :
28419 : : bool
28420 : 14527286289 : dependent_type_p (tree type)
28421 : : {
28422 : : /* If there are no template parameters in scope, then there can't be
28423 : : any dependent types. */
28424 : 14527286289 : if (!processing_template_decl)
28425 : : {
28426 : : /* If we are not processing a template, then nobody should be
28427 : : providing us with a dependent type. */
28428 : 2424950499 : gcc_assert (type);
28429 : 2424950499 : gcc_assert (TREE_CODE (type) != TEMPLATE_TYPE_PARM || is_auto (type)
28430 : : || seen_error ());
28431 : 2424950499 : return false;
28432 : : }
28433 : :
28434 : : /* If the type is NULL, we have not computed a type for the entity
28435 : : in question; in that case, the type is dependent. */
28436 : 12102335790 : if (!type)
28437 : : return true;
28438 : :
28439 : : /* Erroneous types can be considered non-dependent. */
28440 : 11868550983 : if (type == error_mark_node)
28441 : : return false;
28442 : :
28443 : : /* If we have not already computed the appropriate value for TYPE,
28444 : : do so now. */
28445 : 11868550866 : if (!TYPE_DEPENDENT_P_VALID (type))
28446 : : {
28447 : 453065926 : TYPE_DEPENDENT_P (type) = dependent_type_p_r (type);
28448 : 453065926 : TYPE_DEPENDENT_P_VALID (type) = 1;
28449 : : }
28450 : :
28451 : 11868550866 : return TYPE_DEPENDENT_P (type);
28452 : : }
28453 : :
28454 : : /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
28455 : : lookup. In other words, a dependent type that is not the current
28456 : : instantiation. */
28457 : :
28458 : : bool
28459 : 1094809662 : dependent_scope_p (tree scope)
28460 : : {
28461 : 1094809662 : return (scope && TYPE_P (scope) && dependent_type_p (scope)
28462 : 1829312026 : && !currently_open_class (scope));
28463 : : }
28464 : :
28465 : : /* True if we might find more declarations in SCOPE during instantiation than
28466 : : we can when parsing the template. */
28467 : :
28468 : : bool
28469 : 371519745 : dependentish_scope_p (tree scope)
28470 : : {
28471 : 371519745 : return dependent_scope_p (scope) || any_dependent_bases_p (scope);
28472 : : }
28473 : :
28474 : : /* T is a SCOPE_REF. Return whether it represents a non-static member of
28475 : : an unknown base of 'this' (and is therefore instantiation-dependent). */
28476 : :
28477 : : static bool
28478 : 5119909 : unknown_base_ref_p (tree t)
28479 : : {
28480 : 5119909 : if (!current_class_ptr)
28481 : : return false;
28482 : :
28483 : 3001594 : tree mem = TREE_OPERAND (t, 1);
28484 : 3001594 : if (shared_member_p (mem))
28485 : : return false;
28486 : :
28487 : 7 : tree cur = current_nonlambda_class_type ();
28488 : 7 : if (!any_dependent_bases_p (cur))
28489 : : return false;
28490 : :
28491 : 0 : tree ctx = TREE_OPERAND (t, 0);
28492 : 0 : if (DERIVED_FROM_P (ctx, cur))
28493 : : return false;
28494 : :
28495 : : return true;
28496 : : }
28497 : :
28498 : : /* T is a SCOPE_REF; return whether we need to consider it
28499 : : instantiation-dependent so that we can check access at instantiation
28500 : : time even though we know which member it resolves to. */
28501 : :
28502 : : static bool
28503 : 9624913 : instantiation_dependent_scope_ref_p (tree t)
28504 : : {
28505 : 9624913 : if (DECL_P (TREE_OPERAND (t, 1))
28506 : 5119921 : && CLASS_TYPE_P (TREE_OPERAND (t, 0))
28507 : 5119921 : && !dependent_scope_p (TREE_OPERAND (t, 0))
28508 : 5119909 : && !unknown_base_ref_p (t)
28509 : 14744822 : && accessible_in_template_p (TREE_OPERAND (t, 0),
28510 : 5119909 : TREE_OPERAND (t, 1)))
28511 : : return false;
28512 : : else
28513 : 4505226 : return true;
28514 : : }
28515 : :
28516 : : /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
28517 : : [temp.dep.constexpr]. EXPRESSION is already known to be a constant
28518 : : expression. */
28519 : :
28520 : : /* Note that this predicate is not appropriate for general expressions;
28521 : : only constant expressions (that satisfy potential_constant_expression)
28522 : : can be tested for value dependence. */
28523 : :
28524 : : bool
28525 : 1013017059 : value_dependent_expression_p (tree expression)
28526 : : {
28527 : 1034503516 : if (!processing_template_decl || expression == NULL_TREE)
28528 : : return false;
28529 : :
28530 : : /* A type-dependent expression is also value-dependent. */
28531 : 823647061 : if (type_dependent_expression_p (expression))
28532 : : return true;
28533 : :
28534 : 689217460 : switch (TREE_CODE (expression))
28535 : : {
28536 : 4667262 : case BASELINK:
28537 : : /* A dependent member function of the current instantiation. */
28538 : 4667262 : return dependent_type_p (BINFO_TYPE (BASELINK_BINFO (expression)));
28539 : :
28540 : 6631916 : case FUNCTION_DECL:
28541 : : /* A dependent member function of the current instantiation. */
28542 : 13263593 : if (DECL_CLASS_SCOPE_P (expression)
28543 : 10057181 : && dependent_type_p (DECL_CONTEXT (expression)))
28544 : : return true;
28545 : : break;
28546 : :
28547 : : case IDENTIFIER_NODE:
28548 : : /* A name that has not been looked up -- must be dependent. */
28549 : : return true;
28550 : :
28551 : : case TEMPLATE_PARM_INDEX:
28552 : : /* A non-type template parm. */
28553 : : return true;
28554 : :
28555 : 733689 : case CONST_DECL:
28556 : : /* A non-type template parm. */
28557 : 733689 : if (DECL_TEMPLATE_PARM_P (expression))
28558 : : return true;
28559 : 733689 : return value_dependent_expression_p (DECL_INITIAL (expression));
28560 : :
28561 : 16025051 : case VAR_DECL:
28562 : : /* A constant with literal type and is initialized
28563 : : with an expression that is value-dependent. */
28564 : 16025051 : if (DECL_DEPENDENT_INIT_P (expression))
28565 : : return true;
28566 : 9334685 : if (DECL_HAS_VALUE_EXPR_P (expression))
28567 : : {
28568 : 104248 : tree value_expr = DECL_VALUE_EXPR (expression);
28569 : 104248 : if (value_dependent_expression_p (value_expr)
28570 : : /* __PRETTY_FUNCTION__ inside a template function is dependent
28571 : : on the name of the function. */
28572 : 104248 : || (DECL_PRETTY_FUNCTION_P (expression)
28573 : : /* It might be used in a template, but not a template
28574 : : function, in which case its DECL_VALUE_EXPR will be
28575 : : "top level". */
28576 : 5 : && value_expr == error_mark_node))
28577 : : return true;
28578 : : }
28579 : 9230437 : else if (TYPE_REF_P (TREE_TYPE (expression)))
28580 : : /* FIXME cp_finish_decl doesn't fold reference initializers. */
28581 : : return true;
28582 : : /* We have a constexpr variable and we're processing a template. When
28583 : : there's lifetime extension involved (for which finish_compound_literal
28584 : : used to create a temporary), we'll not be able to evaluate the
28585 : : variable until instantiating, so pretend it's value-dependent. */
28586 : 9226322 : else if (DECL_DECLARED_CONSTEXPR_P (expression)
28587 : 9226322 : && !TREE_CONSTANT (expression))
28588 : : return true;
28589 : : return false;
28590 : :
28591 : 23680526 : case DYNAMIC_CAST_EXPR:
28592 : 23680526 : case STATIC_CAST_EXPR:
28593 : 23680526 : case CONST_CAST_EXPR:
28594 : 23680526 : case REINTERPRET_CAST_EXPR:
28595 : 23680526 : case CAST_EXPR:
28596 : 23680526 : case IMPLICIT_CONV_EXPR:
28597 : : /* These expressions are value-dependent if the type to which
28598 : : the cast occurs is dependent or the expression being casted
28599 : : is value-dependent. */
28600 : 23680526 : {
28601 : 23680526 : tree type = TREE_TYPE (expression);
28602 : :
28603 : 23680526 : if (dependent_type_p (type))
28604 : : return true;
28605 : :
28606 : : /* A functional cast has a list of operands. */
28607 : 23680526 : expression = TREE_OPERAND (expression, 0);
28608 : 23680526 : if (!expression)
28609 : : {
28610 : : /* If there are no operands, it must be an expression such
28611 : : as "int()". This should not happen for aggregate types
28612 : : because it would form non-constant expressions. */
28613 : 118 : gcc_assert (cxx_dialect >= cxx11
28614 : : || INTEGRAL_OR_ENUMERATION_TYPE_P (type));
28615 : :
28616 : : return false;
28617 : : }
28618 : :
28619 : 23680408 : if (TREE_CODE (expression) == TREE_LIST)
28620 : 2927615 : return any_value_dependent_elements_p (expression);
28621 : :
28622 : 20752793 : if (TREE_CODE (type) == REFERENCE_TYPE
28623 : 20752793 : && has_value_dependent_address (expression))
28624 : : return true;
28625 : :
28626 : 20752768 : return value_dependent_expression_p (expression);
28627 : : }
28628 : :
28629 : 6721254 : case SIZEOF_EXPR:
28630 : 6721254 : if (SIZEOF_EXPR_TYPE_P (expression))
28631 : 0 : return dependent_type_p (TREE_TYPE (TREE_OPERAND (expression, 0)));
28632 : : /* FALLTHRU */
28633 : 7324485 : case ALIGNOF_EXPR:
28634 : 7324485 : case TYPEID_EXPR:
28635 : : /* A `sizeof' expression is value-dependent if the operand is
28636 : : type-dependent or is a pack expansion. */
28637 : 7324485 : expression = TREE_OPERAND (expression, 0);
28638 : 7324485 : if (PACK_EXPANSION_P (expression))
28639 : : return true;
28640 : 3690010 : else if (TYPE_P (expression))
28641 : 3578291 : return dependent_type_p (expression);
28642 : 111719 : return instantiation_dependent_uneval_expression_p (expression);
28643 : :
28644 : 0 : case AT_ENCODE_EXPR:
28645 : : /* An 'encode' expression is value-dependent if the operand is
28646 : : type-dependent. */
28647 : 0 : expression = TREE_OPERAND (expression, 0);
28648 : 0 : return dependent_type_p (expression);
28649 : :
28650 : 589553 : case NOEXCEPT_EXPR:
28651 : 589553 : expression = TREE_OPERAND (expression, 0);
28652 : 589553 : return instantiation_dependent_uneval_expression_p (expression);
28653 : :
28654 : 3054376 : case SCOPE_REF:
28655 : : /* All instantiation-dependent expressions should also be considered
28656 : : value-dependent. */
28657 : 3054376 : return instantiation_dependent_scope_ref_p (expression);
28658 : :
28659 : 958449 : case COMPONENT_REF:
28660 : 958449 : return (value_dependent_expression_p (TREE_OPERAND (expression, 0))
28661 : 958449 : || value_dependent_expression_p (TREE_OPERAND (expression, 1)));
28662 : :
28663 : 0 : case NONTYPE_ARGUMENT_PACK:
28664 : : /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
28665 : : is value-dependent. */
28666 : 0 : for (tree arg : tree_vec_range (ARGUMENT_PACK_ARGS (expression)))
28667 : 0 : if (value_dependent_expression_p (arg))
28668 : 0 : return true;
28669 : 0 : return false;
28670 : :
28671 : 14979299 : case TRAIT_EXPR:
28672 : 14979299 : {
28673 : 14979299 : if (dependent_type_p (TRAIT_EXPR_TYPE1 (expression)))
28674 : : return true;
28675 : :
28676 : 23199 : tree type2 = TRAIT_EXPR_TYPE2 (expression);
28677 : 23199 : if (!type2)
28678 : : return false;
28679 : :
28680 : 23195 : if (TREE_CODE (type2) != TREE_VEC)
28681 : 23155 : return dependent_type_p (type2);
28682 : :
28683 : 52 : for (tree arg : tree_vec_range (type2))
28684 : 37 : if (dependent_type_p (arg))
28685 : 25 : return true;
28686 : :
28687 : 15 : return false;
28688 : : }
28689 : :
28690 : 28 : case MODOP_EXPR:
28691 : 28 : return ((value_dependent_expression_p (TREE_OPERAND (expression, 0)))
28692 : 28 : || (value_dependent_expression_p (TREE_OPERAND (expression, 2))));
28693 : :
28694 : 245367 : case ARRAY_REF:
28695 : 245367 : return ((value_dependent_expression_p (TREE_OPERAND (expression, 0)))
28696 : 245367 : || (value_dependent_expression_p (TREE_OPERAND (expression, 1))));
28697 : :
28698 : 48589 : case ADDR_EXPR:
28699 : 48589 : {
28700 : 48589 : tree op = TREE_OPERAND (expression, 0);
28701 : 48589 : return (value_dependent_expression_p (op)
28702 : 48589 : || has_value_dependent_address (op));
28703 : : }
28704 : :
28705 : : case REQUIRES_EXPR:
28706 : : /* Treat all requires-expressions as value-dependent so
28707 : : we don't try to fold them. */
28708 : : return true;
28709 : :
28710 : 0 : case TYPE_REQ:
28711 : 0 : return dependent_type_p (TREE_OPERAND (expression, 0));
28712 : :
28713 : 6815397 : case CALL_EXPR:
28714 : 6815397 : {
28715 : 6815397 : if (value_dependent_expression_p (CALL_EXPR_FN (expression)))
28716 : : return true;
28717 : 6627938 : tree fn = get_callee_fndecl (expression);
28718 : 6627938 : int i, nargs;
28719 : 6627938 : nargs = call_expr_nargs (expression);
28720 : 7544846 : for (i = 0; i < nargs; ++i)
28721 : : {
28722 : 1329627 : tree op = CALL_EXPR_ARG (expression, i);
28723 : : /* In a call to a constexpr member function, look through the
28724 : : implicit ADDR_EXPR on the object argument so that it doesn't
28725 : : cause the call to be considered value-dependent. We also
28726 : : look through it in potential_constant_expression. */
28727 : 2098 : if (i == 0 && fn && DECL_DECLARED_CONSTEXPR_P (fn)
28728 : 2098 : && DECL_IOBJ_MEMBER_FUNCTION_P (fn)
28729 : 1329627 : && TREE_CODE (op) == ADDR_EXPR)
28730 : 0 : op = TREE_OPERAND (op, 0);
28731 : 1329627 : if (value_dependent_expression_p (op))
28732 : : return true;
28733 : : }
28734 : : return false;
28735 : : }
28736 : :
28737 : 2133505 : case TEMPLATE_ID_EXPR:
28738 : 2133505 : return concept_definition_p (TREE_OPERAND (expression, 0))
28739 : 2133505 : && any_dependent_template_arguments_p (TREE_OPERAND (expression, 1));
28740 : :
28741 : 2370337 : case CONSTRUCTOR:
28742 : 2370337 : {
28743 : 2370337 : unsigned ix;
28744 : 2370337 : tree val;
28745 : 2370337 : if (dependent_type_p (TREE_TYPE (expression)))
28746 : : return true;
28747 : 2436249 : FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression), ix, val)
28748 : 66157 : if (value_dependent_expression_p (val))
28749 : : return true;
28750 : : return false;
28751 : : }
28752 : :
28753 : : case STMT_EXPR:
28754 : : /* Treat a GNU statement expression as dependent to avoid crashing
28755 : : under instantiate_non_dependent_expr; it can't be constant. */
28756 : : return true;
28757 : :
28758 : 8 : case NEW_EXPR:
28759 : 8 : case VEC_NEW_EXPR:
28760 : : /* The second operand is a type, which type_dependent_expression_p
28761 : : (and therefore value_dependent_expression_p) doesn't want to see. */
28762 : 8 : return (value_dependent_expression_p (TREE_OPERAND (expression, 0))
28763 : 8 : || value_dependent_expression_p (TREE_OPERAND (expression, 2))
28764 : 16 : || value_dependent_expression_p (TREE_OPERAND (expression, 3)));
28765 : :
28766 : 501067879 : default:
28767 : : /* A constant expression is value-dependent if any subexpression is
28768 : : value-dependent. */
28769 : 501067879 : switch (TREE_CODE_CLASS (TREE_CODE (expression)))
28770 : : {
28771 : 56530367 : case tcc_reference:
28772 : 56530367 : case tcc_unary:
28773 : 56530367 : case tcc_comparison:
28774 : 56530367 : case tcc_binary:
28775 : 56530367 : case tcc_expression:
28776 : 56530367 : case tcc_vl_exp:
28777 : 56530367 : {
28778 : 56530367 : int i, len = cp_tree_operand_length (expression);
28779 : :
28780 : 100832746 : for (i = 0; i < len; i++)
28781 : : {
28782 : 64649966 : tree t = TREE_OPERAND (expression, i);
28783 : :
28784 : : /* In some cases, some of the operands may be missing.
28785 : : (For example, in the case of PREDECREMENT_EXPR, the
28786 : : amount to increment by may be missing.) That doesn't
28787 : : make the expression dependent. */
28788 : 64649966 : if (t && value_dependent_expression_p (t))
28789 : : return true;
28790 : : }
28791 : : }
28792 : : break;
28793 : : default:
28794 : : break;
28795 : : }
28796 : : break;
28797 : : }
28798 : :
28799 : : /* The expression is not value-dependent. */
28800 : : return false;
28801 : : }
28802 : :
28803 : : /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
28804 : : [temp.dep.expr]. Note that an expression with no type is
28805 : : considered dependent. Other parts of the compiler arrange for an
28806 : : expression with type-dependent subexpressions to have no type, so
28807 : : this function doesn't have to be fully recursive. */
28808 : :
28809 : : bool
28810 : 3390794446 : type_dependent_expression_p (tree expression)
28811 : : {
28812 : 3390794636 : if (!processing_template_decl)
28813 : : return false;
28814 : :
28815 : 2935702338 : if (expression == NULL_TREE || expression == error_mark_node)
28816 : : return false;
28817 : :
28818 : 2934705392 : gcc_checking_assert (!TYPE_P (expression));
28819 : :
28820 : 2934705392 : STRIP_ANY_LOCATION_WRAPPER (expression);
28821 : :
28822 : : /* An unresolved name is always dependent. */
28823 : 2934705392 : if (identifier_p (expression)
28824 : : || TREE_CODE (expression) == USING_DECL)
28825 : : return true;
28826 : :
28827 : : /* A lambda-expression in template context is dependent. dependent_type_p is
28828 : : true for a lambda in the scope of a class or function template, but that
28829 : : doesn't cover all template contexts, like a default template argument. */
28830 : : if (TREE_CODE (expression) == LAMBDA_EXPR)
28831 : : return true;
28832 : :
28833 : : /* A fold expression is type-dependent. */
28834 : : if (TREE_CODE (expression) == UNARY_LEFT_FOLD_EXPR
28835 : : || TREE_CODE (expression) == UNARY_RIGHT_FOLD_EXPR
28836 : : || TREE_CODE (expression) == BINARY_LEFT_FOLD_EXPR
28837 : : || TREE_CODE (expression) == BINARY_RIGHT_FOLD_EXPR)
28838 : : return true;
28839 : :
28840 : : /* Some expression forms are never type-dependent. */
28841 : : if (TREE_CODE (expression) == SIZEOF_EXPR
28842 : : || TREE_CODE (expression) == ALIGNOF_EXPR
28843 : : || TREE_CODE (expression) == AT_ENCODE_EXPR
28844 : : || TREE_CODE (expression) == NOEXCEPT_EXPR
28845 : : || TREE_CODE (expression) == TRAIT_EXPR
28846 : : || TREE_CODE (expression) == TYPEID_EXPR
28847 : : || TREE_CODE (expression) == DELETE_EXPR
28848 : : || TREE_CODE (expression) == VEC_DELETE_EXPR
28849 : : || TREE_CODE (expression) == THROW_EXPR
28850 : : || TREE_CODE (expression) == REQUIRES_EXPR)
28851 : : return false;
28852 : :
28853 : : /* The types of these expressions depends only on the type to which
28854 : : the cast occurs. */
28855 : : if (TREE_CODE (expression) == DYNAMIC_CAST_EXPR
28856 : : || TREE_CODE (expression) == STATIC_CAST_EXPR
28857 : : || TREE_CODE (expression) == CONST_CAST_EXPR
28858 : : || TREE_CODE (expression) == REINTERPRET_CAST_EXPR
28859 : : || TREE_CODE (expression) == IMPLICIT_CONV_EXPR
28860 : : || TREE_CODE (expression) == CAST_EXPR)
28861 : 54099196 : return dependent_type_p (TREE_TYPE (expression));
28862 : :
28863 : : /* The types of these expressions depends only on the type created
28864 : : by the expression. */
28865 : : if (TREE_CODE (expression) == NEW_EXPR
28866 : : || TREE_CODE (expression) == VEC_NEW_EXPR)
28867 : : {
28868 : : /* For NEW_EXPR tree nodes created inside a template, either
28869 : : the object type itself or a TREE_LIST may appear as the
28870 : : operand 1. */
28871 : 671257 : tree type = TREE_OPERAND (expression, 1);
28872 : 671257 : if (TREE_CODE (type) == TREE_LIST)
28873 : : /* This is an array type. We need to check array dimensions
28874 : : as well. */
28875 : 0 : return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type)))
28876 : 0 : || value_dependent_expression_p
28877 : 0 : (TREE_OPERAND (TREE_VALUE (type), 1));
28878 : : /* Array type whose dimension has to be deduced. */
28879 : 671257 : else if (TREE_CODE (type) == ARRAY_TYPE
28880 : 671257 : && TREE_OPERAND (expression, 2) == NULL_TREE)
28881 : : return true;
28882 : : else
28883 : 671245 : return dependent_type_p (type);
28884 : : }
28885 : :
28886 : : if (TREE_CODE (expression) == SCOPE_REF)
28887 : : {
28888 : 95696733 : tree scope = TREE_OPERAND (expression, 0);
28889 : 95696733 : tree name = TREE_OPERAND (expression, 1);
28890 : :
28891 : : /* 14.6.2.2 [temp.dep.expr]: An id-expression is type-dependent if it
28892 : : contains an identifier associated by name lookup with one or more
28893 : : declarations declared with a dependent type, or...a
28894 : : nested-name-specifier or qualified-id that names a member of an
28895 : : unknown specialization. */
28896 : 95696733 : return (type_dependent_expression_p (name)
28897 : 95696733 : || dependent_scope_p (scope));
28898 : : }
28899 : :
28900 : : if (TREE_CODE (expression) == TEMPLATE_DECL
28901 : 255408234 : && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression))
28902 : 255408234 : return uses_outer_template_parms (expression);
28903 : :
28904 : 2411315322 : if (TREE_CODE (expression) == STMT_EXPR)
28905 : 151 : expression = stmt_expr_value_expr (expression);
28906 : :
28907 : 2411315322 : if (BRACE_ENCLOSED_INITIALIZER_P (expression))
28908 : : {
28909 : 7497758 : for (auto &elt : CONSTRUCTOR_ELTS (expression))
28910 : 954812 : if (type_dependent_expression_p (elt.value))
28911 : : return true;
28912 : : return false;
28913 : : }
28914 : :
28915 : : /* A static data member of the current instantiation with incomplete
28916 : : array type is type-dependent, as the definition and specializations
28917 : : can have different bounds. */
28918 : 2405767082 : if (VAR_P (expression)
28919 : 339427302 : && DECL_CLASS_SCOPE_P (expression)
28920 : 43456620 : && dependent_type_p (DECL_CONTEXT (expression))
28921 : 2422030057 : && VAR_HAD_UNKNOWN_BOUND (expression))
28922 : : return true;
28923 : :
28924 : : /* An array of unknown bound depending on a variadic parameter, eg:
28925 : :
28926 : : template<typename... Args>
28927 : : void foo (Args... args)
28928 : : {
28929 : : int arr[] = { args... };
28930 : : }
28931 : :
28932 : : template<int... vals>
28933 : : void bar ()
28934 : : {
28935 : : int arr[] = { vals... };
28936 : : }
28937 : :
28938 : : If the array has no length and has an initializer, it must be that
28939 : : we couldn't determine its length in cp_complete_array_type because
28940 : : it is dependent. */
28941 : 339427070 : if (((VAR_P (expression) && DECL_INITIAL (expression))
28942 : 2103446685 : || COMPOUND_LITERAL_P (expression))
28943 : 303974441 : && TREE_TYPE (expression) != NULL_TREE
28944 : 303974441 : && TREE_CODE (TREE_TYPE (expression)) == ARRAY_TYPE
28945 : 2406552660 : && !TYPE_DOMAIN (TREE_TYPE (expression)))
28946 : : return true;
28947 : :
28948 : : /* Pull a FUNCTION_DECL out of a BASELINK if we can. */
28949 : 2405575268 : if (BASELINK_P (expression))
28950 : : {
28951 : 20855946 : if (BASELINK_OPTYPE (expression)
28952 : 20855946 : && dependent_type_p (BASELINK_OPTYPE (expression)))
28953 : : return true;
28954 : 20855902 : expression = BASELINK_FUNCTIONS (expression);
28955 : : }
28956 : :
28957 : : /* A function or variable template-id is type-dependent if it has any
28958 : : dependent template arguments. */
28959 : 2066339730 : if (VAR_OR_FUNCTION_DECL_P (expression)
28960 : 520236829 : && DECL_LANG_SPECIFIC (expression)
28961 : 2661668214 : && DECL_TEMPLATE_INFO (expression))
28962 : : {
28963 : : /* Consider the innermost template arguments, since those are the ones
28964 : : that come from the template-id; the template arguments for the
28965 : : enclosing class do not make it type-dependent unless they are used in
28966 : : the type of the decl. */
28967 : 105842288 : if (instantiates_primary_template_p (expression)
28968 : 116658385 : && (any_dependent_template_arguments_p
28969 : 10816097 : (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression)))))
28970 : : return true;
28971 : : }
28972 : :
28973 : : /* Otherwise, if the function decl isn't from a dependent scope, it can't be
28974 : : type-dependent. Checking this is important for functions with auto return
28975 : : type, which looks like a dependent type. */
28976 : 2403537180 : if (TREE_CODE (expression) == FUNCTION_DECL
28977 : 257819346 : && !(DECL_CLASS_SCOPE_P (expression)
28978 : 78856049 : && dependent_type_p (DECL_CONTEXT (expression)))
28979 : 121468817 : && !(DECL_LANG_SPECIFIC (expression)
28980 : 121468817 : && DECL_UNIQUE_FRIEND_P (expression)
28981 : 902374 : && (!DECL_FRIEND_CONTEXT (expression)
28982 : 410395 : || dependent_type_p (DECL_FRIEND_CONTEXT (expression))))
28983 : 2524965205 : && !DECL_LOCAL_DECL_P (expression))
28984 : : {
28985 : 121383443 : gcc_assert (!dependent_type_p (TREE_TYPE (expression))
28986 : : || undeduced_auto_decl (expression));
28987 : 121383443 : return false;
28988 : : }
28989 : :
28990 : : /* Otherwise, its constraints could still depend on outer template parameters
28991 : : from its (dependent) scope. */
28992 : 2282153737 : if (TREE_CODE (expression) == FUNCTION_DECL
28993 : : /* As an optimization, check this cheaper sufficient condition first.
28994 : : (At this point we've established that we're looking at a member of
28995 : : a dependent class, so it makes sense to start treating say undeduced
28996 : : auto as dependent.) */
28997 : 57579854 : && !dependent_type_p (TREE_TYPE (expression))
28998 : 2284507866 : && uses_outer_template_parms_in_constraints (expression))
28999 : : return true;
29000 : :
29001 : : /* Always dependent, on the number of arguments if nothing else. */
29002 : 2282153731 : if (TREE_CODE (expression) == EXPR_PACK_EXPANSION)
29003 : : return true;
29004 : :
29005 : : /* [temp.dep.expr]: "A pack-index-expression is type-dependent if its
29006 : : id-expression is type-dependent." */
29007 : 2278640376 : if (TREE_CODE (expression) == PACK_INDEX_EXPR)
29008 : 58 : return type_dependent_expression_p (PACK_INDEX_PACK (expression));
29009 : :
29010 : 2278640318 : if (TREE_TYPE (expression) == unknown_type_node)
29011 : : {
29012 : 177869208 : if (TREE_CODE (expression) == ADDR_EXPR)
29013 : 132 : return type_dependent_expression_p (TREE_OPERAND (expression, 0));
29014 : 177869076 : if (TREE_CODE (expression) == COMPONENT_REF
29015 : 140730875 : || TREE_CODE (expression) == OFFSET_REF)
29016 : : {
29017 : 37138324 : if (type_dependent_object_expression_p (TREE_OPERAND (expression, 0)))
29018 : : return true;
29019 : 37138324 : expression = TREE_OPERAND (expression, 1);
29020 : 772721198 : if (identifier_p (expression))
29021 : : return false;
29022 : : }
29023 : : /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
29024 : 177869076 : if (TREE_CODE (expression) == SCOPE_REF)
29025 : : return false;
29026 : :
29027 : 177869076 : if (BASELINK_P (expression))
29028 : : {
29029 : 37138324 : if (BASELINK_OPTYPE (expression)
29030 : 37138324 : && dependent_type_p (BASELINK_OPTYPE (expression)))
29031 : : return true;
29032 : 37138318 : expression = BASELINK_FUNCTIONS (expression);
29033 : : }
29034 : :
29035 : 177869070 : if (TREE_CODE (expression) == TEMPLATE_ID_EXPR)
29036 : : {
29037 : 50229428 : if (any_dependent_template_arguments_p
29038 : 50229428 : (TREE_OPERAND (expression, 1)))
29039 : : return true;
29040 : 12840063 : expression = TREE_OPERAND (expression, 0);
29041 : 257104738 : if (identifier_p (expression))
29042 : : return true;
29043 : : }
29044 : :
29045 : 140479705 : gcc_assert (OVL_P (expression));
29046 : :
29047 : 444083394 : for (lkp_iterator iter (expression); iter; ++iter)
29048 : 348654782 : if (type_dependent_expression_p (*iter))
29049 : 45051093 : return true;
29050 : :
29051 : 95428612 : return false;
29052 : : }
29053 : :
29054 : : /* The type of a non-type template parm declared with a placeholder type
29055 : : depends on the corresponding template argument, even though
29056 : : placeholders are not normally considered dependent. */
29057 : 2100771110 : if (TREE_CODE (expression) == TEMPLATE_PARM_INDEX
29058 : 2100771110 : && is_auto (TREE_TYPE (expression)))
29059 : : return true;
29060 : :
29061 : 2100768267 : gcc_assert (TREE_CODE (expression) != TYPE_DECL);
29062 : :
29063 : : /* Dependent type attributes might not have made it from the decl to
29064 : : the type yet. */
29065 : 2100768267 : if (DECL_P (expression)
29066 : 2100768267 : && any_dependent_type_attributes_p (DECL_ATTRIBUTES (expression)))
29067 : : return true;
29068 : :
29069 : 2100768222 : return (dependent_type_p (TREE_TYPE (expression)));
29070 : : }
29071 : :
29072 : : /* [temp.dep.expr]/5: A class member access expression (5.2.5) is
29073 : : type-dependent if the expression refers to a member of the current
29074 : : instantiation and the type of the referenced member is dependent, or the
29075 : : class member access expression refers to a member of an unknown
29076 : : specialization.
29077 : :
29078 : : This function returns true if the OBJECT in such a class member access
29079 : : expression is of an unknown specialization. */
29080 : :
29081 : : bool
29082 : 287894045 : type_dependent_object_expression_p (tree object)
29083 : : {
29084 : : /* An IDENTIFIER_NODE can sometimes have a TREE_TYPE, but it's still
29085 : : dependent. */
29086 : 287894045 : if (TREE_CODE (object) == IDENTIFIER_NODE)
29087 : : return true;
29088 : 287894045 : tree scope = TREE_TYPE (object);
29089 : 287894045 : return (!scope || dependent_scope_p (scope));
29090 : : }
29091 : :
29092 : : /* walk_tree callback function for instantiation_dependent_expression_p,
29093 : : below. Returns non-zero if a dependent subexpression is found. */
29094 : :
29095 : : static tree
29096 : 352903641 : instantiation_dependent_r (tree *tp, int *walk_subtrees,
29097 : : void * /*data*/)
29098 : : {
29099 : 352903641 : if (TYPE_P (*tp))
29100 : : {
29101 : : /* We don't have to worry about decltype currently because decltype
29102 : : of an instantiation-dependent expr is a dependent type. This
29103 : : might change depending on the resolution of DR 1172. */
29104 : 18934179 : *walk_subtrees = false;
29105 : 18934179 : return NULL_TREE;
29106 : : }
29107 : 333969462 : enum tree_code code = TREE_CODE (*tp);
29108 : 333969462 : switch (code)
29109 : : {
29110 : : /* Don't treat an argument list as dependent just because it has no
29111 : : TREE_TYPE. */
29112 : : case TREE_LIST:
29113 : : case TREE_VEC:
29114 : : case NONTYPE_ARGUMENT_PACK:
29115 : : return NULL_TREE;
29116 : :
29117 : 31279484 : case TEMPLATE_PARM_INDEX:
29118 : 31279484 : if (dependent_type_p (TREE_TYPE (*tp)))
29119 : 224 : return *tp;
29120 : 31279260 : if (TEMPLATE_PARM_PARAMETER_PACK (*tp))
29121 : : return *tp;
29122 : : /* We'll check value-dependence separately. */
29123 : : return NULL_TREE;
29124 : :
29125 : : /* Handle expressions with type operands. */
29126 : 3257492 : case SIZEOF_EXPR:
29127 : 3257492 : case ALIGNOF_EXPR:
29128 : 3257492 : case TYPEID_EXPR:
29129 : 3257492 : case AT_ENCODE_EXPR:
29130 : 3257492 : {
29131 : 3257492 : tree op = TREE_OPERAND (*tp, 0);
29132 : 3257492 : if (code == SIZEOF_EXPR && SIZEOF_EXPR_TYPE_P (*tp))
29133 : 0 : op = TREE_TYPE (op);
29134 : 3257492 : if (TYPE_P (op))
29135 : : {
29136 : 3211728 : if (dependent_type_p (op))
29137 : 3041308 : return *tp;
29138 : : else
29139 : : {
29140 : 170420 : *walk_subtrees = false;
29141 : 170420 : return NULL_TREE;
29142 : : }
29143 : : }
29144 : : break;
29145 : : }
29146 : :
29147 : 218801 : case COMPONENT_REF:
29148 : 218801 : if (identifier_p (TREE_OPERAND (*tp, 1)))
29149 : : /* In a template, finish_class_member_access_expr creates a
29150 : : COMPONENT_REF with an IDENTIFIER_NODE for op1 even if it isn't
29151 : : type-dependent, so that we can check access control at
29152 : : instantiation time (PR 42277). See also Core issue 1273. */
29153 : : return *tp;
29154 : : break;
29155 : :
29156 : 6570537 : case SCOPE_REF:
29157 : 6570537 : if (instantiation_dependent_scope_ref_p (*tp))
29158 : 4505204 : return *tp;
29159 : : else
29160 : : break;
29161 : :
29162 : : /* Treat statement-expressions as dependent. */
29163 : : case BIND_EXPR:
29164 : : return *tp;
29165 : :
29166 : : /* Treat requires-expressions as dependent. */
29167 : : case REQUIRES_EXPR:
29168 : : return *tp;
29169 : :
29170 : 3202165 : case CONSTRUCTOR:
29171 : 3202165 : if (CONSTRUCTOR_IS_DEPENDENT (*tp))
29172 : : return *tp;
29173 : : break;
29174 : :
29175 : 8126057 : case TEMPLATE_DECL:
29176 : 8126057 : case FUNCTION_DECL:
29177 : : /* Before C++17, a noexcept-specifier isn't part of the function type
29178 : : so it doesn't affect type dependence, but we still want to consider it
29179 : : for instantiation dependence. */
29180 : 8126057 : if (cxx_dialect < cxx17
29181 : 5631 : && DECL_DECLARES_FUNCTION_P (*tp)
29182 : 8131687 : && value_dependent_noexcept_spec_p (TREE_TYPE (*tp)))
29183 : 4 : return *tp;
29184 : : break;
29185 : :
29186 : : default:
29187 : : break;
29188 : : }
29189 : :
29190 : 289988847 : if (type_dependent_expression_p (*tp))
29191 : 18726612 : return *tp;
29192 : : else
29193 : : return NULL_TREE;
29194 : : }
29195 : :
29196 : : /* Returns TRUE if the EXPRESSION is instantiation-dependent, in the
29197 : : sense defined by the ABI:
29198 : :
29199 : : "An expression is instantiation-dependent if it is type-dependent
29200 : : or value-dependent, or it has a subexpression that is type-dependent
29201 : : or value-dependent."
29202 : :
29203 : : Except don't actually check value-dependence for unevaluated expressions,
29204 : : because in sizeof(i) we don't care about the value of i. Checking
29205 : : type-dependence will in turn check value-dependence of array bounds/template
29206 : : arguments as needed. */
29207 : :
29208 : : bool
29209 : 819156785 : instantiation_dependent_uneval_expression_p (tree expression)
29210 : : {
29211 : 819156785 : tree result;
29212 : :
29213 : 819156785 : if (!processing_template_decl)
29214 : : return false;
29215 : :
29216 : 286507895 : if (expression == error_mark_node)
29217 : : return false;
29218 : :
29219 : 286507881 : result = cp_walk_tree_without_duplicates (&expression,
29220 : : instantiation_dependent_r, NULL);
29221 : 286507881 : return result != NULL_TREE;
29222 : : }
29223 : :
29224 : : /* As above, but also check value-dependence of the expression as a whole. */
29225 : :
29226 : : bool
29227 : 768523757 : instantiation_dependent_expression_p (tree expression)
29228 : : {
29229 : 768523757 : return (instantiation_dependent_uneval_expression_p (expression)
29230 : 768523757 : || (processing_template_decl
29231 : 229248047 : && potential_constant_expression (expression)
29232 : 229247972 : && value_dependent_expression_p (expression)));
29233 : : }
29234 : :
29235 : : /* Like type_dependent_expression_p, but it also works while not processing
29236 : : a template definition, i.e. during substitution or mangling. */
29237 : :
29238 : : bool
29239 : 5586000 : type_dependent_expression_p_push (tree expr)
29240 : : {
29241 : 5586000 : bool b;
29242 : 5586000 : ++processing_template_decl;
29243 : 5586000 : b = type_dependent_expression_p (expr);
29244 : 5586000 : --processing_template_decl;
29245 : 5586000 : return b;
29246 : : }
29247 : :
29248 : : /* Returns TRUE if ARGS contains a type-dependent expression. */
29249 : :
29250 : : bool
29251 : 100277347 : any_type_dependent_arguments_p (const vec<tree, va_gc> *args)
29252 : : {
29253 : 100277347 : if (!processing_template_decl || !args)
29254 : : return false;
29255 : :
29256 : 97413525 : for (tree arg : *args)
29257 : 71619157 : if (type_dependent_expression_p (arg))
29258 : : return true;
29259 : :
29260 : : return false;
29261 : : }
29262 : :
29263 : : /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
29264 : : expressions) contains any type-dependent expressions. */
29265 : :
29266 : : bool
29267 : 0 : any_type_dependent_elements_p (const_tree list)
29268 : : {
29269 : 0 : for (; list; list = TREE_CHAIN (list))
29270 : 0 : if (type_dependent_expression_p (TREE_VALUE (list)))
29271 : : return true;
29272 : :
29273 : : return false;
29274 : : }
29275 : :
29276 : : /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
29277 : : expressions) contains any value-dependent expressions. */
29278 : :
29279 : : bool
29280 : 2931736 : any_value_dependent_elements_p (const_tree list)
29281 : : {
29282 : 4496057 : for (; list; list = TREE_CHAIN (list))
29283 : 2931957 : if (value_dependent_expression_p (TREE_VALUE (list)))
29284 : : return true;
29285 : :
29286 : : return false;
29287 : : }
29288 : :
29289 : : /* Returns TRUE if the ARG (a template argument) is dependent. */
29290 : :
29291 : : bool
29292 : 3332438477 : dependent_template_arg_p (tree arg)
29293 : : {
29294 : 3332438477 : if (!processing_template_decl)
29295 : : return false;
29296 : :
29297 : : /* Assume a template argument that was wrongly written by the user
29298 : : is dependent. This is consistent with what
29299 : : any_dependent_template_arguments_p [that calls this function]
29300 : : does. */
29301 : 3056332110 : if (!arg || arg == error_mark_node)
29302 : : return true;
29303 : :
29304 : 3056331574 : if (TREE_CODE (arg) == ARGUMENT_PACK_SELECT)
29305 : 0 : arg = argument_pack_select_arg (arg);
29306 : :
29307 : 3056331574 : if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
29308 : : return true;
29309 : 3056064459 : if (TREE_CODE (arg) == TEMPLATE_DECL)
29310 : : {
29311 : 10056751 : if (DECL_TEMPLATE_PARM_P (arg))
29312 : : return true;
29313 : : /* A member template of a dependent class is not necessarily
29314 : : type-dependent, but it is a dependent template argument because it
29315 : : will be a member of an unknown specialization to that template. */
29316 : 10051915 : tree scope = CP_DECL_CONTEXT (arg);
29317 : 10051915 : return TYPE_P (scope) && dependent_type_p (scope);
29318 : : }
29319 : 3046007708 : else if (ARGUMENT_PACK_P (arg))
29320 : : {
29321 : 121150498 : tree args = ARGUMENT_PACK_ARGS (arg);
29322 : 275387673 : for (tree arg : tree_vec_range (args))
29323 : 197248443 : if (dependent_template_arg_p (arg))
29324 : 43011268 : return true;
29325 : 78139230 : return false;
29326 : : }
29327 : 2924857210 : else if (TYPE_P (arg))
29328 : 2589300123 : return dependent_type_p (arg);
29329 : : else
29330 : 335557087 : return value_dependent_expression_p (arg);
29331 : : }
29332 : :
29333 : : /* Identify any expressions that use function parms. */
29334 : :
29335 : : static tree
29336 : 445891286 : find_parm_usage_r (tree *tp, int *walk_subtrees, void*)
29337 : : {
29338 : 445891286 : tree t = *tp;
29339 : 445891286 : if (TREE_CODE (t) == PARM_DECL)
29340 : : {
29341 : 81801 : *walk_subtrees = 0;
29342 : 81801 : return t;
29343 : : }
29344 : : return NULL_TREE;
29345 : : }
29346 : :
29347 : : /* Returns true if a type specialization formed using the template
29348 : : arguments ARGS needs to use structural equality. */
29349 : :
29350 : : bool
29351 : 83106447 : any_template_arguments_need_structural_equality_p (tree args)
29352 : : {
29353 : 83106447 : int i;
29354 : 83106447 : int j;
29355 : :
29356 : 83106447 : if (!args)
29357 : : return false;
29358 : 83106447 : if (args == error_mark_node)
29359 : : return true;
29360 : :
29361 : 328357144 : for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i)
29362 : : {
29363 : 85248347 : tree level = TMPL_ARGS_LEVEL (args, i + 1);
29364 : 238311208 : for (j = 0; j < TREE_VEC_LENGTH (level); ++j)
29365 : : {
29366 : 154089333 : tree arg = TREE_VEC_ELT (level, j);
29367 : 154089333 : tree packed_args = NULL_TREE;
29368 : 154089333 : int k, len = 1;
29369 : :
29370 : 154089333 : if (ARGUMENT_PACK_P (arg))
29371 : : {
29372 : : /* Look inside the argument pack. */
29373 : 13062423 : packed_args = ARGUMENT_PACK_ARGS (arg);
29374 : 13062423 : len = TREE_VEC_LENGTH (packed_args);
29375 : : }
29376 : :
29377 : 319069360 : for (k = 0; k < len; ++k)
29378 : : {
29379 : 166006499 : if (packed_args)
29380 : 24979589 : arg = TREE_VEC_ELT (packed_args, k);
29381 : :
29382 : 166006499 : if (error_operand_p (arg))
29383 : 1026472 : return true;
29384 : 166006499 : else if (TREE_CODE (arg) == TEMPLATE_DECL)
29385 : 3993021 : continue;
29386 : 162013478 : else if (arg == any_targ_node)
29387 : : /* An any_targ_node argument (added by add_defaults_to_ttp)
29388 : : makes the corresponding specialization not canonicalizable,
29389 : : since template_args_equal always return true for it. We
29390 : : may see this when called from bind_template_template_parm. */
29391 : : return true;
29392 : : /* Checking current_function_decl because this structural
29393 : : comparison is only necessary for redeclaration. */
29394 : 162013474 : else if (!current_function_decl
29395 : 146199857 : && dependent_template_arg_p (arg)
29396 : 234153702 : && (cp_walk_tree_without_duplicates
29397 : : (&arg, find_parm_usage_r, NULL)))
29398 : : /* The identity of a class template specialization that uses
29399 : : a function parameter depends on the identity of the function.
29400 : : And if this specialization appeared in the trailing return
29401 : : type thereof, we don't know the identity of the function
29402 : : (e.g. if it's a redeclaration or a new function) until we
29403 : : form its signature and go through duplicate_decls. Thus
29404 : : it's unsafe to decide on a canonical type now (which depends
29405 : : on the DECL_CONTEXT of the function parameter, which can get
29406 : : mutated after the fact by duplicate_decls), so just require
29407 : : structural equality in this case (PR52830). */
29408 : : return true;
29409 : 161931673 : else if (TYPE_P (arg)
29410 : 133553455 : && TYPE_STRUCTURAL_EQUALITY_P (arg)
29411 : 177834683 : && (dependent_alias_template_spec_p (arg, nt_opaque)
29412 : 14970344 : || dependent_opaque_alias_p (arg)))
29413 : : /* Require structural equality for specializations written
29414 : : in terms of a dependent alias template specialization. */
29415 : 932699 : return true;
29416 : 47737199 : else if (CLASS_TYPE_P (arg)
29417 : 46915397 : && TYPE_TEMPLATE_INFO (arg)
29418 : 198077493 : && TYPE_STRUCTURAL_EQUALITY_P (arg))
29419 : : /* Require structural equality for specializations written
29420 : : in terms of a class template specialization that itself
29421 : : needs structural equality. */
29422 : : return true;
29423 : : }
29424 : : }
29425 : : }
29426 : :
29427 : : return false;
29428 : : }
29429 : :
29430 : : /* Returns true if ARGS (a collection of template arguments) contains
29431 : : any dependent arguments. */
29432 : :
29433 : : bool
29434 : 1813934932 : any_dependent_template_arguments_p (const_tree args)
29435 : : {
29436 : 1813934932 : if (args == error_mark_node)
29437 : : return true;
29438 : 1813934932 : if (!processing_template_decl || !args)
29439 : : return false;
29440 : :
29441 : 4177677195 : for (int i = 0, depth = TMPL_ARGS_DEPTH (args); i < depth; ++i)
29442 : : {
29443 : 1700577597 : const_tree level = TMPL_ARGS_LEVEL (args, i + 1);
29444 : 3739181492 : for (tree arg : tree_vec_range (CONST_CAST_TREE (level)))
29445 : 2717306940 : if (dependent_template_arg_p (arg))
29446 : 678703045 : return true;
29447 : : }
29448 : :
29449 : : return false;
29450 : : }
29451 : :
29452 : : /* Returns true if ARGS contains any errors. */
29453 : :
29454 : : bool
29455 : 21488341 : any_erroneous_template_args_p (const_tree args)
29456 : : {
29457 : 21488341 : int i;
29458 : 21488341 : int j;
29459 : :
29460 : 21488341 : if (args == error_mark_node)
29461 : : return true;
29462 : :
29463 : 21488308 : if (args && TREE_CODE (args) != TREE_VEC)
29464 : : {
29465 : 21488308 : if (tree ti = get_template_info (args))
29466 : 17426514 : args = TI_ARGS (ti);
29467 : : else
29468 : : args = NULL_TREE;
29469 : : }
29470 : :
29471 : 17426514 : if (!args)
29472 : 4061794 : return false;
29473 : :
29474 : 69610938 : for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i)
29475 : : {
29476 : 17521348 : const_tree level = TMPL_ARGS_LEVEL (args, i + 1);
29477 : 47969135 : for (j = 0; j < TREE_VEC_LENGTH (level); ++j)
29478 : 30447935 : if (error_operand_p (TREE_VEC_ELT (level, j)))
29479 : : return true;
29480 : : }
29481 : :
29482 : : return false;
29483 : : }
29484 : :
29485 : : /* Returns TRUE if the template TMPL is type-dependent. */
29486 : :
29487 : : bool
29488 : 1722094 : dependent_template_p (tree tmpl)
29489 : : {
29490 : 1722094 : if (TREE_CODE (tmpl) == OVERLOAD)
29491 : : {
29492 : 1712562 : for (lkp_iterator iter (tmpl); iter; ++iter)
29493 : 1179904 : if (dependent_template_p (*iter))
29494 : 0 : return true;
29495 : 532658 : return false;
29496 : : }
29497 : :
29498 : : /* Template template parameters are dependent. */
29499 : 941193 : if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl)
29500 : 2130629 : || TREE_CODE (tmpl) == TEMPLATE_TEMPLATE_PARM)
29501 : : return true;
29502 : : /* So are names that have not been looked up. */
29503 : 1198956 : if (TREE_CODE (tmpl) == SCOPE_REF || identifier_p (tmpl))
29504 : : return true;
29505 : : return false;
29506 : : }
29507 : :
29508 : : /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
29509 : :
29510 : : bool
29511 : 542190 : dependent_template_id_p (tree tmpl, tree args)
29512 : : {
29513 : 542190 : return (dependent_template_p (tmpl)
29514 : 542190 : || any_dependent_template_arguments_p (args));
29515 : : }
29516 : :
29517 : : /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
29518 : : are dependent. BODY is the body to use for loop transforming
29519 : : constructs. */
29520 : :
29521 : : bool
29522 : 19909 : dependent_omp_for_p (tree declv, tree initv, tree condv, tree incrv, tree body)
29523 : : {
29524 : 19909 : int i, k;
29525 : :
29526 : 19909 : if (!processing_template_decl)
29527 : : return false;
29528 : :
29529 : 1821 : for (i = 0, k = 0; i < TREE_VEC_LENGTH (declv); i++)
29530 : : {
29531 : 1203 : tree decl = TREE_VEC_ELT (declv, i);
29532 : 1203 : tree init = TREE_VEC_ELT (initv, i);
29533 : 1203 : tree cond = TREE_VEC_ELT (condv, i);
29534 : 1203 : tree incr = TREE_VEC_ELT (incrv, i);
29535 : :
29536 : 1203 : if (decl == NULL_TREE)
29537 : : {
29538 : 10 : tree stmt = body;
29539 : 10 : int j = c_omp_find_generated_loop (stmt, k++, cp_walk_subtrees);
29540 : 10 : init = TREE_VEC_ELT (OMP_FOR_INIT (stmt), j);
29541 : 10 : decl = TREE_OPERAND (init, 0);
29542 : 10 : cond = TREE_VEC_ELT (OMP_FOR_INIT (stmt), j);
29543 : 10 : incr = TREE_VEC_ELT (OMP_FOR_INIT (stmt), j);
29544 : : }
29545 : :
29546 : 1203 : if (type_dependent_expression_p (decl)
29547 : 1203 : || TREE_CODE (decl) == SCOPE_REF)
29548 : : return true;
29549 : :
29550 : 869 : if (init && type_dependent_expression_p (init))
29551 : : return true;
29552 : :
29553 : 869 : if (cond == global_namespace)
29554 : : return true;
29555 : :
29556 : 796 : if (type_dependent_expression_p (cond))
29557 : : return true;
29558 : :
29559 : 781 : if (COMPARISON_CLASS_P (cond)
29560 : 781 : && (type_dependent_expression_p (TREE_OPERAND (cond, 0))
29561 : 777 : || type_dependent_expression_p (TREE_OPERAND (cond, 1))))
29562 : 11 : return true;
29563 : :
29564 : 770 : if (TREE_CODE (incr) == MODOP_EXPR)
29565 : : {
29566 : 1 : if (type_dependent_expression_p (TREE_OPERAND (incr, 0))
29567 : 1 : || type_dependent_expression_p (TREE_OPERAND (incr, 2)))
29568 : 0 : return true;
29569 : : }
29570 : 769 : else if (type_dependent_expression_p (incr))
29571 : : return true;
29572 : 769 : else if (TREE_CODE (incr) == MODIFY_EXPR)
29573 : : {
29574 : 233 : if (type_dependent_expression_p (TREE_OPERAND (incr, 0)))
29575 : : return true;
29576 : 233 : else if (BINARY_CLASS_P (TREE_OPERAND (incr, 1)))
29577 : : {
29578 : 232 : tree t = TREE_OPERAND (incr, 1);
29579 : 232 : if (type_dependent_expression_p (TREE_OPERAND (t, 0))
29580 : 232 : || type_dependent_expression_p (TREE_OPERAND (t, 1)))
29581 : 5 : return true;
29582 : :
29583 : : /* If this loop has a class iterator with != comparison
29584 : : with increment other than i++/++i/i--/--i, make sure the
29585 : : increment is constant. */
29586 : 454 : if (CLASS_TYPE_P (TREE_TYPE (decl))
29587 : 288 : && TREE_CODE (cond) == NE_EXPR)
29588 : : {
29589 : 8 : if (TREE_OPERAND (t, 0) == decl)
29590 : 8 : t = TREE_OPERAND (t, 1);
29591 : : else
29592 : 0 : t = TREE_OPERAND (t, 0);
29593 : 8 : if (TREE_CODE (t) != INTEGER_CST)
29594 : : return true;
29595 : : }
29596 : : }
29597 : : }
29598 : : }
29599 : :
29600 : : return false;
29601 : : }
29602 : :
29603 : : /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
29604 : : TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
29605 : : no such TYPE can be found. Note that this function peers inside
29606 : : uninstantiated templates and therefore should be used only in
29607 : : extremely limited situations. ONLY_CURRENT_P restricts this
29608 : : peering to the currently open classes hierarchy (which is required
29609 : : when comparing types). */
29610 : :
29611 : : tree
29612 : 170045559 : resolve_typename_type (tree type, bool only_current_p)
29613 : : {
29614 : 170045559 : tree scope;
29615 : 170045559 : tree name;
29616 : 170045559 : tree decl;
29617 : 170045559 : int quals;
29618 : 170045559 : tree pushed_scope;
29619 : 170045559 : tree result;
29620 : :
29621 : 170045559 : gcc_assert (TREE_CODE (type) == TYPENAME_TYPE);
29622 : :
29623 : 170045559 : scope = TYPE_CONTEXT (type);
29624 : : /* We shouldn't have built a TYPENAME_TYPE with a non-dependent scope. */
29625 : 170045559 : gcc_checking_assert (uses_template_parms (scope));
29626 : :
29627 : : /* Usually the non-qualified identifier of a TYPENAME_TYPE is
29628 : : TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of a
29629 : : TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL
29630 : : representing the typedef. In that case TYPE_IDENTIFIER (type) is
29631 : : not the non-qualified identifier of the TYPENAME_TYPE anymore.
29632 : : So by getting the TYPE_IDENTIFIER of the _main declaration_ of
29633 : : the TYPENAME_TYPE instead, we avoid messing up with a possible
29634 : : typedef variant case. */
29635 : 170045559 : name = TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type));
29636 : :
29637 : : /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
29638 : : it first before we can figure out what NAME refers to. */
29639 : 170045559 : if (TREE_CODE (scope) == TYPENAME_TYPE)
29640 : : {
29641 : 3835300 : if (TYPENAME_IS_RESOLVING_P (scope))
29642 : : /* Given a class template A with a dependent base with nested type C,
29643 : : typedef typename A::C::C C will land us here, as trying to resolve
29644 : : the initial A::C leads to the local C typedef, which leads back to
29645 : : A::C::C. So we break the recursion now. */
29646 : : return type;
29647 : : else
29648 : 3835300 : scope = resolve_typename_type (scope, only_current_p);
29649 : : }
29650 : : /* If we don't know what SCOPE refers to, then we cannot resolve the
29651 : : TYPENAME_TYPE. */
29652 : 170045559 : if (!CLASS_TYPE_P (scope))
29653 : : return type;
29654 : : /* If this is a typedef, we don't want to look inside (c++/11987). */
29655 : 148181165 : if (typedef_variant_p (type))
29656 : : return type;
29657 : : /* If SCOPE isn't the template itself, it will not have a valid
29658 : : TYPE_FIELDS list. */
29659 : 101200325 : if (same_type_p (scope, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope)))
29660 : : /* scope is either the template itself or a compatible instantiation
29661 : : like X<T>, so look up the name in the original template. */
29662 : 38531556 : scope = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope);
29663 : : /* If scope has no fields, it can't be a current instantiation. Check this
29664 : : before currently_open_class to avoid infinite recursion (71515). */
29665 : 101200325 : if (!TYPE_FIELDS (scope))
29666 : : return type;
29667 : : /* If the SCOPE is not the current instantiation, there's no reason
29668 : : to look inside it. */
29669 : 38202670 : if (only_current_p && !currently_open_class (scope))
29670 : : return type;
29671 : : /* Enter the SCOPE so that name lookup will be resolved as if we
29672 : : were in the class definition. In particular, SCOPE will no
29673 : : longer be considered a dependent type. */
29674 : 57575 : pushed_scope = push_scope (scope);
29675 : : /* Look up the declaration. */
29676 : 57575 : decl = lookup_member (scope, name, /*protect=*/0, /*want_type=*/true,
29677 : : tf_warning_or_error);
29678 : :
29679 : 57575 : result = NULL_TREE;
29680 : :
29681 : : /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
29682 : : find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
29683 : 57575 : tree fullname = TYPENAME_TYPE_FULLNAME (type);
29684 : 57575 : if (!decl)
29685 : : /*nop*/;
29686 : 57550 : else if (identifier_p (fullname)
29687 : 57544 : && TREE_CODE (decl) == TYPE_DECL)
29688 : : {
29689 : 57544 : result = TREE_TYPE (decl);
29690 : 57544 : if (result == error_mark_node)
29691 : 28 : result = NULL_TREE;
29692 : : }
29693 : 6 : else if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR
29694 : 6 : && DECL_CLASS_TEMPLATE_P (decl))
29695 : : {
29696 : : /* Obtain the template and the arguments. */
29697 : 3 : tree tmpl = TREE_OPERAND (fullname, 0);
29698 : 3 : if (TREE_CODE (tmpl) == IDENTIFIER_NODE)
29699 : : {
29700 : : /* We get here with a plain identifier because a previous tentative
29701 : : parse of the nested-name-specifier as part of a ptr-operator saw
29702 : : ::template X<A>. The use of ::template is necessary in a
29703 : : ptr-operator, but wrong in a declarator-id.
29704 : :
29705 : : [temp.names]: In a qualified-id of a declarator-id, the keyword
29706 : : template shall not appear at the top level. */
29707 : 3 : pedwarn (cp_expr_loc_or_input_loc (fullname), OPT_Wpedantic,
29708 : : "keyword %<template%> not allowed in declarator-id");
29709 : 3 : tmpl = decl;
29710 : : }
29711 : 3 : tree args = TREE_OPERAND (fullname, 1);
29712 : : /* Instantiate the template. */
29713 : 3 : result = lookup_template_class (tmpl, args, NULL_TREE, NULL_TREE,
29714 : : tf_error | tf_user);
29715 : 3 : result = adjust_type_for_entering_scope (result);
29716 : 3 : if (result == error_mark_node)
29717 : 28 : result = NULL_TREE;
29718 : : }
29719 : :
29720 : : /* Leave the SCOPE. */
29721 : 57575 : if (pushed_scope)
29722 : 57560 : pop_scope (pushed_scope);
29723 : :
29724 : : /* If we failed to resolve it, return the original typename. */
29725 : 57575 : if (!result)
29726 : : return type;
29727 : :
29728 : : /* If lookup found a typename type, resolve that too. */
29729 : 57547 : if (TREE_CODE (result) == TYPENAME_TYPE && !TYPENAME_IS_RESOLVING_P (result))
29730 : : {
29731 : : /* Ill-formed programs can cause infinite recursion here, so we
29732 : : must catch that. */
29733 : 3 : TYPENAME_IS_RESOLVING_P (result) = 1;
29734 : 3 : result = resolve_typename_type (result, only_current_p);
29735 : 3 : TYPENAME_IS_RESOLVING_P (result) = 0;
29736 : : }
29737 : :
29738 : : /* Qualify the resulting type. */
29739 : 57547 : quals = cp_type_quals (type);
29740 : 57547 : if (quals)
29741 : 0 : result = cp_build_qualified_type (result, cp_type_quals (result) | quals);
29742 : :
29743 : : return result;
29744 : : }
29745 : :
29746 : : /* Returns a type which represents 'auto' or 'decltype(auto)'. We use a
29747 : : TEMPLATE_TYPE_PARM with a level one deeper than the actual template parms,
29748 : : by default. If set_canonical is true, we set TYPE_CANONICAL on it. */
29749 : :
29750 : : static tree
29751 : 19325356 : make_auto_1 (tree name, bool set_canonical, int level = -1)
29752 : : {
29753 : 19325356 : if (level == -1)
29754 : 10875896 : level = current_template_depth + 1;
29755 : 19325356 : tree au = cxx_make_type (TEMPLATE_TYPE_PARM);
29756 : 19325356 : TYPE_NAME (au) = build_decl (input_location, TYPE_DECL, name, au);
29757 : 19325356 : TYPE_STUB_DECL (au) = TYPE_NAME (au);
29758 : 19325356 : TEMPLATE_TYPE_PARM_INDEX (au) = build_template_parm_index
29759 : 19325356 : (0, level, level, TYPE_NAME (au), NULL_TREE);
29760 : 19325356 : if (set_canonical)
29761 : 10543562 : TYPE_CANONICAL (au) = canonical_type_parameter (au);
29762 : 19325356 : DECL_ARTIFICIAL (TYPE_NAME (au)) = 1;
29763 : 19325356 : SET_DECL_TEMPLATE_PARM_P (TYPE_NAME (au));
29764 : 19325356 : if (name == decltype_auto_identifier)
29765 : 622765 : AUTO_IS_DECLTYPE (au) = true;
29766 : :
29767 : 19325356 : return au;
29768 : : }
29769 : :
29770 : : tree
29771 : 289923 : make_decltype_auto (void)
29772 : : {
29773 : 289923 : return make_auto_1 (decltype_auto_identifier, true);
29774 : : }
29775 : :
29776 : : tree
29777 : 10247551 : make_auto (void)
29778 : : {
29779 : 10247551 : return make_auto_1 (auto_identifier, true);
29780 : : }
29781 : :
29782 : : /* Return a C++17 deduction placeholder for class template TMPL.
29783 : : There are represented as an 'auto' with the special level 0 and
29784 : : CLASS_PLACEHOLDER_TEMPLATE set. */
29785 : :
29786 : : tree
29787 : 8443372 : make_template_placeholder (tree tmpl)
29788 : : {
29789 : 8443372 : tree t = make_auto_1 (auto_identifier, false, /*level=*/0);
29790 : 8443372 : CLASS_PLACEHOLDER_TEMPLATE (t) = tmpl;
29791 : : /* Our canonical type depends on the placeholder. */
29792 : 8443372 : TYPE_CANONICAL (t) = canonical_type_parameter (t);
29793 : 8443372 : return t;
29794 : : }
29795 : :
29796 : : /* True iff T is a C++17 class template deduction placeholder. */
29797 : :
29798 : : bool
29799 : 1428900020 : template_placeholder_p (tree t)
29800 : : {
29801 : 1445378798 : return is_auto (t) && CLASS_PLACEHOLDER_TEMPLATE (t);
29802 : : }
29803 : :
29804 : : /* Return an auto for an explicit cast expression auto(x).
29805 : : Like CTAD placeholders, these have level 0 so that they're
29806 : : not accidentally replaced via tsubst and are always directly
29807 : : resolved via do_auto_deduction. */
29808 : :
29809 : : tree
29810 : 6088 : make_cast_auto ()
29811 : : {
29812 : 6088 : return make_auto_1 (auto_identifier, true, /*level=*/0);
29813 : : }
29814 : :
29815 : : /* Make a "constrained auto" type-specifier. This is an auto or
29816 : : decltype(auto) type with constraints that must be associated after
29817 : : deduction. The constraint is formed from the given concept CON
29818 : : and its optional sequence of template arguments ARGS.
29819 : :
29820 : : TYPE must be the result of make_auto_type or make_decltype_auto_type. */
29821 : :
29822 : : static tree
29823 : 338364 : make_constrained_placeholder_type (tree type, tree con, tree args)
29824 : : {
29825 : : /* Build the constraint. */
29826 : 338364 : tree tmpl = DECL_TI_TEMPLATE (con);
29827 : 338364 : ++processing_template_decl;
29828 : 338364 : tree expr = build_concept_check (tmpl, type, args, tf_warning_or_error);
29829 : 338364 : --processing_template_decl;
29830 : :
29831 : 338364 : PLACEHOLDER_TYPE_CONSTRAINTS_INFO (type)
29832 : 338364 : = build_tree_list (current_template_parms, expr);
29833 : :
29834 : : /* Our canonical type depends on the constraint. */
29835 : 338364 : TYPE_CANONICAL (type) = canonical_type_parameter (type);
29836 : :
29837 : : /* Attach the constraint to the type declaration. */
29838 : 338364 : return TYPE_NAME (type);
29839 : : }
29840 : :
29841 : : /* Make a "constrained auto" type-specifier. */
29842 : :
29843 : : tree
29844 : 5531 : make_constrained_auto (tree con, tree args)
29845 : : {
29846 : 5531 : tree type = make_auto_1 (auto_identifier, false);
29847 : 5531 : return make_constrained_placeholder_type (type, con, args);
29848 : : }
29849 : :
29850 : : /* Make a "constrained decltype(auto)" type-specifier. */
29851 : :
29852 : : tree
29853 : 332833 : make_constrained_decltype_auto (tree con, tree args)
29854 : : {
29855 : 332833 : tree type = make_auto_1 (decltype_auto_identifier, false);
29856 : 332833 : return make_constrained_placeholder_type (type, con, args);
29857 : : }
29858 : :
29859 : : /* Returns true if the placeholder type constraint T has any dependent
29860 : : (explicit) template arguments. */
29861 : :
29862 : : static bool
29863 : 58 : placeholder_type_constraint_dependent_p (tree t)
29864 : : {
29865 : 58 : gcc_assert (concept_check_p (t));
29866 : 58 : tree args = TREE_OPERAND (t, 1);
29867 : 58 : tree first = TREE_VEC_ELT (args, 0);
29868 : 58 : if (ARGUMENT_PACK_P (first))
29869 : : {
29870 : 18 : args = expand_template_argument_pack (args);
29871 : 18 : first = TREE_VEC_ELT (args, 0);
29872 : : }
29873 : 58 : gcc_checking_assert (is_auto (first));
29874 : 76 : for (int i = 1; i < TREE_VEC_LENGTH (args); ++i)
29875 : 42 : if (dependent_template_arg_p (TREE_VEC_ELT (args, i)))
29876 : : return true;
29877 : : return false;
29878 : : }
29879 : :
29880 : : /* Build and return a concept definition. Like other templates, the
29881 : : CONCEPT_DECL node is wrapped by a TEMPLATE_DECL. This returns the
29882 : : the TEMPLATE_DECL. */
29883 : :
29884 : : tree
29885 : 620551 : finish_concept_definition (cp_expr id, tree init, tree attrs)
29886 : : {
29887 : 620551 : gcc_assert (identifier_p (id));
29888 : 620551 : gcc_assert (processing_template_decl);
29889 : :
29890 : 620551 : location_t loc = id.get_location();
29891 : :
29892 : : /* A concept-definition shall not have associated constraints. */
29893 : 620551 : if (TEMPLATE_PARMS_CONSTRAINTS (current_template_parms))
29894 : : {
29895 : 6 : error_at (loc, "a concept cannot be constrained");
29896 : 6 : TEMPLATE_PARMS_CONSTRAINTS (current_template_parms) = NULL_TREE;
29897 : : }
29898 : :
29899 : : /* A concept-definition shall appear in namespace scope. Templates
29900 : : aren't allowed in block scope, so we only need to check for class
29901 : : scope. */
29902 : 620551 : if (TYPE_P (current_scope()) || !DECL_NAMESPACE_SCOPE_P (current_scope ()))
29903 : : {
29904 : 6 : error_at (loc, "concept %qE not in namespace scope", *id);
29905 : 6 : return error_mark_node;
29906 : : }
29907 : :
29908 : 620545 : if (current_template_depth > 1)
29909 : : {
29910 : 3 : error_at (loc, "concept %qE has multiple template parameter lists", *id);
29911 : 3 : return error_mark_node;
29912 : : }
29913 : :
29914 : : /* Initially build the concept declaration; its type is bool. */
29915 : 620542 : tree decl = build_lang_decl_loc (loc, CONCEPT_DECL, *id, boolean_type_node);
29916 : 620542 : DECL_CONTEXT (decl) = current_scope ();
29917 : 620542 : DECL_INITIAL (decl) = init;
29918 : 620542 : TREE_PUBLIC (decl) = true;
29919 : :
29920 : 620542 : if (attrs)
29921 : 21 : cplus_decl_attributes (&decl, attrs, 0);
29922 : :
29923 : 620542 : set_originating_module (decl, false);
29924 : 620542 : check_module_decl_linkage (decl);
29925 : :
29926 : : /* Push the enclosing template. */
29927 : 620542 : return push_template_decl (decl);
29928 : : }
29929 : :
29930 : : /* Given type ARG, return std::initializer_list<ARG>. */
29931 : :
29932 : : static tree
29933 : 359 : listify (tree arg)
29934 : : {
29935 : 359 : tree std_init_list = lookup_qualified_name (std_node, init_list_identifier);
29936 : :
29937 : 359 : if (std_init_list == error_mark_node
29938 : 359 : || !DECL_CLASS_TEMPLATE_P (std_init_list))
29939 : : {
29940 : 18 : gcc_rich_location richloc (input_location);
29941 : 18 : maybe_add_include_fixit (&richloc, "<initializer_list>", false);
29942 : 18 : error_at (&richloc,
29943 : : "deducing from brace-enclosed initializer list"
29944 : : " requires %<#include <initializer_list>%>");
29945 : :
29946 : 18 : return error_mark_node;
29947 : 18 : }
29948 : 341 : tree argvec = make_tree_vec (1);
29949 : 341 : TREE_VEC_ELT (argvec, 0) = arg;
29950 : :
29951 : 341 : return lookup_template_class (std_init_list, argvec, NULL_TREE,
29952 : 341 : NULL_TREE, tf_warning_or_error);
29953 : : }
29954 : :
29955 : : /* Replace auto in TYPE with std::initializer_list<auto>. */
29956 : :
29957 : : static tree
29958 : 359 : listify_autos (tree type, tree auto_node)
29959 : : {
29960 : 359 : tree init_auto = listify (strip_top_quals (auto_node));
29961 : 359 : tree argvec = make_tree_vec (1);
29962 : 359 : TREE_VEC_ELT (argvec, 0) = init_auto;
29963 : 359 : if (processing_template_decl)
29964 : 3 : argvec = add_to_template_args (current_template_args (), argvec);
29965 : 359 : return tsubst (type, argvec, tf_warning_or_error, NULL_TREE);
29966 : : }
29967 : :
29968 : : /* Hash traits for hashing possibly constrained 'auto'
29969 : : TEMPLATE_TYPE_PARMs for use by do_auto_deduction. */
29970 : :
29971 : : struct auto_hash : default_hash_traits<tree>
29972 : : {
29973 : : static inline hashval_t hash (tree);
29974 : : static inline bool equal (tree, tree);
29975 : : };
29976 : :
29977 : : /* Hash the 'auto' T. */
29978 : :
29979 : : inline hashval_t
29980 : : auto_hash::hash (tree t)
29981 : : {
29982 : : if (tree c = NON_ERROR (PLACEHOLDER_TYPE_CONSTRAINTS (t)))
29983 : : /* Matching constrained-type-specifiers denote the same template
29984 : : parameter, so hash the constraint. */
29985 : : return iterative_hash_placeholder_constraint (c, 0);
29986 : : else
29987 : : /* But unconstrained autos are all separate, so just hash the pointer. */
29988 : : return iterative_hash_object (t, 0);
29989 : : }
29990 : :
29991 : : /* Compare two 'auto's. */
29992 : :
29993 : : inline bool
29994 : : auto_hash::equal (tree t1, tree t2)
29995 : : {
29996 : : if (t1 == t2)
29997 : : return true;
29998 : :
29999 : : tree c1 = PLACEHOLDER_TYPE_CONSTRAINTS (t1);
30000 : : tree c2 = PLACEHOLDER_TYPE_CONSTRAINTS (t2);
30001 : :
30002 : : /* Two unconstrained autos are distinct. */
30003 : : if (!c1 || !c2)
30004 : : return false;
30005 : :
30006 : : return equivalent_placeholder_constraints (c1, c2);
30007 : : }
30008 : :
30009 : : /* The stem for deduction guide names. */
30010 : : const char *const dguide_base = "__dguide_";
30011 : :
30012 : : /* Return the name for a deduction guide for class template TMPL. */
30013 : :
30014 : : tree
30015 : 1050644 : dguide_name (tree tmpl)
30016 : : {
30017 : 1050644 : tree type = (TYPE_P (tmpl) ? tmpl : TREE_TYPE (tmpl));
30018 : 1050644 : tree tname = TYPE_IDENTIFIER (type);
30019 : 1050644 : char *buf = (char *) alloca (1 + strlen (dguide_base)
30020 : : + IDENTIFIER_LENGTH (tname));
30021 : 1050644 : memcpy (buf, dguide_base, strlen (dguide_base));
30022 : 1050644 : memcpy (buf + strlen (dguide_base), IDENTIFIER_POINTER (tname),
30023 : 1050644 : IDENTIFIER_LENGTH (tname) + 1);
30024 : 1050644 : tree dname = get_identifier (buf);
30025 : 1050644 : TREE_TYPE (dname) = type;
30026 : 1050644 : return dname;
30027 : : }
30028 : :
30029 : : /* True if NAME is the name of a deduction guide. */
30030 : :
30031 : : bool
30032 : 737099631 : dguide_name_p (tree name)
30033 : : {
30034 : 737099631 : return (TREE_CODE (name) == IDENTIFIER_NODE
30035 : 737099629 : && TREE_TYPE (name)
30036 : 784275400 : && startswith (IDENTIFIER_POINTER (name), dguide_base));
30037 : : }
30038 : :
30039 : : /* True if FN is a deduction guide. */
30040 : :
30041 : : bool
30042 : 438017753 : deduction_guide_p (const_tree fn)
30043 : : {
30044 : 438017753 : if (DECL_P (fn))
30045 : 438017713 : if (tree name = DECL_NAME (fn))
30046 : 438017713 : return dguide_name_p (name);
30047 : : return false;
30048 : : }
30049 : :
30050 : : /* True if FN is the copy deduction guide, i.e. A(A)->A. */
30051 : :
30052 : : bool
30053 : 9170 : copy_guide_p (const_tree fn)
30054 : : {
30055 : 9170 : gcc_assert (deduction_guide_p (fn));
30056 : 9170 : if (!DECL_ARTIFICIAL (fn))
30057 : : return false;
30058 : 9170 : tree parms = FUNCTION_FIRST_USER_PARMTYPE (DECL_TI_TEMPLATE (fn));
30059 : 9170 : return (TREE_CHAIN (parms) == void_list_node
30060 : 9170 : && same_type_p (TREE_VALUE (parms), TREE_TYPE (DECL_NAME (fn))));
30061 : : }
30062 : :
30063 : : /* True if FN is a guide generated from a constructor template. */
30064 : :
30065 : : bool
30066 : 52 : template_guide_p (const_tree fn)
30067 : : {
30068 : 52 : gcc_assert (deduction_guide_p (fn));
30069 : 52 : if (!DECL_ARTIFICIAL (fn))
30070 : : return false;
30071 : 52 : tree tmpl = DECL_TI_TEMPLATE (fn);
30072 : 52 : if (tree org = DECL_ABSTRACT_ORIGIN (tmpl))
30073 : 40 : return PRIMARY_TEMPLATE_P (org);
30074 : : return false;
30075 : : }
30076 : :
30077 : : /* True if FN is an aggregate initialization guide or the copy deduction
30078 : : guide. */
30079 : :
30080 : : bool
30081 : 12 : builtin_guide_p (const_tree fn)
30082 : : {
30083 : 12 : if (!deduction_guide_p (fn))
30084 : : return false;
30085 : 12 : if (!DECL_ARTIFICIAL (fn))
30086 : : /* Explicitly declared. */
30087 : : return false;
30088 : 12 : if (DECL_ABSTRACT_ORIGIN (fn))
30089 : : /* Derived from a constructor. */
30090 : 0 : return false;
30091 : : return true;
30092 : : }
30093 : :
30094 : : /* True if FN is a C++23 inherited guide. */
30095 : :
30096 : : bool
30097 : 11222 : inherited_guide_p (const_tree fn)
30098 : : {
30099 : 11222 : gcc_assert (deduction_guide_p (fn));
30100 : 11222 : return LANG_DECL_FN_CHECK (fn)->context != NULL_TREE;
30101 : : }
30102 : :
30103 : : /* Set the base class BASE from which the transformed guide FN
30104 : : was inherited as part of C++23 inherited CTAD. */
30105 : :
30106 : : static void
30107 : 82 : set_inherited_guide_context (const_tree fn, tree base)
30108 : : {
30109 : 82 : gcc_assert (deduction_guide_p (fn));
30110 : 82 : LANG_DECL_FN_CHECK (fn)->context = base;
30111 : 82 : }
30112 : :
30113 : : /* OLDDECL is a _DECL for a template parameter. Return a similar parameter at
30114 : : LEVEL:INDEX, using tsubst_args and complain for substitution into non-type
30115 : : template parameter types. Note that the handling of template template
30116 : : parameters relies on current_template_parms being set appropriately for the
30117 : : new template. */
30118 : :
30119 : : static tree
30120 : 125184 : rewrite_template_parm (tree olddecl, unsigned index, unsigned level,
30121 : : tree tsubst_args, tsubst_flags_t complain)
30122 : : {
30123 : 125184 : if (olddecl == error_mark_node)
30124 : : return error_mark_node;
30125 : :
30126 : 125181 : tree oldidx = get_template_parm_index (olddecl);
30127 : :
30128 : 125181 : tree newtype;
30129 : 125181 : if (TREE_CODE (olddecl) == TYPE_DECL
30130 : 9873 : || TREE_CODE (olddecl) == TEMPLATE_DECL)
30131 : : {
30132 : 115343 : tree oldtype = TREE_TYPE (olddecl);
30133 : 115343 : newtype = cxx_make_type (TREE_CODE (oldtype));
30134 : 115343 : TYPE_MAIN_VARIANT (newtype) = newtype;
30135 : 115343 : }
30136 : : else
30137 : : {
30138 : 9838 : newtype = TREE_TYPE (olddecl);
30139 : 9838 : if (type_uses_auto (newtype))
30140 : : {
30141 : : // Substitute once to fix references to other template parameters.
30142 : 6 : newtype = tsubst (newtype, tsubst_args,
30143 : : complain|tf_partial, NULL_TREE);
30144 : : // Now substitute again to reduce the level of the auto.
30145 : 6 : newtype = tsubst (newtype, current_template_args (),
30146 : : complain, NULL_TREE);
30147 : : }
30148 : : else
30149 : 9832 : newtype = tsubst (newtype, tsubst_args,
30150 : : complain, NULL_TREE);
30151 : : }
30152 : :
30153 : 125181 : tree newdecl
30154 : 125181 : = build_decl (DECL_SOURCE_LOCATION (olddecl), TREE_CODE (olddecl),
30155 : 125181 : DECL_NAME (olddecl), newtype);
30156 : 125181 : SET_DECL_TEMPLATE_PARM_P (newdecl);
30157 : :
30158 : 125181 : tree newidx;
30159 : 125181 : if (TREE_CODE (olddecl) == TYPE_DECL
30160 : 9873 : || TREE_CODE (olddecl) == TEMPLATE_DECL)
30161 : : {
30162 : 115343 : newidx = TEMPLATE_TYPE_PARM_INDEX (newtype)
30163 : 115343 : = build_template_parm_index (index, level, level,
30164 : : newdecl, newtype);
30165 : 230686 : TEMPLATE_PARM_PARAMETER_PACK (newidx)
30166 : 115343 : = TEMPLATE_PARM_PARAMETER_PACK (oldidx);
30167 : 115343 : TYPE_STUB_DECL (newtype) = TYPE_NAME (newtype) = newdecl;
30168 : :
30169 : 115343 : if (TREE_CODE (olddecl) == TEMPLATE_DECL)
30170 : : {
30171 : 35 : tree newresult
30172 : 35 : = build_lang_decl_loc (DECL_SOURCE_LOCATION (olddecl), TYPE_DECL,
30173 : 35 : DECL_NAME (olddecl), newtype);
30174 : 35 : DECL_ARTIFICIAL (newresult) = true;
30175 : 35 : DECL_TEMPLATE_RESULT (newdecl) = newresult;
30176 : : // First create a copy (ttargs) of tsubst_args with an
30177 : : // additional level for the template template parameter's own
30178 : : // template parameters (ttparms).
30179 : 35 : tree ttparms = (INNERMOST_TEMPLATE_PARMS
30180 : 35 : (DECL_TEMPLATE_PARMS (olddecl)));
30181 : 70 : const int depth = TMPL_ARGS_DEPTH (tsubst_args);
30182 : 35 : tree ttargs = make_tree_vec (depth + 1);
30183 : 91 : for (int i = 0; i < depth; ++i)
30184 : 112 : TREE_VEC_ELT (ttargs, i) = TMPL_ARGS_LEVEL (tsubst_args, i + 1);
30185 : 35 : TREE_VEC_ELT (ttargs, depth)
30186 : 35 : = template_parms_level_to_args (ttparms);
30187 : : // Substitute ttargs into ttparms to fix references to
30188 : : // other template parameters.
30189 : 35 : ttparms = tsubst_template_parms_level (ttparms, ttargs,
30190 : : complain|tf_partial);
30191 : : // Now substitute again with args based on tparms, to reduce
30192 : : // the level of the ttparms.
30193 : 35 : ttargs = current_template_args ();
30194 : 35 : ttparms = tsubst_template_parms_level (ttparms, ttargs,
30195 : : complain);
30196 : : // Finally, tack the adjusted parms onto tparms.
30197 : 35 : ttparms = tree_cons (size_int (level + 1), ttparms,
30198 : : copy_node (current_template_parms));
30199 : : // As with all template template parms, the parameter list captured
30200 : : // by this template template parm that corresponds to its own level
30201 : : // should be empty. This avoids infinite recursion when structurally
30202 : : // comparing two such rewritten template template parms (PR102479).
30203 : 35 : gcc_assert (!TREE_VEC_LENGTH
30204 : : (TREE_VALUE (TREE_CHAIN (DECL_TEMPLATE_PARMS (olddecl)))));
30205 : 35 : gcc_assert (TMPL_PARMS_DEPTH (TREE_CHAIN (ttparms)) == level);
30206 : 35 : TREE_VALUE (TREE_CHAIN (ttparms)) = make_tree_vec (0);
30207 : : // All done.
30208 : 35 : DECL_TEMPLATE_PARMS (newdecl) = ttparms;
30209 : 35 : DECL_TEMPLATE_INFO (newresult)
30210 : 70 : = build_template_info (newdecl, template_parms_to_args (ttparms));
30211 : : }
30212 : :
30213 : 115343 : if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (olddecl)))
30214 : 0 : SET_TYPE_STRUCTURAL_EQUALITY (newtype);
30215 : : else
30216 : 115343 : TYPE_CANONICAL (newtype) = canonical_type_parameter (newtype);
30217 : : }
30218 : : else
30219 : : {
30220 : 9838 : tree oldconst = TEMPLATE_PARM_DECL (oldidx);
30221 : 9838 : tree newconst
30222 : 9838 : = build_decl (DECL_SOURCE_LOCATION (oldconst),
30223 : 9838 : TREE_CODE (oldconst),
30224 : 9838 : DECL_NAME (oldconst), newtype);
30225 : 39352 : TREE_CONSTANT (newconst) = TREE_CONSTANT (newdecl)
30226 : 9838 : = TREE_READONLY (newconst) = TREE_READONLY (newdecl) = true;
30227 : 9838 : SET_DECL_TEMPLATE_PARM_P (newconst);
30228 : 9838 : newidx = build_template_parm_index (index, level, level,
30229 : : newconst, newtype);
30230 : 19676 : TEMPLATE_PARM_PARAMETER_PACK (newidx)
30231 : 9838 : = TEMPLATE_PARM_PARAMETER_PACK (oldidx);
30232 : 9838 : DECL_INITIAL (newdecl) = DECL_INITIAL (newconst) = newidx;
30233 : : }
30234 : :
30235 : : return newdecl;
30236 : : }
30237 : :
30238 : : /* As rewrite_template_parm, but for the whole TREE_LIST representing a
30239 : : template parameter. */
30240 : :
30241 : : static tree
30242 : 125184 : rewrite_tparm_list (tree oldelt, unsigned index, unsigned level,
30243 : : tree targs, unsigned targs_index, tsubst_flags_t complain)
30244 : : {
30245 : 125184 : tree olddecl = TREE_VALUE (oldelt);
30246 : 125184 : tree newdecl = rewrite_template_parm (olddecl, index, level,
30247 : : targs, complain);
30248 : 125184 : if (newdecl == error_mark_node)
30249 : : return error_mark_node;
30250 : 125181 : tree newdef = tsubst_template_arg (TREE_PURPOSE (oldelt),
30251 : : targs, complain, NULL_TREE);
30252 : 125181 : tree list = build_tree_list (newdef, newdecl);
30253 : 250362 : TEMPLATE_PARM_CONSTRAINTS (list)
30254 : 125181 : = tsubst_constraint_info (TEMPLATE_PARM_CONSTRAINTS (oldelt),
30255 : : targs, complain, NULL_TREE);
30256 : 250362 : int depth = TMPL_ARGS_DEPTH (targs);
30257 : 250362 : TMPL_ARG (targs, depth, targs_index) = template_parm_to_arg (list);
30258 : 125181 : return list;
30259 : : }
30260 : :
30261 : : /* Returns a C++17 class deduction guide template based on the constructor
30262 : : CTOR. As a special case, CTOR can be a RECORD_TYPE for an implicit default
30263 : : guide, REFERENCE_TYPE for an implicit copy/move guide, or TREE_LIST for an
30264 : : aggregate initialization guide. OUTER_ARGS are the template arguments
30265 : : for the enclosing scope of the class. */
30266 : :
30267 : : static tree
30268 : 90228 : build_deduction_guide (tree type, tree ctor, tree outer_args, tsubst_flags_t complain)
30269 : : {
30270 : 90228 : tree tparms, targs, fparms, fargs, ci;
30271 : 90228 : bool memtmpl = false;
30272 : 90228 : bool explicit_p;
30273 : 90228 : location_t loc;
30274 : 90228 : tree fn_tmpl = NULL_TREE;
30275 : :
30276 : 90228 : if (outer_args)
30277 : : {
30278 : 165 : ++processing_template_decl;
30279 : 165 : type = tsubst (type, outer_args, complain, CLASSTYPE_TI_TEMPLATE (type));
30280 : 165 : --processing_template_decl;
30281 : : }
30282 : :
30283 : 90228 : if (!DECL_DECLARES_FUNCTION_P (ctor))
30284 : : {
30285 : 6421 : if (TYPE_P (ctor))
30286 : : {
30287 : 6109 : bool copy_p = TYPE_REF_P (ctor);
30288 : 6109 : if (copy_p)
30289 : 5642 : fparms = tree_cons (NULL_TREE, type, void_list_node);
30290 : : else
30291 : 467 : fparms = void_list_node;
30292 : : }
30293 : 312 : else if (TREE_CODE (ctor) == TREE_LIST)
30294 : : fparms = ctor;
30295 : : else
30296 : 0 : gcc_unreachable ();
30297 : :
30298 : 6421 : tree ctmpl = CLASSTYPE_TI_TEMPLATE (type);
30299 : 6421 : tparms = DECL_TEMPLATE_PARMS (ctmpl);
30300 : 6421 : targs = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
30301 : 6421 : ci = NULL_TREE;
30302 : 6421 : fargs = NULL_TREE;
30303 : 6421 : loc = DECL_SOURCE_LOCATION (ctmpl);
30304 : 6421 : explicit_p = false;
30305 : : }
30306 : : else
30307 : : {
30308 : 83807 : ++processing_template_decl;
30309 : 83807 : bool ok = true;
30310 : :
30311 : 83807 : complain |= tf_dguide;
30312 : :
30313 : 83807 : fn_tmpl
30314 : 83807 : = (TREE_CODE (ctor) == TEMPLATE_DECL ? ctor
30315 : 12595 : : DECL_TI_TEMPLATE (ctor));
30316 : 83807 : if (outer_args)
30317 : 62 : fn_tmpl = tsubst (fn_tmpl, outer_args, complain, ctor);
30318 : 83807 : ctor = DECL_TEMPLATE_RESULT (fn_tmpl);
30319 : :
30320 : 83807 : tparms = DECL_TEMPLATE_PARMS (fn_tmpl);
30321 : : /* If type is a member class template, DECL_TI_ARGS (ctor) will have
30322 : : fully specialized args for the enclosing class. Strip those off, as
30323 : : the deduction guide won't have those template parameters. */
30324 : 167614 : targs = get_innermost_template_args (DECL_TI_ARGS (ctor),
30325 : 83807 : TMPL_PARMS_DEPTH (tparms));
30326 : : /* Discard the 'this' parameter. */
30327 : 83807 : fparms = FUNCTION_ARG_CHAIN (ctor);
30328 : 83807 : fargs = TREE_CHAIN (DECL_ARGUMENTS (ctor));
30329 : 83807 : ci = get_constraints (ctor);
30330 : 83807 : loc = DECL_SOURCE_LOCATION (ctor);
30331 : 83807 : explicit_p = DECL_NONCONVERTING_P (ctor);
30332 : :
30333 : 83807 : if (PRIMARY_TEMPLATE_P (fn_tmpl))
30334 : : {
30335 : 71212 : memtmpl = true;
30336 : :
30337 : : /* For a member template constructor, we need to flatten the two
30338 : : template parameter lists into one, and then adjust the function
30339 : : signature accordingly. This gets...complicated. */
30340 : 71212 : tree save_parms = current_template_parms;
30341 : :
30342 : : /* For a member template we should have two levels of parms/args, one
30343 : : for the class and one for the constructor. We stripped
30344 : : specialized args for further enclosing classes above. */
30345 : 71212 : const int depth = 2;
30346 : 142424 : gcc_assert (TMPL_ARGS_DEPTH (targs) == depth);
30347 : :
30348 : : /* Template args for translating references to the two-level template
30349 : : parameters into references to the one-level template parameters we
30350 : : are creating. */
30351 : 71212 : tree tsubst_args = copy_node (targs);
30352 : 71212 : TMPL_ARGS_LEVEL (tsubst_args, depth)
30353 : 142424 : = copy_node (TMPL_ARGS_LEVEL (tsubst_args, depth));
30354 : :
30355 : : /* Template parms for the constructor template. */
30356 : 71212 : tree ftparms = TREE_VALUE (tparms);
30357 : 71212 : unsigned flen = TREE_VEC_LENGTH (ftparms);
30358 : : /* Template parms for the class template. */
30359 : 71212 : tparms = TREE_CHAIN (tparms);
30360 : 71212 : tree ctparms = TREE_VALUE (tparms);
30361 : 71212 : unsigned clen = TREE_VEC_LENGTH (ctparms);
30362 : : /* Template parms for the deduction guide start as a copy of the
30363 : : template parms for the class. We set current_template_parms for
30364 : : lookup_template_class_1. */
30365 : 71212 : current_template_parms = tparms = copy_node (tparms);
30366 : 71212 : tree new_vec = TREE_VALUE (tparms) = make_tree_vec (flen + clen);
30367 : 160901 : for (unsigned i = 0; i < clen; ++i)
30368 : 89689 : TREE_VEC_ELT (new_vec, i) = TREE_VEC_ELT (ctparms, i);
30369 : :
30370 : : /* Now we need to rewrite the constructor parms to append them to the
30371 : : class parms. */
30372 : 195960 : for (unsigned i = 0; i < flen; ++i)
30373 : : {
30374 : 124748 : unsigned index = i + clen;
30375 : 124748 : unsigned level = 1;
30376 : 124748 : tree oldelt = TREE_VEC_ELT (ftparms, i);
30377 : 124748 : tree newelt
30378 : 124748 : = rewrite_tparm_list (oldelt, index, level,
30379 : : tsubst_args, i, complain);
30380 : 124748 : if (newelt == error_mark_node)
30381 : 3 : ok = false;
30382 : 124748 : TREE_VEC_ELT (new_vec, index) = newelt;
30383 : : }
30384 : :
30385 : : /* Now we have a final set of template parms to substitute into the
30386 : : function signature. */
30387 : 71212 : targs = template_parms_to_args (tparms);
30388 : 71212 : fparms = tsubst_arg_types (fparms, tsubst_args, NULL_TREE,
30389 : : complain, ctor);
30390 : 71212 : if (fparms == error_mark_node)
30391 : 0 : ok = false;
30392 : 71212 : if (ci)
30393 : : {
30394 : 69331 : if (outer_args)
30395 : : /* FIXME: We'd like to avoid substituting outer template
30396 : : arguments into the constraint ahead of time, but the
30397 : : construction of tsubst_args assumes that outer arguments
30398 : : are already substituted in. */
30399 : 6 : ci = tsubst_constraint_info (ci, outer_args, complain, ctor);
30400 : 69331 : ci = tsubst_constraint_info (ci, tsubst_args, complain, ctor);
30401 : : }
30402 : :
30403 : : /* Parms are to have DECL_CHAIN tsubsted, which would be skipped if
30404 : : cp_unevaluated_operand. */
30405 : 71212 : cp_evaluated ev;
30406 : 71212 : fargs = tsubst (fargs, tsubst_args, complain, ctor);
30407 : 71212 : current_template_parms = save_parms;
30408 : 71212 : }
30409 : : else
30410 : : {
30411 : : /* Substitute in the same arguments to rewrite class members into
30412 : : references to members of an unknown specialization. */
30413 : 12595 : cp_evaluated ev;
30414 : 12595 : fparms = tsubst_arg_types (fparms, targs, NULL_TREE, complain, ctor);
30415 : 12595 : if (fparms == error_mark_node)
30416 : 3 : ok = false;
30417 : 12595 : fargs = tsubst (fargs, targs, complain, ctor);
30418 : 12595 : if (ci)
30419 : : {
30420 : 5671 : if (outer_args)
30421 : : /* FIXME: As above. */
30422 : 6 : ci = tsubst_constraint_info (ci, outer_args, complain, ctor);
30423 : 5671 : ci = tsubst_constraint_info (ci, targs, complain, ctor);
30424 : : }
30425 : 12595 : }
30426 : :
30427 : 83807 : --processing_template_decl;
30428 : 83807 : if (!ok)
30429 : 6 : return error_mark_node;
30430 : : }
30431 : :
30432 : 90222 : if (!memtmpl)
30433 : : {
30434 : : /* Copy the parms so we can set DECL_PRIMARY_TEMPLATE. */
30435 : 19013 : tparms = copy_node (tparms);
30436 : 19013 : INNERMOST_TEMPLATE_PARMS (tparms)
30437 : 19013 : = copy_node (INNERMOST_TEMPLATE_PARMS (tparms));
30438 : : }
30439 : :
30440 : 90222 : tree fntype = build_function_type (type, fparms);
30441 : 90222 : tree ded_fn = build_lang_decl_loc (loc,
30442 : : FUNCTION_DECL,
30443 : : dguide_name (type), fntype);
30444 : 90222 : DECL_ARGUMENTS (ded_fn) = fargs;
30445 : 90222 : DECL_ARTIFICIAL (ded_fn) = true;
30446 : 90222 : DECL_NONCONVERTING_P (ded_fn) = explicit_p;
30447 : 90222 : tree ded_tmpl = build_template_decl (ded_fn, tparms, /*member*/false);
30448 : 90222 : DECL_ARTIFICIAL (ded_tmpl) = true;
30449 : 90222 : DECL_TEMPLATE_INFO (ded_fn) = build_template_info (ded_tmpl, targs);
30450 : 90222 : DECL_PRIMARY_TEMPLATE (ded_tmpl) = ded_tmpl;
30451 : 90222 : if (DECL_P (ctor))
30452 : 83801 : DECL_ABSTRACT_ORIGIN (ded_tmpl) = fn_tmpl;
30453 : 90222 : if (ci)
30454 : 75002 : set_constraints (ded_tmpl, ci);
30455 : :
30456 : : return ded_tmpl;
30457 : : }
30458 : :
30459 : : /* Add to LIST the member types for the reshaped initializer CTOR. */
30460 : :
30461 : : static tree
30462 : 410 : collect_ctor_idx_types (tree ctor, tree list, tree elt = NULL_TREE)
30463 : : {
30464 : 410 : vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (ctor);
30465 : 410 : tree idx, val; unsigned i;
30466 : 838 : FOR_EACH_CONSTRUCTOR_ELT (v, i, idx, val)
30467 : : {
30468 : 386 : tree ftype = elt ? elt : TREE_TYPE (idx);
30469 : 68 : if (BRACE_ENCLOSED_INITIALIZER_P (val)
30470 : 496 : && CONSTRUCTOR_BRACES_ELIDED_P (val))
30471 : : {
30472 : 27 : tree subelt = NULL_TREE;
30473 : 27 : if (TREE_CODE (ftype) == ARRAY_TYPE)
30474 : 21 : subelt = TREE_TYPE (ftype);
30475 : 27 : list = collect_ctor_idx_types (val, list, subelt);
30476 : 27 : continue;
30477 : 27 : }
30478 : 401 : tree arg = NULL_TREE;
30479 : 401 : if (i == v->length() - 1
30480 : 401 : && PACK_EXPANSION_P (ftype))
30481 : : /* Give the trailing pack expansion parameter a default argument to
30482 : : match aggregate initialization behavior, even if we deduce the
30483 : : length of the pack separately to more than we have initializers. */
30484 : 16 : arg = build_constructor (init_list_type_node, NULL);
30485 : : /* if ei is of array type and xi is a braced-init-list or string literal,
30486 : : Ti is an rvalue reference to the declared type of ei */
30487 : 401 : STRIP_ANY_LOCATION_WRAPPER (val);
30488 : 401 : if (TREE_CODE (ftype) == ARRAY_TYPE
30489 : 401 : && (BRACE_ENCLOSED_INITIALIZER_P (val)
30490 : 6 : || TREE_CODE (val) == STRING_CST))
30491 : : {
30492 : 24 : if (TREE_CODE (val) == STRING_CST)
30493 : 6 : ftype = cp_build_qualified_type
30494 : 6 : (ftype, cp_type_quals (ftype) | TYPE_QUAL_CONST);
30495 : 24 : ftype = (cp_build_reference_type
30496 : 30 : (ftype, BRACE_ENCLOSED_INITIALIZER_P (val)));
30497 : : }
30498 : 401 : list = tree_cons (arg, ftype, list);
30499 : : }
30500 : :
30501 : 410 : return list;
30502 : : }
30503 : :
30504 : : /* Return whether ETYPE is, or is derived from, a specialization of TMPL. */
30505 : :
30506 : : static bool
30507 : 2225 : is_spec_or_derived (tree etype, tree tmpl)
30508 : : {
30509 : 2225 : if (!etype || !CLASS_TYPE_P (etype))
30510 : : return false;
30511 : :
30512 : 1187 : etype = cv_unqualified (etype);
30513 : 1187 : tree type = TREE_TYPE (tmpl);
30514 : 1187 : tree tparms = (INNERMOST_TEMPLATE_PARMS
30515 : 1187 : (DECL_TEMPLATE_PARMS (tmpl)));
30516 : 1187 : tree targs = make_tree_vec (TREE_VEC_LENGTH (tparms));
30517 : 1187 : int err = unify (tparms, targs, type, etype,
30518 : : UNIFY_ALLOW_DERIVED, /*explain*/false);
30519 : 1187 : ggc_free (targs);
30520 : 1187 : return !err;
30521 : : }
30522 : :
30523 : : /* Return a C++20 aggregate deduction candidate for TYPE initialized from
30524 : : INIT. */
30525 : :
30526 : : static tree
30527 : 2203 : maybe_aggr_guide (tree tmpl, tree init, vec<tree,va_gc> *args)
30528 : : {
30529 : 2203 : if (cxx_dialect < cxx20)
30530 : : return NULL_TREE;
30531 : :
30532 : 1972 : if (init == NULL_TREE)
30533 : : return NULL_TREE;
30534 : :
30535 : 1926 : if (DECL_ALIAS_TEMPLATE_P (tmpl))
30536 : : {
30537 : 123 : tree under = DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl));
30538 : 123 : tree tinfo = get_template_info (under);
30539 : 123 : if (tree guide = maybe_aggr_guide (TI_TEMPLATE (tinfo), init, args))
30540 : 3 : return alias_ctad_tweaks (tmpl, guide);
30541 : : return NULL_TREE;
30542 : : }
30543 : :
30544 : : /* We might be creating a guide for a class member template, e.g.,
30545 : :
30546 : : template<typename U> struct A {
30547 : : template<typename T> struct B { T t; };
30548 : : };
30549 : :
30550 : : At this point, A will have been instantiated. Below, we need to
30551 : : use both A<U>::B<T> (TEMPLATE_TYPE) and A<int>::B<T> (TYPE) types. */
30552 : 1803 : const bool member_template_p
30553 : 1803 : = (DECL_TEMPLATE_INFO (tmpl)
30554 : 1803 : && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (tmpl)));
30555 : 1803 : tree type = TREE_TYPE (tmpl);
30556 : 1803 : tree template_type = (member_template_p
30557 : 1803 : ? TREE_TYPE (DECL_TI_TEMPLATE (tmpl))
30558 : 1803 : : type);
30559 : 1803 : if (!CP_AGGREGATE_TYPE_P (template_type))
30560 : : return NULL_TREE;
30561 : :
30562 : : /* No aggregate candidate for copy-initialization. */
30563 : 494 : if (args->length() == 1)
30564 : : {
30565 : 482 : tree val = (*args)[0];
30566 : 482 : if (is_spec_or_derived (TREE_TYPE (val), tmpl))
30567 : : return NULL_TREE;
30568 : : }
30569 : :
30570 : : /* If we encounter a problem, we just won't add the candidate. */
30571 : 415 : tsubst_flags_t complain = tf_none;
30572 : :
30573 : 415 : tree parms = NULL_TREE;
30574 : 415 : if (BRACE_ENCLOSED_INITIALIZER_P (init))
30575 : : {
30576 : 394 : init = reshape_init (template_type, init, complain);
30577 : 394 : if (init == error_mark_node)
30578 : : return NULL_TREE;
30579 : 383 : parms = collect_ctor_idx_types (init, parms);
30580 : : }
30581 : 21 : else if (TREE_CODE (init) == TREE_LIST)
30582 : : {
30583 : 20 : int len = list_length (init);
30584 : 40 : for (tree binfo : BINFO_BASE_BINFOS (TYPE_BINFO (template_type)))
30585 : : {
30586 : 20 : if (!len)
30587 : : break;
30588 : 20 : parms = tree_cons (NULL_TREE, BINFO_TYPE (binfo), parms);
30589 : 20 : --len;
30590 : : }
30591 : 20 : for (tree field = TYPE_FIELDS (template_type);
30592 : 29 : len;
30593 : 9 : --len, field = DECL_CHAIN (field))
30594 : : {
30595 : 12 : field = next_aggregate_field (field);
30596 : 12 : if (!field)
30597 : : return NULL_TREE;
30598 : 9 : tree ftype = finish_decltype_type (field, true, complain);
30599 : 9 : parms = tree_cons (NULL_TREE, ftype, parms);
30600 : : }
30601 : : }
30602 : : else
30603 : : /* Aggregate initialization doesn't apply to an initializer expression. */
30604 : : return NULL_TREE;
30605 : :
30606 : : /* If we're creating a deduction guide for a member class template,
30607 : : we've used the original template pattern type for the reshape_init
30608 : : above; this is done because we want PARMS to be a template parameter
30609 : : type, something that can be deduced when used as a function template
30610 : : parameter. At this point the outer class template has already been
30611 : : partially instantiated (we deferred the deduction until the enclosing
30612 : : scope is non-dependent). Therefore we have to partially instantiate
30613 : : PARMS, so that its template level is properly reduced and we don't get
30614 : : mismatches when deducing types using the guide with PARMS. */
30615 : 400 : if (member_template_p)
30616 : : {
30617 : 22 : ++processing_template_decl;
30618 : 22 : parms = tsubst (parms, outer_template_args (tmpl), complain, init);
30619 : 22 : --processing_template_decl;
30620 : : }
30621 : :
30622 : 400 : if (parms)
30623 : : {
30624 : 312 : tree last = parms;
30625 : 312 : parms = nreverse (parms);
30626 : 312 : TREE_CHAIN (last) = void_list_node;
30627 : 312 : tree guide = build_deduction_guide (type, parms, NULL_TREE, complain);
30628 : 312 : return guide;
30629 : : }
30630 : :
30631 : : return NULL_TREE;
30632 : : }
30633 : :
30634 : : /* UGUIDES are the deduction guides for the underlying template of alias
30635 : : template TMPL; adjust them to be deduction guides for TMPL.
30636 : :
30637 : : This routine also handles C++23 inherited CTAD, in which case TMPL is a
30638 : : TREE_LIST representing a synthetic alias template whose TREE_PURPOSE is
30639 : : the template parameter list of the alias template (equivalently, of the
30640 : : derived class) and TREE_VALUE the defining-type-id (equivalently, the
30641 : : base whose guides we're inheriting). UGUIDES are the base's guides. */
30642 : :
30643 : : static tree
30644 : 142 : alias_ctad_tweaks (tree tmpl, tree uguides)
30645 : : {
30646 : : /* [over.match.class.deduct]: When resolving a placeholder for a deduced
30647 : : class type (9.2.8.2) where the template-name names an alias template A,
30648 : : the defining-type-id of A must be of the form
30649 : :
30650 : : typename(opt) nested-name-specifier(opt) template(opt) simple-template-id
30651 : :
30652 : : as specified in 9.2.8.2. The guides of A are the set of functions or
30653 : : function templates formed as follows. For each function or function
30654 : : template f in the guides of the template named by the simple-template-id
30655 : : of the defining-type-id, the template arguments of the return type of f
30656 : : are deduced from the defining-type-id of A according to the process in
30657 : : 13.10.2.5 with the exception that deduction does not fail if not all
30658 : : template arguments are deduced. Let g denote the result of substituting
30659 : : these deductions into f. If substitution succeeds, form a function or
30660 : : function template f' with the following properties and add it to the set
30661 : : of guides of A:
30662 : :
30663 : : * The function type of f' is the function type of g.
30664 : :
30665 : : * If f is a function template, f' is a function template whose template
30666 : : parameter list consists of all the template parameters of A (including
30667 : : their default template arguments) that appear in the above deductions or
30668 : : (recursively) in their default template arguments, followed by the
30669 : : template parameters of f that were not deduced (including their default
30670 : : template arguments), otherwise f' is not a function template.
30671 : :
30672 : : * The associated constraints (13.5.2) are the conjunction of the
30673 : : associated constraints of g and a constraint that is satisfied if and only
30674 : : if the arguments of A are deducible (see below) from the return type.
30675 : :
30676 : : * If f is a copy deduction candidate (12.4.1.8), then f' is considered to
30677 : : be so as well.
30678 : :
30679 : : * If f was generated from a deduction-guide (12.4.1.8), then f' is
30680 : : considered to be so as well.
30681 : :
30682 : : * The explicit-specifier of f' is the explicit-specifier of g (if
30683 : : any). */
30684 : :
30685 : 142 : enum { alias, inherited } ctad_kind;
30686 : 142 : tree atype, fullatparms, utype, name;
30687 : 142 : if (TREE_CODE (tmpl) == TEMPLATE_DECL)
30688 : : {
30689 : 108 : ctad_kind = alias;
30690 : 108 : atype = TREE_TYPE (tmpl);
30691 : 108 : fullatparms = DECL_TEMPLATE_PARMS (tmpl);
30692 : 108 : utype = DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl));
30693 : 108 : name = dguide_name (tmpl);
30694 : : }
30695 : : else
30696 : : {
30697 : 34 : ctad_kind = inherited;
30698 : 34 : atype = NULL_TREE;
30699 : 34 : fullatparms = TREE_PURPOSE (tmpl);
30700 : 34 : utype = TREE_VALUE (tmpl);
30701 : 34 : name = dguide_name (TPARMS_PRIMARY_TEMPLATE
30702 : : (INNERMOST_TEMPLATE_PARMS (fullatparms)));
30703 : : }
30704 : :
30705 : 142 : tsubst_flags_t complain = tf_none;
30706 : 142 : tree aguides = NULL_TREE;
30707 : 142 : tree atparms = INNERMOST_TEMPLATE_PARMS (fullatparms);
30708 : 142 : unsigned natparms = TREE_VEC_LENGTH (atparms);
30709 : 879 : for (ovl_iterator iter (uguides); iter; ++iter)
30710 : : {
30711 : 370 : tree f = *iter;
30712 : 370 : tree in_decl = f;
30713 : 370 : location_t loc = DECL_SOURCE_LOCATION (f);
30714 : 370 : tree ret = TREE_TYPE (TREE_TYPE (f));
30715 : 370 : tree fprime = f;
30716 : 370 : if (TREE_CODE (f) == TEMPLATE_DECL)
30717 : : {
30718 : 361 : processing_template_decl_sentinel ptds (/*reset*/false);
30719 : 361 : ++processing_template_decl;
30720 : :
30721 : : /* Deduce template arguments for f from the type-id of A. */
30722 : 361 : tree ftparms = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (f));
30723 : 361 : unsigned len = TREE_VEC_LENGTH (ftparms);
30724 : 361 : tree targs = make_tree_vec (len);
30725 : 361 : int err = unify (ftparms, targs, ret, utype, UNIFY_ALLOW_NONE, false);
30726 : 361 : if (err)
30727 : : /* CWG2664: Discard any deductions, still build the guide. */
30728 : 28 : for (unsigned i = 0; i < len; ++i)
30729 : 14 : TREE_VEC_ELT (targs, i) = NULL_TREE;
30730 : :
30731 : : /* The number of parms for f' is the number of parms of A used in
30732 : : the deduced arguments plus non-deduced parms of f. */
30733 : : unsigned ndlen = 0;
30734 : : unsigned j;
30735 : 994 : for (unsigned i = 0; i < len; ++i)
30736 : 633 : if (TREE_VEC_ELT (targs, i) == NULL_TREE)
30737 : 66 : ++ndlen;
30738 : 361 : find_template_parameter_info ftpi (fullatparms);
30739 : 361 : ftpi.find_in_recursive (targs);
30740 : 361 : unsigned nusedatparms = ftpi.num_found ();
30741 : 361 : unsigned nfparms = nusedatparms + ndlen;
30742 : 361 : tree gtparms = make_tree_vec (nfparms);
30743 : :
30744 : : /* Set current_template_parms as in build_deduction_guide. */
30745 : 361 : auto ctp = make_temp_override (current_template_parms);
30746 : 361 : current_template_parms = copy_node (fullatparms);
30747 : 361 : TREE_VALUE (current_template_parms) = gtparms;
30748 : :
30749 : 361 : j = 0;
30750 : 361 : unsigned level = 1;
30751 : :
30752 : : /* First copy over the used parms of A. */
30753 : 361 : tree atargs = make_tree_vec (natparms);
30754 : 792 : for (unsigned i = 0; i < natparms; ++i)
30755 : : {
30756 : 431 : tree elt = TREE_VEC_ELT (atparms, i);
30757 : 431 : if (ftpi.found (elt))
30758 : : {
30759 : 370 : unsigned index = j++;
30760 : 370 : tree nelt = rewrite_tparm_list (elt, index, level,
30761 : : atargs, i, complain);
30762 : 370 : TREE_VEC_ELT (gtparms, index) = nelt;
30763 : : }
30764 : : }
30765 : 361 : gcc_checking_assert (j == nusedatparms);
30766 : :
30767 : : /* Adjust the deduced template args for f to refer to the A parms
30768 : : with their new indexes. */
30769 : 361 : if (nusedatparms && nusedatparms != natparms)
30770 : 18 : targs = tsubst_template_args (targs, atargs, complain, in_decl);
30771 : :
30772 : : /* Now rewrite the non-deduced parms of f. */
30773 : 477 : for (unsigned i = 0; ndlen && i < len; ++i)
30774 : 116 : if (TREE_VEC_ELT (targs, i) == NULL_TREE)
30775 : : {
30776 : 66 : --ndlen;
30777 : 66 : unsigned index = j++;
30778 : 66 : tree oldlist = TREE_VEC_ELT (ftparms, i);
30779 : 66 : tree list = rewrite_tparm_list (oldlist, index, level,
30780 : : targs, i, complain);
30781 : 66 : TREE_VEC_ELT (gtparms, index) = list;
30782 : : }
30783 : 361 : gtparms = build_tree_list (size_one_node, gtparms);
30784 : :
30785 : : /* Substitute the deduced arguments plus the rewritten template
30786 : : parameters into f to get g. This covers the type, copyness,
30787 : : guideness, and explicit-specifier. */
30788 : 361 : tree g;
30789 : 361 : {
30790 : : /* Parms are to have DECL_CHAIN tsubsted, which would be skipped
30791 : : if cp_unevaluated_operand. */
30792 : 361 : cp_evaluated ev;
30793 : 361 : g = tsubst_decl (DECL_TEMPLATE_RESULT (f), targs, complain,
30794 : : /*use_spec_table=*/false);
30795 : 361 : }
30796 : 361 : if (g == error_mark_node)
30797 : 3 : continue;
30798 : 358 : DECL_NAME (g) = name;
30799 : 358 : if (nfparms == 0)
30800 : : {
30801 : : /* The targs are all non-dependent, so g isn't a template. */
30802 : 18 : fprime = g;
30803 : 18 : ret = TREE_TYPE (TREE_TYPE (fprime));
30804 : 18 : goto non_template;
30805 : : }
30806 : 340 : DECL_USE_TEMPLATE (g) = 0;
30807 : 340 : fprime = build_template_decl (g, gtparms, false);
30808 : 340 : DECL_TEMPLATE_RESULT (fprime) = g;
30809 : 340 : TREE_TYPE (fprime) = TREE_TYPE (g);
30810 : 340 : tree gtargs = template_parms_to_args (gtparms);
30811 : 340 : DECL_TEMPLATE_INFO (g) = build_template_info (fprime, gtargs);
30812 : 340 : DECL_PRIMARY_TEMPLATE (fprime) = fprime;
30813 : :
30814 : : /* Substitute the associated constraints. */
30815 : 340 : tree ci = get_constraints (f);
30816 : 340 : if (ci)
30817 : : {
30818 : 28 : if (tree outer_targs = outer_template_args (f))
30819 : 6 : ci = tsubst_constraint_info (ci, outer_targs, complain, in_decl);
30820 : 28 : ci = tsubst_constraint_info (ci, targs, complain, in_decl);
30821 : : }
30822 : 340 : if (ci == error_mark_node)
30823 : 0 : continue;
30824 : :
30825 : : /* Add a constraint that the return type matches the instantiation of
30826 : : A with the same template arguments. */
30827 : 340 : ret = TREE_TYPE (TREE_TYPE (fprime));
30828 : 340 : if (ctad_kind == alias
30829 : : /* Use template_args_equal instead of same_type_p to get the
30830 : : comparing_dependent_aliases behavior. */
30831 : 340 : && !template_args_equal (atype, ret))
30832 : : {
30833 : 60 : tree same = finish_trait_expr (loc, CPTK_IS_DEDUCIBLE, tmpl, ret);
30834 : 60 : ci = append_constraint (ci, same);
30835 : : }
30836 : :
30837 : 340 : if (ci)
30838 : : {
30839 : 78 : remove_constraints (fprime);
30840 : 78 : set_constraints (fprime, ci);
30841 : : }
30842 : 722 : }
30843 : : else
30844 : : {
30845 : : /* For a non-template deduction guide, if the arguments of A aren't
30846 : : deducible from the return type, don't add the candidate. */
30847 : 9 : non_template:
30848 : 30 : if (ctad_kind == alias
30849 : 27 : && !type_targs_deducible_from (tmpl, ret))
30850 : 3 : continue;
30851 : : }
30852 : :
30853 : : /* Rewrite the return type of the inherited guide in terms of the
30854 : : derived class. This is specified as replacing the return type R
30855 : : with typename CC<R>::type where the partially specialized CC maps a
30856 : : base class specialization to a specialization of the derived class
30857 : : having such a base (inducing substitution failure if no such derived
30858 : : class exists).
30859 : :
30860 : : As specified this mapping would be done at instantiation time using
30861 : : non-dependent template arguments, but we do it ahead of time using
30862 : : the generic arguments. This seems to be good enough since generic
30863 : : deduction should succeed only if concrete deduction would. */
30864 : 364 : if (ctad_kind == inherited)
30865 : : {
30866 : 88 : processing_template_decl_sentinel ptds (/*reset*/false);
30867 : 88 : if (TREE_CODE (fprime) == TEMPLATE_DECL)
30868 : 74 : ++processing_template_decl;
30869 : :
30870 : 88 : tree targs = type_targs_deducible_from (tmpl, ret);
30871 : 88 : if (!targs)
30872 : 6 : continue;
30873 : :
30874 : 82 : if (TREE_CODE (f) != TEMPLATE_DECL)
30875 : 4 : fprime = copy_decl (fprime);
30876 : 82 : tree fntype = TREE_TYPE (fprime);
30877 : 82 : ret = lookup_template_class (TPARMS_PRIMARY_TEMPLATE (atparms), targs,
30878 : : in_decl, NULL_TREE, complain);
30879 : 82 : fntype = build_function_type (ret, TYPE_ARG_TYPES (fntype));
30880 : 82 : TREE_TYPE (fprime) = fntype;
30881 : 82 : if (TREE_CODE (fprime) == TEMPLATE_DECL)
30882 : 74 : TREE_TYPE (DECL_TEMPLATE_RESULT (fprime)) = fntype;
30883 : 82 : set_inherited_guide_context (fprime, utype);
30884 : 88 : }
30885 : :
30886 : 358 : aguides = lookup_add (fprime, aguides);
30887 : : }
30888 : :
30889 : 142 : return aguides;
30890 : : }
30891 : :
30892 : : /* CTOR is a using-decl inheriting the constructors of some base of the class
30893 : : template TMPL; adjust the base's guides be deduction guides for TMPL. */
30894 : :
30895 : : static tree
30896 : 40 : inherited_ctad_tweaks (tree tmpl, tree ctor, tsubst_flags_t complain)
30897 : : {
30898 : : /* [over.match.class.deduct]: In addition, if C is defined and inherits
30899 : : constructors ([namespace.udecl]) from a direct base class denoted in the
30900 : : base-specifier-list by a class-or-decltype B, let A be an alias template
30901 : : whose template parameter list is that of C and whose defining-type-id is
30902 : : B. If A is a deducible template ([dcl.type.simple]), the set contains the
30903 : : guides of A with the return type R of each guide replaced with typename
30904 : : CC::type given a class template
30905 : :
30906 : : template <typename> class CC;
30907 : :
30908 : : whose primary template is not defined and with a single partial
30909 : : specialization whose template parameter list is that of A and whose
30910 : : template argument list is a specialization of A with the template argument
30911 : : list of A ([temp.dep.type]) having a member typedef type designating a
30912 : : template specialization with the template argument list of A but with C as
30913 : : the template. */
30914 : :
30915 : 40 : tree scope = USING_DECL_SCOPE (ctor);
30916 : 40 : if (TREE_CODE (scope) == TYPENAME_TYPE
30917 : 40 : && (TYPE_IDENTIFIER (TYPE_CONTEXT (scope))
30918 : 6 : == TYPENAME_TYPE_FULLNAME (scope)))
30919 : : /* Recognize using B<T>::B::B as an inherited constructor. */
30920 : : /* FIXME: Also recognize using C::B::B? We might have to call
30921 : : resolve_typename_type for that. */
30922 : 4 : scope = TYPE_CONTEXT (scope);
30923 : 38 : if (!CLASS_TYPE_P (scope)
30924 : 38 : || !CLASSTYPE_TEMPLATE_INFO (scope)
30925 : 74 : || !PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (scope)))
30926 : : return NULL_TREE;
30927 : :
30928 : 34 : tree t = build_tree_list (DECL_TEMPLATE_PARMS (tmpl), scope);
30929 : 34 : bool any_dguides_p;
30930 : 34 : tree uguides = deduction_guides_for (CLASSTYPE_TI_TEMPLATE (scope),
30931 : : any_dguides_p, complain);
30932 : 34 : return alias_ctad_tweaks (t, uguides);
30933 : : }
30934 : :
30935 : : /* If template arguments for TMPL can be deduced from TYPE, return
30936 : : the deduced arguments, otherwise return NULL_TREE.
30937 : : Used to implement CPTK_IS_DEDUCIBLE for alias CTAD according to
30938 : : [over.match.class.deduct].
30939 : :
30940 : : This check is specified in terms of partial specialization, so the behavior
30941 : : should be parallel to that of get_partial_spec_bindings. */
30942 : :
30943 : : tree
30944 : 175 : type_targs_deducible_from (tree tmpl, tree type)
30945 : : {
30946 : 175 : tree tparms, ttype;
30947 : 175 : if (TREE_CODE (tmpl) == TEMPLATE_DECL)
30948 : : {
30949 : : /* If tmpl is a class template, this is trivial: it's deducible if
30950 : : TYPE is a specialization of TMPL. */
30951 : 87 : if (DECL_CLASS_TEMPLATE_P (tmpl))
30952 : : {
30953 : 0 : if (CLASS_TYPE_P (type)
30954 : 0 : && CLASSTYPE_TEMPLATE_INFO (type)
30955 : 0 : && CLASSTYPE_TI_TEMPLATE (type) == tmpl)
30956 : 0 : return INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
30957 : : else
30958 : : return NULL_TREE;
30959 : : }
30960 : :
30961 : : /* Otherwise it's an alias template. */
30962 : 87 : tparms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl);
30963 : 87 : ttype = TREE_TYPE (tmpl);
30964 : : }
30965 : : else
30966 : : {
30967 : : /* TMPL is a synthetic alias template represented as a TREE_LIST as
30968 : : per alias_ctad_tweaks. */
30969 : 88 : tparms = INNERMOST_TEMPLATE_PARMS (TREE_PURPOSE (tmpl));
30970 : 88 : ttype = TREE_VALUE (tmpl);
30971 : 176 : tmpl = TI_TEMPLATE (TYPE_TEMPLATE_INFO_MAYBE_ALIAS (ttype));
30972 : : }
30973 : :
30974 : 175 : int len = TREE_VEC_LENGTH (tparms);
30975 : 175 : tree targs = make_tree_vec (len);
30976 : 175 : bool tried_array_deduction = (cxx_dialect < cxx17);
30977 : :
30978 : 175 : again:
30979 : 175 : if (unify (tparms, targs, ttype, type,
30980 : : UNIFY_ALLOW_NONE, false))
30981 : : return NULL_TREE;
30982 : :
30983 : : /* We don't fail on an undeduced targ the second time through (like
30984 : : get_partial_spec_bindings) because we're going to try defaults. */
30985 : 347 : for (int i = 0; i < len; ++i)
30986 : 197 : if (! TREE_VEC_ELT (targs, i))
30987 : : {
30988 : 48 : tree tparm = TREE_VEC_ELT (tparms, i);
30989 : 48 : tparm = TREE_VALUE (tparm);
30990 : :
30991 : 48 : if (!tried_array_deduction
30992 : 36 : && TREE_CODE (tparm) == TYPE_DECL)
30993 : : {
30994 : 30 : try_array_deduction (tparms, targs, ttype);
30995 : 30 : tried_array_deduction = true;
30996 : 30 : if (TREE_VEC_ELT (targs, i))
30997 : 0 : goto again;
30998 : : }
30999 : : /* If the type parameter is a parameter pack, then it will be deduced
31000 : : to an empty parameter pack. This is another case that doesn't model
31001 : : well as partial specialization. */
31002 : 48 : if (template_parameter_pack_p (tparm))
31003 : : {
31004 : 6 : tree arg;
31005 : 6 : if (TREE_CODE (tparm) == PARM_DECL)
31006 : : {
31007 : 6 : arg = make_node (NONTYPE_ARGUMENT_PACK);
31008 : 6 : TREE_CONSTANT (arg) = 1;
31009 : : }
31010 : : else
31011 : 0 : arg = cxx_make_type (TYPE_ARGUMENT_PACK);
31012 : 6 : ARGUMENT_PACK_ARGS (arg) = make_tree_vec (0);
31013 : 6 : TREE_VEC_ELT (targs, i) = arg;
31014 : : }
31015 : : }
31016 : :
31017 : : /* Maybe add in default template args. This seems like a flaw in the
31018 : : specification in terms of partial specialization, since it says the
31019 : : partial specialization has the template parameter list of A, but a
31020 : : partial specialization can't have default targs. */
31021 : 150 : targs = coerce_template_parms (tparms, targs, tmpl, tf_none);
31022 : 150 : if (targs == error_mark_node)
31023 : : return NULL_TREE;
31024 : :
31025 : : /* I believe we don't need the template_template_parm_bindings_ok_p call
31026 : : because coerce_template_parms did coerce_template_template_parms. */
31027 : :
31028 : 128 : if (!constraints_satisfied_p (tmpl, targs))
31029 : : return NULL_TREE;
31030 : :
31031 : : return targs;
31032 : : }
31033 : :
31034 : : /* Return artificial deduction guides built from the constructors of class
31035 : : template TMPL. */
31036 : :
31037 : : static tree
31038 : 5642 : ctor_deduction_guides_for (tree tmpl, tsubst_flags_t complain)
31039 : : {
31040 : 5642 : tree outer_args = outer_template_args (tmpl);
31041 : 5642 : tree type = TREE_TYPE (most_general_template (tmpl));
31042 : :
31043 : 5642 : tree cands = NULL_TREE;
31044 : :
31045 : 168430 : for (ovl_iterator iter (CLASSTYPE_CONSTRUCTORS (type)); iter; ++iter)
31046 : : {
31047 : : /* We handle C++23 inherited CTAD below. */
31048 : 83836 : if (iter.using_p ())
31049 : 29 : continue;
31050 : :
31051 : 83807 : tree guide = build_deduction_guide (type, *iter, outer_args, complain);
31052 : 83807 : cands = lookup_add (guide, cands);
31053 : : }
31054 : :
31055 : 5642 : if (cxx_dialect >= cxx23)
31056 : : /* FIXME: CLASSTYPE_CONSTRUCTORS doesn't contain inherited constructors if
31057 : : e.g. the class also has a user-defined constructor. So instead iterate
31058 : : over TYPE_FIELDS manually to robustly find all relevant using-decls. */
31059 : 198326 : for (tree field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
31060 : 194480 : if (TREE_CODE (field) == USING_DECL
31061 : 194480 : && DECL_NAME (field) == ctor_identifier)
31062 : : {
31063 : 40 : tree uguides = inherited_ctad_tweaks (tmpl, field, complain);
31064 : 40 : if (uguides)
31065 : 32 : cands = lookup_add (uguides, cands);
31066 : : }
31067 : :
31068 : : /* Add implicit default constructor deduction guide. */
31069 : 5642 : if (!TYPE_HAS_USER_CONSTRUCTOR (type))
31070 : : {
31071 : 467 : tree guide = build_deduction_guide (type, type, outer_args,
31072 : : complain);
31073 : 467 : cands = lookup_add (guide, cands);
31074 : : }
31075 : :
31076 : : /* Add copy guide. */
31077 : 5642 : {
31078 : 5642 : tree gtype = build_reference_type (type);
31079 : 5642 : tree guide = build_deduction_guide (type, gtype, outer_args,
31080 : : complain);
31081 : 5642 : cands = lookup_add (guide, cands);
31082 : : }
31083 : :
31084 : 5642 : return cands;
31085 : : }
31086 : :
31087 : : static GTY((deletable)) hash_map<tree, tree_pair_p> *dguide_cache;
31088 : :
31089 : : /* Return the non-aggregate deduction guides for deducible template TMPL. The
31090 : : aggregate candidate is added separately because it depends on the
31091 : : initializer. Set ANY_DGUIDES_P if we find a non-implicit deduction
31092 : : guide. */
31093 : :
31094 : : static tree
31095 : 12375 : deduction_guides_for (tree tmpl, bool &any_dguides_p, tsubst_flags_t complain)
31096 : : {
31097 : 12375 : tree guides = NULL_TREE;
31098 : 12375 : if (DECL_ALIAS_TEMPLATE_P (tmpl))
31099 : : {
31100 : 198 : tree under = DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl));
31101 : 198 : tree tinfo = get_template_info (under);
31102 : 198 : guides = deduction_guides_for (TI_TEMPLATE (tinfo), any_dguides_p,
31103 : : complain);
31104 : : }
31105 : : else
31106 : : {
31107 : 12177 : guides = lookup_qualified_name (CP_DECL_CONTEXT (tmpl),
31108 : : dguide_name (tmpl),
31109 : : LOOK_want::ANY_REACHABLE,
31110 : : /*complain=*/false);
31111 : 12177 : if (guides == error_mark_node)
31112 : : guides = NULL_TREE;
31113 : : else
31114 : 10063 : any_dguides_p = true;
31115 : : }
31116 : :
31117 : : /* Cache the deduction guides for a template. We also remember the result of
31118 : : lookup, and rebuild everything if it changes; should be very rare. */
31119 : : /* FIXME: Also rebuild if this is a class template that inherits guides from a
31120 : : base class, and lookup for the latter changed. */
31121 : 12375 : tree_pair_p cache = NULL;
31122 : 24750 : if (tree_pair_p &r
31123 : 12375 : = hash_map_safe_get_or_insert<hm_ggc> (dguide_cache, tmpl))
31124 : : {
31125 : 6654 : cache = r;
31126 : 6654 : if (cache->purpose == guides)
31127 : 6628 : return cache->value;
31128 : : }
31129 : : else
31130 : : {
31131 : 5721 : r = cache = ggc_cleared_alloc<tree_pair_s> ();
31132 : 5721 : cache->purpose = guides;
31133 : : }
31134 : :
31135 : 5747 : tree cands = NULL_TREE;
31136 : 5747 : if (DECL_ALIAS_TEMPLATE_P (tmpl))
31137 : 105 : cands = alias_ctad_tweaks (tmpl, guides);
31138 : : else
31139 : : {
31140 : 5642 : cands = ctor_deduction_guides_for (tmpl, complain);
31141 : 25230 : for (lkp_iterator it (guides); it; ++it)
31142 : 19588 : cands = lookup_add (*it, cands);
31143 : : }
31144 : :
31145 : 5747 : cache->value = cands;
31146 : 5747 : return cands;
31147 : : }
31148 : :
31149 : : /* Return whether TMPL is a (class template argument-) deducible template. */
31150 : :
31151 : : bool
31152 : 708790083 : ctad_template_p (tree tmpl)
31153 : : {
31154 : : /* A deducible template is either a class template or is an alias template
31155 : : whose defining-type-id is of the form
31156 : :
31157 : : typename(opt) nested-name-specifier(opt) template(opt) simple-template-id
31158 : :
31159 : : where the nested-name-specifier (if any) is non-dependent and the
31160 : : template-name of the simple-template-id names a deducible template. */
31161 : :
31162 : 9139050 : if (DECL_CLASS_TEMPLATE_P (tmpl)
31163 : 716269378 : && IDENTIFIER_TRAIT_P (DECL_NAME (tmpl)))
31164 : : /* Don't consider CTAD for templates with the same name as a trait; that
31165 : : is ambiguous with e.g. __is_invocable(_Fn,_Args...). */
31166 : : return false;
31167 : 9084750 : if (DECL_CLASS_TEMPLATE_P (tmpl)
31168 : 710443976 : || DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl))
31169 : : return true;
31170 : 701203918 : if (!DECL_ALIAS_TEMPLATE_P (tmpl))
31171 : : return false;
31172 : 129476 : tree orig = DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl));
31173 : 129476 : if (tree tinfo = get_template_info (orig))
31174 : 24219 : return ctad_template_p (TI_TEMPLATE (tinfo));
31175 : : return false;
31176 : : }
31177 : :
31178 : : /* Deduce template arguments for the class template placeholder PTYPE for
31179 : : template TMPL based on the initializer INIT, and return the resulting
31180 : : type. */
31181 : :
31182 : : static tree
31183 : 12418 : do_class_deduction (tree ptype, tree tmpl, tree init, tree outer_targs,
31184 : : int flags, tsubst_flags_t complain)
31185 : : {
31186 : : /* We should have handled this in the caller. */
31187 : 12418 : if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl))
31188 : : return ptype;
31189 : :
31190 : : /* If the class was erroneous, don't try to deduce, because that
31191 : : can generate a lot of diagnostic. */
31192 : 12311 : if (TREE_TYPE (tmpl)
31193 : 12311 : && TYPE_LANG_SPECIFIC (TREE_TYPE (tmpl))
31194 : 24619 : && CLASSTYPE_ERRONEOUS (TREE_TYPE (tmpl)))
31195 : : return ptype;
31196 : :
31197 : : /* Wait until the enclosing scope is non-dependent. */
31198 : 24614 : if (DECL_CLASS_SCOPE_P (tmpl)
31199 : 12466 : && dependent_type_p (DECL_CONTEXT (tmpl)))
31200 : : return ptype;
31201 : :
31202 : : /* Initializing one placeholder from another. */
31203 : 12286 : if (init
31204 : 12165 : && (TREE_CODE (init) == TEMPLATE_PARM_INDEX
31205 : 12070 : || (TREE_CODE (init) == EXPR_PACK_EXPANSION
31206 : 3 : && (TREE_CODE (PACK_EXPANSION_PATTERN (init))
31207 : : == TEMPLATE_PARM_INDEX)))
31208 : 98 : && is_auto (TREE_TYPE (init))
31209 : 12384 : && CLASS_PLACEHOLDER_TEMPLATE (TREE_TYPE (init)) == tmpl)
31210 : 38 : return cp_build_qualified_type (TREE_TYPE (init), cp_type_quals (ptype));
31211 : :
31212 : 12248 : if (!ctad_template_p (tmpl))
31213 : : {
31214 : 3 : if (complain & tf_error)
31215 : 3 : error ("non-deducible template %qT used without template arguments", tmpl);
31216 : 3 : return error_mark_node;
31217 : : }
31218 : 12245 : else if (cxx_dialect < cxx20 && DECL_ALIAS_TEMPLATE_P (tmpl))
31219 : : {
31220 : 7 : if (complain & tf_error)
31221 : : {
31222 : : /* Be permissive with equivalent alias templates. */
31223 : 7 : tree u = get_underlying_template (tmpl);
31224 : 7 : auto_diagnostic_group d;
31225 : 7 : diagnostic_t dk = (u == tmpl) ? DK_ERROR : DK_PEDWARN;
31226 : 7 : bool complained
31227 : 7 : = emit_diagnostic (dk, input_location, 0,
31228 : : "alias template deduction only available "
31229 : : "with %<-std=c++20%> or %<-std=gnu++20%>");
31230 : 7 : if (u == tmpl)
31231 : 6 : return error_mark_node;
31232 : 1 : else if (complained)
31233 : : {
31234 : 1 : inform (input_location, "use %qD directly instead", u);
31235 : 1 : tmpl = u;
31236 : : }
31237 : 7 : }
31238 : : else
31239 : 0 : return error_mark_node;
31240 : : }
31241 : :
31242 : : /* Wait until the initializer is non-dependent. */
31243 : 12239 : if (type_dependent_expression_p (init))
31244 : : return ptype;
31245 : :
31246 : 12149 : if (outer_targs)
31247 : : {
31248 : 99 : int args_depth = TMPL_ARGS_DEPTH (outer_targs);
31249 : 99 : int parms_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
31250 : 99 : if (parms_depth > 1)
31251 : : {
31252 : : /* Substitute outer arguments into this CTAD template from the
31253 : : current instantiation. */
31254 : 3 : int want = std::min (args_depth, parms_depth - 1);
31255 : 3 : outer_targs = strip_innermost_template_args (outer_targs,
31256 : : args_depth - want);
31257 : 3 : tmpl = tsubst (tmpl, outer_targs, complain, NULL_TREE);
31258 : 3 : if (tmpl == error_mark_node)
31259 : 0 : return error_mark_node;
31260 : : }
31261 : : }
31262 : :
31263 : : /* Don't bother with the alias rules for an equivalent template. */
31264 : 12149 : tmpl = get_underlying_template (tmpl);
31265 : :
31266 : 12149 : tree type = TREE_TYPE (tmpl);
31267 : :
31268 : 12149 : bool try_list_cand = false;
31269 : 12149 : bool list_init_p = false;
31270 : :
31271 : 12149 : releasing_vec rv_args = NULL;
31272 : 12149 : vec<tree,va_gc> *&args = *&rv_args;
31273 : 12149 : if (init == NULL_TREE)
31274 : 120 : args = make_tree_vector ();
31275 : 12029 : else if (BRACE_ENCLOSED_INITIALIZER_P (init))
31276 : : {
31277 : 3940 : list_init_p = true;
31278 : 3940 : try_list_cand = true;
31279 : 3940 : if (CONSTRUCTOR_NELTS (init) == 1
31280 : 2630 : && !CONSTRUCTOR_IS_DESIGNATED_INIT (init))
31281 : : {
31282 : : /* As an exception, the first phase in 16.3.1.7 (considering the
31283 : : initializer list as a single argument) is omitted if the
31284 : : initializer list consists of a single expression of type cv U,
31285 : : where U is a specialization of C or a class derived from a
31286 : : specialization of C. */
31287 : 1743 : tree elt = CONSTRUCTOR_ELT (init, 0)->value;
31288 : 1743 : if (is_spec_or_derived (TREE_TYPE (elt), tmpl))
31289 : 36 : try_list_cand = false;
31290 : : }
31291 : 36 : if (try_list_cand || is_std_init_list (type))
31292 : 3904 : args = make_tree_vector_single (init);
31293 : : else
31294 : 36 : args = make_tree_vector_from_ctor (init);
31295 : : }
31296 : 8089 : else if (TREE_CODE (init) == TREE_LIST)
31297 : 3204 : args = make_tree_vector_from_list (init);
31298 : : else
31299 : 4885 : args = make_tree_vector_single (init);
31300 : :
31301 : : /* Do this now to avoid problems with erroneous args later on. */
31302 : 12149 : args = resolve_args (args, complain);
31303 : 12149 : if (args == NULL)
31304 : 6 : return error_mark_node;
31305 : :
31306 : 12143 : bool any_dguides_p = false;
31307 : 12143 : tree cands = deduction_guides_for (tmpl, any_dguides_p, complain);
31308 : 12143 : if (cands == error_mark_node)
31309 : : return error_mark_node;
31310 : :
31311 : : /* Prune explicit deduction guides in copy-initialization context (but
31312 : : not copy-list-initialization). */
31313 : 12137 : bool elided = false;
31314 : 12137 : if (!list_init_p && (flags & LOOKUP_ONLYCONVERTING))
31315 : : {
31316 : 73381 : for (lkp_iterator iter (cands); !elided && iter; ++iter)
31317 : 68508 : if (DECL_NONCONVERTING_P (STRIP_TEMPLATE (*iter)))
31318 : 121 : elided = true;
31319 : :
31320 : 4873 : if (elided)
31321 : : {
31322 : : /* Found a nonconverting guide, prune the candidates. */
31323 : 121 : tree pruned = NULL_TREE;
31324 : 1727 : for (lkp_iterator iter (cands); iter; ++iter)
31325 : 1606 : if (!DECL_NONCONVERTING_P (STRIP_TEMPLATE (*iter)))
31326 : 1229 : pruned = lookup_add (*iter, pruned);
31327 : :
31328 : 121 : cands = pruned;
31329 : : }
31330 : : }
31331 : :
31332 : 12137 : if (!any_dguides_p)
31333 : 2080 : if (tree guide = maybe_aggr_guide (tmpl, init, args))
31334 : 312 : cands = lookup_add (guide, cands);
31335 : :
31336 : 12137 : tree fndecl = error_mark_node;
31337 : :
31338 : : /* If this is list-initialization and the class has a list guide, first
31339 : : try deducing from the list as a single argument, as [over.match.list]. */
31340 : 12137 : if (try_list_cand)
31341 : : {
31342 : 3904 : tree list_cands = NULL_TREE;
31343 : 87193 : for (tree dg : lkp_range (cands))
31344 : 83289 : if (is_list_ctor (dg))
31345 : 692 : list_cands = lookup_add (dg, list_cands);
31346 : 3904 : if (list_cands)
31347 : 374 : fndecl = perform_dguide_overload_resolution (list_cands, args, tf_none);
31348 : 3904 : if (fndecl == error_mark_node)
31349 : : {
31350 : : /* That didn't work, now try treating the list as a sequence of
31351 : : arguments. */
31352 : 3829 : release_tree_vector (args);
31353 : 3829 : args = make_tree_vector_from_ctor (init);
31354 : 3829 : args = resolve_args (args, complain);
31355 : 3829 : if (args == NULL)
31356 : 6 : return error_mark_node;
31357 : : }
31358 : : }
31359 : :
31360 : 12131 : if (elided && !cands)
31361 : : {
31362 : 0 : error ("cannot deduce template arguments for copy-initialization"
31363 : : " of %qT, as it has no non-explicit deduction guides or "
31364 : : "user-declared constructors", type);
31365 : 0 : return error_mark_node;
31366 : : }
31367 : 12131 : else if (!cands && fndecl == error_mark_node)
31368 : : {
31369 : 0 : error ("cannot deduce template arguments of %qT, as it has no viable "
31370 : : "deduction guides", type);
31371 : 0 : return error_mark_node;
31372 : : }
31373 : :
31374 : 12131 : if (fndecl == error_mark_node)
31375 : 12056 : fndecl = perform_dguide_overload_resolution (cands, args, tf_none);
31376 : :
31377 : 12131 : if (fndecl == error_mark_node)
31378 : : {
31379 : 326 : if (complain & tf_warning_or_error)
31380 : : {
31381 : 188 : auto_diagnostic_group d;
31382 : 188 : error ("class template argument deduction failed:");
31383 : 188 : perform_dguide_overload_resolution (cands, args, complain);
31384 : 188 : if (elided)
31385 : 27 : inform (input_location, "explicit deduction guides not considered "
31386 : : "for copy-initialization");
31387 : 188 : }
31388 : 326 : return error_mark_node;
31389 : : }
31390 : : /* [over.match.list]/1: In copy-list-initialization, if an explicit
31391 : : constructor is chosen, the initialization is ill-formed. */
31392 : 11805 : else if (flags & LOOKUP_ONLYCONVERTING)
31393 : : {
31394 : 5023 : if (DECL_NONCONVERTING_P (fndecl))
31395 : : {
31396 : 35 : if (complain & tf_warning_or_error)
31397 : : {
31398 : : // TODO: Pass down location from cp_finish_decl.
31399 : 35 : auto_diagnostic_group d;
31400 : 35 : error ("class template argument deduction for %qT failed: "
31401 : : "explicit deduction guide selected in "
31402 : : "copy-list-initialization", type);
31403 : 35 : inform (DECL_SOURCE_LOCATION (fndecl),
31404 : : "explicit deduction guide declared here");
31405 : :
31406 : 35 : }
31407 : 35 : return error_mark_node;
31408 : : }
31409 : : }
31410 : :
31411 : : /* If CTAD succeeded but the type doesn't have any explicit deduction
31412 : : guides, this deduction might not be what the user intended. */
31413 : 11770 : if (fndecl != error_mark_node && !any_dguides_p && (complain & tf_warning))
31414 : : {
31415 : 1813 : auto_diagnostic_group d;
31416 : 1813 : if ((!DECL_IN_SYSTEM_HEADER (fndecl)
31417 : 6 : || global_dc->m_warn_system_headers)
31418 : 1819 : && warning (OPT_Wctad_maybe_unsupported,
31419 : : "%qT may not intend to support class template argument "
31420 : : "deduction", type))
31421 : 24 : inform (input_location, "add a deduction guide to suppress this "
31422 : : "warning");
31423 : 1813 : }
31424 : :
31425 : 11770 : return cp_build_qualified_type (TREE_TYPE (TREE_TYPE (fndecl)),
31426 : 11770 : cp_type_quals (ptype));
31427 : 12149 : }
31428 : :
31429 : : /* Return true if INIT is an unparenthesized id-expression or an
31430 : : unparenthesized class member access. Used for the argument of
31431 : : decltype(auto). */
31432 : :
31433 : : bool
31434 : 2483222 : unparenthesized_id_or_class_member_access_p (tree init)
31435 : : {
31436 : 2483222 : STRIP_ANY_LOCATION_WRAPPER (init);
31437 : :
31438 : : /* We need to be able to tell '(r)' and 'r' apart (when it's of
31439 : : reference type). Only the latter is an id-expression. */
31440 : 358098 : if (REFERENCE_REF_P (init)
31441 : 2721937 : && !REF_PARENTHESIZED_P (init))
31442 : 3020 : init = TREE_OPERAND (init, 0);
31443 : 2483222 : return (DECL_P (init)
31444 : 2483222 : || ((TREE_CODE (init) == COMPONENT_REF
31445 : 2482402 : || TREE_CODE (init) == SCOPE_REF)
31446 : 253 : && !REF_PARENTHESIZED_P (init)));
31447 : : }
31448 : :
31449 : : /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
31450 : : from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE.
31451 : : The CONTEXT determines the context in which auto deduction is performed
31452 : : and is used to control error diagnostics. FLAGS are the LOOKUP_* flags.
31453 : :
31454 : : OUTER_TARGS is used during template argument deduction (context == adc_unify)
31455 : : to properly substitute the result. It's also used in the adc_unify and
31456 : : adc_requirement contexts to communicate the necessary template arguments
31457 : : to satisfaction. OUTER_TARGS is ignored in other contexts.
31458 : :
31459 : : Additionally for adc_unify contexts TMPL is the template for which TYPE
31460 : : is a template parameter type.
31461 : :
31462 : : For partial-concept-ids, extra args from OUTER_TARGS, TMPL and the current
31463 : : scope may be appended to the list of deduced template arguments prior to
31464 : : determining constraint satisfaction as appropriate. */
31465 : :
31466 : : tree
31467 : 11054808 : do_auto_deduction (tree type, tree init, tree auto_node,
31468 : : tsubst_flags_t complain /* = tf_warning_or_error */,
31469 : : auto_deduction_context context /* = adc_unspecified */,
31470 : : tree outer_targs /* = NULL_TREE */,
31471 : : int flags /* = LOOKUP_NORMAL */,
31472 : : tree tmpl /* = NULL_TREE */)
31473 : : {
31474 : 11054808 : if (type == error_mark_node || init == error_mark_node)
31475 : : return error_mark_node;
31476 : :
31477 : 11053999 : if (init && type_dependent_expression_p (init)
31478 : 16861944 : && context != adc_unify)
31479 : : /* Defining a subset of type-dependent expressions that we can deduce
31480 : : from ahead of time isn't worth the trouble. */
31481 : : return type;
31482 : :
31483 : : /* Similarly, we can't deduce from another undeduced decl. */
31484 : 5248963 : if (init && undeduced_auto_decl (init))
31485 : : return type;
31486 : :
31487 : : /* We may be doing a partial substitution, but we still want to replace
31488 : : auto_node. */
31489 : 5248954 : complain &= ~tf_partial;
31490 : :
31491 : 5248954 : if (init && BRACE_ENCLOSED_INITIALIZER_P (init))
31492 : : {
31493 : : /* We don't recurse here because we can't deduce from a nested
31494 : : initializer_list. */
31495 : 4535 : if (CONSTRUCTOR_ELTS (init))
31496 : 8789 : for (constructor_elt &elt : CONSTRUCTOR_ELTS (init))
31497 : 5590 : elt.value = resolve_nondeduced_context (elt.value, complain);
31498 : : }
31499 : 5244419 : else if (init)
31500 : 5244264 : init = resolve_nondeduced_context (init, complain);
31501 : :
31502 : : /* In C++23, we must deduce the type to int&& for code like
31503 : : decltype(auto) f(int&& x) { return (x); }
31504 : : or
31505 : : auto&& f(int x) { return x; }
31506 : : so we use treat_lvalue_as_rvalue_p. But don't do it for
31507 : : decltype(auto) f(int x) { return x; }
31508 : : where we should deduce 'int' rather than 'int&&'; transmogrifying
31509 : : INIT to an rvalue would break that. */
31510 : 5248954 : tree r;
31511 : 5248954 : if (cxx_dialect >= cxx23
31512 : 2632613 : && context == adc_return_type
31513 : 463485 : && (!AUTO_IS_DECLTYPE (auto_node)
31514 : 125085 : || !unparenthesized_id_or_class_member_access_p (init))
31515 : 5712266 : && (r = treat_lvalue_as_rvalue_p (maybe_undo_parenthesized_ref (init),
31516 : : /*return*/true)))
31517 : 16214 : init = r;
31518 : :
31519 : 5248954 : if (tree ctmpl = CLASS_PLACEHOLDER_TEMPLATE (auto_node))
31520 : : /* C++17 class template argument deduction. */
31521 : 12418 : return do_class_deduction (type, ctmpl, init, outer_targs, flags, complain);
31522 : :
31523 : 5236536 : if (init == NULL_TREE || TREE_TYPE (init) == NULL_TREE)
31524 : : /* Nothing we can do with this, even in deduction context. */
31525 : : return type;
31526 : :
31527 : 5234456 : location_t loc = cp_expr_loc_or_input_loc (init);
31528 : :
31529 : : /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
31530 : : with either a new invented type template parameter U or, if the
31531 : : initializer is a braced-init-list (8.5.4), with
31532 : : std::initializer_list<U>. */
31533 : 5234456 : if (BRACE_ENCLOSED_INITIALIZER_P (init))
31534 : : {
31535 : 509 : if (!DIRECT_LIST_INIT_P (init))
31536 : 353 : type = listify_autos (type, auto_node);
31537 : 156 : else if (CONSTRUCTOR_NELTS (init) == 1)
31538 : 150 : init = CONSTRUCTOR_ELT (init, 0)->value;
31539 : : else
31540 : : {
31541 : 6 : if (complain & tf_warning_or_error)
31542 : : {
31543 : 6 : auto_diagnostic_group d;
31544 : 6 : if (permerror (loc, "direct-list-initialization of "
31545 : : "%<auto%> requires exactly one element"))
31546 : 6 : inform (loc,
31547 : : "for deduction to %<std::initializer_list%>, use copy-"
31548 : : "list-initialization (i.e. add %<=%> before the %<{%>)");
31549 : 6 : }
31550 : 6 : type = listify_autos (type, auto_node);
31551 : : }
31552 : : }
31553 : :
31554 : 5234456 : if (type == error_mark_node || init == error_mark_node)
31555 : : return error_mark_node;
31556 : :
31557 : 5234436 : tree targs;
31558 : 5234436 : if (context == adc_decomp_type
31559 : 5234436 : && auto_node == type
31560 : 5234436 : && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
31561 : : {
31562 : : /* [dcl.struct.bind]/1 - if decomposition declaration has no ref-qualifiers
31563 : : and initializer has array type, deduce cv-qualified array type. */
31564 : 272 : targs = make_tree_vec (1);
31565 : 272 : TREE_VEC_ELT (targs, 0) = TREE_TYPE (init);
31566 : : }
31567 : 5234164 : else if (AUTO_IS_DECLTYPE (auto_node))
31568 : : {
31569 : 2358137 : const bool id = unparenthesized_id_or_class_member_access_p (init);
31570 : 2358137 : tree deduced = finish_decltype_type (init, id, complain);
31571 : 2358137 : deduced = canonicalize_type_argument (deduced, complain);
31572 : 2358137 : if (deduced == error_mark_node)
31573 : : return error_mark_node;
31574 : 2358134 : targs = make_tree_vec (1);
31575 : 2358134 : TREE_VEC_ELT (targs, 0) = deduced;
31576 : : }
31577 : : else
31578 : : {
31579 : 2876027 : if (error_operand_p (init))
31580 : : return error_mark_node;
31581 : :
31582 : 2876015 : tree parms = build_tree_list (NULL_TREE, type);
31583 : 2876015 : tree tparms = make_tree_vec (1);
31584 : 2876015 : TREE_VEC_ELT (tparms, 0)
31585 : 2876015 : = build_tree_list (NULL_TREE, TYPE_NAME (auto_node));
31586 : :
31587 : 2876015 : targs = make_tree_vec (TREE_VEC_LENGTH (tparms));
31588 : 2876015 : int val = type_unification_real (tparms, targs, parms, &init, 1, 0,
31589 : : DEDUCE_CALL,
31590 : : NULL, /*explain_p=*/false);
31591 : 2876015 : if (val > 0)
31592 : : {
31593 : 72 : if (processing_template_decl)
31594 : : /* Try again at instantiation time. */
31595 : : return type;
31596 : 63 : if (type && type != error_mark_node
31597 : 63 : && (complain & tf_error))
31598 : : /* If type is error_mark_node a diagnostic must have been
31599 : : emitted by now. Also, having a mention to '<type error>'
31600 : : in the diagnostic is not really useful to the user. */
31601 : : {
31602 : 60 : if (cfun
31603 : 30 : && FNDECL_USED_AUTO (current_function_decl)
31604 : 12 : && (auto_node
31605 : 12 : == DECL_SAVED_AUTO_RETURN_TYPE (current_function_decl))
31606 : 72 : && LAMBDA_FUNCTION_P (current_function_decl))
31607 : 6 : error_at (loc, "unable to deduce lambda return type from %qE",
31608 : : init);
31609 : : else
31610 : 54 : error_at (loc, "unable to deduce %qT from %qE", type, init);
31611 : 60 : type_unification_real (tparms, targs, parms, &init, 1, 0,
31612 : : DEDUCE_CALL,
31613 : : NULL, /*explain_p=*/true);
31614 : : }
31615 : 63 : return error_mark_node;
31616 : : }
31617 : : }
31618 : :
31619 : : /* Check any placeholder constraints against the deduced type. */
31620 : 5234349 : if (processing_template_decl && context == adc_unify)
31621 : : /* Constraints will be checked after deduction. */;
31622 : 5233861 : else if (tree constr = NON_ERROR (PLACEHOLDER_TYPE_CONSTRAINTS (auto_node)))
31623 : : {
31624 : 2150042 : if (processing_template_decl)
31625 : : {
31626 : 58 : gcc_checking_assert (context == adc_variable_type
31627 : : || context == adc_return_type
31628 : : || context == adc_decomp_type);
31629 : 58 : gcc_checking_assert (!type_dependent_expression_p (init));
31630 : : /* If the constraint is dependent, we need to wait until
31631 : : instantiation time to resolve the placeholder. */
31632 : 58 : if (placeholder_type_constraint_dependent_p (constr))
31633 : : return type;
31634 : : }
31635 : :
31636 : 2150018 : if (context == adc_return_type
31637 : 2150018 : || context == adc_variable_type
31638 : 2150018 : || context == adc_decomp_type)
31639 : 336 : if (tree fn = current_function_decl)
31640 : 257 : if (DECL_TEMPLATE_INFO (fn) || LAMBDA_FUNCTION_P (fn))
31641 : : {
31642 : 100 : outer_targs = DECL_TEMPLATE_INFO (fn)
31643 : 100 : ? DECL_TI_ARGS (fn) : NULL_TREE;
31644 : 112 : if (LAMBDA_FUNCTION_P (fn))
31645 : : {
31646 : : /* As in satisfy_declaration_constraints. */
31647 : 12 : tree regen_args = lambda_regenerating_args (fn);
31648 : 12 : if (outer_targs)
31649 : 0 : outer_targs = add_to_template_args (regen_args, outer_targs);
31650 : : else
31651 : : outer_targs = regen_args;
31652 : : }
31653 : : }
31654 : :
31655 : 2150018 : tree full_targs = outer_targs;
31656 : 2150018 : if (context == adc_unify && tmpl)
31657 : 177 : full_targs = add_outermost_template_args (tmpl, full_targs);
31658 : 2150018 : full_targs = add_to_template_args (full_targs, targs);
31659 : :
31660 : : /* HACK: Compensate for callers not always communicating all levels of
31661 : : outer template arguments by filling in the outermost missing levels
31662 : : with dummy levels before checking satisfaction. We'll still crash
31663 : : if the constraint depends on a template argument belonging to one of
31664 : : these missing levels, but this hack otherwise allows us to handle a
31665 : : large subset of possible constraints (including all non-dependent
31666 : : constraints). */
31667 : 2150018 : if (int missing_levels = (TEMPLATE_TYPE_ORIG_LEVEL (auto_node)
31668 : 4300262 : - TMPL_ARGS_DEPTH (full_targs)))
31669 : : {
31670 : 12 : tree dummy_levels = make_tree_vec (missing_levels);
31671 : 24 : for (int i = 0; i < missing_levels; ++i)
31672 : 12 : TREE_VEC_ELT (dummy_levels, i) = make_tree_vec (0);
31673 : 12 : full_targs = add_to_template_args (dummy_levels, full_targs);
31674 : : }
31675 : :
31676 : 2150018 : if (!constraints_satisfied_p (auto_node, full_targs))
31677 : : {
31678 : 1135 : if (complain & tf_warning_or_error)
31679 : : {
31680 : 132 : auto_diagnostic_group d;
31681 : 132 : switch (context)
31682 : : {
31683 : 25 : case adc_unspecified:
31684 : 25 : case adc_unify:
31685 : 25 : error_at (loc, "placeholder constraints not satisfied");
31686 : 25 : break;
31687 : 72 : case adc_variable_type:
31688 : 72 : case adc_decomp_type:
31689 : 72 : error_at (loc, "deduced initializer does not satisfy "
31690 : : "placeholder constraints");
31691 : 72 : break;
31692 : 23 : case adc_return_type:
31693 : 23 : error_at (loc, "deduced return type does not satisfy "
31694 : : "placeholder constraints");
31695 : 23 : break;
31696 : 12 : case adc_requirement:
31697 : 12 : error_at (loc, "deduced expression type does not satisfy "
31698 : : "placeholder constraints");
31699 : 12 : break;
31700 : : }
31701 : 132 : diagnose_constraints (loc, auto_node, full_targs);
31702 : 132 : }
31703 : 1135 : return error_mark_node;
31704 : : }
31705 : : }
31706 : :
31707 : 5233190 : if (TEMPLATE_TYPE_LEVEL (auto_node) == 0)
31708 : : {
31709 : : /* Substitute this level-less auto via tsubst by temporarily
31710 : : overriding its level to 1. */
31711 : 253 : TEMPLATE_TYPE_LEVEL (auto_node) = 1;
31712 : 253 : type = tsubst (type, targs, complain, NULL_TREE);
31713 : 253 : TEMPLATE_TYPE_LEVEL (auto_node) = 0;
31714 : 253 : return type;
31715 : : }
31716 : :
31717 : 5232937 : if (TEMPLATE_TYPE_LEVEL (auto_node) == 1)
31718 : : /* The outer template arguments are already substituted into type
31719 : : (but we still may have used them for constraint checking above). */;
31720 : 554436 : else if (context == adc_unify)
31721 : 2777 : targs = add_to_template_args (outer_targs, targs);
31722 : 551659 : else if (processing_template_decl)
31723 : 551659 : targs = add_to_template_args (current_template_args (), targs);
31724 : 5232937 : return tsubst (type, targs, complain, NULL_TREE);
31725 : : }
31726 : :
31727 : : /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
31728 : : result. */
31729 : :
31730 : : tree
31731 : 165421280 : splice_late_return_type (tree type, tree late_return_type)
31732 : : {
31733 : 165421280 : if (late_return_type)
31734 : : {
31735 : 2714260 : gcc_assert (is_auto (type) || seen_error ());
31736 : 2714260 : return late_return_type;
31737 : : }
31738 : :
31739 : 162707020 : if (tree auto_node = find_type_usage (type, is_auto))
31740 : 1778538 : if (TEMPLATE_TYPE_LEVEL (auto_node) <= current_template_depth)
31741 : : {
31742 : : /* In an abbreviated function template we didn't know we were dealing
31743 : : with a function template when we saw the auto return type, so rebuild
31744 : : the return type using an auto with the correct level. */
31745 : 58 : tree new_auto = make_auto_1 (TYPE_IDENTIFIER (auto_node), false);
31746 : 58 : tree auto_vec = make_tree_vec (1);
31747 : 58 : TREE_VEC_ELT (auto_vec, 0) = new_auto;
31748 : 58 : tree targs = add_outermost_template_args (current_template_args (),
31749 : : auto_vec);
31750 : : /* Also rebuild the constraint info in terms of the new auto. */
31751 : 58 : if (tree ci = PLACEHOLDER_TYPE_CONSTRAINTS_INFO (auto_node))
31752 : 4 : PLACEHOLDER_TYPE_CONSTRAINTS_INFO (new_auto)
31753 : 4 : = build_tree_list (current_template_parms,
31754 : 2 : tsubst_constraint (TREE_VALUE (ci), targs,
31755 : : tf_none, NULL_TREE));
31756 : 58 : TYPE_CANONICAL (new_auto) = canonical_type_parameter (new_auto);
31757 : 58 : return tsubst (type, targs, tf_none, NULL_TREE);
31758 : : }
31759 : : return type;
31760 : : }
31761 : :
31762 : : /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto' or
31763 : : 'decltype(auto)' or a deduced class template. */
31764 : :
31765 : : bool
31766 : 7786675349 : is_auto (const_tree type)
31767 : : {
31768 : 7786675349 : if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
31769 : 7786675349 : && (TYPE_IDENTIFIER (type) == auto_identifier
31770 : 3316663335 : || TYPE_IDENTIFIER (type) == decltype_auto_identifier))
31771 : : return true;
31772 : : else
31773 : 7548567124 : return false;
31774 : : }
31775 : :
31776 : : /* for_each_template_parm callback for type_uses_auto. */
31777 : :
31778 : : int
31779 : 0 : is_auto_r (tree tp, void */*data*/)
31780 : : {
31781 : 0 : return is_auto (tp);
31782 : : }
31783 : :
31784 : : /* Returns the TEMPLATE_TYPE_PARM in TYPE representing `auto' iff TYPE contains
31785 : : a use of `auto'. Returns NULL_TREE otherwise. */
31786 : :
31787 : : tree
31788 : 3012049013 : type_uses_auto (tree type)
31789 : : {
31790 : 3012049013 : if (type == NULL_TREE)
31791 : : return NULL_TREE;
31792 : :
31793 : : /* For parameter packs, check the contents of the pack. */
31794 : 3010096770 : if (PACK_EXPANSION_P (type))
31795 : 6250056 : type = PACK_EXPANSION_PATTERN (type);
31796 : :
31797 : 3010096770 : return find_type_usage (type, is_auto);
31798 : : }
31799 : :
31800 : : /* Recursively walk over && expressions searching for EXPR. Return a reference
31801 : : to that expression. */
31802 : :
31803 : 48 : static tree *find_template_requirement (tree *t, tree key)
31804 : : {
31805 : 48 : if (*t == key)
31806 : : return t;
31807 : 24 : if (TREE_CODE (*t) == TRUTH_ANDIF_EXPR)
31808 : : {
31809 : 12 : if (tree *p = find_template_requirement (&TREE_OPERAND (*t, 0), key))
31810 : : return p;
31811 : 12 : if (tree *p = find_template_requirement (&TREE_OPERAND (*t, 1), key))
31812 : : return p;
31813 : : }
31814 : : return 0;
31815 : : }
31816 : :
31817 : : /* Convert the generic type parameters in PARM that match the types given in the
31818 : : range [START_IDX, END_IDX) from the current_template_parms into generic type
31819 : : packs. */
31820 : :
31821 : : tree
31822 : 34437 : convert_generic_types_to_packs (tree parm, int start_idx, int end_idx)
31823 : : {
31824 : 34437 : tree current = current_template_parms;
31825 : 34437 : int depth = TMPL_PARMS_DEPTH (current);
31826 : 34437 : current = INNERMOST_TEMPLATE_PARMS (current);
31827 : 34437 : tree replacement = make_tree_vec (TREE_VEC_LENGTH (current));
31828 : :
31829 : 36003 : for (int i = 0; i < start_idx; ++i)
31830 : 3132 : TREE_VEC_ELT (replacement, i)
31831 : 1566 : = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current, i)));
31832 : :
31833 : 68880 : for (int i = start_idx; i < end_idx; ++i)
31834 : : {
31835 : : /* Create a distinct parameter pack type from the current parm and add it
31836 : : to the replacement args to tsubst below into the generic function
31837 : : parameter. */
31838 : 34443 : tree node = TREE_VEC_ELT (current, i);
31839 : 34443 : tree o = TREE_TYPE (TREE_VALUE (node));
31840 : 34443 : tree t = copy_type (o);
31841 : 34443 : TEMPLATE_TYPE_PARM_INDEX (t)
31842 : 34443 : = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (o),
31843 : : t, 0, 0, tf_none);
31844 : 34443 : TREE_TYPE (TEMPLATE_TYPE_DECL (t)) = t;
31845 : 34443 : TYPE_STUB_DECL (t) = TYPE_NAME (t) = TEMPLATE_TYPE_DECL (t);
31846 : 34443 : TYPE_MAIN_VARIANT (t) = t;
31847 : 34443 : TEMPLATE_TYPE_PARAMETER_PACK (t) = true;
31848 : 34443 : TYPE_CANONICAL (t) = canonical_type_parameter (t);
31849 : 34443 : TREE_VEC_ELT (replacement, i) = t;
31850 : :
31851 : : /* Replace the current template parameter with new pack. */
31852 : 34443 : TREE_VALUE (node) = TREE_CHAIN (t);
31853 : :
31854 : : /* Surgically adjust the associated constraint of adjusted parameter
31855 : : and it's corresponding contribution to the current template
31856 : : requirements. */
31857 : 34443 : if (tree constr = TEMPLATE_PARM_CONSTRAINTS (node))
31858 : : {
31859 : 24 : gcc_assert (concept_check_p (constr));
31860 : 24 : TREE_VEC_ELT (TREE_OPERAND (constr, 1), 0) = t;
31861 : : /* Use UNKNOWN_LOCATION so write_template_args can tell the
31862 : : difference between this and a fold the user wrote. */
31863 : 24 : location_t loc = UNKNOWN_LOCATION;
31864 : 24 : tree fold = finish_left_unary_fold_expr (loc, constr,
31865 : : TRUTH_ANDIF_EXPR);
31866 : 24 : TEMPLATE_PARM_CONSTRAINTS (node) = fold;
31867 : :
31868 : : /* If there was a constraint, we also need to replace that in
31869 : : the template requirements, which we've already built. */
31870 : 24 : tree *reqs = &TEMPLATE_PARMS_CONSTRAINTS (current_template_parms);
31871 : 24 : reqs = find_template_requirement (reqs, constr);
31872 : 24 : *reqs = fold;
31873 : : }
31874 : : }
31875 : :
31876 : 34437 : for (int i = end_idx, e = TREE_VEC_LENGTH (current); i < e; ++i)
31877 : 0 : TREE_VEC_ELT (replacement, i)
31878 : 0 : = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current, i)));
31879 : :
31880 : : /* If there are more levels then build up the replacement with the outer
31881 : : template parms. */
31882 : 34437 : if (depth > 1)
31883 : 34203 : replacement = add_to_template_args (template_parms_to_args
31884 : 34203 : (TREE_CHAIN (current_template_parms)),
31885 : : replacement);
31886 : :
31887 : 34437 : return tsubst (parm, replacement, tf_none, NULL_TREE);
31888 : : }
31889 : :
31890 : : /* __integer_pack(N) in a pack expansion expands to a sequence of numbers from
31891 : : 0..N-1. */
31892 : :
31893 : : void
31894 : 79030 : declare_integer_pack (void)
31895 : : {
31896 : 79030 : tree ipfn = push_library_fn (get_identifier ("__integer_pack"),
31897 : : build_function_type_list (integer_type_node,
31898 : : integer_type_node,
31899 : : NULL_TREE),
31900 : : NULL_TREE, ECF_CONST);
31901 : 79030 : DECL_DECLARED_CONSTEXPR_P (ipfn) = true;
31902 : 79030 : set_decl_built_in_function (ipfn, BUILT_IN_FRONTEND,
31903 : : CP_BUILT_IN_INTEGER_PACK);
31904 : 79030 : }
31905 : :
31906 : : /* Walk the decl or type specialization table calling FN on each
31907 : : entry. */
31908 : :
31909 : : void
31910 : 4340 : walk_specializations (bool decls_p,
31911 : : void (*fn) (bool decls_p, spec_entry *entry, void *data),
31912 : : void *data)
31913 : : {
31914 : 4340 : spec_hash_table *table = decls_p ? decl_specializations
31915 : : : type_specializations;
31916 : 4340 : spec_hash_table::iterator end (table->end ());
31917 : 1662286 : for (spec_hash_table::iterator iter (table->begin ()); iter != end; ++iter)
31918 : 828973 : fn (decls_p, *iter, data);
31919 : 4340 : }
31920 : :
31921 : : /* Lookup the specialization of *ELT, in the decl or type
31922 : : specialization table. Return the SPEC that's already there, or
31923 : : NULL if nothing. */
31924 : :
31925 : : tree
31926 : 2535642 : match_mergeable_specialization (bool decl_p, spec_entry *elt)
31927 : : {
31928 : 5071284 : hash_table<spec_hasher> *specializations
31929 : 2535642 : = decl_p ? decl_specializations : type_specializations;
31930 : 2535642 : auto *slot = specializations->find_slot (elt, NO_INSERT);
31931 : :
31932 : 2535642 : if (slot)
31933 : 2037657 : return (*slot)->spec;
31934 : :
31935 : : return NULL_TREE;
31936 : : }
31937 : :
31938 : : /* Return flags encoding whether SPEC is on the instantiation and/or
31939 : : specialization lists of TMPL. */
31940 : :
31941 : : unsigned
31942 : 571075 : get_mergeable_specialization_flags (bool decl_p, tree tmpl, tree decl)
31943 : : {
31944 : 571075 : unsigned flags = 0;
31945 : :
31946 : 571075 : tree spec = decl_p ? decl : TREE_TYPE (decl);
31947 : 571075 : for (tree inst = DECL_TEMPLATE_INSTANTIATIONS (tmpl);
31948 : 9201219 : inst; inst = TREE_CHAIN (inst))
31949 : 9196677 : if (TREE_VALUE (inst) == spec)
31950 : : {
31951 : : flags |= 1;
31952 : : break;
31953 : : }
31954 : :
31955 : 1142150 : if (CLASS_TYPE_P (TREE_TYPE (decl))
31956 : 246474 : && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl))
31957 : 810770 : && CLASSTYPE_USE_TEMPLATE (TREE_TYPE (decl)) == 2)
31958 : : /* Only need to search if DECL is a partial specialization. */
31959 : 17388 : for (tree part = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
31960 : 39864 : part; part = TREE_CHAIN (part))
31961 : 22476 : if (TREE_VALUE (part) == decl)
31962 : : {
31963 : 0 : flags |= 2;
31964 : 0 : break;
31965 : : }
31966 : :
31967 : 571075 : return flags;
31968 : : }
31969 : :
31970 : : /* Add a new specialization described by SPEC. DECL is the
31971 : : maybe-template decl and FLAGS is as returned from
31972 : : get_mergeable_specialization_flags. */
31973 : :
31974 : : void
31975 : 240171 : add_mergeable_specialization (bool decl_p, spec_entry *elt, tree decl,
31976 : : unsigned flags)
31977 : : {
31978 : 240171 : if (decl_p)
31979 : : {
31980 : 170017 : auto *slot = decl_specializations->find_slot (elt, INSERT);
31981 : :
31982 : 170017 : gcc_checking_assert (!*slot);
31983 : 170017 : auto entry = ggc_alloc<spec_entry> ();
31984 : 170017 : *entry = *elt;
31985 : 170017 : *slot = entry;
31986 : : }
31987 : : else
31988 : : {
31989 : 70154 : auto *slot = type_specializations->find_slot (elt, INSERT);
31990 : :
31991 : : /* We don't distinguish different constrained partial type
31992 : : specializations, so there could be duplicates. In that case we
31993 : : must propagate TYPE_CANONICAL so that they are treated as the
31994 : : same type. Everything else must be new. */
31995 : 70154 : if (*slot)
31996 : : {
31997 : 201 : gcc_checking_assert (flags & 2);
31998 : 201 : TYPE_CANONICAL (elt->spec) = TYPE_CANONICAL ((*slot)->spec);
31999 : : }
32000 : : else
32001 : : {
32002 : 69953 : auto entry = ggc_alloc<spec_entry> ();
32003 : 69953 : *entry = *elt;
32004 : 69953 : *slot = entry;
32005 : : }
32006 : : }
32007 : :
32008 : 240171 : if (flags & 1)
32009 : 230809 : DECL_TEMPLATE_INSTANTIATIONS (elt->tmpl)
32010 : 461618 : = tree_cons (elt->args, elt->spec,
32011 : 230809 : DECL_TEMPLATE_INSTANTIATIONS (elt->tmpl));
32012 : :
32013 : 240171 : if (flags & 2)
32014 : : {
32015 : : /* A partial specialization. */
32016 : 7676 : tree cons = tree_cons (elt->args, decl,
32017 : 7676 : DECL_TEMPLATE_SPECIALIZATIONS (elt->tmpl));
32018 : 7676 : TREE_TYPE (cons) = decl_p ? TREE_TYPE (elt->spec) : elt->spec;
32019 : 7676 : DECL_TEMPLATE_SPECIALIZATIONS (elt->tmpl) = cons;
32020 : 7676 : set_defining_module_for_partial_spec (STRIP_TEMPLATE (decl));
32021 : : }
32022 : 240171 : }
32023 : :
32024 : : /* Set up the hash tables for template instantiations. */
32025 : :
32026 : : void
32027 : 92703 : init_template_processing (void)
32028 : : {
32029 : 92703 : decl_specializations = hash_table<spec_hasher>::create_ggc (37);
32030 : 92703 : type_specializations = hash_table<spec_hasher>::create_ggc (37);
32031 : :
32032 : 92703 : if (cxx_dialect >= cxx11)
32033 : 79030 : declare_integer_pack ();
32034 : 92703 : }
32035 : :
32036 : : /* Print stats about the template hash tables for -fstats. */
32037 : :
32038 : : void
32039 : 0 : print_template_statistics (void)
32040 : : {
32041 : 0 : fprintf (stderr, "decl_specializations: size " HOST_SIZE_T_PRINT_DEC ", "
32042 : : HOST_SIZE_T_PRINT_DEC " elements, %f collisions\n",
32043 : 0 : (fmt_size_t) decl_specializations->size (),
32044 : 0 : (fmt_size_t) decl_specializations->elements (),
32045 : : decl_specializations->collisions ());
32046 : 0 : fprintf (stderr, "type_specializations: size " HOST_SIZE_T_PRINT_DEC ", "
32047 : : HOST_SIZE_T_PRINT_DEC " elements, %f collisions\n",
32048 : 0 : (fmt_size_t) type_specializations->size (),
32049 : 0 : (fmt_size_t) type_specializations->elements (),
32050 : : type_specializations->collisions ());
32051 : 0 : }
32052 : :
32053 : : #if CHECKING_P
32054 : :
32055 : : namespace selftest {
32056 : :
32057 : : /* Verify that type_dependent_expression_p () works correctly, even
32058 : : in the presence of location wrapper nodes. */
32059 : :
32060 : : static void
32061 : 1 : test_type_dependent_expression_p ()
32062 : : {
32063 : 1 : location_t loc = BUILTINS_LOCATION;
32064 : :
32065 : 1 : tree name = get_identifier ("foo");
32066 : :
32067 : : /* If no templates are involved, nothing is type-dependent. */
32068 : 1 : gcc_assert (!processing_template_decl);
32069 : 1 : ASSERT_FALSE (type_dependent_expression_p (name));
32070 : :
32071 : 1 : ++processing_template_decl;
32072 : :
32073 : : /* Within a template, an unresolved name is always type-dependent. */
32074 : 1 : ASSERT_TRUE (type_dependent_expression_p (name));
32075 : :
32076 : : /* Ensure it copes with NULL_TREE and errors. */
32077 : 1 : ASSERT_FALSE (type_dependent_expression_p (NULL_TREE));
32078 : 1 : ASSERT_FALSE (type_dependent_expression_p (error_mark_node));
32079 : :
32080 : : /* A USING_DECL in a template should be type-dependent, even if wrapped
32081 : : with a location wrapper (PR c++/83799). */
32082 : 1 : tree using_decl = build_lang_decl (USING_DECL, name, NULL_TREE);
32083 : 1 : TREE_TYPE (using_decl) = integer_type_node;
32084 : 1 : ASSERT_TRUE (type_dependent_expression_p (using_decl));
32085 : 1 : tree wrapped_using_decl = maybe_wrap_with_location (using_decl, loc);
32086 : 1 : ASSERT_TRUE (location_wrapper_p (wrapped_using_decl));
32087 : 1 : ASSERT_TRUE (type_dependent_expression_p (wrapped_using_decl));
32088 : :
32089 : 1 : --processing_template_decl;
32090 : 1 : }
32091 : :
32092 : : /* Run all of the selftests within this file. */
32093 : :
32094 : : void
32095 : 1 : cp_pt_cc_tests ()
32096 : : {
32097 : 1 : test_type_dependent_expression_p ();
32098 : 1 : }
32099 : :
32100 : : } // namespace selftest
32101 : :
32102 : : #endif /* #if CHECKING_P */
32103 : :
32104 : : #include "gt-cp-pt.h"
|
