1/* Handle parameterized types (templates) for GNU C++.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
4 Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing.
5 Rewritten by Jason Merrill (jason@cygnus.com).
6
7This file is part of GCC.
8
9GCC is free software; you can redistribute it and/or modify
10it under the terms of the GNU General Public License as published by
11the Free Software Foundation; either version 2, or (at your option)
12any later version.
13
14GCC is distributed in the hope that it will be useful,
15but WITHOUT ANY WARRANTY; without even the implied warranty of
16MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17GNU General Public License for more details.
18
19You should have received a copy of the GNU General Public License
20along with GCC; see the file COPYING. If not, write to
21the Free Software Foundation, 51 Franklin Street, Fifth Floor,
22Boston, MA 02110-1301, USA. */
23
24/* Known bugs or deficiencies include:
25
26 all methods must be provided in header files; can't use a source
27 file that contains only the method templates and "just win". */
28
29#include "config.h"
30#include "system.h"
31#include "coretypes.h"
32#include "tm.h"
33#include "obstack.h"
34#include "tree.h"
35#include "pointer-set.h"
36#include "flags.h"
37#include "c-common.h"
38#include "cp-tree.h"
39#include "cp-objcp-common.h"
40#include "tree-inline.h"
41#include "decl.h"
42#include "output.h"
43#include "except.h"
44#include "toplev.h"
45#include "rtl.h"
46#include "timevar.h"
47#include "tree-iterator.h"
48#include "vecprim.h"
49
50/* The type of functions taking a tree, and some additional data, and
51 returning an int. */
52typedef int (*tree_fn_t) (tree, void*);
53
54/* The PENDING_TEMPLATES is a TREE_LIST of templates whose
55 instantiations have been deferred, either because their definitions
56 were not yet available, or because we were putting off doing the work.
57 The TREE_PURPOSE of each entry is either a DECL (for a function or
58 static data member), or a TYPE (for a class) indicating what we are
59 hoping to instantiate. The TREE_VALUE is not used. */
60static GTY(()) tree pending_templates;
61static GTY(()) tree last_pending_template;
62
63int processing_template_parmlist;
64static int template_header_count;
65
66static GTY(()) tree saved_trees;
67static VEC(int,heap) *inline_parm_levels;
68
69static GTY(()) tree current_tinst_level;
70
71static GTY(()) tree saved_access_scope;
72
73/* Live only within one (recursive) call to tsubst_expr. We use
74 this to pass the statement expression node from the STMT_EXPR
75 to the EXPR_STMT that is its result. */
76static tree cur_stmt_expr;
77
78/* A map from local variable declarations in the body of the template
79 presently being instantiated to the corresponding instantiated
80 local variables. */
81static htab_t local_specializations;
82
83#define UNIFY_ALLOW_NONE 0
84#define UNIFY_ALLOW_MORE_CV_QUAL 1
85#define UNIFY_ALLOW_LESS_CV_QUAL 2
86#define UNIFY_ALLOW_DERIVED 4
87#define UNIFY_ALLOW_INTEGER 8
88#define UNIFY_ALLOW_OUTER_LEVEL 16
89#define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
90#define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
91
92static void push_access_scope (tree);
93static void pop_access_scope (tree);
94static bool resolve_overloaded_unification (tree, tree, tree, tree,
95 unification_kind_t, int);
96static int try_one_overload (tree, tree, tree, tree, tree,
97 unification_kind_t, int, bool);
98static int unify (tree, tree, tree, tree, int);
99static void add_pending_template (tree);
100static int push_tinst_level (tree);
101static void pop_tinst_level (void);
102static void reopen_tinst_level (tree);
103static tree classtype_mangled_name (tree);
104static char* mangle_class_name_for_template (const char *, tree, tree);
105static tree tsubst_initializer_list (tree, tree);
106static tree get_class_bindings (tree, tree, tree);
107static tree coerce_template_parms (tree, tree, tree, tsubst_flags_t,
108 bool, bool);
109static void tsubst_enum (tree, tree, tree);
110static tree add_to_template_args (tree, tree);
111static tree add_outermost_template_args (tree, tree);
112static bool check_instantiated_args (tree, tree, tsubst_flags_t);
113static int maybe_adjust_types_for_deduction (unification_kind_t, tree*, tree*);
114static int type_unification_real (tree, tree, tree, tree,
115 int, unification_kind_t, int);
116static void note_template_header (int);
117static tree convert_nontype_argument_function (tree, tree);
118static tree convert_nontype_argument (tree, tree);
119static tree convert_template_argument (tree, tree, tree,
120 tsubst_flags_t, int, tree);
121static int for_each_template_parm (tree, tree_fn_t, void*,
122 struct pointer_set_t*);
123static tree build_template_parm_index (int, int, int, tree, tree);
124static int inline_needs_template_parms (tree);
125static void push_inline_template_parms_recursive (tree, int);
126static tree retrieve_local_specialization (tree);
127static void register_local_specialization (tree, tree);
128static tree reduce_template_parm_level (tree, tree, int);
129static int mark_template_parm (tree, void *);
130static int template_parm_this_level_p (tree, void *);
131static tree tsubst_friend_function (tree, tree);
132static tree tsubst_friend_class (tree, tree);
133static int can_complete_type_without_circularity (tree);
134static tree get_bindings (tree, tree, tree, bool);
135static int template_decl_level (tree);
136static int check_cv_quals_for_unify (int, tree, tree);
137static tree tsubst_template_arg (tree, tree, tsubst_flags_t, tree);
138static tree tsubst_template_args (tree, tree, tsubst_flags_t, tree);
139static tree tsubst_template_parms (tree, tree, tsubst_flags_t);
140static void regenerate_decl_from_template (tree, tree);
141static tree most_specialized_class (tree, tree);
142static tree tsubst_aggr_type (tree, tree, tsubst_flags_t, tree, int);
143static tree tsubst_arg_types (tree, tree, tsubst_flags_t, tree);
144static tree tsubst_function_type (tree, tree, tsubst_flags_t, tree);
145static bool check_specialization_scope (void);
146static tree process_partial_specialization (tree);
147static void set_current_access_from_decl (tree);
148static void check_default_tmpl_args (tree, tree, int, int);
149static tree get_template_base (tree, tree, tree, tree);
150static tree try_class_unification (tree, tree, tree, tree);
151static int coerce_template_template_parms (tree, tree, tsubst_flags_t,
152 tree, tree);
153static int template_args_equal (tree, tree);
154static void tsubst_default_arguments (tree);
155static tree for_each_template_parm_r (tree *, int *, void *);
156static tree copy_default_args_to_explicit_spec_1 (tree, tree);
157static void copy_default_args_to_explicit_spec (tree);
158static int invalid_nontype_parm_type_p (tree, tsubst_flags_t);
159static int eq_local_specializations (const void *, const void *);
160static bool dependent_type_p_r (tree);
161static tree tsubst (tree, tree, tsubst_flags_t, tree);
162static tree tsubst_expr (tree, tree, tsubst_flags_t, tree, bool);
163static tree tsubst_copy (tree, tree, tsubst_flags_t, tree);
164
165/* Make the current scope suitable for access checking when we are
166 processing T. T can be FUNCTION_DECL for instantiated function
167 template, or VAR_DECL for static member variable (need by
168 instantiate_decl). */
169
170static void
171push_access_scope (tree t)
172{
173 gcc_assert (TREE_CODE (t) == FUNCTION_DECL
174 || TREE_CODE (t) == VAR_DECL);
175
176 if (DECL_FRIEND_CONTEXT (t))
177 push_nested_class (DECL_FRIEND_CONTEXT (t));
178 else if (DECL_CLASS_SCOPE_P (t))
179 push_nested_class (DECL_CONTEXT (t));
180 else
181 push_to_top_level ();
182
183 if (TREE_CODE (t) == FUNCTION_DECL)
184 {
185 saved_access_scope = tree_cons
186 (NULL_TREE, current_function_decl, saved_access_scope);
187 current_function_decl = t;
188 }
189}
190
191/* Restore the scope set up by push_access_scope. T is the node we
192 are processing. */
193
194static void
195pop_access_scope (tree t)
196{
197 if (TREE_CODE (t) == FUNCTION_DECL)
198 {
199 current_function_decl = TREE_VALUE (saved_access_scope);
200 saved_access_scope = TREE_CHAIN (saved_access_scope);
201 }
202
203 if (DECL_FRIEND_CONTEXT (t) || DECL_CLASS_SCOPE_P (t))
204 pop_nested_class ();
205 else
206 pop_from_top_level ();
207}
208
209/* Do any processing required when DECL (a member template
210 declaration) is finished. Returns the TEMPLATE_DECL corresponding
211 to DECL, unless it is a specialization, in which case the DECL
212 itself is returned. */
213
214tree
215finish_member_template_decl (tree decl)
216{
217 if (decl == error_mark_node)
218 return error_mark_node;
219
220 gcc_assert (DECL_P (decl));
221
222 if (TREE_CODE (decl) == TYPE_DECL)
223 {
224 tree type;
225
226 type = TREE_TYPE (decl);
227 if (IS_AGGR_TYPE (type)
228 && CLASSTYPE_TEMPLATE_INFO (type)
229 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
230 {
231 tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
232 check_member_template (tmpl);
233 return tmpl;
234 }
235 return NULL_TREE;
236 }
237 else if (TREE_CODE (decl) == FIELD_DECL)
238 error ("data member %qD cannot be a member template", decl);
239 else if (DECL_TEMPLATE_INFO (decl))
240 {
241 if (!DECL_TEMPLATE_SPECIALIZATION (decl))
242 {
243 check_member_template (DECL_TI_TEMPLATE (decl));
244 return DECL_TI_TEMPLATE (decl);
245 }
246 else
247 return decl;
248 }
249 else
250 error ("invalid member template declaration %qD", decl);
251
252 return error_mark_node;
253}
254
255/* Returns the template nesting level of the indicated class TYPE.
256
257 For example, in:
258 template <class T>
259 struct A
260 {
261 template <class U>
262 struct B {};
263 };
264
265 A<T>::B<U> has depth two, while A<T> has depth one.
266 Both A<T>::B<int> and A<int>::B<U> have depth one, if
267 they are instantiations, not specializations.
268
269 This function is guaranteed to return 0 if passed NULL_TREE so
270 that, for example, `template_class_depth (current_class_type)' is
271 always safe. */
272
273int
274template_class_depth (tree type)
275{
276 int depth;
277
278 for (depth = 0;
279 type && TREE_CODE (type) != NAMESPACE_DECL;
280 type = (TREE_CODE (type) == FUNCTION_DECL)
281 ? CP_DECL_CONTEXT (type) : TYPE_CONTEXT (type))
282 {
283 if (TREE_CODE (type) != FUNCTION_DECL)
284 {
285 if (CLASSTYPE_TEMPLATE_INFO (type)
286 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type))
287 && uses_template_parms (CLASSTYPE_TI_ARGS (type)))
288 ++depth;
289 }
290 else
291 {
292 if (DECL_TEMPLATE_INFO (type)
293 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (type))
294 && uses_template_parms (DECL_TI_ARGS (type)))
295 ++depth;
296 }
297 }
298
299 return depth;
300}
301
302/* Returns 1 if processing DECL as part of do_pending_inlines
303 needs us to push template parms. */
304
305static int
306inline_needs_template_parms (tree decl)
307{
308 if (! DECL_TEMPLATE_INFO (decl))
309 return 0;
310
311 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl)))
312 > (processing_template_decl + DECL_TEMPLATE_SPECIALIZATION (decl)));
313}
314
315/* Subroutine of maybe_begin_member_template_processing.
316 Push the template parms in PARMS, starting from LEVELS steps into the
317 chain, and ending at the beginning, since template parms are listed
318 innermost first. */
319
320static void
321push_inline_template_parms_recursive (tree parmlist, int levels)
322{
323 tree parms = TREE_VALUE (parmlist);
324 int i;
325
326 if (levels > 1)
327 push_inline_template_parms_recursive (TREE_CHAIN (parmlist), levels - 1);
328
329 ++processing_template_decl;
330 current_template_parms
331 = tree_cons (size_int (processing_template_decl),
332 parms, current_template_parms);
333 TEMPLATE_PARMS_FOR_INLINE (current_template_parms) = 1;
334
335 begin_scope (TREE_VEC_LENGTH (parms) ? sk_template_parms : sk_template_spec,
336 NULL);
337 for (i = 0; i < TREE_VEC_LENGTH (parms); ++i)
338 {
339 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
340
341 if (parm == error_mark_node)
342 continue;
343
344 gcc_assert (DECL_P (parm));
345
346 switch (TREE_CODE (parm))
347 {
348 case TYPE_DECL:
349 case TEMPLATE_DECL:
350 pushdecl (parm);
351 break;
352
353 case PARM_DECL:
354 {
355 /* Make a CONST_DECL as is done in process_template_parm.
356 It is ugly that we recreate this here; the original
357 version built in process_template_parm is no longer
358 available. */
359 tree decl = build_decl (CONST_DECL, DECL_NAME (parm),
360 TREE_TYPE (parm));
361 DECL_ARTIFICIAL (decl) = 1;
362 TREE_CONSTANT (decl) = 1;
363 TREE_INVARIANT (decl) = 1;
364 TREE_READONLY (decl) = 1;
365 DECL_INITIAL (decl) = DECL_INITIAL (parm);
366 SET_DECL_TEMPLATE_PARM_P (decl);
367 pushdecl (decl);
368 }
369 break;
370
371 default:
372 gcc_unreachable ();
373 }
374 }
375}
376
377/* Restore the template parameter context for a member template or
378 a friend template defined in a class definition. */
379
380void
381maybe_begin_member_template_processing (tree decl)
382{
383 tree parms;
384 int levels = 0;
385
386 if (inline_needs_template_parms (decl))
387 {
388 parms = DECL_TEMPLATE_PARMS (most_general_template (decl));
389 levels = TMPL_PARMS_DEPTH (parms) - processing_template_decl;
390
391 if (DECL_TEMPLATE_SPECIALIZATION (decl))
392 {
393 --levels;
394 parms = TREE_CHAIN (parms);
395 }
396
397 push_inline_template_parms_recursive (parms, levels);
398 }
399
400 /* Remember how many levels of template parameters we pushed so that
401 we can pop them later. */
402 VEC_safe_push (int, heap, inline_parm_levels, levels);
403}
404
405/* Undo the effects of maybe_begin_member_template_processing. */
406
407void
408maybe_end_member_template_processing (void)
409{
410 int i;
411 int last;
412
413 if (VEC_length (int, inline_parm_levels) == 0)
414 return;
415
416 last = VEC_pop (int, inline_parm_levels);
417 for (i = 0; i < last; ++i)
418 {
419 --processing_template_decl;
420 current_template_parms = TREE_CHAIN (current_template_parms);
421 poplevel (0, 0, 0);
422 }
423}
424
425/* Return a new template argument vector which contains all of ARGS,
426 but has as its innermost set of arguments the EXTRA_ARGS. */
427
428static tree
429add_to_template_args (tree args, tree extra_args)
430{
431 tree new_args;
432 int extra_depth;
433 int i;
434 int j;
435
436 extra_depth = TMPL_ARGS_DEPTH (extra_args);
437 new_args = make_tree_vec (TMPL_ARGS_DEPTH (args) + extra_depth);
438
439 for (i = 1; i <= TMPL_ARGS_DEPTH (args); ++i)
440 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (args, i));
441
442 for (j = 1; j <= extra_depth; ++j, ++i)
443 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (extra_args, j));
444
445 return new_args;
446}
447
448/* Like add_to_template_args, but only the outermost ARGS are added to
449 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
450 (EXTRA_ARGS) levels are added. This function is used to combine
451 the template arguments from a partial instantiation with the
452 template arguments used to attain the full instantiation from the
453 partial instantiation. */
454
455static tree
456add_outermost_template_args (tree args, tree extra_args)
457{
458 tree new_args;
459
460 /* If there are more levels of EXTRA_ARGS than there are ARGS,
461 something very fishy is going on. */
462 gcc_assert (TMPL_ARGS_DEPTH (args) >= TMPL_ARGS_DEPTH (extra_args));
463
464 /* If *all* the new arguments will be the EXTRA_ARGS, just return
465 them. */
466 if (TMPL_ARGS_DEPTH (args) == TMPL_ARGS_DEPTH (extra_args))
467 return extra_args;
468
469 /* For the moment, we make ARGS look like it contains fewer levels. */
470 TREE_VEC_LENGTH (args) -= TMPL_ARGS_DEPTH (extra_args);
471
472 new_args = add_to_template_args (args, extra_args);
473
474 /* Now, we restore ARGS to its full dimensions. */
475 TREE_VEC_LENGTH (args) += TMPL_ARGS_DEPTH (extra_args);
476
477 return new_args;
478}
479
480/* Return the N levels of innermost template arguments from the ARGS. */
481
482tree
483get_innermost_template_args (tree args, int n)
484{
485 tree new_args;
486 int extra_levels;
487 int i;
488
489 gcc_assert (n >= 0);
490
491 /* If N is 1, just return the innermost set of template arguments. */
492 if (n == 1)
493 return TMPL_ARGS_LEVEL (args, TMPL_ARGS_DEPTH (args));
494
495 /* If we're not removing anything, just return the arguments we were
496 given. */
497 extra_levels = TMPL_ARGS_DEPTH (args) - n;
498 gcc_assert (extra_levels >= 0);
499 if (extra_levels == 0)
500 return args;
501
502 /* Make a new set of arguments, not containing the outer arguments. */
503 new_args = make_tree_vec (n);
504 for (i = 1; i <= n; ++i)
505 SET_TMPL_ARGS_LEVEL (new_args, i,
506 TMPL_ARGS_LEVEL (args, i + extra_levels));
507
508 return new_args;
509}
510
511/* We've got a template header coming up; push to a new level for storing
512 the parms. */
513
514void
515begin_template_parm_list (void)
516{
517 /* We use a non-tag-transparent scope here, which causes pushtag to
518 put tags in this scope, rather than in the enclosing class or
519 namespace scope. This is the right thing, since we want
520 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
521 global template class, push_template_decl handles putting the
522 TEMPLATE_DECL into top-level scope. For a nested template class,
523 e.g.:
524
525 template <class T> struct S1 {
526 template <class T> struct S2 {};
527 };
528
529 pushtag contains special code to call pushdecl_with_scope on the
530 TEMPLATE_DECL for S2. */
531 begin_scope (sk_template_parms, NULL);
532 ++processing_template_decl;
533 ++processing_template_parmlist;
534 note_template_header (0);
535}
536
537/* This routine is called when a specialization is declared. If it is
538 invalid to declare a specialization here, an error is reported and
539 false is returned, otherwise this routine will return true. */
540
541static bool
542check_specialization_scope (void)
543{
544 tree scope = current_scope ();
545
546 /* [temp.expl.spec]
547
548 An explicit specialization shall be declared in the namespace of
549 which the template is a member, or, for member templates, in the
550 namespace of which the enclosing class or enclosing class
551 template is a member. An explicit specialization of a member
552 function, member class or static data member of a class template
553 shall be declared in the namespace of which the class template
554 is a member. */
555 if (scope && TREE_CODE (scope) != NAMESPACE_DECL)
556 {
557 error ("explicit specialization in non-namespace scope %qD", scope);
558 return false;
559 }
560
561 /* [temp.expl.spec]
562
563 In an explicit specialization declaration for a member of a class
564 template or a member template that appears in namespace scope,
565 the member template and some of its enclosing class templates may
566 remain unspecialized, except that the declaration shall not
567 explicitly specialize a class member template if its enclosing
568 class templates are not explicitly specialized as well. */
569 if (current_template_parms)
570 {
571 error ("enclosing class templates are not explicitly specialized");
572 return false;
573 }
574
575 return true;
576}
577
578/* We've just seen template <>. */
579
580bool
581begin_specialization (void)
582{
583 begin_scope (sk_template_spec, NULL);
584 note_template_header (1);
585 return check_specialization_scope ();
586}
587
588/* Called at then end of processing a declaration preceded by
589 template<>. */
590
591void
592end_specialization (void)
593{
594 finish_scope ();
595 reset_specialization ();
596}
597
598/* Any template <>'s that we have seen thus far are not referring to a
599 function specialization. */
600
601void
602reset_specialization (void)
603{
604 processing_specialization = 0;
605 template_header_count = 0;
606}
607
608/* We've just seen a template header. If SPECIALIZATION is nonzero,
609 it was of the form template <>. */
610
611static void
612note_template_header (int specialization)
613{
614 processing_specialization = specialization;
615 template_header_count++;
616}
617
618/* We're beginning an explicit instantiation. */
619
620void
621begin_explicit_instantiation (void)
622{
623 gcc_assert (!processing_explicit_instantiation);
624 processing_explicit_instantiation = true;
625}
626
627
628void
629end_explicit_instantiation (void)
630{
631 gcc_assert (processing_explicit_instantiation);
632 processing_explicit_instantiation = false;
633}
634
635/* An explicit specialization or partial specialization TMPL is being
636 declared. Check that the namespace in which the specialization is
637 occurring is permissible. Returns false iff it is invalid to
638 specialize TMPL in the current namespace. */
639
640static bool
641check_specialization_namespace (tree tmpl)
642{
643 tree tpl_ns = decl_namespace_context (tmpl);
644
645 /* [tmpl.expl.spec]
646
647 An explicit specialization shall be declared in the namespace of
648 which the template is a member, or, for member templates, in the
649 namespace of which the enclosing class or enclosing class
650 template is a member. An explicit specialization of a member
651 function, member class or static data member of a class template
652 shall be declared in the namespace of which the class template is
653 a member. */
654 if (is_associated_namespace (current_namespace, tpl_ns))
655 /* Same or super-using namespace. */
656 return true;
657 else
658 {
659 pedwarn ("specialization of %qD in different namespace", tmpl);
660 pedwarn (" from definition of %q+#D", tmpl);
661 return false;
662 }
663}
664
665/* SPEC is an explicit instantiation. Check that it is valid to
666 perform this explicit instantiation in the current namespace. */
667
668static void
669check_explicit_instantiation_namespace (tree spec)
670{
671 tree ns;
672
673 /* DR 275: An explicit instantiation shall appear in an enclosing
674 namespace of its template. */
675 ns = decl_namespace_context (spec);
676 if (!is_ancestor (current_namespace, ns))
677 pedwarn ("explicit instantiation of %qD in namespace %qD "
678 "(which does not enclose namespace %qD)",
679 spec, current_namespace, ns);
680}
681
682/* The TYPE is being declared. If it is a template type, that means it
683 is a partial specialization. Do appropriate error-checking. */
684
685tree
686maybe_process_partial_specialization (tree type)
687{
688 tree context;
689
690 if (type == error_mark_node)
691 return error_mark_node;
692
693 if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
694 {
695 error ("name of class shadows template template parameter %qD",
696 TYPE_NAME (type));
697 return error_mark_node;
698 }
699
700 context = TYPE_CONTEXT (type);
701
702 if (CLASS_TYPE_P (type) && CLASSTYPE_USE_TEMPLATE (type))
703 {
704 /* This is for ordinary explicit specialization and partial
705 specialization of a template class such as:
706
707 template <> class C<int>;
708
709 or:
710
711 template <class T> class C<T*>;
712
713 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
714
715 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type)
716 && !COMPLETE_TYPE_P (type))
717 {
718 check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (type));
719 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
720 if (processing_template_decl)
721 push_template_decl (TYPE_MAIN_DECL (type));
722 }
723 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type))
724 error ("specialization of %qT after instantiation", type);
725 }
726 else if (CLASS_TYPE_P (type)
727 && !CLASSTYPE_USE_TEMPLATE (type)
728 && CLASSTYPE_TEMPLATE_INFO (type)
729 && context && CLASS_TYPE_P (context)
730 && CLASSTYPE_TEMPLATE_INFO (context))
731 {
732 /* This is for an explicit specialization of member class
733 template according to [temp.expl.spec/18]:
734
735 template <> template <class U> class C<int>::D;
736
737 The context `C<int>' must be an implicit instantiation.
738 Otherwise this is just a member class template declared
739 earlier like:
740
741 template <> class C<int> { template <class U> class D; };
742 template <> template <class U> class C<int>::D;
743
744 In the first case, `C<int>::D' is a specialization of `C<T>::D'
745 while in the second case, `C<int>::D' is a primary template
746 and `C<T>::D' may not exist. */
747
748 if (CLASSTYPE_IMPLICIT_INSTANTIATION (context)
749 && !COMPLETE_TYPE_P (type))
750 {
751 tree t;
752
753 if (current_namespace
754 != decl_namespace_context (CLASSTYPE_TI_TEMPLATE (type)))
755 {
756 pedwarn ("specializing %q#T in different namespace", type);
757 pedwarn (" from definition of %q+#D",
758 CLASSTYPE_TI_TEMPLATE (type));
759 }
760
761 /* Check for invalid specialization after instantiation:
762
763 template <> template <> class C<int>::D<int>;
764 template <> template <class U> class C<int>::D; */
765
766 for (t = DECL_TEMPLATE_INSTANTIATIONS
767 (most_general_template (CLASSTYPE_TI_TEMPLATE (type)));
768 t; t = TREE_CHAIN (t))
769 if (TREE_VALUE (t) != type
770 && TYPE_CONTEXT (TREE_VALUE (t)) == context)
771 error ("specialization %qT after instantiation %qT",
772 type, TREE_VALUE (t));
773
774 /* Mark TYPE as a specialization. And as a result, we only
775 have one level of template argument for the innermost
776 class template. */
777 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
778 CLASSTYPE_TI_ARGS (type)
779 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
780 }
781 }
782 else if (processing_specialization)
783 {
784 error ("explicit specialization of non-template %qT", type);
785 return error_mark_node;
786 }
787
788 return type;
789}
790
791/* Returns nonzero if we can optimize the retrieval of specializations
792 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
793 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
794
795static inline bool
796optimize_specialization_lookup_p (tree tmpl)
797{
798 return (DECL_FUNCTION_TEMPLATE_P (tmpl)
799 && DECL_CLASS_SCOPE_P (tmpl)
800 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
801 parameter. */
802 && CLASS_TYPE_P (DECL_CONTEXT (tmpl))
803 /* The optimized lookup depends on the fact that the
804 template arguments for the member function template apply
805 purely to the containing class, which is not true if the
806 containing class is an explicit or partial
807 specialization. */
808 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl))
809 && !DECL_MEMBER_TEMPLATE_P (tmpl)
810 && !DECL_CONV_FN_P (tmpl)
811 /* It is possible to have a template that is not a member
812 template and is not a member of a template class:
813
814 template <typename T>
815 struct S { friend A::f(); };
816
817 Here, the friend function is a template, but the context does
818 not have template information. The optimized lookup relies
819 on having ARGS be the template arguments for both the class
820 and the function template. */
821 && !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl)));
822}
823
824/* Retrieve the specialization (in the sense of [temp.spec] - a
825 specialization is either an instantiation or an explicit
826 specialization) of TMPL for the given template ARGS. If there is
827 no such specialization, return NULL_TREE. The ARGS are a vector of
828 arguments, or a vector of vectors of arguments, in the case of
829 templates with more than one level of parameters.
830
831 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
832 then we search for a partial specialization matching ARGS. This
833 parameter is ignored if TMPL is not a class template. */
834
835static tree
836retrieve_specialization (tree tmpl, tree args,
837 bool class_specializations_p)
838{
839 if (args == error_mark_node)
840 return NULL_TREE;
841
842 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
843
844 /* There should be as many levels of arguments as there are
845 levels of parameters. */
846 gcc_assert (TMPL_ARGS_DEPTH (args)
847 == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)));
848
849 if (optimize_specialization_lookup_p (tmpl))
850 {
851 tree class_template;
852 tree class_specialization;
853 VEC(tree,gc) *methods;
854 tree fns;
855 int idx;
856
857 /* The template arguments actually apply to the containing
858 class. Find the class specialization with those
859 arguments. */
860 class_template = CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl));
861 class_specialization
862 = retrieve_specialization (class_template, args,
863 /*class_specializations_p=*/false);
864 if (!class_specialization)
865 return NULL_TREE;
866 /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
867 for the specialization. */
868 idx = class_method_index_for_fn (class_specialization, tmpl);
869 if (idx == -1)
870 return NULL_TREE;
871 /* Iterate through the methods with the indicated name, looking
872 for the one that has an instance of TMPL. */
873 methods = CLASSTYPE_METHOD_VEC (class_specialization);
874 for (fns = VEC_index (tree, methods, idx); fns; fns = OVL_NEXT (fns))
875 {
876 tree fn = OVL_CURRENT (fns);
877 if (DECL_TEMPLATE_INFO (fn) && DECL_TI_TEMPLATE (fn) == tmpl)
878 return fn;
879 }
880 return NULL_TREE;
881 }
882 else
883 {
884 tree *sp;
885 tree *head;
886
887 /* Class templates store their instantiations on the
888 DECL_TEMPLATE_INSTANTIATIONS list; other templates use the
889 DECL_TEMPLATE_SPECIALIZATIONS list. */
890 if (!class_specializations_p
891 && TREE_CODE (DECL_TEMPLATE_RESULT (tmpl)) == TYPE_DECL)
892 sp = &DECL_TEMPLATE_INSTANTIATIONS (tmpl);
893 else
894 sp = &DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
895 head = sp;
896 /* Iterate through the list until we find a matching template. */
897 while (*sp != NULL_TREE)
898 {
899 tree spec = *sp;
900
901 if (comp_template_args (TREE_PURPOSE (spec), args))
902 {
903 /* Use the move-to-front heuristic to speed up future
904 searches. */
905 if (spec != *head)
906 {
907 *sp = TREE_CHAIN (*sp);
908 TREE_CHAIN (spec) = *head;
909 *head = spec;
910 }
911 return TREE_VALUE (spec);
912 }
913 sp = &TREE_CHAIN (spec);
914 }
915 }
916
917 return NULL_TREE;
918}
919
920/* Like retrieve_specialization, but for local declarations. */
921
922static tree
923retrieve_local_specialization (tree tmpl)
924{
925 tree spec = (tree) htab_find_with_hash (local_specializations, tmpl,
926 htab_hash_pointer (tmpl));
927 return spec ? TREE_PURPOSE (spec) : NULL_TREE;
928}
929
930/* Returns nonzero iff DECL is a specialization of TMPL. */
931
932int
933is_specialization_of (tree decl, tree tmpl)
934{
935 tree t;
936
937 if (TREE_CODE (decl) == FUNCTION_DECL)
938 {
939 for (t = decl;
940 t != NULL_TREE;
941 t = DECL_TEMPLATE_INFO (t) ? DECL_TI_TEMPLATE (t) : NULL_TREE)
942 if (t == tmpl)
943 return 1;
944 }
945 else
946 {
947 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
948
949 for (t = TREE_TYPE (decl);
950 t != NULL_TREE;
951 t = CLASSTYPE_USE_TEMPLATE (t)
952 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t)) : NULL_TREE)
953 if (same_type_ignoring_top_level_qualifiers_p (t, TREE_TYPE (tmpl)))
954 return 1;
955 }
956
957 return 0;
958}
959
960/* Returns nonzero iff DECL is a specialization of friend declaration
961 FRIEND according to [temp.friend]. */
962
963bool
964is_specialization_of_friend (tree decl, tree friend)
965{
966 bool need_template = true;
967 int template_depth;
968
969 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
970 || TREE_CODE (decl) == TYPE_DECL);
971
972 /* For [temp.friend/6] when FRIEND is an ordinary member function
973 of a template class, we want to check if DECL is a specialization
974 if this. */
975 if (TREE_CODE (friend) == FUNCTION_DECL
976 && DECL_TEMPLATE_INFO (friend)
977 && !DECL_USE_TEMPLATE (friend))
978 {
979 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
980 friend = DECL_TI_TEMPLATE (friend);
981 need_template = false;
982 }
983 else if (TREE_CODE (friend) == TEMPLATE_DECL
984 && !PRIMARY_TEMPLATE_P (friend))
985 need_template = false;
986
987 /* There is nothing to do if this is not a template friend. */
988 if (TREE_CODE (friend) != TEMPLATE_DECL)
989 return false;
990
991 if (is_specialization_of (decl, friend))
992 return true;
993
994 /* [temp.friend/6]
995 A member of a class template may be declared to be a friend of a
996 non-template class. In this case, the corresponding member of
997 every specialization of the class template is a friend of the
998 class granting friendship.
999
1000 For example, given a template friend declaration
1001
1002 template <class T> friend void A<T>::f();
1003
1004 the member function below is considered a friend
1005
1006 template <> struct A<int> {
1007 void f();
1008 };
1009
1010 For this type of template friend, TEMPLATE_DEPTH below will be
1011 nonzero. To determine if DECL is a friend of FRIEND, we first
1012 check if the enclosing class is a specialization of another. */
1013
1014 template_depth = template_class_depth (DECL_CONTEXT (friend));
1015 if (template_depth
1016 && DECL_CLASS_SCOPE_P (decl)
1017 && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl)),
1018 CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend))))
1019 {
1020 /* Next, we check the members themselves. In order to handle
1021 a few tricky cases, such as when FRIEND's are
1022
1023 template <class T> friend void A<T>::g(T t);
1024 template <class T> template <T t> friend void A<T>::h();
1025
1026 and DECL's are
1027
1028 void A<int>::g(int);
1029 template <int> void A<int>::h();
1030
1031 we need to figure out ARGS, the template arguments from
1032 the context of DECL. This is required for template substitution
1033 of `T' in the function parameter of `g' and template parameter
1034 of `h' in the above examples. Here ARGS corresponds to `int'. */
1035
1036 tree context = DECL_CONTEXT (decl);
1037 tree args = NULL_TREE;
1038 int current_depth = 0;
1039
1040 while (current_depth < template_depth)
1041 {
1042 if (CLASSTYPE_TEMPLATE_INFO (context))
1043 {
1044 if (current_depth == 0)
1045 args = TYPE_TI_ARGS (context);
1046 else
1047 args = add_to_template_args (TYPE_TI_ARGS (context), args);
1048 current_depth++;
1049 }
1050 context = TYPE_CONTEXT (context);
1051 }
1052
1053 if (TREE_CODE (decl) == FUNCTION_DECL)
1054 {
1055 bool is_template;
1056 tree friend_type;
1057 tree decl_type;
1058 tree friend_args_type;
1059 tree decl_args_type;
1060
1061 /* Make sure that both DECL and FRIEND are templates or
1062 non-templates. */
1063 is_template = DECL_TEMPLATE_INFO (decl)
1064 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl));
1065 if (need_template ^ is_template)
1066 return false;
1067 else if (is_template)
1068 {
1069 /* If both are templates, check template parameter list. */
1070 tree friend_parms
1071 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend),
1072 args, tf_none);
1073 if (!comp_template_parms
1074 (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl)),
1075 friend_parms))
1076 return false;
1077
1078 decl_type = TREE_TYPE (DECL_TI_TEMPLATE (decl));
1079 }
1080 else
1081 decl_type = TREE_TYPE (decl);
1082
1083 friend_type = tsubst_function_type (TREE_TYPE (friend), args,
1084 tf_none, NULL_TREE);
1085 if (friend_type == error_mark_node)
1086 return false;
1087
1088 /* Check if return types match. */
1089 if (!same_type_p (TREE_TYPE (decl_type), TREE_TYPE (friend_type)))
1090 return false;
1091
1092 /* Check if function parameter types match, ignoring the
1093 `this' parameter. */
1094 friend_args_type = TYPE_ARG_TYPES (friend_type);
1095 decl_args_type = TYPE_ARG_TYPES (decl_type);
1096 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend))
1097 friend_args_type = TREE_CHAIN (friend_args_type);
1098 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1099 decl_args_type = TREE_CHAIN (decl_args_type);
1100
1101 return compparms (decl_args_type, friend_args_type);
1102 }
1103 else
1104 {
1105 /* DECL is a TYPE_DECL */
1106 bool is_template;
1107 tree decl_type = TREE_TYPE (decl);
1108
1109 /* Make sure that both DECL and FRIEND are templates or
1110 non-templates. */
1111 is_template
1112 = CLASSTYPE_TEMPLATE_INFO (decl_type)
1113 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type));
1114
1115 if (need_template ^ is_template)
1116 return false;
1117 else if (is_template)
1118 {
1119 tree friend_parms;
1120 /* If both are templates, check the name of the two
1121 TEMPLATE_DECL's first because is_friend didn't. */
1122 if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type))
1123 != DECL_NAME (friend))
1124 return false;
1125
1126 /* Now check template parameter list. */
1127 friend_parms
1128 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend),
1129 args, tf_none);
1130 return comp_template_parms
1131 (DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type)),
1132 friend_parms);
1133 }
1134 else
1135 return (DECL_NAME (decl)
1136 == DECL_NAME (friend));
1137 }
1138 }
1139 return false;
1140}
1141
1142/* Register the specialization SPEC as a specialization of TMPL with
1143 the indicated ARGS. IS_FRIEND indicates whether the specialization
1144 is actually just a friend declaration. Returns SPEC, or an
1145 equivalent prior declaration, if available. */
1146
1147static tree
1148register_specialization (tree spec, tree tmpl, tree args, bool is_friend)
1149{
1150 tree fn;
1151
1152 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
1153
1154 if (TREE_CODE (spec) == FUNCTION_DECL
1155 && uses_template_parms (DECL_TI_ARGS (spec)))
1156 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1157 register it; we want the corresponding TEMPLATE_DECL instead.
1158 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1159 the more obvious `uses_template_parms (spec)' to avoid problems
1160 with default function arguments. In particular, given
1161 something like this:
1162
1163 template <class T> void f(T t1, T t = T())
1164
1165 the default argument expression is not substituted for in an
1166 instantiation unless and until it is actually needed. */
1167 return spec;
1168
1169 fn = retrieve_specialization (tmpl, args,
1170 /*class_specializations_p=*/false);
1171 /* We can sometimes try to re-register a specialization that we've
1172 already got. In particular, regenerate_decl_from_template calls
1173 duplicate_decls which will update the specialization list. But,
1174 we'll still get called again here anyhow. It's more convenient
1175 to simply allow this than to try to prevent it. */
1176 if (fn == spec)
1177 return spec;
1178 else if (fn && DECL_TEMPLATE_SPECIALIZATION (spec))
1179 {
1180 if (DECL_TEMPLATE_INSTANTIATION (fn))
1181 {
1182 if (TREE_USED (fn)
1183 || DECL_EXPLICIT_INSTANTIATION (fn))
1184 {
1185 error ("specialization of %qD after instantiation",
1186 fn);
1187 return error_mark_node;
1188 }
1189 else
1190 {
1191 tree clone;
1192 /* This situation should occur only if the first
1193 specialization is an implicit instantiation, the
1194 second is an explicit specialization, and the
1195 implicit instantiation has not yet been used. That
1196 situation can occur if we have implicitly
1197 instantiated a member function and then specialized
1198 it later.
1199
1200 We can also wind up here if a friend declaration that
1201 looked like an instantiation turns out to be a
1202 specialization:
1203
1204 template <class T> void foo(T);
1205 class S { friend void foo<>(int) };
1206 template <> void foo(int);
1207
1208 We transform the existing DECL in place so that any
1209 pointers to it become pointers to the updated
1210 declaration.
1211
1212 If there was a definition for the template, but not
1213 for the specialization, we want this to look as if
1214 there were no definition, and vice versa. */
1215 DECL_INITIAL (fn) = NULL_TREE;
1216 duplicate_decls (spec, fn, is_friend);
1217 /* The call to duplicate_decls will have applied
1218 [temp.expl.spec]:
1219
1220 An explicit specialization of a function template
1221 is inline only if it is explicitly declared to be,
1222 and independently of whether its function template
1223 is.
1224
1225 to the primary function; now copy the inline bits to
1226 the various clones. */
1227 FOR_EACH_CLONE (clone, fn)
1228 {
1229 DECL_DECLARED_INLINE_P (clone)
1230 = DECL_DECLARED_INLINE_P (fn);
1231 DECL_INLINE (clone)
1232 = DECL_INLINE (fn);
1233 }
1234 check_specialization_namespace (fn);
1235
1236 return fn;
1237 }
1238 }
1239 else if (DECL_TEMPLATE_SPECIALIZATION (fn))
1240 {
1241 if (!duplicate_decls (spec, fn, is_friend) && DECL_INITIAL (spec))
1242 /* Dup decl failed, but this is a new definition. Set the
1243 line number so any errors match this new
1244 definition. */
1245 DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (spec);
1246
1247 return fn;
1248 }
1249 }
1250
1251 /* A specialization must be declared in the same namespace as the
1252 template it is specializing. */
1253 if (DECL_TEMPLATE_SPECIALIZATION (spec)
1254 && !check_specialization_namespace (tmpl))
1255 DECL_CONTEXT (spec) = FROB_CONTEXT (decl_namespace_context (tmpl));
1256
1257 if (!optimize_specialization_lookup_p (tmpl))
1258 DECL_TEMPLATE_SPECIALIZATIONS (tmpl)
1259 = tree_cons (args, spec, DECL_TEMPLATE_SPECIALIZATIONS (tmpl));
1260
1261 return spec;
1262}
1263
1264/* Unregister the specialization SPEC as a specialization of TMPL.
1265 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1266 if the SPEC was listed as a specialization of TMPL. */
1267
1268bool
1269reregister_specialization (tree spec, tree tmpl, tree new_spec)
1270{
1271 tree* s;
1272
1273 for (s = &DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
1274 *s != NULL_TREE;
1275 s = &TREE_CHAIN (*s))
1276 if (TREE_VALUE (*s) == spec)
1277 {
1278 if (!new_spec)
1279 *s = TREE_CHAIN (*s);
1280 else
1281 TREE_VALUE (*s) = new_spec;
1282 return 1;
1283 }
1284
1285 return 0;
1286}
1287
1288/* Compare an entry in the local specializations hash table P1 (which
1289 is really a pointer to a TREE_LIST) with P2 (which is really a
1290 DECL). */
1291
1292static int
1293eq_local_specializations (const void *p1, const void *p2)
1294{
1295 return TREE_VALUE ((tree) p1) == (tree) p2;
1296}
1297
1298/* Hash P1, an entry in the local specializations table. */
1299
1300static hashval_t
1301hash_local_specialization (const void* p1)
1302{
1303 return htab_hash_pointer (TREE_VALUE ((tree) p1));
1304}
1305
1306/* Like register_specialization, but for local declarations. We are
1307 registering SPEC, an instantiation of TMPL. */
1308
1309static void
1310register_local_specialization (tree spec, tree tmpl)
1311{
1312 void **slot;
1313
1314 slot = htab_find_slot_with_hash (local_specializations, tmpl,
1315 htab_hash_pointer (tmpl), INSERT);
1316 *slot = build_tree_list (spec, tmpl);
1317}
1318
1319/* TYPE is a class type. Returns true if TYPE is an explicitly
1320 specialized class. */
1321
1322bool
1323explicit_class_specialization_p (tree type)
1324{
1325 if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
1326 return false;
1327 return !uses_template_parms (CLASSTYPE_TI_ARGS (type));
1328}
1329
1330/* Print the list of candidate FNS in an error message. */
1331
1332void
1333print_candidates (tree fns)
1334{
1335 tree fn;
1336
1337 const char *str = "candidates are:";
1338
1339 for (fn = fns; fn != NULL_TREE; fn = TREE_CHAIN (fn))
1340 {
1341 tree f;
1342
1343 for (f = TREE_VALUE (fn); f; f = OVL_NEXT (f))
1344 error ("%s %+#D", str, OVL_CURRENT (f));
1345 str = " ";
1346 }
1347}
1348
1349/* Returns the template (one of the functions given by TEMPLATE_ID)
1350 which can be specialized to match the indicated DECL with the
1351 explicit template args given in TEMPLATE_ID. The DECL may be
1352 NULL_TREE if none is available. In that case, the functions in
1353 TEMPLATE_ID are non-members.
1354
1355 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1356 specialization of a member template.
1357
1358 The TEMPLATE_COUNT is the number of references to qualifying
1359 template classes that appeared in the name of the function. See
1360 check_explicit_specialization for a more accurate description.
1361
1362 TSK indicates what kind of template declaration (if any) is being
1363 declared. TSK_TEMPLATE indicates that the declaration given by
1364 DECL, though a FUNCTION_DECL, has template parameters, and is
1365 therefore a template function.
1366
1367 The template args (those explicitly specified and those deduced)
1368 are output in a newly created vector *TARGS_OUT.
1369
1370 If it is impossible to determine the result, an error message is
1371 issued. The error_mark_node is returned to indicate failure. */
1372
1373static tree
1374determine_specialization (tree template_id,
1375 tree decl,
1376 tree* targs_out,
1377 int need_member_template,
1378 int template_count,
1379 tmpl_spec_kind tsk)
1380{
1381 tree fns;
1382 tree targs;
1383 tree explicit_targs;
1384 tree candidates = NULL_TREE;
1385 /* A TREE_LIST of templates of which DECL may be a specialization.
1386 The TREE_VALUE of each node is a TEMPLATE_DECL. The
1387 corresponding TREE_PURPOSE is the set of template arguments that,
1388 when used to instantiate the template, would produce a function
1389 with the signature of DECL. */
1390 tree templates = NULL_TREE;
1391 int header_count;
1392 struct cp_binding_level *b;
1393
1394 *targs_out = NULL_TREE;
1395
1396 if (template_id == error_mark_node || decl == error_mark_node)
1397 return error_mark_node;
1398
1399 fns = TREE_OPERAND (template_id, 0);
1400 explicit_targs = TREE_OPERAND (template_id, 1);
1401
1402 if (fns == error_mark_node)
1403 return error_mark_node;
1404
1405 /* Check for baselinks. */
1406 if (BASELINK_P (fns))
1407 fns = BASELINK_FUNCTIONS (fns);
1408
1409 if (!is_overloaded_fn (fns))
1410 {
1411 error ("%qD is not a function template", fns);
1412 return error_mark_node;
1413 }
1414
1415 /* Count the number of template headers specified for this
1416 specialization. */
1417 header_count = 0;
1418 for (b = current_binding_level;
1419 b->kind == sk_template_parms;
1420 b = b->level_chain)
1421 ++header_count;
1422
1423 for (; fns; fns = OVL_NEXT (fns))
1424 {
1425 tree fn = OVL_CURRENT (fns);
1426
1427 if (TREE_CODE (fn) == TEMPLATE_DECL)
1428 {
1429 tree decl_arg_types;
1430 tree fn_arg_types;
1431
1432 /* In case of explicit specialization, we need to check if
1433 the number of template headers appearing in the specialization
1434 is correct. This is usually done in check_explicit_specialization,
1435 but the check done there cannot be exhaustive when specializing
1436 member functions. Consider the following code:
1437
1438 template <> void A<int>::f(int);
1439 template <> template <> void A<int>::f(int);
1440
1441 Assuming that A<int> is not itself an explicit specialization
1442 already, the first line specializes "f" which is a non-template
1443 member function, whilst the second line specializes "f" which
1444 is a template member function. So both lines are syntactically
1445 correct, and check_explicit_specialization does not reject
1446 them.
1447
1448 Here, we can do better, as we are matching the specialization
1449 against the declarations. We count the number of template
1450 headers, and we check if they match TEMPLATE_COUNT + 1
1451 (TEMPLATE_COUNT is the number of qualifying template classes,
1452 plus there must be another header for the member template
1453 itself).
1454
1455 Notice that if header_count is zero, this is not a
1456 specialization but rather a template instantiation, so there
1457 is no check we can perform here. */
1458 if (header_count && header_count != template_count + 1)
1459 continue;
1460
1461 /* Check that the number of template arguments at the
1462 innermost level for DECL is the same as for FN. */
1463 if (current_binding_level->kind == sk_template_parms
1464 && !current_binding_level->explicit_spec_p
1465 && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn))
1466 != TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
1467 (current_template_parms))))
1468 continue;
1469
1470 /* DECL might be a specialization of FN. */
1471 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
1472 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
1473
1474 /* For a non-static member function, we need to make sure
1475 that the const qualification is the same. Since
1476 get_bindings does not try to merge the "this" parameter,
1477 we must do the comparison explicitly. */
1478 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1479 && !same_type_p (TREE_VALUE (fn_arg_types),
1480 TREE_VALUE (decl_arg_types)))
1481 continue;
1482
1483 /* Skip the "this" parameter and, for constructors of
1484 classes with virtual bases, the VTT parameter. A
1485 full specialization of a constructor will have a VTT
1486 parameter, but a template never will. */
1487 decl_arg_types
1488 = skip_artificial_parms_for (decl, decl_arg_types);
1489 fn_arg_types
1490 = skip_artificial_parms_for (fn, fn_arg_types);
1491
1492 /* Check that the number of function parameters matches.
1493 For example,
1494 template <class T> void f(int i = 0);
1495 template <> void f<int>();
1496 The specialization f<int> is invalid but is not caught
1497 by get_bindings below. */
1498 if (list_length (fn_arg_types) != list_length (decl_arg_types))
1499 continue;
1500
1501 /* Function templates cannot be specializations; there are
1502 no partial specializations of functions. Therefore, if
1503 the type of DECL does not match FN, there is no
1504 match. */
1505 if (tsk == tsk_template)
1506 {
1507 if (compparms (fn_arg_types, decl_arg_types))
1508 candidates = tree_cons (NULL_TREE, fn, candidates);
1509 continue;
1510 }
1511
1512 /* See whether this function might be a specialization of this
1513 template. */
1514 targs = get_bindings (fn, decl, explicit_targs, /*check_ret=*/true);
1515
1516 if (!targs)
1517 /* We cannot deduce template arguments that when used to
1518 specialize TMPL will produce DECL. */
1519 continue;
1520
1521 /* Save this template, and the arguments deduced. */
1522 templates = tree_cons (targs, fn, templates);
1523 }
1524 else if (need_member_template)
1525 /* FN is an ordinary member function, and we need a
1526 specialization of a member template. */
1527 ;
1528 else if (TREE_CODE (fn) != FUNCTION_DECL)
1529 /* We can get IDENTIFIER_NODEs here in certain erroneous
1530 cases. */
1531 ;
1532 else if (!DECL_FUNCTION_MEMBER_P (fn))
1533 /* This is just an ordinary non-member function. Nothing can
1534 be a specialization of that. */
1535 ;
1536 else if (DECL_ARTIFICIAL (fn))
1537 /* Cannot specialize functions that are created implicitly. */
1538 ;
1539 else
1540 {
1541 tree decl_arg_types;
1542
1543 /* This is an ordinary member function. However, since
1544 we're here, we can assume it's enclosing class is a
1545 template class. For example,
1546
1547 template <typename T> struct S { void f(); };
1548 template <> void S<int>::f() {}
1549
1550 Here, S<int>::f is a non-template, but S<int> is a
1551 template class. If FN has the same type as DECL, we
1552 might be in business. */
1553
1554 if (!DECL_TEMPLATE_INFO (fn))
1555 /* Its enclosing class is an explicit specialization
1556 of a template class. This is not a candidate. */
1557 continue;
1558
1559 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
1560 TREE_TYPE (TREE_TYPE (fn))))
1561 /* The return types differ. */
1562 continue;
1563
1564 /* Adjust the type of DECL in case FN is a static member. */
1565 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
1566 if (DECL_STATIC_FUNCTION_P (fn)
1567 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1568 decl_arg_types = TREE_CHAIN (decl_arg_types);
1569
1570 if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1571 decl_arg_types))
1572 /* They match! */
1573 candidates = tree_cons (NULL_TREE, fn, candidates);
1574 }
1575 }
1576
1577 if (templates && TREE_CHAIN (templates))
1578 {
1579 /* We have:
1580
1581 [temp.expl.spec]
1582
1583 It is possible for a specialization with a given function
1584 signature to be instantiated from more than one function
1585 template. In such cases, explicit specification of the
1586 template arguments must be used to uniquely identify the
1587 function template specialization being specialized.
1588
1589 Note that here, there's no suggestion that we're supposed to
1590 determine which of the candidate templates is most
1591 specialized. However, we, also have:
1592
1593 [temp.func.order]
1594
1595 Partial ordering of overloaded function template
1596 declarations is used in the following contexts to select
1597 the function template to which a function template
1598 specialization refers:
1599
1600 -- when an explicit specialization refers to a function
1601 template.
1602
1603 So, we do use the partial ordering rules, at least for now.
1604 This extension can only serve to make invalid programs valid,
1605 so it's safe. And, there is strong anecdotal evidence that
1606 the committee intended the partial ordering rules to apply;
1607 the EDG front-end has that behavior, and John Spicer claims
1608 that the committee simply forgot to delete the wording in
1609 [temp.expl.spec]. */
1610 tree tmpl = most_specialized_instantiation (templates);
1611 if (tmpl != error_mark_node)
1612 {
1613 templates = tmpl;
1614 TREE_CHAIN (templates) = NULL_TREE;
1615 }
1616 }
1617
1618 if (templates == NULL_TREE && candidates == NULL_TREE)
1619 {
1620 error ("template-id %qD for %q+D does not match any template "
1621 "declaration", template_id, decl);
1622 return error_mark_node;
1623 }
1624 else if ((templates && TREE_CHAIN (templates))
1625 || (candidates && TREE_CHAIN (candidates))
1626 || (templates && candidates))
1627 {
1628 error ("ambiguous template specialization %qD for %q+D",
1629 template_id, decl);
1630 chainon (candidates, templates);
1631 print_candidates (candidates);
1632 return error_mark_node;
1633 }
1634
1635 /* We have one, and exactly one, match. */
1636 if (candidates)
1637 {
1638 tree fn = TREE_VALUE (candidates);
1639 /* DECL is a re-declaration of a template function. */
1640 if (TREE_CODE (fn) == TEMPLATE_DECL)
1641 return fn;
1642 /* It was a specialization of an ordinary member function in a
1643 template class. */
1644 *targs_out = copy_node (DECL_TI_ARGS (fn));
1645 return DECL_TI_TEMPLATE (fn);
1646 }
1647
1648 /* It was a specialization of a template. */
1649 targs = DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates)));
1650 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs))
1651 {
1652 *targs_out = copy_node (targs);
1653 SET_TMPL_ARGS_LEVEL (*targs_out,
1654 TMPL_ARGS_DEPTH (*targs_out),
1655 TREE_PURPOSE (templates));
1656 }
1657 else
1658 *targs_out = TREE_PURPOSE (templates);
1659 return TREE_VALUE (templates);
1660}
1661
1662/* Returns a chain of parameter types, exactly like the SPEC_TYPES,
1663 but with the default argument values filled in from those in the
1664 TMPL_TYPES. */
1665
1666static tree
1667copy_default_args_to_explicit_spec_1 (tree spec_types,
1668 tree tmpl_types)
1669{
1670 tree new_spec_types;
1671
1672 if (!spec_types)
1673 return NULL_TREE;
1674
1675 if (spec_types == void_list_node)
1676 return void_list_node;
1677
1678 /* Substitute into the rest of the list. */
1679 new_spec_types =
1680 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types),
1681 TREE_CHAIN (tmpl_types));
1682
1683 /* Add the default argument for this parameter. */
1684 return hash_tree_cons (TREE_PURPOSE (tmpl_types),
1685 TREE_VALUE (spec_types),
1686 new_spec_types);
1687}
1688
1689/* DECL is an explicit specialization. Replicate default arguments
1690 from the template it specializes. (That way, code like:
1691
1692 template <class T> void f(T = 3);
1693 template <> void f(double);
1694 void g () { f (); }
1695
1696 works, as required.) An alternative approach would be to look up
1697 the correct default arguments at the call-site, but this approach
1698 is consistent with how implicit instantiations are handled. */
1699
1700static void
1701copy_default_args_to_explicit_spec (tree decl)
1702{
1703 tree tmpl;
1704 tree spec_types;
1705 tree tmpl_types;
1706 tree new_spec_types;
1707 tree old_type;
1708 tree new_type;
1709 tree t;
1710 tree object_type = NULL_TREE;
1711 tree in_charge = NULL_TREE;
1712 tree vtt = NULL_TREE;
1713
1714 /* See if there's anything we need to do. */
1715 tmpl = DECL_TI_TEMPLATE (decl);
1716 tmpl_types = TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl)));
1717 for (t = tmpl_types; t; t = TREE_CHAIN (t))
1718 if (TREE_PURPOSE (t))
1719 break;
1720 if (!t)
1721 return;
1722
1723 old_type = TREE_TYPE (decl);
1724 spec_types = TYPE_ARG_TYPES (old_type);
1725
1726 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1727 {
1728 /* Remove the this pointer, but remember the object's type for
1729 CV quals. */
1730 object_type = TREE_TYPE (TREE_VALUE (spec_types));
1731 spec_types = TREE_CHAIN (spec_types);
1732 tmpl_types = TREE_CHAIN (tmpl_types);
1733
1734 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
1735 {
1736 /* DECL may contain more parameters than TMPL due to the extra
1737 in-charge parameter in constructors and destructors. */
1738 in_charge = spec_types;
1739 spec_types = TREE_CHAIN (spec_types);
1740 }
1741 if (DECL_HAS_VTT_PARM_P (decl))
1742 {
1743 vtt = spec_types;
1744 spec_types = TREE_CHAIN (spec_types);
1745 }
1746 }
1747
1748 /* Compute the merged default arguments. */
1749 new_spec_types =
1750 copy_default_args_to_explicit_spec_1 (spec_types, tmpl_types);
1751
1752 /* Compute the new FUNCTION_TYPE. */
1753 if (object_type)
1754 {
1755 if (vtt)
1756 new_spec_types = hash_tree_cons (TREE_PURPOSE (vtt),
1757 TREE_VALUE (vtt),
1758 new_spec_types);
1759
1760 if (in_charge)
1761 /* Put the in-charge parameter back. */
1762 new_spec_types = hash_tree_cons (TREE_PURPOSE (in_charge),
1763 TREE_VALUE (in_charge),
1764 new_spec_types);
1765
1766 new_type = build_method_type_directly (object_type,
1767 TREE_TYPE (old_type),
1768 new_spec_types);
1769 }
1770 else
1771 new_type = build_function_type (TREE_TYPE (old_type),
1772 new_spec_types);
1773 new_type = cp_build_type_attribute_variant (new_type,
1774 TYPE_ATTRIBUTES (old_type));
1775 new_type = build_exception_variant (new_type,
1776 TYPE_RAISES_EXCEPTIONS (old_type));
1777 TREE_TYPE (decl) = new_type;
1778}
1779
1780/* Check to see if the function just declared, as indicated in
1781 DECLARATOR, and in DECL, is a specialization of a function
1782 template. We may also discover that the declaration is an explicit
1783 instantiation at this point.
1784
1785 Returns DECL, or an equivalent declaration that should be used
1786 instead if all goes well. Issues an error message if something is
1787 amiss. Returns error_mark_node if the error is not easily
1788 recoverable.
1789
1790 FLAGS is a bitmask consisting of the following flags:
1791
1792 2: The function has a definition.
1793 4: The function is a friend.
1794
1795 The TEMPLATE_COUNT is the number of references to qualifying
1796 template classes that appeared in the name of the function. For
1797 example, in
1798
1799 template <class T> struct S { void f(); };
1800 void S<int>::f();
1801
1802 the TEMPLATE_COUNT would be 1. However, explicitly specialized
1803 classes are not counted in the TEMPLATE_COUNT, so that in
1804
1805 template <class T> struct S {};
1806 template <> struct S<int> { void f(); }
1807 template <> void S<int>::f();
1808
1809 the TEMPLATE_COUNT would be 0. (Note that this declaration is
1810 invalid; there should be no template <>.)
1811
1812 If the function is a specialization, it is marked as such via
1813 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
1814 is set up correctly, and it is added to the list of specializations
1815 for that template. */
1816
1817tree
1818check_explicit_specialization (tree declarator,
1819 tree decl,
1820 int template_count,
1821 int flags)
1822{
1823 int have_def = flags & 2;
1824 int is_friend = flags & 4;
1825 int specialization = 0;
1826 int explicit_instantiation = 0;
1827 int member_specialization = 0;
1828 tree ctype = DECL_CLASS_CONTEXT (decl);
1829 tree dname = DECL_NAME (decl);
1830 tmpl_spec_kind tsk;
1831
1832 if (is_friend)
1833 {
1834 if (!processing_specialization)
1835 tsk = tsk_none;
1836 else
1837 tsk = tsk_excessive_parms;
1838 }
1839 else
1840 tsk = current_tmpl_spec_kind (template_count);
1841
1842 switch (tsk)
1843 {
1844 case tsk_none:
1845 if (processing_specialization)
1846 {
1847 specialization = 1;
1848 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
1849 }
1850 else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
1851 {
1852 if (is_friend)
1853 /* This could be something like:
1854
1855 template <class T> void f(T);
1856 class S { friend void f<>(int); } */
1857 specialization = 1;
1858 else
1859 {
1860 /* This case handles bogus declarations like template <>
1861 template <class T> void f<int>(); */
1862
1863 error ("template-id %qD in declaration of primary template",
1864 declarator);
1865 return decl;
1866 }
1867 }
1868 break;
1869
1870 case tsk_invalid_member_spec:
1871 /* The error has already been reported in
1872 check_specialization_scope. */
1873 return error_mark_node;
1874
1875 case tsk_invalid_expl_inst:
1876 error ("template parameter list used in explicit instantiation");
1877
1878 /* Fall through. */
1879
1880 case tsk_expl_inst:
1881 if (have_def)
1882 error ("definition provided for explicit instantiation");
1883
1884 explicit_instantiation = 1;
1885 break;
1886
1887 case tsk_excessive_parms:
1888 case tsk_insufficient_parms:
1889 if (tsk == tsk_excessive_parms)
1890 error ("too many template parameter lists in declaration of %qD",
1891 decl);
1892 else if (template_header_count)
1893 error("too few template parameter lists in declaration of %qD", decl);
1894 else
1895 error("explicit specialization of %qD must be introduced by "
1896 "%<template <>%>", decl);
1897
1898 /* Fall through. */
1899 case tsk_expl_spec:
1900 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
1901 if (ctype)
1902 member_specialization = 1;
1903 else
1904 specialization = 1;
1905 break;
1906
1907 case tsk_template:
1908 if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
1909 {
1910 /* This case handles bogus declarations like template <>
1911 template <class T> void f<int>(); */
1912
1913 if (uses_template_parms (declarator))
1914 error ("function template partial specialization %qD "
1915 "is not allowed", declarator);
1916 else
1917 error ("template-id %qD in declaration of primary template",
1918 declarator);
1919 return decl;
1920 }
1921
1922 if (ctype && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype))
1923 /* This is a specialization of a member template, without
1924 specialization the containing class. Something like:
1925
1926 template <class T> struct S {
1927 template <class U> void f (U);
1928 };
1929 template <> template <class U> void S<int>::f(U) {}
1930
1931 That's a specialization -- but of the entire template. */
1932 specialization = 1;
1933 break;
1934
1935 default:
1936 gcc_unreachable ();
1937 }
1938
1939 if (specialization || member_specialization)
1940 {
1941 tree t = TYPE_ARG_TYPES (TREE_TYPE (decl));
1942 for (; t; t = TREE_CHAIN (t))
1943 if (TREE_PURPOSE (t))
1944 {
1945 pedwarn
1946 ("default argument specified in explicit specialization");
1947 break;
1948 }
1949 }
1950
1951 if (specialization || member_specialization || explicit_instantiation)
1952 {
1953 tree tmpl = NULL_TREE;
1954 tree targs = NULL_TREE;
1955
1956 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
1957 if (TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
1958 {
1959 tree fns;
1960
1961 gcc_assert (TREE_CODE (declarator) == IDENTIFIER_NODE);
1962 if (ctype)
1963 fns = dname;
1964 else
1965 {
1966 /* If there is no class context, the explicit instantiation
1967 must be at namespace scope. */
1968 gcc_assert (DECL_NAMESPACE_SCOPE_P (decl));
1969
1970 /* Find the namespace binding, using the declaration
1971 context. */
1972 fns = lookup_qualified_name (CP_DECL_CONTEXT (decl), dname,
1973 false, true);
| 1/* Handle parameterized types (templates) for GNU C++.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
4 Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing.
5 Rewritten by Jason Merrill (jason@cygnus.com).
6
7This file is part of GCC.
8
9GCC is free software; you can redistribute it and/or modify
10it under the terms of the GNU General Public License as published by
11the Free Software Foundation; either version 2, or (at your option)
12any later version.
13
14GCC is distributed in the hope that it will be useful,
15but WITHOUT ANY WARRANTY; without even the implied warranty of
16MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17GNU General Public License for more details.
18
19You should have received a copy of the GNU General Public License
20along with GCC; see the file COPYING. If not, write to
21the Free Software Foundation, 51 Franklin Street, Fifth Floor,
22Boston, MA 02110-1301, USA. */
23
24/* Known bugs or deficiencies include:
25
26 all methods must be provided in header files; can't use a source
27 file that contains only the method templates and "just win". */
28
29#include "config.h"
30#include "system.h"
31#include "coretypes.h"
32#include "tm.h"
33#include "obstack.h"
34#include "tree.h"
35#include "pointer-set.h"
36#include "flags.h"
37#include "c-common.h"
38#include "cp-tree.h"
39#include "cp-objcp-common.h"
40#include "tree-inline.h"
41#include "decl.h"
42#include "output.h"
43#include "except.h"
44#include "toplev.h"
45#include "rtl.h"
46#include "timevar.h"
47#include "tree-iterator.h"
48#include "vecprim.h"
49
50/* The type of functions taking a tree, and some additional data, and
51 returning an int. */
52typedef int (*tree_fn_t) (tree, void*);
53
54/* The PENDING_TEMPLATES is a TREE_LIST of templates whose
55 instantiations have been deferred, either because their definitions
56 were not yet available, or because we were putting off doing the work.
57 The TREE_PURPOSE of each entry is either a DECL (for a function or
58 static data member), or a TYPE (for a class) indicating what we are
59 hoping to instantiate. The TREE_VALUE is not used. */
60static GTY(()) tree pending_templates;
61static GTY(()) tree last_pending_template;
62
63int processing_template_parmlist;
64static int template_header_count;
65
66static GTY(()) tree saved_trees;
67static VEC(int,heap) *inline_parm_levels;
68
69static GTY(()) tree current_tinst_level;
70
71static GTY(()) tree saved_access_scope;
72
73/* Live only within one (recursive) call to tsubst_expr. We use
74 this to pass the statement expression node from the STMT_EXPR
75 to the EXPR_STMT that is its result. */
76static tree cur_stmt_expr;
77
78/* A map from local variable declarations in the body of the template
79 presently being instantiated to the corresponding instantiated
80 local variables. */
81static htab_t local_specializations;
82
83#define UNIFY_ALLOW_NONE 0
84#define UNIFY_ALLOW_MORE_CV_QUAL 1
85#define UNIFY_ALLOW_LESS_CV_QUAL 2
86#define UNIFY_ALLOW_DERIVED 4
87#define UNIFY_ALLOW_INTEGER 8
88#define UNIFY_ALLOW_OUTER_LEVEL 16
89#define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
90#define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
91
92static void push_access_scope (tree);
93static void pop_access_scope (tree);
94static bool resolve_overloaded_unification (tree, tree, tree, tree,
95 unification_kind_t, int);
96static int try_one_overload (tree, tree, tree, tree, tree,
97 unification_kind_t, int, bool);
98static int unify (tree, tree, tree, tree, int);
99static void add_pending_template (tree);
100static int push_tinst_level (tree);
101static void pop_tinst_level (void);
102static void reopen_tinst_level (tree);
103static tree classtype_mangled_name (tree);
104static char* mangle_class_name_for_template (const char *, tree, tree);
105static tree tsubst_initializer_list (tree, tree);
106static tree get_class_bindings (tree, tree, tree);
107static tree coerce_template_parms (tree, tree, tree, tsubst_flags_t,
108 bool, bool);
109static void tsubst_enum (tree, tree, tree);
110static tree add_to_template_args (tree, tree);
111static tree add_outermost_template_args (tree, tree);
112static bool check_instantiated_args (tree, tree, tsubst_flags_t);
113static int maybe_adjust_types_for_deduction (unification_kind_t, tree*, tree*);
114static int type_unification_real (tree, tree, tree, tree,
115 int, unification_kind_t, int);
116static void note_template_header (int);
117static tree convert_nontype_argument_function (tree, tree);
118static tree convert_nontype_argument (tree, tree);
119static tree convert_template_argument (tree, tree, tree,
120 tsubst_flags_t, int, tree);
121static int for_each_template_parm (tree, tree_fn_t, void*,
122 struct pointer_set_t*);
123static tree build_template_parm_index (int, int, int, tree, tree);
124static int inline_needs_template_parms (tree);
125static void push_inline_template_parms_recursive (tree, int);
126static tree retrieve_local_specialization (tree);
127static void register_local_specialization (tree, tree);
128static tree reduce_template_parm_level (tree, tree, int);
129static int mark_template_parm (tree, void *);
130static int template_parm_this_level_p (tree, void *);
131static tree tsubst_friend_function (tree, tree);
132static tree tsubst_friend_class (tree, tree);
133static int can_complete_type_without_circularity (tree);
134static tree get_bindings (tree, tree, tree, bool);
135static int template_decl_level (tree);
136static int check_cv_quals_for_unify (int, tree, tree);
137static tree tsubst_template_arg (tree, tree, tsubst_flags_t, tree);
138static tree tsubst_template_args (tree, tree, tsubst_flags_t, tree);
139static tree tsubst_template_parms (tree, tree, tsubst_flags_t);
140static void regenerate_decl_from_template (tree, tree);
141static tree most_specialized_class (tree, tree);
142static tree tsubst_aggr_type (tree, tree, tsubst_flags_t, tree, int);
143static tree tsubst_arg_types (tree, tree, tsubst_flags_t, tree);
144static tree tsubst_function_type (tree, tree, tsubst_flags_t, tree);
145static bool check_specialization_scope (void);
146static tree process_partial_specialization (tree);
147static void set_current_access_from_decl (tree);
148static void check_default_tmpl_args (tree, tree, int, int);
149static tree get_template_base (tree, tree, tree, tree);
150static tree try_class_unification (tree, tree, tree, tree);
151static int coerce_template_template_parms (tree, tree, tsubst_flags_t,
152 tree, tree);
153static int template_args_equal (tree, tree);
154static void tsubst_default_arguments (tree);
155static tree for_each_template_parm_r (tree *, int *, void *);
156static tree copy_default_args_to_explicit_spec_1 (tree, tree);
157static void copy_default_args_to_explicit_spec (tree);
158static int invalid_nontype_parm_type_p (tree, tsubst_flags_t);
159static int eq_local_specializations (const void *, const void *);
160static bool dependent_type_p_r (tree);
161static tree tsubst (tree, tree, tsubst_flags_t, tree);
162static tree tsubst_expr (tree, tree, tsubst_flags_t, tree, bool);
163static tree tsubst_copy (tree, tree, tsubst_flags_t, tree);
164
165/* Make the current scope suitable for access checking when we are
166 processing T. T can be FUNCTION_DECL for instantiated function
167 template, or VAR_DECL for static member variable (need by
168 instantiate_decl). */
169
170static void
171push_access_scope (tree t)
172{
173 gcc_assert (TREE_CODE (t) == FUNCTION_DECL
174 || TREE_CODE (t) == VAR_DECL);
175
176 if (DECL_FRIEND_CONTEXT (t))
177 push_nested_class (DECL_FRIEND_CONTEXT (t));
178 else if (DECL_CLASS_SCOPE_P (t))
179 push_nested_class (DECL_CONTEXT (t));
180 else
181 push_to_top_level ();
182
183 if (TREE_CODE (t) == FUNCTION_DECL)
184 {
185 saved_access_scope = tree_cons
186 (NULL_TREE, current_function_decl, saved_access_scope);
187 current_function_decl = t;
188 }
189}
190
191/* Restore the scope set up by push_access_scope. T is the node we
192 are processing. */
193
194static void
195pop_access_scope (tree t)
196{
197 if (TREE_CODE (t) == FUNCTION_DECL)
198 {
199 current_function_decl = TREE_VALUE (saved_access_scope);
200 saved_access_scope = TREE_CHAIN (saved_access_scope);
201 }
202
203 if (DECL_FRIEND_CONTEXT (t) || DECL_CLASS_SCOPE_P (t))
204 pop_nested_class ();
205 else
206 pop_from_top_level ();
207}
208
209/* Do any processing required when DECL (a member template
210 declaration) is finished. Returns the TEMPLATE_DECL corresponding
211 to DECL, unless it is a specialization, in which case the DECL
212 itself is returned. */
213
214tree
215finish_member_template_decl (tree decl)
216{
217 if (decl == error_mark_node)
218 return error_mark_node;
219
220 gcc_assert (DECL_P (decl));
221
222 if (TREE_CODE (decl) == TYPE_DECL)
223 {
224 tree type;
225
226 type = TREE_TYPE (decl);
227 if (IS_AGGR_TYPE (type)
228 && CLASSTYPE_TEMPLATE_INFO (type)
229 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
230 {
231 tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
232 check_member_template (tmpl);
233 return tmpl;
234 }
235 return NULL_TREE;
236 }
237 else if (TREE_CODE (decl) == FIELD_DECL)
238 error ("data member %qD cannot be a member template", decl);
239 else if (DECL_TEMPLATE_INFO (decl))
240 {
241 if (!DECL_TEMPLATE_SPECIALIZATION (decl))
242 {
243 check_member_template (DECL_TI_TEMPLATE (decl));
244 return DECL_TI_TEMPLATE (decl);
245 }
246 else
247 return decl;
248 }
249 else
250 error ("invalid member template declaration %qD", decl);
251
252 return error_mark_node;
253}
254
255/* Returns the template nesting level of the indicated class TYPE.
256
257 For example, in:
258 template <class T>
259 struct A
260 {
261 template <class U>
262 struct B {};
263 };
264
265 A<T>::B<U> has depth two, while A<T> has depth one.
266 Both A<T>::B<int> and A<int>::B<U> have depth one, if
267 they are instantiations, not specializations.
268
269 This function is guaranteed to return 0 if passed NULL_TREE so
270 that, for example, `template_class_depth (current_class_type)' is
271 always safe. */
272
273int
274template_class_depth (tree type)
275{
276 int depth;
277
278 for (depth = 0;
279 type && TREE_CODE (type) != NAMESPACE_DECL;
280 type = (TREE_CODE (type) == FUNCTION_DECL)
281 ? CP_DECL_CONTEXT (type) : TYPE_CONTEXT (type))
282 {
283 if (TREE_CODE (type) != FUNCTION_DECL)
284 {
285 if (CLASSTYPE_TEMPLATE_INFO (type)
286 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type))
287 && uses_template_parms (CLASSTYPE_TI_ARGS (type)))
288 ++depth;
289 }
290 else
291 {
292 if (DECL_TEMPLATE_INFO (type)
293 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (type))
294 && uses_template_parms (DECL_TI_ARGS (type)))
295 ++depth;
296 }
297 }
298
299 return depth;
300}
301
302/* Returns 1 if processing DECL as part of do_pending_inlines
303 needs us to push template parms. */
304
305static int
306inline_needs_template_parms (tree decl)
307{
308 if (! DECL_TEMPLATE_INFO (decl))
309 return 0;
310
311 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl)))
312 > (processing_template_decl + DECL_TEMPLATE_SPECIALIZATION (decl)));
313}
314
315/* Subroutine of maybe_begin_member_template_processing.
316 Push the template parms in PARMS, starting from LEVELS steps into the
317 chain, and ending at the beginning, since template parms are listed
318 innermost first. */
319
320static void
321push_inline_template_parms_recursive (tree parmlist, int levels)
322{
323 tree parms = TREE_VALUE (parmlist);
324 int i;
325
326 if (levels > 1)
327 push_inline_template_parms_recursive (TREE_CHAIN (parmlist), levels - 1);
328
329 ++processing_template_decl;
330 current_template_parms
331 = tree_cons (size_int (processing_template_decl),
332 parms, current_template_parms);
333 TEMPLATE_PARMS_FOR_INLINE (current_template_parms) = 1;
334
335 begin_scope (TREE_VEC_LENGTH (parms) ? sk_template_parms : sk_template_spec,
336 NULL);
337 for (i = 0; i < TREE_VEC_LENGTH (parms); ++i)
338 {
339 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
340
341 if (parm == error_mark_node)
342 continue;
343
344 gcc_assert (DECL_P (parm));
345
346 switch (TREE_CODE (parm))
347 {
348 case TYPE_DECL:
349 case TEMPLATE_DECL:
350 pushdecl (parm);
351 break;
352
353 case PARM_DECL:
354 {
355 /* Make a CONST_DECL as is done in process_template_parm.
356 It is ugly that we recreate this here; the original
357 version built in process_template_parm is no longer
358 available. */
359 tree decl = build_decl (CONST_DECL, DECL_NAME (parm),
360 TREE_TYPE (parm));
361 DECL_ARTIFICIAL (decl) = 1;
362 TREE_CONSTANT (decl) = 1;
363 TREE_INVARIANT (decl) = 1;
364 TREE_READONLY (decl) = 1;
365 DECL_INITIAL (decl) = DECL_INITIAL (parm);
366 SET_DECL_TEMPLATE_PARM_P (decl);
367 pushdecl (decl);
368 }
369 break;
370
371 default:
372 gcc_unreachable ();
373 }
374 }
375}
376
377/* Restore the template parameter context for a member template or
378 a friend template defined in a class definition. */
379
380void
381maybe_begin_member_template_processing (tree decl)
382{
383 tree parms;
384 int levels = 0;
385
386 if (inline_needs_template_parms (decl))
387 {
388 parms = DECL_TEMPLATE_PARMS (most_general_template (decl));
389 levels = TMPL_PARMS_DEPTH (parms) - processing_template_decl;
390
391 if (DECL_TEMPLATE_SPECIALIZATION (decl))
392 {
393 --levels;
394 parms = TREE_CHAIN (parms);
395 }
396
397 push_inline_template_parms_recursive (parms, levels);
398 }
399
400 /* Remember how many levels of template parameters we pushed so that
401 we can pop them later. */
402 VEC_safe_push (int, heap, inline_parm_levels, levels);
403}
404
405/* Undo the effects of maybe_begin_member_template_processing. */
406
407void
408maybe_end_member_template_processing (void)
409{
410 int i;
411 int last;
412
413 if (VEC_length (int, inline_parm_levels) == 0)
414 return;
415
416 last = VEC_pop (int, inline_parm_levels);
417 for (i = 0; i < last; ++i)
418 {
419 --processing_template_decl;
420 current_template_parms = TREE_CHAIN (current_template_parms);
421 poplevel (0, 0, 0);
422 }
423}
424
425/* Return a new template argument vector which contains all of ARGS,
426 but has as its innermost set of arguments the EXTRA_ARGS. */
427
428static tree
429add_to_template_args (tree args, tree extra_args)
430{
431 tree new_args;
432 int extra_depth;
433 int i;
434 int j;
435
436 extra_depth = TMPL_ARGS_DEPTH (extra_args);
437 new_args = make_tree_vec (TMPL_ARGS_DEPTH (args) + extra_depth);
438
439 for (i = 1; i <= TMPL_ARGS_DEPTH (args); ++i)
440 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (args, i));
441
442 for (j = 1; j <= extra_depth; ++j, ++i)
443 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (extra_args, j));
444
445 return new_args;
446}
447
448/* Like add_to_template_args, but only the outermost ARGS are added to
449 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
450 (EXTRA_ARGS) levels are added. This function is used to combine
451 the template arguments from a partial instantiation with the
452 template arguments used to attain the full instantiation from the
453 partial instantiation. */
454
455static tree
456add_outermost_template_args (tree args, tree extra_args)
457{
458 tree new_args;
459
460 /* If there are more levels of EXTRA_ARGS than there are ARGS,
461 something very fishy is going on. */
462 gcc_assert (TMPL_ARGS_DEPTH (args) >= TMPL_ARGS_DEPTH (extra_args));
463
464 /* If *all* the new arguments will be the EXTRA_ARGS, just return
465 them. */
466 if (TMPL_ARGS_DEPTH (args) == TMPL_ARGS_DEPTH (extra_args))
467 return extra_args;
468
469 /* For the moment, we make ARGS look like it contains fewer levels. */
470 TREE_VEC_LENGTH (args) -= TMPL_ARGS_DEPTH (extra_args);
471
472 new_args = add_to_template_args (args, extra_args);
473
474 /* Now, we restore ARGS to its full dimensions. */
475 TREE_VEC_LENGTH (args) += TMPL_ARGS_DEPTH (extra_args);
476
477 return new_args;
478}
479
480/* Return the N levels of innermost template arguments from the ARGS. */
481
482tree
483get_innermost_template_args (tree args, int n)
484{
485 tree new_args;
486 int extra_levels;
487 int i;
488
489 gcc_assert (n >= 0);
490
491 /* If N is 1, just return the innermost set of template arguments. */
492 if (n == 1)
493 return TMPL_ARGS_LEVEL (args, TMPL_ARGS_DEPTH (args));
494
495 /* If we're not removing anything, just return the arguments we were
496 given. */
497 extra_levels = TMPL_ARGS_DEPTH (args) - n;
498 gcc_assert (extra_levels >= 0);
499 if (extra_levels == 0)
500 return args;
501
502 /* Make a new set of arguments, not containing the outer arguments. */
503 new_args = make_tree_vec (n);
504 for (i = 1; i <= n; ++i)
505 SET_TMPL_ARGS_LEVEL (new_args, i,
506 TMPL_ARGS_LEVEL (args, i + extra_levels));
507
508 return new_args;
509}
510
511/* We've got a template header coming up; push to a new level for storing
512 the parms. */
513
514void
515begin_template_parm_list (void)
516{
517 /* We use a non-tag-transparent scope here, which causes pushtag to
518 put tags in this scope, rather than in the enclosing class or
519 namespace scope. This is the right thing, since we want
520 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
521 global template class, push_template_decl handles putting the
522 TEMPLATE_DECL into top-level scope. For a nested template class,
523 e.g.:
524
525 template <class T> struct S1 {
526 template <class T> struct S2 {};
527 };
528
529 pushtag contains special code to call pushdecl_with_scope on the
530 TEMPLATE_DECL for S2. */
531 begin_scope (sk_template_parms, NULL);
532 ++processing_template_decl;
533 ++processing_template_parmlist;
534 note_template_header (0);
535}
536
537/* This routine is called when a specialization is declared. If it is
538 invalid to declare a specialization here, an error is reported and
539 false is returned, otherwise this routine will return true. */
540
541static bool
542check_specialization_scope (void)
543{
544 tree scope = current_scope ();
545
546 /* [temp.expl.spec]
547
548 An explicit specialization shall be declared in the namespace of
549 which the template is a member, or, for member templates, in the
550 namespace of which the enclosing class or enclosing class
551 template is a member. An explicit specialization of a member
552 function, member class or static data member of a class template
553 shall be declared in the namespace of which the class template
554 is a member. */
555 if (scope && TREE_CODE (scope) != NAMESPACE_DECL)
556 {
557 error ("explicit specialization in non-namespace scope %qD", scope);
558 return false;
559 }
560
561 /* [temp.expl.spec]
562
563 In an explicit specialization declaration for a member of a class
564 template or a member template that appears in namespace scope,
565 the member template and some of its enclosing class templates may
566 remain unspecialized, except that the declaration shall not
567 explicitly specialize a class member template if its enclosing
568 class templates are not explicitly specialized as well. */
569 if (current_template_parms)
570 {
571 error ("enclosing class templates are not explicitly specialized");
572 return false;
573 }
574
575 return true;
576}
577
578/* We've just seen template <>. */
579
580bool
581begin_specialization (void)
582{
583 begin_scope (sk_template_spec, NULL);
584 note_template_header (1);
585 return check_specialization_scope ();
586}
587
588/* Called at then end of processing a declaration preceded by
589 template<>. */
590
591void
592end_specialization (void)
593{
594 finish_scope ();
595 reset_specialization ();
596}
597
598/* Any template <>'s that we have seen thus far are not referring to a
599 function specialization. */
600
601void
602reset_specialization (void)
603{
604 processing_specialization = 0;
605 template_header_count = 0;
606}
607
608/* We've just seen a template header. If SPECIALIZATION is nonzero,
609 it was of the form template <>. */
610
611static void
612note_template_header (int specialization)
613{
614 processing_specialization = specialization;
615 template_header_count++;
616}
617
618/* We're beginning an explicit instantiation. */
619
620void
621begin_explicit_instantiation (void)
622{
623 gcc_assert (!processing_explicit_instantiation);
624 processing_explicit_instantiation = true;
625}
626
627
628void
629end_explicit_instantiation (void)
630{
631 gcc_assert (processing_explicit_instantiation);
632 processing_explicit_instantiation = false;
633}
634
635/* An explicit specialization or partial specialization TMPL is being
636 declared. Check that the namespace in which the specialization is
637 occurring is permissible. Returns false iff it is invalid to
638 specialize TMPL in the current namespace. */
639
640static bool
641check_specialization_namespace (tree tmpl)
642{
643 tree tpl_ns = decl_namespace_context (tmpl);
644
645 /* [tmpl.expl.spec]
646
647 An explicit specialization shall be declared in the namespace of
648 which the template is a member, or, for member templates, in the
649 namespace of which the enclosing class or enclosing class
650 template is a member. An explicit specialization of a member
651 function, member class or static data member of a class template
652 shall be declared in the namespace of which the class template is
653 a member. */
654 if (is_associated_namespace (current_namespace, tpl_ns))
655 /* Same or super-using namespace. */
656 return true;
657 else
658 {
659 pedwarn ("specialization of %qD in different namespace", tmpl);
660 pedwarn (" from definition of %q+#D", tmpl);
661 return false;
662 }
663}
664
665/* SPEC is an explicit instantiation. Check that it is valid to
666 perform this explicit instantiation in the current namespace. */
667
668static void
669check_explicit_instantiation_namespace (tree spec)
670{
671 tree ns;
672
673 /* DR 275: An explicit instantiation shall appear in an enclosing
674 namespace of its template. */
675 ns = decl_namespace_context (spec);
676 if (!is_ancestor (current_namespace, ns))
677 pedwarn ("explicit instantiation of %qD in namespace %qD "
678 "(which does not enclose namespace %qD)",
679 spec, current_namespace, ns);
680}
681
682/* The TYPE is being declared. If it is a template type, that means it
683 is a partial specialization. Do appropriate error-checking. */
684
685tree
686maybe_process_partial_specialization (tree type)
687{
688 tree context;
689
690 if (type == error_mark_node)
691 return error_mark_node;
692
693 if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
694 {
695 error ("name of class shadows template template parameter %qD",
696 TYPE_NAME (type));
697 return error_mark_node;
698 }
699
700 context = TYPE_CONTEXT (type);
701
702 if (CLASS_TYPE_P (type) && CLASSTYPE_USE_TEMPLATE (type))
703 {
704 /* This is for ordinary explicit specialization and partial
705 specialization of a template class such as:
706
707 template <> class C<int>;
708
709 or:
710
711 template <class T> class C<T*>;
712
713 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
714
715 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type)
716 && !COMPLETE_TYPE_P (type))
717 {
718 check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (type));
719 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
720 if (processing_template_decl)
721 push_template_decl (TYPE_MAIN_DECL (type));
722 }
723 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type))
724 error ("specialization of %qT after instantiation", type);
725 }
726 else if (CLASS_TYPE_P (type)
727 && !CLASSTYPE_USE_TEMPLATE (type)
728 && CLASSTYPE_TEMPLATE_INFO (type)
729 && context && CLASS_TYPE_P (context)
730 && CLASSTYPE_TEMPLATE_INFO (context))
731 {
732 /* This is for an explicit specialization of member class
733 template according to [temp.expl.spec/18]:
734
735 template <> template <class U> class C<int>::D;
736
737 The context `C<int>' must be an implicit instantiation.
738 Otherwise this is just a member class template declared
739 earlier like:
740
741 template <> class C<int> { template <class U> class D; };
742 template <> template <class U> class C<int>::D;
743
744 In the first case, `C<int>::D' is a specialization of `C<T>::D'
745 while in the second case, `C<int>::D' is a primary template
746 and `C<T>::D' may not exist. */
747
748 if (CLASSTYPE_IMPLICIT_INSTANTIATION (context)
749 && !COMPLETE_TYPE_P (type))
750 {
751 tree t;
752
753 if (current_namespace
754 != decl_namespace_context (CLASSTYPE_TI_TEMPLATE (type)))
755 {
756 pedwarn ("specializing %q#T in different namespace", type);
757 pedwarn (" from definition of %q+#D",
758 CLASSTYPE_TI_TEMPLATE (type));
759 }
760
761 /* Check for invalid specialization after instantiation:
762
763 template <> template <> class C<int>::D<int>;
764 template <> template <class U> class C<int>::D; */
765
766 for (t = DECL_TEMPLATE_INSTANTIATIONS
767 (most_general_template (CLASSTYPE_TI_TEMPLATE (type)));
768 t; t = TREE_CHAIN (t))
769 if (TREE_VALUE (t) != type
770 && TYPE_CONTEXT (TREE_VALUE (t)) == context)
771 error ("specialization %qT after instantiation %qT",
772 type, TREE_VALUE (t));
773
774 /* Mark TYPE as a specialization. And as a result, we only
775 have one level of template argument for the innermost
776 class template. */
777 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
778 CLASSTYPE_TI_ARGS (type)
779 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
780 }
781 }
782 else if (processing_specialization)
783 {
784 error ("explicit specialization of non-template %qT", type);
785 return error_mark_node;
786 }
787
788 return type;
789}
790
791/* Returns nonzero if we can optimize the retrieval of specializations
792 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
793 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
794
795static inline bool
796optimize_specialization_lookup_p (tree tmpl)
797{
798 return (DECL_FUNCTION_TEMPLATE_P (tmpl)
799 && DECL_CLASS_SCOPE_P (tmpl)
800 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
801 parameter. */
802 && CLASS_TYPE_P (DECL_CONTEXT (tmpl))
803 /* The optimized lookup depends on the fact that the
804 template arguments for the member function template apply
805 purely to the containing class, which is not true if the
806 containing class is an explicit or partial
807 specialization. */
808 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl))
809 && !DECL_MEMBER_TEMPLATE_P (tmpl)
810 && !DECL_CONV_FN_P (tmpl)
811 /* It is possible to have a template that is not a member
812 template and is not a member of a template class:
813
814 template <typename T>
815 struct S { friend A::f(); };
816
817 Here, the friend function is a template, but the context does
818 not have template information. The optimized lookup relies
819 on having ARGS be the template arguments for both the class
820 and the function template. */
821 && !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl)));
822}
823
824/* Retrieve the specialization (in the sense of [temp.spec] - a
825 specialization is either an instantiation or an explicit
826 specialization) of TMPL for the given template ARGS. If there is
827 no such specialization, return NULL_TREE. The ARGS are a vector of
828 arguments, or a vector of vectors of arguments, in the case of
829 templates with more than one level of parameters.
830
831 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
832 then we search for a partial specialization matching ARGS. This
833 parameter is ignored if TMPL is not a class template. */
834
835static tree
836retrieve_specialization (tree tmpl, tree args,
837 bool class_specializations_p)
838{
839 if (args == error_mark_node)
840 return NULL_TREE;
841
842 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
843
844 /* There should be as many levels of arguments as there are
845 levels of parameters. */
846 gcc_assert (TMPL_ARGS_DEPTH (args)
847 == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)));
848
849 if (optimize_specialization_lookup_p (tmpl))
850 {
851 tree class_template;
852 tree class_specialization;
853 VEC(tree,gc) *methods;
854 tree fns;
855 int idx;
856
857 /* The template arguments actually apply to the containing
858 class. Find the class specialization with those
859 arguments. */
860 class_template = CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl));
861 class_specialization
862 = retrieve_specialization (class_template, args,
863 /*class_specializations_p=*/false);
864 if (!class_specialization)
865 return NULL_TREE;
866 /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
867 for the specialization. */
868 idx = class_method_index_for_fn (class_specialization, tmpl);
869 if (idx == -1)
870 return NULL_TREE;
871 /* Iterate through the methods with the indicated name, looking
872 for the one that has an instance of TMPL. */
873 methods = CLASSTYPE_METHOD_VEC (class_specialization);
874 for (fns = VEC_index (tree, methods, idx); fns; fns = OVL_NEXT (fns))
875 {
876 tree fn = OVL_CURRENT (fns);
877 if (DECL_TEMPLATE_INFO (fn) && DECL_TI_TEMPLATE (fn) == tmpl)
878 return fn;
879 }
880 return NULL_TREE;
881 }
882 else
883 {
884 tree *sp;
885 tree *head;
886
887 /* Class templates store their instantiations on the
888 DECL_TEMPLATE_INSTANTIATIONS list; other templates use the
889 DECL_TEMPLATE_SPECIALIZATIONS list. */
890 if (!class_specializations_p
891 && TREE_CODE (DECL_TEMPLATE_RESULT (tmpl)) == TYPE_DECL)
892 sp = &DECL_TEMPLATE_INSTANTIATIONS (tmpl);
893 else
894 sp = &DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
895 head = sp;
896 /* Iterate through the list until we find a matching template. */
897 while (*sp != NULL_TREE)
898 {
899 tree spec = *sp;
900
901 if (comp_template_args (TREE_PURPOSE (spec), args))
902 {
903 /* Use the move-to-front heuristic to speed up future
904 searches. */
905 if (spec != *head)
906 {
907 *sp = TREE_CHAIN (*sp);
908 TREE_CHAIN (spec) = *head;
909 *head = spec;
910 }
911 return TREE_VALUE (spec);
912 }
913 sp = &TREE_CHAIN (spec);
914 }
915 }
916
917 return NULL_TREE;
918}
919
920/* Like retrieve_specialization, but for local declarations. */
921
922static tree
923retrieve_local_specialization (tree tmpl)
924{
925 tree spec = (tree) htab_find_with_hash (local_specializations, tmpl,
926 htab_hash_pointer (tmpl));
927 return spec ? TREE_PURPOSE (spec) : NULL_TREE;
928}
929
930/* Returns nonzero iff DECL is a specialization of TMPL. */
931
932int
933is_specialization_of (tree decl, tree tmpl)
934{
935 tree t;
936
937 if (TREE_CODE (decl) == FUNCTION_DECL)
938 {
939 for (t = decl;
940 t != NULL_TREE;
941 t = DECL_TEMPLATE_INFO (t) ? DECL_TI_TEMPLATE (t) : NULL_TREE)
942 if (t == tmpl)
943 return 1;
944 }
945 else
946 {
947 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
948
949 for (t = TREE_TYPE (decl);
950 t != NULL_TREE;
951 t = CLASSTYPE_USE_TEMPLATE (t)
952 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t)) : NULL_TREE)
953 if (same_type_ignoring_top_level_qualifiers_p (t, TREE_TYPE (tmpl)))
954 return 1;
955 }
956
957 return 0;
958}
959
960/* Returns nonzero iff DECL is a specialization of friend declaration
961 FRIEND according to [temp.friend]. */
962
963bool
964is_specialization_of_friend (tree decl, tree friend)
965{
966 bool need_template = true;
967 int template_depth;
968
969 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
970 || TREE_CODE (decl) == TYPE_DECL);
971
972 /* For [temp.friend/6] when FRIEND is an ordinary member function
973 of a template class, we want to check if DECL is a specialization
974 if this. */
975 if (TREE_CODE (friend) == FUNCTION_DECL
976 && DECL_TEMPLATE_INFO (friend)
977 && !DECL_USE_TEMPLATE (friend))
978 {
979 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
980 friend = DECL_TI_TEMPLATE (friend);
981 need_template = false;
982 }
983 else if (TREE_CODE (friend) == TEMPLATE_DECL
984 && !PRIMARY_TEMPLATE_P (friend))
985 need_template = false;
986
987 /* There is nothing to do if this is not a template friend. */
988 if (TREE_CODE (friend) != TEMPLATE_DECL)
989 return false;
990
991 if (is_specialization_of (decl, friend))
992 return true;
993
994 /* [temp.friend/6]
995 A member of a class template may be declared to be a friend of a
996 non-template class. In this case, the corresponding member of
997 every specialization of the class template is a friend of the
998 class granting friendship.
999
1000 For example, given a template friend declaration
1001
1002 template <class T> friend void A<T>::f();
1003
1004 the member function below is considered a friend
1005
1006 template <> struct A<int> {
1007 void f();
1008 };
1009
1010 For this type of template friend, TEMPLATE_DEPTH below will be
1011 nonzero. To determine if DECL is a friend of FRIEND, we first
1012 check if the enclosing class is a specialization of another. */
1013
1014 template_depth = template_class_depth (DECL_CONTEXT (friend));
1015 if (template_depth
1016 && DECL_CLASS_SCOPE_P (decl)
1017 && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl)),
1018 CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend))))
1019 {
1020 /* Next, we check the members themselves. In order to handle
1021 a few tricky cases, such as when FRIEND's are
1022
1023 template <class T> friend void A<T>::g(T t);
1024 template <class T> template <T t> friend void A<T>::h();
1025
1026 and DECL's are
1027
1028 void A<int>::g(int);
1029 template <int> void A<int>::h();
1030
1031 we need to figure out ARGS, the template arguments from
1032 the context of DECL. This is required for template substitution
1033 of `T' in the function parameter of `g' and template parameter
1034 of `h' in the above examples. Here ARGS corresponds to `int'. */
1035
1036 tree context = DECL_CONTEXT (decl);
1037 tree args = NULL_TREE;
1038 int current_depth = 0;
1039
1040 while (current_depth < template_depth)
1041 {
1042 if (CLASSTYPE_TEMPLATE_INFO (context))
1043 {
1044 if (current_depth == 0)
1045 args = TYPE_TI_ARGS (context);
1046 else
1047 args = add_to_template_args (TYPE_TI_ARGS (context), args);
1048 current_depth++;
1049 }
1050 context = TYPE_CONTEXT (context);
1051 }
1052
1053 if (TREE_CODE (decl) == FUNCTION_DECL)
1054 {
1055 bool is_template;
1056 tree friend_type;
1057 tree decl_type;
1058 tree friend_args_type;
1059 tree decl_args_type;
1060
1061 /* Make sure that both DECL and FRIEND are templates or
1062 non-templates. */
1063 is_template = DECL_TEMPLATE_INFO (decl)
1064 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl));
1065 if (need_template ^ is_template)
1066 return false;
1067 else if (is_template)
1068 {
1069 /* If both are templates, check template parameter list. */
1070 tree friend_parms
1071 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend),
1072 args, tf_none);
1073 if (!comp_template_parms
1074 (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl)),
1075 friend_parms))
1076 return false;
1077
1078 decl_type = TREE_TYPE (DECL_TI_TEMPLATE (decl));
1079 }
1080 else
1081 decl_type = TREE_TYPE (decl);
1082
1083 friend_type = tsubst_function_type (TREE_TYPE (friend), args,
1084 tf_none, NULL_TREE);
1085 if (friend_type == error_mark_node)
1086 return false;
1087
1088 /* Check if return types match. */
1089 if (!same_type_p (TREE_TYPE (decl_type), TREE_TYPE (friend_type)))
1090 return false;
1091
1092 /* Check if function parameter types match, ignoring the
1093 `this' parameter. */
1094 friend_args_type = TYPE_ARG_TYPES (friend_type);
1095 decl_args_type = TYPE_ARG_TYPES (decl_type);
1096 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend))
1097 friend_args_type = TREE_CHAIN (friend_args_type);
1098 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1099 decl_args_type = TREE_CHAIN (decl_args_type);
1100
1101 return compparms (decl_args_type, friend_args_type);
1102 }
1103 else
1104 {
1105 /* DECL is a TYPE_DECL */
1106 bool is_template;
1107 tree decl_type = TREE_TYPE (decl);
1108
1109 /* Make sure that both DECL and FRIEND are templates or
1110 non-templates. */
1111 is_template
1112 = CLASSTYPE_TEMPLATE_INFO (decl_type)
1113 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type));
1114
1115 if (need_template ^ is_template)
1116 return false;
1117 else if (is_template)
1118 {
1119 tree friend_parms;
1120 /* If both are templates, check the name of the two
1121 TEMPLATE_DECL's first because is_friend didn't. */
1122 if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type))
1123 != DECL_NAME (friend))
1124 return false;
1125
1126 /* Now check template parameter list. */
1127 friend_parms
1128 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend),
1129 args, tf_none);
1130 return comp_template_parms
1131 (DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type)),
1132 friend_parms);
1133 }
1134 else
1135 return (DECL_NAME (decl)
1136 == DECL_NAME (friend));
1137 }
1138 }
1139 return false;
1140}
1141
1142/* Register the specialization SPEC as a specialization of TMPL with
1143 the indicated ARGS. IS_FRIEND indicates whether the specialization
1144 is actually just a friend declaration. Returns SPEC, or an
1145 equivalent prior declaration, if available. */
1146
1147static tree
1148register_specialization (tree spec, tree tmpl, tree args, bool is_friend)
1149{
1150 tree fn;
1151
1152 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
1153
1154 if (TREE_CODE (spec) == FUNCTION_DECL
1155 && uses_template_parms (DECL_TI_ARGS (spec)))
1156 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1157 register it; we want the corresponding TEMPLATE_DECL instead.
1158 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1159 the more obvious `uses_template_parms (spec)' to avoid problems
1160 with default function arguments. In particular, given
1161 something like this:
1162
1163 template <class T> void f(T t1, T t = T())
1164
1165 the default argument expression is not substituted for in an
1166 instantiation unless and until it is actually needed. */
1167 return spec;
1168
1169 fn = retrieve_specialization (tmpl, args,
1170 /*class_specializations_p=*/false);
1171 /* We can sometimes try to re-register a specialization that we've
1172 already got. In particular, regenerate_decl_from_template calls
1173 duplicate_decls which will update the specialization list. But,
1174 we'll still get called again here anyhow. It's more convenient
1175 to simply allow this than to try to prevent it. */
1176 if (fn == spec)
1177 return spec;
1178 else if (fn && DECL_TEMPLATE_SPECIALIZATION (spec))
1179 {
1180 if (DECL_TEMPLATE_INSTANTIATION (fn))
1181 {
1182 if (TREE_USED (fn)
1183 || DECL_EXPLICIT_INSTANTIATION (fn))
1184 {
1185 error ("specialization of %qD after instantiation",
1186 fn);
1187 return error_mark_node;
1188 }
1189 else
1190 {
1191 tree clone;
1192 /* This situation should occur only if the first
1193 specialization is an implicit instantiation, the
1194 second is an explicit specialization, and the
1195 implicit instantiation has not yet been used. That
1196 situation can occur if we have implicitly
1197 instantiated a member function and then specialized
1198 it later.
1199
1200 We can also wind up here if a friend declaration that
1201 looked like an instantiation turns out to be a
1202 specialization:
1203
1204 template <class T> void foo(T);
1205 class S { friend void foo<>(int) };
1206 template <> void foo(int);
1207
1208 We transform the existing DECL in place so that any
1209 pointers to it become pointers to the updated
1210 declaration.
1211
1212 If there was a definition for the template, but not
1213 for the specialization, we want this to look as if
1214 there were no definition, and vice versa. */
1215 DECL_INITIAL (fn) = NULL_TREE;
1216 duplicate_decls (spec, fn, is_friend);
1217 /* The call to duplicate_decls will have applied
1218 [temp.expl.spec]:
1219
1220 An explicit specialization of a function template
1221 is inline only if it is explicitly declared to be,
1222 and independently of whether its function template
1223 is.
1224
1225 to the primary function; now copy the inline bits to
1226 the various clones. */
1227 FOR_EACH_CLONE (clone, fn)
1228 {
1229 DECL_DECLARED_INLINE_P (clone)
1230 = DECL_DECLARED_INLINE_P (fn);
1231 DECL_INLINE (clone)
1232 = DECL_INLINE (fn);
1233 }
1234 check_specialization_namespace (fn);
1235
1236 return fn;
1237 }
1238 }
1239 else if (DECL_TEMPLATE_SPECIALIZATION (fn))
1240 {
1241 if (!duplicate_decls (spec, fn, is_friend) && DECL_INITIAL (spec))
1242 /* Dup decl failed, but this is a new definition. Set the
1243 line number so any errors match this new
1244 definition. */
1245 DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (spec);
1246
1247 return fn;
1248 }
1249 }
1250
1251 /* A specialization must be declared in the same namespace as the
1252 template it is specializing. */
1253 if (DECL_TEMPLATE_SPECIALIZATION (spec)
1254 && !check_specialization_namespace (tmpl))
1255 DECL_CONTEXT (spec) = FROB_CONTEXT (decl_namespace_context (tmpl));
1256
1257 if (!optimize_specialization_lookup_p (tmpl))
1258 DECL_TEMPLATE_SPECIALIZATIONS (tmpl)
1259 = tree_cons (args, spec, DECL_TEMPLATE_SPECIALIZATIONS (tmpl));
1260
1261 return spec;
1262}
1263
1264/* Unregister the specialization SPEC as a specialization of TMPL.
1265 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1266 if the SPEC was listed as a specialization of TMPL. */
1267
1268bool
1269reregister_specialization (tree spec, tree tmpl, tree new_spec)
1270{
1271 tree* s;
1272
1273 for (s = &DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
1274 *s != NULL_TREE;
1275 s = &TREE_CHAIN (*s))
1276 if (TREE_VALUE (*s) == spec)
1277 {
1278 if (!new_spec)
1279 *s = TREE_CHAIN (*s);
1280 else
1281 TREE_VALUE (*s) = new_spec;
1282 return 1;
1283 }
1284
1285 return 0;
1286}
1287
1288/* Compare an entry in the local specializations hash table P1 (which
1289 is really a pointer to a TREE_LIST) with P2 (which is really a
1290 DECL). */
1291
1292static int
1293eq_local_specializations (const void *p1, const void *p2)
1294{
1295 return TREE_VALUE ((tree) p1) == (tree) p2;
1296}
1297
1298/* Hash P1, an entry in the local specializations table. */
1299
1300static hashval_t
1301hash_local_specialization (const void* p1)
1302{
1303 return htab_hash_pointer (TREE_VALUE ((tree) p1));
1304}
1305
1306/* Like register_specialization, but for local declarations. We are
1307 registering SPEC, an instantiation of TMPL. */
1308
1309static void
1310register_local_specialization (tree spec, tree tmpl)
1311{
1312 void **slot;
1313
1314 slot = htab_find_slot_with_hash (local_specializations, tmpl,
1315 htab_hash_pointer (tmpl), INSERT);
1316 *slot = build_tree_list (spec, tmpl);
1317}
1318
1319/* TYPE is a class type. Returns true if TYPE is an explicitly
1320 specialized class. */
1321
1322bool
1323explicit_class_specialization_p (tree type)
1324{
1325 if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
1326 return false;
1327 return !uses_template_parms (CLASSTYPE_TI_ARGS (type));
1328}
1329
1330/* Print the list of candidate FNS in an error message. */
1331
1332void
1333print_candidates (tree fns)
1334{
1335 tree fn;
1336
1337 const char *str = "candidates are:";
1338
1339 for (fn = fns; fn != NULL_TREE; fn = TREE_CHAIN (fn))
1340 {
1341 tree f;
1342
1343 for (f = TREE_VALUE (fn); f; f = OVL_NEXT (f))
1344 error ("%s %+#D", str, OVL_CURRENT (f));
1345 str = " ";
1346 }
1347}
1348
1349/* Returns the template (one of the functions given by TEMPLATE_ID)
1350 which can be specialized to match the indicated DECL with the
1351 explicit template args given in TEMPLATE_ID. The DECL may be
1352 NULL_TREE if none is available. In that case, the functions in
1353 TEMPLATE_ID are non-members.
1354
1355 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1356 specialization of a member template.
1357
1358 The TEMPLATE_COUNT is the number of references to qualifying
1359 template classes that appeared in the name of the function. See
1360 check_explicit_specialization for a more accurate description.
1361
1362 TSK indicates what kind of template declaration (if any) is being
1363 declared. TSK_TEMPLATE indicates that the declaration given by
1364 DECL, though a FUNCTION_DECL, has template parameters, and is
1365 therefore a template function.
1366
1367 The template args (those explicitly specified and those deduced)
1368 are output in a newly created vector *TARGS_OUT.
1369
1370 If it is impossible to determine the result, an error message is
1371 issued. The error_mark_node is returned to indicate failure. */
1372
1373static tree
1374determine_specialization (tree template_id,
1375 tree decl,
1376 tree* targs_out,
1377 int need_member_template,
1378 int template_count,
1379 tmpl_spec_kind tsk)
1380{
1381 tree fns;
1382 tree targs;
1383 tree explicit_targs;
1384 tree candidates = NULL_TREE;
1385 /* A TREE_LIST of templates of which DECL may be a specialization.
1386 The TREE_VALUE of each node is a TEMPLATE_DECL. The
1387 corresponding TREE_PURPOSE is the set of template arguments that,
1388 when used to instantiate the template, would produce a function
1389 with the signature of DECL. */
1390 tree templates = NULL_TREE;
1391 int header_count;
1392 struct cp_binding_level *b;
1393
1394 *targs_out = NULL_TREE;
1395
1396 if (template_id == error_mark_node || decl == error_mark_node)
1397 return error_mark_node;
1398
1399 fns = TREE_OPERAND (template_id, 0);
1400 explicit_targs = TREE_OPERAND (template_id, 1);
1401
1402 if (fns == error_mark_node)
1403 return error_mark_node;
1404
1405 /* Check for baselinks. */
1406 if (BASELINK_P (fns))
1407 fns = BASELINK_FUNCTIONS (fns);
1408
1409 if (!is_overloaded_fn (fns))
1410 {
1411 error ("%qD is not a function template", fns);
1412 return error_mark_node;
1413 }
1414
1415 /* Count the number of template headers specified for this
1416 specialization. */
1417 header_count = 0;
1418 for (b = current_binding_level;
1419 b->kind == sk_template_parms;
1420 b = b->level_chain)
1421 ++header_count;
1422
1423 for (; fns; fns = OVL_NEXT (fns))
1424 {
1425 tree fn = OVL_CURRENT (fns);
1426
1427 if (TREE_CODE (fn) == TEMPLATE_DECL)
1428 {
1429 tree decl_arg_types;
1430 tree fn_arg_types;
1431
1432 /* In case of explicit specialization, we need to check if
1433 the number of template headers appearing in the specialization
1434 is correct. This is usually done in check_explicit_specialization,
1435 but the check done there cannot be exhaustive when specializing
1436 member functions. Consider the following code:
1437
1438 template <> void A<int>::f(int);
1439 template <> template <> void A<int>::f(int);
1440
1441 Assuming that A<int> is not itself an explicit specialization
1442 already, the first line specializes "f" which is a non-template
1443 member function, whilst the second line specializes "f" which
1444 is a template member function. So both lines are syntactically
1445 correct, and check_explicit_specialization does not reject
1446 them.
1447
1448 Here, we can do better, as we are matching the specialization
1449 against the declarations. We count the number of template
1450 headers, and we check if they match TEMPLATE_COUNT + 1
1451 (TEMPLATE_COUNT is the number of qualifying template classes,
1452 plus there must be another header for the member template
1453 itself).
1454
1455 Notice that if header_count is zero, this is not a
1456 specialization but rather a template instantiation, so there
1457 is no check we can perform here. */
1458 if (header_count && header_count != template_count + 1)
1459 continue;
1460
1461 /* Check that the number of template arguments at the
1462 innermost level for DECL is the same as for FN. */
1463 if (current_binding_level->kind == sk_template_parms
1464 && !current_binding_level->explicit_spec_p
1465 && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn))
1466 != TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
1467 (current_template_parms))))
1468 continue;
1469
1470 /* DECL might be a specialization of FN. */
1471 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
1472 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
1473
1474 /* For a non-static member function, we need to make sure
1475 that the const qualification is the same. Since
1476 get_bindings does not try to merge the "this" parameter,
1477 we must do the comparison explicitly. */
1478 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1479 && !same_type_p (TREE_VALUE (fn_arg_types),
1480 TREE_VALUE (decl_arg_types)))
1481 continue;
1482
1483 /* Skip the "this" parameter and, for constructors of
1484 classes with virtual bases, the VTT parameter. A
1485 full specialization of a constructor will have a VTT
1486 parameter, but a template never will. */
1487 decl_arg_types
1488 = skip_artificial_parms_for (decl, decl_arg_types);
1489 fn_arg_types
1490 = skip_artificial_parms_for (fn, fn_arg_types);
1491
1492 /* Check that the number of function parameters matches.
1493 For example,
1494 template <class T> void f(int i = 0);
1495 template <> void f<int>();
1496 The specialization f<int> is invalid but is not caught
1497 by get_bindings below. */
1498 if (list_length (fn_arg_types) != list_length (decl_arg_types))
1499 continue;
1500
1501 /* Function templates cannot be specializations; there are
1502 no partial specializations of functions. Therefore, if
1503 the type of DECL does not match FN, there is no
1504 match. */
1505 if (tsk == tsk_template)
1506 {
1507 if (compparms (fn_arg_types, decl_arg_types))
1508 candidates = tree_cons (NULL_TREE, fn, candidates);
1509 continue;
1510 }
1511
1512 /* See whether this function might be a specialization of this
1513 template. */
1514 targs = get_bindings (fn, decl, explicit_targs, /*check_ret=*/true);
1515
1516 if (!targs)
1517 /* We cannot deduce template arguments that when used to
1518 specialize TMPL will produce DECL. */
1519 continue;
1520
1521 /* Save this template, and the arguments deduced. */
1522 templates = tree_cons (targs, fn, templates);
1523 }
1524 else if (need_member_template)
1525 /* FN is an ordinary member function, and we need a
1526 specialization of a member template. */
1527 ;
1528 else if (TREE_CODE (fn) != FUNCTION_DECL)
1529 /* We can get IDENTIFIER_NODEs here in certain erroneous
1530 cases. */
1531 ;
1532 else if (!DECL_FUNCTION_MEMBER_P (fn))
1533 /* This is just an ordinary non-member function. Nothing can
1534 be a specialization of that. */
1535 ;
1536 else if (DECL_ARTIFICIAL (fn))
1537 /* Cannot specialize functions that are created implicitly. */
1538 ;
1539 else
1540 {
1541 tree decl_arg_types;
1542
1543 /* This is an ordinary member function. However, since
1544 we're here, we can assume it's enclosing class is a
1545 template class. For example,
1546
1547 template <typename T> struct S { void f(); };
1548 template <> void S<int>::f() {}
1549
1550 Here, S<int>::f is a non-template, but S<int> is a
1551 template class. If FN has the same type as DECL, we
1552 might be in business. */
1553
1554 if (!DECL_TEMPLATE_INFO (fn))
1555 /* Its enclosing class is an explicit specialization
1556 of a template class. This is not a candidate. */
1557 continue;
1558
1559 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
1560 TREE_TYPE (TREE_TYPE (fn))))
1561 /* The return types differ. */
1562 continue;
1563
1564 /* Adjust the type of DECL in case FN is a static member. */
1565 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
1566 if (DECL_STATIC_FUNCTION_P (fn)
1567 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1568 decl_arg_types = TREE_CHAIN (decl_arg_types);
1569
1570 if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1571 decl_arg_types))
1572 /* They match! */
1573 candidates = tree_cons (NULL_TREE, fn, candidates);
1574 }
1575 }
1576
1577 if (templates && TREE_CHAIN (templates))
1578 {
1579 /* We have:
1580
1581 [temp.expl.spec]
1582
1583 It is possible for a specialization with a given function
1584 signature to be instantiated from more than one function
1585 template. In such cases, explicit specification of the
1586 template arguments must be used to uniquely identify the
1587 function template specialization being specialized.
1588
1589 Note that here, there's no suggestion that we're supposed to
1590 determine which of the candidate templates is most
1591 specialized. However, we, also have:
1592
1593 [temp.func.order]
1594
1595 Partial ordering of overloaded function template
1596 declarations is used in the following contexts to select
1597 the function template to which a function template
1598 specialization refers:
1599
1600 -- when an explicit specialization refers to a function
1601 template.
1602
1603 So, we do use the partial ordering rules, at least for now.
1604 This extension can only serve to make invalid programs valid,
1605 so it's safe. And, there is strong anecdotal evidence that
1606 the committee intended the partial ordering rules to apply;
1607 the EDG front-end has that behavior, and John Spicer claims
1608 that the committee simply forgot to delete the wording in
1609 [temp.expl.spec]. */
1610 tree tmpl = most_specialized_instantiation (templates);
1611 if (tmpl != error_mark_node)
1612 {
1613 templates = tmpl;
1614 TREE_CHAIN (templates) = NULL_TREE;
1615 }
1616 }
1617
1618 if (templates == NULL_TREE && candidates == NULL_TREE)
1619 {
1620 error ("template-id %qD for %q+D does not match any template "
1621 "declaration", template_id, decl);
1622 return error_mark_node;
1623 }
1624 else if ((templates && TREE_CHAIN (templates))
1625 || (candidates && TREE_CHAIN (candidates))
1626 || (templates && candidates))
1627 {
1628 error ("ambiguous template specialization %qD for %q+D",
1629 template_id, decl);
1630 chainon (candidates, templates);
1631 print_candidates (candidates);
1632 return error_mark_node;
1633 }
1634
1635 /* We have one, and exactly one, match. */
1636 if (candidates)
1637 {
1638 tree fn = TREE_VALUE (candidates);
1639 /* DECL is a re-declaration of a template function. */
1640 if (TREE_CODE (fn) == TEMPLATE_DECL)
1641 return fn;
1642 /* It was a specialization of an ordinary member function in a
1643 template class. */
1644 *targs_out = copy_node (DECL_TI_ARGS (fn));
1645 return DECL_TI_TEMPLATE (fn);
1646 }
1647
1648 /* It was a specialization of a template. */
1649 targs = DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates)));
1650 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs))
1651 {
1652 *targs_out = copy_node (targs);
1653 SET_TMPL_ARGS_LEVEL (*targs_out,
1654 TMPL_ARGS_DEPTH (*targs_out),
1655 TREE_PURPOSE (templates));
1656 }
1657 else
1658 *targs_out = TREE_PURPOSE (templates);
1659 return TREE_VALUE (templates);
1660}
1661
1662/* Returns a chain of parameter types, exactly like the SPEC_TYPES,
1663 but with the default argument values filled in from those in the
1664 TMPL_TYPES. */
1665
1666static tree
1667copy_default_args_to_explicit_spec_1 (tree spec_types,
1668 tree tmpl_types)
1669{
1670 tree new_spec_types;
1671
1672 if (!spec_types)
1673 return NULL_TREE;
1674
1675 if (spec_types == void_list_node)
1676 return void_list_node;
1677
1678 /* Substitute into the rest of the list. */
1679 new_spec_types =
1680 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types),
1681 TREE_CHAIN (tmpl_types));
1682
1683 /* Add the default argument for this parameter. */
1684 return hash_tree_cons (TREE_PURPOSE (tmpl_types),
1685 TREE_VALUE (spec_types),
1686 new_spec_types);
1687}
1688
1689/* DECL is an explicit specialization. Replicate default arguments
1690 from the template it specializes. (That way, code like:
1691
1692 template <class T> void f(T = 3);
1693 template <> void f(double);
1694 void g () { f (); }
1695
1696 works, as required.) An alternative approach would be to look up
1697 the correct default arguments at the call-site, but this approach
1698 is consistent with how implicit instantiations are handled. */
1699
1700static void
1701copy_default_args_to_explicit_spec (tree decl)
1702{
1703 tree tmpl;
1704 tree spec_types;
1705 tree tmpl_types;
1706 tree new_spec_types;
1707 tree old_type;
1708 tree new_type;
1709 tree t;
1710 tree object_type = NULL_TREE;
1711 tree in_charge = NULL_TREE;
1712 tree vtt = NULL_TREE;
1713
1714 /* See if there's anything we need to do. */
1715 tmpl = DECL_TI_TEMPLATE (decl);
1716 tmpl_types = TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl)));
1717 for (t = tmpl_types; t; t = TREE_CHAIN (t))
1718 if (TREE_PURPOSE (t))
1719 break;
1720 if (!t)
1721 return;
1722
1723 old_type = TREE_TYPE (decl);
1724 spec_types = TYPE_ARG_TYPES (old_type);
1725
1726 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1727 {
1728 /* Remove the this pointer, but remember the object's type for
1729 CV quals. */
1730 object_type = TREE_TYPE (TREE_VALUE (spec_types));
1731 spec_types = TREE_CHAIN (spec_types);
1732 tmpl_types = TREE_CHAIN (tmpl_types);
1733
1734 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
1735 {
1736 /* DECL may contain more parameters than TMPL due to the extra
1737 in-charge parameter in constructors and destructors. */
1738 in_charge = spec_types;
1739 spec_types = TREE_CHAIN (spec_types);
1740 }
1741 if (DECL_HAS_VTT_PARM_P (decl))
1742 {
1743 vtt = spec_types;
1744 spec_types = TREE_CHAIN (spec_types);
1745 }
1746 }
1747
1748 /* Compute the merged default arguments. */
1749 new_spec_types =
1750 copy_default_args_to_explicit_spec_1 (spec_types, tmpl_types);
1751
1752 /* Compute the new FUNCTION_TYPE. */
1753 if (object_type)
1754 {
1755 if (vtt)
1756 new_spec_types = hash_tree_cons (TREE_PURPOSE (vtt),
1757 TREE_VALUE (vtt),
1758 new_spec_types);
1759
1760 if (in_charge)
1761 /* Put the in-charge parameter back. */
1762 new_spec_types = hash_tree_cons (TREE_PURPOSE (in_charge),
1763 TREE_VALUE (in_charge),
1764 new_spec_types);
1765
1766 new_type = build_method_type_directly (object_type,
1767 TREE_TYPE (old_type),
1768 new_spec_types);
1769 }
1770 else
1771 new_type = build_function_type (TREE_TYPE (old_type),
1772 new_spec_types);
1773 new_type = cp_build_type_attribute_variant (new_type,
1774 TYPE_ATTRIBUTES (old_type));
1775 new_type = build_exception_variant (new_type,
1776 TYPE_RAISES_EXCEPTIONS (old_type));
1777 TREE_TYPE (decl) = new_type;
1778}
1779
1780/* Check to see if the function just declared, as indicated in
1781 DECLARATOR, and in DECL, is a specialization of a function
1782 template. We may also discover that the declaration is an explicit
1783 instantiation at this point.
1784
1785 Returns DECL, or an equivalent declaration that should be used
1786 instead if all goes well. Issues an error message if something is
1787 amiss. Returns error_mark_node if the error is not easily
1788 recoverable.
1789
1790 FLAGS is a bitmask consisting of the following flags:
1791
1792 2: The function has a definition.
1793 4: The function is a friend.
1794
1795 The TEMPLATE_COUNT is the number of references to qualifying
1796 template classes that appeared in the name of the function. For
1797 example, in
1798
1799 template <class T> struct S { void f(); };
1800 void S<int>::f();
1801
1802 the TEMPLATE_COUNT would be 1. However, explicitly specialized
1803 classes are not counted in the TEMPLATE_COUNT, so that in
1804
1805 template <class T> struct S {};
1806 template <> struct S<int> { void f(); }
1807 template <> void S<int>::f();
1808
1809 the TEMPLATE_COUNT would be 0. (Note that this declaration is
1810 invalid; there should be no template <>.)
1811
1812 If the function is a specialization, it is marked as such via
1813 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
1814 is set up correctly, and it is added to the list of specializations
1815 for that template. */
1816
1817tree
1818check_explicit_specialization (tree declarator,
1819 tree decl,
1820 int template_count,
1821 int flags)
1822{
1823 int have_def = flags & 2;
1824 int is_friend = flags & 4;
1825 int specialization = 0;
1826 int explicit_instantiation = 0;
1827 int member_specialization = 0;
1828 tree ctype = DECL_CLASS_CONTEXT (decl);
1829 tree dname = DECL_NAME (decl);
1830 tmpl_spec_kind tsk;
1831
1832 if (is_friend)
1833 {
1834 if (!processing_specialization)
1835 tsk = tsk_none;
1836 else
1837 tsk = tsk_excessive_parms;
1838 }
1839 else
1840 tsk = current_tmpl_spec_kind (template_count);
1841
1842 switch (tsk)
1843 {
1844 case tsk_none:
1845 if (processing_specialization)
1846 {
1847 specialization = 1;
1848 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
1849 }
1850 else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
1851 {
1852 if (is_friend)
1853 /* This could be something like:
1854
1855 template <class T> void f(T);
1856 class S { friend void f<>(int); } */
1857 specialization = 1;
1858 else
1859 {
1860 /* This case handles bogus declarations like template <>
1861 template <class T> void f<int>(); */
1862
1863 error ("template-id %qD in declaration of primary template",
1864 declarator);
1865 return decl;
1866 }
1867 }
1868 break;
1869
1870 case tsk_invalid_member_spec:
1871 /* The error has already been reported in
1872 check_specialization_scope. */
1873 return error_mark_node;
1874
1875 case tsk_invalid_expl_inst:
1876 error ("template parameter list used in explicit instantiation");
1877
1878 /* Fall through. */
1879
1880 case tsk_expl_inst:
1881 if (have_def)
1882 error ("definition provided for explicit instantiation");
1883
1884 explicit_instantiation = 1;
1885 break;
1886
1887 case tsk_excessive_parms:
1888 case tsk_insufficient_parms:
1889 if (tsk == tsk_excessive_parms)
1890 error ("too many template parameter lists in declaration of %qD",
1891 decl);
1892 else if (template_header_count)
1893 error("too few template parameter lists in declaration of %qD", decl);
1894 else
1895 error("explicit specialization of %qD must be introduced by "
1896 "%<template <>%>", decl);
1897
1898 /* Fall through. */
1899 case tsk_expl_spec:
1900 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
1901 if (ctype)
1902 member_specialization = 1;
1903 else
1904 specialization = 1;
1905 break;
1906
1907 case tsk_template:
1908 if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
1909 {
1910 /* This case handles bogus declarations like template <>
1911 template <class T> void f<int>(); */
1912
1913 if (uses_template_parms (declarator))
1914 error ("function template partial specialization %qD "
1915 "is not allowed", declarator);
1916 else
1917 error ("template-id %qD in declaration of primary template",
1918 declarator);
1919 return decl;
1920 }
1921
1922 if (ctype && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype))
1923 /* This is a specialization of a member template, without
1924 specialization the containing class. Something like:
1925
1926 template <class T> struct S {
1927 template <class U> void f (U);
1928 };
1929 template <> template <class U> void S<int>::f(U) {}
1930
1931 That's a specialization -- but of the entire template. */
1932 specialization = 1;
1933 break;
1934
1935 default:
1936 gcc_unreachable ();
1937 }
1938
1939 if (specialization || member_specialization)
1940 {
1941 tree t = TYPE_ARG_TYPES (TREE_TYPE (decl));
1942 for (; t; t = TREE_CHAIN (t))
1943 if (TREE_PURPOSE (t))
1944 {
1945 pedwarn
1946 ("default argument specified in explicit specialization");
1947 break;
1948 }
1949 }
1950
1951 if (specialization || member_specialization || explicit_instantiation)
1952 {
1953 tree tmpl = NULL_TREE;
1954 tree targs = NULL_TREE;
1955
1956 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
1957 if (TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
1958 {
1959 tree fns;
1960
1961 gcc_assert (TREE_CODE (declarator) == IDENTIFIER_NODE);
1962 if (ctype)
1963 fns = dname;
1964 else
1965 {
1966 /* If there is no class context, the explicit instantiation
1967 must be at namespace scope. */
1968 gcc_assert (DECL_NAMESPACE_SCOPE_P (decl));
1969
1970 /* Find the namespace binding, using the declaration
1971 context. */
1972 fns = lookup_qualified_name (CP_DECL_CONTEXT (decl), dname,
1973 false, true);
|
1974 if (!fns || !is_overloaded_fn (fns))
| 1974 if (fns == error_mark_node || !is_overloaded_fn (fns))
|
1975 {
1976 error ("%qD is not a template function", dname);
1977 fns = error_mark_node;
1978 }
1979 else
1980 {
1981 tree fn = OVL_CURRENT (fns);
1982 if (!is_associated_namespace (CP_DECL_CONTEXT (decl),
1983 CP_DECL_CONTEXT (fn)))
1984 error ("%qD is not declared in %qD",
1985 decl, current_namespace);
1986 }
1987 }
1988
1989 declarator = lookup_template_function (fns, NULL_TREE);
1990 }
1991
1992 if (declarator == error_mark_node)
1993 return error_mark_node;
1994
1995 if (ctype != NULL_TREE && TYPE_BEING_DEFINED (ctype))
1996 {
1997 if (!explicit_instantiation)
1998 /* A specialization in class scope. This is invalid,
1999 but the error will already have been flagged by
2000 check_specialization_scope. */
2001 return error_mark_node;
2002 else
2003 {
2004 /* It's not valid to write an explicit instantiation in
2005 class scope, e.g.:
2006
2007 class C { template void f(); }
2008
2009 This case is caught by the parser. However, on
2010 something like:
2011
2012 template class C { void f(); };
2013
2014 (which is invalid) we can get here. The error will be
2015 issued later. */
2016 ;
2017 }
2018
2019 return decl;
2020 }
2021 else if (ctype != NULL_TREE
2022 && (TREE_CODE (TREE_OPERAND (declarator, 0)) ==
2023 IDENTIFIER_NODE))
2024 {
2025 /* Find the list of functions in ctype that have the same
2026 name as the declared function. */
2027 tree name = TREE_OPERAND (declarator, 0);
2028 tree fns = NULL_TREE;
2029 int idx;
2030
2031 if (constructor_name_p (name, ctype))
2032 {
2033 int is_constructor = DECL_CONSTRUCTOR_P (decl);
2034
2035 if (is_constructor ? !TYPE_HAS_CONSTRUCTOR (ctype)
2036 : !CLASSTYPE_DESTRUCTORS (ctype))
2037 {
2038 /* From [temp.expl.spec]:
2039
2040 If such an explicit specialization for the member
2041 of a class template names an implicitly-declared
2042 special member function (clause _special_), the
2043 program is ill-formed.
2044
2045 Similar language is found in [temp.explicit]. */
2046 error ("specialization of implicitly-declared special member function");
2047 return error_mark_node;
2048 }
2049
2050 name = is_constructor ? ctor_identifier : dtor_identifier;
2051 }
2052
2053 if (!DECL_CONV_FN_P (decl))
2054 {
2055 idx = lookup_fnfields_1 (ctype, name);
2056 if (idx >= 0)
2057 fns = VEC_index (tree, CLASSTYPE_METHOD_VEC (ctype), idx);
2058 }
2059 else
2060 {
2061 VEC(tree,gc) *methods;
2062 tree ovl;
2063
2064 /* For a type-conversion operator, we cannot do a
2065 name-based lookup. We might be looking for `operator
2066 int' which will be a specialization of `operator T'.
2067 So, we find *all* the conversion operators, and then
2068 select from them. */
2069 fns = NULL_TREE;
2070
2071 methods = CLASSTYPE_METHOD_VEC (ctype);
2072 if (methods)
2073 for (idx = CLASSTYPE_FIRST_CONVERSION_SLOT;
2074 VEC_iterate (tree, methods, idx, ovl);
2075 ++idx)
2076 {
2077 if (!DECL_CONV_FN_P (OVL_CURRENT (ovl)))
2078 /* There are no more conversion functions. */
2079 break;
2080
2081 /* Glue all these conversion functions together
2082 with those we already have. */
2083 for (; ovl; ovl = OVL_NEXT (ovl))
2084 fns = ovl_cons (OVL_CURRENT (ovl), fns);
2085 }
2086 }
2087
2088 if (fns == NULL_TREE)
2089 {
2090 error ("no member function %qD declared in %qT", name, ctype);
2091 return error_mark_node;
2092 }
2093 else
2094 TREE_OPERAND (declarator, 0) = fns;
2095 }
2096
2097 /* Figure out what exactly is being specialized at this point.
2098 Note that for an explicit instantiation, even one for a
2099 member function, we cannot tell apriori whether the
2100 instantiation is for a member template, or just a member
2101 function of a template class. Even if a member template is
2102 being instantiated, the member template arguments may be
2103 elided if they can be deduced from the rest of the
2104 declaration. */
2105 tmpl = determine_specialization (declarator, decl,
2106 &targs,
2107 member_specialization,
2108 template_count,
2109 tsk);
2110
2111 if (!tmpl || tmpl == error_mark_node)
2112 /* We couldn't figure out what this declaration was
2113 specializing. */
2114 return error_mark_node;
2115 else
2116 {
2117 tree gen_tmpl = most_general_template (tmpl);
2118
2119 if (explicit_instantiation)
2120 {
2121 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2122 is done by do_decl_instantiation later. */
2123
2124 int arg_depth = TMPL_ARGS_DEPTH (targs);
2125 int parm_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
2126
2127 if (arg_depth > parm_depth)
2128 {
2129 /* If TMPL is not the most general template (for
2130 example, if TMPL is a friend template that is
2131 injected into namespace scope), then there will
2132 be too many levels of TARGS. Remove some of them
2133 here. */
2134 int i;
2135 tree new_targs;
2136
2137 new_targs = make_tree_vec (parm_depth);
2138 for (i = arg_depth - parm_depth; i < arg_depth; ++i)
2139 TREE_VEC_ELT (new_targs, i - (arg_depth - parm_depth))
2140 = TREE_VEC_ELT (targs, i);
2141 targs = new_targs;
2142 }
2143
2144 return instantiate_template (tmpl, targs, tf_error);
2145 }
2146
2147 /* If we thought that the DECL was a member function, but it
2148 turns out to be specializing a static member function,
2149 make DECL a static member function as well. */
2150 if (DECL_STATIC_FUNCTION_P (tmpl)
2151 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
2152 revert_static_member_fn (decl);
2153
2154 /* If this is a specialization of a member template of a
2155 template class, we want to return the TEMPLATE_DECL, not
2156 the specialization of it. */
2157 if (tsk == tsk_template)
2158 {
2159 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
2160 DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl)) = NULL_TREE;
2161 if (have_def)
2162 {
2163 DECL_SOURCE_LOCATION (tmpl) = DECL_SOURCE_LOCATION (decl);
2164 DECL_SOURCE_LOCATION (DECL_TEMPLATE_RESULT (tmpl))
2165 = DECL_SOURCE_LOCATION (decl);
2166 /* We want to use the argument list specified in the
2167 definition, not in the original declaration. */
2168 DECL_ARGUMENTS (DECL_TEMPLATE_RESULT (tmpl))
2169 = DECL_ARGUMENTS (decl);
2170 }
2171 return tmpl;
2172 }
2173
2174 /* Set up the DECL_TEMPLATE_INFO for DECL. */
2175 DECL_TEMPLATE_INFO (decl) = tree_cons (tmpl, targs, NULL_TREE);
2176
2177 /* Inherit default function arguments from the template
2178 DECL is specializing. */
2179 copy_default_args_to_explicit_spec (decl);
2180
2181 /* This specialization has the same protection as the
2182 template it specializes. */
2183 TREE_PRIVATE (decl) = TREE_PRIVATE (gen_tmpl);
2184 TREE_PROTECTED (decl) = TREE_PROTECTED (gen_tmpl);
2185
2186 /* If DECL is a friend declaration, declared using an
2187 unqualified name, the namespace associated with DECL may
2188 have been set incorrectly. For example, in:
2189
2190 template <typename T> void f(T);
2191 namespace N {
2192 struct S { friend void f<int>(int); }
2193 }
2194
2195 we will have set the DECL_CONTEXT for the friend
2196 declaration to N, rather than to the global namespace. */
2197 if (DECL_NAMESPACE_SCOPE_P (decl))
2198 DECL_CONTEXT (decl) = DECL_CONTEXT (tmpl);
2199
2200 if (is_friend && !have_def)
2201 /* This is not really a declaration of a specialization.
2202 It's just the name of an instantiation. But, it's not
2203 a request for an instantiation, either. */
2204 SET_DECL_IMPLICIT_INSTANTIATION (decl);
2205 else if (DECL_CONSTRUCTOR_P (decl) || DECL_DESTRUCTOR_P (decl))
2206 /* This is indeed a specialization. In case of constructors
2207 and destructors, we need in-charge and not-in-charge
2208 versions in V3 ABI. */
2209 clone_function_decl (decl, /*update_method_vec_p=*/0);
2210
2211 /* Register this specialization so that we can find it
2212 again. */
2213 decl = register_specialization (decl, gen_tmpl, targs, is_friend);
2214 }
2215 }
2216
2217 return decl;
2218}
2219
2220/* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2221 parameters. These are represented in the same format used for
2222 DECL_TEMPLATE_PARMS. */
2223
2224int
2225comp_template_parms (tree parms1, tree parms2)
2226{
2227 tree p1;
2228 tree p2;
2229
2230 if (parms1 == parms2)
2231 return 1;
2232
2233 for (p1 = parms1, p2 = parms2;
2234 p1 != NULL_TREE && p2 != NULL_TREE;
2235 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2))
2236 {
2237 tree t1 = TREE_VALUE (p1);
2238 tree t2 = TREE_VALUE (p2);
2239 int i;
2240
2241 gcc_assert (TREE_CODE (t1) == TREE_VEC);
2242 gcc_assert (TREE_CODE (t2) == TREE_VEC);
2243
2244 if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2))
2245 return 0;
2246
2247 for (i = 0; i < TREE_VEC_LENGTH (t2); ++i)
2248 {
2249 tree parm1 = TREE_VALUE (TREE_VEC_ELT (t1, i));
2250 tree parm2 = TREE_VALUE (TREE_VEC_ELT (t2, i));
2251
2252 /* If either of the template parameters are invalid, assume
2253 they match for the sake of error recovery. */
2254 if (parm1 == error_mark_node || parm2 == error_mark_node)
2255 return 1;
2256
2257 if (TREE_CODE (parm1) != TREE_CODE (parm2))
2258 return 0;
2259
2260 if (TREE_CODE (parm1) == TEMPLATE_TYPE_PARM)
2261 continue;
2262 else if (!same_type_p (TREE_TYPE (parm1), TREE_TYPE (parm2)))
2263 return 0;
2264 }
2265 }
2266
2267 if ((p1 != NULL_TREE) != (p2 != NULL_TREE))
2268 /* One set of parameters has more parameters lists than the
2269 other. */
2270 return 0;
2271
2272 return 1;
2273}
2274
2275/* Complain if DECL shadows a template parameter.
2276
2277 [temp.local]: A template-parameter shall not be redeclared within its
2278 scope (including nested scopes). */
2279
2280void
2281check_template_shadow (tree decl)
2282{
2283 tree olddecl;
2284
2285 /* If we're not in a template, we can't possibly shadow a template
2286 parameter. */
2287 if (!current_template_parms)
2288 return;
2289
2290 /* Figure out what we're shadowing. */
2291 if (TREE_CODE (decl) == OVERLOAD)
2292 decl = OVL_CURRENT (decl);
2293 olddecl = innermost_non_namespace_value (DECL_NAME (decl));
2294
2295 /* If there's no previous binding for this name, we're not shadowing
2296 anything, let alone a template parameter. */
2297 if (!olddecl)
2298 return;
2299
2300 /* If we're not shadowing a template parameter, we're done. Note
2301 that OLDDECL might be an OVERLOAD (or perhaps even an
2302 ERROR_MARK), so we can't just blithely assume it to be a _DECL
2303 node. */
2304 if (!DECL_P (olddecl) || !DECL_TEMPLATE_PARM_P (olddecl))
2305 return;
2306
2307 /* We check for decl != olddecl to avoid bogus errors for using a
2308 name inside a class. We check TPFI to avoid duplicate errors for
2309 inline member templates. */
2310 if (decl == olddecl
2311 || TEMPLATE_PARMS_FOR_INLINE (current_template_parms))
2312 return;
2313
2314 error ("declaration of %q+#D", decl);
2315 error (" shadows template parm %q+#D", olddecl);
2316}
2317
2318/* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
2319 ORIG_LEVEL, DECL, and TYPE. */
2320
2321static tree
2322build_template_parm_index (int index,
2323 int level,
2324 int orig_level,
2325 tree decl,
2326 tree type)
2327{
2328 tree t = make_node (TEMPLATE_PARM_INDEX);
2329 TEMPLATE_PARM_IDX (t) = index;
2330 TEMPLATE_PARM_LEVEL (t) = level;
2331 TEMPLATE_PARM_ORIG_LEVEL (t) = orig_level;
2332 TEMPLATE_PARM_DECL (t) = decl;
2333 TREE_TYPE (t) = type;
2334 TREE_CONSTANT (t) = TREE_CONSTANT (decl);
2335 TREE_INVARIANT (t) = TREE_INVARIANT (decl);
2336 TREE_READONLY (t) = TREE_READONLY (decl);
2337
2338 return t;
2339}
2340
2341/* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
2342 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
2343 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
2344 new one is created. */
2345
2346static tree
2347reduce_template_parm_level (tree index, tree type, int levels)
2348{
2349 if (TEMPLATE_PARM_DESCENDANTS (index) == NULL_TREE
2350 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index))
2351 != TEMPLATE_PARM_LEVEL (index) - levels))
2352 {
2353 tree orig_decl = TEMPLATE_PARM_DECL (index);
2354 tree decl, t;
2355
2356 decl = build_decl (TREE_CODE (orig_decl), DECL_NAME (orig_decl), type);
2357 TREE_CONSTANT (decl) = TREE_CONSTANT (orig_decl);
2358 TREE_INVARIANT (decl) = TREE_INVARIANT (orig_decl);
2359 TREE_READONLY (decl) = TREE_READONLY (orig_decl);
2360 DECL_ARTIFICIAL (decl) = 1;
2361 SET_DECL_TEMPLATE_PARM_P (decl);
2362
2363 t = build_template_parm_index (TEMPLATE_PARM_IDX (index),
2364 TEMPLATE_PARM_LEVEL (index) - levels,
2365 TEMPLATE_PARM_ORIG_LEVEL (index),
2366 decl, type);
2367 TEMPLATE_PARM_DESCENDANTS (index) = t;
2368
2369 /* Template template parameters need this. */
2370 if (TREE_CODE (decl) != CONST_DECL)
2371 DECL_TEMPLATE_PARMS (decl)
2372 = DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index));
2373 }
2374
2375 return TEMPLATE_PARM_DESCENDANTS (index);
2376}
2377
2378/* Process information from new template parameter PARM and append it to the
2379 LIST being built. This new parameter is a non-type parameter iff
2380 IS_NON_TYPE is true. */
2381
2382tree
2383process_template_parm (tree list, tree parm, bool is_non_type)
2384{
2385 tree decl = 0;
2386 tree defval;
2387 tree err_parm_list;
2388 int idx = 0;
2389
2390 gcc_assert (TREE_CODE (parm) == TREE_LIST);
2391 defval = TREE_PURPOSE (parm);
2392
2393 if (list)
2394 {
2395 tree p = tree_last (list);
2396
2397 if (p && TREE_VALUE (p) != error_mark_node)
2398 {
2399 p = TREE_VALUE (p);
2400 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
2401 idx = TEMPLATE_TYPE_IDX (TREE_TYPE (p));
2402 else
2403 idx = TEMPLATE_PARM_IDX (DECL_INITIAL (p));
2404 }
2405
2406 ++idx;
2407 }
2408 else
2409 idx = 0;
2410
2411 if (is_non_type)
2412 {
2413 parm = TREE_VALUE (parm);
2414
2415 SET_DECL_TEMPLATE_PARM_P (parm);
2416
2417 if (TREE_TYPE (parm) == error_mark_node)
2418 {
2419 err_parm_list = build_tree_list (defval, parm);
2420 TREE_VALUE (err_parm_list) = error_mark_node;
2421 return chainon (list, err_parm_list);
2422 }
2423 else
2424 {
2425 /* [temp.param]
2426
2427 The top-level cv-qualifiers on the template-parameter are
2428 ignored when determining its type. */
2429 TREE_TYPE (parm) = TYPE_MAIN_VARIANT (TREE_TYPE (parm));
2430 if (invalid_nontype_parm_type_p (TREE_TYPE (parm), 1))
2431 {
2432 err_parm_list = build_tree_list (defval, parm);
2433 TREE_VALUE (err_parm_list) = error_mark_node;
2434 return chainon (list, err_parm_list);
2435 }
2436 }
2437
2438 /* A template parameter is not modifiable. */
2439 TREE_CONSTANT (parm) = 1;
2440 TREE_INVARIANT (parm) = 1;
2441 TREE_READONLY (parm) = 1;
2442 decl = build_decl (CONST_DECL, DECL_NAME (parm), TREE_TYPE (parm));
2443 TREE_CONSTANT (decl) = 1;
2444 TREE_INVARIANT (decl) = 1;
2445 TREE_READONLY (decl) = 1;
2446 DECL_INITIAL (parm) = DECL_INITIAL (decl)
2447 = build_template_parm_index (idx, processing_template_decl,
2448 processing_template_decl,
2449 decl, TREE_TYPE (parm));
2450 }
2451 else
2452 {
2453 tree t;
2454 parm = TREE_VALUE (TREE_VALUE (parm));
2455
2456 if (parm && TREE_CODE (parm) == TEMPLATE_DECL)
2457 {
2458 t = make_aggr_type (TEMPLATE_TEMPLATE_PARM);
2459 /* This is for distinguishing between real templates and template
2460 template parameters */
2461 TREE_TYPE (parm) = t;
2462 TREE_TYPE (DECL_TEMPLATE_RESULT (parm)) = t;
2463 decl = parm;
2464 }
2465 else
2466 {
2467 t = make_aggr_type (TEMPLATE_TYPE_PARM);
2468 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
2469 decl = build_decl (TYPE_DECL, parm, t);
2470 }
2471
2472 TYPE_NAME (t) = decl;
2473 TYPE_STUB_DECL (t) = decl;
2474 parm = decl;
2475 TEMPLATE_TYPE_PARM_INDEX (t)
2476 = build_template_parm_index (idx, processing_template_decl,
2477 processing_template_decl,
2478 decl, TREE_TYPE (parm));
2479 }
2480 DECL_ARTIFICIAL (decl) = 1;
2481 SET_DECL_TEMPLATE_PARM_P (decl);
2482 pushdecl (decl);
2483 parm = build_tree_list (defval, parm);
2484 return chainon (list, parm);
2485}
2486
2487/* The end of a template parameter list has been reached. Process the
2488 tree list into a parameter vector, converting each parameter into a more
2489 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
2490 as PARM_DECLs. */
2491
2492tree
2493end_template_parm_list (tree parms)
2494{
2495 int nparms;
2496 tree parm, next;
2497 tree saved_parmlist = make_tree_vec (list_length (parms));
2498
2499 current_template_parms
2500 = tree_cons (size_int (processing_template_decl),
2501 saved_parmlist, current_template_parms);
2502
2503 for (parm = parms, nparms = 0; parm; parm = next, nparms++)
2504 {
2505 next = TREE_CHAIN (parm);
2506 TREE_VEC_ELT (saved_parmlist, nparms) = parm;
2507 TREE_CHAIN (parm) = NULL_TREE;
2508 }
2509
2510 --processing_template_parmlist;
2511
2512 return saved_parmlist;
2513}
2514
2515/* end_template_decl is called after a template declaration is seen. */
2516
2517void
2518end_template_decl (void)
2519{
2520 reset_specialization ();
2521
2522 if (! processing_template_decl)
2523 return;
2524
2525 /* This matches the pushlevel in begin_template_parm_list. */
2526 finish_scope ();
2527
2528 --processing_template_decl;
2529 current_template_parms = TREE_CHAIN (current_template_parms);
2530}
2531
2532/* Given a template argument vector containing the template PARMS.
2533 The innermost PARMS are given first. */
2534
2535static tree
2536current_template_args (void)
2537{
2538 tree header;
2539 tree args = NULL_TREE;
2540 int length = TMPL_PARMS_DEPTH (current_template_parms);
2541 int l = length;
2542
2543 /* If there is only one level of template parameters, we do not
2544 create a TREE_VEC of TREE_VECs. Instead, we return a single
2545 TREE_VEC containing the arguments. */
2546 if (length > 1)
2547 args = make_tree_vec (length);
2548
2549 for (header = current_template_parms; header; header = TREE_CHAIN (header))
2550 {
2551 tree a = copy_node (TREE_VALUE (header));
2552 int i;
2553
2554 TREE_TYPE (a) = NULL_TREE;
2555 for (i = TREE_VEC_LENGTH (a) - 1; i >= 0; --i)
2556 {
2557 tree t = TREE_VEC_ELT (a, i);
2558
2559 /* T will be a list if we are called from within a
2560 begin/end_template_parm_list pair, but a vector directly
2561 if within a begin/end_member_template_processing pair. */
2562 if (TREE_CODE (t) == TREE_LIST)
2563 {
2564 t = TREE_VALUE (t);
2565
2566 if (t != error_mark_node)
2567 {
2568 if (TREE_CODE (t) == TYPE_DECL
2569 || TREE_CODE (t) == TEMPLATE_DECL)
2570 t = TREE_TYPE (t);
2571 else
2572 t = DECL_INITIAL (t);
2573 }
2574
2575 TREE_VEC_ELT (a, i) = t;
2576 }
2577 }
2578
2579 if (length > 1)
2580 TREE_VEC_ELT (args, --l) = a;
2581 else
2582 args = a;
2583 }
2584
2585 return args;
2586}
2587
2588/* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
2589 template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
2590 a member template. Used by push_template_decl below. */
2591
2592static tree
2593build_template_decl (tree decl, tree parms, bool member_template_p)
2594{
2595 tree tmpl = build_lang_decl (TEMPLATE_DECL, DECL_NAME (decl), NULL_TREE);
2596 DECL_TEMPLATE_PARMS (tmpl) = parms;
2597 DECL_CONTEXT (tmpl) = DECL_CONTEXT (decl);
2598 DECL_MEMBER_TEMPLATE_P (tmpl) = member_template_p;
2599 if (DECL_LANG_SPECIFIC (decl))
2600 {
2601 DECL_STATIC_FUNCTION_P (tmpl) = DECL_STATIC_FUNCTION_P (decl);
2602 DECL_CONSTRUCTOR_P (tmpl) = DECL_CONSTRUCTOR_P (decl);
2603 DECL_DESTRUCTOR_P (tmpl) = DECL_DESTRUCTOR_P (decl);
2604 DECL_NONCONVERTING_P (tmpl) = DECL_NONCONVERTING_P (decl);
2605 DECL_ASSIGNMENT_OPERATOR_P (tmpl) = DECL_ASSIGNMENT_OPERATOR_P (decl);
2606 if (DECL_OVERLOADED_OPERATOR_P (decl))
2607 SET_OVERLOADED_OPERATOR_CODE (tmpl,
2608 DECL_OVERLOADED_OPERATOR_P (decl));
2609 }
2610
2611 return tmpl;
2612}
2613
2614struct template_parm_data
2615{
2616 /* The level of the template parameters we are currently
2617 processing. */
2618 int level;
2619
2620 /* The index of the specialization argument we are currently
2621 processing. */
2622 int current_arg;
2623
2624 /* An array whose size is the number of template parameters. The
2625 elements are nonzero if the parameter has been used in any one
2626 of the arguments processed so far. */
2627 int* parms;
2628
2629 /* An array whose size is the number of template arguments. The
2630 elements are nonzero if the argument makes use of template
2631 parameters of this level. */
2632 int* arg_uses_template_parms;
2633};
2634
2635/* Subroutine of push_template_decl used to see if each template
2636 parameter in a partial specialization is used in the explicit
2637 argument list. If T is of the LEVEL given in DATA (which is
2638 treated as a template_parm_data*), then DATA->PARMS is marked
2639 appropriately. */
2640
2641static int
2642mark_template_parm (tree t, void* data)
2643{
2644 int level;
2645 int idx;
2646 struct template_parm_data* tpd = (struct template_parm_data*) data;
2647
2648 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
2649 {
2650 level = TEMPLATE_PARM_LEVEL (t);
2651 idx = TEMPLATE_PARM_IDX (t);
2652 }
2653 else
2654 {
2655 level = TEMPLATE_TYPE_LEVEL (t);
2656 idx = TEMPLATE_TYPE_IDX (t);
2657 }
2658
2659 if (level == tpd->level)
2660 {
2661 tpd->parms[idx] = 1;
2662 tpd->arg_uses_template_parms[tpd->current_arg] = 1;
2663 }
2664
2665 /* Return zero so that for_each_template_parm will continue the
2666 traversal of the tree; we want to mark *every* template parm. */
2667 return 0;
2668}
2669
2670/* Process the partial specialization DECL. */
2671
2672static tree
2673process_partial_specialization (tree decl)
2674{
2675 tree type = TREE_TYPE (decl);
2676 tree maintmpl = CLASSTYPE_TI_TEMPLATE (type);
2677 tree specargs = CLASSTYPE_TI_ARGS (type);
2678 tree inner_args = INNERMOST_TEMPLATE_ARGS (specargs);
2679 tree inner_parms = INNERMOST_TEMPLATE_PARMS (current_template_parms);
2680 tree main_inner_parms = DECL_INNERMOST_TEMPLATE_PARMS (maintmpl);
2681 int nargs = TREE_VEC_LENGTH (inner_args);
2682 int ntparms = TREE_VEC_LENGTH (inner_parms);
2683 int i;
2684 int did_error_intro = 0;
2685 struct template_parm_data tpd;
2686 struct template_parm_data tpd2;
2687
2688 /* We check that each of the template parameters given in the
2689 partial specialization is used in the argument list to the
2690 specialization. For example:
2691
2692 template <class T> struct S;
2693 template <class T> struct S<T*>;
2694
2695 The second declaration is OK because `T*' uses the template
2696 parameter T, whereas
2697
2698 template <class T> struct S<int>;
2699
2700 is no good. Even trickier is:
2701
2702 template <class T>
2703 struct S1
2704 {
2705 template <class U>
2706 struct S2;
2707 template <class U>
2708 struct S2<T>;
2709 };
2710
2711 The S2<T> declaration is actually invalid; it is a
2712 full-specialization. Of course,
2713
2714 template <class U>
2715 struct S2<T (*)(U)>;
2716
2717 or some such would have been OK. */
2718 tpd.level = TMPL_PARMS_DEPTH (current_template_parms);
2719 tpd.parms = (int *) alloca (sizeof (int) * ntparms);
2720 memset (tpd.parms, 0, sizeof (int) * ntparms);
2721
2722 tpd.arg_uses_template_parms = (int *) alloca (sizeof (int) * nargs);
2723 memset (tpd.arg_uses_template_parms, 0, sizeof (int) * nargs);
2724 for (i = 0; i < nargs; ++i)
2725 {
2726 tpd.current_arg = i;
2727 for_each_template_parm (TREE_VEC_ELT (inner_args, i),
2728 &mark_template_parm,
2729 &tpd,
2730 NULL);
2731 }
2732 for (i = 0; i < ntparms; ++i)
2733 if (tpd.parms[i] == 0)
2734 {
2735 /* One of the template parms was not used in the
2736 specialization. */
2737 if (!did_error_intro)
2738 {
2739 error ("template parameters not used in partial specialization:");
2740 did_error_intro = 1;
2741 }
2742
2743 error (" %qD", TREE_VALUE (TREE_VEC_ELT (inner_parms, i)));
2744 }
2745
2746 /* [temp.class.spec]
2747
2748 The argument list of the specialization shall not be identical to
2749 the implicit argument list of the primary template. */
2750 if (comp_template_args
2751 (inner_args,
2752 INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE
2753 (maintmpl)))))
2754 error ("partial specialization %qT does not specialize any template arguments", type);
2755
2756 /* [temp.class.spec]
2757
2758 A partially specialized non-type argument expression shall not
2759 involve template parameters of the partial specialization except
2760 when the argument expression is a simple identifier.
2761
2762 The type of a template parameter corresponding to a specialized
2763 non-type argument shall not be dependent on a parameter of the
2764 specialization. */
2765 gcc_assert (nargs == DECL_NTPARMS (maintmpl));
2766 tpd2.parms = 0;
2767 for (i = 0; i < nargs; ++i)
2768 {
2769 tree arg = TREE_VEC_ELT (inner_args, i);
2770 if (/* These first two lines are the `non-type' bit. */
2771 !TYPE_P (arg)
2772 && TREE_CODE (arg) != TEMPLATE_DECL
2773 /* This next line is the `argument expression is not just a
2774 simple identifier' condition and also the `specialized
2775 non-type argument' bit. */
2776 && TREE_CODE (arg) != TEMPLATE_PARM_INDEX)
2777 {
2778 if (tpd.arg_uses_template_parms[i])
2779 error ("template argument %qE involves template parameter(s)", arg);
2780 else
2781 {
2782 /* Look at the corresponding template parameter,
2783 marking which template parameters its type depends
2784 upon. */
2785 tree type =
2786 TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (main_inner_parms,
2787 i)));
2788
2789 if (!tpd2.parms)
2790 {
2791 /* We haven't yet initialized TPD2. Do so now. */
2792 tpd2.arg_uses_template_parms
2793 = (int *) alloca (sizeof (int) * nargs);
2794 /* The number of parameters here is the number in the
2795 main template, which, as checked in the assertion
2796 above, is NARGS. */
2797 tpd2.parms = (int *) alloca (sizeof (int) * nargs);
2798 tpd2.level =
2799 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl));
2800 }
2801
2802 /* Mark the template parameters. But this time, we're
2803 looking for the template parameters of the main
2804 template, not in the specialization. */
2805 tpd2.current_arg = i;
2806 tpd2.arg_uses_template_parms[i] = 0;
2807 memset (tpd2.parms, 0, sizeof (int) * nargs);
2808 for_each_template_parm (type,
2809 &mark_template_parm,
2810 &tpd2,
2811 NULL);
2812
2813 if (tpd2.arg_uses_template_parms [i])
2814 {
2815 /* The type depended on some template parameters.
2816 If they are fully specialized in the
2817 specialization, that's OK. */
2818 int j;
2819 for (j = 0; j < nargs; ++j)
2820 if (tpd2.parms[j] != 0
2821 && tpd.arg_uses_template_parms [j])
2822 {
2823 error ("type %qT of template argument %qE depends "
2824 "on template parameter(s)",
2825 type,
2826 arg);
2827 break;
2828 }
2829 }
2830 }
2831 }
2832 }
2833
2834 if (retrieve_specialization (maintmpl, specargs,
2835 /*class_specializations_p=*/true))
2836 /* We've already got this specialization. */
2837 return decl;
2838
2839 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)
2840 = tree_cons (specargs, inner_parms,
2841 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl));
2842 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)) = type;
2843 return decl;
2844}
2845
2846/* Check that a template declaration's use of default arguments is not
2847 invalid. Here, PARMS are the template parameters. IS_PRIMARY is
2848 nonzero if DECL is the thing declared by a primary template.
2849 IS_PARTIAL is nonzero if DECL is a partial specialization. */
2850
2851static void
2852check_default_tmpl_args (tree decl, tree parms, int is_primary, int is_partial)
2853{
2854 const char *msg;
2855 int last_level_to_check;
2856 tree parm_level;
2857
2858 /* [temp.param]
2859
2860 A default template-argument shall not be specified in a
2861 function template declaration or a function template definition, nor
2862 in the template-parameter-list of the definition of a member of a
2863 class template. */
2864
2865 if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
2866 /* You can't have a function template declaration in a local
2867 scope, nor you can you define a member of a class template in a
2868 local scope. */
2869 return;
2870
2871 if (current_class_type
2872 && !TYPE_BEING_DEFINED (current_class_type)
2873 && DECL_LANG_SPECIFIC (decl)
2874 /* If this is either a friend defined in the scope of the class
2875 or a member function. */
2876 && (DECL_FUNCTION_MEMBER_P (decl)
2877 ? same_type_p (DECL_CONTEXT (decl), current_class_type)
2878 : DECL_FRIEND_CONTEXT (decl)
2879 ? same_type_p (DECL_FRIEND_CONTEXT (decl), current_class_type)
2880 : false)
2881 /* And, if it was a member function, it really was defined in
2882 the scope of the class. */
2883 && (!DECL_FUNCTION_MEMBER_P (decl)
2884 || DECL_INITIALIZED_IN_CLASS_P (decl)))
2885 /* We already checked these parameters when the template was
2886 declared, so there's no need to do it again now. This function
2887 was defined in class scope, but we're processing it's body now
2888 that the class is complete. */
2889 return;
2890
2891 /* [temp.param]
2892
2893 If a template-parameter has a default template-argument, all
2894 subsequent template-parameters shall have a default
2895 template-argument supplied. */
2896 for (parm_level = parms; parm_level; parm_level = TREE_CHAIN (parm_level))
2897 {
2898 tree inner_parms = TREE_VALUE (parm_level);
2899 int ntparms = TREE_VEC_LENGTH (inner_parms);
2900 int seen_def_arg_p = 0;
2901 int i;
2902
2903 for (i = 0; i < ntparms; ++i)
2904 {
2905 tree parm = TREE_VEC_ELT (inner_parms, i);
2906
2907 if (parm == error_mark_node)
2908 continue;
2909
2910 if (TREE_PURPOSE (parm))
2911 seen_def_arg_p = 1;
2912 else if (seen_def_arg_p)
2913 {
2914 error ("no default argument for %qD", TREE_VALUE (parm));
2915 /* For better subsequent error-recovery, we indicate that
2916 there should have been a default argument. */
2917 TREE_PURPOSE (parm) = error_mark_node;
2918 }
2919 }
2920 }
2921
2922 if (TREE_CODE (decl) != TYPE_DECL || is_partial || !is_primary)
2923 /* For an ordinary class template, default template arguments are
2924 allowed at the innermost level, e.g.:
2925 template <class T = int>
2926 struct S {};
2927 but, in a partial specialization, they're not allowed even
2928 there, as we have in [temp.class.spec]:
2929
2930 The template parameter list of a specialization shall not
2931 contain default template argument values.
2932
2933 So, for a partial specialization, or for a function template,
2934 we look at all of them. */
2935 ;
2936 else
2937 /* But, for a primary class template that is not a partial
2938 specialization we look at all template parameters except the
2939 innermost ones. */
2940 parms = TREE_CHAIN (parms);
2941
2942 /* Figure out what error message to issue. */
2943 if (TREE_CODE (decl) == FUNCTION_DECL)
2944 msg = "default template arguments may not be used in function templates";
2945 else if (is_partial)
2946 msg = "default template arguments may not be used in partial specializations";
2947 else
2948 msg = "default argument for template parameter for class enclosing %qD";
2949
2950 if (current_class_type && TYPE_BEING_DEFINED (current_class_type))
2951 /* If we're inside a class definition, there's no need to
2952 examine the parameters to the class itself. On the one
2953 hand, they will be checked when the class is defined, and,
2954 on the other, default arguments are valid in things like:
2955 template <class T = double>
2956 struct S { template <class U> void f(U); };
2957 Here the default argument for `S' has no bearing on the
2958 declaration of `f'. */
2959 last_level_to_check = template_class_depth (current_class_type) + 1;
2960 else
2961 /* Check everything. */
2962 last_level_to_check = 0;
2963
2964 for (parm_level = parms;
2965 parm_level && TMPL_PARMS_DEPTH (parm_level) >= last_level_to_check;
2966 parm_level = TREE_CHAIN (parm_level))
2967 {
2968 tree inner_parms = TREE_VALUE (parm_level);
2969 int i;
2970 int ntparms;
2971
2972 ntparms = TREE_VEC_LENGTH (inner_parms);
2973 for (i = 0; i < ntparms; ++i)
2974 {
2975 if (TREE_VEC_ELT (inner_parms, i) == error_mark_node)
2976 continue;
2977
2978 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)))
2979 {
2980 if (msg)
2981 {
2982 error (msg, decl);
2983 msg = 0;
2984 }
2985
2986 /* Clear out the default argument so that we are not
2987 confused later. */
2988 TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)) = NULL_TREE;
2989 }
2990 }
2991
2992 /* At this point, if we're still interested in issuing messages,
2993 they must apply to classes surrounding the object declared. */
2994 if (msg)
2995 msg = "default argument for template parameter for class enclosing %qD";
2996 }
2997}
2998
2999/* Worker for push_template_decl_real, called via
3000 for_each_template_parm. DATA is really an int, indicating the
3001 level of the parameters we are interested in. If T is a template
3002 parameter of that level, return nonzero. */
3003
3004static int
3005template_parm_this_level_p (tree t, void* data)
3006{
3007 int this_level = *(int *)data;
3008 int level;
3009
3010 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
3011 level = TEMPLATE_PARM_LEVEL (t);
3012 else
3013 level = TEMPLATE_TYPE_LEVEL (t);
3014 return level == this_level;
3015}
3016
3017/* Creates a TEMPLATE_DECL for the indicated DECL using the template
3018 parameters given by current_template_args, or reuses a
3019 previously existing one, if appropriate. Returns the DECL, or an
3020 equivalent one, if it is replaced via a call to duplicate_decls.
3021
3022 If IS_FRIEND is true, DECL is a friend declaration. */
3023
3024tree
3025push_template_decl_real (tree decl, bool is_friend)
3026{
3027 tree tmpl;
3028 tree args;
3029 tree info;
3030 tree ctx;
3031 int primary;
3032 int is_partial;
3033 int new_template_p = 0;
3034 /* True if the template is a member template, in the sense of
3035 [temp.mem]. */
3036 bool member_template_p = false;
3037
3038 if (decl == error_mark_node)
3039 return decl;
3040
3041 /* See if this is a partial specialization. */
3042 is_partial = (DECL_IMPLICIT_TYPEDEF_P (decl)
3043 && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE
3044 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)));
3045
3046 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_FRIEND_P (decl))
3047 is_friend = true;
3048
3049 if (is_friend)
3050 /* For a friend, we want the context of the friend function, not
3051 the type of which it is a friend. */
3052 ctx = DECL_CONTEXT (decl);
3053 else if (CP_DECL_CONTEXT (decl)
3054 && TREE_CODE (CP_DECL_CONTEXT (decl)) != NAMESPACE_DECL)
3055 /* In the case of a virtual function, we want the class in which
3056 it is defined. */
3057 ctx = CP_DECL_CONTEXT (decl);
3058 else
3059 /* Otherwise, if we're currently defining some class, the DECL
3060 is assumed to be a member of the class. */
3061 ctx = current_scope ();
3062
3063 if (ctx && TREE_CODE (ctx) == NAMESPACE_DECL)
3064 ctx = NULL_TREE;
3065
3066 if (!DECL_CONTEXT (decl))
3067 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
3068
3069 /* See if this is a primary template. */
3070 if (is_friend && ctx)
3071 /* A friend template that specifies a class context, i.e.
3072 template <typename T> friend void A<T>::f();
3073 is not primary. */
3074 primary = 0;
3075 else
3076 primary = template_parm_scope_p ();
3077
3078 if (primary)
3079 {
3080 if (DECL_CLASS_SCOPE_P (decl))
3081 member_template_p = true;
3082 if (TREE_CODE (decl) == TYPE_DECL
3083 && ANON_AGGRNAME_P (DECL_NAME (decl)))
3084 error ("template class without a name");
3085 else if (TREE_CODE (decl) == FUNCTION_DECL)
3086 {
3087 if (DECL_DESTRUCTOR_P (decl))
3088 {
3089 /* [temp.mem]
3090
3091 A destructor shall not be a member template. */
3092 error ("destructor %qD declared as member template", decl);
3093 return error_mark_node;
3094 }
3095 if (NEW_DELETE_OPNAME_P (DECL_NAME (decl))
3096 && (!TYPE_ARG_TYPES (TREE_TYPE (decl))
3097 || TYPE_ARG_TYPES (TREE_TYPE (decl)) == void_list_node
3098 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
3099 || (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl))))
3100 == void_list_node)))
3101 {
3102 /* [basic.stc.dynamic.allocation]
3103
3104 An allocation function can be a function
3105 template. ... Template allocation functions shall
3106 have two or more parameters. */
3107 error ("invalid template declaration of %qD", decl);
3108 return error_mark_node;
3109 }
3110 }
3111 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
3112 && CLASS_TYPE_P (TREE_TYPE (decl)))
3113 /* OK */;
3114 else
3115 {
3116 error ("template declaration of %q#D", decl);
3117 return error_mark_node;
3118 }
3119 }
3120
3121 /* Check to see that the rules regarding the use of default
3122 arguments are not being violated. */
3123 check_default_tmpl_args (decl, current_template_parms,
3124 primary, is_partial);
3125
3126 if (is_partial)
3127 return process_partial_specialization (decl);
3128
3129 args = current_template_args ();
3130
3131 if (!ctx
3132 || TREE_CODE (ctx) == FUNCTION_DECL
3133 || (CLASS_TYPE_P (ctx) && TYPE_BEING_DEFINED (ctx))
3134 || (is_friend && !DECL_TEMPLATE_INFO (decl)))
3135 {
3136 if (DECL_LANG_SPECIFIC (decl)
3137 && DECL_TEMPLATE_INFO (decl)
3138 && DECL_TI_TEMPLATE (decl))
3139 tmpl = DECL_TI_TEMPLATE (decl);
3140 /* If DECL is a TYPE_DECL for a class-template, then there won't
3141 be DECL_LANG_SPECIFIC. The information equivalent to
3142 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
3143 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
3144 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
3145 && TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
3146 {
3147 /* Since a template declaration already existed for this
3148 class-type, we must be redeclaring it here. Make sure
3149 that the redeclaration is valid. */
3150 redeclare_class_template (TREE_TYPE (decl),
3151 current_template_parms);
3152 /* We don't need to create a new TEMPLATE_DECL; just use the
3153 one we already had. */
3154 tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
3155 }
3156 else
3157 {
3158 tmpl = build_template_decl (decl, current_template_parms,
3159 member_template_p);
3160 new_template_p = 1;
3161
3162 if (DECL_LANG_SPECIFIC (decl)
3163 && DECL_TEMPLATE_SPECIALIZATION (decl))
3164 {
3165 /* A specialization of a member template of a template
3166 class. */
3167 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
3168 DECL_TEMPLATE_INFO (tmpl) = DECL_TEMPLATE_INFO (decl);
3169 DECL_TEMPLATE_INFO (decl) = NULL_TREE;
3170 }
3171 }
3172 }
3173 else
3174 {
3175 tree a, t, current, parms;
3176 int i;
3177
3178 if (TREE_CODE (decl) == TYPE_DECL)
3179 {
3180 if ((IS_AGGR_TYPE_CODE (TREE_CODE (TREE_TYPE (decl)))
3181 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
3182 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
3183 && TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
3184 tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
3185 else
3186 {
3187 error ("%qD does not declare a template type", decl);
3188 return decl;
3189 }
3190 }
3191 else if (!DECL_LANG_SPECIFIC (decl) || !DECL_TEMPLATE_INFO (decl))
3192 {
3193 error ("template definition of non-template %q#D", decl);
3194 return decl;
3195 }
3196 else
3197 tmpl = DECL_TI_TEMPLATE (decl);
3198
3199 if (DECL_FUNCTION_TEMPLATE_P (tmpl)
3200 && DECL_TEMPLATE_INFO (decl) && DECL_TI_ARGS (decl)
3201 && DECL_TEMPLATE_SPECIALIZATION (decl)
3202 && DECL_MEMBER_TEMPLATE_P (tmpl))
3203 {
3204 tree new_tmpl;
3205
3206 /* The declaration is a specialization of a member
3207 template, declared outside the class. Therefore, the
3208 innermost template arguments will be NULL, so we
3209 replace them with the arguments determined by the
3210 earlier call to check_explicit_specialization. */
3211 args = DECL_TI_ARGS (decl);
3212
3213 new_tmpl
3214 = build_template_decl (decl, current_template_parms,
3215 member_template_p);
3216 DECL_TEMPLATE_RESULT (new_tmpl) = decl;
3217 TREE_TYPE (new_tmpl) = TREE_TYPE (decl);
3218 DECL_TI_TEMPLATE (decl) = new_tmpl;
3219 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl);
3220 DECL_TEMPLATE_INFO (new_tmpl)
3221 = tree_cons (tmpl, args, NULL_TREE);
3222
3223 register_specialization (new_tmpl,
3224 most_general_template (tmpl),
3225 args,
3226 is_friend);
3227 return decl;
3228 }
3229
3230 /* Make sure the template headers we got make sense. */
3231
3232 parms = DECL_TEMPLATE_PARMS (tmpl);
3233 i = TMPL_PARMS_DEPTH (parms);
3234 if (TMPL_ARGS_DEPTH (args) != i)
3235 {
3236 error ("expected %d levels of template parms for %q#D, got %d",
3237 i, decl, TMPL_ARGS_DEPTH (args));
3238 }
3239 else
3240 for (current = decl; i > 0; --i, parms = TREE_CHAIN (parms))
3241 {
3242 a = TMPL_ARGS_LEVEL (args, i);
3243 t = INNERMOST_TEMPLATE_PARMS (parms);
3244
3245 if (TREE_VEC_LENGTH (t) != TREE_VEC_LENGTH (a))
3246 {
3247 if (current == decl)
3248 error ("got %d template parameters for %q#D",
3249 TREE_VEC_LENGTH (a), decl);
3250 else
3251 error ("got %d template parameters for %q#T",
3252 TREE_VEC_LENGTH (a), current);
3253 error (" but %d required", TREE_VEC_LENGTH (t));
3254 return error_mark_node;
3255 }
3256
3257 /* Perhaps we should also check that the parms are used in the
3258 appropriate qualifying scopes in the declarator? */
3259
3260 if (current == decl)
3261 current = ctx;
3262 else
3263 current = TYPE_CONTEXT (current);
3264 }
3265 }
3266
3267 DECL_TEMPLATE_RESULT (tmpl) = decl;
3268 TREE_TYPE (tmpl) = TREE_TYPE (decl);
3269
3270 /* Push template declarations for global functions and types. Note
3271 that we do not try to push a global template friend declared in a
3272 template class; such a thing may well depend on the template
3273 parameters of the class. */
3274 if (new_template_p && !ctx
3275 && !(is_friend && template_class_depth (current_class_type) > 0))
3276 {
3277 tmpl = pushdecl_namespace_level (tmpl, is_friend);
3278 if (tmpl == error_mark_node)
3279 return error_mark_node;
3280
3281 /* Hide template friend classes that haven't been declared yet. */
3282 if (is_friend && TREE_CODE (decl) == TYPE_DECL)
3283 {
3284 DECL_ANTICIPATED (tmpl) = 1;
3285 DECL_FRIEND_P (tmpl) = 1;
3286 }
3287 }
3288
3289 if (primary)
3290 {
3291 DECL_PRIMARY_TEMPLATE (tmpl) = tmpl;
3292 if (DECL_CONV_FN_P (tmpl))
3293 {
3294 int depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
3295
3296 /* It is a conversion operator. See if the type converted to
3297 depends on innermost template operands. */
3298
3299 if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl)),
3300 depth))
3301 DECL_TEMPLATE_CONV_FN_P (tmpl) = 1;
3302 }
3303 }
3304
3305 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
3306 back to its most general template. If TMPL is a specialization,
3307 ARGS may only have the innermost set of arguments. Add the missing
3308 argument levels if necessary. */
3309 if (DECL_TEMPLATE_INFO (tmpl))
3310 args = add_outermost_template_args (DECL_TI_ARGS (tmpl), args);
3311
3312 info = tree_cons (tmpl, args, NULL_TREE);
3313
3314 if (DECL_IMPLICIT_TYPEDEF_P (decl))
3315 {
3316 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl), info);
3317 if ((!ctx || TREE_CODE (ctx) != FUNCTION_DECL)
3318 && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE
3319 /* Don't change the name if we've already set it up. */
3320 && !IDENTIFIER_TEMPLATE (DECL_NAME (decl)))
3321 DECL_NAME (decl) = classtype_mangled_name (TREE_TYPE (decl));
3322 }
3323 else if (DECL_LANG_SPECIFIC (decl))
3324 DECL_TEMPLATE_INFO (decl) = info;
3325
3326 return DECL_TEMPLATE_RESULT (tmpl);
3327}
3328
3329tree
3330push_template_decl (tree decl)
3331{
3332 return push_template_decl_real (decl, false);
3333}
3334
3335/* Called when a class template TYPE is redeclared with the indicated
3336 template PARMS, e.g.:
3337
3338 template <class T> struct S;
3339 template <class T> struct S {}; */
3340
3341bool
3342redeclare_class_template (tree type, tree parms)
3343{
3344 tree tmpl;
3345 tree tmpl_parms;
3346 int i;
3347
3348 if (!TYPE_TEMPLATE_INFO (type))
3349 {
3350 error ("%qT is not a template type", type);
3351 return false;
3352 }
3353
3354 tmpl = TYPE_TI_TEMPLATE (type);
3355 if (!PRIMARY_TEMPLATE_P (tmpl))
3356 /* The type is nested in some template class. Nothing to worry
3357 about here; there are no new template parameters for the nested
3358 type. */
3359 return true;
3360
3361 if (!parms)
3362 {
3363 error ("template specifiers not specified in declaration of %qD",
3364 tmpl);
3365 return false;
3366 }
3367
3368 parms = INNERMOST_TEMPLATE_PARMS (parms);
3369 tmpl_parms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl);
3370
3371 if (TREE_VEC_LENGTH (parms) != TREE_VEC_LENGTH (tmpl_parms))
3372 {
3373 error ("previous declaration %q+D", tmpl);
3374 error ("used %d template parameter(s) instead of %d",
3375 TREE_VEC_LENGTH (tmpl_parms),
3376 TREE_VEC_LENGTH (parms));
3377 return false;
3378 }
3379
3380 for (i = 0; i < TREE_VEC_LENGTH (tmpl_parms); ++i)
3381 {
3382 tree tmpl_parm;
3383 tree parm;
3384 tree tmpl_default;
3385 tree parm_default;
3386
3387 if (TREE_VEC_ELT (tmpl_parms, i) == error_mark_node
3388 || TREE_VEC_ELT (parms, i) == error_mark_node)
3389 continue;
3390
3391 tmpl_parm = TREE_VALUE (TREE_VEC_ELT (tmpl_parms, i));
3392 parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
3393 tmpl_default = TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i));
3394 parm_default = TREE_PURPOSE (TREE_VEC_ELT (parms, i));
3395
3396 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
3397 TEMPLATE_DECL. */
3398 if (tmpl_parm != error_mark_node
3399 && (TREE_CODE (tmpl_parm) != TREE_CODE (parm)
3400 || (TREE_CODE (tmpl_parm) != TYPE_DECL
3401 && !same_type_p (TREE_TYPE (tmpl_parm), TREE_TYPE (parm)))))
3402 {
3403 error ("template parameter %q+#D", tmpl_parm);
3404 error ("redeclared here as %q#D", parm);
3405 return false;
3406 }
3407
3408 if (tmpl_default != NULL_TREE && parm_default != NULL_TREE)
3409 {
3410 /* We have in [temp.param]:
3411
3412 A template-parameter may not be given default arguments
3413 by two different declarations in the same scope. */
3414 error ("redefinition of default argument for %q#D", parm);
3415 error ("%J original definition appeared here", tmpl_parm);
3416 return false;
3417 }
3418
3419 if (parm_default != NULL_TREE)
3420 /* Update the previous template parameters (which are the ones
3421 that will really count) with the new default value. */
3422 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i)) = parm_default;
3423 else if (tmpl_default != NULL_TREE)
3424 /* Update the new parameters, too; they'll be used as the
3425 parameters for any members. */
3426 TREE_PURPOSE (TREE_VEC_ELT (parms, i)) = tmpl_default;
3427 }
3428
3429 return true;
3430}
3431
3432/* Simplify EXPR if it is a non-dependent expression. Returns the
3433 (possibly simplified) expression. */
3434
3435tree
3436fold_non_dependent_expr (tree expr)
3437{
3438 if (expr == NULL_TREE)
3439 return NULL_TREE;
3440
3441 /* If we're in a template, but EXPR isn't value dependent, simplify
3442 it. We're supposed to treat:
3443
3444 template <typename T> void f(T[1 + 1]);
3445 template <typename T> void f(T[2]);
3446
3447 as two declarations of the same function, for example. */
3448 if (processing_template_decl
3449 && !type_dependent_expression_p (expr)
3450 && !value_dependent_expression_p (expr))
3451 {
3452 HOST_WIDE_INT saved_processing_template_decl;
3453
3454 saved_processing_template_decl = processing_template_decl;
3455 processing_template_decl = 0;
3456 expr = tsubst_copy_and_build (expr,
3457 /*args=*/NULL_TREE,
3458 tf_error,
3459 /*in_decl=*/NULL_TREE,
3460 /*function_p=*/false,
3461 /*integral_constant_expression_p=*/true);
3462 processing_template_decl = saved_processing_template_decl;
3463 }
3464 return expr;
3465}
3466
3467/* EXPR is an expression which is used in a constant-expression context.
3468 For instance, it could be a VAR_DECL with a constant initializer.
3469 Extract the innest constant expression.
3470
3471 This is basically a more powerful version of
3472 integral_constant_value, which can be used also in templates where
3473 initializers can maintain a syntactic rather than semantic form
3474 (even if they are non-dependent, for access-checking purposes). */
3475
3476static tree
3477fold_decl_constant_value (tree expr)
3478{
3479 tree const_expr = expr;
3480 do
3481 {
3482 expr = fold_non_dependent_expr (const_expr);
3483 const_expr = integral_constant_value (expr);
3484 }
3485 while (expr != const_expr);
3486
3487 return expr;
3488}
3489
3490/* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
3491 must be a function or a pointer-to-function type, as specified
3492 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
3493 and check that the resulting function has external linkage. */
3494
3495static tree
3496convert_nontype_argument_function (tree type, tree expr)
3497{
3498 tree fns = expr;
3499 tree fn, fn_no_ptr;
3500
3501 fn = instantiate_type (type, fns, tf_none);
3502 if (fn == error_mark_node)
3503 return error_mark_node;
3504
3505 fn_no_ptr = fn;
3506 if (TREE_CODE (fn_no_ptr) == ADDR_EXPR)
3507 fn_no_ptr = TREE_OPERAND (fn_no_ptr, 0);
3508 if (TREE_CODE (fn_no_ptr) == BASELINK)
3509 fn_no_ptr = BASELINK_FUNCTIONS (fn_no_ptr);
3510
3511 /* [temp.arg.nontype]/1
3512
3513 A template-argument for a non-type, non-template template-parameter
3514 shall be one of:
3515 [...]
3516 -- the address of an object or function with external linkage. */
3517 if (!DECL_EXTERNAL_LINKAGE_P (fn_no_ptr))
3518 {
3519 error ("%qE is not a valid template argument for type %qT "
3520 "because function %qD has not external linkage",
3521 expr, type, fn_no_ptr);
3522 return NULL_TREE;
3523 }
3524
3525 return fn;
3526}
3527
3528/* Attempt to convert the non-type template parameter EXPR to the
3529 indicated TYPE. If the conversion is successful, return the
3530 converted value. If the conversion is unsuccessful, return
3531 NULL_TREE if we issued an error message, or error_mark_node if we
3532 did not. We issue error messages for out-and-out bad template
3533 parameters, but not simply because the conversion failed, since we
3534 might be just trying to do argument deduction. Both TYPE and EXPR
3535 must be non-dependent.
3536
3537 The conversion follows the special rules described in
3538 [temp.arg.nontype], and it is much more strict than an implicit
3539 conversion.
3540
3541 This function is called twice for each template argument (see
3542 lookup_template_class for a more accurate description of this
3543 problem). This means that we need to handle expressions which
3544 are not valid in a C++ source, but can be created from the
3545 first call (for instance, casts to perform conversions). These
3546 hacks can go away after we fix the double coercion problem. */
3547
3548static tree
3549convert_nontype_argument (tree type, tree expr)
3550{
3551 tree expr_type;
3552
3553 /* Detect immediately string literals as invalid non-type argument.
3554 This special-case is not needed for correctness (we would easily
3555 catch this later), but only to provide better diagnostic for this
3556 common user mistake. As suggested by DR 100, we do not mention
3557 linkage issues in the diagnostic as this is not the point. */
3558 if (TREE_CODE (expr) == STRING_CST)
3559 {
3560 error ("%qE is not a valid template argument for type %qT "
3561 "because string literals can never be used in this context",
3562 expr, type);
3563 return NULL_TREE;
3564 }
3565
3566 /* If we are in a template, EXPR may be non-dependent, but still
3567 have a syntactic, rather than semantic, form. For example, EXPR
3568 might be a SCOPE_REF, rather than the VAR_DECL to which the
3569 SCOPE_REF refers. Preserving the qualifying scope is necessary
3570 so that access checking can be performed when the template is
3571 instantiated -- but here we need the resolved form so that we can
3572 convert the argument. */
3573 expr = fold_non_dependent_expr (expr);
3574 if (error_operand_p (expr))
3575 return error_mark_node;
3576 expr_type = TREE_TYPE (expr);
3577
3578 /* HACK: Due to double coercion, we can get a
3579 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
3580 which is the tree that we built on the first call (see
3581 below when coercing to reference to object or to reference to
3582 function). We just strip everything and get to the arg.
3583 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
3584 for examples. */
3585 if (TREE_CODE (expr) == NOP_EXPR)
3586 {
3587 if (TYPE_REF_OBJ_P (type) || TYPE_REFFN_P (type))
3588 {
3589 /* ??? Maybe we could use convert_from_reference here, but we
3590 would need to relax its constraints because the NOP_EXPR
3591 could actually change the type to something more cv-qualified,
3592 and this is not folded by convert_from_reference. */
3593 tree addr = TREE_OPERAND (expr, 0);
3594 gcc_assert (TREE_CODE (expr_type) == REFERENCE_TYPE);
3595 gcc_assert (TREE_CODE (addr) == ADDR_EXPR);
3596 gcc_assert (TREE_CODE (TREE_TYPE (addr)) == POINTER_TYPE);
3597 gcc_assert (same_type_ignoring_top_level_qualifiers_p
3598 (TREE_TYPE (expr_type),
3599 TREE_TYPE (TREE_TYPE (addr))));
3600
3601 expr = TREE_OPERAND (addr, 0);
3602 expr_type = TREE_TYPE (expr);
3603 }
3604
3605 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
3606 parameter is a pointer to object, through decay and
3607 qualification conversion. Let's strip everything. */
3608 else if (TYPE_PTROBV_P (type))
3609 {
3610 STRIP_NOPS (expr);
3611 gcc_assert (TREE_CODE (expr) == ADDR_EXPR);
3612 gcc_assert (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE);
3613 /* Skip the ADDR_EXPR only if it is part of the decay for
3614 an array. Otherwise, it is part of the original argument
3615 in the source code. */
3616 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == ARRAY_TYPE)
3617 expr = TREE_OPERAND (expr, 0);
3618 expr_type = TREE_TYPE (expr);
3619 }
3620 }
3621
3622 /* [temp.arg.nontype]/5, bullet 1
3623
3624 For a non-type template-parameter of integral or enumeration type,
3625 integral promotions (_conv.prom_) and integral conversions
3626 (_conv.integral_) are applied. */
3627 if (INTEGRAL_TYPE_P (type))
3628 {
3629 if (!INTEGRAL_TYPE_P (expr_type))
3630 return error_mark_node;
3631
3632 expr = fold_decl_constant_value (expr);
3633 /* Notice that there are constant expressions like '4 % 0' which
3634 do not fold into integer constants. */
3635 if (TREE_CODE (expr) != INTEGER_CST)
3636 {
3637 error ("%qE is not a valid template argument for type %qT "
3638 "because it is a non-constant expression", expr, type);
3639 return NULL_TREE;
3640 }
3641
3642 /* At this point, an implicit conversion does what we want,
3643 because we already know that the expression is of integral
3644 type. */
3645 expr = ocp_convert (type, expr, CONV_IMPLICIT, LOOKUP_PROTECT);
3646 if (expr == error_mark_node)
3647 return error_mark_node;
3648
3649 /* Conversion was allowed: fold it to a bare integer constant. */
3650 expr = fold (expr);
3651 }
3652 /* [temp.arg.nontype]/5, bullet 2
3653
3654 For a non-type template-parameter of type pointer to object,
3655 qualification conversions (_conv.qual_) and the array-to-pointer
3656 conversion (_conv.array_) are applied. */
3657 else if (TYPE_PTROBV_P (type))
3658 {
3659 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
3660
3661 A template-argument for a non-type, non-template template-parameter
3662 shall be one of: [...]
3663
3664 -- the name of a non-type template-parameter;
3665 -- the address of an object or function with external linkage, [...]
3666 expressed as "& id-expression" where the & is optional if the name
3667 refers to a function or array, or if the corresponding
3668 template-parameter is a reference.
3669
3670 Here, we do not care about functions, as they are invalid anyway
3671 for a parameter of type pointer-to-object. */
3672
3673 if (DECL_P (expr) && DECL_TEMPLATE_PARM_P (expr))
3674 /* Non-type template parameters are OK. */
3675 ;
3676 else if (TREE_CODE (expr) != ADDR_EXPR
3677 && TREE_CODE (expr_type) != ARRAY_TYPE)
3678 {
3679 if (TREE_CODE (expr) == VAR_DECL)
3680 {
3681 error ("%qD is not a valid template argument "
3682 "because %qD is a variable, not the address of "
3683 "a variable",
3684 expr, expr);
3685 return NULL_TREE;
3686 }
3687 /* Other values, like integer constants, might be valid
3688 non-type arguments of some other type. */
3689 return error_mark_node;
3690 }
3691 else
3692 {
3693 tree decl;
3694
3695 decl = ((TREE_CODE (expr) == ADDR_EXPR)
3696 ? TREE_OPERAND (expr, 0) : expr);
3697 if (TREE_CODE (decl) != VAR_DECL)
3698 {
3699 error ("%qE is not a valid template argument of type %qT "
3700 "because %qE is not a variable",
3701 expr, type, decl);
3702 return NULL_TREE;
3703 }
3704 else if (!DECL_EXTERNAL_LINKAGE_P (decl))
3705 {
3706 error ("%qE is not a valid template argument of type %qT "
3707 "because %qD does not have external linkage",
3708 expr, type, decl);
3709 return NULL_TREE;
3710 }
3711 }
3712
3713 expr = decay_conversion (expr);
3714 if (expr == error_mark_node)
3715 return error_mark_node;
3716
3717 expr = perform_qualification_conversions (type, expr);
3718 if (expr == error_mark_node)
3719 return error_mark_node;
3720 }
3721 /* [temp.arg.nontype]/5, bullet 3
3722
3723 For a non-type template-parameter of type reference to object, no
3724 conversions apply. The type referred to by the reference may be more
3725 cv-qualified than the (otherwise identical) type of the
3726 template-argument. The template-parameter is bound directly to the
3727 template-argument, which must be an lvalue. */
3728 else if (TYPE_REF_OBJ_P (type))
3729 {
3730 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type),
3731 expr_type))
3732 return error_mark_node;
3733
3734 if (!at_least_as_qualified_p (TREE_TYPE (type), expr_type))
3735 {
3736 error ("%qE is not a valid template argument for type %qT "
3737 "because of conflicts in cv-qualification", expr, type);
3738 return NULL_TREE;
3739 }
3740
3741 if (!real_lvalue_p (expr))
3742 {
3743 error ("%qE is not a valid template argument for type %qT "
3744 "because it is not an lvalue", expr, type);
3745 return NULL_TREE;
3746 }
3747
3748 /* [temp.arg.nontype]/1
3749
3750 A template-argument for a non-type, non-template template-parameter
3751 shall be one of: [...]
3752
3753 -- the address of an object or function with external linkage. */
3754 if (!DECL_EXTERNAL_LINKAGE_P (expr))
3755 {
3756 error ("%qE is not a valid template argument for type %qT "
3757 "because object %qD has not external linkage",
3758 expr, type, expr);
3759 return NULL_TREE;
3760 }
3761
3762 expr = build_nop (type, build_address (expr));
3763 }
3764 /* [temp.arg.nontype]/5, bullet 4
3765
3766 For a non-type template-parameter of type pointer to function, only
3767 the function-to-pointer conversion (_conv.func_) is applied. If the
3768 template-argument represents a set of overloaded functions (or a
3769 pointer to such), the matching function is selected from the set
3770 (_over.over_). */
3771 else if (TYPE_PTRFN_P (type))
3772 {
3773 /* If the argument is a template-id, we might not have enough
3774 context information to decay the pointer. */
3775 if (!type_unknown_p (expr_type))
3776 {
3777 expr = decay_conversion (expr);
3778 if (expr == error_mark_node)
3779 return error_mark_node;
3780 }
3781
3782 expr = convert_nontype_argument_function (type, expr);
3783 if (!expr || expr == error_mark_node)
3784 return expr;
3785 }
3786 /* [temp.arg.nontype]/5, bullet 5
3787
3788 For a non-type template-parameter of type reference to function, no
3789 conversions apply. If the template-argument represents a set of
3790 overloaded functions, the matching function is selected from the set
3791 (_over.over_). */
3792 else if (TYPE_REFFN_P (type))
3793 {
3794 if (TREE_CODE (expr) == ADDR_EXPR)
3795 {
3796 error ("%qE is not a valid template argument for type %qT "
3797 "because it is a pointer", expr, type);
3798 inform ("try using %qE instead", TREE_OPERAND (expr, 0));
3799 return NULL_TREE;
3800 }
3801
3802 expr = convert_nontype_argument_function (TREE_TYPE (type), expr);
3803 if (!expr || expr == error_mark_node)
3804 return expr;
3805
3806 expr = build_nop (type, build_address (expr));
3807 }
3808 /* [temp.arg.nontype]/5, bullet 6
3809
3810 For a non-type template-parameter of type pointer to member function,
3811 no conversions apply. If the template-argument represents a set of
3812 overloaded member functions, the matching member function is selected
3813 from the set (_over.over_). */
3814 else if (TYPE_PTRMEMFUNC_P (type))
3815 {
3816 expr = instantiate_type (type, expr, tf_none);
3817 if (expr == error_mark_node)
3818 return error_mark_node;
3819
3820 /* There is no way to disable standard conversions in
3821 resolve_address_of_overloaded_function (called by
3822 instantiate_type). It is possible that the call succeeded by
3823 converting &B::I to &D::I (where B is a base of D), so we need
3824 to reject this conversion here.
3825
3826 Actually, even if there was a way to disable standard conversions,
3827 it would still be better to reject them here so that we can
3828 provide a superior diagnostic. */
3829 if (!same_type_p (TREE_TYPE (expr), type))
3830 {
3831 /* Make sure we are just one standard conversion off. */
3832 gcc_assert (can_convert (type, TREE_TYPE (expr)));
3833 error ("%qE is not a valid template argument for type %qT "
3834 "because it is of type %qT", expr, type,
3835 TREE_TYPE (expr));
3836 inform ("standard conversions are not allowed in this context");
3837 return NULL_TREE;
3838 }
3839 }
3840 /* [temp.arg.nontype]/5, bullet 7
3841
3842 For a non-type template-parameter of type pointer to data member,
3843 qualification conversions (_conv.qual_) are applied. */
3844 else if (TYPE_PTRMEM_P (type))
3845 {
3846 expr = perform_qualification_conversions (type, expr);
3847 if (expr == error_mark_node)
3848 return expr;
3849 }
3850 /* A template non-type parameter must be one of the above. */
3851 else
3852 gcc_unreachable ();
3853
3854 /* Sanity check: did we actually convert the argument to the
3855 right type? */
3856 gcc_assert (same_type_p (type, TREE_TYPE (expr)));
3857 return expr;
3858}
3859
3860
3861/* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
3862 template template parameters. Both PARM_PARMS and ARG_PARMS are
3863 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
3864 or PARM_DECL.
3865
3866 Consider the example:
3867 template <class T> class A;
3868 template<template <class U> class TT> class B;
3869
3870 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
3871 the parameters to A, and OUTER_ARGS contains A. */
3872
3873static int
3874coerce_template_template_parms (tree parm_parms,
3875 tree arg_parms,
3876 tsubst_flags_t complain,
3877 tree in_decl,
3878 tree outer_args)
3879{
3880 int nparms, nargs, i;
3881 tree parm, arg;
3882
3883 gcc_assert (TREE_CODE (parm_parms) == TREE_VEC);
3884 gcc_assert (TREE_CODE (arg_parms) == TREE_VEC);
3885
3886 nparms = TREE_VEC_LENGTH (parm_parms);
3887 nargs = TREE_VEC_LENGTH (arg_parms);
3888
3889 if (nargs != nparms)
3890 return 0;
3891
3892 for (i = 0; i < nparms; ++i)
3893 {
3894 if (TREE_VEC_ELT (parm_parms, i) == error_mark_node
3895 || TREE_VEC_ELT (arg_parms, i) == error_mark_node)
3896 continue;
3897
3898 parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, i));
3899 arg = TREE_VALUE (TREE_VEC_ELT (arg_parms, i));
3900
3901 if (arg == NULL_TREE || arg == error_mark_node
3902 || parm == NULL_TREE || parm == error_mark_node)
3903 return 0;
3904
3905 if (TREE_CODE (arg) != TREE_CODE (parm))
3906 return 0;
3907
3908 switch (TREE_CODE (parm))
3909 {
3910 case TYPE_DECL:
3911 break;
3912
3913 case TEMPLATE_DECL:
3914 /* We encounter instantiations of templates like
3915 template <template <template <class> class> class TT>
3916 class C; */
3917 {
3918 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
3919 tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
3920
3921 if (!coerce_template_template_parms
3922 (parmparm, argparm, complain, in_decl, outer_args))
3923 return 0;
3924 }
3925 break;
3926
3927 case PARM_DECL:
3928 /* The tsubst call is used to handle cases such as
3929
3930 template <int> class C {};
3931 template <class T, template <T> class TT> class D {};
3932 D<int, C> d;
3933
3934 i.e. the parameter list of TT depends on earlier parameters. */
3935 if (!dependent_type_p (TREE_TYPE (arg))
3936 && !same_type_p
3937 (tsubst (TREE_TYPE (parm), outer_args, complain, in_decl),
3938 TREE_TYPE (arg)))
3939 return 0;
3940 break;
3941
3942 default:
3943 gcc_unreachable ();
3944 }
3945 }
3946 return 1;
3947}
3948
3949/* Convert the indicated template ARG as necessary to match the
3950 indicated template PARM. Returns the converted ARG, or
3951 error_mark_node if the conversion was unsuccessful. Error and
3952 warning messages are issued under control of COMPLAIN. This
3953 conversion is for the Ith parameter in the parameter list. ARGS is
3954 the full set of template arguments deduced so far. */
3955
3956static tree
3957convert_template_argument (tree parm,
3958 tree arg,
3959 tree args,
3960 tsubst_flags_t complain,
3961 int i,
3962 tree in_decl)
3963{
3964 tree val;
3965 int is_type, requires_type, is_tmpl_type, requires_tmpl_type;
3966
3967 if (TREE_CODE (arg) == TREE_LIST
3968 && TREE_CODE (TREE_VALUE (arg)) == OFFSET_REF)
3969 {
3970 /* The template argument was the name of some
3971 member function. That's usually
3972 invalid, but static members are OK. In any
3973 case, grab the underlying fields/functions
3974 and issue an error later if required. */
3975 arg = TREE_VALUE (arg);
3976 TREE_TYPE (arg) = unknown_type_node;
3977 }
3978
3979 requires_tmpl_type = TREE_CODE (parm) == TEMPLATE_DECL;
3980 requires_type = (TREE_CODE (parm) == TYPE_DECL
3981 || requires_tmpl_type);
3982
3983 is_tmpl_type = ((TREE_CODE (arg) == TEMPLATE_DECL
3984 && TREE_CODE (DECL_TEMPLATE_RESULT (arg)) == TYPE_DECL)
3985 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
3986 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE);
3987
3988 if (is_tmpl_type
3989 && (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
3990 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE))
3991 arg = TYPE_STUB_DECL (arg);
3992
3993 is_type = TYPE_P (arg) || is_tmpl_type;
3994
3995 if (requires_type && ! is_type && TREE_CODE (arg) == SCOPE_REF
3996 && TREE_CODE (TREE_OPERAND (arg, 0)) == TEMPLATE_TYPE_PARM)
3997 {
3998 pedwarn ("to refer to a type member of a template parameter, "
3999 "use %<typename %E%>", arg);
4000
4001 arg = make_typename_type (TREE_OPERAND (arg, 0),
4002 TREE_OPERAND (arg, 1),
4003 typename_type,
4004 complain & tf_error);
4005 is_type = 1;
4006 }
4007 if (is_type != requires_type)
4008 {
4009 if (in_decl)
4010 {
4011 if (complain & tf_error)
4012 {
4013 error ("type/value mismatch at argument %d in template "
4014 "parameter list for %qD",
4015 i + 1, in_decl);
4016 if (is_type)
4017 error (" expected a constant of type %qT, got %qT",
4018 TREE_TYPE (parm),
4019 (is_tmpl_type ? DECL_NAME (arg) : arg));
4020 else if (requires_tmpl_type)
4021 error (" expected a class template, got %qE", arg);
4022 else
4023 error (" expected a type, got %qE", arg);
4024 }
4025 }
4026 return error_mark_node;
4027 }
4028 if (is_tmpl_type ^ requires_tmpl_type)
4029 {
4030 if (in_decl && (complain & tf_error))
4031 {
4032 error ("type/value mismatch at argument %d in template "
4033 "parameter list for %qD",
4034 i + 1, in_decl);
4035 if (is_tmpl_type)
4036 error (" expected a type, got %qT", DECL_NAME (arg));
4037 else
4038 error (" expected a class template, got %qT", arg);
4039 }
4040 return error_mark_node;
4041 }
4042
4043 if (is_type)
4044 {
4045 if (requires_tmpl_type)
4046 {
4047 if (TREE_CODE (TREE_TYPE (arg)) == UNBOUND_CLASS_TEMPLATE)
4048 /* The number of argument required is not known yet.
4049 Just accept it for now. */
4050 val = TREE_TYPE (arg);
4051 else
4052 {
4053 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
4054 tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
4055
4056 if (coerce_template_template_parms (parmparm, argparm,
4057 complain, in_decl,
4058 args))
4059 {
4060 val = arg;
4061
4062 /* TEMPLATE_TEMPLATE_PARM node is preferred over
4063 TEMPLATE_DECL. */
4064 if (val != error_mark_node
4065 && DECL_TEMPLATE_TEMPLATE_PARM_P (val))
4066 val = TREE_TYPE (val);
4067 }
4068 else
4069 {
4070 if (in_decl && (complain & tf_error))
4071 {
4072 error ("type/value mismatch at argument %d in "
4073 "template parameter list for %qD",
4074 i + 1, in_decl);
4075 error (" expected a template of type %qD, got %qD",
4076 parm, arg);
4077 }
4078
4079 val = error_mark_node;
4080 }
4081 }
4082 }
4083 else
4084 val = arg;
4085 /* We only form one instance of each template specialization.
4086 Therefore, if we use a non-canonical variant (i.e., a
4087 typedef), any future messages referring to the type will use
4088 the typedef, which is confusing if those future uses do not
4089 themselves also use the typedef. */
4090 if (TYPE_P (val))
4091 val = canonical_type_variant (val);
4092 }
4093 else
4094 {
4095 tree t = tsubst (TREE_TYPE (parm), args, complain, in_decl);
4096
4097 if (invalid_nontype_parm_type_p (t, complain))
4098 return error_mark_node;
4099
4100 if (!uses_template_parms (arg) && !uses_template_parms (t))
4101 /* We used to call digest_init here. However, digest_init
4102 will report errors, which we don't want when complain
4103 is zero. More importantly, digest_init will try too
4104 hard to convert things: for example, `0' should not be
4105 converted to pointer type at this point according to
4106 the standard. Accepting this is not merely an
4107 extension, since deciding whether or not these
4108 conversions can occur is part of determining which
4109 function template to call, or whether a given explicit
4110 argument specification is valid. */
4111 val = convert_nontype_argument (t, arg);
4112 else
4113 val = arg;
4114
4115 if (val == NULL_TREE)
4116 val = error_mark_node;
4117 else if (val == error_mark_node && (complain & tf_error))
4118 error ("could not convert template argument %qE to %qT", arg, t);
4119 }
4120
4121 return val;
4122}
4123
4124/* Convert all template arguments to their appropriate types, and
4125 return a vector containing the innermost resulting template
4126 arguments. If any error occurs, return error_mark_node. Error and
4127 warning messages are issued under control of COMPLAIN.
4128
4129 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
4130 for arguments not specified in ARGS. Otherwise, if
4131 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
4132 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
4133 USE_DEFAULT_ARGS is false, then all arguments must be specified in
4134 ARGS. */
4135
4136static tree
4137coerce_template_parms (tree parms,
4138 tree args,
4139 tree in_decl,
4140 tsubst_flags_t complain,
4141 bool require_all_args,
4142 bool use_default_args)
4143{
4144 int nparms, nargs, i, lost = 0;
4145 tree inner_args;
4146 tree new_args;
4147 tree new_inner_args;
4148 bool saved_skip_evaluation;
4149
4150 inner_args = INNERMOST_TEMPLATE_ARGS (args);
4151 nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0;
4152 nparms = TREE_VEC_LENGTH (parms);
4153
4154 if (nargs > nparms
4155 || (nargs < nparms
4156 && require_all_args
4157 && (!use_default_args
4158 || (TREE_VEC_ELT (parms, nargs) != error_mark_node
4159 && !TREE_PURPOSE (TREE_VEC_ELT (parms, nargs))))))
4160 {
4161 if (complain & tf_error)
4162 {
4163 error ("wrong number of template arguments (%d, should be %d)",
4164 nargs, nparms);
4165
4166 if (in_decl)
4167 error ("provided for %q+D", in_decl);
4168 }
4169
4170 return error_mark_node;
4171 }
4172
4173 /* We need to evaluate the template arguments, even though this
4174 template-id may be nested within a "sizeof". */
4175 saved_skip_evaluation = skip_evaluation;
4176 skip_evaluation = false;
4177 new_inner_args = make_tree_vec (nparms);
4178 new_args = add_outermost_template_args (args, new_inner_args);
4179 for (i = 0; i < nparms; i++)
4180 {
4181 tree arg;
4182 tree parm;
4183
4184 /* Get the Ith template parameter. */
4185 parm = TREE_VEC_ELT (parms, i);
4186
4187 if (parm == error_mark_node)
4188 {
4189 TREE_VEC_ELT (new_inner_args, i) = error_mark_node;
4190 continue;
4191 }
4192
4193 /* Calculate the Ith argument. */
4194 if (i < nargs)
4195 arg = TREE_VEC_ELT (inner_args, i);
4196 else if (require_all_args)
4197 /* There must be a default arg in this case. */
4198 arg = tsubst_template_arg (TREE_PURPOSE (parm), new_args,
4199 complain, in_decl);
4200 else
4201 break;
4202
4203 gcc_assert (arg);
4204 if (arg == error_mark_node)
4205 {
4206 if (complain & tf_error)
4207 error ("template argument %d is invalid", i + 1);
4208 }
4209 else
4210 arg = convert_template_argument (TREE_VALUE (parm),
4211 arg, new_args, complain, i,
4212 in_decl);
4213
4214 if (arg == error_mark_node)
4215 lost++;
4216 TREE_VEC_ELT (new_inner_args, i) = arg;
4217 }
4218 skip_evaluation = saved_skip_evaluation;
4219
4220 if (lost)
4221 return error_mark_node;
4222
4223 return new_inner_args;
4224}
4225
4226/* Returns 1 if template args OT and NT are equivalent. */
4227
4228static int
4229template_args_equal (tree ot, tree nt)
4230{
4231 if (nt == ot)
4232 return 1;
4233
4234 if (TREE_CODE (nt) == TREE_VEC)
4235 /* For member templates */
4236 return TREE_CODE (ot) == TREE_VEC && comp_template_args (ot, nt);
4237 else if (TYPE_P (nt))
4238 return TYPE_P (ot) && same_type_p (ot, nt);
4239 else if (TREE_CODE (ot) == TREE_VEC || TYPE_P (ot))
4240 return 0;
4241 else
4242 return cp_tree_equal (ot, nt);
4243}
4244
4245/* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
4246 of template arguments. Returns 0 otherwise. */
4247
4248int
4249comp_template_args (tree oldargs, tree newargs)
4250{
4251 int i;
4252
4253 if (TREE_VEC_LENGTH (oldargs) != TREE_VEC_LENGTH (newargs))
4254 return 0;
4255
4256 for (i = 0; i < TREE_VEC_LENGTH (oldargs); ++i)
4257 {
4258 tree nt = TREE_VEC_ELT (newargs, i);
4259 tree ot = TREE_VEC_ELT (oldargs, i);
4260
4261 if (! template_args_equal (ot, nt))
4262 return 0;
4263 }
4264 return 1;
4265}
4266
4267/* Given class template name and parameter list, produce a user-friendly name
4268 for the instantiation. */
4269
4270static char *
4271mangle_class_name_for_template (const char* name, tree parms, tree arglist)
4272{
4273 static struct obstack scratch_obstack;
4274 static char *scratch_firstobj;
4275 int i, nparms;
4276
4277 if (!scratch_firstobj)
4278 gcc_obstack_init (&scratch_obstack);
4279 else
4280 obstack_free (&scratch_obstack, scratch_firstobj);
4281 scratch_firstobj = (char *) obstack_alloc (&scratch_obstack, 1);
4282
4283#define ccat(C) obstack_1grow (&scratch_obstack, (C));
4284#define cat(S) obstack_grow (&scratch_obstack, (S), strlen (S))
4285
4286 cat (name);
4287 ccat ('<');
4288 nparms = TREE_VEC_LENGTH (parms);
4289 arglist = INNERMOST_TEMPLATE_ARGS (arglist);
4290 gcc_assert (nparms == TREE_VEC_LENGTH (arglist));
4291 for (i = 0; i < nparms; i++)
4292 {
4293 tree parm;
4294 tree arg;
4295
4296 parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
4297 arg = TREE_VEC_ELT (arglist, i);
4298
4299 if (parm == error_mark_node)
4300 continue;
4301
4302 if (i)
4303 ccat (',');
4304
4305 if (TREE_CODE (parm) == TYPE_DECL)
4306 {
4307 cat (type_as_string (arg, TFF_CHASE_TYPEDEF));
4308 continue;
4309 }
4310 else if (TREE_CODE (parm) == TEMPLATE_DECL)
4311 {
4312 if (TREE_CODE (arg) == TEMPLATE_DECL)
4313 {
4314 /* Already substituted with real template. Just output
4315 the template name here */
4316 tree context = DECL_CONTEXT (arg);
4317 if (context)
4318 {
4319 /* The template may be defined in a namespace, or
4320 may be a member template. */
4321 gcc_assert (TREE_CODE (context) == NAMESPACE_DECL
4322 || CLASS_TYPE_P (context));
4323 cat (decl_as_string (DECL_CONTEXT (arg),
4324 TFF_PLAIN_IDENTIFIER));
4325 cat ("::");
4326 }
4327 cat (IDENTIFIER_POINTER (DECL_NAME (arg)));
4328 }
4329 else
4330 /* Output the parameter declaration. */
4331 cat (type_as_string (arg, TFF_CHASE_TYPEDEF));
4332 continue;
4333 }
4334 else
4335 gcc_assert (TREE_CODE (parm) == PARM_DECL);
4336
4337 /* No need to check arglist against parmlist here; we did that
4338 in coerce_template_parms, called from lookup_template_class. */
4339 cat (expr_as_string (arg, TFF_PLAIN_IDENTIFIER));
4340 }
4341 {
4342 char *bufp = obstack_next_free (&scratch_obstack);
4343 int offset = 0;
4344 while (bufp[offset - 1] == ' ')
4345 offset--;
4346 obstack_blank_fast (&scratch_obstack, offset);
4347
4348 /* B<C<char> >, not B<C<char>> */
4349 if (bufp[offset - 1] == '>')
4350 ccat (' ');
4351 }
4352 ccat ('>');
4353 ccat ('\0');
4354 return (char *) obstack_base (&scratch_obstack);
4355}
4356
4357static tree
4358classtype_mangled_name (tree t)
4359{
4360 if (CLASSTYPE_TEMPLATE_INFO (t)
4361 /* Specializations have already had their names set up in
4362 lookup_template_class. */
4363 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
4364 {
4365 tree tmpl = most_general_template (CLASSTYPE_TI_TEMPLATE (t));
4366
4367 /* For non-primary templates, the template parameters are
4368 implicit from their surrounding context. */
4369 if (PRIMARY_TEMPLATE_P (tmpl))
4370 {
4371 tree name = DECL_NAME (tmpl);
4372 char *mangled_name = mangle_class_name_for_template
4373 (IDENTIFIER_POINTER (name),
4374 DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
4375 CLASSTYPE_TI_ARGS (t));
4376 tree id = get_identifier (mangled_name);
4377 IDENTIFIER_TEMPLATE (id) = name;
4378 return id;
4379 }
4380 }
4381
4382 return TYPE_IDENTIFIER (t);
4383}
4384
4385static void
4386add_pending_template (tree d)
4387{
4388 tree ti = (TYPE_P (d)
4389 ? CLASSTYPE_TEMPLATE_INFO (d)
4390 : DECL_TEMPLATE_INFO (d));
4391 tree pt;
4392 int level;
4393
4394 if (TI_PENDING_TEMPLATE_FLAG (ti))
4395 return;
4396
4397 /* We are called both from instantiate_decl, where we've already had a
4398 tinst_level pushed, and instantiate_template, where we haven't.
4399 Compensate. */
4400 level = !(current_tinst_level && TINST_DECL (current_tinst_level) == d);
4401
4402 if (level)
4403 push_tinst_level (d);
4404
4405 pt = tree_cons (current_tinst_level, d, NULL_TREE);
4406 if (last_pending_template)
4407 TREE_CHAIN (last_pending_template) = pt;
4408 else
4409 pending_templates = pt;
4410
4411 last_pending_template = pt;
4412
4413 TI_PENDING_TEMPLATE_FLAG (ti) = 1;
4414
4415 if (level)
4416 pop_tinst_level ();
4417}
4418
4419
4420/* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
4421 ARGLIST. Valid choices for FNS are given in the cp-tree.def
4422 documentation for TEMPLATE_ID_EXPR. */
4423
4424tree
4425lookup_template_function (tree fns, tree arglist)
4426{
4427 tree type;
4428
4429 if (fns == error_mark_node || arglist == error_mark_node)
4430 return error_mark_node;
4431
4432 gcc_assert (!arglist || TREE_CODE (arglist) == TREE_VEC);
4433 gcc_assert (fns && (is_overloaded_fn (fns)
4434 || TREE_CODE (fns) == IDENTIFIER_NODE));
4435
4436 if (BASELINK_P (fns))
4437 {
4438 BASELINK_FUNCTIONS (fns) = build2 (TEMPLATE_ID_EXPR,
4439 unknown_type_node,
4440 BASELINK_FUNCTIONS (fns),
4441 arglist);
4442 return fns;
4443 }
4444
4445 type = TREE_TYPE (fns);
4446 if (TREE_CODE (fns) == OVERLOAD || !type)
4447 type = unknown_type_node;
4448
4449 return build2 (TEMPLATE_ID_EXPR, type, fns, arglist);
4450}
4451
4452/* Within the scope of a template class S<T>, the name S gets bound
4453 (in build_self_reference) to a TYPE_DECL for the class, not a
4454 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
4455 or one of its enclosing classes, and that type is a template,
4456 return the associated TEMPLATE_DECL. Otherwise, the original
4457 DECL is returned. */
4458
4459tree
4460maybe_get_template_decl_from_type_decl (tree decl)
4461{
4462 return (decl != NULL_TREE
4463 && TREE_CODE (decl) == TYPE_DECL
4464 && DECL_ARTIFICIAL (decl)
4465 && CLASS_TYPE_P (TREE_TYPE (decl))
4466 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl)))
4467 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl)) : decl;
4468}
4469
4470/* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
4471 parameters, find the desired type.
4472
4473 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
4474
4475 IN_DECL, if non-NULL, is the template declaration we are trying to
4476 instantiate.
4477
4478 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
4479 the class we are looking up.
4480
4481 Issue error and warning messages under control of COMPLAIN.
4482
4483 If the template class is really a local class in a template
4484 function, then the FUNCTION_CONTEXT is the function in which it is
4485 being instantiated.
4486
4487 ??? Note that this function is currently called *twice* for each
4488 template-id: the first time from the parser, while creating the
4489 incomplete type (finish_template_type), and the second type during the
4490 real instantiation (instantiate_template_class). This is surely something
4491 that we want to avoid. It also causes some problems with argument
4492 coercion (see convert_nontype_argument for more information on this). */
4493
4494tree
4495lookup_template_class (tree d1,
4496 tree arglist,
4497 tree in_decl,
4498 tree context,
4499 int entering_scope,
4500 tsubst_flags_t complain)
4501{
4502 tree template = NULL_TREE, parmlist;
4503 tree t;
4504
4505 timevar_push (TV_NAME_LOOKUP);
4506
4507 if (TREE_CODE (d1) == IDENTIFIER_NODE)
4508 {
4509 tree value = innermost_non_namespace_value (d1);
4510 if (value && DECL_TEMPLATE_TEMPLATE_PARM_P (value))
4511 template = value;
4512 else
4513 {
4514 if (context)
4515 push_decl_namespace (context);
4516 template = lookup_name (d1);
4517 template = maybe_get_template_decl_from_type_decl (template);
4518 if (context)
4519 pop_decl_namespace ();
4520 }
4521 if (template)
4522 context = DECL_CONTEXT (template);
4523 }
4524 else if (TREE_CODE (d1) == TYPE_DECL && IS_AGGR_TYPE (TREE_TYPE (d1)))
4525 {
4526 tree type = TREE_TYPE (d1);
4527
4528 /* If we are declaring a constructor, say A<T>::A<T>, we will get
4529 an implicit typename for the second A. Deal with it. */
4530 if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
4531 type = TREE_TYPE (type);
4532
4533 if (CLASSTYPE_TEMPLATE_INFO (type))
4534 {
4535 template = CLASSTYPE_TI_TEMPLATE (type);
4536 d1 = DECL_NAME (template);
4537 }
4538 }
4539 else if (TREE_CODE (d1) == ENUMERAL_TYPE
4540 || (TYPE_P (d1) && IS_AGGR_TYPE (d1)))
4541 {
4542 template = TYPE_TI_TEMPLATE (d1);
4543 d1 = DECL_NAME (template);
4544 }
4545 else if (TREE_CODE (d1) == TEMPLATE_DECL
4546 && TREE_CODE (DECL_TEMPLATE_RESULT (d1)) == TYPE_DECL)
4547 {
4548 template = d1;
4549 d1 = DECL_NAME (template);
4550 context = DECL_CONTEXT (template);
4551 }
4552
4553 /* Issue an error message if we didn't find a template. */
4554 if (! template)
4555 {
4556 if (complain & tf_error)
4557 error ("%qT is not a template", d1);
4558 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4559 }
4560
4561 if (TREE_CODE (template) != TEMPLATE_DECL
4562 /* Make sure it's a user visible template, if it was named by
4563 the user. */
4564 || ((complain & tf_user) && !DECL_TEMPLATE_PARM_P (template)
4565 && !PRIMARY_TEMPLATE_P (template)))
4566 {
4567 if (complain & tf_error)
4568 {
4569 error ("non-template type %qT used as a template", d1);
4570 if (in_decl)
4571 error ("for template declaration %q+D", in_decl);
4572 }
4573 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4574 }
4575
4576 complain &= ~tf_user;
4577
4578 if (DECL_TEMPLATE_TEMPLATE_PARM_P (template))
4579 {
4580 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
4581 template arguments */
4582
4583 tree parm;
4584 tree arglist2;
4585
4586 parmlist = DECL_INNERMOST_TEMPLATE_PARMS (template);
4587
4588 /* Consider an example where a template template parameter declared as
4589
4590 template <class T, class U = std::allocator<T> > class TT
4591
4592 The template parameter level of T and U are one level larger than
4593 of TT. To proper process the default argument of U, say when an
4594 instantiation `TT<int>' is seen, we need to build the full
4595 arguments containing {int} as the innermost level. Outer levels,
4596 available when not appearing as default template argument, can be
4597 obtained from `current_template_args ()'.
4598
4599 Suppose that TT is later substituted with std::vector. The above
4600 instantiation is `TT<int, std::allocator<T> >' with TT at
4601 level 1, and T at level 2, while the template arguments at level 1
4602 becomes {std::vector} and the inner level 2 is {int}. */
4603
4604 if (current_template_parms)
4605 arglist = add_to_template_args (current_template_args (), arglist);
4606
4607 arglist2 = coerce_template_parms (parmlist, arglist, template,
4608 complain,
4609 /*require_all_args=*/true,
4610 /*use_default_args=*/true);
4611 if (arglist2 == error_mark_node
4612 || (!uses_template_parms (arglist2)
4613 && check_instantiated_args (template, arglist2, complain)))
4614 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4615
4616 parm = bind_template_template_parm (TREE_TYPE (template), arglist2);
4617 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, parm);
4618 }
4619 else
4620 {
4621 tree template_type = TREE_TYPE (template);
4622 tree gen_tmpl;
4623 tree type_decl;
4624 tree found = NULL_TREE;
4625 int arg_depth;
4626 int parm_depth;
4627 int is_partial_instantiation;
4628
4629 gen_tmpl = most_general_template (template);
4630 parmlist = DECL_TEMPLATE_PARMS (gen_tmpl);
4631 parm_depth = TMPL_PARMS_DEPTH (parmlist);
4632 arg_depth = TMPL_ARGS_DEPTH (arglist);
4633
4634 if (arg_depth == 1 && parm_depth > 1)
4635 {
4636 /* We've been given an incomplete set of template arguments.
4637 For example, given:
4638
4639 template <class T> struct S1 {
4640 template <class U> struct S2 {};
4641 template <class U> struct S2<U*> {};
4642 };
4643
4644 we will be called with an ARGLIST of `U*', but the
4645 TEMPLATE will be `template <class T> template
4646 <class U> struct S1<T>::S2'. We must fill in the missing
4647 arguments. */
4648 arglist
4649 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (template)),
4650 arglist);
4651 arg_depth = TMPL_ARGS_DEPTH (arglist);
4652 }
4653
4654 /* Now we should have enough arguments. */
4655 gcc_assert (parm_depth == arg_depth);
4656
4657 /* From here on, we're only interested in the most general
4658 template. */
4659 template = gen_tmpl;
4660
4661 /* Calculate the BOUND_ARGS. These will be the args that are
4662 actually tsubst'd into the definition to create the
4663 instantiation. */
4664 if (parm_depth > 1)
4665 {
4666 /* We have multiple levels of arguments to coerce, at once. */
4667 int i;
4668 int saved_depth = TMPL_ARGS_DEPTH (arglist);
4669
4670 tree bound_args = make_tree_vec (parm_depth);
4671
4672 for (i = saved_depth,
4673 t = DECL_TEMPLATE_PARMS (template);
4674 i > 0 && t != NULL_TREE;
4675 --i, t = TREE_CHAIN (t))
4676 {
4677 tree a = coerce_template_parms (TREE_VALUE (t),
4678 arglist, template,
4679 complain,
4680 /*require_all_args=*/true,
4681 /*use_default_args=*/true);
4682
4683 /* Don't process further if one of the levels fails. */
4684 if (a == error_mark_node)
4685 {
4686 /* Restore the ARGLIST to its full size. */
4687 TREE_VEC_LENGTH (arglist) = saved_depth;
4688 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4689 }
4690
4691 SET_TMPL_ARGS_LEVEL (bound_args, i, a);
4692
4693 /* We temporarily reduce the length of the ARGLIST so
4694 that coerce_template_parms will see only the arguments
4695 corresponding to the template parameters it is
4696 examining. */
4697 TREE_VEC_LENGTH (arglist)--;
4698 }
4699
4700 /* Restore the ARGLIST to its full size. */
4701 TREE_VEC_LENGTH (arglist) = saved_depth;
4702
4703 arglist = bound_args;
4704 }
4705 else
4706 arglist
4707 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist),
4708 INNERMOST_TEMPLATE_ARGS (arglist),
4709 template,
4710 complain,
4711 /*require_all_args=*/true,
4712 /*use_default_args=*/true);
4713
4714 if (arglist == error_mark_node)
4715 /* We were unable to bind the arguments. */
4716 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4717
4718 /* In the scope of a template class, explicit references to the
4719 template class refer to the type of the template, not any
4720 instantiation of it. For example, in:
4721
4722 template <class T> class C { void f(C<T>); }
4723
4724 the `C<T>' is just the same as `C'. Outside of the
4725 class, however, such a reference is an instantiation. */
4726 if (comp_template_args (TYPE_TI_ARGS (template_type),
4727 arglist))
4728 {
4729 found = template_type;
4730
4731 if (!entering_scope && PRIMARY_TEMPLATE_P (template))
4732 {
4733 tree ctx;
4734
4735 for (ctx = current_class_type;
4736 ctx && TREE_CODE (ctx) != NAMESPACE_DECL;
4737 ctx = (TYPE_P (ctx)
4738 ? TYPE_CONTEXT (ctx)
4739 : DECL_CONTEXT (ctx)))
4740 if (TYPE_P (ctx) && same_type_p (ctx, template_type))
4741 goto found_ctx;
4742
4743 /* We're not in the scope of the class, so the
4744 TEMPLATE_TYPE is not the type we want after all. */
4745 found = NULL_TREE;
4746 found_ctx:;
4747 }
4748 }
4749 if (found)
4750 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
4751
4752 /* If we already have this specialization, return it. */
4753 found = retrieve_specialization (template, arglist,
4754 /*class_specializations_p=*/false);
4755 if (found)
4756 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
4757
4758 /* This type is a "partial instantiation" if any of the template
4759 arguments still involve template parameters. Note that we set
4760 IS_PARTIAL_INSTANTIATION for partial specializations as
4761 well. */
4762 is_partial_instantiation = uses_template_parms (arglist);
4763
4764 /* If the deduced arguments are invalid, then the binding
4765 failed. */
4766 if (!is_partial_instantiation
4767 && check_instantiated_args (template,
4768 INNERMOST_TEMPLATE_ARGS (arglist),
4769 complain))
4770 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4771
4772 if (!is_partial_instantiation
4773 && !PRIMARY_TEMPLATE_P (template)
4774 && TREE_CODE (CP_DECL_CONTEXT (template)) == NAMESPACE_DECL)
4775 {
4776 found = xref_tag_from_type (TREE_TYPE (template),
4777 DECL_NAME (template),
4778 /*tag_scope=*/ts_global);
4779 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
4780 }
4781
4782 context = tsubst (DECL_CONTEXT (template), arglist,
4783 complain, in_decl);
4784 if (!context)
4785 context = global_namespace;
4786
4787 /* Create the type. */
4788 if (TREE_CODE (template_type) == ENUMERAL_TYPE)
4789 {
4790 if (!is_partial_instantiation)
4791 {
4792 set_current_access_from_decl (TYPE_NAME (template_type));
4793 t = start_enum (TYPE_IDENTIFIER (template_type));
4794 }
4795 else
4796 /* We don't want to call start_enum for this type, since
4797 the values for the enumeration constants may involve
4798 template parameters. And, no one should be interested
4799 in the enumeration constants for such a type. */
4800 t = make_node (ENUMERAL_TYPE);
4801 }
4802 else
4803 {
4804 t = make_aggr_type (TREE_CODE (template_type));
4805 CLASSTYPE_DECLARED_CLASS (t)
4806 = CLASSTYPE_DECLARED_CLASS (template_type);
4807 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t);
4808 TYPE_FOR_JAVA (t) = TYPE_FOR_JAVA (template_type);
4809
4810 /* A local class. Make sure the decl gets registered properly. */
4811 if (context == current_function_decl)
4812 pushtag (DECL_NAME (template), t, /*tag_scope=*/ts_current);
4813 }
4814
4815 /* If we called start_enum or pushtag above, this information
4816 will already be set up. */
4817 if (!TYPE_NAME (t))
4818 {
4819 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
4820
4821 type_decl = create_implicit_typedef (DECL_NAME (template), t);
4822 DECL_CONTEXT (type_decl) = TYPE_CONTEXT (t);
4823 TYPE_STUB_DECL (t) = type_decl;
4824 DECL_SOURCE_LOCATION (type_decl)
4825 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type));
4826 }
4827 else
4828 type_decl = TYPE_NAME (t);
4829
4830 TREE_PRIVATE (type_decl)
4831 = TREE_PRIVATE (TYPE_STUB_DECL (template_type));
4832 TREE_PROTECTED (type_decl)
4833 = TREE_PROTECTED (TYPE_STUB_DECL (template_type));
4834 DECL_IN_SYSTEM_HEADER (type_decl)
4835 = DECL_IN_SYSTEM_HEADER (template);
4836 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type))
4837 {
4838 DECL_VISIBILITY_SPECIFIED (type_decl) = 1;
4839 DECL_VISIBILITY (type_decl) = CLASSTYPE_VISIBILITY (template_type);
4840 }
4841
4842 /* Set up the template information. We have to figure out which
4843 template is the immediate parent if this is a full
4844 instantiation. */
4845 if (parm_depth == 1 || is_partial_instantiation
4846 || !PRIMARY_TEMPLATE_P (template))
4847 /* This case is easy; there are no member templates involved. */
4848 found = template;
4849 else
4850 {
4851 /* This is a full instantiation of a member template. Look
4852 for a partial instantiation of which this is an instance. */
4853
4854 for (found = DECL_TEMPLATE_INSTANTIATIONS (template);
4855 found; found = TREE_CHAIN (found))
4856 {
4857 int success;
4858 tree tmpl = CLASSTYPE_TI_TEMPLATE (TREE_VALUE (found));
4859
4860 /* We only want partial instantiations, here, not
4861 specializations or full instantiations. */
4862 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_VALUE (found))
4863 || !uses_template_parms (TREE_VALUE (found)))
4864 continue;
4865
4866 /* Temporarily reduce by one the number of levels in the
4867 ARGLIST and in FOUND so as to avoid comparing the
4868 last set of arguments. */
4869 TREE_VEC_LENGTH (arglist)--;
4870 TREE_VEC_LENGTH (TREE_PURPOSE (found)) --;
4871
4872 /* See if the arguments match. If they do, then TMPL is
4873 the partial instantiation we want. */
4874 success = comp_template_args (TREE_PURPOSE (found), arglist);
4875
4876 /* Restore the argument vectors to their full size. */
4877 TREE_VEC_LENGTH (arglist)++;
4878 TREE_VEC_LENGTH (TREE_PURPOSE (found))++;
4879
4880 if (success)
4881 {
4882 found = tmpl;
4883 break;
4884 }
4885 }
4886
4887 if (!found)
4888 {
4889 /* There was no partial instantiation. This happens
4890 where C<T> is a member template of A<T> and it's used
4891 in something like
4892
4893 template <typename T> struct B { A<T>::C<int> m; };
4894 B<float>;
4895
4896 Create the partial instantiation.
4897 */
4898 TREE_VEC_LENGTH (arglist)--;
4899 found = tsubst (template, arglist, complain, NULL_TREE);
4900 TREE_VEC_LENGTH (arglist)++;
4901 }
4902 }
4903
4904 SET_TYPE_TEMPLATE_INFO (t, tree_cons (found, arglist, NULL_TREE));
4905 DECL_TEMPLATE_INSTANTIATIONS (template)
4906 = tree_cons (arglist, t,
4907 DECL_TEMPLATE_INSTANTIATIONS (template));
4908
4909 if (TREE_CODE (t) == ENUMERAL_TYPE
4910 && !is_partial_instantiation)
4911 /* Now that the type has been registered on the instantiations
4912 list, we set up the enumerators. Because the enumeration
4913 constants may involve the enumeration type itself, we make
4914 sure to register the type first, and then create the
4915 constants. That way, doing tsubst_expr for the enumeration
4916 constants won't result in recursive calls here; we'll find
4917 the instantiation and exit above. */
4918 tsubst_enum (template_type, t, arglist);
4919
4920 /* Reset the name of the type, now that CLASSTYPE_TEMPLATE_INFO
4921 is set up. */
4922 if (TREE_CODE (t) != ENUMERAL_TYPE)
4923 DECL_NAME (type_decl) = classtype_mangled_name (t);
4924 if (is_partial_instantiation)
4925 /* If the type makes use of template parameters, the
4926 code that generates debugging information will crash. */
4927 DECL_IGNORED_P (TYPE_STUB_DECL (t)) = 1;
4928
4929 /* Possibly limit visibility based on template args. */
4930 TREE_PUBLIC (type_decl) = 1;
4931 determine_visibility (type_decl);
4932
4933 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4934 }
4935 timevar_pop (TV_NAME_LOOKUP);
4936}
4937
4938struct pair_fn_data
4939{
4940 tree_fn_t fn;
4941 void *data;
4942 struct pointer_set_t *visited;
4943};
4944
4945/* Called from for_each_template_parm via walk_tree. */
4946
4947static tree
4948for_each_template_parm_r (tree *tp, int *walk_subtrees, void *d)
4949{
4950 tree t = *tp;
4951 struct pair_fn_data *pfd = (struct pair_fn_data *) d;
4952 tree_fn_t fn = pfd->fn;
4953 void *data = pfd->data;
4954
4955 if (TYPE_P (t)
4956 && for_each_template_parm (TYPE_CONTEXT (t), fn, data, pfd->visited))
4957 return error_mark_node;
4958
4959 switch (TREE_CODE (t))
4960 {
4961 case RECORD_TYPE:
4962 if (TYPE_PTRMEMFUNC_P (t))
4963 break;
4964 /* Fall through. */
4965
4966 case UNION_TYPE:
4967 case ENUMERAL_TYPE:
4968 if (!TYPE_TEMPLATE_INFO (t))
4969 *walk_subtrees = 0;
4970 else if (for_each_template_parm (TREE_VALUE (TYPE_TEMPLATE_INFO (t)),
4971 fn, data, pfd->visited))
4972 return error_mark_node;
4973 break;
4974
4975 case METHOD_TYPE:
4976 /* Since we're not going to walk subtrees, we have to do this
4977 explicitly here. */
4978 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t), fn, data,
4979 pfd->visited))
4980 return error_mark_node;
4981 /* Fall through. */
4982
4983 case FUNCTION_TYPE:
4984 /* Check the return type. */
4985 if (for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited))
4986 return error_mark_node;
4987
4988 /* Check the parameter types. Since default arguments are not
4989 instantiated until they are needed, the TYPE_ARG_TYPES may
4990 contain expressions that involve template parameters. But,
4991 no-one should be looking at them yet. And, once they're
4992 instantiated, they don't contain template parameters, so
4993 there's no point in looking at them then, either. */
4994 {
4995 tree parm;
4996
4997 for (parm = TYPE_ARG_TYPES (t); parm; parm = TREE_CHAIN (parm))
4998 if (for_each_template_parm (TREE_VALUE (parm), fn, data,
4999 pfd->visited))
5000 return error_mark_node;
5001
5002 /* Since we've already handled the TYPE_ARG_TYPES, we don't
5003 want walk_tree walking into them itself. */
5004 *walk_subtrees = 0;
5005 }
5006 break;
5007
5008 case TYPEOF_TYPE:
5009 if (for_each_template_parm (TYPE_FIELDS (t), fn, data,
5010 pfd->visited))
5011 return error_mark_node;
5012 break;
5013
5014 case FUNCTION_DECL:
5015 case VAR_DECL:
5016 if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t)
5017 && for_each_template_parm (DECL_TI_ARGS (t), fn, data,
5018 pfd->visited))
5019 return error_mark_node;
5020 /* Fall through. */
5021
5022 case PARM_DECL:
5023 case CONST_DECL:
5024 if (TREE_CODE (t) == CONST_DECL && DECL_TEMPLATE_PARM_P (t)
5025 && for_each_template_parm (DECL_INITIAL (t), fn, data,
5026 pfd->visited))
5027 return error_mark_node;
5028 if (DECL_CONTEXT (t)
5029 && for_each_template_parm (DECL_CONTEXT (t), fn, data,
5030 pfd->visited))
5031 return error_mark_node;
5032 break;
5033
5034 case BOUND_TEMPLATE_TEMPLATE_PARM:
5035 /* Record template parameters such as `T' inside `TT<T>'. */
5036 if (for_each_template_parm (TYPE_TI_ARGS (t), fn, data, pfd->visited))
5037 return error_mark_node;
5038 /* Fall through. */
5039
5040 case TEMPLATE_TEMPLATE_PARM:
5041 case TEMPLATE_TYPE_PARM:
5042 case TEMPLATE_PARM_INDEX:
5043 if (fn && (*fn)(t, data))
5044 return error_mark_node;
5045 else if (!fn)
5046 return error_mark_node;
5047 break;
5048
5049 case TEMPLATE_DECL:
5050 /* A template template parameter is encountered. */
5051 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t)
5052 && for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited))
5053 return error_mark_node;
5054
5055 /* Already substituted template template parameter */
5056 *walk_subtrees = 0;
5057 break;
5058
5059 case TYPENAME_TYPE:
5060 if (!fn
5061 || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t), fn,
5062 data, pfd->visited))
5063 return error_mark_node;
5064 break;
5065
5066 case CONSTRUCTOR:
5067 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t))
5068 && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
5069 (TREE_TYPE (t)), fn, data,
5070 pfd->visited))
5071 return error_mark_node;
5072 break;
5073
5074 case INDIRECT_REF:
5075 case COMPONENT_REF:
5076 /* If there's no type, then this thing must be some expression
5077 involving template parameters. */
5078 if (!fn && !TREE_TYPE (t))
5079 return error_mark_node;
5080 break;
5081
5082 case MODOP_EXPR:
5083 case CAST_EXPR:
5084 case REINTERPRET_CAST_EXPR:
5085 case CONST_CAST_EXPR:
5086 case STATIC_CAST_EXPR:
5087 case DYNAMIC_CAST_EXPR:
5088 case ARROW_EXPR:
5089 case DOTSTAR_EXPR:
5090 case TYPEID_EXPR:
5091 case PSEUDO_DTOR_EXPR:
5092 if (!fn)
5093 return error_mark_node;
5094 break;
5095
5096 case BASELINK:
5097 /* If we do not handle this case specially, we end up walking
5098 the BINFO hierarchy, which is circular, and therefore
5099 confuses walk_tree. */
5100 *walk_subtrees = 0;
5101 if (for_each_template_parm (BASELINK_FUNCTIONS (*tp), fn, data,
5102 pfd->visited))
5103 return error_mark_node;
5104 break;
5105
5106 default:
5107 break;
5108 }
5109
5110 /* We didn't find any template parameters we liked. */
5111 return NULL_TREE;
5112}
5113
5114/* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
5115 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
5116 call FN with the parameter and the DATA.
5117 If FN returns nonzero, the iteration is terminated, and
5118 for_each_template_parm returns 1. Otherwise, the iteration
5119 continues. If FN never returns a nonzero value, the value
5120 returned by for_each_template_parm is 0. If FN is NULL, it is
5121 considered to be the function which always returns 1. */
5122
5123static int
5124for_each_template_parm (tree t, tree_fn_t fn, void* data,
5125 struct pointer_set_t *visited)
5126{
5127 struct pair_fn_data pfd;
5128 int result;
5129
5130 /* Set up. */
5131 pfd.fn = fn;
5132 pfd.data = data;
5133
5134 /* Walk the tree. (Conceptually, we would like to walk without
5135 duplicates, but for_each_template_parm_r recursively calls
5136 for_each_template_parm, so we would need to reorganize a fair
5137 bit to use walk_tree_without_duplicates, so we keep our own
5138 visited list.) */
5139 if (visited)
5140 pfd.visited = visited;
5141 else
5142 pfd.visited = pointer_set_create ();
5143 result = walk_tree (&t,
5144 for_each_template_parm_r,
5145 &pfd,
5146 pfd.visited) != NULL_TREE;
5147
5148 /* Clean up. */
5149 if (!visited)
5150 {
5151 pointer_set_destroy (pfd.visited);
5152 pfd.visited = 0;
5153 }
5154
5155 return result;
5156}
5157
5158/* Returns true if T depends on any template parameter. */
5159
5160int
5161uses_template_parms (tree t)
5162{
5163 bool dependent_p;
5164 int saved_processing_template_decl;
5165
5166 saved_processing_template_decl = processing_template_decl;
5167 if (!saved_processing_template_decl)
5168 processing_template_decl = 1;
5169 if (TYPE_P (t))
5170 dependent_p = dependent_type_p (t);
5171 else if (TREE_CODE (t) == TREE_VEC)
5172 dependent_p = any_dependent_template_arguments_p (t);
5173 else if (TREE_CODE (t) == TREE_LIST)
5174 dependent_p = (uses_template_parms (TREE_VALUE (t))
5175 || uses_template_parms (TREE_CHAIN (t)));
5176 else if (TREE_CODE (t) == TYPE_DECL)
5177 dependent_p = dependent_type_p (TREE_TYPE (t));
5178 else if (DECL_P (t)
5179 || EXPR_P (t)
5180 || TREE_CODE (t) == TEMPLATE_PARM_INDEX
5181 || TREE_CODE (t) == OVERLOAD
5182 || TREE_CODE (t) == BASELINK
5183 || TREE_CODE (t) == IDENTIFIER_NODE
5184 || CONSTANT_CLASS_P (t))
5185 dependent_p = (type_dependent_expression_p (t)
5186 || value_dependent_expression_p (t));
5187 else
5188 {
5189 gcc_assert (t == error_mark_node);
5190 dependent_p = false;
5191 }
5192
5193 processing_template_decl = saved_processing_template_decl;
5194
5195 return dependent_p;
5196}
5197
5198/* Returns true if T depends on any template parameter with level LEVEL. */
5199
5200int
5201uses_template_parms_level (tree t, int level)
5202{
5203 return for_each_template_parm (t, template_parm_this_level_p, &level, NULL);
5204}
5205
5206static int tinst_depth;
5207extern int max_tinst_depth;
5208#ifdef GATHER_STATISTICS
5209int depth_reached;
5210#endif
5211static int tinst_level_tick;
5212static int last_template_error_tick;
5213
5214/* We're starting to instantiate D; record the template instantiation context
5215 for diagnostics and to restore it later. */
5216
5217static int
5218push_tinst_level (tree d)
5219{
5220 tree new;
5221
5222 if (tinst_depth >= max_tinst_depth)
5223 {
5224 /* If the instantiation in question still has unbound template parms,
5225 we don't really care if we can't instantiate it, so just return.
5226 This happens with base instantiation for implicit `typename'. */
5227 if (uses_template_parms (d))
5228 return 0;
5229
5230 last_template_error_tick = tinst_level_tick;
5231 error ("template instantiation depth exceeds maximum of %d (use "
5232 "-ftemplate-depth-NN to increase the maximum) instantiating %qD",
5233 max_tinst_depth, d);
5234
5235 print_instantiation_context ();
5236
5237 return 0;
5238 }
5239
5240 new = make_node (TINST_LEVEL);
5241 TINST_DECL (new) = d;
5242 TINST_LOCATION (new) = input_location;
5243 TINST_IN_SYSTEM_HEADER_P (new) = in_system_header;
5244 TREE_CHAIN (new) = current_tinst_level;
5245 current_tinst_level = new;
5246
5247 ++tinst_depth;
5248#ifdef GATHER_STATISTICS
5249 if (tinst_depth > depth_reached)
5250 depth_reached = tinst_depth;
5251#endif
5252
5253 ++tinst_level_tick;
5254 return 1;
5255}
5256
5257/* We're done instantiating this template; return to the instantiation
5258 context. */
5259
5260static void
5261pop_tinst_level (void)
5262{
5263 tree old = current_tinst_level;
5264
5265 /* Restore the filename and line number stashed away when we started
5266 this instantiation. */
5267 input_location = TINST_LOCATION (old);
5268 in_system_header = TINST_IN_SYSTEM_HEADER_P (old);
5269 current_tinst_level = TREE_CHAIN (old);
5270 --tinst_depth;
5271 ++tinst_level_tick;
5272}
5273
5274/* We're instantiating a deferred template; restore the template
5275 instantiation context in which the instantiation was requested, which
5276 is one step out from LEVEL. */
5277
5278static void
5279reopen_tinst_level (tree level)
5280{
5281 tree t;
5282
5283 tinst_depth = 0;
5284 for (t = level; t; t = TREE_CHAIN (t))
5285 ++tinst_depth;
5286
5287 current_tinst_level = level;
5288 pop_tinst_level ();
5289}
5290
| 1975 {
1976 error ("%qD is not a template function", dname);
1977 fns = error_mark_node;
1978 }
1979 else
1980 {
1981 tree fn = OVL_CURRENT (fns);
1982 if (!is_associated_namespace (CP_DECL_CONTEXT (decl),
1983 CP_DECL_CONTEXT (fn)))
1984 error ("%qD is not declared in %qD",
1985 decl, current_namespace);
1986 }
1987 }
1988
1989 declarator = lookup_template_function (fns, NULL_TREE);
1990 }
1991
1992 if (declarator == error_mark_node)
1993 return error_mark_node;
1994
1995 if (ctype != NULL_TREE && TYPE_BEING_DEFINED (ctype))
1996 {
1997 if (!explicit_instantiation)
1998 /* A specialization in class scope. This is invalid,
1999 but the error will already have been flagged by
2000 check_specialization_scope. */
2001 return error_mark_node;
2002 else
2003 {
2004 /* It's not valid to write an explicit instantiation in
2005 class scope, e.g.:
2006
2007 class C { template void f(); }
2008
2009 This case is caught by the parser. However, on
2010 something like:
2011
2012 template class C { void f(); };
2013
2014 (which is invalid) we can get here. The error will be
2015 issued later. */
2016 ;
2017 }
2018
2019 return decl;
2020 }
2021 else if (ctype != NULL_TREE
2022 && (TREE_CODE (TREE_OPERAND (declarator, 0)) ==
2023 IDENTIFIER_NODE))
2024 {
2025 /* Find the list of functions in ctype that have the same
2026 name as the declared function. */
2027 tree name = TREE_OPERAND (declarator, 0);
2028 tree fns = NULL_TREE;
2029 int idx;
2030
2031 if (constructor_name_p (name, ctype))
2032 {
2033 int is_constructor = DECL_CONSTRUCTOR_P (decl);
2034
2035 if (is_constructor ? !TYPE_HAS_CONSTRUCTOR (ctype)
2036 : !CLASSTYPE_DESTRUCTORS (ctype))
2037 {
2038 /* From [temp.expl.spec]:
2039
2040 If such an explicit specialization for the member
2041 of a class template names an implicitly-declared
2042 special member function (clause _special_), the
2043 program is ill-formed.
2044
2045 Similar language is found in [temp.explicit]. */
2046 error ("specialization of implicitly-declared special member function");
2047 return error_mark_node;
2048 }
2049
2050 name = is_constructor ? ctor_identifier : dtor_identifier;
2051 }
2052
2053 if (!DECL_CONV_FN_P (decl))
2054 {
2055 idx = lookup_fnfields_1 (ctype, name);
2056 if (idx >= 0)
2057 fns = VEC_index (tree, CLASSTYPE_METHOD_VEC (ctype), idx);
2058 }
2059 else
2060 {
2061 VEC(tree,gc) *methods;
2062 tree ovl;
2063
2064 /* For a type-conversion operator, we cannot do a
2065 name-based lookup. We might be looking for `operator
2066 int' which will be a specialization of `operator T'.
2067 So, we find *all* the conversion operators, and then
2068 select from them. */
2069 fns = NULL_TREE;
2070
2071 methods = CLASSTYPE_METHOD_VEC (ctype);
2072 if (methods)
2073 for (idx = CLASSTYPE_FIRST_CONVERSION_SLOT;
2074 VEC_iterate (tree, methods, idx, ovl);
2075 ++idx)
2076 {
2077 if (!DECL_CONV_FN_P (OVL_CURRENT (ovl)))
2078 /* There are no more conversion functions. */
2079 break;
2080
2081 /* Glue all these conversion functions together
2082 with those we already have. */
2083 for (; ovl; ovl = OVL_NEXT (ovl))
2084 fns = ovl_cons (OVL_CURRENT (ovl), fns);
2085 }
2086 }
2087
2088 if (fns == NULL_TREE)
2089 {
2090 error ("no member function %qD declared in %qT", name, ctype);
2091 return error_mark_node;
2092 }
2093 else
2094 TREE_OPERAND (declarator, 0) = fns;
2095 }
2096
2097 /* Figure out what exactly is being specialized at this point.
2098 Note that for an explicit instantiation, even one for a
2099 member function, we cannot tell apriori whether the
2100 instantiation is for a member template, or just a member
2101 function of a template class. Even if a member template is
2102 being instantiated, the member template arguments may be
2103 elided if they can be deduced from the rest of the
2104 declaration. */
2105 tmpl = determine_specialization (declarator, decl,
2106 &targs,
2107 member_specialization,
2108 template_count,
2109 tsk);
2110
2111 if (!tmpl || tmpl == error_mark_node)
2112 /* We couldn't figure out what this declaration was
2113 specializing. */
2114 return error_mark_node;
2115 else
2116 {
2117 tree gen_tmpl = most_general_template (tmpl);
2118
2119 if (explicit_instantiation)
2120 {
2121 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2122 is done by do_decl_instantiation later. */
2123
2124 int arg_depth = TMPL_ARGS_DEPTH (targs);
2125 int parm_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
2126
2127 if (arg_depth > parm_depth)
2128 {
2129 /* If TMPL is not the most general template (for
2130 example, if TMPL is a friend template that is
2131 injected into namespace scope), then there will
2132 be too many levels of TARGS. Remove some of them
2133 here. */
2134 int i;
2135 tree new_targs;
2136
2137 new_targs = make_tree_vec (parm_depth);
2138 for (i = arg_depth - parm_depth; i < arg_depth; ++i)
2139 TREE_VEC_ELT (new_targs, i - (arg_depth - parm_depth))
2140 = TREE_VEC_ELT (targs, i);
2141 targs = new_targs;
2142 }
2143
2144 return instantiate_template (tmpl, targs, tf_error);
2145 }
2146
2147 /* If we thought that the DECL was a member function, but it
2148 turns out to be specializing a static member function,
2149 make DECL a static member function as well. */
2150 if (DECL_STATIC_FUNCTION_P (tmpl)
2151 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
2152 revert_static_member_fn (decl);
2153
2154 /* If this is a specialization of a member template of a
2155 template class, we want to return the TEMPLATE_DECL, not
2156 the specialization of it. */
2157 if (tsk == tsk_template)
2158 {
2159 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
2160 DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl)) = NULL_TREE;
2161 if (have_def)
2162 {
2163 DECL_SOURCE_LOCATION (tmpl) = DECL_SOURCE_LOCATION (decl);
2164 DECL_SOURCE_LOCATION (DECL_TEMPLATE_RESULT (tmpl))
2165 = DECL_SOURCE_LOCATION (decl);
2166 /* We want to use the argument list specified in the
2167 definition, not in the original declaration. */
2168 DECL_ARGUMENTS (DECL_TEMPLATE_RESULT (tmpl))
2169 = DECL_ARGUMENTS (decl);
2170 }
2171 return tmpl;
2172 }
2173
2174 /* Set up the DECL_TEMPLATE_INFO for DECL. */
2175 DECL_TEMPLATE_INFO (decl) = tree_cons (tmpl, targs, NULL_TREE);
2176
2177 /* Inherit default function arguments from the template
2178 DECL is specializing. */
2179 copy_default_args_to_explicit_spec (decl);
2180
2181 /* This specialization has the same protection as the
2182 template it specializes. */
2183 TREE_PRIVATE (decl) = TREE_PRIVATE (gen_tmpl);
2184 TREE_PROTECTED (decl) = TREE_PROTECTED (gen_tmpl);
2185
2186 /* If DECL is a friend declaration, declared using an
2187 unqualified name, the namespace associated with DECL may
2188 have been set incorrectly. For example, in:
2189
2190 template <typename T> void f(T);
2191 namespace N {
2192 struct S { friend void f<int>(int); }
2193 }
2194
2195 we will have set the DECL_CONTEXT for the friend
2196 declaration to N, rather than to the global namespace. */
2197 if (DECL_NAMESPACE_SCOPE_P (decl))
2198 DECL_CONTEXT (decl) = DECL_CONTEXT (tmpl);
2199
2200 if (is_friend && !have_def)
2201 /* This is not really a declaration of a specialization.
2202 It's just the name of an instantiation. But, it's not
2203 a request for an instantiation, either. */
2204 SET_DECL_IMPLICIT_INSTANTIATION (decl);
2205 else if (DECL_CONSTRUCTOR_P (decl) || DECL_DESTRUCTOR_P (decl))
2206 /* This is indeed a specialization. In case of constructors
2207 and destructors, we need in-charge and not-in-charge
2208 versions in V3 ABI. */
2209 clone_function_decl (decl, /*update_method_vec_p=*/0);
2210
2211 /* Register this specialization so that we can find it
2212 again. */
2213 decl = register_specialization (decl, gen_tmpl, targs, is_friend);
2214 }
2215 }
2216
2217 return decl;
2218}
2219
2220/* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2221 parameters. These are represented in the same format used for
2222 DECL_TEMPLATE_PARMS. */
2223
2224int
2225comp_template_parms (tree parms1, tree parms2)
2226{
2227 tree p1;
2228 tree p2;
2229
2230 if (parms1 == parms2)
2231 return 1;
2232
2233 for (p1 = parms1, p2 = parms2;
2234 p1 != NULL_TREE && p2 != NULL_TREE;
2235 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2))
2236 {
2237 tree t1 = TREE_VALUE (p1);
2238 tree t2 = TREE_VALUE (p2);
2239 int i;
2240
2241 gcc_assert (TREE_CODE (t1) == TREE_VEC);
2242 gcc_assert (TREE_CODE (t2) == TREE_VEC);
2243
2244 if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2))
2245 return 0;
2246
2247 for (i = 0; i < TREE_VEC_LENGTH (t2); ++i)
2248 {
2249 tree parm1 = TREE_VALUE (TREE_VEC_ELT (t1, i));
2250 tree parm2 = TREE_VALUE (TREE_VEC_ELT (t2, i));
2251
2252 /* If either of the template parameters are invalid, assume
2253 they match for the sake of error recovery. */
2254 if (parm1 == error_mark_node || parm2 == error_mark_node)
2255 return 1;
2256
2257 if (TREE_CODE (parm1) != TREE_CODE (parm2))
2258 return 0;
2259
2260 if (TREE_CODE (parm1) == TEMPLATE_TYPE_PARM)
2261 continue;
2262 else if (!same_type_p (TREE_TYPE (parm1), TREE_TYPE (parm2)))
2263 return 0;
2264 }
2265 }
2266
2267 if ((p1 != NULL_TREE) != (p2 != NULL_TREE))
2268 /* One set of parameters has more parameters lists than the
2269 other. */
2270 return 0;
2271
2272 return 1;
2273}
2274
2275/* Complain if DECL shadows a template parameter.
2276
2277 [temp.local]: A template-parameter shall not be redeclared within its
2278 scope (including nested scopes). */
2279
2280void
2281check_template_shadow (tree decl)
2282{
2283 tree olddecl;
2284
2285 /* If we're not in a template, we can't possibly shadow a template
2286 parameter. */
2287 if (!current_template_parms)
2288 return;
2289
2290 /* Figure out what we're shadowing. */
2291 if (TREE_CODE (decl) == OVERLOAD)
2292 decl = OVL_CURRENT (decl);
2293 olddecl = innermost_non_namespace_value (DECL_NAME (decl));
2294
2295 /* If there's no previous binding for this name, we're not shadowing
2296 anything, let alone a template parameter. */
2297 if (!olddecl)
2298 return;
2299
2300 /* If we're not shadowing a template parameter, we're done. Note
2301 that OLDDECL might be an OVERLOAD (or perhaps even an
2302 ERROR_MARK), so we can't just blithely assume it to be a _DECL
2303 node. */
2304 if (!DECL_P (olddecl) || !DECL_TEMPLATE_PARM_P (olddecl))
2305 return;
2306
2307 /* We check for decl != olddecl to avoid bogus errors for using a
2308 name inside a class. We check TPFI to avoid duplicate errors for
2309 inline member templates. */
2310 if (decl == olddecl
2311 || TEMPLATE_PARMS_FOR_INLINE (current_template_parms))
2312 return;
2313
2314 error ("declaration of %q+#D", decl);
2315 error (" shadows template parm %q+#D", olddecl);
2316}
2317
2318/* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
2319 ORIG_LEVEL, DECL, and TYPE. */
2320
2321static tree
2322build_template_parm_index (int index,
2323 int level,
2324 int orig_level,
2325 tree decl,
2326 tree type)
2327{
2328 tree t = make_node (TEMPLATE_PARM_INDEX);
2329 TEMPLATE_PARM_IDX (t) = index;
2330 TEMPLATE_PARM_LEVEL (t) = level;
2331 TEMPLATE_PARM_ORIG_LEVEL (t) = orig_level;
2332 TEMPLATE_PARM_DECL (t) = decl;
2333 TREE_TYPE (t) = type;
2334 TREE_CONSTANT (t) = TREE_CONSTANT (decl);
2335 TREE_INVARIANT (t) = TREE_INVARIANT (decl);
2336 TREE_READONLY (t) = TREE_READONLY (decl);
2337
2338 return t;
2339}
2340
2341/* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
2342 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
2343 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
2344 new one is created. */
2345
2346static tree
2347reduce_template_parm_level (tree index, tree type, int levels)
2348{
2349 if (TEMPLATE_PARM_DESCENDANTS (index) == NULL_TREE
2350 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index))
2351 != TEMPLATE_PARM_LEVEL (index) - levels))
2352 {
2353 tree orig_decl = TEMPLATE_PARM_DECL (index);
2354 tree decl, t;
2355
2356 decl = build_decl (TREE_CODE (orig_decl), DECL_NAME (orig_decl), type);
2357 TREE_CONSTANT (decl) = TREE_CONSTANT (orig_decl);
2358 TREE_INVARIANT (decl) = TREE_INVARIANT (orig_decl);
2359 TREE_READONLY (decl) = TREE_READONLY (orig_decl);
2360 DECL_ARTIFICIAL (decl) = 1;
2361 SET_DECL_TEMPLATE_PARM_P (decl);
2362
2363 t = build_template_parm_index (TEMPLATE_PARM_IDX (index),
2364 TEMPLATE_PARM_LEVEL (index) - levels,
2365 TEMPLATE_PARM_ORIG_LEVEL (index),
2366 decl, type);
2367 TEMPLATE_PARM_DESCENDANTS (index) = t;
2368
2369 /* Template template parameters need this. */
2370 if (TREE_CODE (decl) != CONST_DECL)
2371 DECL_TEMPLATE_PARMS (decl)
2372 = DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index));
2373 }
2374
2375 return TEMPLATE_PARM_DESCENDANTS (index);
2376}
2377
2378/* Process information from new template parameter PARM and append it to the
2379 LIST being built. This new parameter is a non-type parameter iff
2380 IS_NON_TYPE is true. */
2381
2382tree
2383process_template_parm (tree list, tree parm, bool is_non_type)
2384{
2385 tree decl = 0;
2386 tree defval;
2387 tree err_parm_list;
2388 int idx = 0;
2389
2390 gcc_assert (TREE_CODE (parm) == TREE_LIST);
2391 defval = TREE_PURPOSE (parm);
2392
2393 if (list)
2394 {
2395 tree p = tree_last (list);
2396
2397 if (p && TREE_VALUE (p) != error_mark_node)
2398 {
2399 p = TREE_VALUE (p);
2400 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
2401 idx = TEMPLATE_TYPE_IDX (TREE_TYPE (p));
2402 else
2403 idx = TEMPLATE_PARM_IDX (DECL_INITIAL (p));
2404 }
2405
2406 ++idx;
2407 }
2408 else
2409 idx = 0;
2410
2411 if (is_non_type)
2412 {
2413 parm = TREE_VALUE (parm);
2414
2415 SET_DECL_TEMPLATE_PARM_P (parm);
2416
2417 if (TREE_TYPE (parm) == error_mark_node)
2418 {
2419 err_parm_list = build_tree_list (defval, parm);
2420 TREE_VALUE (err_parm_list) = error_mark_node;
2421 return chainon (list, err_parm_list);
2422 }
2423 else
2424 {
2425 /* [temp.param]
2426
2427 The top-level cv-qualifiers on the template-parameter are
2428 ignored when determining its type. */
2429 TREE_TYPE (parm) = TYPE_MAIN_VARIANT (TREE_TYPE (parm));
2430 if (invalid_nontype_parm_type_p (TREE_TYPE (parm), 1))
2431 {
2432 err_parm_list = build_tree_list (defval, parm);
2433 TREE_VALUE (err_parm_list) = error_mark_node;
2434 return chainon (list, err_parm_list);
2435 }
2436 }
2437
2438 /* A template parameter is not modifiable. */
2439 TREE_CONSTANT (parm) = 1;
2440 TREE_INVARIANT (parm) = 1;
2441 TREE_READONLY (parm) = 1;
2442 decl = build_decl (CONST_DECL, DECL_NAME (parm), TREE_TYPE (parm));
2443 TREE_CONSTANT (decl) = 1;
2444 TREE_INVARIANT (decl) = 1;
2445 TREE_READONLY (decl) = 1;
2446 DECL_INITIAL (parm) = DECL_INITIAL (decl)
2447 = build_template_parm_index (idx, processing_template_decl,
2448 processing_template_decl,
2449 decl, TREE_TYPE (parm));
2450 }
2451 else
2452 {
2453 tree t;
2454 parm = TREE_VALUE (TREE_VALUE (parm));
2455
2456 if (parm && TREE_CODE (parm) == TEMPLATE_DECL)
2457 {
2458 t = make_aggr_type (TEMPLATE_TEMPLATE_PARM);
2459 /* This is for distinguishing between real templates and template
2460 template parameters */
2461 TREE_TYPE (parm) = t;
2462 TREE_TYPE (DECL_TEMPLATE_RESULT (parm)) = t;
2463 decl = parm;
2464 }
2465 else
2466 {
2467 t = make_aggr_type (TEMPLATE_TYPE_PARM);
2468 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
2469 decl = build_decl (TYPE_DECL, parm, t);
2470 }
2471
2472 TYPE_NAME (t) = decl;
2473 TYPE_STUB_DECL (t) = decl;
2474 parm = decl;
2475 TEMPLATE_TYPE_PARM_INDEX (t)
2476 = build_template_parm_index (idx, processing_template_decl,
2477 processing_template_decl,
2478 decl, TREE_TYPE (parm));
2479 }
2480 DECL_ARTIFICIAL (decl) = 1;
2481 SET_DECL_TEMPLATE_PARM_P (decl);
2482 pushdecl (decl);
2483 parm = build_tree_list (defval, parm);
2484 return chainon (list, parm);
2485}
2486
2487/* The end of a template parameter list has been reached. Process the
2488 tree list into a parameter vector, converting each parameter into a more
2489 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
2490 as PARM_DECLs. */
2491
2492tree
2493end_template_parm_list (tree parms)
2494{
2495 int nparms;
2496 tree parm, next;
2497 tree saved_parmlist = make_tree_vec (list_length (parms));
2498
2499 current_template_parms
2500 = tree_cons (size_int (processing_template_decl),
2501 saved_parmlist, current_template_parms);
2502
2503 for (parm = parms, nparms = 0; parm; parm = next, nparms++)
2504 {
2505 next = TREE_CHAIN (parm);
2506 TREE_VEC_ELT (saved_parmlist, nparms) = parm;
2507 TREE_CHAIN (parm) = NULL_TREE;
2508 }
2509
2510 --processing_template_parmlist;
2511
2512 return saved_parmlist;
2513}
2514
2515/* end_template_decl is called after a template declaration is seen. */
2516
2517void
2518end_template_decl (void)
2519{
2520 reset_specialization ();
2521
2522 if (! processing_template_decl)
2523 return;
2524
2525 /* This matches the pushlevel in begin_template_parm_list. */
2526 finish_scope ();
2527
2528 --processing_template_decl;
2529 current_template_parms = TREE_CHAIN (current_template_parms);
2530}
2531
2532/* Given a template argument vector containing the template PARMS.
2533 The innermost PARMS are given first. */
2534
2535static tree
2536current_template_args (void)
2537{
2538 tree header;
2539 tree args = NULL_TREE;
2540 int length = TMPL_PARMS_DEPTH (current_template_parms);
2541 int l = length;
2542
2543 /* If there is only one level of template parameters, we do not
2544 create a TREE_VEC of TREE_VECs. Instead, we return a single
2545 TREE_VEC containing the arguments. */
2546 if (length > 1)
2547 args = make_tree_vec (length);
2548
2549 for (header = current_template_parms; header; header = TREE_CHAIN (header))
2550 {
2551 tree a = copy_node (TREE_VALUE (header));
2552 int i;
2553
2554 TREE_TYPE (a) = NULL_TREE;
2555 for (i = TREE_VEC_LENGTH (a) - 1; i >= 0; --i)
2556 {
2557 tree t = TREE_VEC_ELT (a, i);
2558
2559 /* T will be a list if we are called from within a
2560 begin/end_template_parm_list pair, but a vector directly
2561 if within a begin/end_member_template_processing pair. */
2562 if (TREE_CODE (t) == TREE_LIST)
2563 {
2564 t = TREE_VALUE (t);
2565
2566 if (t != error_mark_node)
2567 {
2568 if (TREE_CODE (t) == TYPE_DECL
2569 || TREE_CODE (t) == TEMPLATE_DECL)
2570 t = TREE_TYPE (t);
2571 else
2572 t = DECL_INITIAL (t);
2573 }
2574
2575 TREE_VEC_ELT (a, i) = t;
2576 }
2577 }
2578
2579 if (length > 1)
2580 TREE_VEC_ELT (args, --l) = a;
2581 else
2582 args = a;
2583 }
2584
2585 return args;
2586}
2587
2588/* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
2589 template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
2590 a member template. Used by push_template_decl below. */
2591
2592static tree
2593build_template_decl (tree decl, tree parms, bool member_template_p)
2594{
2595 tree tmpl = build_lang_decl (TEMPLATE_DECL, DECL_NAME (decl), NULL_TREE);
2596 DECL_TEMPLATE_PARMS (tmpl) = parms;
2597 DECL_CONTEXT (tmpl) = DECL_CONTEXT (decl);
2598 DECL_MEMBER_TEMPLATE_P (tmpl) = member_template_p;
2599 if (DECL_LANG_SPECIFIC (decl))
2600 {
2601 DECL_STATIC_FUNCTION_P (tmpl) = DECL_STATIC_FUNCTION_P (decl);
2602 DECL_CONSTRUCTOR_P (tmpl) = DECL_CONSTRUCTOR_P (decl);
2603 DECL_DESTRUCTOR_P (tmpl) = DECL_DESTRUCTOR_P (decl);
2604 DECL_NONCONVERTING_P (tmpl) = DECL_NONCONVERTING_P (decl);
2605 DECL_ASSIGNMENT_OPERATOR_P (tmpl) = DECL_ASSIGNMENT_OPERATOR_P (decl);
2606 if (DECL_OVERLOADED_OPERATOR_P (decl))
2607 SET_OVERLOADED_OPERATOR_CODE (tmpl,
2608 DECL_OVERLOADED_OPERATOR_P (decl));
2609 }
2610
2611 return tmpl;
2612}
2613
2614struct template_parm_data
2615{
2616 /* The level of the template parameters we are currently
2617 processing. */
2618 int level;
2619
2620 /* The index of the specialization argument we are currently
2621 processing. */
2622 int current_arg;
2623
2624 /* An array whose size is the number of template parameters. The
2625 elements are nonzero if the parameter has been used in any one
2626 of the arguments processed so far. */
2627 int* parms;
2628
2629 /* An array whose size is the number of template arguments. The
2630 elements are nonzero if the argument makes use of template
2631 parameters of this level. */
2632 int* arg_uses_template_parms;
2633};
2634
2635/* Subroutine of push_template_decl used to see if each template
2636 parameter in a partial specialization is used in the explicit
2637 argument list. If T is of the LEVEL given in DATA (which is
2638 treated as a template_parm_data*), then DATA->PARMS is marked
2639 appropriately. */
2640
2641static int
2642mark_template_parm (tree t, void* data)
2643{
2644 int level;
2645 int idx;
2646 struct template_parm_data* tpd = (struct template_parm_data*) data;
2647
2648 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
2649 {
2650 level = TEMPLATE_PARM_LEVEL (t);
2651 idx = TEMPLATE_PARM_IDX (t);
2652 }
2653 else
2654 {
2655 level = TEMPLATE_TYPE_LEVEL (t);
2656 idx = TEMPLATE_TYPE_IDX (t);
2657 }
2658
2659 if (level == tpd->level)
2660 {
2661 tpd->parms[idx] = 1;
2662 tpd->arg_uses_template_parms[tpd->current_arg] = 1;
2663 }
2664
2665 /* Return zero so that for_each_template_parm will continue the
2666 traversal of the tree; we want to mark *every* template parm. */
2667 return 0;
2668}
2669
2670/* Process the partial specialization DECL. */
2671
2672static tree
2673process_partial_specialization (tree decl)
2674{
2675 tree type = TREE_TYPE (decl);
2676 tree maintmpl = CLASSTYPE_TI_TEMPLATE (type);
2677 tree specargs = CLASSTYPE_TI_ARGS (type);
2678 tree inner_args = INNERMOST_TEMPLATE_ARGS (specargs);
2679 tree inner_parms = INNERMOST_TEMPLATE_PARMS (current_template_parms);
2680 tree main_inner_parms = DECL_INNERMOST_TEMPLATE_PARMS (maintmpl);
2681 int nargs = TREE_VEC_LENGTH (inner_args);
2682 int ntparms = TREE_VEC_LENGTH (inner_parms);
2683 int i;
2684 int did_error_intro = 0;
2685 struct template_parm_data tpd;
2686 struct template_parm_data tpd2;
2687
2688 /* We check that each of the template parameters given in the
2689 partial specialization is used in the argument list to the
2690 specialization. For example:
2691
2692 template <class T> struct S;
2693 template <class T> struct S<T*>;
2694
2695 The second declaration is OK because `T*' uses the template
2696 parameter T, whereas
2697
2698 template <class T> struct S<int>;
2699
2700 is no good. Even trickier is:
2701
2702 template <class T>
2703 struct S1
2704 {
2705 template <class U>
2706 struct S2;
2707 template <class U>
2708 struct S2<T>;
2709 };
2710
2711 The S2<T> declaration is actually invalid; it is a
2712 full-specialization. Of course,
2713
2714 template <class U>
2715 struct S2<T (*)(U)>;
2716
2717 or some such would have been OK. */
2718 tpd.level = TMPL_PARMS_DEPTH (current_template_parms);
2719 tpd.parms = (int *) alloca (sizeof (int) * ntparms);
2720 memset (tpd.parms, 0, sizeof (int) * ntparms);
2721
2722 tpd.arg_uses_template_parms = (int *) alloca (sizeof (int) * nargs);
2723 memset (tpd.arg_uses_template_parms, 0, sizeof (int) * nargs);
2724 for (i = 0; i < nargs; ++i)
2725 {
2726 tpd.current_arg = i;
2727 for_each_template_parm (TREE_VEC_ELT (inner_args, i),
2728 &mark_template_parm,
2729 &tpd,
2730 NULL);
2731 }
2732 for (i = 0; i < ntparms; ++i)
2733 if (tpd.parms[i] == 0)
2734 {
2735 /* One of the template parms was not used in the
2736 specialization. */
2737 if (!did_error_intro)
2738 {
2739 error ("template parameters not used in partial specialization:");
2740 did_error_intro = 1;
2741 }
2742
2743 error (" %qD", TREE_VALUE (TREE_VEC_ELT (inner_parms, i)));
2744 }
2745
2746 /* [temp.class.spec]
2747
2748 The argument list of the specialization shall not be identical to
2749 the implicit argument list of the primary template. */
2750 if (comp_template_args
2751 (inner_args,
2752 INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE
2753 (maintmpl)))))
2754 error ("partial specialization %qT does not specialize any template arguments", type);
2755
2756 /* [temp.class.spec]
2757
2758 A partially specialized non-type argument expression shall not
2759 involve template parameters of the partial specialization except
2760 when the argument expression is a simple identifier.
2761
2762 The type of a template parameter corresponding to a specialized
2763 non-type argument shall not be dependent on a parameter of the
2764 specialization. */
2765 gcc_assert (nargs == DECL_NTPARMS (maintmpl));
2766 tpd2.parms = 0;
2767 for (i = 0; i < nargs; ++i)
2768 {
2769 tree arg = TREE_VEC_ELT (inner_args, i);
2770 if (/* These first two lines are the `non-type' bit. */
2771 !TYPE_P (arg)
2772 && TREE_CODE (arg) != TEMPLATE_DECL
2773 /* This next line is the `argument expression is not just a
2774 simple identifier' condition and also the `specialized
2775 non-type argument' bit. */
2776 && TREE_CODE (arg) != TEMPLATE_PARM_INDEX)
2777 {
2778 if (tpd.arg_uses_template_parms[i])
2779 error ("template argument %qE involves template parameter(s)", arg);
2780 else
2781 {
2782 /* Look at the corresponding template parameter,
2783 marking which template parameters its type depends
2784 upon. */
2785 tree type =
2786 TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (main_inner_parms,
2787 i)));
2788
2789 if (!tpd2.parms)
2790 {
2791 /* We haven't yet initialized TPD2. Do so now. */
2792 tpd2.arg_uses_template_parms
2793 = (int *) alloca (sizeof (int) * nargs);
2794 /* The number of parameters here is the number in the
2795 main template, which, as checked in the assertion
2796 above, is NARGS. */
2797 tpd2.parms = (int *) alloca (sizeof (int) * nargs);
2798 tpd2.level =
2799 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl));
2800 }
2801
2802 /* Mark the template parameters. But this time, we're
2803 looking for the template parameters of the main
2804 template, not in the specialization. */
2805 tpd2.current_arg = i;
2806 tpd2.arg_uses_template_parms[i] = 0;
2807 memset (tpd2.parms, 0, sizeof (int) * nargs);
2808 for_each_template_parm (type,
2809 &mark_template_parm,
2810 &tpd2,
2811 NULL);
2812
2813 if (tpd2.arg_uses_template_parms [i])
2814 {
2815 /* The type depended on some template parameters.
2816 If they are fully specialized in the
2817 specialization, that's OK. */
2818 int j;
2819 for (j = 0; j < nargs; ++j)
2820 if (tpd2.parms[j] != 0
2821 && tpd.arg_uses_template_parms [j])
2822 {
2823 error ("type %qT of template argument %qE depends "
2824 "on template parameter(s)",
2825 type,
2826 arg);
2827 break;
2828 }
2829 }
2830 }
2831 }
2832 }
2833
2834 if (retrieve_specialization (maintmpl, specargs,
2835 /*class_specializations_p=*/true))
2836 /* We've already got this specialization. */
2837 return decl;
2838
2839 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)
2840 = tree_cons (specargs, inner_parms,
2841 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl));
2842 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)) = type;
2843 return decl;
2844}
2845
2846/* Check that a template declaration's use of default arguments is not
2847 invalid. Here, PARMS are the template parameters. IS_PRIMARY is
2848 nonzero if DECL is the thing declared by a primary template.
2849 IS_PARTIAL is nonzero if DECL is a partial specialization. */
2850
2851static void
2852check_default_tmpl_args (tree decl, tree parms, int is_primary, int is_partial)
2853{
2854 const char *msg;
2855 int last_level_to_check;
2856 tree parm_level;
2857
2858 /* [temp.param]
2859
2860 A default template-argument shall not be specified in a
2861 function template declaration or a function template definition, nor
2862 in the template-parameter-list of the definition of a member of a
2863 class template. */
2864
2865 if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
2866 /* You can't have a function template declaration in a local
2867 scope, nor you can you define a member of a class template in a
2868 local scope. */
2869 return;
2870
2871 if (current_class_type
2872 && !TYPE_BEING_DEFINED (current_class_type)
2873 && DECL_LANG_SPECIFIC (decl)
2874 /* If this is either a friend defined in the scope of the class
2875 or a member function. */
2876 && (DECL_FUNCTION_MEMBER_P (decl)
2877 ? same_type_p (DECL_CONTEXT (decl), current_class_type)
2878 : DECL_FRIEND_CONTEXT (decl)
2879 ? same_type_p (DECL_FRIEND_CONTEXT (decl), current_class_type)
2880 : false)
2881 /* And, if it was a member function, it really was defined in
2882 the scope of the class. */
2883 && (!DECL_FUNCTION_MEMBER_P (decl)
2884 || DECL_INITIALIZED_IN_CLASS_P (decl)))
2885 /* We already checked these parameters when the template was
2886 declared, so there's no need to do it again now. This function
2887 was defined in class scope, but we're processing it's body now
2888 that the class is complete. */
2889 return;
2890
2891 /* [temp.param]
2892
2893 If a template-parameter has a default template-argument, all
2894 subsequent template-parameters shall have a default
2895 template-argument supplied. */
2896 for (parm_level = parms; parm_level; parm_level = TREE_CHAIN (parm_level))
2897 {
2898 tree inner_parms = TREE_VALUE (parm_level);
2899 int ntparms = TREE_VEC_LENGTH (inner_parms);
2900 int seen_def_arg_p = 0;
2901 int i;
2902
2903 for (i = 0; i < ntparms; ++i)
2904 {
2905 tree parm = TREE_VEC_ELT (inner_parms, i);
2906
2907 if (parm == error_mark_node)
2908 continue;
2909
2910 if (TREE_PURPOSE (parm))
2911 seen_def_arg_p = 1;
2912 else if (seen_def_arg_p)
2913 {
2914 error ("no default argument for %qD", TREE_VALUE (parm));
2915 /* For better subsequent error-recovery, we indicate that
2916 there should have been a default argument. */
2917 TREE_PURPOSE (parm) = error_mark_node;
2918 }
2919 }
2920 }
2921
2922 if (TREE_CODE (decl) != TYPE_DECL || is_partial || !is_primary)
2923 /* For an ordinary class template, default template arguments are
2924 allowed at the innermost level, e.g.:
2925 template <class T = int>
2926 struct S {};
2927 but, in a partial specialization, they're not allowed even
2928 there, as we have in [temp.class.spec]:
2929
2930 The template parameter list of a specialization shall not
2931 contain default template argument values.
2932
2933 So, for a partial specialization, or for a function template,
2934 we look at all of them. */
2935 ;
2936 else
2937 /* But, for a primary class template that is not a partial
2938 specialization we look at all template parameters except the
2939 innermost ones. */
2940 parms = TREE_CHAIN (parms);
2941
2942 /* Figure out what error message to issue. */
2943 if (TREE_CODE (decl) == FUNCTION_DECL)
2944 msg = "default template arguments may not be used in function templates";
2945 else if (is_partial)
2946 msg = "default template arguments may not be used in partial specializations";
2947 else
2948 msg = "default argument for template parameter for class enclosing %qD";
2949
2950 if (current_class_type && TYPE_BEING_DEFINED (current_class_type))
2951 /* If we're inside a class definition, there's no need to
2952 examine the parameters to the class itself. On the one
2953 hand, they will be checked when the class is defined, and,
2954 on the other, default arguments are valid in things like:
2955 template <class T = double>
2956 struct S { template <class U> void f(U); };
2957 Here the default argument for `S' has no bearing on the
2958 declaration of `f'. */
2959 last_level_to_check = template_class_depth (current_class_type) + 1;
2960 else
2961 /* Check everything. */
2962 last_level_to_check = 0;
2963
2964 for (parm_level = parms;
2965 parm_level && TMPL_PARMS_DEPTH (parm_level) >= last_level_to_check;
2966 parm_level = TREE_CHAIN (parm_level))
2967 {
2968 tree inner_parms = TREE_VALUE (parm_level);
2969 int i;
2970 int ntparms;
2971
2972 ntparms = TREE_VEC_LENGTH (inner_parms);
2973 for (i = 0; i < ntparms; ++i)
2974 {
2975 if (TREE_VEC_ELT (inner_parms, i) == error_mark_node)
2976 continue;
2977
2978 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)))
2979 {
2980 if (msg)
2981 {
2982 error (msg, decl);
2983 msg = 0;
2984 }
2985
2986 /* Clear out the default argument so that we are not
2987 confused later. */
2988 TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)) = NULL_TREE;
2989 }
2990 }
2991
2992 /* At this point, if we're still interested in issuing messages,
2993 they must apply to classes surrounding the object declared. */
2994 if (msg)
2995 msg = "default argument for template parameter for class enclosing %qD";
2996 }
2997}
2998
2999/* Worker for push_template_decl_real, called via
3000 for_each_template_parm. DATA is really an int, indicating the
3001 level of the parameters we are interested in. If T is a template
3002 parameter of that level, return nonzero. */
3003
3004static int
3005template_parm_this_level_p (tree t, void* data)
3006{
3007 int this_level = *(int *)data;
3008 int level;
3009
3010 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
3011 level = TEMPLATE_PARM_LEVEL (t);
3012 else
3013 level = TEMPLATE_TYPE_LEVEL (t);
3014 return level == this_level;
3015}
3016
3017/* Creates a TEMPLATE_DECL for the indicated DECL using the template
3018 parameters given by current_template_args, or reuses a
3019 previously existing one, if appropriate. Returns the DECL, or an
3020 equivalent one, if it is replaced via a call to duplicate_decls.
3021
3022 If IS_FRIEND is true, DECL is a friend declaration. */
3023
3024tree
3025push_template_decl_real (tree decl, bool is_friend)
3026{
3027 tree tmpl;
3028 tree args;
3029 tree info;
3030 tree ctx;
3031 int primary;
3032 int is_partial;
3033 int new_template_p = 0;
3034 /* True if the template is a member template, in the sense of
3035 [temp.mem]. */
3036 bool member_template_p = false;
3037
3038 if (decl == error_mark_node)
3039 return decl;
3040
3041 /* See if this is a partial specialization. */
3042 is_partial = (DECL_IMPLICIT_TYPEDEF_P (decl)
3043 && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE
3044 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)));
3045
3046 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_FRIEND_P (decl))
3047 is_friend = true;
3048
3049 if (is_friend)
3050 /* For a friend, we want the context of the friend function, not
3051 the type of which it is a friend. */
3052 ctx = DECL_CONTEXT (decl);
3053 else if (CP_DECL_CONTEXT (decl)
3054 && TREE_CODE (CP_DECL_CONTEXT (decl)) != NAMESPACE_DECL)
3055 /* In the case of a virtual function, we want the class in which
3056 it is defined. */
3057 ctx = CP_DECL_CONTEXT (decl);
3058 else
3059 /* Otherwise, if we're currently defining some class, the DECL
3060 is assumed to be a member of the class. */
3061 ctx = current_scope ();
3062
3063 if (ctx && TREE_CODE (ctx) == NAMESPACE_DECL)
3064 ctx = NULL_TREE;
3065
3066 if (!DECL_CONTEXT (decl))
3067 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
3068
3069 /* See if this is a primary template. */
3070 if (is_friend && ctx)
3071 /* A friend template that specifies a class context, i.e.
3072 template <typename T> friend void A<T>::f();
3073 is not primary. */
3074 primary = 0;
3075 else
3076 primary = template_parm_scope_p ();
3077
3078 if (primary)
3079 {
3080 if (DECL_CLASS_SCOPE_P (decl))
3081 member_template_p = true;
3082 if (TREE_CODE (decl) == TYPE_DECL
3083 && ANON_AGGRNAME_P (DECL_NAME (decl)))
3084 error ("template class without a name");
3085 else if (TREE_CODE (decl) == FUNCTION_DECL)
3086 {
3087 if (DECL_DESTRUCTOR_P (decl))
3088 {
3089 /* [temp.mem]
3090
3091 A destructor shall not be a member template. */
3092 error ("destructor %qD declared as member template", decl);
3093 return error_mark_node;
3094 }
3095 if (NEW_DELETE_OPNAME_P (DECL_NAME (decl))
3096 && (!TYPE_ARG_TYPES (TREE_TYPE (decl))
3097 || TYPE_ARG_TYPES (TREE_TYPE (decl)) == void_list_node
3098 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
3099 || (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl))))
3100 == void_list_node)))
3101 {
3102 /* [basic.stc.dynamic.allocation]
3103
3104 An allocation function can be a function
3105 template. ... Template allocation functions shall
3106 have two or more parameters. */
3107 error ("invalid template declaration of %qD", decl);
3108 return error_mark_node;
3109 }
3110 }
3111 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
3112 && CLASS_TYPE_P (TREE_TYPE (decl)))
3113 /* OK */;
3114 else
3115 {
3116 error ("template declaration of %q#D", decl);
3117 return error_mark_node;
3118 }
3119 }
3120
3121 /* Check to see that the rules regarding the use of default
3122 arguments are not being violated. */
3123 check_default_tmpl_args (decl, current_template_parms,
3124 primary, is_partial);
3125
3126 if (is_partial)
3127 return process_partial_specialization (decl);
3128
3129 args = current_template_args ();
3130
3131 if (!ctx
3132 || TREE_CODE (ctx) == FUNCTION_DECL
3133 || (CLASS_TYPE_P (ctx) && TYPE_BEING_DEFINED (ctx))
3134 || (is_friend && !DECL_TEMPLATE_INFO (decl)))
3135 {
3136 if (DECL_LANG_SPECIFIC (decl)
3137 && DECL_TEMPLATE_INFO (decl)
3138 && DECL_TI_TEMPLATE (decl))
3139 tmpl = DECL_TI_TEMPLATE (decl);
3140 /* If DECL is a TYPE_DECL for a class-template, then there won't
3141 be DECL_LANG_SPECIFIC. The information equivalent to
3142 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
3143 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
3144 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
3145 && TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
3146 {
3147 /* Since a template declaration already existed for this
3148 class-type, we must be redeclaring it here. Make sure
3149 that the redeclaration is valid. */
3150 redeclare_class_template (TREE_TYPE (decl),
3151 current_template_parms);
3152 /* We don't need to create a new TEMPLATE_DECL; just use the
3153 one we already had. */
3154 tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
3155 }
3156 else
3157 {
3158 tmpl = build_template_decl (decl, current_template_parms,
3159 member_template_p);
3160 new_template_p = 1;
3161
3162 if (DECL_LANG_SPECIFIC (decl)
3163 && DECL_TEMPLATE_SPECIALIZATION (decl))
3164 {
3165 /* A specialization of a member template of a template
3166 class. */
3167 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
3168 DECL_TEMPLATE_INFO (tmpl) = DECL_TEMPLATE_INFO (decl);
3169 DECL_TEMPLATE_INFO (decl) = NULL_TREE;
3170 }
3171 }
3172 }
3173 else
3174 {
3175 tree a, t, current, parms;
3176 int i;
3177
3178 if (TREE_CODE (decl) == TYPE_DECL)
3179 {
3180 if ((IS_AGGR_TYPE_CODE (TREE_CODE (TREE_TYPE (decl)))
3181 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
3182 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
3183 && TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
3184 tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
3185 else
3186 {
3187 error ("%qD does not declare a template type", decl);
3188 return decl;
3189 }
3190 }
3191 else if (!DECL_LANG_SPECIFIC (decl) || !DECL_TEMPLATE_INFO (decl))
3192 {
3193 error ("template definition of non-template %q#D", decl);
3194 return decl;
3195 }
3196 else
3197 tmpl = DECL_TI_TEMPLATE (decl);
3198
3199 if (DECL_FUNCTION_TEMPLATE_P (tmpl)
3200 && DECL_TEMPLATE_INFO (decl) && DECL_TI_ARGS (decl)
3201 && DECL_TEMPLATE_SPECIALIZATION (decl)
3202 && DECL_MEMBER_TEMPLATE_P (tmpl))
3203 {
3204 tree new_tmpl;
3205
3206 /* The declaration is a specialization of a member
3207 template, declared outside the class. Therefore, the
3208 innermost template arguments will be NULL, so we
3209 replace them with the arguments determined by the
3210 earlier call to check_explicit_specialization. */
3211 args = DECL_TI_ARGS (decl);
3212
3213 new_tmpl
3214 = build_template_decl (decl, current_template_parms,
3215 member_template_p);
3216 DECL_TEMPLATE_RESULT (new_tmpl) = decl;
3217 TREE_TYPE (new_tmpl) = TREE_TYPE (decl);
3218 DECL_TI_TEMPLATE (decl) = new_tmpl;
3219 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl);
3220 DECL_TEMPLATE_INFO (new_tmpl)
3221 = tree_cons (tmpl, args, NULL_TREE);
3222
3223 register_specialization (new_tmpl,
3224 most_general_template (tmpl),
3225 args,
3226 is_friend);
3227 return decl;
3228 }
3229
3230 /* Make sure the template headers we got make sense. */
3231
3232 parms = DECL_TEMPLATE_PARMS (tmpl);
3233 i = TMPL_PARMS_DEPTH (parms);
3234 if (TMPL_ARGS_DEPTH (args) != i)
3235 {
3236 error ("expected %d levels of template parms for %q#D, got %d",
3237 i, decl, TMPL_ARGS_DEPTH (args));
3238 }
3239 else
3240 for (current = decl; i > 0; --i, parms = TREE_CHAIN (parms))
3241 {
3242 a = TMPL_ARGS_LEVEL (args, i);
3243 t = INNERMOST_TEMPLATE_PARMS (parms);
3244
3245 if (TREE_VEC_LENGTH (t) != TREE_VEC_LENGTH (a))
3246 {
3247 if (current == decl)
3248 error ("got %d template parameters for %q#D",
3249 TREE_VEC_LENGTH (a), decl);
3250 else
3251 error ("got %d template parameters for %q#T",
3252 TREE_VEC_LENGTH (a), current);
3253 error (" but %d required", TREE_VEC_LENGTH (t));
3254 return error_mark_node;
3255 }
3256
3257 /* Perhaps we should also check that the parms are used in the
3258 appropriate qualifying scopes in the declarator? */
3259
3260 if (current == decl)
3261 current = ctx;
3262 else
3263 current = TYPE_CONTEXT (current);
3264 }
3265 }
3266
3267 DECL_TEMPLATE_RESULT (tmpl) = decl;
3268 TREE_TYPE (tmpl) = TREE_TYPE (decl);
3269
3270 /* Push template declarations for global functions and types. Note
3271 that we do not try to push a global template friend declared in a
3272 template class; such a thing may well depend on the template
3273 parameters of the class. */
3274 if (new_template_p && !ctx
3275 && !(is_friend && template_class_depth (current_class_type) > 0))
3276 {
3277 tmpl = pushdecl_namespace_level (tmpl, is_friend);
3278 if (tmpl == error_mark_node)
3279 return error_mark_node;
3280
3281 /* Hide template friend classes that haven't been declared yet. */
3282 if (is_friend && TREE_CODE (decl) == TYPE_DECL)
3283 {
3284 DECL_ANTICIPATED (tmpl) = 1;
3285 DECL_FRIEND_P (tmpl) = 1;
3286 }
3287 }
3288
3289 if (primary)
3290 {
3291 DECL_PRIMARY_TEMPLATE (tmpl) = tmpl;
3292 if (DECL_CONV_FN_P (tmpl))
3293 {
3294 int depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
3295
3296 /* It is a conversion operator. See if the type converted to
3297 depends on innermost template operands. */
3298
3299 if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl)),
3300 depth))
3301 DECL_TEMPLATE_CONV_FN_P (tmpl) = 1;
3302 }
3303 }
3304
3305 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
3306 back to its most general template. If TMPL is a specialization,
3307 ARGS may only have the innermost set of arguments. Add the missing
3308 argument levels if necessary. */
3309 if (DECL_TEMPLATE_INFO (tmpl))
3310 args = add_outermost_template_args (DECL_TI_ARGS (tmpl), args);
3311
3312 info = tree_cons (tmpl, args, NULL_TREE);
3313
3314 if (DECL_IMPLICIT_TYPEDEF_P (decl))
3315 {
3316 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl), info);
3317 if ((!ctx || TREE_CODE (ctx) != FUNCTION_DECL)
3318 && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE
3319 /* Don't change the name if we've already set it up. */
3320 && !IDENTIFIER_TEMPLATE (DECL_NAME (decl)))
3321 DECL_NAME (decl) = classtype_mangled_name (TREE_TYPE (decl));
3322 }
3323 else if (DECL_LANG_SPECIFIC (decl))
3324 DECL_TEMPLATE_INFO (decl) = info;
3325
3326 return DECL_TEMPLATE_RESULT (tmpl);
3327}
3328
3329tree
3330push_template_decl (tree decl)
3331{
3332 return push_template_decl_real (decl, false);
3333}
3334
3335/* Called when a class template TYPE is redeclared with the indicated
3336 template PARMS, e.g.:
3337
3338 template <class T> struct S;
3339 template <class T> struct S {}; */
3340
3341bool
3342redeclare_class_template (tree type, tree parms)
3343{
3344 tree tmpl;
3345 tree tmpl_parms;
3346 int i;
3347
3348 if (!TYPE_TEMPLATE_INFO (type))
3349 {
3350 error ("%qT is not a template type", type);
3351 return false;
3352 }
3353
3354 tmpl = TYPE_TI_TEMPLATE (type);
3355 if (!PRIMARY_TEMPLATE_P (tmpl))
3356 /* The type is nested in some template class. Nothing to worry
3357 about here; there are no new template parameters for the nested
3358 type. */
3359 return true;
3360
3361 if (!parms)
3362 {
3363 error ("template specifiers not specified in declaration of %qD",
3364 tmpl);
3365 return false;
3366 }
3367
3368 parms = INNERMOST_TEMPLATE_PARMS (parms);
3369 tmpl_parms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl);
3370
3371 if (TREE_VEC_LENGTH (parms) != TREE_VEC_LENGTH (tmpl_parms))
3372 {
3373 error ("previous declaration %q+D", tmpl);
3374 error ("used %d template parameter(s) instead of %d",
3375 TREE_VEC_LENGTH (tmpl_parms),
3376 TREE_VEC_LENGTH (parms));
3377 return false;
3378 }
3379
3380 for (i = 0; i < TREE_VEC_LENGTH (tmpl_parms); ++i)
3381 {
3382 tree tmpl_parm;
3383 tree parm;
3384 tree tmpl_default;
3385 tree parm_default;
3386
3387 if (TREE_VEC_ELT (tmpl_parms, i) == error_mark_node
3388 || TREE_VEC_ELT (parms, i) == error_mark_node)
3389 continue;
3390
3391 tmpl_parm = TREE_VALUE (TREE_VEC_ELT (tmpl_parms, i));
3392 parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
3393 tmpl_default = TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i));
3394 parm_default = TREE_PURPOSE (TREE_VEC_ELT (parms, i));
3395
3396 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
3397 TEMPLATE_DECL. */
3398 if (tmpl_parm != error_mark_node
3399 && (TREE_CODE (tmpl_parm) != TREE_CODE (parm)
3400 || (TREE_CODE (tmpl_parm) != TYPE_DECL
3401 && !same_type_p (TREE_TYPE (tmpl_parm), TREE_TYPE (parm)))))
3402 {
3403 error ("template parameter %q+#D", tmpl_parm);
3404 error ("redeclared here as %q#D", parm);
3405 return false;
3406 }
3407
3408 if (tmpl_default != NULL_TREE && parm_default != NULL_TREE)
3409 {
3410 /* We have in [temp.param]:
3411
3412 A template-parameter may not be given default arguments
3413 by two different declarations in the same scope. */
3414 error ("redefinition of default argument for %q#D", parm);
3415 error ("%J original definition appeared here", tmpl_parm);
3416 return false;
3417 }
3418
3419 if (parm_default != NULL_TREE)
3420 /* Update the previous template parameters (which are the ones
3421 that will really count) with the new default value. */
3422 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i)) = parm_default;
3423 else if (tmpl_default != NULL_TREE)
3424 /* Update the new parameters, too; they'll be used as the
3425 parameters for any members. */
3426 TREE_PURPOSE (TREE_VEC_ELT (parms, i)) = tmpl_default;
3427 }
3428
3429 return true;
3430}
3431
3432/* Simplify EXPR if it is a non-dependent expression. Returns the
3433 (possibly simplified) expression. */
3434
3435tree
3436fold_non_dependent_expr (tree expr)
3437{
3438 if (expr == NULL_TREE)
3439 return NULL_TREE;
3440
3441 /* If we're in a template, but EXPR isn't value dependent, simplify
3442 it. We're supposed to treat:
3443
3444 template <typename T> void f(T[1 + 1]);
3445 template <typename T> void f(T[2]);
3446
3447 as two declarations of the same function, for example. */
3448 if (processing_template_decl
3449 && !type_dependent_expression_p (expr)
3450 && !value_dependent_expression_p (expr))
3451 {
3452 HOST_WIDE_INT saved_processing_template_decl;
3453
3454 saved_processing_template_decl = processing_template_decl;
3455 processing_template_decl = 0;
3456 expr = tsubst_copy_and_build (expr,
3457 /*args=*/NULL_TREE,
3458 tf_error,
3459 /*in_decl=*/NULL_TREE,
3460 /*function_p=*/false,
3461 /*integral_constant_expression_p=*/true);
3462 processing_template_decl = saved_processing_template_decl;
3463 }
3464 return expr;
3465}
3466
3467/* EXPR is an expression which is used in a constant-expression context.
3468 For instance, it could be a VAR_DECL with a constant initializer.
3469 Extract the innest constant expression.
3470
3471 This is basically a more powerful version of
3472 integral_constant_value, which can be used also in templates where
3473 initializers can maintain a syntactic rather than semantic form
3474 (even if they are non-dependent, for access-checking purposes). */
3475
3476static tree
3477fold_decl_constant_value (tree expr)
3478{
3479 tree const_expr = expr;
3480 do
3481 {
3482 expr = fold_non_dependent_expr (const_expr);
3483 const_expr = integral_constant_value (expr);
3484 }
3485 while (expr != const_expr);
3486
3487 return expr;
3488}
3489
3490/* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
3491 must be a function or a pointer-to-function type, as specified
3492 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
3493 and check that the resulting function has external linkage. */
3494
3495static tree
3496convert_nontype_argument_function (tree type, tree expr)
3497{
3498 tree fns = expr;
3499 tree fn, fn_no_ptr;
3500
3501 fn = instantiate_type (type, fns, tf_none);
3502 if (fn == error_mark_node)
3503 return error_mark_node;
3504
3505 fn_no_ptr = fn;
3506 if (TREE_CODE (fn_no_ptr) == ADDR_EXPR)
3507 fn_no_ptr = TREE_OPERAND (fn_no_ptr, 0);
3508 if (TREE_CODE (fn_no_ptr) == BASELINK)
3509 fn_no_ptr = BASELINK_FUNCTIONS (fn_no_ptr);
3510
3511 /* [temp.arg.nontype]/1
3512
3513 A template-argument for a non-type, non-template template-parameter
3514 shall be one of:
3515 [...]
3516 -- the address of an object or function with external linkage. */
3517 if (!DECL_EXTERNAL_LINKAGE_P (fn_no_ptr))
3518 {
3519 error ("%qE is not a valid template argument for type %qT "
3520 "because function %qD has not external linkage",
3521 expr, type, fn_no_ptr);
3522 return NULL_TREE;
3523 }
3524
3525 return fn;
3526}
3527
3528/* Attempt to convert the non-type template parameter EXPR to the
3529 indicated TYPE. If the conversion is successful, return the
3530 converted value. If the conversion is unsuccessful, return
3531 NULL_TREE if we issued an error message, or error_mark_node if we
3532 did not. We issue error messages for out-and-out bad template
3533 parameters, but not simply because the conversion failed, since we
3534 might be just trying to do argument deduction. Both TYPE and EXPR
3535 must be non-dependent.
3536
3537 The conversion follows the special rules described in
3538 [temp.arg.nontype], and it is much more strict than an implicit
3539 conversion.
3540
3541 This function is called twice for each template argument (see
3542 lookup_template_class for a more accurate description of this
3543 problem). This means that we need to handle expressions which
3544 are not valid in a C++ source, but can be created from the
3545 first call (for instance, casts to perform conversions). These
3546 hacks can go away after we fix the double coercion problem. */
3547
3548static tree
3549convert_nontype_argument (tree type, tree expr)
3550{
3551 tree expr_type;
3552
3553 /* Detect immediately string literals as invalid non-type argument.
3554 This special-case is not needed for correctness (we would easily
3555 catch this later), but only to provide better diagnostic for this
3556 common user mistake. As suggested by DR 100, we do not mention
3557 linkage issues in the diagnostic as this is not the point. */
3558 if (TREE_CODE (expr) == STRING_CST)
3559 {
3560 error ("%qE is not a valid template argument for type %qT "
3561 "because string literals can never be used in this context",
3562 expr, type);
3563 return NULL_TREE;
3564 }
3565
3566 /* If we are in a template, EXPR may be non-dependent, but still
3567 have a syntactic, rather than semantic, form. For example, EXPR
3568 might be a SCOPE_REF, rather than the VAR_DECL to which the
3569 SCOPE_REF refers. Preserving the qualifying scope is necessary
3570 so that access checking can be performed when the template is
3571 instantiated -- but here we need the resolved form so that we can
3572 convert the argument. */
3573 expr = fold_non_dependent_expr (expr);
3574 if (error_operand_p (expr))
3575 return error_mark_node;
3576 expr_type = TREE_TYPE (expr);
3577
3578 /* HACK: Due to double coercion, we can get a
3579 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
3580 which is the tree that we built on the first call (see
3581 below when coercing to reference to object or to reference to
3582 function). We just strip everything and get to the arg.
3583 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
3584 for examples. */
3585 if (TREE_CODE (expr) == NOP_EXPR)
3586 {
3587 if (TYPE_REF_OBJ_P (type) || TYPE_REFFN_P (type))
3588 {
3589 /* ??? Maybe we could use convert_from_reference here, but we
3590 would need to relax its constraints because the NOP_EXPR
3591 could actually change the type to something more cv-qualified,
3592 and this is not folded by convert_from_reference. */
3593 tree addr = TREE_OPERAND (expr, 0);
3594 gcc_assert (TREE_CODE (expr_type) == REFERENCE_TYPE);
3595 gcc_assert (TREE_CODE (addr) == ADDR_EXPR);
3596 gcc_assert (TREE_CODE (TREE_TYPE (addr)) == POINTER_TYPE);
3597 gcc_assert (same_type_ignoring_top_level_qualifiers_p
3598 (TREE_TYPE (expr_type),
3599 TREE_TYPE (TREE_TYPE (addr))));
3600
3601 expr = TREE_OPERAND (addr, 0);
3602 expr_type = TREE_TYPE (expr);
3603 }
3604
3605 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
3606 parameter is a pointer to object, through decay and
3607 qualification conversion. Let's strip everything. */
3608 else if (TYPE_PTROBV_P (type))
3609 {
3610 STRIP_NOPS (expr);
3611 gcc_assert (TREE_CODE (expr) == ADDR_EXPR);
3612 gcc_assert (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE);
3613 /* Skip the ADDR_EXPR only if it is part of the decay for
3614 an array. Otherwise, it is part of the original argument
3615 in the source code. */
3616 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == ARRAY_TYPE)
3617 expr = TREE_OPERAND (expr, 0);
3618 expr_type = TREE_TYPE (expr);
3619 }
3620 }
3621
3622 /* [temp.arg.nontype]/5, bullet 1
3623
3624 For a non-type template-parameter of integral or enumeration type,
3625 integral promotions (_conv.prom_) and integral conversions
3626 (_conv.integral_) are applied. */
3627 if (INTEGRAL_TYPE_P (type))
3628 {
3629 if (!INTEGRAL_TYPE_P (expr_type))
3630 return error_mark_node;
3631
3632 expr = fold_decl_constant_value (expr);
3633 /* Notice that there are constant expressions like '4 % 0' which
3634 do not fold into integer constants. */
3635 if (TREE_CODE (expr) != INTEGER_CST)
3636 {
3637 error ("%qE is not a valid template argument for type %qT "
3638 "because it is a non-constant expression", expr, type);
3639 return NULL_TREE;
3640 }
3641
3642 /* At this point, an implicit conversion does what we want,
3643 because we already know that the expression is of integral
3644 type. */
3645 expr = ocp_convert (type, expr, CONV_IMPLICIT, LOOKUP_PROTECT);
3646 if (expr == error_mark_node)
3647 return error_mark_node;
3648
3649 /* Conversion was allowed: fold it to a bare integer constant. */
3650 expr = fold (expr);
3651 }
3652 /* [temp.arg.nontype]/5, bullet 2
3653
3654 For a non-type template-parameter of type pointer to object,
3655 qualification conversions (_conv.qual_) and the array-to-pointer
3656 conversion (_conv.array_) are applied. */
3657 else if (TYPE_PTROBV_P (type))
3658 {
3659 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
3660
3661 A template-argument for a non-type, non-template template-parameter
3662 shall be one of: [...]
3663
3664 -- the name of a non-type template-parameter;
3665 -- the address of an object or function with external linkage, [...]
3666 expressed as "& id-expression" where the & is optional if the name
3667 refers to a function or array, or if the corresponding
3668 template-parameter is a reference.
3669
3670 Here, we do not care about functions, as they are invalid anyway
3671 for a parameter of type pointer-to-object. */
3672
3673 if (DECL_P (expr) && DECL_TEMPLATE_PARM_P (expr))
3674 /* Non-type template parameters are OK. */
3675 ;
3676 else if (TREE_CODE (expr) != ADDR_EXPR
3677 && TREE_CODE (expr_type) != ARRAY_TYPE)
3678 {
3679 if (TREE_CODE (expr) == VAR_DECL)
3680 {
3681 error ("%qD is not a valid template argument "
3682 "because %qD is a variable, not the address of "
3683 "a variable",
3684 expr, expr);
3685 return NULL_TREE;
3686 }
3687 /* Other values, like integer constants, might be valid
3688 non-type arguments of some other type. */
3689 return error_mark_node;
3690 }
3691 else
3692 {
3693 tree decl;
3694
3695 decl = ((TREE_CODE (expr) == ADDR_EXPR)
3696 ? TREE_OPERAND (expr, 0) : expr);
3697 if (TREE_CODE (decl) != VAR_DECL)
3698 {
3699 error ("%qE is not a valid template argument of type %qT "
3700 "because %qE is not a variable",
3701 expr, type, decl);
3702 return NULL_TREE;
3703 }
3704 else if (!DECL_EXTERNAL_LINKAGE_P (decl))
3705 {
3706 error ("%qE is not a valid template argument of type %qT "
3707 "because %qD does not have external linkage",
3708 expr, type, decl);
3709 return NULL_TREE;
3710 }
3711 }
3712
3713 expr = decay_conversion (expr);
3714 if (expr == error_mark_node)
3715 return error_mark_node;
3716
3717 expr = perform_qualification_conversions (type, expr);
3718 if (expr == error_mark_node)
3719 return error_mark_node;
3720 }
3721 /* [temp.arg.nontype]/5, bullet 3
3722
3723 For a non-type template-parameter of type reference to object, no
3724 conversions apply. The type referred to by the reference may be more
3725 cv-qualified than the (otherwise identical) type of the
3726 template-argument. The template-parameter is bound directly to the
3727 template-argument, which must be an lvalue. */
3728 else if (TYPE_REF_OBJ_P (type))
3729 {
3730 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type),
3731 expr_type))
3732 return error_mark_node;
3733
3734 if (!at_least_as_qualified_p (TREE_TYPE (type), expr_type))
3735 {
3736 error ("%qE is not a valid template argument for type %qT "
3737 "because of conflicts in cv-qualification", expr, type);
3738 return NULL_TREE;
3739 }
3740
3741 if (!real_lvalue_p (expr))
3742 {
3743 error ("%qE is not a valid template argument for type %qT "
3744 "because it is not an lvalue", expr, type);
3745 return NULL_TREE;
3746 }
3747
3748 /* [temp.arg.nontype]/1
3749
3750 A template-argument for a non-type, non-template template-parameter
3751 shall be one of: [...]
3752
3753 -- the address of an object or function with external linkage. */
3754 if (!DECL_EXTERNAL_LINKAGE_P (expr))
3755 {
3756 error ("%qE is not a valid template argument for type %qT "
3757 "because object %qD has not external linkage",
3758 expr, type, expr);
3759 return NULL_TREE;
3760 }
3761
3762 expr = build_nop (type, build_address (expr));
3763 }
3764 /* [temp.arg.nontype]/5, bullet 4
3765
3766 For a non-type template-parameter of type pointer to function, only
3767 the function-to-pointer conversion (_conv.func_) is applied. If the
3768 template-argument represents a set of overloaded functions (or a
3769 pointer to such), the matching function is selected from the set
3770 (_over.over_). */
3771 else if (TYPE_PTRFN_P (type))
3772 {
3773 /* If the argument is a template-id, we might not have enough
3774 context information to decay the pointer. */
3775 if (!type_unknown_p (expr_type))
3776 {
3777 expr = decay_conversion (expr);
3778 if (expr == error_mark_node)
3779 return error_mark_node;
3780 }
3781
3782 expr = convert_nontype_argument_function (type, expr);
3783 if (!expr || expr == error_mark_node)
3784 return expr;
3785 }
3786 /* [temp.arg.nontype]/5, bullet 5
3787
3788 For a non-type template-parameter of type reference to function, no
3789 conversions apply. If the template-argument represents a set of
3790 overloaded functions, the matching function is selected from the set
3791 (_over.over_). */
3792 else if (TYPE_REFFN_P (type))
3793 {
3794 if (TREE_CODE (expr) == ADDR_EXPR)
3795 {
3796 error ("%qE is not a valid template argument for type %qT "
3797 "because it is a pointer", expr, type);
3798 inform ("try using %qE instead", TREE_OPERAND (expr, 0));
3799 return NULL_TREE;
3800 }
3801
3802 expr = convert_nontype_argument_function (TREE_TYPE (type), expr);
3803 if (!expr || expr == error_mark_node)
3804 return expr;
3805
3806 expr = build_nop (type, build_address (expr));
3807 }
3808 /* [temp.arg.nontype]/5, bullet 6
3809
3810 For a non-type template-parameter of type pointer to member function,
3811 no conversions apply. If the template-argument represents a set of
3812 overloaded member functions, the matching member function is selected
3813 from the set (_over.over_). */
3814 else if (TYPE_PTRMEMFUNC_P (type))
3815 {
3816 expr = instantiate_type (type, expr, tf_none);
3817 if (expr == error_mark_node)
3818 return error_mark_node;
3819
3820 /* There is no way to disable standard conversions in
3821 resolve_address_of_overloaded_function (called by
3822 instantiate_type). It is possible that the call succeeded by
3823 converting &B::I to &D::I (where B is a base of D), so we need
3824 to reject this conversion here.
3825
3826 Actually, even if there was a way to disable standard conversions,
3827 it would still be better to reject them here so that we can
3828 provide a superior diagnostic. */
3829 if (!same_type_p (TREE_TYPE (expr), type))
3830 {
3831 /* Make sure we are just one standard conversion off. */
3832 gcc_assert (can_convert (type, TREE_TYPE (expr)));
3833 error ("%qE is not a valid template argument for type %qT "
3834 "because it is of type %qT", expr, type,
3835 TREE_TYPE (expr));
3836 inform ("standard conversions are not allowed in this context");
3837 return NULL_TREE;
3838 }
3839 }
3840 /* [temp.arg.nontype]/5, bullet 7
3841
3842 For a non-type template-parameter of type pointer to data member,
3843 qualification conversions (_conv.qual_) are applied. */
3844 else if (TYPE_PTRMEM_P (type))
3845 {
3846 expr = perform_qualification_conversions (type, expr);
3847 if (expr == error_mark_node)
3848 return expr;
3849 }
3850 /* A template non-type parameter must be one of the above. */
3851 else
3852 gcc_unreachable ();
3853
3854 /* Sanity check: did we actually convert the argument to the
3855 right type? */
3856 gcc_assert (same_type_p (type, TREE_TYPE (expr)));
3857 return expr;
3858}
3859
3860
3861/* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
3862 template template parameters. Both PARM_PARMS and ARG_PARMS are
3863 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
3864 or PARM_DECL.
3865
3866 Consider the example:
3867 template <class T> class A;
3868 template<template <class U> class TT> class B;
3869
3870 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
3871 the parameters to A, and OUTER_ARGS contains A. */
3872
3873static int
3874coerce_template_template_parms (tree parm_parms,
3875 tree arg_parms,
3876 tsubst_flags_t complain,
3877 tree in_decl,
3878 tree outer_args)
3879{
3880 int nparms, nargs, i;
3881 tree parm, arg;
3882
3883 gcc_assert (TREE_CODE (parm_parms) == TREE_VEC);
3884 gcc_assert (TREE_CODE (arg_parms) == TREE_VEC);
3885
3886 nparms = TREE_VEC_LENGTH (parm_parms);
3887 nargs = TREE_VEC_LENGTH (arg_parms);
3888
3889 if (nargs != nparms)
3890 return 0;
3891
3892 for (i = 0; i < nparms; ++i)
3893 {
3894 if (TREE_VEC_ELT (parm_parms, i) == error_mark_node
3895 || TREE_VEC_ELT (arg_parms, i) == error_mark_node)
3896 continue;
3897
3898 parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, i));
3899 arg = TREE_VALUE (TREE_VEC_ELT (arg_parms, i));
3900
3901 if (arg == NULL_TREE || arg == error_mark_node
3902 || parm == NULL_TREE || parm == error_mark_node)
3903 return 0;
3904
3905 if (TREE_CODE (arg) != TREE_CODE (parm))
3906 return 0;
3907
3908 switch (TREE_CODE (parm))
3909 {
3910 case TYPE_DECL:
3911 break;
3912
3913 case TEMPLATE_DECL:
3914 /* We encounter instantiations of templates like
3915 template <template <template <class> class> class TT>
3916 class C; */
3917 {
3918 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
3919 tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
3920
3921 if (!coerce_template_template_parms
3922 (parmparm, argparm, complain, in_decl, outer_args))
3923 return 0;
3924 }
3925 break;
3926
3927 case PARM_DECL:
3928 /* The tsubst call is used to handle cases such as
3929
3930 template <int> class C {};
3931 template <class T, template <T> class TT> class D {};
3932 D<int, C> d;
3933
3934 i.e. the parameter list of TT depends on earlier parameters. */
3935 if (!dependent_type_p (TREE_TYPE (arg))
3936 && !same_type_p
3937 (tsubst (TREE_TYPE (parm), outer_args, complain, in_decl),
3938 TREE_TYPE (arg)))
3939 return 0;
3940 break;
3941
3942 default:
3943 gcc_unreachable ();
3944 }
3945 }
3946 return 1;
3947}
3948
3949/* Convert the indicated template ARG as necessary to match the
3950 indicated template PARM. Returns the converted ARG, or
3951 error_mark_node if the conversion was unsuccessful. Error and
3952 warning messages are issued under control of COMPLAIN. This
3953 conversion is for the Ith parameter in the parameter list. ARGS is
3954 the full set of template arguments deduced so far. */
3955
3956static tree
3957convert_template_argument (tree parm,
3958 tree arg,
3959 tree args,
3960 tsubst_flags_t complain,
3961 int i,
3962 tree in_decl)
3963{
3964 tree val;
3965 int is_type, requires_type, is_tmpl_type, requires_tmpl_type;
3966
3967 if (TREE_CODE (arg) == TREE_LIST
3968 && TREE_CODE (TREE_VALUE (arg)) == OFFSET_REF)
3969 {
3970 /* The template argument was the name of some
3971 member function. That's usually
3972 invalid, but static members are OK. In any
3973 case, grab the underlying fields/functions
3974 and issue an error later if required. */
3975 arg = TREE_VALUE (arg);
3976 TREE_TYPE (arg) = unknown_type_node;
3977 }
3978
3979 requires_tmpl_type = TREE_CODE (parm) == TEMPLATE_DECL;
3980 requires_type = (TREE_CODE (parm) == TYPE_DECL
3981 || requires_tmpl_type);
3982
3983 is_tmpl_type = ((TREE_CODE (arg) == TEMPLATE_DECL
3984 && TREE_CODE (DECL_TEMPLATE_RESULT (arg)) == TYPE_DECL)
3985 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
3986 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE);
3987
3988 if (is_tmpl_type
3989 && (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
3990 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE))
3991 arg = TYPE_STUB_DECL (arg);
3992
3993 is_type = TYPE_P (arg) || is_tmpl_type;
3994
3995 if (requires_type && ! is_type && TREE_CODE (arg) == SCOPE_REF
3996 && TREE_CODE (TREE_OPERAND (arg, 0)) == TEMPLATE_TYPE_PARM)
3997 {
3998 pedwarn ("to refer to a type member of a template parameter, "
3999 "use %<typename %E%>", arg);
4000
4001 arg = make_typename_type (TREE_OPERAND (arg, 0),
4002 TREE_OPERAND (arg, 1),
4003 typename_type,
4004 complain & tf_error);
4005 is_type = 1;
4006 }
4007 if (is_type != requires_type)
4008 {
4009 if (in_decl)
4010 {
4011 if (complain & tf_error)
4012 {
4013 error ("type/value mismatch at argument %d in template "
4014 "parameter list for %qD",
4015 i + 1, in_decl);
4016 if (is_type)
4017 error (" expected a constant of type %qT, got %qT",
4018 TREE_TYPE (parm),
4019 (is_tmpl_type ? DECL_NAME (arg) : arg));
4020 else if (requires_tmpl_type)
4021 error (" expected a class template, got %qE", arg);
4022 else
4023 error (" expected a type, got %qE", arg);
4024 }
4025 }
4026 return error_mark_node;
4027 }
4028 if (is_tmpl_type ^ requires_tmpl_type)
4029 {
4030 if (in_decl && (complain & tf_error))
4031 {
4032 error ("type/value mismatch at argument %d in template "
4033 "parameter list for %qD",
4034 i + 1, in_decl);
4035 if (is_tmpl_type)
4036 error (" expected a type, got %qT", DECL_NAME (arg));
4037 else
4038 error (" expected a class template, got %qT", arg);
4039 }
4040 return error_mark_node;
4041 }
4042
4043 if (is_type)
4044 {
4045 if (requires_tmpl_type)
4046 {
4047 if (TREE_CODE (TREE_TYPE (arg)) == UNBOUND_CLASS_TEMPLATE)
4048 /* The number of argument required is not known yet.
4049 Just accept it for now. */
4050 val = TREE_TYPE (arg);
4051 else
4052 {
4053 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
4054 tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
4055
4056 if (coerce_template_template_parms (parmparm, argparm,
4057 complain, in_decl,
4058 args))
4059 {
4060 val = arg;
4061
4062 /* TEMPLATE_TEMPLATE_PARM node is preferred over
4063 TEMPLATE_DECL. */
4064 if (val != error_mark_node
4065 && DECL_TEMPLATE_TEMPLATE_PARM_P (val))
4066 val = TREE_TYPE (val);
4067 }
4068 else
4069 {
4070 if (in_decl && (complain & tf_error))
4071 {
4072 error ("type/value mismatch at argument %d in "
4073 "template parameter list for %qD",
4074 i + 1, in_decl);
4075 error (" expected a template of type %qD, got %qD",
4076 parm, arg);
4077 }
4078
4079 val = error_mark_node;
4080 }
4081 }
4082 }
4083 else
4084 val = arg;
4085 /* We only form one instance of each template specialization.
4086 Therefore, if we use a non-canonical variant (i.e., a
4087 typedef), any future messages referring to the type will use
4088 the typedef, which is confusing if those future uses do not
4089 themselves also use the typedef. */
4090 if (TYPE_P (val))
4091 val = canonical_type_variant (val);
4092 }
4093 else
4094 {
4095 tree t = tsubst (TREE_TYPE (parm), args, complain, in_decl);
4096
4097 if (invalid_nontype_parm_type_p (t, complain))
4098 return error_mark_node;
4099
4100 if (!uses_template_parms (arg) && !uses_template_parms (t))
4101 /* We used to call digest_init here. However, digest_init
4102 will report errors, which we don't want when complain
4103 is zero. More importantly, digest_init will try too
4104 hard to convert things: for example, `0' should not be
4105 converted to pointer type at this point according to
4106 the standard. Accepting this is not merely an
4107 extension, since deciding whether or not these
4108 conversions can occur is part of determining which
4109 function template to call, or whether a given explicit
4110 argument specification is valid. */
4111 val = convert_nontype_argument (t, arg);
4112 else
4113 val = arg;
4114
4115 if (val == NULL_TREE)
4116 val = error_mark_node;
4117 else if (val == error_mark_node && (complain & tf_error))
4118 error ("could not convert template argument %qE to %qT", arg, t);
4119 }
4120
4121 return val;
4122}
4123
4124/* Convert all template arguments to their appropriate types, and
4125 return a vector containing the innermost resulting template
4126 arguments. If any error occurs, return error_mark_node. Error and
4127 warning messages are issued under control of COMPLAIN.
4128
4129 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
4130 for arguments not specified in ARGS. Otherwise, if
4131 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
4132 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
4133 USE_DEFAULT_ARGS is false, then all arguments must be specified in
4134 ARGS. */
4135
4136static tree
4137coerce_template_parms (tree parms,
4138 tree args,
4139 tree in_decl,
4140 tsubst_flags_t complain,
4141 bool require_all_args,
4142 bool use_default_args)
4143{
4144 int nparms, nargs, i, lost = 0;
4145 tree inner_args;
4146 tree new_args;
4147 tree new_inner_args;
4148 bool saved_skip_evaluation;
4149
4150 inner_args = INNERMOST_TEMPLATE_ARGS (args);
4151 nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0;
4152 nparms = TREE_VEC_LENGTH (parms);
4153
4154 if (nargs > nparms
4155 || (nargs < nparms
4156 && require_all_args
4157 && (!use_default_args
4158 || (TREE_VEC_ELT (parms, nargs) != error_mark_node
4159 && !TREE_PURPOSE (TREE_VEC_ELT (parms, nargs))))))
4160 {
4161 if (complain & tf_error)
4162 {
4163 error ("wrong number of template arguments (%d, should be %d)",
4164 nargs, nparms);
4165
4166 if (in_decl)
4167 error ("provided for %q+D", in_decl);
4168 }
4169
4170 return error_mark_node;
4171 }
4172
4173 /* We need to evaluate the template arguments, even though this
4174 template-id may be nested within a "sizeof". */
4175 saved_skip_evaluation = skip_evaluation;
4176 skip_evaluation = false;
4177 new_inner_args = make_tree_vec (nparms);
4178 new_args = add_outermost_template_args (args, new_inner_args);
4179 for (i = 0; i < nparms; i++)
4180 {
4181 tree arg;
4182 tree parm;
4183
4184 /* Get the Ith template parameter. */
4185 parm = TREE_VEC_ELT (parms, i);
4186
4187 if (parm == error_mark_node)
4188 {
4189 TREE_VEC_ELT (new_inner_args, i) = error_mark_node;
4190 continue;
4191 }
4192
4193 /* Calculate the Ith argument. */
4194 if (i < nargs)
4195 arg = TREE_VEC_ELT (inner_args, i);
4196 else if (require_all_args)
4197 /* There must be a default arg in this case. */
4198 arg = tsubst_template_arg (TREE_PURPOSE (parm), new_args,
4199 complain, in_decl);
4200 else
4201 break;
4202
4203 gcc_assert (arg);
4204 if (arg == error_mark_node)
4205 {
4206 if (complain & tf_error)
4207 error ("template argument %d is invalid", i + 1);
4208 }
4209 else
4210 arg = convert_template_argument (TREE_VALUE (parm),
4211 arg, new_args, complain, i,
4212 in_decl);
4213
4214 if (arg == error_mark_node)
4215 lost++;
4216 TREE_VEC_ELT (new_inner_args, i) = arg;
4217 }
4218 skip_evaluation = saved_skip_evaluation;
4219
4220 if (lost)
4221 return error_mark_node;
4222
4223 return new_inner_args;
4224}
4225
4226/* Returns 1 if template args OT and NT are equivalent. */
4227
4228static int
4229template_args_equal (tree ot, tree nt)
4230{
4231 if (nt == ot)
4232 return 1;
4233
4234 if (TREE_CODE (nt) == TREE_VEC)
4235 /* For member templates */
4236 return TREE_CODE (ot) == TREE_VEC && comp_template_args (ot, nt);
4237 else if (TYPE_P (nt))
4238 return TYPE_P (ot) && same_type_p (ot, nt);
4239 else if (TREE_CODE (ot) == TREE_VEC || TYPE_P (ot))
4240 return 0;
4241 else
4242 return cp_tree_equal (ot, nt);
4243}
4244
4245/* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
4246 of template arguments. Returns 0 otherwise. */
4247
4248int
4249comp_template_args (tree oldargs, tree newargs)
4250{
4251 int i;
4252
4253 if (TREE_VEC_LENGTH (oldargs) != TREE_VEC_LENGTH (newargs))
4254 return 0;
4255
4256 for (i = 0; i < TREE_VEC_LENGTH (oldargs); ++i)
4257 {
4258 tree nt = TREE_VEC_ELT (newargs, i);
4259 tree ot = TREE_VEC_ELT (oldargs, i);
4260
4261 if (! template_args_equal (ot, nt))
4262 return 0;
4263 }
4264 return 1;
4265}
4266
4267/* Given class template name and parameter list, produce a user-friendly name
4268 for the instantiation. */
4269
4270static char *
4271mangle_class_name_for_template (const char* name, tree parms, tree arglist)
4272{
4273 static struct obstack scratch_obstack;
4274 static char *scratch_firstobj;
4275 int i, nparms;
4276
4277 if (!scratch_firstobj)
4278 gcc_obstack_init (&scratch_obstack);
4279 else
4280 obstack_free (&scratch_obstack, scratch_firstobj);
4281 scratch_firstobj = (char *) obstack_alloc (&scratch_obstack, 1);
4282
4283#define ccat(C) obstack_1grow (&scratch_obstack, (C));
4284#define cat(S) obstack_grow (&scratch_obstack, (S), strlen (S))
4285
4286 cat (name);
4287 ccat ('<');
4288 nparms = TREE_VEC_LENGTH (parms);
4289 arglist = INNERMOST_TEMPLATE_ARGS (arglist);
4290 gcc_assert (nparms == TREE_VEC_LENGTH (arglist));
4291 for (i = 0; i < nparms; i++)
4292 {
4293 tree parm;
4294 tree arg;
4295
4296 parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
4297 arg = TREE_VEC_ELT (arglist, i);
4298
4299 if (parm == error_mark_node)
4300 continue;
4301
4302 if (i)
4303 ccat (',');
4304
4305 if (TREE_CODE (parm) == TYPE_DECL)
4306 {
4307 cat (type_as_string (arg, TFF_CHASE_TYPEDEF));
4308 continue;
4309 }
4310 else if (TREE_CODE (parm) == TEMPLATE_DECL)
4311 {
4312 if (TREE_CODE (arg) == TEMPLATE_DECL)
4313 {
4314 /* Already substituted with real template. Just output
4315 the template name here */
4316 tree context = DECL_CONTEXT (arg);
4317 if (context)
4318 {
4319 /* The template may be defined in a namespace, or
4320 may be a member template. */
4321 gcc_assert (TREE_CODE (context) == NAMESPACE_DECL
4322 || CLASS_TYPE_P (context));
4323 cat (decl_as_string (DECL_CONTEXT (arg),
4324 TFF_PLAIN_IDENTIFIER));
4325 cat ("::");
4326 }
4327 cat (IDENTIFIER_POINTER (DECL_NAME (arg)));
4328 }
4329 else
4330 /* Output the parameter declaration. */
4331 cat (type_as_string (arg, TFF_CHASE_TYPEDEF));
4332 continue;
4333 }
4334 else
4335 gcc_assert (TREE_CODE (parm) == PARM_DECL);
4336
4337 /* No need to check arglist against parmlist here; we did that
4338 in coerce_template_parms, called from lookup_template_class. */
4339 cat (expr_as_string (arg, TFF_PLAIN_IDENTIFIER));
4340 }
4341 {
4342 char *bufp = obstack_next_free (&scratch_obstack);
4343 int offset = 0;
4344 while (bufp[offset - 1] == ' ')
4345 offset--;
4346 obstack_blank_fast (&scratch_obstack, offset);
4347
4348 /* B<C<char> >, not B<C<char>> */
4349 if (bufp[offset - 1] == '>')
4350 ccat (' ');
4351 }
4352 ccat ('>');
4353 ccat ('\0');
4354 return (char *) obstack_base (&scratch_obstack);
4355}
4356
4357static tree
4358classtype_mangled_name (tree t)
4359{
4360 if (CLASSTYPE_TEMPLATE_INFO (t)
4361 /* Specializations have already had their names set up in
4362 lookup_template_class. */
4363 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
4364 {
4365 tree tmpl = most_general_template (CLASSTYPE_TI_TEMPLATE (t));
4366
4367 /* For non-primary templates, the template parameters are
4368 implicit from their surrounding context. */
4369 if (PRIMARY_TEMPLATE_P (tmpl))
4370 {
4371 tree name = DECL_NAME (tmpl);
4372 char *mangled_name = mangle_class_name_for_template
4373 (IDENTIFIER_POINTER (name),
4374 DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
4375 CLASSTYPE_TI_ARGS (t));
4376 tree id = get_identifier (mangled_name);
4377 IDENTIFIER_TEMPLATE (id) = name;
4378 return id;
4379 }
4380 }
4381
4382 return TYPE_IDENTIFIER (t);
4383}
4384
4385static void
4386add_pending_template (tree d)
4387{
4388 tree ti = (TYPE_P (d)
4389 ? CLASSTYPE_TEMPLATE_INFO (d)
4390 : DECL_TEMPLATE_INFO (d));
4391 tree pt;
4392 int level;
4393
4394 if (TI_PENDING_TEMPLATE_FLAG (ti))
4395 return;
4396
4397 /* We are called both from instantiate_decl, where we've already had a
4398 tinst_level pushed, and instantiate_template, where we haven't.
4399 Compensate. */
4400 level = !(current_tinst_level && TINST_DECL (current_tinst_level) == d);
4401
4402 if (level)
4403 push_tinst_level (d);
4404
4405 pt = tree_cons (current_tinst_level, d, NULL_TREE);
4406 if (last_pending_template)
4407 TREE_CHAIN (last_pending_template) = pt;
4408 else
4409 pending_templates = pt;
4410
4411 last_pending_template = pt;
4412
4413 TI_PENDING_TEMPLATE_FLAG (ti) = 1;
4414
4415 if (level)
4416 pop_tinst_level ();
4417}
4418
4419
4420/* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
4421 ARGLIST. Valid choices for FNS are given in the cp-tree.def
4422 documentation for TEMPLATE_ID_EXPR. */
4423
4424tree
4425lookup_template_function (tree fns, tree arglist)
4426{
4427 tree type;
4428
4429 if (fns == error_mark_node || arglist == error_mark_node)
4430 return error_mark_node;
4431
4432 gcc_assert (!arglist || TREE_CODE (arglist) == TREE_VEC);
4433 gcc_assert (fns && (is_overloaded_fn (fns)
4434 || TREE_CODE (fns) == IDENTIFIER_NODE));
4435
4436 if (BASELINK_P (fns))
4437 {
4438 BASELINK_FUNCTIONS (fns) = build2 (TEMPLATE_ID_EXPR,
4439 unknown_type_node,
4440 BASELINK_FUNCTIONS (fns),
4441 arglist);
4442 return fns;
4443 }
4444
4445 type = TREE_TYPE (fns);
4446 if (TREE_CODE (fns) == OVERLOAD || !type)
4447 type = unknown_type_node;
4448
4449 return build2 (TEMPLATE_ID_EXPR, type, fns, arglist);
4450}
4451
4452/* Within the scope of a template class S<T>, the name S gets bound
4453 (in build_self_reference) to a TYPE_DECL for the class, not a
4454 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
4455 or one of its enclosing classes, and that type is a template,
4456 return the associated TEMPLATE_DECL. Otherwise, the original
4457 DECL is returned. */
4458
4459tree
4460maybe_get_template_decl_from_type_decl (tree decl)
4461{
4462 return (decl != NULL_TREE
4463 && TREE_CODE (decl) == TYPE_DECL
4464 && DECL_ARTIFICIAL (decl)
4465 && CLASS_TYPE_P (TREE_TYPE (decl))
4466 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl)))
4467 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl)) : decl;
4468}
4469
4470/* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
4471 parameters, find the desired type.
4472
4473 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
4474
4475 IN_DECL, if non-NULL, is the template declaration we are trying to
4476 instantiate.
4477
4478 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
4479 the class we are looking up.
4480
4481 Issue error and warning messages under control of COMPLAIN.
4482
4483 If the template class is really a local class in a template
4484 function, then the FUNCTION_CONTEXT is the function in which it is
4485 being instantiated.
4486
4487 ??? Note that this function is currently called *twice* for each
4488 template-id: the first time from the parser, while creating the
4489 incomplete type (finish_template_type), and the second type during the
4490 real instantiation (instantiate_template_class). This is surely something
4491 that we want to avoid. It also causes some problems with argument
4492 coercion (see convert_nontype_argument for more information on this). */
4493
4494tree
4495lookup_template_class (tree d1,
4496 tree arglist,
4497 tree in_decl,
4498 tree context,
4499 int entering_scope,
4500 tsubst_flags_t complain)
4501{
4502 tree template = NULL_TREE, parmlist;
4503 tree t;
4504
4505 timevar_push (TV_NAME_LOOKUP);
4506
4507 if (TREE_CODE (d1) == IDENTIFIER_NODE)
4508 {
4509 tree value = innermost_non_namespace_value (d1);
4510 if (value && DECL_TEMPLATE_TEMPLATE_PARM_P (value))
4511 template = value;
4512 else
4513 {
4514 if (context)
4515 push_decl_namespace (context);
4516 template = lookup_name (d1);
4517 template = maybe_get_template_decl_from_type_decl (template);
4518 if (context)
4519 pop_decl_namespace ();
4520 }
4521 if (template)
4522 context = DECL_CONTEXT (template);
4523 }
4524 else if (TREE_CODE (d1) == TYPE_DECL && IS_AGGR_TYPE (TREE_TYPE (d1)))
4525 {
4526 tree type = TREE_TYPE (d1);
4527
4528 /* If we are declaring a constructor, say A<T>::A<T>, we will get
4529 an implicit typename for the second A. Deal with it. */
4530 if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
4531 type = TREE_TYPE (type);
4532
4533 if (CLASSTYPE_TEMPLATE_INFO (type))
4534 {
4535 template = CLASSTYPE_TI_TEMPLATE (type);
4536 d1 = DECL_NAME (template);
4537 }
4538 }
4539 else if (TREE_CODE (d1) == ENUMERAL_TYPE
4540 || (TYPE_P (d1) && IS_AGGR_TYPE (d1)))
4541 {
4542 template = TYPE_TI_TEMPLATE (d1);
4543 d1 = DECL_NAME (template);
4544 }
4545 else if (TREE_CODE (d1) == TEMPLATE_DECL
4546 && TREE_CODE (DECL_TEMPLATE_RESULT (d1)) == TYPE_DECL)
4547 {
4548 template = d1;
4549 d1 = DECL_NAME (template);
4550 context = DECL_CONTEXT (template);
4551 }
4552
4553 /* Issue an error message if we didn't find a template. */
4554 if (! template)
4555 {
4556 if (complain & tf_error)
4557 error ("%qT is not a template", d1);
4558 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4559 }
4560
4561 if (TREE_CODE (template) != TEMPLATE_DECL
4562 /* Make sure it's a user visible template, if it was named by
4563 the user. */
4564 || ((complain & tf_user) && !DECL_TEMPLATE_PARM_P (template)
4565 && !PRIMARY_TEMPLATE_P (template)))
4566 {
4567 if (complain & tf_error)
4568 {
4569 error ("non-template type %qT used as a template", d1);
4570 if (in_decl)
4571 error ("for template declaration %q+D", in_decl);
4572 }
4573 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4574 }
4575
4576 complain &= ~tf_user;
4577
4578 if (DECL_TEMPLATE_TEMPLATE_PARM_P (template))
4579 {
4580 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
4581 template arguments */
4582
4583 tree parm;
4584 tree arglist2;
4585
4586 parmlist = DECL_INNERMOST_TEMPLATE_PARMS (template);
4587
4588 /* Consider an example where a template template parameter declared as
4589
4590 template <class T, class U = std::allocator<T> > class TT
4591
4592 The template parameter level of T and U are one level larger than
4593 of TT. To proper process the default argument of U, say when an
4594 instantiation `TT<int>' is seen, we need to build the full
4595 arguments containing {int} as the innermost level. Outer levels,
4596 available when not appearing as default template argument, can be
4597 obtained from `current_template_args ()'.
4598
4599 Suppose that TT is later substituted with std::vector. The above
4600 instantiation is `TT<int, std::allocator<T> >' with TT at
4601 level 1, and T at level 2, while the template arguments at level 1
4602 becomes {std::vector} and the inner level 2 is {int}. */
4603
4604 if (current_template_parms)
4605 arglist = add_to_template_args (current_template_args (), arglist);
4606
4607 arglist2 = coerce_template_parms (parmlist, arglist, template,
4608 complain,
4609 /*require_all_args=*/true,
4610 /*use_default_args=*/true);
4611 if (arglist2 == error_mark_node
4612 || (!uses_template_parms (arglist2)
4613 && check_instantiated_args (template, arglist2, complain)))
4614 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4615
4616 parm = bind_template_template_parm (TREE_TYPE (template), arglist2);
4617 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, parm);
4618 }
4619 else
4620 {
4621 tree template_type = TREE_TYPE (template);
4622 tree gen_tmpl;
4623 tree type_decl;
4624 tree found = NULL_TREE;
4625 int arg_depth;
4626 int parm_depth;
4627 int is_partial_instantiation;
4628
4629 gen_tmpl = most_general_template (template);
4630 parmlist = DECL_TEMPLATE_PARMS (gen_tmpl);
4631 parm_depth = TMPL_PARMS_DEPTH (parmlist);
4632 arg_depth = TMPL_ARGS_DEPTH (arglist);
4633
4634 if (arg_depth == 1 && parm_depth > 1)
4635 {
4636 /* We've been given an incomplete set of template arguments.
4637 For example, given:
4638
4639 template <class T> struct S1 {
4640 template <class U> struct S2 {};
4641 template <class U> struct S2<U*> {};
4642 };
4643
4644 we will be called with an ARGLIST of `U*', but the
4645 TEMPLATE will be `template <class T> template
4646 <class U> struct S1<T>::S2'. We must fill in the missing
4647 arguments. */
4648 arglist
4649 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (template)),
4650 arglist);
4651 arg_depth = TMPL_ARGS_DEPTH (arglist);
4652 }
4653
4654 /* Now we should have enough arguments. */
4655 gcc_assert (parm_depth == arg_depth);
4656
4657 /* From here on, we're only interested in the most general
4658 template. */
4659 template = gen_tmpl;
4660
4661 /* Calculate the BOUND_ARGS. These will be the args that are
4662 actually tsubst'd into the definition to create the
4663 instantiation. */
4664 if (parm_depth > 1)
4665 {
4666 /* We have multiple levels of arguments to coerce, at once. */
4667 int i;
4668 int saved_depth = TMPL_ARGS_DEPTH (arglist);
4669
4670 tree bound_args = make_tree_vec (parm_depth);
4671
4672 for (i = saved_depth,
4673 t = DECL_TEMPLATE_PARMS (template);
4674 i > 0 && t != NULL_TREE;
4675 --i, t = TREE_CHAIN (t))
4676 {
4677 tree a = coerce_template_parms (TREE_VALUE (t),
4678 arglist, template,
4679 complain,
4680 /*require_all_args=*/true,
4681 /*use_default_args=*/true);
4682
4683 /* Don't process further if one of the levels fails. */
4684 if (a == error_mark_node)
4685 {
4686 /* Restore the ARGLIST to its full size. */
4687 TREE_VEC_LENGTH (arglist) = saved_depth;
4688 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4689 }
4690
4691 SET_TMPL_ARGS_LEVEL (bound_args, i, a);
4692
4693 /* We temporarily reduce the length of the ARGLIST so
4694 that coerce_template_parms will see only the arguments
4695 corresponding to the template parameters it is
4696 examining. */
4697 TREE_VEC_LENGTH (arglist)--;
4698 }
4699
4700 /* Restore the ARGLIST to its full size. */
4701 TREE_VEC_LENGTH (arglist) = saved_depth;
4702
4703 arglist = bound_args;
4704 }
4705 else
4706 arglist
4707 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist),
4708 INNERMOST_TEMPLATE_ARGS (arglist),
4709 template,
4710 complain,
4711 /*require_all_args=*/true,
4712 /*use_default_args=*/true);
4713
4714 if (arglist == error_mark_node)
4715 /* We were unable to bind the arguments. */
4716 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4717
4718 /* In the scope of a template class, explicit references to the
4719 template class refer to the type of the template, not any
4720 instantiation of it. For example, in:
4721
4722 template <class T> class C { void f(C<T>); }
4723
4724 the `C<T>' is just the same as `C'. Outside of the
4725 class, however, such a reference is an instantiation. */
4726 if (comp_template_args (TYPE_TI_ARGS (template_type),
4727 arglist))
4728 {
4729 found = template_type;
4730
4731 if (!entering_scope && PRIMARY_TEMPLATE_P (template))
4732 {
4733 tree ctx;
4734
4735 for (ctx = current_class_type;
4736 ctx && TREE_CODE (ctx) != NAMESPACE_DECL;
4737 ctx = (TYPE_P (ctx)
4738 ? TYPE_CONTEXT (ctx)
4739 : DECL_CONTEXT (ctx)))
4740 if (TYPE_P (ctx) && same_type_p (ctx, template_type))
4741 goto found_ctx;
4742
4743 /* We're not in the scope of the class, so the
4744 TEMPLATE_TYPE is not the type we want after all. */
4745 found = NULL_TREE;
4746 found_ctx:;
4747 }
4748 }
4749 if (found)
4750 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
4751
4752 /* If we already have this specialization, return it. */
4753 found = retrieve_specialization (template, arglist,
4754 /*class_specializations_p=*/false);
4755 if (found)
4756 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
4757
4758 /* This type is a "partial instantiation" if any of the template
4759 arguments still involve template parameters. Note that we set
4760 IS_PARTIAL_INSTANTIATION for partial specializations as
4761 well. */
4762 is_partial_instantiation = uses_template_parms (arglist);
4763
4764 /* If the deduced arguments are invalid, then the binding
4765 failed. */
4766 if (!is_partial_instantiation
4767 && check_instantiated_args (template,
4768 INNERMOST_TEMPLATE_ARGS (arglist),
4769 complain))
4770 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4771
4772 if (!is_partial_instantiation
4773 && !PRIMARY_TEMPLATE_P (template)
4774 && TREE_CODE (CP_DECL_CONTEXT (template)) == NAMESPACE_DECL)
4775 {
4776 found = xref_tag_from_type (TREE_TYPE (template),
4777 DECL_NAME (template),
4778 /*tag_scope=*/ts_global);
4779 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
4780 }
4781
4782 context = tsubst (DECL_CONTEXT (template), arglist,
4783 complain, in_decl);
4784 if (!context)
4785 context = global_namespace;
4786
4787 /* Create the type. */
4788 if (TREE_CODE (template_type) == ENUMERAL_TYPE)
4789 {
4790 if (!is_partial_instantiation)
4791 {
4792 set_current_access_from_decl (TYPE_NAME (template_type));
4793 t = start_enum (TYPE_IDENTIFIER (template_type));
4794 }
4795 else
4796 /* We don't want to call start_enum for this type, since
4797 the values for the enumeration constants may involve
4798 template parameters. And, no one should be interested
4799 in the enumeration constants for such a type. */
4800 t = make_node (ENUMERAL_TYPE);
4801 }
4802 else
4803 {
4804 t = make_aggr_type (TREE_CODE (template_type));
4805 CLASSTYPE_DECLARED_CLASS (t)
4806 = CLASSTYPE_DECLARED_CLASS (template_type);
4807 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t);
4808 TYPE_FOR_JAVA (t) = TYPE_FOR_JAVA (template_type);
4809
4810 /* A local class. Make sure the decl gets registered properly. */
4811 if (context == current_function_decl)
4812 pushtag (DECL_NAME (template), t, /*tag_scope=*/ts_current);
4813 }
4814
4815 /* If we called start_enum or pushtag above, this information
4816 will already be set up. */
4817 if (!TYPE_NAME (t))
4818 {
4819 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
4820
4821 type_decl = create_implicit_typedef (DECL_NAME (template), t);
4822 DECL_CONTEXT (type_decl) = TYPE_CONTEXT (t);
4823 TYPE_STUB_DECL (t) = type_decl;
4824 DECL_SOURCE_LOCATION (type_decl)
4825 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type));
4826 }
4827 else
4828 type_decl = TYPE_NAME (t);
4829
4830 TREE_PRIVATE (type_decl)
4831 = TREE_PRIVATE (TYPE_STUB_DECL (template_type));
4832 TREE_PROTECTED (type_decl)
4833 = TREE_PROTECTED (TYPE_STUB_DECL (template_type));
4834 DECL_IN_SYSTEM_HEADER (type_decl)
4835 = DECL_IN_SYSTEM_HEADER (template);
4836 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type))
4837 {
4838 DECL_VISIBILITY_SPECIFIED (type_decl) = 1;
4839 DECL_VISIBILITY (type_decl) = CLASSTYPE_VISIBILITY (template_type);
4840 }
4841
4842 /* Set up the template information. We have to figure out which
4843 template is the immediate parent if this is a full
4844 instantiation. */
4845 if (parm_depth == 1 || is_partial_instantiation
4846 || !PRIMARY_TEMPLATE_P (template))
4847 /* This case is easy; there are no member templates involved. */
4848 found = template;
4849 else
4850 {
4851 /* This is a full instantiation of a member template. Look
4852 for a partial instantiation of which this is an instance. */
4853
4854 for (found = DECL_TEMPLATE_INSTANTIATIONS (template);
4855 found; found = TREE_CHAIN (found))
4856 {
4857 int success;
4858 tree tmpl = CLASSTYPE_TI_TEMPLATE (TREE_VALUE (found));
4859
4860 /* We only want partial instantiations, here, not
4861 specializations or full instantiations. */
4862 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_VALUE (found))
4863 || !uses_template_parms (TREE_VALUE (found)))
4864 continue;
4865
4866 /* Temporarily reduce by one the number of levels in the
4867 ARGLIST and in FOUND so as to avoid comparing the
4868 last set of arguments. */
4869 TREE_VEC_LENGTH (arglist)--;
4870 TREE_VEC_LENGTH (TREE_PURPOSE (found)) --;
4871
4872 /* See if the arguments match. If they do, then TMPL is
4873 the partial instantiation we want. */
4874 success = comp_template_args (TREE_PURPOSE (found), arglist);
4875
4876 /* Restore the argument vectors to their full size. */
4877 TREE_VEC_LENGTH (arglist)++;
4878 TREE_VEC_LENGTH (TREE_PURPOSE (found))++;
4879
4880 if (success)
4881 {
4882 found = tmpl;
4883 break;
4884 }
4885 }
4886
4887 if (!found)
4888 {
4889 /* There was no partial instantiation. This happens
4890 where C<T> is a member template of A<T> and it's used
4891 in something like
4892
4893 template <typename T> struct B { A<T>::C<int> m; };
4894 B<float>;
4895
4896 Create the partial instantiation.
4897 */
4898 TREE_VEC_LENGTH (arglist)--;
4899 found = tsubst (template, arglist, complain, NULL_TREE);
4900 TREE_VEC_LENGTH (arglist)++;
4901 }
4902 }
4903
4904 SET_TYPE_TEMPLATE_INFO (t, tree_cons (found, arglist, NULL_TREE));
4905 DECL_TEMPLATE_INSTANTIATIONS (template)
4906 = tree_cons (arglist, t,
4907 DECL_TEMPLATE_INSTANTIATIONS (template));
4908
4909 if (TREE_CODE (t) == ENUMERAL_TYPE
4910 && !is_partial_instantiation)
4911 /* Now that the type has been registered on the instantiations
4912 list, we set up the enumerators. Because the enumeration
4913 constants may involve the enumeration type itself, we make
4914 sure to register the type first, and then create the
4915 constants. That way, doing tsubst_expr for the enumeration
4916 constants won't result in recursive calls here; we'll find
4917 the instantiation and exit above. */
4918 tsubst_enum (template_type, t, arglist);
4919
4920 /* Reset the name of the type, now that CLASSTYPE_TEMPLATE_INFO
4921 is set up. */
4922 if (TREE_CODE (t) != ENUMERAL_TYPE)
4923 DECL_NAME (type_decl) = classtype_mangled_name (t);
4924 if (is_partial_instantiation)
4925 /* If the type makes use of template parameters, the
4926 code that generates debugging information will crash. */
4927 DECL_IGNORED_P (TYPE_STUB_DECL (t)) = 1;
4928
4929 /* Possibly limit visibility based on template args. */
4930 TREE_PUBLIC (type_decl) = 1;
4931 determine_visibility (type_decl);
4932
4933 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4934 }
4935 timevar_pop (TV_NAME_LOOKUP);
4936}
4937
4938struct pair_fn_data
4939{
4940 tree_fn_t fn;
4941 void *data;
4942 struct pointer_set_t *visited;
4943};
4944
4945/* Called from for_each_template_parm via walk_tree. */
4946
4947static tree
4948for_each_template_parm_r (tree *tp, int *walk_subtrees, void *d)
4949{
4950 tree t = *tp;
4951 struct pair_fn_data *pfd = (struct pair_fn_data *) d;
4952 tree_fn_t fn = pfd->fn;
4953 void *data = pfd->data;
4954
4955 if (TYPE_P (t)
4956 && for_each_template_parm (TYPE_CONTEXT (t), fn, data, pfd->visited))
4957 return error_mark_node;
4958
4959 switch (TREE_CODE (t))
4960 {
4961 case RECORD_TYPE:
4962 if (TYPE_PTRMEMFUNC_P (t))
4963 break;
4964 /* Fall through. */
4965
4966 case UNION_TYPE:
4967 case ENUMERAL_TYPE:
4968 if (!TYPE_TEMPLATE_INFO (t))
4969 *walk_subtrees = 0;
4970 else if (for_each_template_parm (TREE_VALUE (TYPE_TEMPLATE_INFO (t)),
4971 fn, data, pfd->visited))
4972 return error_mark_node;
4973 break;
4974
4975 case METHOD_TYPE:
4976 /* Since we're not going to walk subtrees, we have to do this
4977 explicitly here. */
4978 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t), fn, data,
4979 pfd->visited))
4980 return error_mark_node;
4981 /* Fall through. */
4982
4983 case FUNCTION_TYPE:
4984 /* Check the return type. */
4985 if (for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited))
4986 return error_mark_node;
4987
4988 /* Check the parameter types. Since default arguments are not
4989 instantiated until they are needed, the TYPE_ARG_TYPES may
4990 contain expressions that involve template parameters. But,
4991 no-one should be looking at them yet. And, once they're
4992 instantiated, they don't contain template parameters, so
4993 there's no point in looking at them then, either. */
4994 {
4995 tree parm;
4996
4997 for (parm = TYPE_ARG_TYPES (t); parm; parm = TREE_CHAIN (parm))
4998 if (for_each_template_parm (TREE_VALUE (parm), fn, data,
4999 pfd->visited))
5000 return error_mark_node;
5001
5002 /* Since we've already handled the TYPE_ARG_TYPES, we don't
5003 want walk_tree walking into them itself. */
5004 *walk_subtrees = 0;
5005 }
5006 break;
5007
5008 case TYPEOF_TYPE:
5009 if (for_each_template_parm (TYPE_FIELDS (t), fn, data,
5010 pfd->visited))
5011 return error_mark_node;
5012 break;
5013
5014 case FUNCTION_DECL:
5015 case VAR_DECL:
5016 if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t)
5017 && for_each_template_parm (DECL_TI_ARGS (t), fn, data,
5018 pfd->visited))
5019 return error_mark_node;
5020 /* Fall through. */
5021
5022 case PARM_DECL:
5023 case CONST_DECL:
5024 if (TREE_CODE (t) == CONST_DECL && DECL_TEMPLATE_PARM_P (t)
5025 && for_each_template_parm (DECL_INITIAL (t), fn, data,
5026 pfd->visited))
5027 return error_mark_node;
5028 if (DECL_CONTEXT (t)
5029 && for_each_template_parm (DECL_CONTEXT (t), fn, data,
5030 pfd->visited))
5031 return error_mark_node;
5032 break;
5033
5034 case BOUND_TEMPLATE_TEMPLATE_PARM:
5035 /* Record template parameters such as `T' inside `TT<T>'. */
5036 if (for_each_template_parm (TYPE_TI_ARGS (t), fn, data, pfd->visited))
5037 return error_mark_node;
5038 /* Fall through. */
5039
5040 case TEMPLATE_TEMPLATE_PARM:
5041 case TEMPLATE_TYPE_PARM:
5042 case TEMPLATE_PARM_INDEX:
5043 if (fn && (*fn)(t, data))
5044 return error_mark_node;
5045 else if (!fn)
5046 return error_mark_node;
5047 break;
5048
5049 case TEMPLATE_DECL:
5050 /* A template template parameter is encountered. */
5051 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t)
5052 && for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited))
5053 return error_mark_node;
5054
5055 /* Already substituted template template parameter */
5056 *walk_subtrees = 0;
5057 break;
5058
5059 case TYPENAME_TYPE:
5060 if (!fn
5061 || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t), fn,
5062 data, pfd->visited))
5063 return error_mark_node;
5064 break;
5065
5066 case CONSTRUCTOR:
5067 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t))
5068 && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
5069 (TREE_TYPE (t)), fn, data,
5070 pfd->visited))
5071 return error_mark_node;
5072 break;
5073
5074 case INDIRECT_REF:
5075 case COMPONENT_REF:
5076 /* If there's no type, then this thing must be some expression
5077 involving template parameters. */
5078 if (!fn && !TREE_TYPE (t))
5079 return error_mark_node;
5080 break;
5081
5082 case MODOP_EXPR:
5083 case CAST_EXPR:
5084 case REINTERPRET_CAST_EXPR:
5085 case CONST_CAST_EXPR:
5086 case STATIC_CAST_EXPR:
5087 case DYNAMIC_CAST_EXPR:
5088 case ARROW_EXPR:
5089 case DOTSTAR_EXPR:
5090 case TYPEID_EXPR:
5091 case PSEUDO_DTOR_EXPR:
5092 if (!fn)
5093 return error_mark_node;
5094 break;
5095
5096 case BASELINK:
5097 /* If we do not handle this case specially, we end up walking
5098 the BINFO hierarchy, which is circular, and therefore
5099 confuses walk_tree. */
5100 *walk_subtrees = 0;
5101 if (for_each_template_parm (BASELINK_FUNCTIONS (*tp), fn, data,
5102 pfd->visited))
5103 return error_mark_node;
5104 break;
5105
5106 default:
5107 break;
5108 }
5109
5110 /* We didn't find any template parameters we liked. */
5111 return NULL_TREE;
5112}
5113
5114/* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
5115 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
5116 call FN with the parameter and the DATA.
5117 If FN returns nonzero, the iteration is terminated, and
5118 for_each_template_parm returns 1. Otherwise, the iteration
5119 continues. If FN never returns a nonzero value, the value
5120 returned by for_each_template_parm is 0. If FN is NULL, it is
5121 considered to be the function which always returns 1. */
5122
5123static int
5124for_each_template_parm (tree t, tree_fn_t fn, void* data,
5125 struct pointer_set_t *visited)
5126{
5127 struct pair_fn_data pfd;
5128 int result;
5129
5130 /* Set up. */
5131 pfd.fn = fn;
5132 pfd.data = data;
5133
5134 /* Walk the tree. (Conceptually, we would like to walk without
5135 duplicates, but for_each_template_parm_r recursively calls
5136 for_each_template_parm, so we would need to reorganize a fair
5137 bit to use walk_tree_without_duplicates, so we keep our own
5138 visited list.) */
5139 if (visited)
5140 pfd.visited = visited;
5141 else
5142 pfd.visited = pointer_set_create ();
5143 result = walk_tree (&t,
5144 for_each_template_parm_r,
5145 &pfd,
5146 pfd.visited) != NULL_TREE;
5147
5148 /* Clean up. */
5149 if (!visited)
5150 {
5151 pointer_set_destroy (pfd.visited);
5152 pfd.visited = 0;
5153 }
5154
5155 return result;
5156}
5157
5158/* Returns true if T depends on any template parameter. */
5159
5160int
5161uses_template_parms (tree t)
5162{
5163 bool dependent_p;
5164 int saved_processing_template_decl;
5165
5166 saved_processing_template_decl = processing_template_decl;
5167 if (!saved_processing_template_decl)
5168 processing_template_decl = 1;
5169 if (TYPE_P (t))
5170 dependent_p = dependent_type_p (t);
5171 else if (TREE_CODE (t) == TREE_VEC)
5172 dependent_p = any_dependent_template_arguments_p (t);
5173 else if (TREE_CODE (t) == TREE_LIST)
5174 dependent_p = (uses_template_parms (TREE_VALUE (t))
5175 || uses_template_parms (TREE_CHAIN (t)));
5176 else if (TREE_CODE (t) == TYPE_DECL)
5177 dependent_p = dependent_type_p (TREE_TYPE (t));
5178 else if (DECL_P (t)
5179 || EXPR_P (t)
5180 || TREE_CODE (t) == TEMPLATE_PARM_INDEX
5181 || TREE_CODE (t) == OVERLOAD
5182 || TREE_CODE (t) == BASELINK
5183 || TREE_CODE (t) == IDENTIFIER_NODE
5184 || CONSTANT_CLASS_P (t))
5185 dependent_p = (type_dependent_expression_p (t)
5186 || value_dependent_expression_p (t));
5187 else
5188 {
5189 gcc_assert (t == error_mark_node);
5190 dependent_p = false;
5191 }
5192
5193 processing_template_decl = saved_processing_template_decl;
5194
5195 return dependent_p;
5196}
5197
5198/* Returns true if T depends on any template parameter with level LEVEL. */
5199
5200int
5201uses_template_parms_level (tree t, int level)
5202{
5203 return for_each_template_parm (t, template_parm_this_level_p, &level, NULL);
5204}
5205
5206static int tinst_depth;
5207extern int max_tinst_depth;
5208#ifdef GATHER_STATISTICS
5209int depth_reached;
5210#endif
5211static int tinst_level_tick;
5212static int last_template_error_tick;
5213
5214/* We're starting to instantiate D; record the template instantiation context
5215 for diagnostics and to restore it later. */
5216
5217static int
5218push_tinst_level (tree d)
5219{
5220 tree new;
5221
5222 if (tinst_depth >= max_tinst_depth)
5223 {
5224 /* If the instantiation in question still has unbound template parms,
5225 we don't really care if we can't instantiate it, so just return.
5226 This happens with base instantiation for implicit `typename'. */
5227 if (uses_template_parms (d))
5228 return 0;
5229
5230 last_template_error_tick = tinst_level_tick;
5231 error ("template instantiation depth exceeds maximum of %d (use "
5232 "-ftemplate-depth-NN to increase the maximum) instantiating %qD",
5233 max_tinst_depth, d);
5234
5235 print_instantiation_context ();
5236
5237 return 0;
5238 }
5239
5240 new = make_node (TINST_LEVEL);
5241 TINST_DECL (new) = d;
5242 TINST_LOCATION (new) = input_location;
5243 TINST_IN_SYSTEM_HEADER_P (new) = in_system_header;
5244 TREE_CHAIN (new) = current_tinst_level;
5245 current_tinst_level = new;
5246
5247 ++tinst_depth;
5248#ifdef GATHER_STATISTICS
5249 if (tinst_depth > depth_reached)
5250 depth_reached = tinst_depth;
5251#endif
5252
5253 ++tinst_level_tick;
5254 return 1;
5255}
5256
5257/* We're done instantiating this template; return to the instantiation
5258 context. */
5259
5260static void
5261pop_tinst_level (void)
5262{
5263 tree old = current_tinst_level;
5264
5265 /* Restore the filename and line number stashed away when we started
5266 this instantiation. */
5267 input_location = TINST_LOCATION (old);
5268 in_system_header = TINST_IN_SYSTEM_HEADER_P (old);
5269 current_tinst_level = TREE_CHAIN (old);
5270 --tinst_depth;
5271 ++tinst_level_tick;
5272}
5273
5274/* We're instantiating a deferred template; restore the template
5275 instantiation context in which the instantiation was requested, which
5276 is one step out from LEVEL. */
5277
5278static void
5279reopen_tinst_level (tree level)
5280{
5281 tree t;
5282
5283 tinst_depth = 0;
5284 for (t = level; t; t = TREE_CHAIN (t))
5285 ++tinst_depth;
5286
5287 current_tinst_level = level;
5288 pop_tinst_level ();
5289}
5290
|
| 5291/* Returns the TINST_LEVEL which gives the original instantiation
5292 context. */
5293
5294tree
5295outermost_tinst_level (void)
5296{
5297 return tree_last (current_tinst_level);
5298}
5299
|
5291/* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
5292 vector of template arguments, as for tsubst.
5293
5294 Returns an appropriate tsubst'd friend declaration. */
5295
5296static tree
5297tsubst_friend_function (tree decl, tree args)
5298{
5299 tree new_friend;
5300
5301 if (TREE_CODE (decl) == FUNCTION_DECL
5302 && DECL_TEMPLATE_INSTANTIATION (decl)
5303 && TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
5304 /* This was a friend declared with an explicit template
5305 argument list, e.g.:
5306
5307 friend void f<>(T);
5308
5309 to indicate that f was a template instantiation, not a new
5310 function declaration. Now, we have to figure out what
5311 instantiation of what template. */
5312 {
5313 tree template_id, arglist, fns;
5314 tree new_args;
5315 tree tmpl;
5316 tree ns = decl_namespace_context (TYPE_MAIN_DECL (current_class_type));
5317
5318 /* Friend functions are looked up in the containing namespace scope.
5319 We must enter that scope, to avoid finding member functions of the
5320 current cless with same name. */
5321 push_nested_namespace (ns);
5322 fns = tsubst_expr (DECL_TI_TEMPLATE (decl), args,
5323 tf_warning_or_error, NULL_TREE,
5324 /*integral_constant_expression_p=*/false);
5325 pop_nested_namespace (ns);
5326 arglist = tsubst (DECL_TI_ARGS (decl), args,
5327 tf_warning_or_error, NULL_TREE);
5328 template_id = lookup_template_function (fns, arglist);
5329
5330 new_friend = tsubst (decl, args, tf_warning_or_error, NULL_TREE);
5331 tmpl = determine_specialization (template_id, new_friend,
5332 &new_args,
5333 /*need_member_template=*/0,
5334 TREE_VEC_LENGTH (args),
5335 tsk_none);
5336 return instantiate_template (tmpl, new_args, tf_error);
5337 }
5338
5339 new_friend = tsubst (decl, args, tf_warning_or_error, NULL_TREE);
5340
5341 /* The NEW_FRIEND will look like an instantiation, to the
5342 compiler, but is not an instantiation from the point of view of
5343 the language. For example, we might have had:
5344
5345 template <class T> struct S {
5346 template <class U> friend void f(T, U);
5347 };
5348
5349 Then, in S<int>, template <class U> void f(int, U) is not an
5350 instantiation of anything. */
5351 if (new_friend == error_mark_node)
5352 return error_mark_node;
5353
5354 DECL_USE_TEMPLATE (new_friend) = 0;
5355 if (TREE_CODE (decl) == TEMPLATE_DECL)
5356 {
5357 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend)) = 0;
5358 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend))
5359 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl));
5360 }
5361
5362 /* The mangled name for the NEW_FRIEND is incorrect. The function
5363 is not a template instantiation and should not be mangled like
5364 one. Therefore, we forget the mangling here; we'll recompute it
5365 later if we need it. */
5366 if (TREE_CODE (new_friend) != TEMPLATE_DECL)
5367 {
5368 SET_DECL_RTL (new_friend, NULL_RTX);
5369 SET_DECL_ASSEMBLER_NAME (new_friend, NULL_TREE);
5370 }
5371
5372 if (DECL_NAMESPACE_SCOPE_P (new_friend))
5373 {
5374 tree old_decl;
5375 tree new_friend_template_info;
5376 tree new_friend_result_template_info;
5377 tree ns;
5378 int new_friend_is_defn;
5379
5380 /* We must save some information from NEW_FRIEND before calling
5381 duplicate decls since that function will free NEW_FRIEND if
5382 possible. */
5383 new_friend_template_info = DECL_TEMPLATE_INFO (new_friend);
5384 new_friend_is_defn =
5385 (DECL_INITIAL (DECL_TEMPLATE_RESULT
5386 (template_for_substitution (new_friend)))
5387 != NULL_TREE);
5388 if (TREE_CODE (new_friend) == TEMPLATE_DECL)
5389 {
5390 /* This declaration is a `primary' template. */
5391 DECL_PRIMARY_TEMPLATE (new_friend) = new_friend;
5392
5393 new_friend_result_template_info
5394 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend));
5395 }
5396 else
5397 new_friend_result_template_info = NULL_TREE;
5398
5399 /* Make the init_value nonzero so pushdecl knows this is a defn. */
5400 if (new_friend_is_defn)
5401 DECL_INITIAL (new_friend) = error_mark_node;
5402
5403 /* Inside pushdecl_namespace_level, we will push into the
5404 current namespace. However, the friend function should go
5405 into the namespace of the template. */
5406 ns = decl_namespace_context (new_friend);
5407 push_nested_namespace (ns);
5408 old_decl = pushdecl_namespace_level (new_friend, /*is_friend=*/true);
5409 pop_nested_namespace (ns);
5410
5411 if (old_decl == error_mark_node)
5412 return error_mark_node;
5413
5414 if (old_decl != new_friend)
5415 {
5416 /* This new friend declaration matched an existing
5417 declaration. For example, given:
5418
5419 template <class T> void f(T);
5420 template <class U> class C {
5421 template <class T> friend void f(T) {}
5422 };
5423
5424 the friend declaration actually provides the definition
5425 of `f', once C has been instantiated for some type. So,
5426 old_decl will be the out-of-class template declaration,
5427 while new_friend is the in-class definition.
5428
5429 But, if `f' was called before this point, the
5430 instantiation of `f' will have DECL_TI_ARGS corresponding
5431 to `T' but not to `U', references to which might appear
5432 in the definition of `f'. Previously, the most general
5433 template for an instantiation of `f' was the out-of-class
5434 version; now it is the in-class version. Therefore, we
5435 run through all specialization of `f', adding to their
5436 DECL_TI_ARGS appropriately. In particular, they need a
5437 new set of outer arguments, corresponding to the
5438 arguments for this class instantiation.
5439
5440 The same situation can arise with something like this:
5441
5442 friend void f(int);
5443 template <class T> class C {
5444 friend void f(T) {}
5445 };
5446
5447 when `C<int>' is instantiated. Now, `f(int)' is defined
5448 in the class. */
5449
5450 if (!new_friend_is_defn)
5451 /* On the other hand, if the in-class declaration does
5452 *not* provide a definition, then we don't want to alter
5453 existing definitions. We can just leave everything
5454 alone. */
5455 ;
5456 else
5457 {
5458 /* Overwrite whatever template info was there before, if
5459 any, with the new template information pertaining to
5460 the declaration. */
5461 DECL_TEMPLATE_INFO (old_decl) = new_friend_template_info;
5462
5463 if (TREE_CODE (old_decl) != TEMPLATE_DECL)
5464 reregister_specialization (new_friend,
5465 most_general_template (old_decl),
5466 old_decl);
5467 else
5468 {
5469 tree t;
5470 tree new_friend_args;
5471
5472 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl))
5473 = new_friend_result_template_info;
5474
5475 new_friend_args = TI_ARGS (new_friend_template_info);
5476 for (t = DECL_TEMPLATE_SPECIALIZATIONS (old_decl);
5477 t != NULL_TREE;
5478 t = TREE_CHAIN (t))
5479 {
5480 tree spec = TREE_VALUE (t);
5481
5482 DECL_TI_ARGS (spec)
5483 = add_outermost_template_args (new_friend_args,
5484 DECL_TI_ARGS (spec));
5485 }
5486
5487 /* Now, since specializations are always supposed to
5488 hang off of the most general template, we must move
5489 them. */
5490 t = most_general_template (old_decl);
5491 if (t != old_decl)
5492 {
5493 DECL_TEMPLATE_SPECIALIZATIONS (t)
5494 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (t),
5495 DECL_TEMPLATE_SPECIALIZATIONS (old_decl));
5496 DECL_TEMPLATE_SPECIALIZATIONS (old_decl) = NULL_TREE;
5497 }
5498 }
5499 }
5500
5501 /* The information from NEW_FRIEND has been merged into OLD_DECL
5502 by duplicate_decls. */
5503 new_friend = old_decl;
5504 }
5505 }
5506 else
5507 {
5508 tree context = DECL_CONTEXT (new_friend);
5509 bool dependent_p;
5510
5511 /* In the code
5512 template <class T> class C {
5513 template <class U> friend void C1<U>::f (); // case 1
5514 friend void C2<T>::f (); // case 2
5515 };
5516 we only need to make sure CONTEXT is a complete type for
5517 case 2. To distinguish between the two cases, we note that
5518 CONTEXT of case 1 remains dependent type after tsubst while
5519 this isn't true for case 2. */
5520 ++processing_template_decl;
5521 dependent_p = dependent_type_p (context);
5522 --processing_template_decl;
5523
5524 if (!dependent_p
5525 && !complete_type_or_else (context, NULL_TREE))
5526 return error_mark_node;
5527
5528 if (COMPLETE_TYPE_P (context))
5529 {
5530 /* Check to see that the declaration is really present, and,
5531 possibly obtain an improved declaration. */
5532 tree fn = check_classfn (context,
5533 new_friend, NULL_TREE);
5534
5535 if (fn)
5536 new_friend = fn;
5537 }
5538 }
5539
5540 return new_friend;
5541}
5542
5543/* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
5544 template arguments, as for tsubst.
5545
5546 Returns an appropriate tsubst'd friend type or error_mark_node on
5547 failure. */
5548
5549static tree
5550tsubst_friend_class (tree friend_tmpl, tree args)
5551{
5552 tree friend_type;
5553 tree tmpl;
5554 tree context;
5555
5556 context = DECL_CONTEXT (friend_tmpl);
5557
5558 if (context)
5559 {
5560 if (TREE_CODE (context) == NAMESPACE_DECL)
5561 push_nested_namespace (context);
5562 else
5563 push_nested_class (tsubst (context, args, tf_none, NULL_TREE));
5564 }
5565
5566 /* Look for a class template declaration. We look for hidden names
5567 because two friend declarations of the same template are the
5568 same. For example, in:
5569
5570 struct A {
5571 template <typename> friend class F;
5572 };
5573 template <typename> struct B {
5574 template <typename> friend class F;
5575 };
5576
5577 both F templates are the same. */
5578 tmpl = lookup_name_real (DECL_NAME (friend_tmpl), 0, 0,
5579 /*block_p=*/true, 0,
5580 LOOKUP_COMPLAIN | LOOKUP_HIDDEN);
5581
5582 /* But, if we don't find one, it might be because we're in a
5583 situation like this:
5584
5585 template <class T>
5586 struct S {
5587 template <class U>
5588 friend struct S;
5589 };
5590
5591 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
5592 for `S<int>', not the TEMPLATE_DECL. */
5593 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5594 {
5595 tmpl = lookup_name_prefer_type (DECL_NAME (friend_tmpl), 1);
5596 tmpl = maybe_get_template_decl_from_type_decl (tmpl);
5597 }
5598
5599 if (tmpl && DECL_CLASS_TEMPLATE_P (tmpl))
5600 {
5601 /* The friend template has already been declared. Just
5602 check to see that the declarations match, and install any new
5603 default parameters. We must tsubst the default parameters,
5604 of course. We only need the innermost template parameters
5605 because that is all that redeclare_class_template will look
5606 at. */
5607 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl))
5608 > TMPL_ARGS_DEPTH (args))
5609 {
5610 tree parms;
5611 parms = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl),
5612 args, tf_warning_or_error);
5613 redeclare_class_template (TREE_TYPE (tmpl), parms);
5614 }
5615
5616 friend_type = TREE_TYPE (tmpl);
5617 }
5618 else
5619 {
5620 /* The friend template has not already been declared. In this
5621 case, the instantiation of the template class will cause the
5622 injection of this template into the global scope. */
5623 tmpl = tsubst (friend_tmpl, args, tf_warning_or_error, NULL_TREE);
5624 if (tmpl == error_mark_node)
5625 return error_mark_node;
5626
5627 /* The new TMPL is not an instantiation of anything, so we
5628 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
5629 the new type because that is supposed to be the corresponding
5630 template decl, i.e., TMPL. */
5631 DECL_USE_TEMPLATE (tmpl) = 0;
5632 DECL_TEMPLATE_INFO (tmpl) = NULL_TREE;
5633 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl)) = 0;
5634 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl))
5635 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl)));
5636
5637 /* Inject this template into the global scope. */
5638 friend_type = TREE_TYPE (pushdecl_top_level_maybe_friend (tmpl, true));
5639 }
5640
5641 if (context)
5642 {
5643 if (TREE_CODE (context) == NAMESPACE_DECL)
5644 pop_nested_namespace (context);
5645 else
5646 pop_nested_class ();
5647 }
5648
5649 return friend_type;
5650}
5651
5652/* Returns zero if TYPE cannot be completed later due to circularity.
5653 Otherwise returns one. */
5654
5655static int
5656can_complete_type_without_circularity (tree type)
5657{
5658 if (type == NULL_TREE || type == error_mark_node)
5659 return 0;
5660 else if (COMPLETE_TYPE_P (type))
5661 return 1;
5662 else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
5663 return can_complete_type_without_circularity (TREE_TYPE (type));
5664 else if (CLASS_TYPE_P (type)
5665 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type)))
5666 return 0;
5667 else
5668 return 1;
5669}
5670
5671tree
5672instantiate_class_template (tree type)
5673{
5674 tree template, args, pattern, t, member;
5675 tree typedecl;
5676 tree pbinfo;
5677 tree base_list;
5678
5679 if (type == error_mark_node)
5680 return error_mark_node;
5681
5682 if (TYPE_BEING_DEFINED (type)
5683 || COMPLETE_TYPE_P (type)
5684 || dependent_type_p (type))
5685 return type;
5686
5687 /* Figure out which template is being instantiated. */
5688 template = most_general_template (CLASSTYPE_TI_TEMPLATE (type));
5689 gcc_assert (TREE_CODE (template) == TEMPLATE_DECL);
5690
5691 /* Determine what specialization of the original template to
5692 instantiate. */
5693 t = most_specialized_class (type, template);
5694 if (t == error_mark_node)
5695 {
5696 TYPE_BEING_DEFINED (type) = 1;
5697 return error_mark_node;
5698 }
5699 else if (t)
5700 {
5701 /* This TYPE is actually an instantiation of a partial
5702 specialization. We replace the innermost set of ARGS with
5703 the arguments appropriate for substitution. For example,
5704 given:
5705
5706 template <class T> struct S {};
5707 template <class T> struct S<T*> {};
5708
5709 and supposing that we are instantiating S<int*>, ARGS will
5710 presently be {int*} -- but we need {int}. */
5711 pattern = TREE_TYPE (t);
5712 args = TREE_PURPOSE (t);
5713 }
5714 else
5715 {
5716 pattern = TREE_TYPE (template);
5717 args = CLASSTYPE_TI_ARGS (type);
5718 }
5719
5720 /* If the template we're instantiating is incomplete, then clearly
5721 there's nothing we can do. */
5722 if (!COMPLETE_TYPE_P (pattern))
5723 return type;
5724
5725 /* If we've recursively instantiated too many templates, stop. */
5726 if (! push_tinst_level (type))
5727 return type;
5728
5729 /* Now we're really doing the instantiation. Mark the type as in
5730 the process of being defined. */
5731 TYPE_BEING_DEFINED (type) = 1;
5732
5733 /* We may be in the middle of deferred access check. Disable
5734 it now. */
5735 push_deferring_access_checks (dk_no_deferred);
5736
5737 push_to_top_level ();
5738
5739 SET_CLASSTYPE_INTERFACE_UNKNOWN (type);
5740
5741 /* Set the input location to the template definition. This is needed
5742 if tsubsting causes an error. */
5743 typedecl = TYPE_MAIN_DECL (type);
5744 input_location = DECL_SOURCE_LOCATION (typedecl);
5745 in_system_header = DECL_IN_SYSTEM_HEADER (typedecl);
5746
5747 TYPE_HAS_CONSTRUCTOR (type) = TYPE_HAS_CONSTRUCTOR (pattern);
5748 TYPE_HAS_NEW_OPERATOR (type) = TYPE_HAS_NEW_OPERATOR (pattern);
5749 TYPE_HAS_ARRAY_NEW_OPERATOR (type) = TYPE_HAS_ARRAY_NEW_OPERATOR (pattern);
5750 TYPE_GETS_DELETE (type) = TYPE_GETS_DELETE (pattern);
5751 TYPE_HAS_ASSIGN_REF (type) = TYPE_HAS_ASSIGN_REF (pattern);
5752 TYPE_HAS_CONST_ASSIGN_REF (type) = TYPE_HAS_CONST_ASSIGN_REF (pattern);
5753 TYPE_HAS_INIT_REF (type) = TYPE_HAS_INIT_REF (pattern);
5754 TYPE_HAS_CONST_INIT_REF (type) = TYPE_HAS_CONST_INIT_REF (pattern);
5755 TYPE_HAS_DEFAULT_CONSTRUCTOR (type) = TYPE_HAS_DEFAULT_CONSTRUCTOR (pattern);
5756 TYPE_HAS_CONVERSION (type) = TYPE_HAS_CONVERSION (pattern);
5757 TYPE_PACKED (type) = TYPE_PACKED (pattern);
5758 TYPE_ALIGN (type) = TYPE_ALIGN (pattern);
5759 TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (pattern);
5760 TYPE_FOR_JAVA (type) = TYPE_FOR_JAVA (pattern); /* For libjava's JArray<T> */
5761 if (ANON_AGGR_TYPE_P (pattern))
5762 SET_ANON_AGGR_TYPE_P (type);
5763 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern))
5764 {
5765 CLASSTYPE_VISIBILITY_SPECIFIED (type) = 1;
5766 CLASSTYPE_VISIBILITY (type) = CLASSTYPE_VISIBILITY (pattern);
5767 }
5768
5769 pbinfo = TYPE_BINFO (pattern);
5770
5771 /* We should never instantiate a nested class before its enclosing
5772 class; we need to look up the nested class by name before we can
5773 instantiate it, and that lookup should instantiate the enclosing
5774 class. */
5775 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern))
5776 || COMPLETE_TYPE_P (TYPE_CONTEXT (type))
5777 || TYPE_BEING_DEFINED (TYPE_CONTEXT (type)));
5778
5779 base_list = NULL_TREE;
5780 if (BINFO_N_BASE_BINFOS (pbinfo))
5781 {
5782 tree pbase_binfo;
5783 tree context = TYPE_CONTEXT (type);
5784 tree pushed_scope;
5785 int i;
5786
5787 /* We must enter the scope containing the type, as that is where
5788 the accessibility of types named in dependent bases are
5789 looked up from. */
5790 pushed_scope = push_scope (context ? context : global_namespace);
5791
5792 /* Substitute into each of the bases to determine the actual
5793 basetypes. */
5794 for (i = 0; BINFO_BASE_ITERATE (pbinfo, i, pbase_binfo); i++)
5795 {
5796 tree base;
5797 tree access = BINFO_BASE_ACCESS (pbinfo, i);
5798
5799 /* Substitute to figure out the base class. */
5800 base = tsubst (BINFO_TYPE (pbase_binfo), args, tf_error, NULL_TREE);
5801 if (base == error_mark_node)
5802 continue;
5803
5804 base_list = tree_cons (access, base, base_list);
5805 if (BINFO_VIRTUAL_P (pbase_binfo))
5806 TREE_TYPE (base_list) = integer_type_node;
5807 }
5808
5809 /* The list is now in reverse order; correct that. */
5810 base_list = nreverse (base_list);
5811
5812 if (pushed_scope)
5813 pop_scope (pushed_scope);
5814 }
5815 /* Now call xref_basetypes to set up all the base-class
5816 information. */
5817 xref_basetypes (type, base_list);
5818
5819
5820 /* Now that our base classes are set up, enter the scope of the
5821 class, so that name lookups into base classes, etc. will work
5822 correctly. This is precisely analogous to what we do in
5823 begin_class_definition when defining an ordinary non-template
5824 class. */
5825 pushclass (type);
5826
5827 /* Now members are processed in the order of declaration. */
5828 for (member = CLASSTYPE_DECL_LIST (pattern);
5829 member; member = TREE_CHAIN (member))
5830 {
5831 tree t = TREE_VALUE (member);
5832
5833 if (TREE_PURPOSE (member))
5834 {
5835 if (TYPE_P (t))
5836 {
5837 /* Build new CLASSTYPE_NESTED_UTDS. */
5838
5839 tree newtag;
5840 bool class_template_p;
5841
5842 class_template_p = (TREE_CODE (t) != ENUMERAL_TYPE
5843 && TYPE_LANG_SPECIFIC (t)
5844 && CLASSTYPE_IS_TEMPLATE (t));
5845 /* If the member is a class template, then -- even after
5846 substitution -- there may be dependent types in the
5847 template argument list for the class. We increment
5848 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
5849 that function will assume that no types are dependent
5850 when outside of a template. */
5851 if (class_template_p)
5852 ++processing_template_decl;
5853 newtag = tsubst (t, args, tf_error, NULL_TREE);
5854 if (class_template_p)
5855 --processing_template_decl;
5856 if (newtag == error_mark_node)
5857 continue;
5858
5859 if (TREE_CODE (newtag) != ENUMERAL_TYPE)
5860 {
5861 tree name = TYPE_IDENTIFIER (t);
5862
5863 if (class_template_p)
5864 /* Unfortunately, lookup_template_class sets
5865 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
5866 instantiation (i.e., for the type of a member
5867 template class nested within a template class.)
5868 This behavior is required for
5869 maybe_process_partial_specialization to work
5870 correctly, but is not accurate in this case;
5871 the TAG is not an instantiation of anything.
5872 (The corresponding TEMPLATE_DECL is an
5873 instantiation, but the TYPE is not.) */
5874 CLASSTYPE_USE_TEMPLATE (newtag) = 0;
5875
5876 /* Now, we call pushtag to put this NEWTAG into the scope of
5877 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
5878 pushtag calling push_template_decl. We don't have to do
5879 this for enums because it will already have been done in
5880 tsubst_enum. */
5881 if (name)
5882 SET_IDENTIFIER_TYPE_VALUE (name, newtag);
5883 pushtag (name, newtag, /*tag_scope=*/ts_current);
5884 }
5885 }
5886 else if (TREE_CODE (t) == FUNCTION_DECL
5887 || DECL_FUNCTION_TEMPLATE_P (t))
5888 {
5889 /* Build new TYPE_METHODS. */
5890 tree r;
5891
5892 if (TREE_CODE (t) == TEMPLATE_DECL)
5893 ++processing_template_decl;
5894 r = tsubst (t, args, tf_error, NULL_TREE);
5895 if (TREE_CODE (t) == TEMPLATE_DECL)
5896 --processing_template_decl;
5897 set_current_access_from_decl (r);
5898 finish_member_declaration (r);
5899 }
5900 else
5901 {
5902 /* Build new TYPE_FIELDS. */
5903
5904 if (TREE_CODE (t) != CONST_DECL)
5905 {
5906 tree r;
5907
5908 /* The the file and line for this declaration, to
5909 assist in error message reporting. Since we
5910 called push_tinst_level above, we don't need to
5911 restore these. */
5912 input_location = DECL_SOURCE_LOCATION (t);
5913
5914 if (TREE_CODE (t) == TEMPLATE_DECL)
5915 ++processing_template_decl;
5916 r = tsubst (t, args, tf_warning_or_error, NULL_TREE);
5917 if (TREE_CODE (t) == TEMPLATE_DECL)
5918 --processing_template_decl;
5919 if (TREE_CODE (r) == VAR_DECL)
5920 {
5921 /* In [temp.inst]:
5922
5923 [t]he initialization (and any associated
5924 side-effects) of a static data member does
5925 not occur unless the static data member is
5926 itself used in a way that requires the
5927 definition of the static data member to
5928 exist.
5929
5930 Therefore, we do not substitute into the
5931 initialized for the static data member here. */
5932 finish_static_data_member_decl
5933 (r,
5934 /*init=*/NULL_TREE,
5935 /*init_const_expr_p=*/false,
5936 /*asmspec_tree=*/NULL_TREE,
5937 /*flags=*/0);
5938 if (DECL_INITIALIZED_IN_CLASS_P (r))
5939 check_static_variable_definition (r, TREE_TYPE (r));
5940 }
5941 else if (TREE_CODE (r) == FIELD_DECL)
5942 {
5943 /* Determine whether R has a valid type and can be
5944 completed later. If R is invalid, then it is
5945 replaced by error_mark_node so that it will not be
5946 added to TYPE_FIELDS. */
5947 tree rtype = TREE_TYPE (r);
5948 if (can_complete_type_without_circularity (rtype))
5949 complete_type (rtype);
5950
5951 if (!COMPLETE_TYPE_P (rtype))
5952 {
5953 cxx_incomplete_type_error (r, rtype);
5954 r = error_mark_node;
5955 }
5956 }
5957
5958 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
5959 such a thing will already have been added to the field
5960 list by tsubst_enum in finish_member_declaration in the
5961 CLASSTYPE_NESTED_UTDS case above. */
5962 if (!(TREE_CODE (r) == TYPE_DECL
5963 && TREE_CODE (TREE_TYPE (r)) == ENUMERAL_TYPE
5964 && DECL_ARTIFICIAL (r)))
5965 {
5966 set_current_access_from_decl (r);
5967 finish_member_declaration (r);
5968 }
5969 }
5970 }
5971 }
5972 else
5973 {
5974 if (TYPE_P (t) || DECL_CLASS_TEMPLATE_P (t))
5975 {
5976 /* Build new CLASSTYPE_FRIEND_CLASSES. */
5977
5978 tree friend_type = t;
5979 bool adjust_processing_template_decl = false;
5980
5981 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
5982 {
5983 /* template <class T> friend class C; */
5984 friend_type = tsubst_friend_class (friend_type, args);
5985 adjust_processing_template_decl = true;
5986 }
5987 else if (TREE_CODE (friend_type) == UNBOUND_CLASS_TEMPLATE)
5988 {
5989 /* template <class T> friend class C::D; */
5990 friend_type = tsubst (friend_type, args,
5991 tf_warning_or_error, NULL_TREE);
5992 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
5993 friend_type = TREE_TYPE (friend_type);
5994 adjust_processing_template_decl = true;
5995 }
5996 else if (TREE_CODE (friend_type) == TYPENAME_TYPE)
5997 {
5998 /* This could be either
5999
6000 friend class T::C;
6001
6002 when dependent_type_p is false or
6003
6004 template <class U> friend class T::C;
6005
6006 otherwise. */
6007 friend_type = tsubst (friend_type, args,
6008 tf_warning_or_error, NULL_TREE);
6009 /* Bump processing_template_decl for correct
6010 dependent_type_p calculation. */
6011 ++processing_template_decl;
6012 if (dependent_type_p (friend_type))
6013 adjust_processing_template_decl = true;
6014 --processing_template_decl;
6015 }
6016 else if (!CLASSTYPE_USE_TEMPLATE (friend_type)
6017 && hidden_name_p (TYPE_NAME (friend_type)))
6018 {
6019 /* friend class C;
6020
6021 where C hasn't been declared yet. Let's lookup name
6022 from namespace scope directly, bypassing any name that
6023 come from dependent base class. */
6024 tree ns = decl_namespace_context (TYPE_MAIN_DECL (friend_type));
6025
6026 /* The call to xref_tag_from_type does injection for friend
6027 classes. */
6028 push_nested_namespace (ns);
6029 friend_type =
6030 xref_tag_from_type (friend_type, NULL_TREE,
6031 /*tag_scope=*/ts_current);
6032 pop_nested_namespace (ns);
6033 }
6034 else if (uses_template_parms (friend_type))
6035 /* friend class C<T>; */
6036 friend_type = tsubst (friend_type, args,
6037 tf_warning_or_error, NULL_TREE);
6038 /* Otherwise it's
6039
6040 friend class C;
6041
6042 where C is already declared or
6043
6044 friend class C<int>;
6045
6046 We don't have to do anything in these cases. */
6047
6048 if (adjust_processing_template_decl)
6049 /* Trick make_friend_class into realizing that the friend
6050 we're adding is a template, not an ordinary class. It's
6051 important that we use make_friend_class since it will
6052 perform some error-checking and output cross-reference
6053 information. */
6054 ++processing_template_decl;
6055
6056 if (friend_type != error_mark_node)
6057 make_friend_class (type, friend_type, /*complain=*/false);
6058
6059 if (adjust_processing_template_decl)
6060 --processing_template_decl;
6061 }
6062 else
6063 {
6064 /* Build new DECL_FRIENDLIST. */
6065 tree r;
6066
6067 /* The the file and line for this declaration, to
6068 assist in error message reporting. Since we
6069 called push_tinst_level above, we don't need to
6070 restore these. */
6071 input_location = DECL_SOURCE_LOCATION (t);
6072
6073 if (TREE_CODE (t) == TEMPLATE_DECL)
6074 {
6075 ++processing_template_decl;
6076 push_deferring_access_checks (dk_no_check);
6077 }
6078
6079 r = tsubst_friend_function (t, args);
6080 add_friend (type, r, /*complain=*/false);
6081 if (TREE_CODE (t) == TEMPLATE_DECL)
6082 {
6083 pop_deferring_access_checks ();
6084 --processing_template_decl;
6085 }
6086 }
6087 }
6088 }
6089
6090 /* Set the file and line number information to whatever is given for
6091 the class itself. This puts error messages involving generated
6092 implicit functions at a predictable point, and the same point
6093 that would be used for non-template classes. */
6094 input_location = DECL_SOURCE_LOCATION (typedecl);
6095
6096 unreverse_member_declarations (type);
6097 finish_struct_1 (type);
6098 TYPE_BEING_DEFINED (type) = 0;
6099
6100 /* Now that the class is complete, instantiate default arguments for
6101 any member functions. We don't do this earlier because the
6102 default arguments may reference members of the class. */
6103 if (!PRIMARY_TEMPLATE_P (template))
6104 for (t = TYPE_METHODS (type); t; t = TREE_CHAIN (t))
6105 if (TREE_CODE (t) == FUNCTION_DECL
6106 /* Implicitly generated member functions will not have template
6107 information; they are not instantiations, but instead are
6108 created "fresh" for each instantiation. */
6109 && DECL_TEMPLATE_INFO (t))
6110 tsubst_default_arguments (t);
6111
6112 popclass ();
6113 pop_from_top_level ();
6114 pop_deferring_access_checks ();
6115 pop_tinst_level ();
6116
6117 /* The vtable for a template class can be emitted in any translation
6118 unit in which the class is instantiated. When there is no key
6119 method, however, finish_struct_1 will already have added TYPE to
6120 the keyed_classes list. */
6121 if (TYPE_CONTAINS_VPTR_P (type) && CLASSTYPE_KEY_METHOD (type))
6122 keyed_classes = tree_cons (NULL_TREE, type, keyed_classes);
6123
6124 return type;
6125}
6126
6127static tree
6128tsubst_template_arg (tree t, tree args, tsubst_flags_t complain, tree in_decl)
6129{
6130 tree r;
6131
6132 if (!t)
6133 r = t;
6134 else if (TYPE_P (t))
6135 r = tsubst (t, args, complain, in_decl);
6136 else
6137 {
6138 r = tsubst_expr (t, args, complain, in_decl,
6139 /*integral_constant_expression_p=*/true);
6140 r = fold_non_dependent_expr (r);
6141 }
6142 return r;
6143}
6144
6145/* Substitute ARGS into the vector or list of template arguments T. */
6146
6147static tree
6148tsubst_template_args (tree t, tree args, tsubst_flags_t complain, tree in_decl)
6149{
6150 int len = TREE_VEC_LENGTH (t);
6151 int need_new = 0, i;
6152 tree *elts = (tree *) alloca (len * sizeof (tree));
6153
6154 for (i = 0; i < len; i++)
6155 {
6156 tree orig_arg = TREE_VEC_ELT (t, i);
6157 tree new_arg;
6158
6159 if (TREE_CODE (orig_arg) == TREE_VEC)
6160 new_arg = tsubst_template_args (orig_arg, args, complain, in_decl);
6161 else
6162 new_arg = tsubst_template_arg (orig_arg, args, complain, in_decl);
6163
6164 if (new_arg == error_mark_node)
6165 return error_mark_node;
6166
6167 elts[i] = new_arg;
6168 if (new_arg != orig_arg)
6169 need_new = 1;
6170 }
6171
6172 if (!need_new)
6173 return t;
6174
6175 t = make_tree_vec (len);
6176 for (i = 0; i < len; i++)
6177 TREE_VEC_ELT (t, i) = elts[i];
6178
6179 return t;
6180}
6181
6182/* Return the result of substituting ARGS into the template parameters
6183 given by PARMS. If there are m levels of ARGS and m + n levels of
6184 PARMS, then the result will contain n levels of PARMS. For
6185 example, if PARMS is `template <class T> template <class U>
6186 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
6187 result will be `template <int*, double, class V>'. */
6188
6189static tree
6190tsubst_template_parms (tree parms, tree args, tsubst_flags_t complain)
6191{
6192 tree r = NULL_TREE;
6193 tree* new_parms;
6194
6195 /* When substituting into a template, we must set
6196 PROCESSING_TEMPLATE_DECL as the template parameters may be
6197 dependent if they are based on one-another, and the dependency
6198 predicates are short-circuit outside of templates. */
6199 ++processing_template_decl;
6200
6201 for (new_parms = &r;
6202 TMPL_PARMS_DEPTH (parms) > TMPL_ARGS_DEPTH (args);
6203 new_parms = &(TREE_CHAIN (*new_parms)),
6204 parms = TREE_CHAIN (parms))
6205 {
6206 tree new_vec =
6207 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms)));
6208 int i;
6209
6210 for (i = 0; i < TREE_VEC_LENGTH (new_vec); ++i)
6211 {
6212 tree tuple;
6213 tree default_value;
6214 tree parm_decl;
6215
6216 if (parms == error_mark_node)
6217 continue;
6218
6219 tuple = TREE_VEC_ELT (TREE_VALUE (parms), i);
6220
6221 if (tuple == error_mark_node)
6222 continue;
6223
6224 default_value = TREE_PURPOSE (tuple);
6225 parm_decl = TREE_VALUE (tuple);
6226
6227 parm_decl = tsubst (parm_decl, args, complain, NULL_TREE);
6228 if (TREE_CODE (parm_decl) == PARM_DECL
6229 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl), complain))
6230 parm_decl = error_mark_node;
6231 default_value = tsubst_template_arg (default_value, args,
6232 complain, NULL_TREE);
6233
6234 tuple = build_tree_list (default_value, parm_decl);
6235 TREE_VEC_ELT (new_vec, i) = tuple;
6236 }
6237
6238 *new_parms =
6239 tree_cons (size_int (TMPL_PARMS_DEPTH (parms)
6240 - TMPL_ARGS_DEPTH (args)),
6241 new_vec, NULL_TREE);
6242 }
6243
6244 --processing_template_decl;
6245
6246 return r;
6247}
6248
6249/* Substitute the ARGS into the indicated aggregate (or enumeration)
6250 type T. If T is not an aggregate or enumeration type, it is
6251 handled as if by tsubst. IN_DECL is as for tsubst. If
6252 ENTERING_SCOPE is nonzero, T is the context for a template which
6253 we are presently tsubst'ing. Return the substituted value. */
6254
6255static tree
6256tsubst_aggr_type (tree t,
6257 tree args,
6258 tsubst_flags_t complain,
6259 tree in_decl,
6260 int entering_scope)
6261{
6262 if (t == NULL_TREE)
6263 return NULL_TREE;
6264
6265 switch (TREE_CODE (t))
6266 {
6267 case RECORD_TYPE:
6268 if (TYPE_PTRMEMFUNC_P (t))
6269 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t), args, complain, in_decl);
6270
6271 /* Else fall through. */
6272 case ENUMERAL_TYPE:
6273 case UNION_TYPE:
6274 if (TYPE_TEMPLATE_INFO (t))
6275 {
6276 tree argvec;
6277 tree context;
6278 tree r;
6279 bool saved_skip_evaluation;
6280
6281 /* In "sizeof(X<I>)" we need to evaluate "I". */
6282 saved_skip_evaluation = skip_evaluation;
6283 skip_evaluation = false;
6284
6285 /* First, determine the context for the type we are looking
6286 up. */
6287 context = TYPE_CONTEXT (t);
6288 if (context)
6289 context = tsubst_aggr_type (context, args, complain,
6290 in_decl, /*entering_scope=*/1);
6291
6292 /* Then, figure out what arguments are appropriate for the
6293 type we are trying to find. For example, given:
6294
6295 template <class T> struct S;
6296 template <class T, class U> void f(T, U) { S<U> su; }
6297
6298 and supposing that we are instantiating f<int, double>,
6299 then our ARGS will be {int, double}, but, when looking up
6300 S we only want {double}. */
6301 argvec = tsubst_template_args (TYPE_TI_ARGS (t), args,
6302 complain, in_decl);
6303 if (argvec == error_mark_node)
6304 r = error_mark_node;
6305 else
6306 {
6307 r = lookup_template_class (t, argvec, in_decl, context,
6308 entering_scope, complain);
6309 r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
6310 }
6311
6312 skip_evaluation = saved_skip_evaluation;
6313
6314 return r;
6315 }
6316 else
6317 /* This is not a template type, so there's nothing to do. */
6318 return t;
6319
6320 default:
6321 return tsubst (t, args, complain, in_decl);
6322 }
6323}
6324
6325/* Substitute into the default argument ARG (a default argument for
6326 FN), which has the indicated TYPE. */
6327
6328tree
6329tsubst_default_argument (tree fn, tree type, tree arg)
6330{
6331 tree saved_class_ptr = NULL_TREE;
6332 tree saved_class_ref = NULL_TREE;
6333
6334 /* This default argument came from a template. Instantiate the
6335 default argument here, not in tsubst. In the case of
6336 something like:
6337
6338 template <class T>
6339 struct S {
6340 static T t();
6341 void f(T = t());
6342 };
6343
6344 we must be careful to do name lookup in the scope of S<T>,
6345 rather than in the current class. */
6346 push_access_scope (fn);
6347 /* The "this" pointer is not valid in a default argument. */
6348 if (cfun)
6349 {
6350 saved_class_ptr = current_class_ptr;
6351 cp_function_chain->x_current_class_ptr = NULL_TREE;
6352 saved_class_ref = current_class_ref;
6353 cp_function_chain->x_current_class_ref = NULL_TREE;
6354 }
6355
6356 push_deferring_access_checks(dk_no_deferred);
6357 /* The default argument expression may cause implicitly defined
6358 member functions to be synthesized, which will result in garbage
6359 collection. We must treat this situation as if we were within
6360 the body of function so as to avoid collecting live data on the
6361 stack. */
6362 ++function_depth;
6363 arg = tsubst_expr (arg, DECL_TI_ARGS (fn),
6364 tf_warning_or_error, NULL_TREE,
6365 /*integral_constant_expression_p=*/false);
6366 --function_depth;
6367 pop_deferring_access_checks();
6368
6369 /* Restore the "this" pointer. */
6370 if (cfun)
6371 {
6372 cp_function_chain->x_current_class_ptr = saved_class_ptr;
6373 cp_function_chain->x_current_class_ref = saved_class_ref;
6374 }
6375
6376 pop_access_scope (fn);
6377
6378 /* Make sure the default argument is reasonable. */
6379 arg = check_default_argument (type, arg);
6380
6381 return arg;
6382}
6383
6384/* Substitute into all the default arguments for FN. */
6385
6386static void
6387tsubst_default_arguments (tree fn)
6388{
6389 tree arg;
6390 tree tmpl_args;
6391
6392 tmpl_args = DECL_TI_ARGS (fn);
6393
6394 /* If this function is not yet instantiated, we certainly don't need
6395 its default arguments. */
6396 if (uses_template_parms (tmpl_args))
6397 return;
6398
6399 for (arg = TYPE_ARG_TYPES (TREE_TYPE (fn));
6400 arg;
6401 arg = TREE_CHAIN (arg))
6402 if (TREE_PURPOSE (arg))
6403 TREE_PURPOSE (arg) = tsubst_default_argument (fn,
6404 TREE_VALUE (arg),
6405 TREE_PURPOSE (arg));
6406}
6407
6408/* Substitute the ARGS into the T, which is a _DECL. Return the
6409 result of the substitution. Issue error and warning messages under
6410 control of COMPLAIN. */
6411
6412static tree
6413tsubst_decl (tree t, tree args, tsubst_flags_t complain)
6414{
6415 location_t saved_loc;
6416 tree r = NULL_TREE;
6417 tree in_decl = t;
6418
6419 /* Set the filename and linenumber to improve error-reporting. */
6420 saved_loc = input_location;
6421 input_location = DECL_SOURCE_LOCATION (t);
6422
6423 switch (TREE_CODE (t))
6424 {
6425 case TEMPLATE_DECL:
6426 {
6427 /* We can get here when processing a member function template,
6428 member class template, and template template parameter of
6429 a template class. */
6430 tree decl = DECL_TEMPLATE_RESULT (t);
6431 tree spec;
6432 tree tmpl_args;
6433 tree full_args;
6434
6435 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
6436 {
6437 /* Template template parameter is treated here. */
6438 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6439 if (new_type == error_mark_node)
6440 return error_mark_node;
6441
6442 r = copy_decl (t);
6443 TREE_CHAIN (r) = NULL_TREE;
6444 TREE_TYPE (r) = new_type;
6445 DECL_TEMPLATE_RESULT (r)
6446 = build_decl (TYPE_DECL, DECL_NAME (decl), new_type);
6447 DECL_TEMPLATE_PARMS (r)
6448 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
6449 complain);
6450 TYPE_NAME (new_type) = r;
6451 break;
6452 }
6453
6454 /* We might already have an instance of this template.
6455 The ARGS are for the surrounding class type, so the
6456 full args contain the tsubst'd args for the context,
6457 plus the innermost args from the template decl. */
6458 tmpl_args = DECL_CLASS_TEMPLATE_P (t)
6459 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t))
6460 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t));
6461 /* Because this is a template, the arguments will still be
6462 dependent, even after substitution. If
6463 PROCESSING_TEMPLATE_DECL is not set, the dependency
6464 predicates will short-circuit. */
6465 ++processing_template_decl;
6466 full_args = tsubst_template_args (tmpl_args, args,
6467 complain, in_decl);
6468 --processing_template_decl;
6469 if (full_args == error_mark_node)
6470 return error_mark_node;
6471
6472 /* tsubst_template_args doesn't copy the vector if
6473 nothing changed. But, *something* should have
6474 changed. */
6475 gcc_assert (full_args != tmpl_args);
6476
6477 spec = retrieve_specialization (t, full_args,
6478 /*class_specializations_p=*/true);
6479 if (spec != NULL_TREE)
6480 {
6481 r = spec;
6482 break;
6483 }
6484
6485 /* Make a new template decl. It will be similar to the
6486 original, but will record the current template arguments.
6487 We also create a new function declaration, which is just
6488 like the old one, but points to this new template, rather
6489 than the old one. */
6490 r = copy_decl (t);
6491 gcc_assert (DECL_LANG_SPECIFIC (r) != 0);
6492 TREE_CHAIN (r) = NULL_TREE;
6493
6494 DECL_TEMPLATE_INFO (r) = build_tree_list (t, args);
6495
6496 if (TREE_CODE (decl) == TYPE_DECL)
6497 {
6498 tree new_type;
6499 ++processing_template_decl;
6500 new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6501 --processing_template_decl;
6502 if (new_type == error_mark_node)
6503 return error_mark_node;
6504
6505 TREE_TYPE (r) = new_type;
6506 CLASSTYPE_TI_TEMPLATE (new_type) = r;
6507 DECL_TEMPLATE_RESULT (r) = TYPE_MAIN_DECL (new_type);
6508 DECL_TI_ARGS (r) = CLASSTYPE_TI_ARGS (new_type);
6509 DECL_CONTEXT (r) = TYPE_CONTEXT (new_type);
6510 }
6511 else
6512 {
6513 tree new_decl;
6514 ++processing_template_decl;
6515 new_decl = tsubst (decl, args, complain, in_decl);
6516 --processing_template_decl;
6517 if (new_decl == error_mark_node)
6518 return error_mark_node;
6519
6520 DECL_TEMPLATE_RESULT (r) = new_decl;
6521 DECL_TI_TEMPLATE (new_decl) = r;
6522 TREE_TYPE (r) = TREE_TYPE (new_decl);
6523 DECL_TI_ARGS (r) = DECL_TI_ARGS (new_decl);
6524 DECL_CONTEXT (r) = DECL_CONTEXT (new_decl);
6525 }
6526
6527 SET_DECL_IMPLICIT_INSTANTIATION (r);
6528 DECL_TEMPLATE_INSTANTIATIONS (r) = NULL_TREE;
6529 DECL_TEMPLATE_SPECIALIZATIONS (r) = NULL_TREE;
6530
6531 /* The template parameters for this new template are all the
6532 template parameters for the old template, except the
6533 outermost level of parameters. */
6534 DECL_TEMPLATE_PARMS (r)
6535 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
6536 complain);
6537
6538 if (PRIMARY_TEMPLATE_P (t))
6539 DECL_PRIMARY_TEMPLATE (r) = r;
6540
6541 if (TREE_CODE (decl) != TYPE_DECL)
6542 /* Record this non-type partial instantiation. */
6543 register_specialization (r, t,
6544 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r)),
6545 false);
6546 }
6547 break;
6548
6549 case FUNCTION_DECL:
6550 {
6551 tree ctx;
6552 tree argvec = NULL_TREE;
6553 tree *friends;
6554 tree gen_tmpl;
6555 tree type;
6556 int member;
6557 int args_depth;
6558 int parms_depth;
6559
6560 /* Nobody should be tsubst'ing into non-template functions. */
6561 gcc_assert (DECL_TEMPLATE_INFO (t) != NULL_TREE);
6562
6563 if (TREE_CODE (DECL_TI_TEMPLATE (t)) == TEMPLATE_DECL)
6564 {
6565 tree spec;
6566 bool dependent_p;
6567
6568 /* If T is not dependent, just return it. We have to
6569 increment PROCESSING_TEMPLATE_DECL because
6570 value_dependent_expression_p assumes that nothing is
6571 dependent when PROCESSING_TEMPLATE_DECL is zero. */
6572 ++processing_template_decl;
6573 dependent_p = value_dependent_expression_p (t);
6574 --processing_template_decl;
6575 if (!dependent_p)
6576 return t;
6577
6578 /* Calculate the most general template of which R is a
6579 specialization, and the complete set of arguments used to
6580 specialize R. */
6581 gen_tmpl = most_general_template (DECL_TI_TEMPLATE (t));
6582 argvec = tsubst_template_args (DECL_TI_ARGS
6583 (DECL_TEMPLATE_RESULT (gen_tmpl)),
6584 args, complain, in_decl);
6585
6586 /* Check to see if we already have this specialization. */
6587 spec = retrieve_specialization (gen_tmpl, argvec,
6588 /*class_specializations_p=*/false);
6589
6590 if (spec)
6591 {
6592 r = spec;
6593 break;
6594 }
6595
6596 /* We can see more levels of arguments than parameters if
6597 there was a specialization of a member template, like
6598 this:
6599
6600 template <class T> struct S { template <class U> void f(); }
6601 template <> template <class U> void S<int>::f(U);
6602
6603 Here, we'll be substituting into the specialization,
6604 because that's where we can find the code we actually
6605 want to generate, but we'll have enough arguments for
6606 the most general template.
6607
6608 We also deal with the peculiar case:
6609
6610 template <class T> struct S {
6611 template <class U> friend void f();
6612 };
6613 template <class U> void f() {}
6614 template S<int>;
6615 template void f<double>();
6616
6617 Here, the ARGS for the instantiation of will be {int,
6618 double}. But, we only need as many ARGS as there are
6619 levels of template parameters in CODE_PATTERN. We are
6620 careful not to get fooled into reducing the ARGS in
6621 situations like:
6622
6623 template <class T> struct S { template <class U> void f(U); }
6624 template <class T> template <> void S<T>::f(int) {}
6625
6626 which we can spot because the pattern will be a
6627 specialization in this case. */
6628 args_depth = TMPL_ARGS_DEPTH (args);
6629 parms_depth =
6630 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t)));
6631 if (args_depth > parms_depth
6632 && !DECL_TEMPLATE_SPECIALIZATION (t))
6633 args = get_innermost_template_args (args, parms_depth);
6634 }
6635 else
6636 {
6637 /* This special case arises when we have something like this:
6638
6639 template <class T> struct S {
6640 friend void f<int>(int, double);
6641 };
6642
6643 Here, the DECL_TI_TEMPLATE for the friend declaration
6644 will be an IDENTIFIER_NODE. We are being called from
6645 tsubst_friend_function, and we want only to create a
6646 new decl (R) with appropriate types so that we can call
6647 determine_specialization. */
6648 gen_tmpl = NULL_TREE;
6649 }
6650
6651 if (DECL_CLASS_SCOPE_P (t))
6652 {
6653 if (DECL_NAME (t) == constructor_name (DECL_CONTEXT (t)))
6654 member = 2;
6655 else
6656 member = 1;
6657 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args,
6658 complain, t, /*entering_scope=*/1);
6659 }
6660 else
6661 {
6662 member = 0;
6663 ctx = DECL_CONTEXT (t);
6664 }
6665 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6666 if (type == error_mark_node)
6667 return error_mark_node;
6668
6669 /* We do NOT check for matching decls pushed separately at this
6670 point, as they may not represent instantiations of this
6671 template, and in any case are considered separate under the
6672 discrete model. */
6673 r = copy_decl (t);
6674 DECL_USE_TEMPLATE (r) = 0;
6675 TREE_TYPE (r) = type;
6676 /* Clear out the mangled name and RTL for the instantiation. */
6677 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
6678 SET_DECL_RTL (r, NULL_RTX);
6679 DECL_INITIAL (r) = NULL_TREE;
6680 DECL_CONTEXT (r) = ctx;
6681
6682 if (member && DECL_CONV_FN_P (r))
6683 /* Type-conversion operator. Reconstruct the name, in
6684 case it's the name of one of the template's parameters. */
6685 DECL_NAME (r) = mangle_conv_op_name_for_type (TREE_TYPE (type));
6686
6687 DECL_ARGUMENTS (r) = tsubst (DECL_ARGUMENTS (t), args,
6688 complain, t);
6689 DECL_RESULT (r) = NULL_TREE;
6690
6691 TREE_STATIC (r) = 0;
6692 TREE_PUBLIC (r) = TREE_PUBLIC (t);
6693 DECL_EXTERNAL (r) = 1;
6694 /* If this is an instantiation of a function with internal
6695 linkage, we already know what object file linkage will be
6696 assigned to the instantiation. */
6697 DECL_INTERFACE_KNOWN (r) = !TREE_PUBLIC (r);
6698 DECL_DEFER_OUTPUT (r) = 0;
6699 TREE_CHAIN (r) = NULL_TREE;
6700 DECL_PENDING_INLINE_INFO (r) = 0;
6701 DECL_PENDING_INLINE_P (r) = 0;
6702 DECL_SAVED_TREE (r) = NULL_TREE;
6703 TREE_USED (r) = 0;
6704 if (DECL_CLONED_FUNCTION (r))
6705 {
6706 DECL_CLONED_FUNCTION (r) = tsubst (DECL_CLONED_FUNCTION (t),
6707 args, complain, t);
6708 TREE_CHAIN (r) = TREE_CHAIN (DECL_CLONED_FUNCTION (r));
6709 TREE_CHAIN (DECL_CLONED_FUNCTION (r)) = r;
6710 }
6711
6712 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
6713 this in the special friend case mentioned above where
6714 GEN_TMPL is NULL. */
6715 if (gen_tmpl)
6716 {
6717 DECL_TEMPLATE_INFO (r)
6718 = tree_cons (gen_tmpl, argvec, NULL_TREE);
6719 SET_DECL_IMPLICIT_INSTANTIATION (r);
6720 register_specialization (r, gen_tmpl, argvec, false);
6721
6722 /* We're not supposed to instantiate default arguments
6723 until they are called, for a template. But, for a
6724 declaration like:
6725
6726 template <class T> void f ()
6727 { extern void g(int i = T()); }
6728
6729 we should do the substitution when the template is
6730 instantiated. We handle the member function case in
6731 instantiate_class_template since the default arguments
6732 might refer to other members of the class. */
6733 if (!member
6734 && !PRIMARY_TEMPLATE_P (gen_tmpl)
6735 && !uses_template_parms (argvec))
6736 tsubst_default_arguments (r);
6737 }
6738 else
6739 DECL_TEMPLATE_INFO (r) = NULL_TREE;
6740
6741 /* Copy the list of befriending classes. */
6742 for (friends = &DECL_BEFRIENDING_CLASSES (r);
6743 *friends;
6744 friends = &TREE_CHAIN (*friends))
6745 {
6746 *friends = copy_node (*friends);
6747 TREE_VALUE (*friends) = tsubst (TREE_VALUE (*friends),
6748 args, complain,
6749 in_decl);
6750 }
6751
6752 if (DECL_CONSTRUCTOR_P (r) || DECL_DESTRUCTOR_P (r))
6753 {
6754 maybe_retrofit_in_chrg (r);
6755 if (DECL_CONSTRUCTOR_P (r))
6756 grok_ctor_properties (ctx, r);
6757 /* If this is an instantiation of a member template, clone it.
6758 If it isn't, that'll be handled by
6759 clone_constructors_and_destructors. */
6760 if (PRIMARY_TEMPLATE_P (gen_tmpl))
6761 clone_function_decl (r, /*update_method_vec_p=*/0);
6762 }
6763 else if (IDENTIFIER_OPNAME_P (DECL_NAME (r))
6764 && !grok_op_properties (r, (complain & tf_error) != 0))
6765 return error_mark_node;
6766
6767 if (DECL_FRIEND_P (t) && DECL_FRIEND_CONTEXT (t))
6768 SET_DECL_FRIEND_CONTEXT (r,
6769 tsubst (DECL_FRIEND_CONTEXT (t),
6770 args, complain, in_decl));
6771
6772 /* Possibly limit visibility based on template args. */
6773 DECL_VISIBILITY (r) = VISIBILITY_DEFAULT;
6774 if (DECL_VISIBILITY_SPECIFIED (t))
6775 {
6776 DECL_VISIBILITY_SPECIFIED (r) = 0;
6777 DECL_ATTRIBUTES (r)
6778 = remove_attribute ("visibility", DECL_ATTRIBUTES (r));
6779 }
6780 determine_visibility (r);
6781 }
6782 break;
6783
6784 case PARM_DECL:
6785 {
6786 tree type;
6787
6788 r = copy_node (t);
6789 if (DECL_TEMPLATE_PARM_P (t))
6790 SET_DECL_TEMPLATE_PARM_P (r);
6791
6792 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6793 type = type_decays_to (type);
6794 TREE_TYPE (r) = type;
6795 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
6796
6797 if (DECL_INITIAL (r))
6798 {
6799 if (TREE_CODE (DECL_INITIAL (r)) != TEMPLATE_PARM_INDEX)
6800 DECL_INITIAL (r) = TREE_TYPE (r);
6801 else
6802 DECL_INITIAL (r) = tsubst (DECL_INITIAL (r), args,
6803 complain, in_decl);
6804 }
6805
6806 DECL_CONTEXT (r) = NULL_TREE;
6807
6808 if (!DECL_TEMPLATE_PARM_P (r))
6809 DECL_ARG_TYPE (r) = type_passed_as (type);
6810 if (TREE_CHAIN (t))
6811 TREE_CHAIN (r) = tsubst (TREE_CHAIN (t), args,
6812 complain, TREE_CHAIN (t));
6813 }
6814 break;
6815
6816 case FIELD_DECL:
6817 {
6818 tree type;
6819
6820 r = copy_decl (t);
6821 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6822 if (type == error_mark_node)
6823 return error_mark_node;
6824 TREE_TYPE (r) = type;
6825 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
6826
6827 /* DECL_INITIAL gives the number of bits in a bit-field. */
6828 DECL_INITIAL (r)
6829 = tsubst_expr (DECL_INITIAL (t), args,
6830 complain, in_decl,
6831 /*integral_constant_expression_p=*/true);
6832 /* We don't have to set DECL_CONTEXT here; it is set by
6833 finish_member_declaration. */
6834 TREE_CHAIN (r) = NULL_TREE;
6835 if (VOID_TYPE_P (type))
6836 error ("instantiation of %q+D as type %qT", r, type);
6837 }
6838 break;
6839
6840 case USING_DECL:
6841 /* We reach here only for member using decls. */
6842 if (DECL_DEPENDENT_P (t))
6843 {
6844 r = do_class_using_decl
6845 (tsubst_copy (USING_DECL_SCOPE (t), args, complain, in_decl),
6846 tsubst_copy (DECL_NAME (t), args, complain, in_decl));
6847 if (!r)
6848 r = error_mark_node;
6849 }
6850 else
6851 {
6852 r = copy_node (t);
6853 TREE_CHAIN (r) = NULL_TREE;
6854 }
6855 break;
6856
6857 case TYPE_DECL:
6858 case VAR_DECL:
6859 {
6860 tree argvec = NULL_TREE;
6861 tree gen_tmpl = NULL_TREE;
6862 tree spec;
6863 tree tmpl = NULL_TREE;
6864 tree ctx;
6865 tree type = NULL_TREE;
6866 bool local_p;
6867
6868 if (TREE_CODE (t) == TYPE_DECL)
6869 {
6870 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6871 if (TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
6872 || t == TYPE_MAIN_DECL (TREE_TYPE (t)))
6873 {
6874 /* If this is the canonical decl, we don't have to
6875 mess with instantiations, and often we can't (for
6876 typename, template type parms and such). Note that
6877 TYPE_NAME is not correct for the above test if
6878 we've copied the type for a typedef. */
6879 r = TYPE_NAME (type);
6880 break;
6881 }
6882 }
6883
6884 /* Check to see if we already have the specialization we
6885 need. */
6886 spec = NULL_TREE;
6887 if (DECL_CLASS_SCOPE_P (t) || DECL_NAMESPACE_SCOPE_P (t))
6888 {
6889 /* T is a static data member or namespace-scope entity.
6890 We have to substitute into namespace-scope variables
6891 (even though such entities are never templates) because
6892 of cases like:
6893
6894 template <class T> void f() { extern T t; }
6895
6896 where the entity referenced is not known until
6897 instantiation time. */
6898 local_p = false;
6899 ctx = DECL_CONTEXT (t);
6900 if (DECL_CLASS_SCOPE_P (t))
6901 {
6902 ctx = tsubst_aggr_type (ctx, args,
6903 complain,
6904 in_decl, /*entering_scope=*/1);
6905 /* If CTX is unchanged, then T is in fact the
6906 specialization we want. That situation occurs when
6907 referencing a static data member within in its own
6908 class. We can use pointer equality, rather than
6909 same_type_p, because DECL_CONTEXT is always
6910 canonical. */
6911 if (ctx == DECL_CONTEXT (t))
6912 spec = t;
6913 }
6914
6915 if (!spec)
6916 {
6917 tmpl = DECL_TI_TEMPLATE (t);
6918 gen_tmpl = most_general_template (tmpl);
6919 argvec = tsubst (DECL_TI_ARGS (t), args, complain, in_decl);
6920 spec = (retrieve_specialization
6921 (gen_tmpl, argvec,
6922 /*class_specializations_p=*/false));
6923 }
6924 }
6925 else
6926 {
6927 /* A local variable. */
6928 local_p = true;
6929 /* Subsequent calls to pushdecl will fill this in. */
6930 ctx = NULL_TREE;
6931 spec = retrieve_local_specialization (t);
6932 }
6933 /* If we already have the specialization we need, there is
6934 nothing more to do. */
6935 if (spec)
6936 {
6937 r = spec;
6938 break;
6939 }
6940
6941 /* Create a new node for the specialization we need. */
6942 r = copy_decl (t);
6943 if (TREE_CODE (r) == VAR_DECL)
6944 {
6945 /* Even if the original location is out of scope, the
6946 newly substituted one is not. */
6947 DECL_DEAD_FOR_LOCAL (r) = 0;
6948 DECL_INITIALIZED_P (r) = 0;
6949 DECL_TEMPLATE_INSTANTIATED (r) = 0;
6950 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6951 if (type == error_mark_node)
6952 return error_mark_node;
6953 if (TREE_CODE (type) == FUNCTION_TYPE)
6954 {
6955 /* It may seem that this case cannot occur, since:
6956
6957 typedef void f();
6958 void g() { f x; }
6959
6960 declares a function, not a variable. However:
6961
6962 typedef void f();
6963 template <typename T> void g() { T t; }
6964 template void g<f>();
6965
6966 is an attempt to declare a variable with function
6967 type. */
6968 error ("variable %qD has function type",
6969 /* R is not yet sufficiently initialized, so we
6970 just use its name. */
6971 DECL_NAME (r));
6972 return error_mark_node;
6973 }
6974 type = complete_type (type);
6975 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r)
6976 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t);
6977 type = check_var_type (DECL_NAME (r), type);
6978
6979 if (DECL_HAS_VALUE_EXPR_P (t))
6980 {
6981 tree ve = DECL_VALUE_EXPR (t);
6982 ve = tsubst_expr (ve, args, complain, in_decl,
6983 /*constant_expression_p=*/false);
6984 SET_DECL_VALUE_EXPR (r, ve);
6985 }
6986 }
6987 else if (DECL_SELF_REFERENCE_P (t))
6988 SET_DECL_SELF_REFERENCE_P (r);
6989 TREE_TYPE (r) = type;
6990 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
6991 DECL_CONTEXT (r) = ctx;
6992 /* Clear out the mangled name and RTL for the instantiation. */
6993 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
6994 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
6995 SET_DECL_RTL (r, NULL_RTX);
6996 /* The initializer must not be expanded until it is required;
6997 see [temp.inst]. */
6998 DECL_INITIAL (r) = NULL_TREE;
6999 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
7000 SET_DECL_RTL (r, NULL_RTX);
7001 DECL_SIZE (r) = DECL_SIZE_UNIT (r) = 0;
7002 if (TREE_CODE (r) == VAR_DECL)
7003 {
7004 /* Possibly limit visibility based on template args. */
7005 DECL_VISIBILITY (r) = VISIBILITY_DEFAULT;
7006 if (DECL_VISIBILITY_SPECIFIED (t))
7007 {
7008 DECL_VISIBILITY_SPECIFIED (r) = 0;
7009 DECL_ATTRIBUTES (r)
7010 = remove_attribute ("visibility", DECL_ATTRIBUTES (r));
7011 }
7012 determine_visibility (r);
7013 }
7014
7015 if (!local_p)
7016 {
7017 /* A static data member declaration is always marked
7018 external when it is declared in-class, even if an
7019 initializer is present. We mimic the non-template
7020 processing here. */
7021 DECL_EXTERNAL (r) = 1;
7022
7023 register_specialization (r, gen_tmpl, argvec, false);
7024 DECL_TEMPLATE_INFO (r) = tree_cons (tmpl, argvec, NULL_TREE);
7025 SET_DECL_IMPLICIT_INSTANTIATION (r);
7026 }
7027 else
7028 register_local_specialization (r, t);
7029
7030 TREE_CHAIN (r) = NULL_TREE;
7031 layout_decl (r, 0);
7032 }
7033 break;
7034
7035 default:
7036 gcc_unreachable ();
7037 }
7038
7039 /* Restore the file and line information. */
7040 input_location = saved_loc;
7041
7042 return r;
7043}
7044
7045/* Substitute into the ARG_TYPES of a function type. */
7046
7047static tree
7048tsubst_arg_types (tree arg_types,
7049 tree args,
7050 tsubst_flags_t complain,
7051 tree in_decl)
7052{
7053 tree remaining_arg_types;
7054 tree type;
7055 tree default_arg;
7056 tree result = NULL_TREE;
7057
7058 if (!arg_types || arg_types == void_list_node)
7059 return arg_types;
7060
7061 remaining_arg_types = tsubst_arg_types (TREE_CHAIN (arg_types),
7062 args, complain, in_decl);
7063 if (remaining_arg_types == error_mark_node)
7064 return error_mark_node;
7065
7066 type = tsubst (TREE_VALUE (arg_types), args, complain, in_decl);
7067 if (type == error_mark_node)
7068 return error_mark_node;
7069 if (VOID_TYPE_P (type))
7070 {
7071 if (complain & tf_error)
7072 {
7073 error ("invalid parameter type %qT", type);
7074 if (in_decl)
7075 error ("in declaration %q+D", in_decl);
7076 }
7077 return error_mark_node;
7078 }
7079
7080 /* Do array-to-pointer, function-to-pointer conversion, and ignore
7081 top-level qualifiers as required. */
7082 type = TYPE_MAIN_VARIANT (type_decays_to (type));
7083
7084 /* We do not substitute into default arguments here. The standard
7085 mandates that they be instantiated only when needed, which is
7086 done in build_over_call. */
7087 default_arg = TREE_PURPOSE (arg_types);
7088
7089 if (default_arg && TREE_CODE (default_arg) == DEFAULT_ARG)
7090 {
7091 /* We've instantiated a template before its default arguments
7092 have been parsed. This can happen for a nested template
7093 class, and is not an error unless we require the default
7094 argument in a call of this function. */
7095 result = tree_cons (default_arg, type, remaining_arg_types);
7096 VEC_safe_push (tree, gc, DEFARG_INSTANTIATIONS (default_arg), result);
7097 }
7098 else
7099 result = hash_tree_cons (default_arg, type, remaining_arg_types);
7100
7101 return result;
7102}
7103
7104/* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
7105 *not* handle the exception-specification for FNTYPE, because the
7106 initial substitution of explicitly provided template parameters
7107 during argument deduction forbids substitution into the
7108 exception-specification:
7109
7110 [temp.deduct]
7111
7112 All references in the function type of the function template to the
7113 corresponding template parameters are replaced by the specified tem-
7114 plate argument values. If a substitution in a template parameter or
7115 in the function type of the function template results in an invalid
7116 type, type deduction fails. [Note: The equivalent substitution in
7117 exception specifications is done only when the function is instanti-
7118 ated, at which point a program is ill-formed if the substitution
7119 results in an invalid type.] */
7120
7121static tree
7122tsubst_function_type (tree t,
7123 tree args,
7124 tsubst_flags_t complain,
7125 tree in_decl)
7126{
7127 tree return_type;
7128 tree arg_types;
7129 tree fntype;
7130
7131 /* The TYPE_CONTEXT is not used for function/method types. */
7132 gcc_assert (TYPE_CONTEXT (t) == NULL_TREE);
7133
7134 /* Substitute the return type. */
7135 return_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
7136 if (return_type == error_mark_node)
7137 return error_mark_node;
7138 /* The standard does not presently indicate that creation of a
7139 function type with an invalid return type is a deduction failure.
7140 However, that is clearly analogous to creating an array of "void"
7141 or a reference to a reference. This is core issue #486. */
7142 if (TREE_CODE (return_type) == ARRAY_TYPE
7143 || TREE_CODE (return_type) == FUNCTION_TYPE)
7144 {
7145 if (complain & tf_error)
7146 {
7147 if (TREE_CODE (return_type) == ARRAY_TYPE)
7148 error ("function returning an array");
7149 else
7150 error ("function returning a function");
7151 }
7152 return error_mark_node;
7153 }
7154
7155 /* Substitute the argument types. */
7156 arg_types = tsubst_arg_types (TYPE_ARG_TYPES (t), args,
7157 complain, in_decl);
7158 if (arg_types == error_mark_node)
7159 return error_mark_node;
7160
7161 /* Construct a new type node and return it. */
7162 if (TREE_CODE (t) == FUNCTION_TYPE)
7163 fntype = build_function_type (return_type, arg_types);
7164 else
7165 {
7166 tree r = TREE_TYPE (TREE_VALUE (arg_types));
7167 if (! IS_AGGR_TYPE (r))
7168 {
7169 /* [temp.deduct]
7170
7171 Type deduction may fail for any of the following
7172 reasons:
7173
7174 -- Attempting to create "pointer to member of T" when T
7175 is not a class type. */
7176 if (complain & tf_error)
7177 error ("creating pointer to member function of non-class type %qT",
7178 r);
7179 return error_mark_node;
7180 }
7181
7182 fntype = build_method_type_directly (r, return_type,
7183 TREE_CHAIN (arg_types));
7184 }
7185 fntype = cp_build_qualified_type_real (fntype, TYPE_QUALS (t), complain);
7186 fntype = cp_build_type_attribute_variant (fntype, TYPE_ATTRIBUTES (t));
7187
7188 return fntype;
7189}
7190
7191/* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
7192 ARGS into that specification, and return the substituted
7193 specification. If there is no specification, return NULL_TREE. */
7194
7195static tree
7196tsubst_exception_specification (tree fntype,
7197 tree args,
7198 tsubst_flags_t complain,
7199 tree in_decl)
7200{
7201 tree specs;
7202 tree new_specs;
7203
7204 specs = TYPE_RAISES_EXCEPTIONS (fntype);
7205 new_specs = NULL_TREE;
7206 if (specs)
7207 {
7208 if (! TREE_VALUE (specs))
7209 new_specs = specs;
7210 else
7211 while (specs)
7212 {
7213 tree spec;
7214 spec = tsubst (TREE_VALUE (specs), args, complain, in_decl);
7215 if (spec == error_mark_node)
7216 return spec;
7217 new_specs = add_exception_specifier (new_specs, spec, complain);
7218 specs = TREE_CHAIN (specs);
7219 }
7220 }
7221 return new_specs;
7222}
7223
7224/* Take the tree structure T and replace template parameters used
7225 therein with the argument vector ARGS. IN_DECL is an associated
7226 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
7227 Issue error and warning messages under control of COMPLAIN. Note
7228 that we must be relatively non-tolerant of extensions here, in
7229 order to preserve conformance; if we allow substitutions that
7230 should not be allowed, we may allow argument deductions that should
7231 not succeed, and therefore report ambiguous overload situations
7232 where there are none. In theory, we could allow the substitution,
7233 but indicate that it should have failed, and allow our caller to
7234 make sure that the right thing happens, but we don't try to do this
7235 yet.
7236
7237 This function is used for dealing with types, decls and the like;
7238 for expressions, use tsubst_expr or tsubst_copy. */
7239
7240static tree
7241tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
7242{
7243 tree type, r;
7244
7245 if (t == NULL_TREE || t == error_mark_node
7246 || t == integer_type_node
7247 || t == void_type_node
7248 || t == char_type_node
7249 || t == unknown_type_node
7250 || TREE_CODE (t) == NAMESPACE_DECL)
7251 return t;
7252
7253 if (DECL_P (t))
7254 return tsubst_decl (t, args, complain);
7255
7256 if (TREE_CODE (t) == IDENTIFIER_NODE)
7257 type = IDENTIFIER_TYPE_VALUE (t);
7258 else
7259 type = TREE_TYPE (t);
7260
7261 gcc_assert (type != unknown_type_node);
7262
7263 if (type
7264 && TREE_CODE (t) != TYPENAME_TYPE
7265 && TREE_CODE (t) != IDENTIFIER_NODE
7266 && TREE_CODE (t) != FUNCTION_TYPE
7267 && TREE_CODE (t) != METHOD_TYPE)
7268 type = tsubst (type, args, complain, in_decl);
7269 if (type == error_mark_node)
7270 return error_mark_node;
7271
7272 switch (TREE_CODE (t))
7273 {
7274 case RECORD_TYPE:
7275 case UNION_TYPE:
7276 case ENUMERAL_TYPE:
7277 return tsubst_aggr_type (t, args, complain, in_decl,
7278 /*entering_scope=*/0);
7279
7280 case ERROR_MARK:
7281 case IDENTIFIER_NODE:
7282 case VOID_TYPE:
7283 case REAL_TYPE:
7284 case COMPLEX_TYPE:
7285 case VECTOR_TYPE:
7286 case BOOLEAN_TYPE:
7287 case INTEGER_CST:
7288 case REAL_CST:
7289 case STRING_CST:
7290 return t;
7291
7292 case INTEGER_TYPE:
7293 if (t == integer_type_node)
7294 return t;
7295
7296 if (TREE_CODE (TYPE_MIN_VALUE (t)) == INTEGER_CST
7297 && TREE_CODE (TYPE_MAX_VALUE (t)) == INTEGER_CST)
7298 return t;
7299
7300 {
7301 tree max, omax = TREE_OPERAND (TYPE_MAX_VALUE (t), 0);
7302
7303 max = tsubst_expr (omax, args, complain, in_decl,
7304 /*integral_constant_expression_p=*/false);
7305 max = fold_decl_constant_value (max);
7306
7307 if (TREE_CODE (max) != INTEGER_CST
7308 && TREE_CODE (max) != TEMPLATE_PARM_INDEX
7309 && !at_function_scope_p ())
7310 {
7311 if (complain & tf_error)
7312 error ("array bound is not an integer constant");
7313 return error_mark_node;
7314 }
7315
7316 /* [temp.deduct]
7317
7318 Type deduction may fail for any of the following
7319 reasons:
7320
7321 Attempting to create an array with a size that is
7322 zero or negative. */
7323 if (integer_zerop (max) && !(complain & tf_error))
7324 /* We must fail if performing argument deduction (as
7325 indicated by the state of complain), so that
7326 another substitution can be found. */
7327 return error_mark_node;
7328 else if (TREE_CODE (max) == INTEGER_CST
7329 && INT_CST_LT (max, integer_zero_node))
7330 {
7331 if (complain & tf_error)
7332 error ("creating array with negative size (%qE)", max);
7333
7334 return error_mark_node;
7335 }
7336
7337 return compute_array_index_type (NULL_TREE, max);
7338 }
7339
7340 case TEMPLATE_TYPE_PARM:
7341 case TEMPLATE_TEMPLATE_PARM:
7342 case BOUND_TEMPLATE_TEMPLATE_PARM:
7343 case TEMPLATE_PARM_INDEX:
7344 {
7345 int idx;
7346 int level;
7347 int levels;
7348 tree arg = NULL_TREE;
7349
7350 r = NULL_TREE;
7351
7352 gcc_assert (TREE_VEC_LENGTH (args) > 0);
7353 if (TREE_CODE (t) == TEMPLATE_TYPE_PARM
7354 || TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM
7355 || TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
7356 {
7357 idx = TEMPLATE_TYPE_IDX (t);
7358 level = TEMPLATE_TYPE_LEVEL (t);
7359 }
7360 else
7361 {
7362 idx = TEMPLATE_PARM_IDX (t);
7363 level = TEMPLATE_PARM_LEVEL (t);
7364 }
7365
7366 levels = TMPL_ARGS_DEPTH (args);
7367 if (level <= levels)
7368 arg = TMPL_ARG (args, level, idx);
7369
7370 if (arg == error_mark_node)
7371 return error_mark_node;
7372 else if (arg != NULL_TREE)
7373 {
7374 if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
7375 {
7376 int quals;
7377 gcc_assert (TYPE_P (arg));
7378
7379 /* cv-quals from the template are discarded when
7380 substituting in a function or reference type. */
7381 if (TREE_CODE (arg) == FUNCTION_TYPE
7382 || TREE_CODE (arg) == METHOD_TYPE
7383 || TREE_CODE (arg) == REFERENCE_TYPE)
7384 quals = cp_type_quals (arg);
7385 else
7386 quals = cp_type_quals (arg) | cp_type_quals (t);
7387
7388 return cp_build_qualified_type_real
7389 (arg, quals, complain | tf_ignore_bad_quals);
7390 }
7391 else if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
7392 {
7393 /* We are processing a type constructed from a
7394 template template parameter. */
7395 tree argvec = tsubst (TYPE_TI_ARGS (t),
7396 args, complain, in_decl);
7397 if (argvec == error_mark_node)
7398 return error_mark_node;
7399
7400 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
7401 are resolving nested-types in the signature of a
7402 member function templates. Otherwise ARG is a
7403 TEMPLATE_DECL and is the real template to be
7404 instantiated. */
7405 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
7406 arg = TYPE_NAME (arg);
7407
7408 r = lookup_template_class (arg,
7409 argvec, in_decl,
7410 DECL_CONTEXT (arg),
7411 /*entering_scope=*/0,
7412 complain);
7413 return cp_build_qualified_type_real
7414 (r, TYPE_QUALS (t), complain);
7415 }
7416 else
7417 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
7418 return arg;
7419 }
7420
7421 if (level == 1)
7422 /* This can happen during the attempted tsubst'ing in
7423 unify. This means that we don't yet have any information
7424 about the template parameter in question. */
7425 return t;
7426
7427 /* If we get here, we must have been looking at a parm for a
7428 more deeply nested template. Make a new version of this
7429 template parameter, but with a lower level. */
7430 switch (TREE_CODE (t))
7431 {
7432 case TEMPLATE_TYPE_PARM:
7433 case TEMPLATE_TEMPLATE_PARM:
7434 case BOUND_TEMPLATE_TEMPLATE_PARM:
7435 if (cp_type_quals (t))
7436 {
7437 r = tsubst (TYPE_MAIN_VARIANT (t), args, complain, in_decl);
7438 r = cp_build_qualified_type_real
7439 (r, cp_type_quals (t),
7440 complain | (TREE_CODE (t) == TEMPLATE_TYPE_PARM
7441 ? tf_ignore_bad_quals : 0));
7442 }
7443 else
7444 {
7445 r = copy_type (t);
7446 TEMPLATE_TYPE_PARM_INDEX (r)
7447 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t),
7448 r, levels);
7449 TYPE_STUB_DECL (r) = TYPE_NAME (r) = TEMPLATE_TYPE_DECL (r);
7450 TYPE_MAIN_VARIANT (r) = r;
7451 TYPE_POINTER_TO (r) = NULL_TREE;
7452 TYPE_REFERENCE_TO (r) = NULL_TREE;
7453
7454 if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
7455 {
7456 tree argvec = tsubst (TYPE_TI_ARGS (t), args,
7457 complain, in_decl);
7458 if (argvec == error_mark_node)
7459 return error_mark_node;
7460
7461 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r)
7462 = tree_cons (TYPE_TI_TEMPLATE (t), argvec, NULL_TREE);
7463 }
7464 }
7465 break;
7466
7467 case TEMPLATE_PARM_INDEX:
7468 r = reduce_template_parm_level (t, type, levels);
7469 break;
7470
7471 default:
7472 gcc_unreachable ();
7473 }
7474
7475 return r;
7476 }
7477
7478 case TREE_LIST:
7479 {
7480 tree purpose, value, chain;
7481
7482 if (t == void_list_node)
7483 return t;
7484
7485 purpose = TREE_PURPOSE (t);
7486 if (purpose)
7487 {
7488 purpose = tsubst (purpose, args, complain, in_decl);
7489 if (purpose == error_mark_node)
7490 return error_mark_node;
7491 }
7492 value = TREE_VALUE (t);
7493 if (value)
7494 {
7495 value = tsubst (value, args, complain, in_decl);
7496 if (value == error_mark_node)
7497 return error_mark_node;
7498 }
7499 chain = TREE_CHAIN (t);
7500 if (chain && chain != void_type_node)
7501 {
7502 chain = tsubst (chain, args, complain, in_decl);
7503 if (chain == error_mark_node)
7504 return error_mark_node;
7505 }
7506 if (purpose == TREE_PURPOSE (t)
7507 && value == TREE_VALUE (t)
7508 && chain == TREE_CHAIN (t))
7509 return t;
7510 return hash_tree_cons (purpose, value, chain);
7511 }
7512
7513 case TREE_BINFO:
7514 /* We should never be tsubsting a binfo. */
7515 gcc_unreachable ();
7516
7517 case TREE_VEC:
7518 /* A vector of template arguments. */
7519 gcc_assert (!type);
7520 return tsubst_template_args (t, args, complain, in_decl);
7521
7522 case POINTER_TYPE:
7523 case REFERENCE_TYPE:
7524 {
7525 enum tree_code code;
7526
7527 if (type == TREE_TYPE (t) && TREE_CODE (type) != METHOD_TYPE)
7528 return t;
7529
7530 code = TREE_CODE (t);
7531
7532
7533 /* [temp.deduct]
7534
7535 Type deduction may fail for any of the following
7536 reasons:
7537
7538 -- Attempting to create a pointer to reference type.
7539 -- Attempting to create a reference to a reference type or
7540 a reference to void. */
7541 if (TREE_CODE (type) == REFERENCE_TYPE
7542 || (code == REFERENCE_TYPE && TREE_CODE (type) == VOID_TYPE))
7543 {
7544 static location_t last_loc;
7545
7546 /* We keep track of the last time we issued this error
7547 message to avoid spewing a ton of messages during a
7548 single bad template instantiation. */
7549 if (complain & tf_error
7550#ifdef USE_MAPPED_LOCATION
7551 && last_loc != input_location
7552#else
7553 && (last_loc.line != input_line
7554 || last_loc.file != input_filename)
7555#endif
7556 )
7557 {
7558 if (TREE_CODE (type) == VOID_TYPE)
7559 error ("forming reference to void");
7560 else
7561 error ("forming %s to reference type %qT",
7562 (code == POINTER_TYPE) ? "pointer" : "reference",
7563 type);
7564 last_loc = input_location;
7565 }
7566
7567 return error_mark_node;
7568 }
7569 else if (code == POINTER_TYPE)
7570 {
7571 r = build_pointer_type (type);
7572 if (TREE_CODE (type) == METHOD_TYPE)
7573 r = build_ptrmemfunc_type (r);
7574 }
7575 else
7576 r = build_reference_type (type);
7577 r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
7578
7579 if (r != error_mark_node)
7580 /* Will this ever be needed for TYPE_..._TO values? */
7581 layout_type (r);
7582
7583 return r;
7584 }
7585 case OFFSET_TYPE:
7586 {
7587 r = tsubst (TYPE_OFFSET_BASETYPE (t), args, complain, in_decl);
7588 if (r == error_mark_node || !IS_AGGR_TYPE (r))
7589 {
7590 /* [temp.deduct]
7591
7592 Type deduction may fail for any of the following
7593 reasons:
7594
7595 -- Attempting to create "pointer to member of T" when T
7596 is not a class type. */
7597 if (complain & tf_error)
7598 error ("creating pointer to member of non-class type %qT", r);
7599 return error_mark_node;
7600 }
7601 if (TREE_CODE (type) == REFERENCE_TYPE)
7602 {
7603 if (complain & tf_error)
7604 error ("creating pointer to member reference type %qT", type);
7605 return error_mark_node;
7606 }
7607 if (TREE_CODE (type) == VOID_TYPE)
7608 {
7609 if (complain & tf_error)
7610 error ("creating pointer to member of type void");
7611 return error_mark_node;
7612 }
7613 gcc_assert (TREE_CODE (type) != METHOD_TYPE);
7614 if (TREE_CODE (type) == FUNCTION_TYPE)
7615 {
7616 /* The type of the implicit object parameter gets its
7617 cv-qualifiers from the FUNCTION_TYPE. */
7618 tree method_type;
7619 tree this_type = cp_build_qualified_type (TYPE_MAIN_VARIANT (r),
7620 cp_type_quals (type));
7621 tree memptr;
7622 method_type = build_method_type_directly (this_type,
7623 TREE_TYPE (type),
7624 TYPE_ARG_TYPES (type));
7625 memptr = build_ptrmemfunc_type (build_pointer_type (method_type));
7626 return cp_build_qualified_type_real (memptr, cp_type_quals (t),
7627 complain);
7628 }
7629 else
7630 return cp_build_qualified_type_real (build_ptrmem_type (r, type),
7631 TYPE_QUALS (t),
7632 complain);
7633 }
7634 case FUNCTION_TYPE:
7635 case METHOD_TYPE:
7636 {
7637 tree fntype;
7638 tree specs;
7639 fntype = tsubst_function_type (t, args, complain, in_decl);
7640 if (fntype == error_mark_node)
7641 return error_mark_node;
7642
7643 /* Substitute the exception specification. */
7644 specs = tsubst_exception_specification (t, args, complain,
7645 in_decl);
7646 if (specs == error_mark_node)
7647 return error_mark_node;
7648 if (specs)
7649 fntype = build_exception_variant (fntype, specs);
7650 return fntype;
7651 }
7652 case ARRAY_TYPE:
7653 {
7654 tree domain = tsubst (TYPE_DOMAIN (t), args, complain, in_decl);
7655 if (domain == error_mark_node)
7656 return error_mark_node;
7657
7658 /* As an optimization, we avoid regenerating the array type if
7659 it will obviously be the same as T. */
7660 if (type == TREE_TYPE (t) && domain == TYPE_DOMAIN (t))
7661 return t;
7662
7663 /* These checks should match the ones in grokdeclarator.
7664
7665 [temp.deduct]
7666
7667 The deduction may fail for any of the following reasons:
7668
7669 -- Attempting to create an array with an element type that
7670 is void, a function type, or a reference type, or [DR337]
7671 an abstract class type. */
7672 if (TREE_CODE (type) == VOID_TYPE
7673 || TREE_CODE (type) == FUNCTION_TYPE
7674 || TREE_CODE (type) == REFERENCE_TYPE)
7675 {
7676 if (complain & tf_error)
7677 error ("creating array of %qT", type);
7678 return error_mark_node;
7679 }
7680 if (CLASS_TYPE_P (type) && CLASSTYPE_PURE_VIRTUALS (type))
7681 {
7682 if (complain & tf_error)
7683 error ("creating array of %qT, which is an abstract class type",
7684 type);
7685 return error_mark_node;
7686 }
7687
7688 r = build_cplus_array_type (type, domain);
7689 return r;
7690 }
7691
7692 case PLUS_EXPR:
7693 case MINUS_EXPR:
7694 {
7695 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7696 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
7697
7698 if (e1 == error_mark_node || e2 == error_mark_node)
7699 return error_mark_node;
7700
7701 return fold_build2 (TREE_CODE (t), TREE_TYPE (t), e1, e2);
7702 }
7703
7704 case NEGATE_EXPR:
7705 case NOP_EXPR:
7706 {
7707 tree e = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7708 if (e == error_mark_node)
7709 return error_mark_node;
7710
7711 return fold_build1 (TREE_CODE (t), TREE_TYPE (t), e);
7712 }
7713
7714 case TYPENAME_TYPE:
7715 {
7716 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
7717 in_decl, /*entering_scope=*/1);
7718 tree f = tsubst_copy (TYPENAME_TYPE_FULLNAME (t), args,
7719 complain, in_decl);
7720
7721 if (ctx == error_mark_node || f == error_mark_node)
7722 return error_mark_node;
7723
7724 if (!IS_AGGR_TYPE (ctx))
7725 {
7726 if (complain & tf_error)
7727 error ("%qT is not a class, struct, or union type", ctx);
7728 return error_mark_node;
7729 }
7730 else if (!uses_template_parms (ctx) && !TYPE_BEING_DEFINED (ctx))
7731 {
7732 /* Normally, make_typename_type does not require that the CTX
7733 have complete type in order to allow things like:
7734
7735 template <class T> struct S { typename S<T>::X Y; };
7736
7737 But, such constructs have already been resolved by this
7738 point, so here CTX really should have complete type, unless
7739 it's a partial instantiation. */
7740 ctx = complete_type (ctx);
7741 if (!COMPLETE_TYPE_P (ctx))
7742 {
7743 if (complain & tf_error)
7744 cxx_incomplete_type_error (NULL_TREE, ctx);
7745 return error_mark_node;
7746 }
7747 }
7748
7749 f = make_typename_type (ctx, f, typename_type,
7750 (complain & tf_error) | tf_keep_type_decl);
7751 if (f == error_mark_node)
7752 return f;
7753 if (TREE_CODE (f) == TYPE_DECL)
7754 {
7755 complain |= tf_ignore_bad_quals;
7756 f = TREE_TYPE (f);
7757 }
7758
7759 if (TREE_CODE (f) != TYPENAME_TYPE)
7760 {
7761 if (TYPENAME_IS_ENUM_P (t) && TREE_CODE (f) != ENUMERAL_TYPE)
7762 error ("%qT resolves to %qT, which is not an enumeration type",
7763 t, f);
7764 else if (TYPENAME_IS_CLASS_P (t) && !CLASS_TYPE_P (f))
7765 error ("%qT resolves to %qT, which is is not a class type",
7766 t, f);
7767 }
7768
7769 return cp_build_qualified_type_real
7770 (f, cp_type_quals (f) | cp_type_quals (t), complain);
7771 }
7772
7773 case UNBOUND_CLASS_TEMPLATE:
7774 {
7775 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
7776 in_decl, /*entering_scope=*/1);
7777 tree name = TYPE_IDENTIFIER (t);
7778 tree parm_list = DECL_TEMPLATE_PARMS (TYPE_NAME (t));
7779
7780 if (ctx == error_mark_node || name == error_mark_node)
7781 return error_mark_node;
7782
7783 if (parm_list)
7784 parm_list = tsubst_template_parms (parm_list, args, complain);
7785 return make_unbound_class_template (ctx, name, parm_list, complain);
7786 }
7787
7788 case INDIRECT_REF:
7789 case ADDR_EXPR:
7790 case CALL_EXPR:
7791 gcc_unreachable ();
7792
7793 case ARRAY_REF:
7794 {
7795 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7796 tree e2 = tsubst_expr (TREE_OPERAND (t, 1), args, complain, in_decl,
7797 /*integral_constant_expression_p=*/false);
7798 if (e1 == error_mark_node || e2 == error_mark_node)
7799 return error_mark_node;
7800
7801 return build_nt (ARRAY_REF, e1, e2, NULL_TREE, NULL_TREE);
7802 }
7803
7804 case SCOPE_REF:
7805 {
7806 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7807 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
7808 if (e1 == error_mark_node || e2 == error_mark_node)
7809 return error_mark_node;
7810
7811 return build_qualified_name (/*type=*/NULL_TREE,
7812 e1, e2, QUALIFIED_NAME_IS_TEMPLATE (t));
7813 }
7814
7815 case TYPEOF_TYPE:
7816 {
7817 tree type;
7818
7819 type = finish_typeof (tsubst_expr
7820 (TYPEOF_TYPE_EXPR (t), args,
7821 complain, in_decl,
7822 /*integral_constant_expression_p=*/false));
7823 return cp_build_qualified_type_real (type,
7824 cp_type_quals (t)
7825 | cp_type_quals (type),
7826 complain);
7827 }
7828
7829 default:
7830 sorry ("use of %qs in template",
7831 tree_code_name [(int) TREE_CODE (t)]);
7832 return error_mark_node;
7833 }
7834}
7835
7836/* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
7837 type of the expression on the left-hand side of the "." or "->"
7838 operator. */
7839
7840static tree
7841tsubst_baselink (tree baselink, tree object_type,
7842 tree args, tsubst_flags_t complain, tree in_decl)
7843{
7844 tree name;
7845 tree qualifying_scope;
7846 tree fns;
7847 tree optype;
7848 tree template_args = 0;
7849 bool template_id_p = false;
7850
7851 /* A baselink indicates a function from a base class. Both the
7852 BASELINK_ACCESS_BINFO and the base class referenced may
7853 indicate bases of the template class, rather than the
7854 instantiated class. In addition, lookups that were not
7855 ambiguous before may be ambiguous now. Therefore, we perform
7856 the lookup again. */
7857 qualifying_scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink));
7858 qualifying_scope = tsubst (qualifying_scope, args,
7859 complain, in_decl);
7860 fns = BASELINK_FUNCTIONS (baselink);
7861 optype = BASELINK_OPTYPE (baselink);
7862 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
7863 {
7864 template_id_p = true;
7865 template_args = TREE_OPERAND (fns, 1);
7866 fns = TREE_OPERAND (fns, 0);
7867 if (template_args)
7868 template_args = tsubst_template_args (template_args, args,
7869 complain, in_decl);
7870 }
7871 name = DECL_NAME (get_first_fn (fns));
7872 baselink = lookup_fnfields (qualifying_scope, name, /*protect=*/1);
7873
7874 /* If lookup found a single function, mark it as used at this
7875 point. (If it lookup found multiple functions the one selected
7876 later by overload resolution will be marked as used at that
7877 point.) */
7878 if (BASELINK_P (baselink))
7879 fns = BASELINK_FUNCTIONS (baselink);
7880 if (!template_id_p && !really_overloaded_fn (fns))
7881 mark_used (OVL_CURRENT (fns));
7882
7883 /* Add back the template arguments, if present. */
7884 if (BASELINK_P (baselink) && template_id_p)
7885 BASELINK_FUNCTIONS (baselink)
7886 = build_nt (TEMPLATE_ID_EXPR,
7887 BASELINK_FUNCTIONS (baselink),
7888 template_args);
7889 /* Update the conversion operator type. */
7890 BASELINK_OPTYPE (baselink)
7891 = tsubst (optype, args, complain, in_decl);
7892
7893 if (!object_type)
7894 object_type = current_class_type;
7895 return adjust_result_of_qualified_name_lookup (baselink,
7896 qualifying_scope,
7897 object_type);
7898}
7899
7900/* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
7901 true if the qualified-id will be a postfix-expression in-and-of
7902 itself; false if more of the postfix-expression follows the
7903 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
7904 of "&". */
7905
7906static tree
7907tsubst_qualified_id (tree qualified_id, tree args,
7908 tsubst_flags_t complain, tree in_decl,
7909 bool done, bool address_p)
7910{
7911 tree expr;
7912 tree scope;
7913 tree name;
7914 bool is_template;
7915 tree template_args;
7916
7917 gcc_assert (TREE_CODE (qualified_id) == SCOPE_REF);
7918
7919 /* Figure out what name to look up. */
7920 name = TREE_OPERAND (qualified_id, 1);
7921 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
7922 {
7923 is_template = true;
7924 template_args = TREE_OPERAND (name, 1);
7925 if (template_args)
7926 template_args = tsubst_template_args (template_args, args,
7927 complain, in_decl);
7928 name = TREE_OPERAND (name, 0);
7929 }
7930 else
7931 {
7932 is_template = false;
7933 template_args = NULL_TREE;
7934 }
7935
7936 /* Substitute into the qualifying scope. When there are no ARGS, we
7937 are just trying to simplify a non-dependent expression. In that
7938 case the qualifying scope may be dependent, and, in any case,
7939 substituting will not help. */
7940 scope = TREE_OPERAND (qualified_id, 0);
7941 if (args)
7942 {
7943 scope = tsubst (scope, args, complain, in_decl);
7944 expr = tsubst_copy (name, args, complain, in_decl);
7945 }
7946 else
7947 expr = name;
7948
7949 if (dependent_type_p (scope))
7950 return build_qualified_name (/*type=*/NULL_TREE,
7951 scope, expr,
7952 QUALIFIED_NAME_IS_TEMPLATE (qualified_id));
7953
7954 if (!BASELINK_P (name) && !DECL_P (expr))
7955 {
7956 if (TREE_CODE (expr) == BIT_NOT_EXPR)
7957 /* If this were actually a destructor call, it would have been
7958 parsed as such by the parser. */
7959 expr = error_mark_node;
7960 else
7961 expr = lookup_qualified_name (scope, expr, /*is_type_p=*/0, false);
7962 if (TREE_CODE (TREE_CODE (expr) == TEMPLATE_DECL
7963 ? DECL_TEMPLATE_RESULT (expr) : expr) == TYPE_DECL)
7964 {
7965 if (complain & tf_error)
7966 {
7967 error ("dependent-name %qE is parsed as a non-type, but "
7968 "instantiation yields a type", qualified_id);
7969 inform ("say %<typename %E%> if a type is meant", qualified_id);
7970 }
7971 return error_mark_node;
7972 }
7973 }
7974
7975 if (DECL_P (expr))
7976 {
7977 check_accessibility_of_qualified_id (expr, /*object_type=*/NULL_TREE,
7978 scope);
7979 /* Remember that there was a reference to this entity. */
7980 mark_used (expr);
7981 }
7982
7983 if (expr == error_mark_node || TREE_CODE (expr) == TREE_LIST)
7984 {
7985 if (complain & tf_error)
7986 qualified_name_lookup_error (scope,
7987 TREE_OPERAND (qualified_id, 1),
7988 expr);
7989 return error_mark_node;
7990 }
7991
7992 if (is_template)
7993 expr = lookup_template_function (expr, template_args);
7994
7995 if (expr == error_mark_node && complain & tf_error)
7996 qualified_name_lookup_error (scope, TREE_OPERAND (qualified_id, 1),
7997 expr);
7998 else if (TYPE_P (scope))
7999 {
8000 expr = (adjust_result_of_qualified_name_lookup
8001 (expr, scope, current_class_type));
8002 expr = (finish_qualified_id_expr
8003 (scope, expr, done, address_p,
8004 QUALIFIED_NAME_IS_TEMPLATE (qualified_id),
8005 /*template_arg_p=*/false));
8006 }
8007
8008 /* Expressions do not generally have reference type. */
8009 if (TREE_CODE (expr) != SCOPE_REF
8010 /* However, if we're about to form a pointer-to-member, we just
8011 want the referenced member referenced. */
8012 && TREE_CODE (expr) != OFFSET_REF)
8013 expr = convert_from_reference (expr);
8014
8015 return expr;
8016}
8017
8018/* Like tsubst, but deals with expressions. This function just replaces
8019 template parms; to finish processing the resultant expression, use
8020 tsubst_expr. */
8021
8022static tree
8023tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl)
8024{
8025 enum tree_code code;
8026 tree r;
8027
8028 if (t == NULL_TREE || t == error_mark_node)
8029 return t;
8030
8031 code = TREE_CODE (t);
8032
8033 switch (code)
8034 {
8035 case PARM_DECL:
8036 r = retrieve_local_specialization (t);
8037 gcc_assert (r != NULL);
8038 mark_used (r);
8039 return r;
8040
8041 case CONST_DECL:
8042 {
8043 tree enum_type;
8044 tree v;
8045
8046 if (DECL_TEMPLATE_PARM_P (t))
8047 return tsubst_copy (DECL_INITIAL (t), args, complain, in_decl);
8048 /* There is no need to substitute into namespace-scope
8049 enumerators. */
8050 if (DECL_NAMESPACE_SCOPE_P (t))
8051 return t;
8052 /* If ARGS is NULL, then T is known to be non-dependent. */
8053 if (args == NULL_TREE)
8054 return integral_constant_value (t);
8055
8056 /* Unfortunately, we cannot just call lookup_name here.
8057 Consider:
8058
8059 template <int I> int f() {
8060 enum E { a = I };
8061 struct S { void g() { E e = a; } };
8062 };
8063
8064 When we instantiate f<7>::S::g(), say, lookup_name is not
8065 clever enough to find f<7>::a. */
8066 enum_type
8067 = tsubst_aggr_type (TREE_TYPE (t), args, complain, in_decl,
8068 /*entering_scope=*/0);
8069
8070 for (v = TYPE_VALUES (enum_type);
8071 v != NULL_TREE;
8072 v = TREE_CHAIN (v))
8073 if (TREE_PURPOSE (v) == DECL_NAME (t))
8074 return TREE_VALUE (v);
8075
8076 /* We didn't find the name. That should never happen; if
8077 name-lookup found it during preliminary parsing, we
8078 should find it again here during instantiation. */
8079 gcc_unreachable ();
8080 }
8081 return t;
8082
8083 case FIELD_DECL:
8084 if (DECL_CONTEXT (t))
8085 {
8086 tree ctx;
8087
8088 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, in_decl,
8089 /*entering_scope=*/1);
8090 if (ctx != DECL_CONTEXT (t))
8091 {
8092 tree r = lookup_field (ctx, DECL_NAME (t), 0, false);
8093 if (!r)
8094 {
8095 if (complain & tf_error)
8096 error ("using invalid field %qD", t);
8097 return error_mark_node;
8098 }
8099 return r;
8100 }
8101 }
8102
8103 return t;
8104
8105 case VAR_DECL:
8106 case FUNCTION_DECL:
8107 if ((DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t))
8108 || local_variable_p (t))
8109 t = tsubst (t, args, complain, in_decl);
8110 mark_used (t);
8111 return t;
8112
8113 case BASELINK:
8114 return tsubst_baselink (t, current_class_type, args, complain, in_decl);
8115
8116 case TEMPLATE_DECL:
8117 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
8118 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
8119 args, complain, in_decl);
8120 else if (DECL_FUNCTION_TEMPLATE_P (t) && DECL_MEMBER_TEMPLATE_P (t))
8121 return tsubst (t, args, complain, in_decl);
8122 else if (DECL_CLASS_SCOPE_P (t)
8123 && uses_template_parms (DECL_CONTEXT (t)))
8124 {
8125 /* Template template argument like the following example need
8126 special treatment:
8127
8128 template <template <class> class TT> struct C {};
8129 template <class T> struct D {
8130 template <class U> struct E {};
8131 C<E> c; // #1
8132 };
8133 D<int> d; // #2
8134
8135 We are processing the template argument `E' in #1 for
8136 the template instantiation #2. Originally, `E' is a
8137 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
8138 have to substitute this with one having context `D<int>'. */
8139
8140 tree context = tsubst (DECL_CONTEXT (t), args, complain, in_decl);
8141 return lookup_field (context, DECL_NAME(t), 0, false);
8142 }
8143 else
8144 /* Ordinary template template argument. */
8145 return t;
8146
8147 case CAST_EXPR:
8148 case REINTERPRET_CAST_EXPR:
8149 case CONST_CAST_EXPR:
8150 case STATIC_CAST_EXPR:
8151 case DYNAMIC_CAST_EXPR:
8152 case NOP_EXPR:
8153 return build1
8154 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
8155 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
8156
8157 case INDIRECT_REF:
8158 case NEGATE_EXPR:
8159 case TRUTH_NOT_EXPR:
8160 case BIT_NOT_EXPR:
8161 case ADDR_EXPR:
8162 case UNARY_PLUS_EXPR: /* Unary + */
8163 case SIZEOF_EXPR:
8164 case ALIGNOF_EXPR:
8165 case ARROW_EXPR:
8166 case THROW_EXPR:
8167 case TYPEID_EXPR:
8168 case REALPART_EXPR:
8169 case IMAGPART_EXPR:
8170 return build1
8171 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
8172 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
8173
8174 case COMPONENT_REF:
8175 {
8176 tree object;
8177 tree name;
8178
8179 object = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
8180 name = TREE_OPERAND (t, 1);
8181 if (TREE_CODE (name) == BIT_NOT_EXPR)
8182 {
8183 name = tsubst_copy (TREE_OPERAND (name, 0), args,
8184 complain, in_decl);
8185 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
8186 }
8187 else if (TREE_CODE (name) == SCOPE_REF
8188 && TREE_CODE (TREE_OPERAND (name, 1)) == BIT_NOT_EXPR)
8189 {
8190 tree base = tsubst_copy (TREE_OPERAND (name, 0), args,
8191 complain, in_decl);
8192 name = TREE_OPERAND (name, 1);
8193 name = tsubst_copy (TREE_OPERAND (name, 0), args,
8194 complain, in_decl);
8195 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
8196 name = build_qualified_name (/*type=*/NULL_TREE,
8197 base, name,
8198 /*template_p=*/false);
8199 }
8200 else if (TREE_CODE (name) == BASELINK)
8201 name = tsubst_baselink (name,
8202 non_reference (TREE_TYPE (object)),
8203 args, complain,
8204 in_decl);
8205 else
8206 name = tsubst_copy (name, args, complain, in_decl);
8207 return build_nt (COMPONENT_REF, object, name, NULL_TREE);
8208 }
8209
8210 case PLUS_EXPR:
8211 case MINUS_EXPR:
8212 case MULT_EXPR:
8213 case TRUNC_DIV_EXPR:
8214 case CEIL_DIV_EXPR:
8215 case FLOOR_DIV_EXPR:
8216 case ROUND_DIV_EXPR:
8217 case EXACT_DIV_EXPR:
8218 case BIT_AND_EXPR:
8219 case BIT_IOR_EXPR:
8220 case BIT_XOR_EXPR:
8221 case TRUNC_MOD_EXPR:
8222 case FLOOR_MOD_EXPR:
8223 case TRUTH_ANDIF_EXPR:
8224 case TRUTH_ORIF_EXPR:
8225 case TRUTH_AND_EXPR:
8226 case TRUTH_OR_EXPR:
8227 case RSHIFT_EXPR:
8228 case LSHIFT_EXPR:
8229 case RROTATE_EXPR:
8230 case LROTATE_EXPR:
8231 case EQ_EXPR:
8232 case NE_EXPR:
8233 case MAX_EXPR:
8234 case MIN_EXPR:
8235 case LE_EXPR:
8236 case GE_EXPR:
8237 case LT_EXPR:
8238 case GT_EXPR:
8239 case COMPOUND_EXPR:
8240 case DOTSTAR_EXPR:
8241 case MEMBER_REF:
8242 case PREDECREMENT_EXPR:
8243 case PREINCREMENT_EXPR:
8244 case POSTDECREMENT_EXPR:
8245 case POSTINCREMENT_EXPR:
8246 return build_nt
8247 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
8248 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
8249
8250 case SCOPE_REF:
8251 return build_qualified_name (/*type=*/NULL_TREE,
8252 tsubst_copy (TREE_OPERAND (t, 0),
8253 args, complain, in_decl),
8254 tsubst_copy (TREE_OPERAND (t, 1),
8255 args, complain, in_decl),
8256 QUALIFIED_NAME_IS_TEMPLATE (t));
8257
8258 case ARRAY_REF:
8259 return build_nt
8260 (ARRAY_REF,
8261 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
8262 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
8263 NULL_TREE, NULL_TREE);
8264
8265 case CALL_EXPR:
8266 return build_nt (code,
8267 tsubst_copy (TREE_OPERAND (t, 0), args,
8268 complain, in_decl),
8269 tsubst_copy (TREE_OPERAND (t, 1), args, complain,
8270 in_decl),
8271 NULL_TREE);
8272
8273 case COND_EXPR:
8274 case MODOP_EXPR:
8275 case PSEUDO_DTOR_EXPR:
8276 {
8277 r = build_nt
8278 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
8279 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
8280 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
8281 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
8282 return r;
8283 }
8284
8285 case NEW_EXPR:
8286 {
8287 r = build_nt
8288 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
8289 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
8290 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
8291 NEW_EXPR_USE_GLOBAL (r) = NEW_EXPR_USE_GLOBAL (t);
8292 return r;
8293 }
8294
8295 case DELETE_EXPR:
8296 {
8297 r = build_nt
8298 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
8299 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
8300 DELETE_EXPR_USE_GLOBAL (r) = DELETE_EXPR_USE_GLOBAL (t);
8301 DELETE_EXPR_USE_VEC (r) = DELETE_EXPR_USE_VEC (t);
8302 return r;
8303 }
8304
8305 case TEMPLATE_ID_EXPR:
8306 {
8307 /* Substituted template arguments */
8308 tree fn = TREE_OPERAND (t, 0);
8309 tree targs = TREE_OPERAND (t, 1);
8310
8311 fn = tsubst_copy (fn, args, complain, in_decl);
8312 if (targs)
8313 targs = tsubst_template_args (targs, args, complain, in_decl);
8314
8315 return lookup_template_function (fn, targs);
8316 }
8317
8318 case TREE_LIST:
8319 {
8320 tree purpose, value, chain;
8321
8322 if (t == void_list_node)
8323 return t;
8324
8325 purpose = TREE_PURPOSE (t);
8326 if (purpose)
8327 purpose = tsubst_copy (purpose, args, complain, in_decl);
8328 value = TREE_VALUE (t);
8329 if (value)
8330 value = tsubst_copy (value, args, complain, in_decl);
8331 chain = TREE_CHAIN (t);
8332 if (chain && chain != void_type_node)
8333 chain = tsubst_copy (chain, args, complain, in_decl);
8334 if (purpose == TREE_PURPOSE (t)
8335 && value == TREE_VALUE (t)
8336 && chain == TREE_CHAIN (t))
8337 return t;
8338 return tree_cons (purpose, value, chain);
8339 }
8340
8341 case RECORD_TYPE:
8342 case UNION_TYPE:
8343 case ENUMERAL_TYPE:
8344 case INTEGER_TYPE:
8345 case TEMPLATE_TYPE_PARM:
8346 case TEMPLATE_TEMPLATE_PARM:
8347 case BOUND_TEMPLATE_TEMPLATE_PARM:
8348 case TEMPLATE_PARM_INDEX:
8349 case POINTER_TYPE:
8350 case REFERENCE_TYPE:
8351 case OFFSET_TYPE:
8352 case FUNCTION_TYPE:
8353 case METHOD_TYPE:
8354 case ARRAY_TYPE:
8355 case TYPENAME_TYPE:
8356 case UNBOUND_CLASS_TEMPLATE:
8357 case TYPEOF_TYPE:
8358 case TYPE_DECL:
8359 return tsubst (t, args, complain, in_decl);
8360
8361 case IDENTIFIER_NODE:
8362 if (IDENTIFIER_TYPENAME_P (t))
8363 {
8364 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8365 return mangle_conv_op_name_for_type (new_type);
8366 }
8367 else
8368 return t;
8369
8370 case CONSTRUCTOR:
8371 /* This is handled by tsubst_copy_and_build. */
8372 gcc_unreachable ();
8373
8374 case VA_ARG_EXPR:
8375 return build_x_va_arg (tsubst_copy (TREE_OPERAND (t, 0), args, complain,
8376 in_decl),
8377 tsubst (TREE_TYPE (t), args, complain, in_decl));
8378
8379 case CLEANUP_POINT_EXPR:
8380 /* We shouldn't have built any of these during initial template
8381 generation. Instead, they should be built during instantiation
8382 in response to the saved STMT_IS_FULL_EXPR_P setting. */
8383 gcc_unreachable ();
8384
8385 case OFFSET_REF:
8386 mark_used (TREE_OPERAND (t, 1));
8387 return t;
8388
8389 default:
8390 return t;
8391 }
8392}
8393
8394/* Like tsubst_copy, but specifically for OpenMP clauses. */
8395
8396static tree
8397tsubst_omp_clauses (tree clauses, tree args, tsubst_flags_t complain,
8398 tree in_decl)
8399{
8400 tree new_clauses = NULL, nc, oc;
8401
8402 for (oc = clauses; oc ; oc = OMP_CLAUSE_CHAIN (oc))
8403 {
8404 nc = copy_node (oc);
8405 OMP_CLAUSE_CHAIN (nc) = new_clauses;
8406 new_clauses = nc;
8407
8408 switch (OMP_CLAUSE_CODE (nc))
8409 {
8410 case OMP_CLAUSE_PRIVATE:
8411 case OMP_CLAUSE_SHARED:
8412 case OMP_CLAUSE_FIRSTPRIVATE:
8413 case OMP_CLAUSE_LASTPRIVATE:
8414 case OMP_CLAUSE_REDUCTION:
8415 case OMP_CLAUSE_COPYIN:
8416 case OMP_CLAUSE_COPYPRIVATE:
8417 case OMP_CLAUSE_IF:
8418 case OMP_CLAUSE_NUM_THREADS:
8419 case OMP_CLAUSE_SCHEDULE:
8420 OMP_CLAUSE_OPERAND (nc, 0)
8421 = tsubst_expr (OMP_CLAUSE_OPERAND (oc, 0), args, complain,
8422 in_decl, /*integral_constant_expression_p=*/false);
8423 break;
8424 case OMP_CLAUSE_NOWAIT:
8425 case OMP_CLAUSE_ORDERED:
8426 case OMP_CLAUSE_DEFAULT:
8427 break;
8428 default:
8429 gcc_unreachable ();
8430 }
8431 }
8432
8433 return finish_omp_clauses (nreverse (new_clauses));
8434}
8435
8436/* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
8437
8438static tree
8439tsubst_copy_asm_operands (tree t, tree args, tsubst_flags_t complain,
8440 tree in_decl)
8441{
8442#define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
8443
8444 tree purpose, value, chain;
8445
8446 if (t == NULL)
8447 return t;
8448
8449 if (TREE_CODE (t) != TREE_LIST)
8450 return tsubst_copy_and_build (t, args, complain, in_decl,
8451 /*function_p=*/false,
8452 /*integral_constant_expression_p=*/false);
8453
8454 if (t == void_list_node)
8455 return t;
8456
8457 purpose = TREE_PURPOSE (t);
8458 if (purpose)
8459 purpose = RECUR (purpose);
8460 value = TREE_VALUE (t);
8461 if (value)
8462 value = RECUR (value);
8463 chain = TREE_CHAIN (t);
8464 if (chain && chain != void_type_node)
8465 chain = RECUR (chain);
8466 return tree_cons (purpose, value, chain);
8467#undef RECUR
8468}
8469
8470/* Like tsubst_copy for expressions, etc. but also does semantic
8471 processing. */
8472
8473static tree
8474tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl,
8475 bool integral_constant_expression_p)
8476{
8477#define RECUR(NODE) \
8478 tsubst_expr ((NODE), args, complain, in_decl, \
8479 integral_constant_expression_p)
8480
8481 tree stmt, tmp;
8482
8483 if (t == NULL_TREE || t == error_mark_node)
8484 return t;
8485
8486 if (EXPR_HAS_LOCATION (t))
8487 input_location = EXPR_LOCATION (t);
8488 if (STATEMENT_CODE_P (TREE_CODE (t)))
8489 current_stmt_tree ()->stmts_are_full_exprs_p = STMT_IS_FULL_EXPR_P (t);
8490
8491 switch (TREE_CODE (t))
8492 {
8493 case STATEMENT_LIST:
8494 {
8495 tree_stmt_iterator i;
8496 for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
8497 RECUR (tsi_stmt (i));
8498 break;
8499 }
8500
8501 case CTOR_INITIALIZER:
8502 finish_mem_initializers (tsubst_initializer_list
8503 (TREE_OPERAND (t, 0), args));
8504 break;
8505
8506 case RETURN_EXPR:
8507 finish_return_stmt (RECUR (TREE_OPERAND (t, 0)));
8508 break;
8509
8510 case EXPR_STMT:
8511 tmp = RECUR (EXPR_STMT_EXPR (t));
8512 if (EXPR_STMT_STMT_EXPR_RESULT (t))
8513 finish_stmt_expr_expr (tmp, cur_stmt_expr);
8514 else
8515 finish_expr_stmt (tmp);
8516 break;
8517
8518 case USING_STMT:
8519 do_using_directive (RECUR (USING_STMT_NAMESPACE (t)));
8520 break;
8521
8522 case DECL_EXPR:
8523 {
8524 tree decl;
8525 tree init;
8526
8527 decl = DECL_EXPR_DECL (t);
8528 if (TREE_CODE (decl) == LABEL_DECL)
8529 finish_label_decl (DECL_NAME (decl));
8530 else if (TREE_CODE (decl) == USING_DECL)
8531 {
8532 tree scope = USING_DECL_SCOPE (decl);
8533 tree name = DECL_NAME (decl);
8534 tree decl;
8535
8536 scope = RECUR (scope);
8537 decl = lookup_qualified_name (scope, name,
8538 /*is_type_p=*/false,
8539 /*complain=*/false);
8540 if (decl == error_mark_node || TREE_CODE (decl) == TREE_LIST)
8541 qualified_name_lookup_error (scope, name, decl);
8542 else
8543 do_local_using_decl (decl, scope, name);
8544 }
8545 else
8546 {
8547 init = DECL_INITIAL (decl);
8548 decl = tsubst (decl, args, complain, in_decl);
8549 if (decl != error_mark_node)
8550 {
8551 /* By marking the declaration as instantiated, we avoid
8552 trying to instantiate it. Since instantiate_decl can't
8553 handle local variables, and since we've already done
8554 all that needs to be done, that's the right thing to
8555 do. */
8556 if (TREE_CODE (decl) == VAR_DECL)
8557 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
8558 if (TREE_CODE (decl) == VAR_DECL
8559 && ANON_AGGR_TYPE_P (TREE_TYPE (decl)))
8560 /* Anonymous aggregates are a special case. */
8561 finish_anon_union (decl);
8562 else
8563 {
8564 maybe_push_decl (decl);
8565 if (TREE_CODE (decl) == VAR_DECL
8566 && DECL_PRETTY_FUNCTION_P (decl))
8567 {
8568 /* For __PRETTY_FUNCTION__ we have to adjust the
8569 initializer. */
8570 const char *const name
8571 = cxx_printable_name (current_function_decl, 2);
8572 init = cp_fname_init (name, &TREE_TYPE (decl));
8573 }
8574 else
8575 init = RECUR (init);
8576 finish_decl (decl, init, NULL_TREE);
8577 }
8578 }
8579 }
8580
8581 /* A DECL_EXPR can also be used as an expression, in the condition
8582 clause of an if/for/while construct. */
8583 return decl;
8584 }
8585
8586 case FOR_STMT:
8587 stmt = begin_for_stmt ();
8588 RECUR (FOR_INIT_STMT (t));
8589 finish_for_init_stmt (stmt);
8590 tmp = RECUR (FOR_COND (t));
8591 finish_for_cond (tmp, stmt);
8592 tmp = RECUR (FOR_EXPR (t));
8593 finish_for_expr (tmp, stmt);
8594 RECUR (FOR_BODY (t));
8595 finish_for_stmt (stmt);
8596 break;
8597
8598 case WHILE_STMT:
8599 stmt = begin_while_stmt ();
8600 tmp = RECUR (WHILE_COND (t));
8601 finish_while_stmt_cond (tmp, stmt);
8602 RECUR (WHILE_BODY (t));
8603 finish_while_stmt (stmt);
8604 break;
8605
8606 case DO_STMT:
8607 stmt = begin_do_stmt ();
8608 RECUR (DO_BODY (t));
8609 finish_do_body (stmt);
8610 tmp = RECUR (DO_COND (t));
8611 finish_do_stmt (tmp, stmt);
8612 break;
8613
8614 case IF_STMT:
8615 stmt = begin_if_stmt ();
8616 tmp = RECUR (IF_COND (t));
8617 finish_if_stmt_cond (tmp, stmt);
8618 RECUR (THEN_CLAUSE (t));
8619 finish_then_clause (stmt);
8620
8621 if (ELSE_CLAUSE (t))
8622 {
8623 begin_else_clause (stmt);
8624 RECUR (ELSE_CLAUSE (t));
8625 finish_else_clause (stmt);
8626 }
8627
8628 finish_if_stmt (stmt);
8629 break;
8630
8631 case BIND_EXPR:
8632 if (BIND_EXPR_BODY_BLOCK (t))
8633 stmt = begin_function_body ();
8634 else
8635 stmt = begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t)
8636 ? BCS_TRY_BLOCK : 0);
8637
8638 RECUR (BIND_EXPR_BODY (t));
8639
8640 if (BIND_EXPR_BODY_BLOCK (t))
8641 finish_function_body (stmt);
8642 else
8643 finish_compound_stmt (stmt);
8644 break;
8645
8646 case BREAK_STMT:
8647 finish_break_stmt ();
8648 break;
8649
8650 case CONTINUE_STMT:
8651 finish_continue_stmt ();
8652 break;
8653
8654 case SWITCH_STMT:
8655 stmt = begin_switch_stmt ();
8656 tmp = RECUR (SWITCH_STMT_COND (t));
8657 finish_switch_cond (tmp, stmt);
8658 RECUR (SWITCH_STMT_BODY (t));
8659 finish_switch_stmt (stmt);
8660 break;
8661
8662 case CASE_LABEL_EXPR:
8663 finish_case_label (RECUR (CASE_LOW (t)),
8664 RECUR (CASE_HIGH (t)));
8665 break;
8666
8667 case LABEL_EXPR:
8668 finish_label_stmt (DECL_NAME (LABEL_EXPR_LABEL (t)));
8669 break;
8670
8671 case GOTO_EXPR:
8672 tmp = GOTO_DESTINATION (t);
8673 if (TREE_CODE (tmp) != LABEL_DECL)
8674 /* Computed goto's must be tsubst'd into. On the other hand,
8675 non-computed gotos must not be; the identifier in question
8676 will have no binding. */
8677 tmp = RECUR (tmp);
8678 else
8679 tmp = DECL_NAME (tmp);
8680 finish_goto_stmt (tmp);
8681 break;
8682
8683 case ASM_EXPR:
8684 tmp = finish_asm_stmt
8685 (ASM_VOLATILE_P (t),
8686 RECUR (ASM_STRING (t)),
8687 tsubst_copy_asm_operands (ASM_OUTPUTS (t), args, complain, in_decl),
8688 tsubst_copy_asm_operands (ASM_INPUTS (t), args, complain, in_decl),
8689 tsubst_copy_asm_operands (ASM_CLOBBERS (t), args, complain, in_decl));
8690 {
8691 tree asm_expr = tmp;
8692 if (TREE_CODE (asm_expr) == CLEANUP_POINT_EXPR)
8693 asm_expr = TREE_OPERAND (asm_expr, 0);
8694 ASM_INPUT_P (asm_expr) = ASM_INPUT_P (t);
8695 }
8696 break;
8697
8698 case TRY_BLOCK:
8699 if (CLEANUP_P (t))
8700 {
8701 stmt = begin_try_block ();
8702 RECUR (TRY_STMTS (t));
8703 finish_cleanup_try_block (stmt);
8704 finish_cleanup (RECUR (TRY_HANDLERS (t)), stmt);
8705 }
8706 else
8707 {
8708 tree compound_stmt = NULL_TREE;
8709
8710 if (FN_TRY_BLOCK_P (t))
8711 stmt = begin_function_try_block (&compound_stmt);
8712 else
8713 stmt = begin_try_block ();
8714
8715 RECUR (TRY_STMTS (t));
8716
8717 if (FN_TRY_BLOCK_P (t))
8718 finish_function_try_block (stmt);
8719 else
8720 finish_try_block (stmt);
8721
8722 RECUR (TRY_HANDLERS (t));
8723 if (FN_TRY_BLOCK_P (t))
8724 finish_function_handler_sequence (stmt, compound_stmt);
8725 else
8726 finish_handler_sequence (stmt);
8727 }
8728 break;
8729
8730 case HANDLER:
8731 {
8732 tree decl = HANDLER_PARMS (t);
8733
8734 if (decl)
8735 {
8736 decl = tsubst (decl, args, complain, in_decl);
8737 /* Prevent instantiate_decl from trying to instantiate
8738 this variable. We've already done all that needs to be
8739 done. */
8740 if (decl != error_mark_node)
8741 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
8742 }
8743 stmt = begin_handler ();
8744 finish_handler_parms (decl, stmt);
8745 RECUR (HANDLER_BODY (t));
8746 finish_handler (stmt);
8747 }
8748 break;
8749
8750 case TAG_DEFN:
8751 tsubst (TREE_TYPE (t), args, complain, NULL_TREE);
8752 break;
8753
8754 case OMP_PARALLEL:
8755 tmp = tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t),
8756 args, complain, in_decl);
8757 stmt = begin_omp_parallel ();
8758 RECUR (OMP_PARALLEL_BODY (t));
8759 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp, stmt))
8760 = OMP_PARALLEL_COMBINED (t);
8761 break;
8762
8763 case OMP_FOR:
8764 {
8765 tree clauses, decl, init, cond, incr, body, pre_body;
8766
8767 clauses = tsubst_omp_clauses (OMP_FOR_CLAUSES (t),
8768 args, complain, in_decl);
8769 init = OMP_FOR_INIT (t);
8770 gcc_assert (TREE_CODE (init) == MODIFY_EXPR);
8771 decl = RECUR (TREE_OPERAND (init, 0));
8772 init = RECUR (TREE_OPERAND (init, 1));
8773 cond = RECUR (OMP_FOR_COND (t));
8774 incr = RECUR (OMP_FOR_INCR (t));
8775
8776 stmt = begin_omp_structured_block ();
8777
8778 pre_body = push_stmt_list ();
8779 RECUR (OMP_FOR_PRE_BODY (t));
8780 pre_body = pop_stmt_list (pre_body);
8781
8782 body = push_stmt_list ();
8783 RECUR (OMP_FOR_BODY (t));
8784 body = pop_stmt_list (body);
8785
8786 t = finish_omp_for (EXPR_LOCATION (t), decl, init, cond, incr, body,
8787 pre_body);
8788 if (t)
8789 OMP_FOR_CLAUSES (t) = clauses;
8790
8791 add_stmt (finish_omp_structured_block (stmt));
8792 }
8793 break;
8794
8795 case OMP_SECTIONS:
8796 case OMP_SINGLE:
8797 tmp = tsubst_omp_clauses (OMP_CLAUSES (t), args, complain, in_decl);
8798 stmt = push_stmt_list ();
8799 RECUR (OMP_BODY (t));
8800 stmt = pop_stmt_list (stmt);
8801
8802 t = copy_node (t);
8803 OMP_BODY (t) = stmt;
8804 OMP_CLAUSES (t) = tmp;
8805 add_stmt (t);
8806 break;
8807
8808 case OMP_SECTION:
8809 case OMP_CRITICAL:
8810 case OMP_MASTER:
8811 case OMP_ORDERED:
8812 stmt = push_stmt_list ();
8813 RECUR (OMP_BODY (t));
8814 stmt = pop_stmt_list (stmt);
8815
8816 t = copy_node (t);
8817 OMP_BODY (t) = stmt;
8818 add_stmt (t);
8819 break;
8820
8821 case OMP_ATOMIC:
8822 {
8823 tree op0, op1;
8824 op0 = RECUR (TREE_OPERAND (t, 0));
8825 op1 = RECUR (TREE_OPERAND (t, 1));
8826 finish_omp_atomic (OMP_ATOMIC_CODE (t), op0, op1);
8827 }
8828 break;
8829
8830 default:
8831 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t)));
8832
8833 return tsubst_copy_and_build (t, args, complain, in_decl,
8834 /*function_p=*/false,
8835 integral_constant_expression_p);
8836 }
8837
8838 return NULL_TREE;
8839#undef RECUR
8840}
8841
8842/* T is a postfix-expression that is not being used in a function
8843 call. Return the substituted version of T. */
8844
8845static tree
8846tsubst_non_call_postfix_expression (tree t, tree args,
8847 tsubst_flags_t complain,
8848 tree in_decl)
8849{
8850 if (TREE_CODE (t) == SCOPE_REF)
8851 t = tsubst_qualified_id (t, args, complain, in_decl,
8852 /*done=*/false, /*address_p=*/false);
8853 else
8854 t = tsubst_copy_and_build (t, args, complain, in_decl,
8855 /*function_p=*/false,
8856 /*integral_constant_expression_p=*/false);
8857
8858 return t;
8859}
8860
8861/* Like tsubst but deals with expressions and performs semantic
8862 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
8863
8864tree
8865tsubst_copy_and_build (tree t,
8866 tree args,
8867 tsubst_flags_t complain,
8868 tree in_decl,
8869 bool function_p,
8870 bool integral_constant_expression_p)
8871{
8872#define RECUR(NODE) \
8873 tsubst_copy_and_build (NODE, args, complain, in_decl, \
8874 /*function_p=*/false, \
8875 integral_constant_expression_p)
8876
8877 tree op1;
8878
8879 if (t == NULL_TREE || t == error_mark_node)
8880 return t;
8881
8882 switch (TREE_CODE (t))
8883 {
8884 case USING_DECL:
8885 t = DECL_NAME (t);
8886 /* Fall through. */
8887 case IDENTIFIER_NODE:
8888 {
8889 tree decl;
8890 cp_id_kind idk;
8891 bool non_integral_constant_expression_p;
8892 const char *error_msg;
8893
8894 if (IDENTIFIER_TYPENAME_P (t))
8895 {
8896 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8897 t = mangle_conv_op_name_for_type (new_type);
8898 }
8899
8900 /* Look up the name. */
8901 decl = lookup_name (t);
8902
8903 /* By convention, expressions use ERROR_MARK_NODE to indicate
8904 failure, not NULL_TREE. */
8905 if (decl == NULL_TREE)
8906 decl = error_mark_node;
8907
8908 decl = finish_id_expression (t, decl, NULL_TREE,
8909 &idk,
8910 integral_constant_expression_p,
8911 /*allow_non_integral_constant_expression_p=*/false,
8912 &non_integral_constant_expression_p,
8913 /*template_p=*/false,
8914 /*done=*/true,
8915 /*address_p=*/false,
8916 /*template_arg_p=*/false,
8917 &error_msg);
8918 if (error_msg)
8919 error (error_msg);
8920 if (!function_p && TREE_CODE (decl) == IDENTIFIER_NODE)
8921 decl = unqualified_name_lookup_error (decl);
8922 return decl;
8923 }
8924
8925 case TEMPLATE_ID_EXPR:
8926 {
8927 tree object;
8928 tree template = RECUR (TREE_OPERAND (t, 0));
8929 tree targs = TREE_OPERAND (t, 1);
8930
8931 if (targs)
8932 targs = tsubst_template_args (targs, args, complain, in_decl);
8933
8934 if (TREE_CODE (template) == COMPONENT_REF)
8935 {
8936 object = TREE_OPERAND (template, 0);
8937 template = TREE_OPERAND (template, 1);
8938 }
8939 else
8940 object = NULL_TREE;
8941 template = lookup_template_function (template, targs);
8942
8943 if (object)
8944 return build3 (COMPONENT_REF, TREE_TYPE (template),
8945 object, template, NULL_TREE);
8946 else
8947 return baselink_for_fns (template);
8948 }
8949
8950 case INDIRECT_REF:
8951 {
8952 tree r = RECUR (TREE_OPERAND (t, 0));
8953
8954 if (REFERENCE_REF_P (t))
8955 {
8956 /* A type conversion to reference type will be enclosed in
8957 such an indirect ref, but the substitution of the cast
8958 will have also added such an indirect ref. */
8959 if (TREE_CODE (TREE_TYPE (r)) == REFERENCE_TYPE)
8960 r = convert_from_reference (r);
8961 }
8962 else
8963 r = build_x_indirect_ref (r, "unary *");
8964 return r;
8965 }
8966
8967 case NOP_EXPR:
8968 return build_nop
8969 (tsubst (TREE_TYPE (t), args, complain, in_decl),
8970 RECUR (TREE_OPERAND (t, 0)));
8971
8972 case CAST_EXPR:
8973 case REINTERPRET_CAST_EXPR:
8974 case CONST_CAST_EXPR:
8975 case DYNAMIC_CAST_EXPR:
8976 case STATIC_CAST_EXPR:
8977 {
8978 tree type;
8979 tree op;
8980
8981 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8982 if (integral_constant_expression_p
8983 && !cast_valid_in_integral_constant_expression_p (type))
8984 {
8985 error ("a cast to a type other than an integral or "
8986 "enumeration type cannot appear in a constant-expression");
8987 return error_mark_node;
8988 }
8989
8990 op = RECUR (TREE_OPERAND (t, 0));
8991
8992 switch (TREE_CODE (t))
8993 {
8994 case CAST_EXPR:
8995 return build_functional_cast (type, op);
8996 case REINTERPRET_CAST_EXPR:
8997 return build_reinterpret_cast (type, op);
8998 case CONST_CAST_EXPR:
8999 return build_const_cast (type, op);
9000 case DYNAMIC_CAST_EXPR:
9001 return build_dynamic_cast (type, op);
9002 case STATIC_CAST_EXPR:
9003 return build_static_cast (type, op);
9004 default:
9005 gcc_unreachable ();
9006 }
9007 }
9008
9009 case POSTDECREMENT_EXPR:
9010 case POSTINCREMENT_EXPR:
9011 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
9012 args, complain, in_decl);
9013 return build_x_unary_op (TREE_CODE (t), op1);
9014
9015 case PREDECREMENT_EXPR:
9016 case PREINCREMENT_EXPR:
9017 case NEGATE_EXPR:
9018 case BIT_NOT_EXPR:
9019 case ABS_EXPR:
9020 case TRUTH_NOT_EXPR:
9021 case UNARY_PLUS_EXPR: /* Unary + */
9022 case REALPART_EXPR:
9023 case IMAGPART_EXPR:
9024 return build_x_unary_op (TREE_CODE (t), RECUR (TREE_OPERAND (t, 0)));
9025
9026 case ADDR_EXPR:
9027 op1 = TREE_OPERAND (t, 0);
9028 if (TREE_CODE (op1) == SCOPE_REF)
9029 op1 = tsubst_qualified_id (op1, args, complain, in_decl,
9030 /*done=*/true, /*address_p=*/true);
9031 else
9032 op1 = tsubst_non_call_postfix_expression (op1, args, complain,
9033 in_decl);
9034 if (TREE_CODE (op1) == LABEL_DECL)
9035 return finish_label_address_expr (DECL_NAME (op1));
9036 return build_x_unary_op (ADDR_EXPR, op1);
9037
9038 case PLUS_EXPR:
9039 case MINUS_EXPR:
9040 case MULT_EXPR:
9041 case TRUNC_DIV_EXPR:
9042 case CEIL_DIV_EXPR:
9043 case FLOOR_DIV_EXPR:
9044 case ROUND_DIV_EXPR:
9045 case EXACT_DIV_EXPR:
9046 case BIT_AND_EXPR:
9047 case BIT_IOR_EXPR:
9048 case BIT_XOR_EXPR:
9049 case TRUNC_MOD_EXPR:
9050 case FLOOR_MOD_EXPR:
9051 case TRUTH_ANDIF_EXPR:
9052 case TRUTH_ORIF_EXPR:
9053 case TRUTH_AND_EXPR:
9054 case TRUTH_OR_EXPR:
9055 case RSHIFT_EXPR:
9056 case LSHIFT_EXPR:
9057 case RROTATE_EXPR:
9058 case LROTATE_EXPR:
9059 case EQ_EXPR:
9060 case NE_EXPR:
9061 case MAX_EXPR:
9062 case MIN_EXPR:
9063 case LE_EXPR:
9064 case GE_EXPR:
9065 case LT_EXPR:
9066 case GT_EXPR:
9067 case MEMBER_REF:
9068 case DOTSTAR_EXPR:
9069 return build_x_binary_op
9070 (TREE_CODE (t),
9071 RECUR (TREE_OPERAND (t, 0)),
9072 RECUR (TREE_OPERAND (t, 1)),
9073 /*overloaded_p=*/NULL);
9074
9075 case SCOPE_REF:
9076 return tsubst_qualified_id (t, args, complain, in_decl, /*done=*/true,
9077 /*address_p=*/false);
9078 case ARRAY_REF:
9079 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
9080 args, complain, in_decl);
9081 return build_x_binary_op (ARRAY_REF, op1, RECUR (TREE_OPERAND (t, 1)),
9082 /*overloaded_p=*/NULL);
9083
9084 case SIZEOF_EXPR:
9085 case ALIGNOF_EXPR:
9086 op1 = TREE_OPERAND (t, 0);
9087 if (!args)
9088 {
9089 /* When there are no ARGS, we are trying to evaluate a
9090 non-dependent expression from the parser. Trying to do
9091 the substitutions may not work. */
9092 if (!TYPE_P (op1))
9093 op1 = TREE_TYPE (op1);
9094 }
9095 else
9096 {
9097 ++skip_evaluation;
9098 op1 = tsubst_copy_and_build (op1, args, complain, in_decl,
9099 /*function_p=*/false,
9100 /*integral_constant_expression_p=*/false);
9101 --skip_evaluation;
9102 }
9103 if (TYPE_P (op1))
9104 return cxx_sizeof_or_alignof_type (op1, TREE_CODE (t), true);
9105 else
9106 return cxx_sizeof_or_alignof_expr (op1, TREE_CODE (t));
9107
9108 case MODOP_EXPR:
9109 {
9110 tree r = build_x_modify_expr
9111 (RECUR (TREE_OPERAND (t, 0)),
9112 TREE_CODE (TREE_OPERAND (t, 1)),
9113 RECUR (TREE_OPERAND (t, 2)));
9114 /* TREE_NO_WARNING must be set if either the expression was
9115 parenthesized or it uses an operator such as >>= rather
9116 than plain assignment. In the former case, it was already
9117 set and must be copied. In the latter case,
9118 build_x_modify_expr sets it and it must not be reset
9119 here. */
9120 if (TREE_NO_WARNING (t))
9121 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
9122 return r;
9123 }
9124
9125 case ARROW_EXPR:
9126 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
9127 args, complain, in_decl);
9128 /* Remember that there was a reference to this entity. */
9129 if (DECL_P (op1))
9130 mark_used (op1);
9131 return build_x_arrow (op1);
9132
9133 case NEW_EXPR:
9134 return build_new
9135 (RECUR (TREE_OPERAND (t, 0)),
9136 RECUR (TREE_OPERAND (t, 1)),
9137 RECUR (TREE_OPERAND (t, 2)),
9138 RECUR (TREE_OPERAND (t, 3)),
9139 NEW_EXPR_USE_GLOBAL (t));
9140
9141 case DELETE_EXPR:
9142 return delete_sanity
9143 (RECUR (TREE_OPERAND (t, 0)),
9144 RECUR (TREE_OPERAND (t, 1)),
9145 DELETE_EXPR_USE_VEC (t),
9146 DELETE_EXPR_USE_GLOBAL (t));
9147
9148 case COMPOUND_EXPR:
9149 return build_x_compound_expr (RECUR (TREE_OPERAND (t, 0)),
9150 RECUR (TREE_OPERAND (t, 1)));
9151
9152 case CALL_EXPR:
9153 {
9154 tree function;
9155 tree call_args;
9156 bool qualified_p;
9157 bool koenig_p;
9158
9159 function = TREE_OPERAND (t, 0);
9160 /* When we parsed the expression, we determined whether or
9161 not Koenig lookup should be performed. */
9162 koenig_p = KOENIG_LOOKUP_P (t);
9163 if (TREE_CODE (function) == SCOPE_REF)
9164 {
9165 qualified_p = true;
9166 function = tsubst_qualified_id (function, args, complain, in_decl,
9167 /*done=*/false,
9168 /*address_p=*/false);
9169 }
9170 else
9171 {
9172 if (TREE_CODE (function) == COMPONENT_REF)
9173 {
9174 tree op = TREE_OPERAND (function, 1);
9175
9176 qualified_p = (TREE_CODE (op) == SCOPE_REF
9177 || (BASELINK_P (op)
9178 && BASELINK_QUALIFIED_P (op)));
9179 }
9180 else
9181 qualified_p = false;
9182
9183 function = tsubst_copy_and_build (function, args, complain,
9184 in_decl,
9185 !qualified_p,
9186 integral_constant_expression_p);
9187
9188 if (BASELINK_P (function))
9189 qualified_p = true;
9190 }
9191
9192 call_args = RECUR (TREE_OPERAND (t, 1));
9193
9194 /* We do not perform argument-dependent lookup if normal
9195 lookup finds a non-function, in accordance with the
9196 expected resolution of DR 218. */
9197 if (koenig_p
9198 && ((is_overloaded_fn (function)
9199 /* If lookup found a member function, the Koenig lookup is
9200 not appropriate, even if an unqualified-name was used
9201 to denote the function. */
9202 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function)))
9203 || TREE_CODE (function) == IDENTIFIER_NODE))
9204 function = perform_koenig_lookup (function, call_args);
9205
9206 if (TREE_CODE (function) == IDENTIFIER_NODE)
9207 {
9208 unqualified_name_lookup_error (function);
9209 return error_mark_node;
9210 }
9211
9212 /* Remember that there was a reference to this entity. */
9213 if (DECL_P (function))
9214 mark_used (function);
9215
9216 if (TREE_CODE (function) == OFFSET_REF)
9217 return build_offset_ref_call_from_tree (function, call_args);
9218 if (TREE_CODE (function) == COMPONENT_REF)
9219 {
9220 if (!BASELINK_P (TREE_OPERAND (function, 1)))
9221 return finish_call_expr (function, call_args,
9222 /*disallow_virtual=*/false,
9223 /*koenig_p=*/false);
9224 else
9225 return (build_new_method_call
9226 (TREE_OPERAND (function, 0),
9227 TREE_OPERAND (function, 1),
9228 call_args, NULL_TREE,
9229 qualified_p ? LOOKUP_NONVIRTUAL : LOOKUP_NORMAL,
9230 /*fn_p=*/NULL));
9231 }
9232 return finish_call_expr (function, call_args,
9233 /*disallow_virtual=*/qualified_p,
9234 koenig_p);
9235 }
9236
9237 case COND_EXPR:
9238 return build_x_conditional_expr
9239 (RECUR (TREE_OPERAND (t, 0)),
9240 RECUR (TREE_OPERAND (t, 1)),
9241 RECUR (TREE_OPERAND (t, 2)));
9242
9243 case PSEUDO_DTOR_EXPR:
9244 return finish_pseudo_destructor_expr
9245 (RECUR (TREE_OPERAND (t, 0)),
9246 RECUR (TREE_OPERAND (t, 1)),
9247 RECUR (TREE_OPERAND (t, 2)));
9248
9249 case TREE_LIST:
9250 {
9251 tree purpose, value, chain;
9252
9253 if (t == void_list_node)
9254 return t;
9255
9256 purpose = TREE_PURPOSE (t);
9257 if (purpose)
9258 purpose = RECUR (purpose);
9259 value = TREE_VALUE (t);
9260 if (value)
9261 value = RECUR (value);
9262 chain = TREE_CHAIN (t);
9263 if (chain && chain != void_type_node)
9264 chain = RECUR (chain);
9265 if (purpose == TREE_PURPOSE (t)
9266 && value == TREE_VALUE (t)
9267 && chain == TREE_CHAIN (t))
9268 return t;
9269 return tree_cons (purpose, value, chain);
9270 }
9271
9272 case COMPONENT_REF:
9273 {
9274 tree object;
9275 tree object_type;
9276 tree member;
9277
9278 object = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
9279 args, complain, in_decl);
9280 /* Remember that there was a reference to this entity. */
9281 if (DECL_P (object))
9282 mark_used (object);
9283 object_type = TREE_TYPE (object);
9284
9285 member = TREE_OPERAND (t, 1);
9286 if (BASELINK_P (member))
9287 member = tsubst_baselink (member,
9288 non_reference (TREE_TYPE (object)),
9289 args, complain, in_decl);
9290 else
9291 member = tsubst_copy (member, args, complain, in_decl);
9292 if (member == error_mark_node)
9293 return error_mark_node;
9294
9295 if (object_type && !CLASS_TYPE_P (object_type))
9296 {
9297 if (TREE_CODE (member) == BIT_NOT_EXPR)
9298 return finish_pseudo_destructor_expr (object,
9299 NULL_TREE,
9300 object_type);
9301 else if (TREE_CODE (member) == SCOPE_REF
9302 && (TREE_CODE (TREE_OPERAND (member, 1)) == BIT_NOT_EXPR))
9303 return finish_pseudo_destructor_expr (object,
9304 object,
9305 object_type);
9306 }
9307 else if (TREE_CODE (member) == SCOPE_REF
9308 && TREE_CODE (TREE_OPERAND (member, 1)) == TEMPLATE_ID_EXPR)
9309 {
9310 tree tmpl;
9311 tree args;
9312
9313 /* Lookup the template functions now that we know what the
9314 scope is. */
9315 tmpl = TREE_OPERAND (TREE_OPERAND (member, 1), 0);
9316 args = TREE_OPERAND (TREE_OPERAND (member, 1), 1);
9317 member = lookup_qualified_name (TREE_OPERAND (member, 0), tmpl,
9318 /*is_type_p=*/false,
9319 /*complain=*/false);
9320 if (BASELINK_P (member))
9321 {
9322 BASELINK_FUNCTIONS (member)
9323 = build_nt (TEMPLATE_ID_EXPR, BASELINK_FUNCTIONS (member),
9324 args);
9325 member = (adjust_result_of_qualified_name_lookup
9326 (member, BINFO_TYPE (BASELINK_BINFO (member)),
9327 object_type));
9328 }
9329 else
9330 {
9331 qualified_name_lookup_error (object_type, tmpl, member);
9332 return error_mark_node;
9333 }
9334 }
9335 else if (TREE_CODE (member) == SCOPE_REF
9336 && !CLASS_TYPE_P (TREE_OPERAND (member, 0))
9337 && TREE_CODE (TREE_OPERAND (member, 0)) != NAMESPACE_DECL)
9338 {
9339 if (complain & tf_error)
9340 {
9341 if (TYPE_P (TREE_OPERAND (member, 0)))
9342 error ("%qT is not a class or namespace",
9343 TREE_OPERAND (member, 0));
9344 else
9345 error ("%qD is not a class or namespace",
9346 TREE_OPERAND (member, 0));
9347 }
9348 return error_mark_node;
9349 }
9350 else if (TREE_CODE (member) == FIELD_DECL)
9351 return finish_non_static_data_member (member, object, NULL_TREE);
9352
9353 return finish_class_member_access_expr (object, member,
9354 /*template_p=*/false);
9355 }
9356
9357 case THROW_EXPR:
9358 return build_throw
9359 (RECUR (TREE_OPERAND (t, 0)));
9360
9361 case CONSTRUCTOR:
9362 {
9363 VEC(constructor_elt,gc) *n;
9364 constructor_elt *ce;
9365 unsigned HOST_WIDE_INT idx;
9366 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
9367 bool process_index_p;
9368
9369 if (type == error_mark_node)
9370 return error_mark_node;
9371
9372 /* digest_init will do the wrong thing if we let it. */
9373 if (type && TYPE_PTRMEMFUNC_P (type))
9374 return t;
9375
9376 /* We do not want to process the index of aggregate
9377 initializers as they are identifier nodes which will be
9378 looked up by digest_init. */
9379 process_index_p = !(type && IS_AGGR_TYPE (type));
9380
9381 n = VEC_copy (constructor_elt, gc, CONSTRUCTOR_ELTS (t));
9382 for (idx = 0; VEC_iterate (constructor_elt, n, idx, ce); idx++)
9383 {
9384 if (ce->index && process_index_p)
9385 ce->index = RECUR (ce->index);
9386 ce->value = RECUR (ce->value);
9387 }
9388
9389 if (TREE_HAS_CONSTRUCTOR (t))
9390 return finish_compound_literal (type, n);
9391
9392 return build_constructor (NULL_TREE, n);
9393 }
9394
9395 case TYPEID_EXPR:
9396 {
9397 tree operand_0 = RECUR (TREE_OPERAND (t, 0));
9398 if (TYPE_P (operand_0))
9399 return get_typeid (operand_0);
9400 return build_typeid (operand_0);
9401 }
9402
9403 case VAR_DECL:
9404 if (!args)
9405 return t;
9406 /* Fall through */
9407
9408 case PARM_DECL:
9409 {
9410 tree r = tsubst_copy (t, args, complain, in_decl);
9411
9412 if (TREE_CODE (TREE_TYPE (t)) != REFERENCE_TYPE)
9413 /* If the original type was a reference, we'll be wrapped in
9414 the appropriate INDIRECT_REF. */
9415 r = convert_from_reference (r);
9416 return r;
9417 }
9418
9419 case VA_ARG_EXPR:
9420 return build_x_va_arg (RECUR (TREE_OPERAND (t, 0)),
9421 tsubst_copy (TREE_TYPE (t), args, complain,
9422 in_decl));
9423
9424 case OFFSETOF_EXPR:
9425 return finish_offsetof (RECUR (TREE_OPERAND (t, 0)));
9426
9427 case STMT_EXPR:
9428 {
9429 tree old_stmt_expr = cur_stmt_expr;
9430 tree stmt_expr = begin_stmt_expr ();
9431
9432 cur_stmt_expr = stmt_expr;
9433 tsubst_expr (STMT_EXPR_STMT (t), args, complain, in_decl,
9434 integral_constant_expression_p);
9435 stmt_expr = finish_stmt_expr (stmt_expr, false);
9436 cur_stmt_expr = old_stmt_expr;
9437
9438 return stmt_expr;
9439 }
9440
9441 case CONST_DECL:
9442 t = tsubst_copy (t, args, complain, in_decl);
9443 /* As in finish_id_expression, we resolve enumeration constants
9444 to their underlying values. */
9445 if (TREE_CODE (t) == CONST_DECL)
9446 {
9447 used_types_insert (TREE_TYPE (t));
9448 return DECL_INITIAL (t);
9449 }
9450 return t;
9451
9452 default:
9453 /* Handle Objective-C++ constructs, if appropriate. */
9454 {
9455 tree subst
9456 = objcp_tsubst_copy_and_build (t, args, complain,
9457 in_decl, /*function_p=*/false);
9458 if (subst)
9459 return subst;
9460 }
9461 return tsubst_copy (t, args, complain, in_decl);
9462 }
9463
9464#undef RECUR
9465}
9466
9467/* Verify that the instantiated ARGS are valid. For type arguments,
9468 make sure that the type's linkage is ok. For non-type arguments,
9469 make sure they are constants if they are integral or enumerations.
9470 Emit an error under control of COMPLAIN, and return TRUE on error. */
9471
9472static bool
9473check_instantiated_args (tree tmpl, tree args, tsubst_flags_t complain)
9474{
9475 int ix, len = DECL_NTPARMS (tmpl);
9476 bool result = false;
9477
9478 for (ix = 0; ix != len; ix++)
9479 {
9480 tree t = TREE_VEC_ELT (args, ix);
9481
9482 if (TYPE_P (t))
9483 {
9484 /* [basic.link]: A name with no linkage (notably, the name
9485 of a class or enumeration declared in a local scope)
9486 shall not be used to declare an entity with linkage.
9487 This implies that names with no linkage cannot be used as
9488 template arguments. */
9489 tree nt = no_linkage_check (t, /*relaxed_p=*/false);
9490
9491 if (nt)
9492 {
9493 /* DR 488 makes use of a type with no linkage cause
9494 type deduction to fail. */
9495 if (complain & tf_error)
9496 {
9497 if (TYPE_ANONYMOUS_P (nt))
9498 error ("%qT is/uses anonymous type", t);
9499 else
9500 error ("template argument for %qD uses local type %qT",
9501 tmpl, t);
9502 }
9503 result = true;
9504 }
9505 /* In order to avoid all sorts of complications, we do not
9506 allow variably-modified types as template arguments. */
9507 else if (variably_modified_type_p (t, NULL_TREE))
9508 {
9509 if (complain & tf_error)
9510 error ("%qT is a variably modified type", t);
9511 result = true;
9512 }
9513 }
9514 /* A non-type argument of integral or enumerated type must be a
9515 constant. */
9516 else if (TREE_TYPE (t)
9517 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t))
9518 && !TREE_CONSTANT (t))
9519 {
9520 if (complain & tf_error)
9521 error ("integral expression %qE is not constant", t);
9522 result = true;
9523 }
9524 }
9525 if (result && (complain & tf_error))
9526 error (" trying to instantiate %qD", tmpl);
9527 return result;
9528}
9529
9530/* Instantiate the indicated variable or function template TMPL with
9531 the template arguments in TARG_PTR. */
9532
9533tree
9534instantiate_template (tree tmpl, tree targ_ptr, tsubst_flags_t complain)
9535{
9536 tree fndecl;
9537 tree gen_tmpl;
9538 tree spec;
9539 HOST_WIDE_INT saved_processing_template_decl;
9540
9541 if (tmpl == error_mark_node)
9542 return error_mark_node;
9543
9544 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
9545
9546 /* If this function is a clone, handle it specially. */
9547 if (DECL_CLONED_FUNCTION_P (tmpl))
9548 {
9549 tree spec;
9550 tree clone;
9551
9552 spec = instantiate_template (DECL_CLONED_FUNCTION (tmpl), targ_ptr,
9553 complain);
9554 if (spec == error_mark_node)
9555 return error_mark_node;
9556
9557 /* Look for the clone. */
9558 FOR_EACH_CLONE (clone, spec)
9559 if (DECL_NAME (clone) == DECL_NAME (tmpl))
9560 return clone;
9561 /* We should always have found the clone by now. */
9562 gcc_unreachable ();
9563 return NULL_TREE;
9564 }
9565
9566 /* Check to see if we already have this specialization. */
9567 spec = retrieve_specialization (tmpl, targ_ptr,
9568 /*class_specializations_p=*/false);
9569 if (spec != NULL_TREE)
9570 return spec;
9571
9572 gen_tmpl = most_general_template (tmpl);
9573 if (tmpl != gen_tmpl)
9574 {
9575 /* The TMPL is a partial instantiation. To get a full set of
9576 arguments we must add the arguments used to perform the
9577 partial instantiation. */
9578 targ_ptr = add_outermost_template_args (DECL_TI_ARGS (tmpl),
9579 targ_ptr);
9580
9581 /* Check to see if we already have this specialization. */
9582 spec = retrieve_specialization (gen_tmpl, targ_ptr,
9583 /*class_specializations_p=*/false);
9584 if (spec != NULL_TREE)
9585 return spec;
9586 }
9587
9588 if (check_instantiated_args (gen_tmpl, INNERMOST_TEMPLATE_ARGS (targ_ptr),
9589 complain))
9590 return error_mark_node;
9591
9592 /* We are building a FUNCTION_DECL, during which the access of its
9593 parameters and return types have to be checked. However this
9594 FUNCTION_DECL which is the desired context for access checking
9595 is not built yet. We solve this chicken-and-egg problem by
9596 deferring all checks until we have the FUNCTION_DECL. */
9597 push_deferring_access_checks (dk_deferred);
9598
9599 /* Although PROCESSING_TEMPLATE_DECL may be true at this point
9600 (because, for example, we have encountered a non-dependent
9601 function call in the body of a template function and must now
9602 determine which of several overloaded functions will be called),
9603 within the instantiation itself we are not processing a
9604 template. */
9605 saved_processing_template_decl = processing_template_decl;
9606 processing_template_decl = 0;
9607 /* Substitute template parameters to obtain the specialization. */
9608 fndecl = tsubst (DECL_TEMPLATE_RESULT (gen_tmpl),
9609 targ_ptr, complain, gen_tmpl);
9610 processing_template_decl = saved_processing_template_decl;
9611 if (fndecl == error_mark_node)
9612 return error_mark_node;
9613
9614 /* Now we know the specialization, compute access previously
9615 deferred. */
9616 push_access_scope (fndecl);
9617 perform_deferred_access_checks ();
9618 pop_access_scope (fndecl);
9619 pop_deferring_access_checks ();
9620
9621 /* The DECL_TI_TEMPLATE should always be the immediate parent
9622 template, not the most general template. */
9623 DECL_TI_TEMPLATE (fndecl) = tmpl;
9624
9625 /* If we've just instantiated the main entry point for a function,
9626 instantiate all the alternate entry points as well. We do this
9627 by cloning the instantiation of the main entry point, not by
9628 instantiating the template clones. */
9629 if (TREE_CHAIN (gen_tmpl) && DECL_CLONED_FUNCTION_P (TREE_CHAIN (gen_tmpl)))
9630 clone_function_decl (fndecl, /*update_method_vec_p=*/0);
9631
9632 return fndecl;
9633}
9634
9635/* The FN is a TEMPLATE_DECL for a function. The ARGS are the
9636 arguments that are being used when calling it. TARGS is a vector
9637 into which the deduced template arguments are placed.
9638
9639 Return zero for success, 2 for an incomplete match that doesn't resolve
9640 all the types, and 1 for complete failure. An error message will be
9641 printed only for an incomplete match.
9642
9643 If FN is a conversion operator, or we are trying to produce a specific
9644 specialization, RETURN_TYPE is the return type desired.
9645
9646 The EXPLICIT_TARGS are explicit template arguments provided via a
9647 template-id.
9648
9649 The parameter STRICT is one of:
9650
9651 DEDUCE_CALL:
9652 We are deducing arguments for a function call, as in
9653 [temp.deduct.call].
9654
9655 DEDUCE_CONV:
9656 We are deducing arguments for a conversion function, as in
9657 [temp.deduct.conv].
9658
9659 DEDUCE_EXACT:
9660 We are deducing arguments when doing an explicit instantiation
9661 as in [temp.explicit], when determining an explicit specialization
9662 as in [temp.expl.spec], or when taking the address of a function
9663 template, as in [temp.deduct.funcaddr]. */
9664
9665int
9666fn_type_unification (tree fn,
9667 tree explicit_targs,
9668 tree targs,
9669 tree args,
9670 tree return_type,
9671 unification_kind_t strict,
9672 int flags)
9673{
9674 tree parms;
9675 tree fntype;
9676 int result;
9677
9678 gcc_assert (TREE_CODE (fn) == TEMPLATE_DECL);
9679
9680 fntype = TREE_TYPE (fn);
9681 if (explicit_targs)
9682 {
9683 /* [temp.deduct]
9684
9685 The specified template arguments must match the template
9686 parameters in kind (i.e., type, nontype, template), and there
9687 must not be more arguments than there are parameters;
9688 otherwise type deduction fails.
9689
9690 Nontype arguments must match the types of the corresponding
9691 nontype template parameters, or must be convertible to the
9692 types of the corresponding nontype parameters as specified in
9693 _temp.arg.nontype_, otherwise type deduction fails.
9694
9695 All references in the function type of the function template
9696 to the corresponding template parameters are replaced by the
9697 specified template argument values. If a substitution in a
9698 template parameter or in the function type of the function
9699 template results in an invalid type, type deduction fails. */
9700 int i;
9701 tree converted_args;
9702 bool incomplete;
9703
9704 if (explicit_targs == error_mark_node)
9705 return 1;
9706
9707 converted_args
9708 = (coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn),
9709 explicit_targs, NULL_TREE, tf_none,
9710 /*require_all_args=*/false,
9711 /*use_default_args=*/false));
9712 if (converted_args == error_mark_node)
9713 return 1;
9714
9715 /* Substitute the explicit args into the function type. This is
9716 necessary so that, for instance, explicitly declared function
9717 arguments can match null pointed constants. If we were given
9718 an incomplete set of explicit args, we must not do semantic
9719 processing during substitution as we could create partial
9720 instantiations. */
9721 incomplete = NUM_TMPL_ARGS (explicit_targs) != NUM_TMPL_ARGS (targs);
9722 processing_template_decl += incomplete;
9723 fntype = tsubst (fntype, converted_args, tf_none, NULL_TREE);
9724 processing_template_decl -= incomplete;
9725
9726 if (fntype == error_mark_node)
9727 return 1;
9728
9729 /* Place the explicitly specified arguments in TARGS. */
9730 for (i = NUM_TMPL_ARGS (converted_args); i--;)
9731 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (converted_args, i);
9732 }
9733
9734 /* Never do unification on the 'this' parameter. */
9735 parms = skip_artificial_parms_for (fn, TYPE_ARG_TYPES (fntype));
9736
9737 if (return_type)
9738 {
9739 parms = tree_cons (NULL_TREE, TREE_TYPE (fntype), parms);
9740 args = tree_cons (NULL_TREE, return_type, args);
9741 }
9742
9743 /* We allow incomplete unification without an error message here
9744 because the standard doesn't seem to explicitly prohibit it. Our
9745 callers must be ready to deal with unification failures in any
9746 event. */
9747 result = type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn),
9748 targs, parms, args, /*subr=*/0,
9749 strict, flags);
9750
9751 if (result == 0)
9752 /* All is well so far. Now, check:
9753
9754 [temp.deduct]
9755
9756 When all template arguments have been deduced, all uses of
9757 template parameters in nondeduced contexts are replaced with
9758 the corresponding deduced argument values. If the
9759 substitution results in an invalid type, as described above,
9760 type deduction fails. */
9761 if (tsubst (TREE_TYPE (fn), targs, tf_none, NULL_TREE)
9762 == error_mark_node)
9763 return 1;
9764
9765 return result;
9766}
9767
9768/* Adjust types before performing type deduction, as described in
9769 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
9770 sections are symmetric. PARM is the type of a function parameter
9771 or the return type of the conversion function. ARG is the type of
9772 the argument passed to the call, or the type of the value
9773 initialized with the result of the conversion function. */
9774
9775static int
9776maybe_adjust_types_for_deduction (unification_kind_t strict,
9777 tree* parm,
9778 tree* arg)
9779{
9780 int result = 0;
9781
9782 switch (strict)
9783 {
9784 case DEDUCE_CALL:
9785 break;
9786
9787 case DEDUCE_CONV:
9788 {
9789 /* Swap PARM and ARG throughout the remainder of this
9790 function; the handling is precisely symmetric since PARM
9791 will initialize ARG rather than vice versa. */
9792 tree* temp = parm;
9793 parm = arg;
9794 arg = temp;
9795 break;
9796 }
9797
9798 case DEDUCE_EXACT:
9799 /* There is nothing to do in this case. */
9800 return 0;
9801
9802 default:
9803 gcc_unreachable ();
9804 }
9805
9806 if (TREE_CODE (*parm) != REFERENCE_TYPE)
9807 {
9808 /* [temp.deduct.call]
9809
9810 If P is not a reference type:
9811
9812 --If A is an array type, the pointer type produced by the
9813 array-to-pointer standard conversion (_conv.array_) is
9814 used in place of A for type deduction; otherwise,
9815
9816 --If A is a function type, the pointer type produced by
9817 the function-to-pointer standard conversion
9818 (_conv.func_) is used in place of A for type deduction;
9819 otherwise,
9820
9821 --If A is a cv-qualified type, the top level
9822 cv-qualifiers of A's type are ignored for type
9823 deduction. */
9824 if (TREE_CODE (*arg) == ARRAY_TYPE)
9825 *arg = build_pointer_type (TREE_TYPE (*arg));
9826 else if (TREE_CODE (*arg) == FUNCTION_TYPE)
9827 *arg = build_pointer_type (*arg);
9828 else
9829 *arg = TYPE_MAIN_VARIANT (*arg);
9830 }
9831
9832 /* [temp.deduct.call]
9833
9834 If P is a cv-qualified type, the top level cv-qualifiers
9835 of P's type are ignored for type deduction. If P is a
9836 reference type, the type referred to by P is used for
9837 type deduction. */
9838 *parm = TYPE_MAIN_VARIANT (*parm);
9839 if (TREE_CODE (*parm) == REFERENCE_TYPE)
9840 {
9841 *parm = TREE_TYPE (*parm);
9842 result |= UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
9843 }
9844
9845 /* DR 322. For conversion deduction, remove a reference type on parm
9846 too (which has been swapped into ARG). */
9847 if (strict == DEDUCE_CONV && TREE_CODE (*arg) == REFERENCE_TYPE)
9848 *arg = TREE_TYPE (*arg);
9849
9850 return result;
9851}
9852
9853/* Most parms like fn_type_unification.
9854
9855 If SUBR is 1, we're being called recursively (to unify the
9856 arguments of a function or method parameter of a function
9857 template). */
9858
9859static int
9860type_unification_real (tree tparms,
9861 tree targs,
9862 tree xparms,
9863 tree xargs,
9864 int subr,
9865 unification_kind_t strict,
9866 int flags)
9867{
9868 tree parm, arg;
9869 int i;
9870 int ntparms = TREE_VEC_LENGTH (tparms);
9871 int sub_strict;
9872 int saw_undeduced = 0;
9873 tree parms, args;
9874
9875 gcc_assert (TREE_CODE (tparms) == TREE_VEC);
9876 gcc_assert (xparms == NULL_TREE || TREE_CODE (xparms) == TREE_LIST);
9877 gcc_assert (!xargs || TREE_CODE (xargs) == TREE_LIST);
9878 gcc_assert (ntparms > 0);
9879
9880 switch (strict)
9881 {
9882 case DEDUCE_CALL:
9883 sub_strict = (UNIFY_ALLOW_OUTER_LEVEL | UNIFY_ALLOW_MORE_CV_QUAL
9884 | UNIFY_ALLOW_DERIVED);
9885 break;
9886
9887 case DEDUCE_CONV:
9888 sub_strict = UNIFY_ALLOW_LESS_CV_QUAL;
9889 break;
9890
9891 case DEDUCE_EXACT:
9892 sub_strict = UNIFY_ALLOW_NONE;
9893 break;
9894
9895 default:
9896 gcc_unreachable ();
9897 }
9898
9899 again:
9900 parms = xparms;
9901 args = xargs;
9902
9903 while (parms && parms != void_list_node
9904 && args && args != void_list_node)
9905 {
9906 parm = TREE_VALUE (parms);
9907 parms = TREE_CHAIN (parms);
9908 arg = TREE_VALUE (args);
9909 args = TREE_CHAIN (args);
9910
9911 if (arg == error_mark_node)
9912 return 1;
9913 if (arg == unknown_type_node)
9914 /* We can't deduce anything from this, but we might get all the
9915 template args from other function args. */
9916 continue;
9917
9918 /* Conversions will be performed on a function argument that
9919 corresponds with a function parameter that contains only
9920 non-deducible template parameters and explicitly specified
9921 template parameters. */
9922 if (!uses_template_parms (parm))
9923 {
9924 tree type;
9925
9926 if (!TYPE_P (arg))
9927 type = TREE_TYPE (arg);
9928 else
9929 type = arg;
9930
9931 if (same_type_p (parm, type))
9932 continue;
9933 if (strict != DEDUCE_EXACT
9934 && can_convert_arg (parm, type, TYPE_P (arg) ? NULL_TREE : arg,
9935 flags))
9936 continue;
9937
9938 return 1;
9939 }
9940
9941 if (!TYPE_P (arg))
9942 {
9943 gcc_assert (TREE_TYPE (arg) != NULL_TREE);
9944 if (type_unknown_p (arg))
9945 {
9946 /* [temp.deduct.type]
9947
9948 A template-argument can be deduced from a pointer to
9949 function or pointer to member function argument if
9950 the set of overloaded functions does not contain
9951 function templates and at most one of a set of
9952 overloaded functions provides a unique match. */
9953 if (resolve_overloaded_unification
9954 (tparms, targs, parm, arg, strict, sub_strict))
9955 continue;
9956
9957 return 1;
9958 }
9959 arg = unlowered_expr_type (arg);
9960 if (arg == error_mark_node)
9961 return 1;
9962 }
9963
9964 {
9965 int arg_strict = sub_strict;
9966
9967 if (!subr)
9968 arg_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg);
9969
9970 if (unify (tparms, targs, parm, arg, arg_strict))
9971 return 1;
9972 }
9973 }
9974
9975 /* Fail if we've reached the end of the parm list, and more args
9976 are present, and the parm list isn't variadic. */
9977 if (args && args != void_list_node && parms == void_list_node)
9978 return 1;
9979 /* Fail if parms are left and they don't have default values. */
9980 if (parms && parms != void_list_node
9981 && TREE_PURPOSE (parms) == NULL_TREE)
9982 return 1;
9983
9984 if (!subr)
9985 for (i = 0; i < ntparms; i++)
9986 if (!TREE_VEC_ELT (targs, i))
9987 {
9988 tree tparm;
9989
9990 if (TREE_VEC_ELT (tparms, i) == error_mark_node)
9991 continue;
9992
9993 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
9994
9995 /* If this is an undeduced nontype parameter that depends on
9996 a type parameter, try another pass; its type may have been
9997 deduced from a later argument than the one from which
9998 this parameter can be deduced. */
9999 if (TREE_CODE (tparm) == PARM_DECL
10000 && uses_template_parms (TREE_TYPE (tparm))
10001 && !saw_undeduced++)
10002 goto again;
10003
10004 return 2;
10005 }
10006
10007 return 0;
10008}
10009
10010/* Subroutine of type_unification_real. Args are like the variables
10011 at the call site. ARG is an overloaded function (or template-id);
10012 we try deducing template args from each of the overloads, and if
10013 only one succeeds, we go with that. Modifies TARGS and returns
10014 true on success. */
10015
10016static bool
10017resolve_overloaded_unification (tree tparms,
10018 tree targs,
10019 tree parm,
10020 tree arg,
10021 unification_kind_t strict,
10022 int sub_strict)
10023{
10024 tree tempargs = copy_node (targs);
10025 int good = 0;
10026 bool addr_p;
10027
10028 if (TREE_CODE (arg) == ADDR_EXPR)
10029 {
10030 arg = TREE_OPERAND (arg, 0);
10031 addr_p = true;
10032 }
10033 else
10034 addr_p = false;
10035
10036 if (TREE_CODE (arg) == COMPONENT_REF)
10037 /* Handle `&x' where `x' is some static or non-static member
10038 function name. */
10039 arg = TREE_OPERAND (arg, 1);
10040
10041 if (TREE_CODE (arg) == OFFSET_REF)
10042 arg = TREE_OPERAND (arg, 1);
10043
10044 /* Strip baselink information. */
10045 if (BASELINK_P (arg))
10046 arg = BASELINK_FUNCTIONS (arg);
10047
10048 if (TREE_CODE (arg) == TEMPLATE_ID_EXPR)
10049 {
10050 /* If we got some explicit template args, we need to plug them into
10051 the affected templates before we try to unify, in case the
10052 explicit args will completely resolve the templates in question. */
10053
10054 tree expl_subargs = TREE_OPERAND (arg, 1);
10055 arg = TREE_OPERAND (arg, 0);
10056
10057 for (; arg; arg = OVL_NEXT (arg))
10058 {
10059 tree fn = OVL_CURRENT (arg);
10060 tree subargs, elem;
10061
10062 if (TREE_CODE (fn) != TEMPLATE_DECL)
10063 continue;
10064
10065 subargs = get_bindings (fn, DECL_TEMPLATE_RESULT (fn),
10066 expl_subargs, /*check_ret=*/false);
10067 if (subargs)
10068 {
10069 elem = tsubst (TREE_TYPE (fn), subargs, tf_none, NULL_TREE);
10070 good += try_one_overload (tparms, targs, tempargs, parm,
10071 elem, strict, sub_strict, addr_p);
10072 }
10073 }
10074 }
10075 else if (TREE_CODE (arg) != OVERLOAD
10076 && TREE_CODE (arg) != FUNCTION_DECL)
10077 /* If ARG is, for example, "(0, &f)" then its type will be unknown
10078 -- but the deduction does not succeed because the expression is
10079 not just the function on its own. */
10080 return false;
10081 else
10082 for (; arg; arg = OVL_NEXT (arg))
10083 good += try_one_overload (tparms, targs, tempargs, parm,
10084 TREE_TYPE (OVL_CURRENT (arg)),
10085 strict, sub_strict, addr_p);
10086
10087 /* [temp.deduct.type] A template-argument can be deduced from a pointer
10088 to function or pointer to member function argument if the set of
10089 overloaded functions does not contain function templates and at most
10090 one of a set of overloaded functions provides a unique match.
10091
10092 So if we found multiple possibilities, we return success but don't
10093 deduce anything. */
10094
10095 if (good == 1)
10096 {
10097 int i = TREE_VEC_LENGTH (targs);
10098 for (; i--; )
10099 if (TREE_VEC_ELT (tempargs, i))
10100 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (tempargs, i);
10101 }
10102 if (good)
10103 return true;
10104
10105 return false;
10106}
10107
10108/* Subroutine of resolve_overloaded_unification; does deduction for a single
10109 overload. Fills TARGS with any deduced arguments, or error_mark_node if
10110 different overloads deduce different arguments for a given parm.
10111 ADDR_P is true if the expression for which deduction is being
10112 performed was of the form "& fn" rather than simply "fn".
10113
10114 Returns 1 on success. */
10115
10116static int
10117try_one_overload (tree tparms,
10118 tree orig_targs,
10119 tree targs,
10120 tree parm,
10121 tree arg,
10122 unification_kind_t strict,
10123 int sub_strict,
10124 bool addr_p)
10125{
10126 int nargs;
10127 tree tempargs;
10128 int i;
10129
10130 /* [temp.deduct.type] A template-argument can be deduced from a pointer
10131 to function or pointer to member function argument if the set of
10132 overloaded functions does not contain function templates and at most
10133 one of a set of overloaded functions provides a unique match.
10134
10135 So if this is a template, just return success. */
10136
10137 if (uses_template_parms (arg))
10138 return 1;
10139
10140 if (TREE_CODE (arg) == METHOD_TYPE)
10141 arg = build_ptrmemfunc_type (build_pointer_type (arg));
10142 else if (addr_p)
10143 arg = build_pointer_type (arg);
10144
10145 sub_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg);
10146
10147 /* We don't copy orig_targs for this because if we have already deduced
10148 some template args from previous args, unify would complain when we
10149 try to deduce a template parameter for the same argument, even though
10150 there isn't really a conflict. */
10151 nargs = TREE_VEC_LENGTH (targs);
10152 tempargs = make_tree_vec (nargs);
10153
10154 if (unify (tparms, tempargs, parm, arg, sub_strict) != 0)
10155 return 0;
10156
10157 /* First make sure we didn't deduce anything that conflicts with
10158 explicitly specified args. */
10159 for (i = nargs; i--; )
10160 {
10161 tree elt = TREE_VEC_ELT (tempargs, i);
10162 tree oldelt = TREE_VEC_ELT (orig_targs, i);
10163
10164 if (!elt)
10165 /*NOP*/;
10166 else if (uses_template_parms (elt))
10167 /* Since we're unifying against ourselves, we will fill in
10168 template args used in the function parm list with our own
10169 template parms. Discard them. */
10170 TREE_VEC_ELT (tempargs, i) = NULL_TREE;
10171 else if (oldelt && !template_args_equal (oldelt, elt))
10172 return 0;
10173 }
10174
10175 for (i = nargs; i--; )
10176 {
10177 tree elt = TREE_VEC_ELT (tempargs, i);
10178
10179 if (elt)
10180 TREE_VEC_ELT (targs, i) = elt;
10181 }
10182
10183 return 1;
10184}
10185
10186/* PARM is a template class (perhaps with unbound template
10187 parameters). ARG is a fully instantiated type. If ARG can be
10188 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
10189 TARGS are as for unify. */
10190
10191static tree
10192try_class_unification (tree tparms, tree targs, tree parm, tree arg)
10193{
10194 tree copy_of_targs;
10195
10196 if (!CLASSTYPE_TEMPLATE_INFO (arg)
10197 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg))
10198 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm))))
10199 return NULL_TREE;
10200
10201 /* We need to make a new template argument vector for the call to
10202 unify. If we used TARGS, we'd clutter it up with the result of
10203 the attempted unification, even if this class didn't work out.
10204 We also don't want to commit ourselves to all the unifications
10205 we've already done, since unification is supposed to be done on
10206 an argument-by-argument basis. In other words, consider the
10207 following pathological case:
10208
10209 template <int I, int J, int K>
10210 struct S {};
10211
10212 template <int I, int J>
10213 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
10214
10215 template <int I, int J, int K>
10216 void f(S<I, J, K>, S<I, I, I>);
10217
10218 void g() {
10219 S<0, 0, 0> s0;
10220 S<0, 1, 2> s2;
10221
10222 f(s0, s2);
10223 }
10224
10225 Now, by the time we consider the unification involving `s2', we
10226 already know that we must have `f<0, 0, 0>'. But, even though
10227 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
10228 because there are two ways to unify base classes of S<0, 1, 2>
10229 with S<I, I, I>. If we kept the already deduced knowledge, we
10230 would reject the possibility I=1. */
10231 copy_of_targs = make_tree_vec (TREE_VEC_LENGTH (targs));
10232
10233 /* If unification failed, we're done. */
10234 if (unify (tparms, copy_of_targs, CLASSTYPE_TI_ARGS (parm),
10235 CLASSTYPE_TI_ARGS (arg), UNIFY_ALLOW_NONE))
10236 return NULL_TREE;
10237
10238 return arg;
10239}
10240
10241/* Given a template type PARM and a class type ARG, find the unique
10242 base type in ARG that is an instance of PARM. We do not examine
10243 ARG itself; only its base-classes. If there is not exactly one
10244 appropriate base class, return NULL_TREE. PARM may be the type of
10245 a partial specialization, as well as a plain template type. Used
10246 by unify. */
10247
10248static tree
10249get_template_base (tree tparms, tree targs, tree parm, tree arg)
10250{
10251 tree rval = NULL_TREE;
10252 tree binfo;
10253
10254 gcc_assert (IS_AGGR_TYPE_CODE (TREE_CODE (arg)));
10255
10256 binfo = TYPE_BINFO (complete_type (arg));
10257 if (!binfo)
10258 /* The type could not be completed. */
10259 return NULL_TREE;
10260
10261 /* Walk in inheritance graph order. The search order is not
10262 important, and this avoids multiple walks of virtual bases. */
10263 for (binfo = TREE_CHAIN (binfo); binfo; binfo = TREE_CHAIN (binfo))
10264 {
10265 tree r = try_class_unification (tparms, targs, parm, BINFO_TYPE (binfo));
10266
10267 if (r)
10268 {
10269 /* If there is more than one satisfactory baseclass, then:
10270
10271 [temp.deduct.call]
10272
10273 If they yield more than one possible deduced A, the type
10274 deduction fails.
10275
10276 applies. */
10277 if (rval && !same_type_p (r, rval))
10278 return NULL_TREE;
10279
10280 rval = r;
10281 }
10282 }
10283
10284 return rval;
10285}
10286
10287/* Returns the level of DECL, which declares a template parameter. */
10288
10289static int
10290template_decl_level (tree decl)
10291{
10292 switch (TREE_CODE (decl))
10293 {
10294 case TYPE_DECL:
10295 case TEMPLATE_DECL:
10296 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl));
10297
10298 case PARM_DECL:
10299 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl));
10300
10301 default:
10302 gcc_unreachable ();
10303 }
10304 return 0;
10305}
10306
10307/* Decide whether ARG can be unified with PARM, considering only the
10308 cv-qualifiers of each type, given STRICT as documented for unify.
10309 Returns nonzero iff the unification is OK on that basis. */
10310
10311static int
10312check_cv_quals_for_unify (int strict, tree arg, tree parm)
10313{
10314 int arg_quals = cp_type_quals (arg);
10315 int parm_quals = cp_type_quals (parm);
10316
10317 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
10318 && !(strict & UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
10319 {
10320 /* Although a CVR qualifier is ignored when being applied to a
10321 substituted template parameter ([8.3.2]/1 for example), that
10322 does not apply during deduction [14.8.2.4]/1, (even though
10323 that is not explicitly mentioned, [14.8.2.4]/9 indicates
10324 this). Except when we're allowing additional CV qualifiers
10325 at the outer level [14.8.2.1]/3,1st bullet. */
10326 if ((TREE_CODE (arg) == REFERENCE_TYPE
10327 || TREE_CODE (arg) == FUNCTION_TYPE
10328 || TREE_CODE (arg) == METHOD_TYPE)
10329 && (parm_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)))
10330 return 0;
10331
10332 if ((!POINTER_TYPE_P (arg) && TREE_CODE (arg) != TEMPLATE_TYPE_PARM)
10333 && (parm_quals & TYPE_QUAL_RESTRICT))
10334 return 0;
10335 }
10336
10337 if (!(strict & (UNIFY_ALLOW_MORE_CV_QUAL | UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
10338 && (arg_quals & parm_quals) != parm_quals)
10339 return 0;
10340
10341 if (!(strict & (UNIFY_ALLOW_LESS_CV_QUAL | UNIFY_ALLOW_OUTER_LESS_CV_QUAL))
10342 && (parm_quals & arg_quals) != arg_quals)
10343 return 0;
10344
10345 return 1;
10346}
10347
10348/* Deduce the value of template parameters. TPARMS is the (innermost)
10349 set of template parameters to a template. TARGS is the bindings
10350 for those template parameters, as determined thus far; TARGS may
10351 include template arguments for outer levels of template parameters
10352 as well. PARM is a parameter to a template function, or a
10353 subcomponent of that parameter; ARG is the corresponding argument.
10354 This function attempts to match PARM with ARG in a manner
10355 consistent with the existing assignments in TARGS. If more values
10356 are deduced, then TARGS is updated.
10357
10358 Returns 0 if the type deduction succeeds, 1 otherwise. The
10359 parameter STRICT is a bitwise or of the following flags:
10360
10361 UNIFY_ALLOW_NONE:
10362 Require an exact match between PARM and ARG.
10363 UNIFY_ALLOW_MORE_CV_QUAL:
10364 Allow the deduced ARG to be more cv-qualified (by qualification
10365 conversion) than ARG.
10366 UNIFY_ALLOW_LESS_CV_QUAL:
10367 Allow the deduced ARG to be less cv-qualified than ARG.
10368 UNIFY_ALLOW_DERIVED:
10369 Allow the deduced ARG to be a template base class of ARG,
10370 or a pointer to a template base class of the type pointed to by
10371 ARG.
10372 UNIFY_ALLOW_INTEGER:
10373 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
10374 case for more information.
10375 UNIFY_ALLOW_OUTER_LEVEL:
10376 This is the outermost level of a deduction. Used to determine validity
10377 of qualification conversions. A valid qualification conversion must
10378 have const qualified pointers leading up to the inner type which
10379 requires additional CV quals, except at the outer level, where const
10380 is not required [conv.qual]. It would be normal to set this flag in
10381 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
10382 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
10383 This is the outermost level of a deduction, and PARM can be more CV
10384 qualified at this point.
10385 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
10386 This is the outermost level of a deduction, and PARM can be less CV
10387 qualified at this point. */
10388
10389static int
10390unify (tree tparms, tree targs, tree parm, tree arg, int strict)
10391{
10392 int idx;
10393 tree targ;
10394 tree tparm;
10395 int strict_in = strict;
10396
10397 /* I don't think this will do the right thing with respect to types.
10398 But the only case I've seen it in so far has been array bounds, where
10399 signedness is the only information lost, and I think that will be
10400 okay. */
10401 while (TREE_CODE (parm) == NOP_EXPR)
10402 parm = TREE_OPERAND (parm, 0);
10403
10404 if (arg == error_mark_node)
10405 return 1;
10406 if (arg == unknown_type_node)
10407 /* We can't deduce anything from this, but we might get all the
10408 template args from other function args. */
10409 return 0;
10410
10411 /* If PARM uses template parameters, then we can't bail out here,
10412 even if ARG == PARM, since we won't record unifications for the
10413 template parameters. We might need them if we're trying to
10414 figure out which of two things is more specialized. */
10415 if (arg == parm && !uses_template_parms (parm))
10416 return 0;
10417
10418 /* Immediately reject some pairs that won't unify because of
10419 cv-qualification mismatches. */
10420 if (TREE_CODE (arg) == TREE_CODE (parm)
10421 && TYPE_P (arg)
10422 /* It is the elements of the array which hold the cv quals of an array
10423 type, and the elements might be template type parms. We'll check
10424 when we recurse. */
10425 && TREE_CODE (arg) != ARRAY_TYPE
10426 /* We check the cv-qualifiers when unifying with template type
10427 parameters below. We want to allow ARG `const T' to unify with
10428 PARM `T' for example, when computing which of two templates
10429 is more specialized, for example. */
10430 && TREE_CODE (arg) != TEMPLATE_TYPE_PARM
10431 && !check_cv_quals_for_unify (strict_in, arg, parm))
10432 return 1;
10433
10434 if (!(strict & UNIFY_ALLOW_OUTER_LEVEL)
10435 && TYPE_P (parm) && !CP_TYPE_CONST_P (parm))
10436 strict &= ~UNIFY_ALLOW_MORE_CV_QUAL;
10437 strict &= ~UNIFY_ALLOW_OUTER_LEVEL;
10438 strict &= ~UNIFY_ALLOW_DERIVED;
10439 strict &= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
10440 strict &= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL;
10441
10442 switch (TREE_CODE (parm))
10443 {
10444 case TYPENAME_TYPE:
10445 case SCOPE_REF:
10446 case UNBOUND_CLASS_TEMPLATE:
10447 /* In a type which contains a nested-name-specifier, template
10448 argument values cannot be deduced for template parameters used
10449 within the nested-name-specifier. */
10450 return 0;
10451
10452 case TEMPLATE_TYPE_PARM:
10453 case TEMPLATE_TEMPLATE_PARM:
10454 case BOUND_TEMPLATE_TEMPLATE_PARM:
10455 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
| 5300/* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
5301 vector of template arguments, as for tsubst.
5302
5303 Returns an appropriate tsubst'd friend declaration. */
5304
5305static tree
5306tsubst_friend_function (tree decl, tree args)
5307{
5308 tree new_friend;
5309
5310 if (TREE_CODE (decl) == FUNCTION_DECL
5311 && DECL_TEMPLATE_INSTANTIATION (decl)
5312 && TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
5313 /* This was a friend declared with an explicit template
5314 argument list, e.g.:
5315
5316 friend void f<>(T);
5317
5318 to indicate that f was a template instantiation, not a new
5319 function declaration. Now, we have to figure out what
5320 instantiation of what template. */
5321 {
5322 tree template_id, arglist, fns;
5323 tree new_args;
5324 tree tmpl;
5325 tree ns = decl_namespace_context (TYPE_MAIN_DECL (current_class_type));
5326
5327 /* Friend functions are looked up in the containing namespace scope.
5328 We must enter that scope, to avoid finding member functions of the
5329 current cless with same name. */
5330 push_nested_namespace (ns);
5331 fns = tsubst_expr (DECL_TI_TEMPLATE (decl), args,
5332 tf_warning_or_error, NULL_TREE,
5333 /*integral_constant_expression_p=*/false);
5334 pop_nested_namespace (ns);
5335 arglist = tsubst (DECL_TI_ARGS (decl), args,
5336 tf_warning_or_error, NULL_TREE);
5337 template_id = lookup_template_function (fns, arglist);
5338
5339 new_friend = tsubst (decl, args, tf_warning_or_error, NULL_TREE);
5340 tmpl = determine_specialization (template_id, new_friend,
5341 &new_args,
5342 /*need_member_template=*/0,
5343 TREE_VEC_LENGTH (args),
5344 tsk_none);
5345 return instantiate_template (tmpl, new_args, tf_error);
5346 }
5347
5348 new_friend = tsubst (decl, args, tf_warning_or_error, NULL_TREE);
5349
5350 /* The NEW_FRIEND will look like an instantiation, to the
5351 compiler, but is not an instantiation from the point of view of
5352 the language. For example, we might have had:
5353
5354 template <class T> struct S {
5355 template <class U> friend void f(T, U);
5356 };
5357
5358 Then, in S<int>, template <class U> void f(int, U) is not an
5359 instantiation of anything. */
5360 if (new_friend == error_mark_node)
5361 return error_mark_node;
5362
5363 DECL_USE_TEMPLATE (new_friend) = 0;
5364 if (TREE_CODE (decl) == TEMPLATE_DECL)
5365 {
5366 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend)) = 0;
5367 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend))
5368 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl));
5369 }
5370
5371 /* The mangled name for the NEW_FRIEND is incorrect. The function
5372 is not a template instantiation and should not be mangled like
5373 one. Therefore, we forget the mangling here; we'll recompute it
5374 later if we need it. */
5375 if (TREE_CODE (new_friend) != TEMPLATE_DECL)
5376 {
5377 SET_DECL_RTL (new_friend, NULL_RTX);
5378 SET_DECL_ASSEMBLER_NAME (new_friend, NULL_TREE);
5379 }
5380
5381 if (DECL_NAMESPACE_SCOPE_P (new_friend))
5382 {
5383 tree old_decl;
5384 tree new_friend_template_info;
5385 tree new_friend_result_template_info;
5386 tree ns;
5387 int new_friend_is_defn;
5388
5389 /* We must save some information from NEW_FRIEND before calling
5390 duplicate decls since that function will free NEW_FRIEND if
5391 possible. */
5392 new_friend_template_info = DECL_TEMPLATE_INFO (new_friend);
5393 new_friend_is_defn =
5394 (DECL_INITIAL (DECL_TEMPLATE_RESULT
5395 (template_for_substitution (new_friend)))
5396 != NULL_TREE);
5397 if (TREE_CODE (new_friend) == TEMPLATE_DECL)
5398 {
5399 /* This declaration is a `primary' template. */
5400 DECL_PRIMARY_TEMPLATE (new_friend) = new_friend;
5401
5402 new_friend_result_template_info
5403 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend));
5404 }
5405 else
5406 new_friend_result_template_info = NULL_TREE;
5407
5408 /* Make the init_value nonzero so pushdecl knows this is a defn. */
5409 if (new_friend_is_defn)
5410 DECL_INITIAL (new_friend) = error_mark_node;
5411
5412 /* Inside pushdecl_namespace_level, we will push into the
5413 current namespace. However, the friend function should go
5414 into the namespace of the template. */
5415 ns = decl_namespace_context (new_friend);
5416 push_nested_namespace (ns);
5417 old_decl = pushdecl_namespace_level (new_friend, /*is_friend=*/true);
5418 pop_nested_namespace (ns);
5419
5420 if (old_decl == error_mark_node)
5421 return error_mark_node;
5422
5423 if (old_decl != new_friend)
5424 {
5425 /* This new friend declaration matched an existing
5426 declaration. For example, given:
5427
5428 template <class T> void f(T);
5429 template <class U> class C {
5430 template <class T> friend void f(T) {}
5431 };
5432
5433 the friend declaration actually provides the definition
5434 of `f', once C has been instantiated for some type. So,
5435 old_decl will be the out-of-class template declaration,
5436 while new_friend is the in-class definition.
5437
5438 But, if `f' was called before this point, the
5439 instantiation of `f' will have DECL_TI_ARGS corresponding
5440 to `T' but not to `U', references to which might appear
5441 in the definition of `f'. Previously, the most general
5442 template for an instantiation of `f' was the out-of-class
5443 version; now it is the in-class version. Therefore, we
5444 run through all specialization of `f', adding to their
5445 DECL_TI_ARGS appropriately. In particular, they need a
5446 new set of outer arguments, corresponding to the
5447 arguments for this class instantiation.
5448
5449 The same situation can arise with something like this:
5450
5451 friend void f(int);
5452 template <class T> class C {
5453 friend void f(T) {}
5454 };
5455
5456 when `C<int>' is instantiated. Now, `f(int)' is defined
5457 in the class. */
5458
5459 if (!new_friend_is_defn)
5460 /* On the other hand, if the in-class declaration does
5461 *not* provide a definition, then we don't want to alter
5462 existing definitions. We can just leave everything
5463 alone. */
5464 ;
5465 else
5466 {
5467 /* Overwrite whatever template info was there before, if
5468 any, with the new template information pertaining to
5469 the declaration. */
5470 DECL_TEMPLATE_INFO (old_decl) = new_friend_template_info;
5471
5472 if (TREE_CODE (old_decl) != TEMPLATE_DECL)
5473 reregister_specialization (new_friend,
5474 most_general_template (old_decl),
5475 old_decl);
5476 else
5477 {
5478 tree t;
5479 tree new_friend_args;
5480
5481 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl))
5482 = new_friend_result_template_info;
5483
5484 new_friend_args = TI_ARGS (new_friend_template_info);
5485 for (t = DECL_TEMPLATE_SPECIALIZATIONS (old_decl);
5486 t != NULL_TREE;
5487 t = TREE_CHAIN (t))
5488 {
5489 tree spec = TREE_VALUE (t);
5490
5491 DECL_TI_ARGS (spec)
5492 = add_outermost_template_args (new_friend_args,
5493 DECL_TI_ARGS (spec));
5494 }
5495
5496 /* Now, since specializations are always supposed to
5497 hang off of the most general template, we must move
5498 them. */
5499 t = most_general_template (old_decl);
5500 if (t != old_decl)
5501 {
5502 DECL_TEMPLATE_SPECIALIZATIONS (t)
5503 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (t),
5504 DECL_TEMPLATE_SPECIALIZATIONS (old_decl));
5505 DECL_TEMPLATE_SPECIALIZATIONS (old_decl) = NULL_TREE;
5506 }
5507 }
5508 }
5509
5510 /* The information from NEW_FRIEND has been merged into OLD_DECL
5511 by duplicate_decls. */
5512 new_friend = old_decl;
5513 }
5514 }
5515 else
5516 {
5517 tree context = DECL_CONTEXT (new_friend);
5518 bool dependent_p;
5519
5520 /* In the code
5521 template <class T> class C {
5522 template <class U> friend void C1<U>::f (); // case 1
5523 friend void C2<T>::f (); // case 2
5524 };
5525 we only need to make sure CONTEXT is a complete type for
5526 case 2. To distinguish between the two cases, we note that
5527 CONTEXT of case 1 remains dependent type after tsubst while
5528 this isn't true for case 2. */
5529 ++processing_template_decl;
5530 dependent_p = dependent_type_p (context);
5531 --processing_template_decl;
5532
5533 if (!dependent_p
5534 && !complete_type_or_else (context, NULL_TREE))
5535 return error_mark_node;
5536
5537 if (COMPLETE_TYPE_P (context))
5538 {
5539 /* Check to see that the declaration is really present, and,
5540 possibly obtain an improved declaration. */
5541 tree fn = check_classfn (context,
5542 new_friend, NULL_TREE);
5543
5544 if (fn)
5545 new_friend = fn;
5546 }
5547 }
5548
5549 return new_friend;
5550}
5551
5552/* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
5553 template arguments, as for tsubst.
5554
5555 Returns an appropriate tsubst'd friend type or error_mark_node on
5556 failure. */
5557
5558static tree
5559tsubst_friend_class (tree friend_tmpl, tree args)
5560{
5561 tree friend_type;
5562 tree tmpl;
5563 tree context;
5564
5565 context = DECL_CONTEXT (friend_tmpl);
5566
5567 if (context)
5568 {
5569 if (TREE_CODE (context) == NAMESPACE_DECL)
5570 push_nested_namespace (context);
5571 else
5572 push_nested_class (tsubst (context, args, tf_none, NULL_TREE));
5573 }
5574
5575 /* Look for a class template declaration. We look for hidden names
5576 because two friend declarations of the same template are the
5577 same. For example, in:
5578
5579 struct A {
5580 template <typename> friend class F;
5581 };
5582 template <typename> struct B {
5583 template <typename> friend class F;
5584 };
5585
5586 both F templates are the same. */
5587 tmpl = lookup_name_real (DECL_NAME (friend_tmpl), 0, 0,
5588 /*block_p=*/true, 0,
5589 LOOKUP_COMPLAIN | LOOKUP_HIDDEN);
5590
5591 /* But, if we don't find one, it might be because we're in a
5592 situation like this:
5593
5594 template <class T>
5595 struct S {
5596 template <class U>
5597 friend struct S;
5598 };
5599
5600 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
5601 for `S<int>', not the TEMPLATE_DECL. */
5602 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5603 {
5604 tmpl = lookup_name_prefer_type (DECL_NAME (friend_tmpl), 1);
5605 tmpl = maybe_get_template_decl_from_type_decl (tmpl);
5606 }
5607
5608 if (tmpl && DECL_CLASS_TEMPLATE_P (tmpl))
5609 {
5610 /* The friend template has already been declared. Just
5611 check to see that the declarations match, and install any new
5612 default parameters. We must tsubst the default parameters,
5613 of course. We only need the innermost template parameters
5614 because that is all that redeclare_class_template will look
5615 at. */
5616 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl))
5617 > TMPL_ARGS_DEPTH (args))
5618 {
5619 tree parms;
5620 parms = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl),
5621 args, tf_warning_or_error);
5622 redeclare_class_template (TREE_TYPE (tmpl), parms);
5623 }
5624
5625 friend_type = TREE_TYPE (tmpl);
5626 }
5627 else
5628 {
5629 /* The friend template has not already been declared. In this
5630 case, the instantiation of the template class will cause the
5631 injection of this template into the global scope. */
5632 tmpl = tsubst (friend_tmpl, args, tf_warning_or_error, NULL_TREE);
5633 if (tmpl == error_mark_node)
5634 return error_mark_node;
5635
5636 /* The new TMPL is not an instantiation of anything, so we
5637 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
5638 the new type because that is supposed to be the corresponding
5639 template decl, i.e., TMPL. */
5640 DECL_USE_TEMPLATE (tmpl) = 0;
5641 DECL_TEMPLATE_INFO (tmpl) = NULL_TREE;
5642 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl)) = 0;
5643 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl))
5644 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl)));
5645
5646 /* Inject this template into the global scope. */
5647 friend_type = TREE_TYPE (pushdecl_top_level_maybe_friend (tmpl, true));
5648 }
5649
5650 if (context)
5651 {
5652 if (TREE_CODE (context) == NAMESPACE_DECL)
5653 pop_nested_namespace (context);
5654 else
5655 pop_nested_class ();
5656 }
5657
5658 return friend_type;
5659}
5660
5661/* Returns zero if TYPE cannot be completed later due to circularity.
5662 Otherwise returns one. */
5663
5664static int
5665can_complete_type_without_circularity (tree type)
5666{
5667 if (type == NULL_TREE || type == error_mark_node)
5668 return 0;
5669 else if (COMPLETE_TYPE_P (type))
5670 return 1;
5671 else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
5672 return can_complete_type_without_circularity (TREE_TYPE (type));
5673 else if (CLASS_TYPE_P (type)
5674 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type)))
5675 return 0;
5676 else
5677 return 1;
5678}
5679
5680tree
5681instantiate_class_template (tree type)
5682{
5683 tree template, args, pattern, t, member;
5684 tree typedecl;
5685 tree pbinfo;
5686 tree base_list;
5687
5688 if (type == error_mark_node)
5689 return error_mark_node;
5690
5691 if (TYPE_BEING_DEFINED (type)
5692 || COMPLETE_TYPE_P (type)
5693 || dependent_type_p (type))
5694 return type;
5695
5696 /* Figure out which template is being instantiated. */
5697 template = most_general_template (CLASSTYPE_TI_TEMPLATE (type));
5698 gcc_assert (TREE_CODE (template) == TEMPLATE_DECL);
5699
5700 /* Determine what specialization of the original template to
5701 instantiate. */
5702 t = most_specialized_class (type, template);
5703 if (t == error_mark_node)
5704 {
5705 TYPE_BEING_DEFINED (type) = 1;
5706 return error_mark_node;
5707 }
5708 else if (t)
5709 {
5710 /* This TYPE is actually an instantiation of a partial
5711 specialization. We replace the innermost set of ARGS with
5712 the arguments appropriate for substitution. For example,
5713 given:
5714
5715 template <class T> struct S {};
5716 template <class T> struct S<T*> {};
5717
5718 and supposing that we are instantiating S<int*>, ARGS will
5719 presently be {int*} -- but we need {int}. */
5720 pattern = TREE_TYPE (t);
5721 args = TREE_PURPOSE (t);
5722 }
5723 else
5724 {
5725 pattern = TREE_TYPE (template);
5726 args = CLASSTYPE_TI_ARGS (type);
5727 }
5728
5729 /* If the template we're instantiating is incomplete, then clearly
5730 there's nothing we can do. */
5731 if (!COMPLETE_TYPE_P (pattern))
5732 return type;
5733
5734 /* If we've recursively instantiated too many templates, stop. */
5735 if (! push_tinst_level (type))
5736 return type;
5737
5738 /* Now we're really doing the instantiation. Mark the type as in
5739 the process of being defined. */
5740 TYPE_BEING_DEFINED (type) = 1;
5741
5742 /* We may be in the middle of deferred access check. Disable
5743 it now. */
5744 push_deferring_access_checks (dk_no_deferred);
5745
5746 push_to_top_level ();
5747
5748 SET_CLASSTYPE_INTERFACE_UNKNOWN (type);
5749
5750 /* Set the input location to the template definition. This is needed
5751 if tsubsting causes an error. */
5752 typedecl = TYPE_MAIN_DECL (type);
5753 input_location = DECL_SOURCE_LOCATION (typedecl);
5754 in_system_header = DECL_IN_SYSTEM_HEADER (typedecl);
5755
5756 TYPE_HAS_CONSTRUCTOR (type) = TYPE_HAS_CONSTRUCTOR (pattern);
5757 TYPE_HAS_NEW_OPERATOR (type) = TYPE_HAS_NEW_OPERATOR (pattern);
5758 TYPE_HAS_ARRAY_NEW_OPERATOR (type) = TYPE_HAS_ARRAY_NEW_OPERATOR (pattern);
5759 TYPE_GETS_DELETE (type) = TYPE_GETS_DELETE (pattern);
5760 TYPE_HAS_ASSIGN_REF (type) = TYPE_HAS_ASSIGN_REF (pattern);
5761 TYPE_HAS_CONST_ASSIGN_REF (type) = TYPE_HAS_CONST_ASSIGN_REF (pattern);
5762 TYPE_HAS_INIT_REF (type) = TYPE_HAS_INIT_REF (pattern);
5763 TYPE_HAS_CONST_INIT_REF (type) = TYPE_HAS_CONST_INIT_REF (pattern);
5764 TYPE_HAS_DEFAULT_CONSTRUCTOR (type) = TYPE_HAS_DEFAULT_CONSTRUCTOR (pattern);
5765 TYPE_HAS_CONVERSION (type) = TYPE_HAS_CONVERSION (pattern);
5766 TYPE_PACKED (type) = TYPE_PACKED (pattern);
5767 TYPE_ALIGN (type) = TYPE_ALIGN (pattern);
5768 TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (pattern);
5769 TYPE_FOR_JAVA (type) = TYPE_FOR_JAVA (pattern); /* For libjava's JArray<T> */
5770 if (ANON_AGGR_TYPE_P (pattern))
5771 SET_ANON_AGGR_TYPE_P (type);
5772 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern))
5773 {
5774 CLASSTYPE_VISIBILITY_SPECIFIED (type) = 1;
5775 CLASSTYPE_VISIBILITY (type) = CLASSTYPE_VISIBILITY (pattern);
5776 }
5777
5778 pbinfo = TYPE_BINFO (pattern);
5779
5780 /* We should never instantiate a nested class before its enclosing
5781 class; we need to look up the nested class by name before we can
5782 instantiate it, and that lookup should instantiate the enclosing
5783 class. */
5784 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern))
5785 || COMPLETE_TYPE_P (TYPE_CONTEXT (type))
5786 || TYPE_BEING_DEFINED (TYPE_CONTEXT (type)));
5787
5788 base_list = NULL_TREE;
5789 if (BINFO_N_BASE_BINFOS (pbinfo))
5790 {
5791 tree pbase_binfo;
5792 tree context = TYPE_CONTEXT (type);
5793 tree pushed_scope;
5794 int i;
5795
5796 /* We must enter the scope containing the type, as that is where
5797 the accessibility of types named in dependent bases are
5798 looked up from. */
5799 pushed_scope = push_scope (context ? context : global_namespace);
5800
5801 /* Substitute into each of the bases to determine the actual
5802 basetypes. */
5803 for (i = 0; BINFO_BASE_ITERATE (pbinfo, i, pbase_binfo); i++)
5804 {
5805 tree base;
5806 tree access = BINFO_BASE_ACCESS (pbinfo, i);
5807
5808 /* Substitute to figure out the base class. */
5809 base = tsubst (BINFO_TYPE (pbase_binfo), args, tf_error, NULL_TREE);
5810 if (base == error_mark_node)
5811 continue;
5812
5813 base_list = tree_cons (access, base, base_list);
5814 if (BINFO_VIRTUAL_P (pbase_binfo))
5815 TREE_TYPE (base_list) = integer_type_node;
5816 }
5817
5818 /* The list is now in reverse order; correct that. */
5819 base_list = nreverse (base_list);
5820
5821 if (pushed_scope)
5822 pop_scope (pushed_scope);
5823 }
5824 /* Now call xref_basetypes to set up all the base-class
5825 information. */
5826 xref_basetypes (type, base_list);
5827
5828
5829 /* Now that our base classes are set up, enter the scope of the
5830 class, so that name lookups into base classes, etc. will work
5831 correctly. This is precisely analogous to what we do in
5832 begin_class_definition when defining an ordinary non-template
5833 class. */
5834 pushclass (type);
5835
5836 /* Now members are processed in the order of declaration. */
5837 for (member = CLASSTYPE_DECL_LIST (pattern);
5838 member; member = TREE_CHAIN (member))
5839 {
5840 tree t = TREE_VALUE (member);
5841
5842 if (TREE_PURPOSE (member))
5843 {
5844 if (TYPE_P (t))
5845 {
5846 /* Build new CLASSTYPE_NESTED_UTDS. */
5847
5848 tree newtag;
5849 bool class_template_p;
5850
5851 class_template_p = (TREE_CODE (t) != ENUMERAL_TYPE
5852 && TYPE_LANG_SPECIFIC (t)
5853 && CLASSTYPE_IS_TEMPLATE (t));
5854 /* If the member is a class template, then -- even after
5855 substitution -- there may be dependent types in the
5856 template argument list for the class. We increment
5857 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
5858 that function will assume that no types are dependent
5859 when outside of a template. */
5860 if (class_template_p)
5861 ++processing_template_decl;
5862 newtag = tsubst (t, args, tf_error, NULL_TREE);
5863 if (class_template_p)
5864 --processing_template_decl;
5865 if (newtag == error_mark_node)
5866 continue;
5867
5868 if (TREE_CODE (newtag) != ENUMERAL_TYPE)
5869 {
5870 tree name = TYPE_IDENTIFIER (t);
5871
5872 if (class_template_p)
5873 /* Unfortunately, lookup_template_class sets
5874 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
5875 instantiation (i.e., for the type of a member
5876 template class nested within a template class.)
5877 This behavior is required for
5878 maybe_process_partial_specialization to work
5879 correctly, but is not accurate in this case;
5880 the TAG is not an instantiation of anything.
5881 (The corresponding TEMPLATE_DECL is an
5882 instantiation, but the TYPE is not.) */
5883 CLASSTYPE_USE_TEMPLATE (newtag) = 0;
5884
5885 /* Now, we call pushtag to put this NEWTAG into the scope of
5886 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
5887 pushtag calling push_template_decl. We don't have to do
5888 this for enums because it will already have been done in
5889 tsubst_enum. */
5890 if (name)
5891 SET_IDENTIFIER_TYPE_VALUE (name, newtag);
5892 pushtag (name, newtag, /*tag_scope=*/ts_current);
5893 }
5894 }
5895 else if (TREE_CODE (t) == FUNCTION_DECL
5896 || DECL_FUNCTION_TEMPLATE_P (t))
5897 {
5898 /* Build new TYPE_METHODS. */
5899 tree r;
5900
5901 if (TREE_CODE (t) == TEMPLATE_DECL)
5902 ++processing_template_decl;
5903 r = tsubst (t, args, tf_error, NULL_TREE);
5904 if (TREE_CODE (t) == TEMPLATE_DECL)
5905 --processing_template_decl;
5906 set_current_access_from_decl (r);
5907 finish_member_declaration (r);
5908 }
5909 else
5910 {
5911 /* Build new TYPE_FIELDS. */
5912
5913 if (TREE_CODE (t) != CONST_DECL)
5914 {
5915 tree r;
5916
5917 /* The the file and line for this declaration, to
5918 assist in error message reporting. Since we
5919 called push_tinst_level above, we don't need to
5920 restore these. */
5921 input_location = DECL_SOURCE_LOCATION (t);
5922
5923 if (TREE_CODE (t) == TEMPLATE_DECL)
5924 ++processing_template_decl;
5925 r = tsubst (t, args, tf_warning_or_error, NULL_TREE);
5926 if (TREE_CODE (t) == TEMPLATE_DECL)
5927 --processing_template_decl;
5928 if (TREE_CODE (r) == VAR_DECL)
5929 {
5930 /* In [temp.inst]:
5931
5932 [t]he initialization (and any associated
5933 side-effects) of a static data member does
5934 not occur unless the static data member is
5935 itself used in a way that requires the
5936 definition of the static data member to
5937 exist.
5938
5939 Therefore, we do not substitute into the
5940 initialized for the static data member here. */
5941 finish_static_data_member_decl
5942 (r,
5943 /*init=*/NULL_TREE,
5944 /*init_const_expr_p=*/false,
5945 /*asmspec_tree=*/NULL_TREE,
5946 /*flags=*/0);
5947 if (DECL_INITIALIZED_IN_CLASS_P (r))
5948 check_static_variable_definition (r, TREE_TYPE (r));
5949 }
5950 else if (TREE_CODE (r) == FIELD_DECL)
5951 {
5952 /* Determine whether R has a valid type and can be
5953 completed later. If R is invalid, then it is
5954 replaced by error_mark_node so that it will not be
5955 added to TYPE_FIELDS. */
5956 tree rtype = TREE_TYPE (r);
5957 if (can_complete_type_without_circularity (rtype))
5958 complete_type (rtype);
5959
5960 if (!COMPLETE_TYPE_P (rtype))
5961 {
5962 cxx_incomplete_type_error (r, rtype);
5963 r = error_mark_node;
5964 }
5965 }
5966
5967 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
5968 such a thing will already have been added to the field
5969 list by tsubst_enum in finish_member_declaration in the
5970 CLASSTYPE_NESTED_UTDS case above. */
5971 if (!(TREE_CODE (r) == TYPE_DECL
5972 && TREE_CODE (TREE_TYPE (r)) == ENUMERAL_TYPE
5973 && DECL_ARTIFICIAL (r)))
5974 {
5975 set_current_access_from_decl (r);
5976 finish_member_declaration (r);
5977 }
5978 }
5979 }
5980 }
5981 else
5982 {
5983 if (TYPE_P (t) || DECL_CLASS_TEMPLATE_P (t))
5984 {
5985 /* Build new CLASSTYPE_FRIEND_CLASSES. */
5986
5987 tree friend_type = t;
5988 bool adjust_processing_template_decl = false;
5989
5990 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
5991 {
5992 /* template <class T> friend class C; */
5993 friend_type = tsubst_friend_class (friend_type, args);
5994 adjust_processing_template_decl = true;
5995 }
5996 else if (TREE_CODE (friend_type) == UNBOUND_CLASS_TEMPLATE)
5997 {
5998 /* template <class T> friend class C::D; */
5999 friend_type = tsubst (friend_type, args,
6000 tf_warning_or_error, NULL_TREE);
6001 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
6002 friend_type = TREE_TYPE (friend_type);
6003 adjust_processing_template_decl = true;
6004 }
6005 else if (TREE_CODE (friend_type) == TYPENAME_TYPE)
6006 {
6007 /* This could be either
6008
6009 friend class T::C;
6010
6011 when dependent_type_p is false or
6012
6013 template <class U> friend class T::C;
6014
6015 otherwise. */
6016 friend_type = tsubst (friend_type, args,
6017 tf_warning_or_error, NULL_TREE);
6018 /* Bump processing_template_decl for correct
6019 dependent_type_p calculation. */
6020 ++processing_template_decl;
6021 if (dependent_type_p (friend_type))
6022 adjust_processing_template_decl = true;
6023 --processing_template_decl;
6024 }
6025 else if (!CLASSTYPE_USE_TEMPLATE (friend_type)
6026 && hidden_name_p (TYPE_NAME (friend_type)))
6027 {
6028 /* friend class C;
6029
6030 where C hasn't been declared yet. Let's lookup name
6031 from namespace scope directly, bypassing any name that
6032 come from dependent base class. */
6033 tree ns = decl_namespace_context (TYPE_MAIN_DECL (friend_type));
6034
6035 /* The call to xref_tag_from_type does injection for friend
6036 classes. */
6037 push_nested_namespace (ns);
6038 friend_type =
6039 xref_tag_from_type (friend_type, NULL_TREE,
6040 /*tag_scope=*/ts_current);
6041 pop_nested_namespace (ns);
6042 }
6043 else if (uses_template_parms (friend_type))
6044 /* friend class C<T>; */
6045 friend_type = tsubst (friend_type, args,
6046 tf_warning_or_error, NULL_TREE);
6047 /* Otherwise it's
6048
6049 friend class C;
6050
6051 where C is already declared or
6052
6053 friend class C<int>;
6054
6055 We don't have to do anything in these cases. */
6056
6057 if (adjust_processing_template_decl)
6058 /* Trick make_friend_class into realizing that the friend
6059 we're adding is a template, not an ordinary class. It's
6060 important that we use make_friend_class since it will
6061 perform some error-checking and output cross-reference
6062 information. */
6063 ++processing_template_decl;
6064
6065 if (friend_type != error_mark_node)
6066 make_friend_class (type, friend_type, /*complain=*/false);
6067
6068 if (adjust_processing_template_decl)
6069 --processing_template_decl;
6070 }
6071 else
6072 {
6073 /* Build new DECL_FRIENDLIST. */
6074 tree r;
6075
6076 /* The the file and line for this declaration, to
6077 assist in error message reporting. Since we
6078 called push_tinst_level above, we don't need to
6079 restore these. */
6080 input_location = DECL_SOURCE_LOCATION (t);
6081
6082 if (TREE_CODE (t) == TEMPLATE_DECL)
6083 {
6084 ++processing_template_decl;
6085 push_deferring_access_checks (dk_no_check);
6086 }
6087
6088 r = tsubst_friend_function (t, args);
6089 add_friend (type, r, /*complain=*/false);
6090 if (TREE_CODE (t) == TEMPLATE_DECL)
6091 {
6092 pop_deferring_access_checks ();
6093 --processing_template_decl;
6094 }
6095 }
6096 }
6097 }
6098
6099 /* Set the file and line number information to whatever is given for
6100 the class itself. This puts error messages involving generated
6101 implicit functions at a predictable point, and the same point
6102 that would be used for non-template classes. */
6103 input_location = DECL_SOURCE_LOCATION (typedecl);
6104
6105 unreverse_member_declarations (type);
6106 finish_struct_1 (type);
6107 TYPE_BEING_DEFINED (type) = 0;
6108
6109 /* Now that the class is complete, instantiate default arguments for
6110 any member functions. We don't do this earlier because the
6111 default arguments may reference members of the class. */
6112 if (!PRIMARY_TEMPLATE_P (template))
6113 for (t = TYPE_METHODS (type); t; t = TREE_CHAIN (t))
6114 if (TREE_CODE (t) == FUNCTION_DECL
6115 /* Implicitly generated member functions will not have template
6116 information; they are not instantiations, but instead are
6117 created "fresh" for each instantiation. */
6118 && DECL_TEMPLATE_INFO (t))
6119 tsubst_default_arguments (t);
6120
6121 popclass ();
6122 pop_from_top_level ();
6123 pop_deferring_access_checks ();
6124 pop_tinst_level ();
6125
6126 /* The vtable for a template class can be emitted in any translation
6127 unit in which the class is instantiated. When there is no key
6128 method, however, finish_struct_1 will already have added TYPE to
6129 the keyed_classes list. */
6130 if (TYPE_CONTAINS_VPTR_P (type) && CLASSTYPE_KEY_METHOD (type))
6131 keyed_classes = tree_cons (NULL_TREE, type, keyed_classes);
6132
6133 return type;
6134}
6135
6136static tree
6137tsubst_template_arg (tree t, tree args, tsubst_flags_t complain, tree in_decl)
6138{
6139 tree r;
6140
6141 if (!t)
6142 r = t;
6143 else if (TYPE_P (t))
6144 r = tsubst (t, args, complain, in_decl);
6145 else
6146 {
6147 r = tsubst_expr (t, args, complain, in_decl,
6148 /*integral_constant_expression_p=*/true);
6149 r = fold_non_dependent_expr (r);
6150 }
6151 return r;
6152}
6153
6154/* Substitute ARGS into the vector or list of template arguments T. */
6155
6156static tree
6157tsubst_template_args (tree t, tree args, tsubst_flags_t complain, tree in_decl)
6158{
6159 int len = TREE_VEC_LENGTH (t);
6160 int need_new = 0, i;
6161 tree *elts = (tree *) alloca (len * sizeof (tree));
6162
6163 for (i = 0; i < len; i++)
6164 {
6165 tree orig_arg = TREE_VEC_ELT (t, i);
6166 tree new_arg;
6167
6168 if (TREE_CODE (orig_arg) == TREE_VEC)
6169 new_arg = tsubst_template_args (orig_arg, args, complain, in_decl);
6170 else
6171 new_arg = tsubst_template_arg (orig_arg, args, complain, in_decl);
6172
6173 if (new_arg == error_mark_node)
6174 return error_mark_node;
6175
6176 elts[i] = new_arg;
6177 if (new_arg != orig_arg)
6178 need_new = 1;
6179 }
6180
6181 if (!need_new)
6182 return t;
6183
6184 t = make_tree_vec (len);
6185 for (i = 0; i < len; i++)
6186 TREE_VEC_ELT (t, i) = elts[i];
6187
6188 return t;
6189}
6190
6191/* Return the result of substituting ARGS into the template parameters
6192 given by PARMS. If there are m levels of ARGS and m + n levels of
6193 PARMS, then the result will contain n levels of PARMS. For
6194 example, if PARMS is `template <class T> template <class U>
6195 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
6196 result will be `template <int*, double, class V>'. */
6197
6198static tree
6199tsubst_template_parms (tree parms, tree args, tsubst_flags_t complain)
6200{
6201 tree r = NULL_TREE;
6202 tree* new_parms;
6203
6204 /* When substituting into a template, we must set
6205 PROCESSING_TEMPLATE_DECL as the template parameters may be
6206 dependent if they are based on one-another, and the dependency
6207 predicates are short-circuit outside of templates. */
6208 ++processing_template_decl;
6209
6210 for (new_parms = &r;
6211 TMPL_PARMS_DEPTH (parms) > TMPL_ARGS_DEPTH (args);
6212 new_parms = &(TREE_CHAIN (*new_parms)),
6213 parms = TREE_CHAIN (parms))
6214 {
6215 tree new_vec =
6216 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms)));
6217 int i;
6218
6219 for (i = 0; i < TREE_VEC_LENGTH (new_vec); ++i)
6220 {
6221 tree tuple;
6222 tree default_value;
6223 tree parm_decl;
6224
6225 if (parms == error_mark_node)
6226 continue;
6227
6228 tuple = TREE_VEC_ELT (TREE_VALUE (parms), i);
6229
6230 if (tuple == error_mark_node)
6231 continue;
6232
6233 default_value = TREE_PURPOSE (tuple);
6234 parm_decl = TREE_VALUE (tuple);
6235
6236 parm_decl = tsubst (parm_decl, args, complain, NULL_TREE);
6237 if (TREE_CODE (parm_decl) == PARM_DECL
6238 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl), complain))
6239 parm_decl = error_mark_node;
6240 default_value = tsubst_template_arg (default_value, args,
6241 complain, NULL_TREE);
6242
6243 tuple = build_tree_list (default_value, parm_decl);
6244 TREE_VEC_ELT (new_vec, i) = tuple;
6245 }
6246
6247 *new_parms =
6248 tree_cons (size_int (TMPL_PARMS_DEPTH (parms)
6249 - TMPL_ARGS_DEPTH (args)),
6250 new_vec, NULL_TREE);
6251 }
6252
6253 --processing_template_decl;
6254
6255 return r;
6256}
6257
6258/* Substitute the ARGS into the indicated aggregate (or enumeration)
6259 type T. If T is not an aggregate or enumeration type, it is
6260 handled as if by tsubst. IN_DECL is as for tsubst. If
6261 ENTERING_SCOPE is nonzero, T is the context for a template which
6262 we are presently tsubst'ing. Return the substituted value. */
6263
6264static tree
6265tsubst_aggr_type (tree t,
6266 tree args,
6267 tsubst_flags_t complain,
6268 tree in_decl,
6269 int entering_scope)
6270{
6271 if (t == NULL_TREE)
6272 return NULL_TREE;
6273
6274 switch (TREE_CODE (t))
6275 {
6276 case RECORD_TYPE:
6277 if (TYPE_PTRMEMFUNC_P (t))
6278 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t), args, complain, in_decl);
6279
6280 /* Else fall through. */
6281 case ENUMERAL_TYPE:
6282 case UNION_TYPE:
6283 if (TYPE_TEMPLATE_INFO (t))
6284 {
6285 tree argvec;
6286 tree context;
6287 tree r;
6288 bool saved_skip_evaluation;
6289
6290 /* In "sizeof(X<I>)" we need to evaluate "I". */
6291 saved_skip_evaluation = skip_evaluation;
6292 skip_evaluation = false;
6293
6294 /* First, determine the context for the type we are looking
6295 up. */
6296 context = TYPE_CONTEXT (t);
6297 if (context)
6298 context = tsubst_aggr_type (context, args, complain,
6299 in_decl, /*entering_scope=*/1);
6300
6301 /* Then, figure out what arguments are appropriate for the
6302 type we are trying to find. For example, given:
6303
6304 template <class T> struct S;
6305 template <class T, class U> void f(T, U) { S<U> su; }
6306
6307 and supposing that we are instantiating f<int, double>,
6308 then our ARGS will be {int, double}, but, when looking up
6309 S we only want {double}. */
6310 argvec = tsubst_template_args (TYPE_TI_ARGS (t), args,
6311 complain, in_decl);
6312 if (argvec == error_mark_node)
6313 r = error_mark_node;
6314 else
6315 {
6316 r = lookup_template_class (t, argvec, in_decl, context,
6317 entering_scope, complain);
6318 r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
6319 }
6320
6321 skip_evaluation = saved_skip_evaluation;
6322
6323 return r;
6324 }
6325 else
6326 /* This is not a template type, so there's nothing to do. */
6327 return t;
6328
6329 default:
6330 return tsubst (t, args, complain, in_decl);
6331 }
6332}
6333
6334/* Substitute into the default argument ARG (a default argument for
6335 FN), which has the indicated TYPE. */
6336
6337tree
6338tsubst_default_argument (tree fn, tree type, tree arg)
6339{
6340 tree saved_class_ptr = NULL_TREE;
6341 tree saved_class_ref = NULL_TREE;
6342
6343 /* This default argument came from a template. Instantiate the
6344 default argument here, not in tsubst. In the case of
6345 something like:
6346
6347 template <class T>
6348 struct S {
6349 static T t();
6350 void f(T = t());
6351 };
6352
6353 we must be careful to do name lookup in the scope of S<T>,
6354 rather than in the current class. */
6355 push_access_scope (fn);
6356 /* The "this" pointer is not valid in a default argument. */
6357 if (cfun)
6358 {
6359 saved_class_ptr = current_class_ptr;
6360 cp_function_chain->x_current_class_ptr = NULL_TREE;
6361 saved_class_ref = current_class_ref;
6362 cp_function_chain->x_current_class_ref = NULL_TREE;
6363 }
6364
6365 push_deferring_access_checks(dk_no_deferred);
6366 /* The default argument expression may cause implicitly defined
6367 member functions to be synthesized, which will result in garbage
6368 collection. We must treat this situation as if we were within
6369 the body of function so as to avoid collecting live data on the
6370 stack. */
6371 ++function_depth;
6372 arg = tsubst_expr (arg, DECL_TI_ARGS (fn),
6373 tf_warning_or_error, NULL_TREE,
6374 /*integral_constant_expression_p=*/false);
6375 --function_depth;
6376 pop_deferring_access_checks();
6377
6378 /* Restore the "this" pointer. */
6379 if (cfun)
6380 {
6381 cp_function_chain->x_current_class_ptr = saved_class_ptr;
6382 cp_function_chain->x_current_class_ref = saved_class_ref;
6383 }
6384
6385 pop_access_scope (fn);
6386
6387 /* Make sure the default argument is reasonable. */
6388 arg = check_default_argument (type, arg);
6389
6390 return arg;
6391}
6392
6393/* Substitute into all the default arguments for FN. */
6394
6395static void
6396tsubst_default_arguments (tree fn)
6397{
6398 tree arg;
6399 tree tmpl_args;
6400
6401 tmpl_args = DECL_TI_ARGS (fn);
6402
6403 /* If this function is not yet instantiated, we certainly don't need
6404 its default arguments. */
6405 if (uses_template_parms (tmpl_args))
6406 return;
6407
6408 for (arg = TYPE_ARG_TYPES (TREE_TYPE (fn));
6409 arg;
6410 arg = TREE_CHAIN (arg))
6411 if (TREE_PURPOSE (arg))
6412 TREE_PURPOSE (arg) = tsubst_default_argument (fn,
6413 TREE_VALUE (arg),
6414 TREE_PURPOSE (arg));
6415}
6416
6417/* Substitute the ARGS into the T, which is a _DECL. Return the
6418 result of the substitution. Issue error and warning messages under
6419 control of COMPLAIN. */
6420
6421static tree
6422tsubst_decl (tree t, tree args, tsubst_flags_t complain)
6423{
6424 location_t saved_loc;
6425 tree r = NULL_TREE;
6426 tree in_decl = t;
6427
6428 /* Set the filename and linenumber to improve error-reporting. */
6429 saved_loc = input_location;
6430 input_location = DECL_SOURCE_LOCATION (t);
6431
6432 switch (TREE_CODE (t))
6433 {
6434 case TEMPLATE_DECL:
6435 {
6436 /* We can get here when processing a member function template,
6437 member class template, and template template parameter of
6438 a template class. */
6439 tree decl = DECL_TEMPLATE_RESULT (t);
6440 tree spec;
6441 tree tmpl_args;
6442 tree full_args;
6443
6444 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
6445 {
6446 /* Template template parameter is treated here. */
6447 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6448 if (new_type == error_mark_node)
6449 return error_mark_node;
6450
6451 r = copy_decl (t);
6452 TREE_CHAIN (r) = NULL_TREE;
6453 TREE_TYPE (r) = new_type;
6454 DECL_TEMPLATE_RESULT (r)
6455 = build_decl (TYPE_DECL, DECL_NAME (decl), new_type);
6456 DECL_TEMPLATE_PARMS (r)
6457 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
6458 complain);
6459 TYPE_NAME (new_type) = r;
6460 break;
6461 }
6462
6463 /* We might already have an instance of this template.
6464 The ARGS are for the surrounding class type, so the
6465 full args contain the tsubst'd args for the context,
6466 plus the innermost args from the template decl. */
6467 tmpl_args = DECL_CLASS_TEMPLATE_P (t)
6468 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t))
6469 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t));
6470 /* Because this is a template, the arguments will still be
6471 dependent, even after substitution. If
6472 PROCESSING_TEMPLATE_DECL is not set, the dependency
6473 predicates will short-circuit. */
6474 ++processing_template_decl;
6475 full_args = tsubst_template_args (tmpl_args, args,
6476 complain, in_decl);
6477 --processing_template_decl;
6478 if (full_args == error_mark_node)
6479 return error_mark_node;
6480
6481 /* tsubst_template_args doesn't copy the vector if
6482 nothing changed. But, *something* should have
6483 changed. */
6484 gcc_assert (full_args != tmpl_args);
6485
6486 spec = retrieve_specialization (t, full_args,
6487 /*class_specializations_p=*/true);
6488 if (spec != NULL_TREE)
6489 {
6490 r = spec;
6491 break;
6492 }
6493
6494 /* Make a new template decl. It will be similar to the
6495 original, but will record the current template arguments.
6496 We also create a new function declaration, which is just
6497 like the old one, but points to this new template, rather
6498 than the old one. */
6499 r = copy_decl (t);
6500 gcc_assert (DECL_LANG_SPECIFIC (r) != 0);
6501 TREE_CHAIN (r) = NULL_TREE;
6502
6503 DECL_TEMPLATE_INFO (r) = build_tree_list (t, args);
6504
6505 if (TREE_CODE (decl) == TYPE_DECL)
6506 {
6507 tree new_type;
6508 ++processing_template_decl;
6509 new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6510 --processing_template_decl;
6511 if (new_type == error_mark_node)
6512 return error_mark_node;
6513
6514 TREE_TYPE (r) = new_type;
6515 CLASSTYPE_TI_TEMPLATE (new_type) = r;
6516 DECL_TEMPLATE_RESULT (r) = TYPE_MAIN_DECL (new_type);
6517 DECL_TI_ARGS (r) = CLASSTYPE_TI_ARGS (new_type);
6518 DECL_CONTEXT (r) = TYPE_CONTEXT (new_type);
6519 }
6520 else
6521 {
6522 tree new_decl;
6523 ++processing_template_decl;
6524 new_decl = tsubst (decl, args, complain, in_decl);
6525 --processing_template_decl;
6526 if (new_decl == error_mark_node)
6527 return error_mark_node;
6528
6529 DECL_TEMPLATE_RESULT (r) = new_decl;
6530 DECL_TI_TEMPLATE (new_decl) = r;
6531 TREE_TYPE (r) = TREE_TYPE (new_decl);
6532 DECL_TI_ARGS (r) = DECL_TI_ARGS (new_decl);
6533 DECL_CONTEXT (r) = DECL_CONTEXT (new_decl);
6534 }
6535
6536 SET_DECL_IMPLICIT_INSTANTIATION (r);
6537 DECL_TEMPLATE_INSTANTIATIONS (r) = NULL_TREE;
6538 DECL_TEMPLATE_SPECIALIZATIONS (r) = NULL_TREE;
6539
6540 /* The template parameters for this new template are all the
6541 template parameters for the old template, except the
6542 outermost level of parameters. */
6543 DECL_TEMPLATE_PARMS (r)
6544 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
6545 complain);
6546
6547 if (PRIMARY_TEMPLATE_P (t))
6548 DECL_PRIMARY_TEMPLATE (r) = r;
6549
6550 if (TREE_CODE (decl) != TYPE_DECL)
6551 /* Record this non-type partial instantiation. */
6552 register_specialization (r, t,
6553 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r)),
6554 false);
6555 }
6556 break;
6557
6558 case FUNCTION_DECL:
6559 {
6560 tree ctx;
6561 tree argvec = NULL_TREE;
6562 tree *friends;
6563 tree gen_tmpl;
6564 tree type;
6565 int member;
6566 int args_depth;
6567 int parms_depth;
6568
6569 /* Nobody should be tsubst'ing into non-template functions. */
6570 gcc_assert (DECL_TEMPLATE_INFO (t) != NULL_TREE);
6571
6572 if (TREE_CODE (DECL_TI_TEMPLATE (t)) == TEMPLATE_DECL)
6573 {
6574 tree spec;
6575 bool dependent_p;
6576
6577 /* If T is not dependent, just return it. We have to
6578 increment PROCESSING_TEMPLATE_DECL because
6579 value_dependent_expression_p assumes that nothing is
6580 dependent when PROCESSING_TEMPLATE_DECL is zero. */
6581 ++processing_template_decl;
6582 dependent_p = value_dependent_expression_p (t);
6583 --processing_template_decl;
6584 if (!dependent_p)
6585 return t;
6586
6587 /* Calculate the most general template of which R is a
6588 specialization, and the complete set of arguments used to
6589 specialize R. */
6590 gen_tmpl = most_general_template (DECL_TI_TEMPLATE (t));
6591 argvec = tsubst_template_args (DECL_TI_ARGS
6592 (DECL_TEMPLATE_RESULT (gen_tmpl)),
6593 args, complain, in_decl);
6594
6595 /* Check to see if we already have this specialization. */
6596 spec = retrieve_specialization (gen_tmpl, argvec,
6597 /*class_specializations_p=*/false);
6598
6599 if (spec)
6600 {
6601 r = spec;
6602 break;
6603 }
6604
6605 /* We can see more levels of arguments than parameters if
6606 there was a specialization of a member template, like
6607 this:
6608
6609 template <class T> struct S { template <class U> void f(); }
6610 template <> template <class U> void S<int>::f(U);
6611
6612 Here, we'll be substituting into the specialization,
6613 because that's where we can find the code we actually
6614 want to generate, but we'll have enough arguments for
6615 the most general template.
6616
6617 We also deal with the peculiar case:
6618
6619 template <class T> struct S {
6620 template <class U> friend void f();
6621 };
6622 template <class U> void f() {}
6623 template S<int>;
6624 template void f<double>();
6625
6626 Here, the ARGS for the instantiation of will be {int,
6627 double}. But, we only need as many ARGS as there are
6628 levels of template parameters in CODE_PATTERN. We are
6629 careful not to get fooled into reducing the ARGS in
6630 situations like:
6631
6632 template <class T> struct S { template <class U> void f(U); }
6633 template <class T> template <> void S<T>::f(int) {}
6634
6635 which we can spot because the pattern will be a
6636 specialization in this case. */
6637 args_depth = TMPL_ARGS_DEPTH (args);
6638 parms_depth =
6639 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t)));
6640 if (args_depth > parms_depth
6641 && !DECL_TEMPLATE_SPECIALIZATION (t))
6642 args = get_innermost_template_args (args, parms_depth);
6643 }
6644 else
6645 {
6646 /* This special case arises when we have something like this:
6647
6648 template <class T> struct S {
6649 friend void f<int>(int, double);
6650 };
6651
6652 Here, the DECL_TI_TEMPLATE for the friend declaration
6653 will be an IDENTIFIER_NODE. We are being called from
6654 tsubst_friend_function, and we want only to create a
6655 new decl (R) with appropriate types so that we can call
6656 determine_specialization. */
6657 gen_tmpl = NULL_TREE;
6658 }
6659
6660 if (DECL_CLASS_SCOPE_P (t))
6661 {
6662 if (DECL_NAME (t) == constructor_name (DECL_CONTEXT (t)))
6663 member = 2;
6664 else
6665 member = 1;
6666 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args,
6667 complain, t, /*entering_scope=*/1);
6668 }
6669 else
6670 {
6671 member = 0;
6672 ctx = DECL_CONTEXT (t);
6673 }
6674 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6675 if (type == error_mark_node)
6676 return error_mark_node;
6677
6678 /* We do NOT check for matching decls pushed separately at this
6679 point, as they may not represent instantiations of this
6680 template, and in any case are considered separate under the
6681 discrete model. */
6682 r = copy_decl (t);
6683 DECL_USE_TEMPLATE (r) = 0;
6684 TREE_TYPE (r) = type;
6685 /* Clear out the mangled name and RTL for the instantiation. */
6686 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
6687 SET_DECL_RTL (r, NULL_RTX);
6688 DECL_INITIAL (r) = NULL_TREE;
6689 DECL_CONTEXT (r) = ctx;
6690
6691 if (member && DECL_CONV_FN_P (r))
6692 /* Type-conversion operator. Reconstruct the name, in
6693 case it's the name of one of the template's parameters. */
6694 DECL_NAME (r) = mangle_conv_op_name_for_type (TREE_TYPE (type));
6695
6696 DECL_ARGUMENTS (r) = tsubst (DECL_ARGUMENTS (t), args,
6697 complain, t);
6698 DECL_RESULT (r) = NULL_TREE;
6699
6700 TREE_STATIC (r) = 0;
6701 TREE_PUBLIC (r) = TREE_PUBLIC (t);
6702 DECL_EXTERNAL (r) = 1;
6703 /* If this is an instantiation of a function with internal
6704 linkage, we already know what object file linkage will be
6705 assigned to the instantiation. */
6706 DECL_INTERFACE_KNOWN (r) = !TREE_PUBLIC (r);
6707 DECL_DEFER_OUTPUT (r) = 0;
6708 TREE_CHAIN (r) = NULL_TREE;
6709 DECL_PENDING_INLINE_INFO (r) = 0;
6710 DECL_PENDING_INLINE_P (r) = 0;
6711 DECL_SAVED_TREE (r) = NULL_TREE;
6712 TREE_USED (r) = 0;
6713 if (DECL_CLONED_FUNCTION (r))
6714 {
6715 DECL_CLONED_FUNCTION (r) = tsubst (DECL_CLONED_FUNCTION (t),
6716 args, complain, t);
6717 TREE_CHAIN (r) = TREE_CHAIN (DECL_CLONED_FUNCTION (r));
6718 TREE_CHAIN (DECL_CLONED_FUNCTION (r)) = r;
6719 }
6720
6721 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
6722 this in the special friend case mentioned above where
6723 GEN_TMPL is NULL. */
6724 if (gen_tmpl)
6725 {
6726 DECL_TEMPLATE_INFO (r)
6727 = tree_cons (gen_tmpl, argvec, NULL_TREE);
6728 SET_DECL_IMPLICIT_INSTANTIATION (r);
6729 register_specialization (r, gen_tmpl, argvec, false);
6730
6731 /* We're not supposed to instantiate default arguments
6732 until they are called, for a template. But, for a
6733 declaration like:
6734
6735 template <class T> void f ()
6736 { extern void g(int i = T()); }
6737
6738 we should do the substitution when the template is
6739 instantiated. We handle the member function case in
6740 instantiate_class_template since the default arguments
6741 might refer to other members of the class. */
6742 if (!member
6743 && !PRIMARY_TEMPLATE_P (gen_tmpl)
6744 && !uses_template_parms (argvec))
6745 tsubst_default_arguments (r);
6746 }
6747 else
6748 DECL_TEMPLATE_INFO (r) = NULL_TREE;
6749
6750 /* Copy the list of befriending classes. */
6751 for (friends = &DECL_BEFRIENDING_CLASSES (r);
6752 *friends;
6753 friends = &TREE_CHAIN (*friends))
6754 {
6755 *friends = copy_node (*friends);
6756 TREE_VALUE (*friends) = tsubst (TREE_VALUE (*friends),
6757 args, complain,
6758 in_decl);
6759 }
6760
6761 if (DECL_CONSTRUCTOR_P (r) || DECL_DESTRUCTOR_P (r))
6762 {
6763 maybe_retrofit_in_chrg (r);
6764 if (DECL_CONSTRUCTOR_P (r))
6765 grok_ctor_properties (ctx, r);
6766 /* If this is an instantiation of a member template, clone it.
6767 If it isn't, that'll be handled by
6768 clone_constructors_and_destructors. */
6769 if (PRIMARY_TEMPLATE_P (gen_tmpl))
6770 clone_function_decl (r, /*update_method_vec_p=*/0);
6771 }
6772 else if (IDENTIFIER_OPNAME_P (DECL_NAME (r))
6773 && !grok_op_properties (r, (complain & tf_error) != 0))
6774 return error_mark_node;
6775
6776 if (DECL_FRIEND_P (t) && DECL_FRIEND_CONTEXT (t))
6777 SET_DECL_FRIEND_CONTEXT (r,
6778 tsubst (DECL_FRIEND_CONTEXT (t),
6779 args, complain, in_decl));
6780
6781 /* Possibly limit visibility based on template args. */
6782 DECL_VISIBILITY (r) = VISIBILITY_DEFAULT;
6783 if (DECL_VISIBILITY_SPECIFIED (t))
6784 {
6785 DECL_VISIBILITY_SPECIFIED (r) = 0;
6786 DECL_ATTRIBUTES (r)
6787 = remove_attribute ("visibility", DECL_ATTRIBUTES (r));
6788 }
6789 determine_visibility (r);
6790 }
6791 break;
6792
6793 case PARM_DECL:
6794 {
6795 tree type;
6796
6797 r = copy_node (t);
6798 if (DECL_TEMPLATE_PARM_P (t))
6799 SET_DECL_TEMPLATE_PARM_P (r);
6800
6801 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6802 type = type_decays_to (type);
6803 TREE_TYPE (r) = type;
6804 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
6805
6806 if (DECL_INITIAL (r))
6807 {
6808 if (TREE_CODE (DECL_INITIAL (r)) != TEMPLATE_PARM_INDEX)
6809 DECL_INITIAL (r) = TREE_TYPE (r);
6810 else
6811 DECL_INITIAL (r) = tsubst (DECL_INITIAL (r), args,
6812 complain, in_decl);
6813 }
6814
6815 DECL_CONTEXT (r) = NULL_TREE;
6816
6817 if (!DECL_TEMPLATE_PARM_P (r))
6818 DECL_ARG_TYPE (r) = type_passed_as (type);
6819 if (TREE_CHAIN (t))
6820 TREE_CHAIN (r) = tsubst (TREE_CHAIN (t), args,
6821 complain, TREE_CHAIN (t));
6822 }
6823 break;
6824
6825 case FIELD_DECL:
6826 {
6827 tree type;
6828
6829 r = copy_decl (t);
6830 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6831 if (type == error_mark_node)
6832 return error_mark_node;
6833 TREE_TYPE (r) = type;
6834 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
6835
6836 /* DECL_INITIAL gives the number of bits in a bit-field. */
6837 DECL_INITIAL (r)
6838 = tsubst_expr (DECL_INITIAL (t), args,
6839 complain, in_decl,
6840 /*integral_constant_expression_p=*/true);
6841 /* We don't have to set DECL_CONTEXT here; it is set by
6842 finish_member_declaration. */
6843 TREE_CHAIN (r) = NULL_TREE;
6844 if (VOID_TYPE_P (type))
6845 error ("instantiation of %q+D as type %qT", r, type);
6846 }
6847 break;
6848
6849 case USING_DECL:
6850 /* We reach here only for member using decls. */
6851 if (DECL_DEPENDENT_P (t))
6852 {
6853 r = do_class_using_decl
6854 (tsubst_copy (USING_DECL_SCOPE (t), args, complain, in_decl),
6855 tsubst_copy (DECL_NAME (t), args, complain, in_decl));
6856 if (!r)
6857 r = error_mark_node;
6858 }
6859 else
6860 {
6861 r = copy_node (t);
6862 TREE_CHAIN (r) = NULL_TREE;
6863 }
6864 break;
6865
6866 case TYPE_DECL:
6867 case VAR_DECL:
6868 {
6869 tree argvec = NULL_TREE;
6870 tree gen_tmpl = NULL_TREE;
6871 tree spec;
6872 tree tmpl = NULL_TREE;
6873 tree ctx;
6874 tree type = NULL_TREE;
6875 bool local_p;
6876
6877 if (TREE_CODE (t) == TYPE_DECL)
6878 {
6879 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6880 if (TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
6881 || t == TYPE_MAIN_DECL (TREE_TYPE (t)))
6882 {
6883 /* If this is the canonical decl, we don't have to
6884 mess with instantiations, and often we can't (for
6885 typename, template type parms and such). Note that
6886 TYPE_NAME is not correct for the above test if
6887 we've copied the type for a typedef. */
6888 r = TYPE_NAME (type);
6889 break;
6890 }
6891 }
6892
6893 /* Check to see if we already have the specialization we
6894 need. */
6895 spec = NULL_TREE;
6896 if (DECL_CLASS_SCOPE_P (t) || DECL_NAMESPACE_SCOPE_P (t))
6897 {
6898 /* T is a static data member or namespace-scope entity.
6899 We have to substitute into namespace-scope variables
6900 (even though such entities are never templates) because
6901 of cases like:
6902
6903 template <class T> void f() { extern T t; }
6904
6905 where the entity referenced is not known until
6906 instantiation time. */
6907 local_p = false;
6908 ctx = DECL_CONTEXT (t);
6909 if (DECL_CLASS_SCOPE_P (t))
6910 {
6911 ctx = tsubst_aggr_type (ctx, args,
6912 complain,
6913 in_decl, /*entering_scope=*/1);
6914 /* If CTX is unchanged, then T is in fact the
6915 specialization we want. That situation occurs when
6916 referencing a static data member within in its own
6917 class. We can use pointer equality, rather than
6918 same_type_p, because DECL_CONTEXT is always
6919 canonical. */
6920 if (ctx == DECL_CONTEXT (t))
6921 spec = t;
6922 }
6923
6924 if (!spec)
6925 {
6926 tmpl = DECL_TI_TEMPLATE (t);
6927 gen_tmpl = most_general_template (tmpl);
6928 argvec = tsubst (DECL_TI_ARGS (t), args, complain, in_decl);
6929 spec = (retrieve_specialization
6930 (gen_tmpl, argvec,
6931 /*class_specializations_p=*/false));
6932 }
6933 }
6934 else
6935 {
6936 /* A local variable. */
6937 local_p = true;
6938 /* Subsequent calls to pushdecl will fill this in. */
6939 ctx = NULL_TREE;
6940 spec = retrieve_local_specialization (t);
6941 }
6942 /* If we already have the specialization we need, there is
6943 nothing more to do. */
6944 if (spec)
6945 {
6946 r = spec;
6947 break;
6948 }
6949
6950 /* Create a new node for the specialization we need. */
6951 r = copy_decl (t);
6952 if (TREE_CODE (r) == VAR_DECL)
6953 {
6954 /* Even if the original location is out of scope, the
6955 newly substituted one is not. */
6956 DECL_DEAD_FOR_LOCAL (r) = 0;
6957 DECL_INITIALIZED_P (r) = 0;
6958 DECL_TEMPLATE_INSTANTIATED (r) = 0;
6959 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6960 if (type == error_mark_node)
6961 return error_mark_node;
6962 if (TREE_CODE (type) == FUNCTION_TYPE)
6963 {
6964 /* It may seem that this case cannot occur, since:
6965
6966 typedef void f();
6967 void g() { f x; }
6968
6969 declares a function, not a variable. However:
6970
6971 typedef void f();
6972 template <typename T> void g() { T t; }
6973 template void g<f>();
6974
6975 is an attempt to declare a variable with function
6976 type. */
6977 error ("variable %qD has function type",
6978 /* R is not yet sufficiently initialized, so we
6979 just use its name. */
6980 DECL_NAME (r));
6981 return error_mark_node;
6982 }
6983 type = complete_type (type);
6984 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r)
6985 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t);
6986 type = check_var_type (DECL_NAME (r), type);
6987
6988 if (DECL_HAS_VALUE_EXPR_P (t))
6989 {
6990 tree ve = DECL_VALUE_EXPR (t);
6991 ve = tsubst_expr (ve, args, complain, in_decl,
6992 /*constant_expression_p=*/false);
6993 SET_DECL_VALUE_EXPR (r, ve);
6994 }
6995 }
6996 else if (DECL_SELF_REFERENCE_P (t))
6997 SET_DECL_SELF_REFERENCE_P (r);
6998 TREE_TYPE (r) = type;
6999 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
7000 DECL_CONTEXT (r) = ctx;
7001 /* Clear out the mangled name and RTL for the instantiation. */
7002 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
7003 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
7004 SET_DECL_RTL (r, NULL_RTX);
7005 /* The initializer must not be expanded until it is required;
7006 see [temp.inst]. */
7007 DECL_INITIAL (r) = NULL_TREE;
7008 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
7009 SET_DECL_RTL (r, NULL_RTX);
7010 DECL_SIZE (r) = DECL_SIZE_UNIT (r) = 0;
7011 if (TREE_CODE (r) == VAR_DECL)
7012 {
7013 /* Possibly limit visibility based on template args. */
7014 DECL_VISIBILITY (r) = VISIBILITY_DEFAULT;
7015 if (DECL_VISIBILITY_SPECIFIED (t))
7016 {
7017 DECL_VISIBILITY_SPECIFIED (r) = 0;
7018 DECL_ATTRIBUTES (r)
7019 = remove_attribute ("visibility", DECL_ATTRIBUTES (r));
7020 }
7021 determine_visibility (r);
7022 }
7023
7024 if (!local_p)
7025 {
7026 /* A static data member declaration is always marked
7027 external when it is declared in-class, even if an
7028 initializer is present. We mimic the non-template
7029 processing here. */
7030 DECL_EXTERNAL (r) = 1;
7031
7032 register_specialization (r, gen_tmpl, argvec, false);
7033 DECL_TEMPLATE_INFO (r) = tree_cons (tmpl, argvec, NULL_TREE);
7034 SET_DECL_IMPLICIT_INSTANTIATION (r);
7035 }
7036 else
7037 register_local_specialization (r, t);
7038
7039 TREE_CHAIN (r) = NULL_TREE;
7040 layout_decl (r, 0);
7041 }
7042 break;
7043
7044 default:
7045 gcc_unreachable ();
7046 }
7047
7048 /* Restore the file and line information. */
7049 input_location = saved_loc;
7050
7051 return r;
7052}
7053
7054/* Substitute into the ARG_TYPES of a function type. */
7055
7056static tree
7057tsubst_arg_types (tree arg_types,
7058 tree args,
7059 tsubst_flags_t complain,
7060 tree in_decl)
7061{
7062 tree remaining_arg_types;
7063 tree type;
7064 tree default_arg;
7065 tree result = NULL_TREE;
7066
7067 if (!arg_types || arg_types == void_list_node)
7068 return arg_types;
7069
7070 remaining_arg_types = tsubst_arg_types (TREE_CHAIN (arg_types),
7071 args, complain, in_decl);
7072 if (remaining_arg_types == error_mark_node)
7073 return error_mark_node;
7074
7075 type = tsubst (TREE_VALUE (arg_types), args, complain, in_decl);
7076 if (type == error_mark_node)
7077 return error_mark_node;
7078 if (VOID_TYPE_P (type))
7079 {
7080 if (complain & tf_error)
7081 {
7082 error ("invalid parameter type %qT", type);
7083 if (in_decl)
7084 error ("in declaration %q+D", in_decl);
7085 }
7086 return error_mark_node;
7087 }
7088
7089 /* Do array-to-pointer, function-to-pointer conversion, and ignore
7090 top-level qualifiers as required. */
7091 type = TYPE_MAIN_VARIANT (type_decays_to (type));
7092
7093 /* We do not substitute into default arguments here. The standard
7094 mandates that they be instantiated only when needed, which is
7095 done in build_over_call. */
7096 default_arg = TREE_PURPOSE (arg_types);
7097
7098 if (default_arg && TREE_CODE (default_arg) == DEFAULT_ARG)
7099 {
7100 /* We've instantiated a template before its default arguments
7101 have been parsed. This can happen for a nested template
7102 class, and is not an error unless we require the default
7103 argument in a call of this function. */
7104 result = tree_cons (default_arg, type, remaining_arg_types);
7105 VEC_safe_push (tree, gc, DEFARG_INSTANTIATIONS (default_arg), result);
7106 }
7107 else
7108 result = hash_tree_cons (default_arg, type, remaining_arg_types);
7109
7110 return result;
7111}
7112
7113/* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
7114 *not* handle the exception-specification for FNTYPE, because the
7115 initial substitution of explicitly provided template parameters
7116 during argument deduction forbids substitution into the
7117 exception-specification:
7118
7119 [temp.deduct]
7120
7121 All references in the function type of the function template to the
7122 corresponding template parameters are replaced by the specified tem-
7123 plate argument values. If a substitution in a template parameter or
7124 in the function type of the function template results in an invalid
7125 type, type deduction fails. [Note: The equivalent substitution in
7126 exception specifications is done only when the function is instanti-
7127 ated, at which point a program is ill-formed if the substitution
7128 results in an invalid type.] */
7129
7130static tree
7131tsubst_function_type (tree t,
7132 tree args,
7133 tsubst_flags_t complain,
7134 tree in_decl)
7135{
7136 tree return_type;
7137 tree arg_types;
7138 tree fntype;
7139
7140 /* The TYPE_CONTEXT is not used for function/method types. */
7141 gcc_assert (TYPE_CONTEXT (t) == NULL_TREE);
7142
7143 /* Substitute the return type. */
7144 return_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
7145 if (return_type == error_mark_node)
7146 return error_mark_node;
7147 /* The standard does not presently indicate that creation of a
7148 function type with an invalid return type is a deduction failure.
7149 However, that is clearly analogous to creating an array of "void"
7150 or a reference to a reference. This is core issue #486. */
7151 if (TREE_CODE (return_type) == ARRAY_TYPE
7152 || TREE_CODE (return_type) == FUNCTION_TYPE)
7153 {
7154 if (complain & tf_error)
7155 {
7156 if (TREE_CODE (return_type) == ARRAY_TYPE)
7157 error ("function returning an array");
7158 else
7159 error ("function returning a function");
7160 }
7161 return error_mark_node;
7162 }
7163
7164 /* Substitute the argument types. */
7165 arg_types = tsubst_arg_types (TYPE_ARG_TYPES (t), args,
7166 complain, in_decl);
7167 if (arg_types == error_mark_node)
7168 return error_mark_node;
7169
7170 /* Construct a new type node and return it. */
7171 if (TREE_CODE (t) == FUNCTION_TYPE)
7172 fntype = build_function_type (return_type, arg_types);
7173 else
7174 {
7175 tree r = TREE_TYPE (TREE_VALUE (arg_types));
7176 if (! IS_AGGR_TYPE (r))
7177 {
7178 /* [temp.deduct]
7179
7180 Type deduction may fail for any of the following
7181 reasons:
7182
7183 -- Attempting to create "pointer to member of T" when T
7184 is not a class type. */
7185 if (complain & tf_error)
7186 error ("creating pointer to member function of non-class type %qT",
7187 r);
7188 return error_mark_node;
7189 }
7190
7191 fntype = build_method_type_directly (r, return_type,
7192 TREE_CHAIN (arg_types));
7193 }
7194 fntype = cp_build_qualified_type_real (fntype, TYPE_QUALS (t), complain);
7195 fntype = cp_build_type_attribute_variant (fntype, TYPE_ATTRIBUTES (t));
7196
7197 return fntype;
7198}
7199
7200/* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
7201 ARGS into that specification, and return the substituted
7202 specification. If there is no specification, return NULL_TREE. */
7203
7204static tree
7205tsubst_exception_specification (tree fntype,
7206 tree args,
7207 tsubst_flags_t complain,
7208 tree in_decl)
7209{
7210 tree specs;
7211 tree new_specs;
7212
7213 specs = TYPE_RAISES_EXCEPTIONS (fntype);
7214 new_specs = NULL_TREE;
7215 if (specs)
7216 {
7217 if (! TREE_VALUE (specs))
7218 new_specs = specs;
7219 else
7220 while (specs)
7221 {
7222 tree spec;
7223 spec = tsubst (TREE_VALUE (specs), args, complain, in_decl);
7224 if (spec == error_mark_node)
7225 return spec;
7226 new_specs = add_exception_specifier (new_specs, spec, complain);
7227 specs = TREE_CHAIN (specs);
7228 }
7229 }
7230 return new_specs;
7231}
7232
7233/* Take the tree structure T and replace template parameters used
7234 therein with the argument vector ARGS. IN_DECL is an associated
7235 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
7236 Issue error and warning messages under control of COMPLAIN. Note
7237 that we must be relatively non-tolerant of extensions here, in
7238 order to preserve conformance; if we allow substitutions that
7239 should not be allowed, we may allow argument deductions that should
7240 not succeed, and therefore report ambiguous overload situations
7241 where there are none. In theory, we could allow the substitution,
7242 but indicate that it should have failed, and allow our caller to
7243 make sure that the right thing happens, but we don't try to do this
7244 yet.
7245
7246 This function is used for dealing with types, decls and the like;
7247 for expressions, use tsubst_expr or tsubst_copy. */
7248
7249static tree
7250tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
7251{
7252 tree type, r;
7253
7254 if (t == NULL_TREE || t == error_mark_node
7255 || t == integer_type_node
7256 || t == void_type_node
7257 || t == char_type_node
7258 || t == unknown_type_node
7259 || TREE_CODE (t) == NAMESPACE_DECL)
7260 return t;
7261
7262 if (DECL_P (t))
7263 return tsubst_decl (t, args, complain);
7264
7265 if (TREE_CODE (t) == IDENTIFIER_NODE)
7266 type = IDENTIFIER_TYPE_VALUE (t);
7267 else
7268 type = TREE_TYPE (t);
7269
7270 gcc_assert (type != unknown_type_node);
7271
7272 if (type
7273 && TREE_CODE (t) != TYPENAME_TYPE
7274 && TREE_CODE (t) != IDENTIFIER_NODE
7275 && TREE_CODE (t) != FUNCTION_TYPE
7276 && TREE_CODE (t) != METHOD_TYPE)
7277 type = tsubst (type, args, complain, in_decl);
7278 if (type == error_mark_node)
7279 return error_mark_node;
7280
7281 switch (TREE_CODE (t))
7282 {
7283 case RECORD_TYPE:
7284 case UNION_TYPE:
7285 case ENUMERAL_TYPE:
7286 return tsubst_aggr_type (t, args, complain, in_decl,
7287 /*entering_scope=*/0);
7288
7289 case ERROR_MARK:
7290 case IDENTIFIER_NODE:
7291 case VOID_TYPE:
7292 case REAL_TYPE:
7293 case COMPLEX_TYPE:
7294 case VECTOR_TYPE:
7295 case BOOLEAN_TYPE:
7296 case INTEGER_CST:
7297 case REAL_CST:
7298 case STRING_CST:
7299 return t;
7300
7301 case INTEGER_TYPE:
7302 if (t == integer_type_node)
7303 return t;
7304
7305 if (TREE_CODE (TYPE_MIN_VALUE (t)) == INTEGER_CST
7306 && TREE_CODE (TYPE_MAX_VALUE (t)) == INTEGER_CST)
7307 return t;
7308
7309 {
7310 tree max, omax = TREE_OPERAND (TYPE_MAX_VALUE (t), 0);
7311
7312 max = tsubst_expr (omax, args, complain, in_decl,
7313 /*integral_constant_expression_p=*/false);
7314 max = fold_decl_constant_value (max);
7315
7316 if (TREE_CODE (max) != INTEGER_CST
7317 && TREE_CODE (max) != TEMPLATE_PARM_INDEX
7318 && !at_function_scope_p ())
7319 {
7320 if (complain & tf_error)
7321 error ("array bound is not an integer constant");
7322 return error_mark_node;
7323 }
7324
7325 /* [temp.deduct]
7326
7327 Type deduction may fail for any of the following
7328 reasons:
7329
7330 Attempting to create an array with a size that is
7331 zero or negative. */
7332 if (integer_zerop (max) && !(complain & tf_error))
7333 /* We must fail if performing argument deduction (as
7334 indicated by the state of complain), so that
7335 another substitution can be found. */
7336 return error_mark_node;
7337 else if (TREE_CODE (max) == INTEGER_CST
7338 && INT_CST_LT (max, integer_zero_node))
7339 {
7340 if (complain & tf_error)
7341 error ("creating array with negative size (%qE)", max);
7342
7343 return error_mark_node;
7344 }
7345
7346 return compute_array_index_type (NULL_TREE, max);
7347 }
7348
7349 case TEMPLATE_TYPE_PARM:
7350 case TEMPLATE_TEMPLATE_PARM:
7351 case BOUND_TEMPLATE_TEMPLATE_PARM:
7352 case TEMPLATE_PARM_INDEX:
7353 {
7354 int idx;
7355 int level;
7356 int levels;
7357 tree arg = NULL_TREE;
7358
7359 r = NULL_TREE;
7360
7361 gcc_assert (TREE_VEC_LENGTH (args) > 0);
7362 if (TREE_CODE (t) == TEMPLATE_TYPE_PARM
7363 || TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM
7364 || TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
7365 {
7366 idx = TEMPLATE_TYPE_IDX (t);
7367 level = TEMPLATE_TYPE_LEVEL (t);
7368 }
7369 else
7370 {
7371 idx = TEMPLATE_PARM_IDX (t);
7372 level = TEMPLATE_PARM_LEVEL (t);
7373 }
7374
7375 levels = TMPL_ARGS_DEPTH (args);
7376 if (level <= levels)
7377 arg = TMPL_ARG (args, level, idx);
7378
7379 if (arg == error_mark_node)
7380 return error_mark_node;
7381 else if (arg != NULL_TREE)
7382 {
7383 if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
7384 {
7385 int quals;
7386 gcc_assert (TYPE_P (arg));
7387
7388 /* cv-quals from the template are discarded when
7389 substituting in a function or reference type. */
7390 if (TREE_CODE (arg) == FUNCTION_TYPE
7391 || TREE_CODE (arg) == METHOD_TYPE
7392 || TREE_CODE (arg) == REFERENCE_TYPE)
7393 quals = cp_type_quals (arg);
7394 else
7395 quals = cp_type_quals (arg) | cp_type_quals (t);
7396
7397 return cp_build_qualified_type_real
7398 (arg, quals, complain | tf_ignore_bad_quals);
7399 }
7400 else if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
7401 {
7402 /* We are processing a type constructed from a
7403 template template parameter. */
7404 tree argvec = tsubst (TYPE_TI_ARGS (t),
7405 args, complain, in_decl);
7406 if (argvec == error_mark_node)
7407 return error_mark_node;
7408
7409 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
7410 are resolving nested-types in the signature of a
7411 member function templates. Otherwise ARG is a
7412 TEMPLATE_DECL and is the real template to be
7413 instantiated. */
7414 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
7415 arg = TYPE_NAME (arg);
7416
7417 r = lookup_template_class (arg,
7418 argvec, in_decl,
7419 DECL_CONTEXT (arg),
7420 /*entering_scope=*/0,
7421 complain);
7422 return cp_build_qualified_type_real
7423 (r, TYPE_QUALS (t), complain);
7424 }
7425 else
7426 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
7427 return arg;
7428 }
7429
7430 if (level == 1)
7431 /* This can happen during the attempted tsubst'ing in
7432 unify. This means that we don't yet have any information
7433 about the template parameter in question. */
7434 return t;
7435
7436 /* If we get here, we must have been looking at a parm for a
7437 more deeply nested template. Make a new version of this
7438 template parameter, but with a lower level. */
7439 switch (TREE_CODE (t))
7440 {
7441 case TEMPLATE_TYPE_PARM:
7442 case TEMPLATE_TEMPLATE_PARM:
7443 case BOUND_TEMPLATE_TEMPLATE_PARM:
7444 if (cp_type_quals (t))
7445 {
7446 r = tsubst (TYPE_MAIN_VARIANT (t), args, complain, in_decl);
7447 r = cp_build_qualified_type_real
7448 (r, cp_type_quals (t),
7449 complain | (TREE_CODE (t) == TEMPLATE_TYPE_PARM
7450 ? tf_ignore_bad_quals : 0));
7451 }
7452 else
7453 {
7454 r = copy_type (t);
7455 TEMPLATE_TYPE_PARM_INDEX (r)
7456 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t),
7457 r, levels);
7458 TYPE_STUB_DECL (r) = TYPE_NAME (r) = TEMPLATE_TYPE_DECL (r);
7459 TYPE_MAIN_VARIANT (r) = r;
7460 TYPE_POINTER_TO (r) = NULL_TREE;
7461 TYPE_REFERENCE_TO (r) = NULL_TREE;
7462
7463 if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
7464 {
7465 tree argvec = tsubst (TYPE_TI_ARGS (t), args,
7466 complain, in_decl);
7467 if (argvec == error_mark_node)
7468 return error_mark_node;
7469
7470 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r)
7471 = tree_cons (TYPE_TI_TEMPLATE (t), argvec, NULL_TREE);
7472 }
7473 }
7474 break;
7475
7476 case TEMPLATE_PARM_INDEX:
7477 r = reduce_template_parm_level (t, type, levels);
7478 break;
7479
7480 default:
7481 gcc_unreachable ();
7482 }
7483
7484 return r;
7485 }
7486
7487 case TREE_LIST:
7488 {
7489 tree purpose, value, chain;
7490
7491 if (t == void_list_node)
7492 return t;
7493
7494 purpose = TREE_PURPOSE (t);
7495 if (purpose)
7496 {
7497 purpose = tsubst (purpose, args, complain, in_decl);
7498 if (purpose == error_mark_node)
7499 return error_mark_node;
7500 }
7501 value = TREE_VALUE (t);
7502 if (value)
7503 {
7504 value = tsubst (value, args, complain, in_decl);
7505 if (value == error_mark_node)
7506 return error_mark_node;
7507 }
7508 chain = TREE_CHAIN (t);
7509 if (chain && chain != void_type_node)
7510 {
7511 chain = tsubst (chain, args, complain, in_decl);
7512 if (chain == error_mark_node)
7513 return error_mark_node;
7514 }
7515 if (purpose == TREE_PURPOSE (t)
7516 && value == TREE_VALUE (t)
7517 && chain == TREE_CHAIN (t))
7518 return t;
7519 return hash_tree_cons (purpose, value, chain);
7520 }
7521
7522 case TREE_BINFO:
7523 /* We should never be tsubsting a binfo. */
7524 gcc_unreachable ();
7525
7526 case TREE_VEC:
7527 /* A vector of template arguments. */
7528 gcc_assert (!type);
7529 return tsubst_template_args (t, args, complain, in_decl);
7530
7531 case POINTER_TYPE:
7532 case REFERENCE_TYPE:
7533 {
7534 enum tree_code code;
7535
7536 if (type == TREE_TYPE (t) && TREE_CODE (type) != METHOD_TYPE)
7537 return t;
7538
7539 code = TREE_CODE (t);
7540
7541
7542 /* [temp.deduct]
7543
7544 Type deduction may fail for any of the following
7545 reasons:
7546
7547 -- Attempting to create a pointer to reference type.
7548 -- Attempting to create a reference to a reference type or
7549 a reference to void. */
7550 if (TREE_CODE (type) == REFERENCE_TYPE
7551 || (code == REFERENCE_TYPE && TREE_CODE (type) == VOID_TYPE))
7552 {
7553 static location_t last_loc;
7554
7555 /* We keep track of the last time we issued this error
7556 message to avoid spewing a ton of messages during a
7557 single bad template instantiation. */
7558 if (complain & tf_error
7559#ifdef USE_MAPPED_LOCATION
7560 && last_loc != input_location
7561#else
7562 && (last_loc.line != input_line
7563 || last_loc.file != input_filename)
7564#endif
7565 )
7566 {
7567 if (TREE_CODE (type) == VOID_TYPE)
7568 error ("forming reference to void");
7569 else
7570 error ("forming %s to reference type %qT",
7571 (code == POINTER_TYPE) ? "pointer" : "reference",
7572 type);
7573 last_loc = input_location;
7574 }
7575
7576 return error_mark_node;
7577 }
7578 else if (code == POINTER_TYPE)
7579 {
7580 r = build_pointer_type (type);
7581 if (TREE_CODE (type) == METHOD_TYPE)
7582 r = build_ptrmemfunc_type (r);
7583 }
7584 else
7585 r = build_reference_type (type);
7586 r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
7587
7588 if (r != error_mark_node)
7589 /* Will this ever be needed for TYPE_..._TO values? */
7590 layout_type (r);
7591
7592 return r;
7593 }
7594 case OFFSET_TYPE:
7595 {
7596 r = tsubst (TYPE_OFFSET_BASETYPE (t), args, complain, in_decl);
7597 if (r == error_mark_node || !IS_AGGR_TYPE (r))
7598 {
7599 /* [temp.deduct]
7600
7601 Type deduction may fail for any of the following
7602 reasons:
7603
7604 -- Attempting to create "pointer to member of T" when T
7605 is not a class type. */
7606 if (complain & tf_error)
7607 error ("creating pointer to member of non-class type %qT", r);
7608 return error_mark_node;
7609 }
7610 if (TREE_CODE (type) == REFERENCE_TYPE)
7611 {
7612 if (complain & tf_error)
7613 error ("creating pointer to member reference type %qT", type);
7614 return error_mark_node;
7615 }
7616 if (TREE_CODE (type) == VOID_TYPE)
7617 {
7618 if (complain & tf_error)
7619 error ("creating pointer to member of type void");
7620 return error_mark_node;
7621 }
7622 gcc_assert (TREE_CODE (type) != METHOD_TYPE);
7623 if (TREE_CODE (type) == FUNCTION_TYPE)
7624 {
7625 /* The type of the implicit object parameter gets its
7626 cv-qualifiers from the FUNCTION_TYPE. */
7627 tree method_type;
7628 tree this_type = cp_build_qualified_type (TYPE_MAIN_VARIANT (r),
7629 cp_type_quals (type));
7630 tree memptr;
7631 method_type = build_method_type_directly (this_type,
7632 TREE_TYPE (type),
7633 TYPE_ARG_TYPES (type));
7634 memptr = build_ptrmemfunc_type (build_pointer_type (method_type));
7635 return cp_build_qualified_type_real (memptr, cp_type_quals (t),
7636 complain);
7637 }
7638 else
7639 return cp_build_qualified_type_real (build_ptrmem_type (r, type),
7640 TYPE_QUALS (t),
7641 complain);
7642 }
7643 case FUNCTION_TYPE:
7644 case METHOD_TYPE:
7645 {
7646 tree fntype;
7647 tree specs;
7648 fntype = tsubst_function_type (t, args, complain, in_decl);
7649 if (fntype == error_mark_node)
7650 return error_mark_node;
7651
7652 /* Substitute the exception specification. */
7653 specs = tsubst_exception_specification (t, args, complain,
7654 in_decl);
7655 if (specs == error_mark_node)
7656 return error_mark_node;
7657 if (specs)
7658 fntype = build_exception_variant (fntype, specs);
7659 return fntype;
7660 }
7661 case ARRAY_TYPE:
7662 {
7663 tree domain = tsubst (TYPE_DOMAIN (t), args, complain, in_decl);
7664 if (domain == error_mark_node)
7665 return error_mark_node;
7666
7667 /* As an optimization, we avoid regenerating the array type if
7668 it will obviously be the same as T. */
7669 if (type == TREE_TYPE (t) && domain == TYPE_DOMAIN (t))
7670 return t;
7671
7672 /* These checks should match the ones in grokdeclarator.
7673
7674 [temp.deduct]
7675
7676 The deduction may fail for any of the following reasons:
7677
7678 -- Attempting to create an array with an element type that
7679 is void, a function type, or a reference type, or [DR337]
7680 an abstract class type. */
7681 if (TREE_CODE (type) == VOID_TYPE
7682 || TREE_CODE (type) == FUNCTION_TYPE
7683 || TREE_CODE (type) == REFERENCE_TYPE)
7684 {
7685 if (complain & tf_error)
7686 error ("creating array of %qT", type);
7687 return error_mark_node;
7688 }
7689 if (CLASS_TYPE_P (type) && CLASSTYPE_PURE_VIRTUALS (type))
7690 {
7691 if (complain & tf_error)
7692 error ("creating array of %qT, which is an abstract class type",
7693 type);
7694 return error_mark_node;
7695 }
7696
7697 r = build_cplus_array_type (type, domain);
7698 return r;
7699 }
7700
7701 case PLUS_EXPR:
7702 case MINUS_EXPR:
7703 {
7704 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7705 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
7706
7707 if (e1 == error_mark_node || e2 == error_mark_node)
7708 return error_mark_node;
7709
7710 return fold_build2 (TREE_CODE (t), TREE_TYPE (t), e1, e2);
7711 }
7712
7713 case NEGATE_EXPR:
7714 case NOP_EXPR:
7715 {
7716 tree e = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7717 if (e == error_mark_node)
7718 return error_mark_node;
7719
7720 return fold_build1 (TREE_CODE (t), TREE_TYPE (t), e);
7721 }
7722
7723 case TYPENAME_TYPE:
7724 {
7725 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
7726 in_decl, /*entering_scope=*/1);
7727 tree f = tsubst_copy (TYPENAME_TYPE_FULLNAME (t), args,
7728 complain, in_decl);
7729
7730 if (ctx == error_mark_node || f == error_mark_node)
7731 return error_mark_node;
7732
7733 if (!IS_AGGR_TYPE (ctx))
7734 {
7735 if (complain & tf_error)
7736 error ("%qT is not a class, struct, or union type", ctx);
7737 return error_mark_node;
7738 }
7739 else if (!uses_template_parms (ctx) && !TYPE_BEING_DEFINED (ctx))
7740 {
7741 /* Normally, make_typename_type does not require that the CTX
7742 have complete type in order to allow things like:
7743
7744 template <class T> struct S { typename S<T>::X Y; };
7745
7746 But, such constructs have already been resolved by this
7747 point, so here CTX really should have complete type, unless
7748 it's a partial instantiation. */
7749 ctx = complete_type (ctx);
7750 if (!COMPLETE_TYPE_P (ctx))
7751 {
7752 if (complain & tf_error)
7753 cxx_incomplete_type_error (NULL_TREE, ctx);
7754 return error_mark_node;
7755 }
7756 }
7757
7758 f = make_typename_type (ctx, f, typename_type,
7759 (complain & tf_error) | tf_keep_type_decl);
7760 if (f == error_mark_node)
7761 return f;
7762 if (TREE_CODE (f) == TYPE_DECL)
7763 {
7764 complain |= tf_ignore_bad_quals;
7765 f = TREE_TYPE (f);
7766 }
7767
7768 if (TREE_CODE (f) != TYPENAME_TYPE)
7769 {
7770 if (TYPENAME_IS_ENUM_P (t) && TREE_CODE (f) != ENUMERAL_TYPE)
7771 error ("%qT resolves to %qT, which is not an enumeration type",
7772 t, f);
7773 else if (TYPENAME_IS_CLASS_P (t) && !CLASS_TYPE_P (f))
7774 error ("%qT resolves to %qT, which is is not a class type",
7775 t, f);
7776 }
7777
7778 return cp_build_qualified_type_real
7779 (f, cp_type_quals (f) | cp_type_quals (t), complain);
7780 }
7781
7782 case UNBOUND_CLASS_TEMPLATE:
7783 {
7784 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
7785 in_decl, /*entering_scope=*/1);
7786 tree name = TYPE_IDENTIFIER (t);
7787 tree parm_list = DECL_TEMPLATE_PARMS (TYPE_NAME (t));
7788
7789 if (ctx == error_mark_node || name == error_mark_node)
7790 return error_mark_node;
7791
7792 if (parm_list)
7793 parm_list = tsubst_template_parms (parm_list, args, complain);
7794 return make_unbound_class_template (ctx, name, parm_list, complain);
7795 }
7796
7797 case INDIRECT_REF:
7798 case ADDR_EXPR:
7799 case CALL_EXPR:
7800 gcc_unreachable ();
7801
7802 case ARRAY_REF:
7803 {
7804 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7805 tree e2 = tsubst_expr (TREE_OPERAND (t, 1), args, complain, in_decl,
7806 /*integral_constant_expression_p=*/false);
7807 if (e1 == error_mark_node || e2 == error_mark_node)
7808 return error_mark_node;
7809
7810 return build_nt (ARRAY_REF, e1, e2, NULL_TREE, NULL_TREE);
7811 }
7812
7813 case SCOPE_REF:
7814 {
7815 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7816 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
7817 if (e1 == error_mark_node || e2 == error_mark_node)
7818 return error_mark_node;
7819
7820 return build_qualified_name (/*type=*/NULL_TREE,
7821 e1, e2, QUALIFIED_NAME_IS_TEMPLATE (t));
7822 }
7823
7824 case TYPEOF_TYPE:
7825 {
7826 tree type;
7827
7828 type = finish_typeof (tsubst_expr
7829 (TYPEOF_TYPE_EXPR (t), args,
7830 complain, in_decl,
7831 /*integral_constant_expression_p=*/false));
7832 return cp_build_qualified_type_real (type,
7833 cp_type_quals (t)
7834 | cp_type_quals (type),
7835 complain);
7836 }
7837
7838 default:
7839 sorry ("use of %qs in template",
7840 tree_code_name [(int) TREE_CODE (t)]);
7841 return error_mark_node;
7842 }
7843}
7844
7845/* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
7846 type of the expression on the left-hand side of the "." or "->"
7847 operator. */
7848
7849static tree
7850tsubst_baselink (tree baselink, tree object_type,
7851 tree args, tsubst_flags_t complain, tree in_decl)
7852{
7853 tree name;
7854 tree qualifying_scope;
7855 tree fns;
7856 tree optype;
7857 tree template_args = 0;
7858 bool template_id_p = false;
7859
7860 /* A baselink indicates a function from a base class. Both the
7861 BASELINK_ACCESS_BINFO and the base class referenced may
7862 indicate bases of the template class, rather than the
7863 instantiated class. In addition, lookups that were not
7864 ambiguous before may be ambiguous now. Therefore, we perform
7865 the lookup again. */
7866 qualifying_scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink));
7867 qualifying_scope = tsubst (qualifying_scope, args,
7868 complain, in_decl);
7869 fns = BASELINK_FUNCTIONS (baselink);
7870 optype = BASELINK_OPTYPE (baselink);
7871 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
7872 {
7873 template_id_p = true;
7874 template_args = TREE_OPERAND (fns, 1);
7875 fns = TREE_OPERAND (fns, 0);
7876 if (template_args)
7877 template_args = tsubst_template_args (template_args, args,
7878 complain, in_decl);
7879 }
7880 name = DECL_NAME (get_first_fn (fns));
7881 baselink = lookup_fnfields (qualifying_scope, name, /*protect=*/1);
7882
7883 /* If lookup found a single function, mark it as used at this
7884 point. (If it lookup found multiple functions the one selected
7885 later by overload resolution will be marked as used at that
7886 point.) */
7887 if (BASELINK_P (baselink))
7888 fns = BASELINK_FUNCTIONS (baselink);
7889 if (!template_id_p && !really_overloaded_fn (fns))
7890 mark_used (OVL_CURRENT (fns));
7891
7892 /* Add back the template arguments, if present. */
7893 if (BASELINK_P (baselink) && template_id_p)
7894 BASELINK_FUNCTIONS (baselink)
7895 = build_nt (TEMPLATE_ID_EXPR,
7896 BASELINK_FUNCTIONS (baselink),
7897 template_args);
7898 /* Update the conversion operator type. */
7899 BASELINK_OPTYPE (baselink)
7900 = tsubst (optype, args, complain, in_decl);
7901
7902 if (!object_type)
7903 object_type = current_class_type;
7904 return adjust_result_of_qualified_name_lookup (baselink,
7905 qualifying_scope,
7906 object_type);
7907}
7908
7909/* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
7910 true if the qualified-id will be a postfix-expression in-and-of
7911 itself; false if more of the postfix-expression follows the
7912 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
7913 of "&". */
7914
7915static tree
7916tsubst_qualified_id (tree qualified_id, tree args,
7917 tsubst_flags_t complain, tree in_decl,
7918 bool done, bool address_p)
7919{
7920 tree expr;
7921 tree scope;
7922 tree name;
7923 bool is_template;
7924 tree template_args;
7925
7926 gcc_assert (TREE_CODE (qualified_id) == SCOPE_REF);
7927
7928 /* Figure out what name to look up. */
7929 name = TREE_OPERAND (qualified_id, 1);
7930 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
7931 {
7932 is_template = true;
7933 template_args = TREE_OPERAND (name, 1);
7934 if (template_args)
7935 template_args = tsubst_template_args (template_args, args,
7936 complain, in_decl);
7937 name = TREE_OPERAND (name, 0);
7938 }
7939 else
7940 {
7941 is_template = false;
7942 template_args = NULL_TREE;
7943 }
7944
7945 /* Substitute into the qualifying scope. When there are no ARGS, we
7946 are just trying to simplify a non-dependent expression. In that
7947 case the qualifying scope may be dependent, and, in any case,
7948 substituting will not help. */
7949 scope = TREE_OPERAND (qualified_id, 0);
7950 if (args)
7951 {
7952 scope = tsubst (scope, args, complain, in_decl);
7953 expr = tsubst_copy (name, args, complain, in_decl);
7954 }
7955 else
7956 expr = name;
7957
7958 if (dependent_type_p (scope))
7959 return build_qualified_name (/*type=*/NULL_TREE,
7960 scope, expr,
7961 QUALIFIED_NAME_IS_TEMPLATE (qualified_id));
7962
7963 if (!BASELINK_P (name) && !DECL_P (expr))
7964 {
7965 if (TREE_CODE (expr) == BIT_NOT_EXPR)
7966 /* If this were actually a destructor call, it would have been
7967 parsed as such by the parser. */
7968 expr = error_mark_node;
7969 else
7970 expr = lookup_qualified_name (scope, expr, /*is_type_p=*/0, false);
7971 if (TREE_CODE (TREE_CODE (expr) == TEMPLATE_DECL
7972 ? DECL_TEMPLATE_RESULT (expr) : expr) == TYPE_DECL)
7973 {
7974 if (complain & tf_error)
7975 {
7976 error ("dependent-name %qE is parsed as a non-type, but "
7977 "instantiation yields a type", qualified_id);
7978 inform ("say %<typename %E%> if a type is meant", qualified_id);
7979 }
7980 return error_mark_node;
7981 }
7982 }
7983
7984 if (DECL_P (expr))
7985 {
7986 check_accessibility_of_qualified_id (expr, /*object_type=*/NULL_TREE,
7987 scope);
7988 /* Remember that there was a reference to this entity. */
7989 mark_used (expr);
7990 }
7991
7992 if (expr == error_mark_node || TREE_CODE (expr) == TREE_LIST)
7993 {
7994 if (complain & tf_error)
7995 qualified_name_lookup_error (scope,
7996 TREE_OPERAND (qualified_id, 1),
7997 expr);
7998 return error_mark_node;
7999 }
8000
8001 if (is_template)
8002 expr = lookup_template_function (expr, template_args);
8003
8004 if (expr == error_mark_node && complain & tf_error)
8005 qualified_name_lookup_error (scope, TREE_OPERAND (qualified_id, 1),
8006 expr);
8007 else if (TYPE_P (scope))
8008 {
8009 expr = (adjust_result_of_qualified_name_lookup
8010 (expr, scope, current_class_type));
8011 expr = (finish_qualified_id_expr
8012 (scope, expr, done, address_p,
8013 QUALIFIED_NAME_IS_TEMPLATE (qualified_id),
8014 /*template_arg_p=*/false));
8015 }
8016
8017 /* Expressions do not generally have reference type. */
8018 if (TREE_CODE (expr) != SCOPE_REF
8019 /* However, if we're about to form a pointer-to-member, we just
8020 want the referenced member referenced. */
8021 && TREE_CODE (expr) != OFFSET_REF)
8022 expr = convert_from_reference (expr);
8023
8024 return expr;
8025}
8026
8027/* Like tsubst, but deals with expressions. This function just replaces
8028 template parms; to finish processing the resultant expression, use
8029 tsubst_expr. */
8030
8031static tree
8032tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl)
8033{
8034 enum tree_code code;
8035 tree r;
8036
8037 if (t == NULL_TREE || t == error_mark_node)
8038 return t;
8039
8040 code = TREE_CODE (t);
8041
8042 switch (code)
8043 {
8044 case PARM_DECL:
8045 r = retrieve_local_specialization (t);
8046 gcc_assert (r != NULL);
8047 mark_used (r);
8048 return r;
8049
8050 case CONST_DECL:
8051 {
8052 tree enum_type;
8053 tree v;
8054
8055 if (DECL_TEMPLATE_PARM_P (t))
8056 return tsubst_copy (DECL_INITIAL (t), args, complain, in_decl);
8057 /* There is no need to substitute into namespace-scope
8058 enumerators. */
8059 if (DECL_NAMESPACE_SCOPE_P (t))
8060 return t;
8061 /* If ARGS is NULL, then T is known to be non-dependent. */
8062 if (args == NULL_TREE)
8063 return integral_constant_value (t);
8064
8065 /* Unfortunately, we cannot just call lookup_name here.
8066 Consider:
8067
8068 template <int I> int f() {
8069 enum E { a = I };
8070 struct S { void g() { E e = a; } };
8071 };
8072
8073 When we instantiate f<7>::S::g(), say, lookup_name is not
8074 clever enough to find f<7>::a. */
8075 enum_type
8076 = tsubst_aggr_type (TREE_TYPE (t), args, complain, in_decl,
8077 /*entering_scope=*/0);
8078
8079 for (v = TYPE_VALUES (enum_type);
8080 v != NULL_TREE;
8081 v = TREE_CHAIN (v))
8082 if (TREE_PURPOSE (v) == DECL_NAME (t))
8083 return TREE_VALUE (v);
8084
8085 /* We didn't find the name. That should never happen; if
8086 name-lookup found it during preliminary parsing, we
8087 should find it again here during instantiation. */
8088 gcc_unreachable ();
8089 }
8090 return t;
8091
8092 case FIELD_DECL:
8093 if (DECL_CONTEXT (t))
8094 {
8095 tree ctx;
8096
8097 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, in_decl,
8098 /*entering_scope=*/1);
8099 if (ctx != DECL_CONTEXT (t))
8100 {
8101 tree r = lookup_field (ctx, DECL_NAME (t), 0, false);
8102 if (!r)
8103 {
8104 if (complain & tf_error)
8105 error ("using invalid field %qD", t);
8106 return error_mark_node;
8107 }
8108 return r;
8109 }
8110 }
8111
8112 return t;
8113
8114 case VAR_DECL:
8115 case FUNCTION_DECL:
8116 if ((DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t))
8117 || local_variable_p (t))
8118 t = tsubst (t, args, complain, in_decl);
8119 mark_used (t);
8120 return t;
8121
8122 case BASELINK:
8123 return tsubst_baselink (t, current_class_type, args, complain, in_decl);
8124
8125 case TEMPLATE_DECL:
8126 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
8127 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
8128 args, complain, in_decl);
8129 else if (DECL_FUNCTION_TEMPLATE_P (t) && DECL_MEMBER_TEMPLATE_P (t))
8130 return tsubst (t, args, complain, in_decl);
8131 else if (DECL_CLASS_SCOPE_P (t)
8132 && uses_template_parms (DECL_CONTEXT (t)))
8133 {
8134 /* Template template argument like the following example need
8135 special treatment:
8136
8137 template <template <class> class TT> struct C {};
8138 template <class T> struct D {
8139 template <class U> struct E {};
8140 C<E> c; // #1
8141 };
8142 D<int> d; // #2
8143
8144 We are processing the template argument `E' in #1 for
8145 the template instantiation #2. Originally, `E' is a
8146 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
8147 have to substitute this with one having context `D<int>'. */
8148
8149 tree context = tsubst (DECL_CONTEXT (t), args, complain, in_decl);
8150 return lookup_field (context, DECL_NAME(t), 0, false);
8151 }
8152 else
8153 /* Ordinary template template argument. */
8154 return t;
8155
8156 case CAST_EXPR:
8157 case REINTERPRET_CAST_EXPR:
8158 case CONST_CAST_EXPR:
8159 case STATIC_CAST_EXPR:
8160 case DYNAMIC_CAST_EXPR:
8161 case NOP_EXPR:
8162 return build1
8163 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
8164 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
8165
8166 case INDIRECT_REF:
8167 case NEGATE_EXPR:
8168 case TRUTH_NOT_EXPR:
8169 case BIT_NOT_EXPR:
8170 case ADDR_EXPR:
8171 case UNARY_PLUS_EXPR: /* Unary + */
8172 case SIZEOF_EXPR:
8173 case ALIGNOF_EXPR:
8174 case ARROW_EXPR:
8175 case THROW_EXPR:
8176 case TYPEID_EXPR:
8177 case REALPART_EXPR:
8178 case IMAGPART_EXPR:
8179 return build1
8180 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
8181 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
8182
8183 case COMPONENT_REF:
8184 {
8185 tree object;
8186 tree name;
8187
8188 object = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
8189 name = TREE_OPERAND (t, 1);
8190 if (TREE_CODE (name) == BIT_NOT_EXPR)
8191 {
8192 name = tsubst_copy (TREE_OPERAND (name, 0), args,
8193 complain, in_decl);
8194 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
8195 }
8196 else if (TREE_CODE (name) == SCOPE_REF
8197 && TREE_CODE (TREE_OPERAND (name, 1)) == BIT_NOT_EXPR)
8198 {
8199 tree base = tsubst_copy (TREE_OPERAND (name, 0), args,
8200 complain, in_decl);
8201 name = TREE_OPERAND (name, 1);
8202 name = tsubst_copy (TREE_OPERAND (name, 0), args,
8203 complain, in_decl);
8204 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
8205 name = build_qualified_name (/*type=*/NULL_TREE,
8206 base, name,
8207 /*template_p=*/false);
8208 }
8209 else if (TREE_CODE (name) == BASELINK)
8210 name = tsubst_baselink (name,
8211 non_reference (TREE_TYPE (object)),
8212 args, complain,
8213 in_decl);
8214 else
8215 name = tsubst_copy (name, args, complain, in_decl);
8216 return build_nt (COMPONENT_REF, object, name, NULL_TREE);
8217 }
8218
8219 case PLUS_EXPR:
8220 case MINUS_EXPR:
8221 case MULT_EXPR:
8222 case TRUNC_DIV_EXPR:
8223 case CEIL_DIV_EXPR:
8224 case FLOOR_DIV_EXPR:
8225 case ROUND_DIV_EXPR:
8226 case EXACT_DIV_EXPR:
8227 case BIT_AND_EXPR:
8228 case BIT_IOR_EXPR:
8229 case BIT_XOR_EXPR:
8230 case TRUNC_MOD_EXPR:
8231 case FLOOR_MOD_EXPR:
8232 case TRUTH_ANDIF_EXPR:
8233 case TRUTH_ORIF_EXPR:
8234 case TRUTH_AND_EXPR:
8235 case TRUTH_OR_EXPR:
8236 case RSHIFT_EXPR:
8237 case LSHIFT_EXPR:
8238 case RROTATE_EXPR:
8239 case LROTATE_EXPR:
8240 case EQ_EXPR:
8241 case NE_EXPR:
8242 case MAX_EXPR:
8243 case MIN_EXPR:
8244 case LE_EXPR:
8245 case GE_EXPR:
8246 case LT_EXPR:
8247 case GT_EXPR:
8248 case COMPOUND_EXPR:
8249 case DOTSTAR_EXPR:
8250 case MEMBER_REF:
8251 case PREDECREMENT_EXPR:
8252 case PREINCREMENT_EXPR:
8253 case POSTDECREMENT_EXPR:
8254 case POSTINCREMENT_EXPR:
8255 return build_nt
8256 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
8257 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
8258
8259 case SCOPE_REF:
8260 return build_qualified_name (/*type=*/NULL_TREE,
8261 tsubst_copy (TREE_OPERAND (t, 0),
8262 args, complain, in_decl),
8263 tsubst_copy (TREE_OPERAND (t, 1),
8264 args, complain, in_decl),
8265 QUALIFIED_NAME_IS_TEMPLATE (t));
8266
8267 case ARRAY_REF:
8268 return build_nt
8269 (ARRAY_REF,
8270 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
8271 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
8272 NULL_TREE, NULL_TREE);
8273
8274 case CALL_EXPR:
8275 return build_nt (code,
8276 tsubst_copy (TREE_OPERAND (t, 0), args,
8277 complain, in_decl),
8278 tsubst_copy (TREE_OPERAND (t, 1), args, complain,
8279 in_decl),
8280 NULL_TREE);
8281
8282 case COND_EXPR:
8283 case MODOP_EXPR:
8284 case PSEUDO_DTOR_EXPR:
8285 {
8286 r = build_nt
8287 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
8288 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
8289 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
8290 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
8291 return r;
8292 }
8293
8294 case NEW_EXPR:
8295 {
8296 r = build_nt
8297 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
8298 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
8299 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
8300 NEW_EXPR_USE_GLOBAL (r) = NEW_EXPR_USE_GLOBAL (t);
8301 return r;
8302 }
8303
8304 case DELETE_EXPR:
8305 {
8306 r = build_nt
8307 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
8308 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
8309 DELETE_EXPR_USE_GLOBAL (r) = DELETE_EXPR_USE_GLOBAL (t);
8310 DELETE_EXPR_USE_VEC (r) = DELETE_EXPR_USE_VEC (t);
8311 return r;
8312 }
8313
8314 case TEMPLATE_ID_EXPR:
8315 {
8316 /* Substituted template arguments */
8317 tree fn = TREE_OPERAND (t, 0);
8318 tree targs = TREE_OPERAND (t, 1);
8319
8320 fn = tsubst_copy (fn, args, complain, in_decl);
8321 if (targs)
8322 targs = tsubst_template_args (targs, args, complain, in_decl);
8323
8324 return lookup_template_function (fn, targs);
8325 }
8326
8327 case TREE_LIST:
8328 {
8329 tree purpose, value, chain;
8330
8331 if (t == void_list_node)
8332 return t;
8333
8334 purpose = TREE_PURPOSE (t);
8335 if (purpose)
8336 purpose = tsubst_copy (purpose, args, complain, in_decl);
8337 value = TREE_VALUE (t);
8338 if (value)
8339 value = tsubst_copy (value, args, complain, in_decl);
8340 chain = TREE_CHAIN (t);
8341 if (chain && chain != void_type_node)
8342 chain = tsubst_copy (chain, args, complain, in_decl);
8343 if (purpose == TREE_PURPOSE (t)
8344 && value == TREE_VALUE (t)
8345 && chain == TREE_CHAIN (t))
8346 return t;
8347 return tree_cons (purpose, value, chain);
8348 }
8349
8350 case RECORD_TYPE:
8351 case UNION_TYPE:
8352 case ENUMERAL_TYPE:
8353 case INTEGER_TYPE:
8354 case TEMPLATE_TYPE_PARM:
8355 case TEMPLATE_TEMPLATE_PARM:
8356 case BOUND_TEMPLATE_TEMPLATE_PARM:
8357 case TEMPLATE_PARM_INDEX:
8358 case POINTER_TYPE:
8359 case REFERENCE_TYPE:
8360 case OFFSET_TYPE:
8361 case FUNCTION_TYPE:
8362 case METHOD_TYPE:
8363 case ARRAY_TYPE:
8364 case TYPENAME_TYPE:
8365 case UNBOUND_CLASS_TEMPLATE:
8366 case TYPEOF_TYPE:
8367 case TYPE_DECL:
8368 return tsubst (t, args, complain, in_decl);
8369
8370 case IDENTIFIER_NODE:
8371 if (IDENTIFIER_TYPENAME_P (t))
8372 {
8373 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8374 return mangle_conv_op_name_for_type (new_type);
8375 }
8376 else
8377 return t;
8378
8379 case CONSTRUCTOR:
8380 /* This is handled by tsubst_copy_and_build. */
8381 gcc_unreachable ();
8382
8383 case VA_ARG_EXPR:
8384 return build_x_va_arg (tsubst_copy (TREE_OPERAND (t, 0), args, complain,
8385 in_decl),
8386 tsubst (TREE_TYPE (t), args, complain, in_decl));
8387
8388 case CLEANUP_POINT_EXPR:
8389 /* We shouldn't have built any of these during initial template
8390 generation. Instead, they should be built during instantiation
8391 in response to the saved STMT_IS_FULL_EXPR_P setting. */
8392 gcc_unreachable ();
8393
8394 case OFFSET_REF:
8395 mark_used (TREE_OPERAND (t, 1));
8396 return t;
8397
8398 default:
8399 return t;
8400 }
8401}
8402
8403/* Like tsubst_copy, but specifically for OpenMP clauses. */
8404
8405static tree
8406tsubst_omp_clauses (tree clauses, tree args, tsubst_flags_t complain,
8407 tree in_decl)
8408{
8409 tree new_clauses = NULL, nc, oc;
8410
8411 for (oc = clauses; oc ; oc = OMP_CLAUSE_CHAIN (oc))
8412 {
8413 nc = copy_node (oc);
8414 OMP_CLAUSE_CHAIN (nc) = new_clauses;
8415 new_clauses = nc;
8416
8417 switch (OMP_CLAUSE_CODE (nc))
8418 {
8419 case OMP_CLAUSE_PRIVATE:
8420 case OMP_CLAUSE_SHARED:
8421 case OMP_CLAUSE_FIRSTPRIVATE:
8422 case OMP_CLAUSE_LASTPRIVATE:
8423 case OMP_CLAUSE_REDUCTION:
8424 case OMP_CLAUSE_COPYIN:
8425 case OMP_CLAUSE_COPYPRIVATE:
8426 case OMP_CLAUSE_IF:
8427 case OMP_CLAUSE_NUM_THREADS:
8428 case OMP_CLAUSE_SCHEDULE:
8429 OMP_CLAUSE_OPERAND (nc, 0)
8430 = tsubst_expr (OMP_CLAUSE_OPERAND (oc, 0), args, complain,
8431 in_decl, /*integral_constant_expression_p=*/false);
8432 break;
8433 case OMP_CLAUSE_NOWAIT:
8434 case OMP_CLAUSE_ORDERED:
8435 case OMP_CLAUSE_DEFAULT:
8436 break;
8437 default:
8438 gcc_unreachable ();
8439 }
8440 }
8441
8442 return finish_omp_clauses (nreverse (new_clauses));
8443}
8444
8445/* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
8446
8447static tree
8448tsubst_copy_asm_operands (tree t, tree args, tsubst_flags_t complain,
8449 tree in_decl)
8450{
8451#define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
8452
8453 tree purpose, value, chain;
8454
8455 if (t == NULL)
8456 return t;
8457
8458 if (TREE_CODE (t) != TREE_LIST)
8459 return tsubst_copy_and_build (t, args, complain, in_decl,
8460 /*function_p=*/false,
8461 /*integral_constant_expression_p=*/false);
8462
8463 if (t == void_list_node)
8464 return t;
8465
8466 purpose = TREE_PURPOSE (t);
8467 if (purpose)
8468 purpose = RECUR (purpose);
8469 value = TREE_VALUE (t);
8470 if (value)
8471 value = RECUR (value);
8472 chain = TREE_CHAIN (t);
8473 if (chain && chain != void_type_node)
8474 chain = RECUR (chain);
8475 return tree_cons (purpose, value, chain);
8476#undef RECUR
8477}
8478
8479/* Like tsubst_copy for expressions, etc. but also does semantic
8480 processing. */
8481
8482static tree
8483tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl,
8484 bool integral_constant_expression_p)
8485{
8486#define RECUR(NODE) \
8487 tsubst_expr ((NODE), args, complain, in_decl, \
8488 integral_constant_expression_p)
8489
8490 tree stmt, tmp;
8491
8492 if (t == NULL_TREE || t == error_mark_node)
8493 return t;
8494
8495 if (EXPR_HAS_LOCATION (t))
8496 input_location = EXPR_LOCATION (t);
8497 if (STATEMENT_CODE_P (TREE_CODE (t)))
8498 current_stmt_tree ()->stmts_are_full_exprs_p = STMT_IS_FULL_EXPR_P (t);
8499
8500 switch (TREE_CODE (t))
8501 {
8502 case STATEMENT_LIST:
8503 {
8504 tree_stmt_iterator i;
8505 for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
8506 RECUR (tsi_stmt (i));
8507 break;
8508 }
8509
8510 case CTOR_INITIALIZER:
8511 finish_mem_initializers (tsubst_initializer_list
8512 (TREE_OPERAND (t, 0), args));
8513 break;
8514
8515 case RETURN_EXPR:
8516 finish_return_stmt (RECUR (TREE_OPERAND (t, 0)));
8517 break;
8518
8519 case EXPR_STMT:
8520 tmp = RECUR (EXPR_STMT_EXPR (t));
8521 if (EXPR_STMT_STMT_EXPR_RESULT (t))
8522 finish_stmt_expr_expr (tmp, cur_stmt_expr);
8523 else
8524 finish_expr_stmt (tmp);
8525 break;
8526
8527 case USING_STMT:
8528 do_using_directive (RECUR (USING_STMT_NAMESPACE (t)));
8529 break;
8530
8531 case DECL_EXPR:
8532 {
8533 tree decl;
8534 tree init;
8535
8536 decl = DECL_EXPR_DECL (t);
8537 if (TREE_CODE (decl) == LABEL_DECL)
8538 finish_label_decl (DECL_NAME (decl));
8539 else if (TREE_CODE (decl) == USING_DECL)
8540 {
8541 tree scope = USING_DECL_SCOPE (decl);
8542 tree name = DECL_NAME (decl);
8543 tree decl;
8544
8545 scope = RECUR (scope);
8546 decl = lookup_qualified_name (scope, name,
8547 /*is_type_p=*/false,
8548 /*complain=*/false);
8549 if (decl == error_mark_node || TREE_CODE (decl) == TREE_LIST)
8550 qualified_name_lookup_error (scope, name, decl);
8551 else
8552 do_local_using_decl (decl, scope, name);
8553 }
8554 else
8555 {
8556 init = DECL_INITIAL (decl);
8557 decl = tsubst (decl, args, complain, in_decl);
8558 if (decl != error_mark_node)
8559 {
8560 /* By marking the declaration as instantiated, we avoid
8561 trying to instantiate it. Since instantiate_decl can't
8562 handle local variables, and since we've already done
8563 all that needs to be done, that's the right thing to
8564 do. */
8565 if (TREE_CODE (decl) == VAR_DECL)
8566 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
8567 if (TREE_CODE (decl) == VAR_DECL
8568 && ANON_AGGR_TYPE_P (TREE_TYPE (decl)))
8569 /* Anonymous aggregates are a special case. */
8570 finish_anon_union (decl);
8571 else
8572 {
8573 maybe_push_decl (decl);
8574 if (TREE_CODE (decl) == VAR_DECL
8575 && DECL_PRETTY_FUNCTION_P (decl))
8576 {
8577 /* For __PRETTY_FUNCTION__ we have to adjust the
8578 initializer. */
8579 const char *const name
8580 = cxx_printable_name (current_function_decl, 2);
8581 init = cp_fname_init (name, &TREE_TYPE (decl));
8582 }
8583 else
8584 init = RECUR (init);
8585 finish_decl (decl, init, NULL_TREE);
8586 }
8587 }
8588 }
8589
8590 /* A DECL_EXPR can also be used as an expression, in the condition
8591 clause of an if/for/while construct. */
8592 return decl;
8593 }
8594
8595 case FOR_STMT:
8596 stmt = begin_for_stmt ();
8597 RECUR (FOR_INIT_STMT (t));
8598 finish_for_init_stmt (stmt);
8599 tmp = RECUR (FOR_COND (t));
8600 finish_for_cond (tmp, stmt);
8601 tmp = RECUR (FOR_EXPR (t));
8602 finish_for_expr (tmp, stmt);
8603 RECUR (FOR_BODY (t));
8604 finish_for_stmt (stmt);
8605 break;
8606
8607 case WHILE_STMT:
8608 stmt = begin_while_stmt ();
8609 tmp = RECUR (WHILE_COND (t));
8610 finish_while_stmt_cond (tmp, stmt);
8611 RECUR (WHILE_BODY (t));
8612 finish_while_stmt (stmt);
8613 break;
8614
8615 case DO_STMT:
8616 stmt = begin_do_stmt ();
8617 RECUR (DO_BODY (t));
8618 finish_do_body (stmt);
8619 tmp = RECUR (DO_COND (t));
8620 finish_do_stmt (tmp, stmt);
8621 break;
8622
8623 case IF_STMT:
8624 stmt = begin_if_stmt ();
8625 tmp = RECUR (IF_COND (t));
8626 finish_if_stmt_cond (tmp, stmt);
8627 RECUR (THEN_CLAUSE (t));
8628 finish_then_clause (stmt);
8629
8630 if (ELSE_CLAUSE (t))
8631 {
8632 begin_else_clause (stmt);
8633 RECUR (ELSE_CLAUSE (t));
8634 finish_else_clause (stmt);
8635 }
8636
8637 finish_if_stmt (stmt);
8638 break;
8639
8640 case BIND_EXPR:
8641 if (BIND_EXPR_BODY_BLOCK (t))
8642 stmt = begin_function_body ();
8643 else
8644 stmt = begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t)
8645 ? BCS_TRY_BLOCK : 0);
8646
8647 RECUR (BIND_EXPR_BODY (t));
8648
8649 if (BIND_EXPR_BODY_BLOCK (t))
8650 finish_function_body (stmt);
8651 else
8652 finish_compound_stmt (stmt);
8653 break;
8654
8655 case BREAK_STMT:
8656 finish_break_stmt ();
8657 break;
8658
8659 case CONTINUE_STMT:
8660 finish_continue_stmt ();
8661 break;
8662
8663 case SWITCH_STMT:
8664 stmt = begin_switch_stmt ();
8665 tmp = RECUR (SWITCH_STMT_COND (t));
8666 finish_switch_cond (tmp, stmt);
8667 RECUR (SWITCH_STMT_BODY (t));
8668 finish_switch_stmt (stmt);
8669 break;
8670
8671 case CASE_LABEL_EXPR:
8672 finish_case_label (RECUR (CASE_LOW (t)),
8673 RECUR (CASE_HIGH (t)));
8674 break;
8675
8676 case LABEL_EXPR:
8677 finish_label_stmt (DECL_NAME (LABEL_EXPR_LABEL (t)));
8678 break;
8679
8680 case GOTO_EXPR:
8681 tmp = GOTO_DESTINATION (t);
8682 if (TREE_CODE (tmp) != LABEL_DECL)
8683 /* Computed goto's must be tsubst'd into. On the other hand,
8684 non-computed gotos must not be; the identifier in question
8685 will have no binding. */
8686 tmp = RECUR (tmp);
8687 else
8688 tmp = DECL_NAME (tmp);
8689 finish_goto_stmt (tmp);
8690 break;
8691
8692 case ASM_EXPR:
8693 tmp = finish_asm_stmt
8694 (ASM_VOLATILE_P (t),
8695 RECUR (ASM_STRING (t)),
8696 tsubst_copy_asm_operands (ASM_OUTPUTS (t), args, complain, in_decl),
8697 tsubst_copy_asm_operands (ASM_INPUTS (t), args, complain, in_decl),
8698 tsubst_copy_asm_operands (ASM_CLOBBERS (t), args, complain, in_decl));
8699 {
8700 tree asm_expr = tmp;
8701 if (TREE_CODE (asm_expr) == CLEANUP_POINT_EXPR)
8702 asm_expr = TREE_OPERAND (asm_expr, 0);
8703 ASM_INPUT_P (asm_expr) = ASM_INPUT_P (t);
8704 }
8705 break;
8706
8707 case TRY_BLOCK:
8708 if (CLEANUP_P (t))
8709 {
8710 stmt = begin_try_block ();
8711 RECUR (TRY_STMTS (t));
8712 finish_cleanup_try_block (stmt);
8713 finish_cleanup (RECUR (TRY_HANDLERS (t)), stmt);
8714 }
8715 else
8716 {
8717 tree compound_stmt = NULL_TREE;
8718
8719 if (FN_TRY_BLOCK_P (t))
8720 stmt = begin_function_try_block (&compound_stmt);
8721 else
8722 stmt = begin_try_block ();
8723
8724 RECUR (TRY_STMTS (t));
8725
8726 if (FN_TRY_BLOCK_P (t))
8727 finish_function_try_block (stmt);
8728 else
8729 finish_try_block (stmt);
8730
8731 RECUR (TRY_HANDLERS (t));
8732 if (FN_TRY_BLOCK_P (t))
8733 finish_function_handler_sequence (stmt, compound_stmt);
8734 else
8735 finish_handler_sequence (stmt);
8736 }
8737 break;
8738
8739 case HANDLER:
8740 {
8741 tree decl = HANDLER_PARMS (t);
8742
8743 if (decl)
8744 {
8745 decl = tsubst (decl, args, complain, in_decl);
8746 /* Prevent instantiate_decl from trying to instantiate
8747 this variable. We've already done all that needs to be
8748 done. */
8749 if (decl != error_mark_node)
8750 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
8751 }
8752 stmt = begin_handler ();
8753 finish_handler_parms (decl, stmt);
8754 RECUR (HANDLER_BODY (t));
8755 finish_handler (stmt);
8756 }
8757 break;
8758
8759 case TAG_DEFN:
8760 tsubst (TREE_TYPE (t), args, complain, NULL_TREE);
8761 break;
8762
8763 case OMP_PARALLEL:
8764 tmp = tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t),
8765 args, complain, in_decl);
8766 stmt = begin_omp_parallel ();
8767 RECUR (OMP_PARALLEL_BODY (t));
8768 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp, stmt))
8769 = OMP_PARALLEL_COMBINED (t);
8770 break;
8771
8772 case OMP_FOR:
8773 {
8774 tree clauses, decl, init, cond, incr, body, pre_body;
8775
8776 clauses = tsubst_omp_clauses (OMP_FOR_CLAUSES (t),
8777 args, complain, in_decl);
8778 init = OMP_FOR_INIT (t);
8779 gcc_assert (TREE_CODE (init) == MODIFY_EXPR);
8780 decl = RECUR (TREE_OPERAND (init, 0));
8781 init = RECUR (TREE_OPERAND (init, 1));
8782 cond = RECUR (OMP_FOR_COND (t));
8783 incr = RECUR (OMP_FOR_INCR (t));
8784
8785 stmt = begin_omp_structured_block ();
8786
8787 pre_body = push_stmt_list ();
8788 RECUR (OMP_FOR_PRE_BODY (t));
8789 pre_body = pop_stmt_list (pre_body);
8790
8791 body = push_stmt_list ();
8792 RECUR (OMP_FOR_BODY (t));
8793 body = pop_stmt_list (body);
8794
8795 t = finish_omp_for (EXPR_LOCATION (t), decl, init, cond, incr, body,
8796 pre_body);
8797 if (t)
8798 OMP_FOR_CLAUSES (t) = clauses;
8799
8800 add_stmt (finish_omp_structured_block (stmt));
8801 }
8802 break;
8803
8804 case OMP_SECTIONS:
8805 case OMP_SINGLE:
8806 tmp = tsubst_omp_clauses (OMP_CLAUSES (t), args, complain, in_decl);
8807 stmt = push_stmt_list ();
8808 RECUR (OMP_BODY (t));
8809 stmt = pop_stmt_list (stmt);
8810
8811 t = copy_node (t);
8812 OMP_BODY (t) = stmt;
8813 OMP_CLAUSES (t) = tmp;
8814 add_stmt (t);
8815 break;
8816
8817 case OMP_SECTION:
8818 case OMP_CRITICAL:
8819 case OMP_MASTER:
8820 case OMP_ORDERED:
8821 stmt = push_stmt_list ();
8822 RECUR (OMP_BODY (t));
8823 stmt = pop_stmt_list (stmt);
8824
8825 t = copy_node (t);
8826 OMP_BODY (t) = stmt;
8827 add_stmt (t);
8828 break;
8829
8830 case OMP_ATOMIC:
8831 {
8832 tree op0, op1;
8833 op0 = RECUR (TREE_OPERAND (t, 0));
8834 op1 = RECUR (TREE_OPERAND (t, 1));
8835 finish_omp_atomic (OMP_ATOMIC_CODE (t), op0, op1);
8836 }
8837 break;
8838
8839 default:
8840 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t)));
8841
8842 return tsubst_copy_and_build (t, args, complain, in_decl,
8843 /*function_p=*/false,
8844 integral_constant_expression_p);
8845 }
8846
8847 return NULL_TREE;
8848#undef RECUR
8849}
8850
8851/* T is a postfix-expression that is not being used in a function
8852 call. Return the substituted version of T. */
8853
8854static tree
8855tsubst_non_call_postfix_expression (tree t, tree args,
8856 tsubst_flags_t complain,
8857 tree in_decl)
8858{
8859 if (TREE_CODE (t) == SCOPE_REF)
8860 t = tsubst_qualified_id (t, args, complain, in_decl,
8861 /*done=*/false, /*address_p=*/false);
8862 else
8863 t = tsubst_copy_and_build (t, args, complain, in_decl,
8864 /*function_p=*/false,
8865 /*integral_constant_expression_p=*/false);
8866
8867 return t;
8868}
8869
8870/* Like tsubst but deals with expressions and performs semantic
8871 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
8872
8873tree
8874tsubst_copy_and_build (tree t,
8875 tree args,
8876 tsubst_flags_t complain,
8877 tree in_decl,
8878 bool function_p,
8879 bool integral_constant_expression_p)
8880{
8881#define RECUR(NODE) \
8882 tsubst_copy_and_build (NODE, args, complain, in_decl, \
8883 /*function_p=*/false, \
8884 integral_constant_expression_p)
8885
8886 tree op1;
8887
8888 if (t == NULL_TREE || t == error_mark_node)
8889 return t;
8890
8891 switch (TREE_CODE (t))
8892 {
8893 case USING_DECL:
8894 t = DECL_NAME (t);
8895 /* Fall through. */
8896 case IDENTIFIER_NODE:
8897 {
8898 tree decl;
8899 cp_id_kind idk;
8900 bool non_integral_constant_expression_p;
8901 const char *error_msg;
8902
8903 if (IDENTIFIER_TYPENAME_P (t))
8904 {
8905 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8906 t = mangle_conv_op_name_for_type (new_type);
8907 }
8908
8909 /* Look up the name. */
8910 decl = lookup_name (t);
8911
8912 /* By convention, expressions use ERROR_MARK_NODE to indicate
8913 failure, not NULL_TREE. */
8914 if (decl == NULL_TREE)
8915 decl = error_mark_node;
8916
8917 decl = finish_id_expression (t, decl, NULL_TREE,
8918 &idk,
8919 integral_constant_expression_p,
8920 /*allow_non_integral_constant_expression_p=*/false,
8921 &non_integral_constant_expression_p,
8922 /*template_p=*/false,
8923 /*done=*/true,
8924 /*address_p=*/false,
8925 /*template_arg_p=*/false,
8926 &error_msg);
8927 if (error_msg)
8928 error (error_msg);
8929 if (!function_p && TREE_CODE (decl) == IDENTIFIER_NODE)
8930 decl = unqualified_name_lookup_error (decl);
8931 return decl;
8932 }
8933
8934 case TEMPLATE_ID_EXPR:
8935 {
8936 tree object;
8937 tree template = RECUR (TREE_OPERAND (t, 0));
8938 tree targs = TREE_OPERAND (t, 1);
8939
8940 if (targs)
8941 targs = tsubst_template_args (targs, args, complain, in_decl);
8942
8943 if (TREE_CODE (template) == COMPONENT_REF)
8944 {
8945 object = TREE_OPERAND (template, 0);
8946 template = TREE_OPERAND (template, 1);
8947 }
8948 else
8949 object = NULL_TREE;
8950 template = lookup_template_function (template, targs);
8951
8952 if (object)
8953 return build3 (COMPONENT_REF, TREE_TYPE (template),
8954 object, template, NULL_TREE);
8955 else
8956 return baselink_for_fns (template);
8957 }
8958
8959 case INDIRECT_REF:
8960 {
8961 tree r = RECUR (TREE_OPERAND (t, 0));
8962
8963 if (REFERENCE_REF_P (t))
8964 {
8965 /* A type conversion to reference type will be enclosed in
8966 such an indirect ref, but the substitution of the cast
8967 will have also added such an indirect ref. */
8968 if (TREE_CODE (TREE_TYPE (r)) == REFERENCE_TYPE)
8969 r = convert_from_reference (r);
8970 }
8971 else
8972 r = build_x_indirect_ref (r, "unary *");
8973 return r;
8974 }
8975
8976 case NOP_EXPR:
8977 return build_nop
8978 (tsubst (TREE_TYPE (t), args, complain, in_decl),
8979 RECUR (TREE_OPERAND (t, 0)));
8980
8981 case CAST_EXPR:
8982 case REINTERPRET_CAST_EXPR:
8983 case CONST_CAST_EXPR:
8984 case DYNAMIC_CAST_EXPR:
8985 case STATIC_CAST_EXPR:
8986 {
8987 tree type;
8988 tree op;
8989
8990 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8991 if (integral_constant_expression_p
8992 && !cast_valid_in_integral_constant_expression_p (type))
8993 {
8994 error ("a cast to a type other than an integral or "
8995 "enumeration type cannot appear in a constant-expression");
8996 return error_mark_node;
8997 }
8998
8999 op = RECUR (TREE_OPERAND (t, 0));
9000
9001 switch (TREE_CODE (t))
9002 {
9003 case CAST_EXPR:
9004 return build_functional_cast (type, op);
9005 case REINTERPRET_CAST_EXPR:
9006 return build_reinterpret_cast (type, op);
9007 case CONST_CAST_EXPR:
9008 return build_const_cast (type, op);
9009 case DYNAMIC_CAST_EXPR:
9010 return build_dynamic_cast (type, op);
9011 case STATIC_CAST_EXPR:
9012 return build_static_cast (type, op);
9013 default:
9014 gcc_unreachable ();
9015 }
9016 }
9017
9018 case POSTDECREMENT_EXPR:
9019 case POSTINCREMENT_EXPR:
9020 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
9021 args, complain, in_decl);
9022 return build_x_unary_op (TREE_CODE (t), op1);
9023
9024 case PREDECREMENT_EXPR:
9025 case PREINCREMENT_EXPR:
9026 case NEGATE_EXPR:
9027 case BIT_NOT_EXPR:
9028 case ABS_EXPR:
9029 case TRUTH_NOT_EXPR:
9030 case UNARY_PLUS_EXPR: /* Unary + */
9031 case REALPART_EXPR:
9032 case IMAGPART_EXPR:
9033 return build_x_unary_op (TREE_CODE (t), RECUR (TREE_OPERAND (t, 0)));
9034
9035 case ADDR_EXPR:
9036 op1 = TREE_OPERAND (t, 0);
9037 if (TREE_CODE (op1) == SCOPE_REF)
9038 op1 = tsubst_qualified_id (op1, args, complain, in_decl,
9039 /*done=*/true, /*address_p=*/true);
9040 else
9041 op1 = tsubst_non_call_postfix_expression (op1, args, complain,
9042 in_decl);
9043 if (TREE_CODE (op1) == LABEL_DECL)
9044 return finish_label_address_expr (DECL_NAME (op1));
9045 return build_x_unary_op (ADDR_EXPR, op1);
9046
9047 case PLUS_EXPR:
9048 case MINUS_EXPR:
9049 case MULT_EXPR:
9050 case TRUNC_DIV_EXPR:
9051 case CEIL_DIV_EXPR:
9052 case FLOOR_DIV_EXPR:
9053 case ROUND_DIV_EXPR:
9054 case EXACT_DIV_EXPR:
9055 case BIT_AND_EXPR:
9056 case BIT_IOR_EXPR:
9057 case BIT_XOR_EXPR:
9058 case TRUNC_MOD_EXPR:
9059 case FLOOR_MOD_EXPR:
9060 case TRUTH_ANDIF_EXPR:
9061 case TRUTH_ORIF_EXPR:
9062 case TRUTH_AND_EXPR:
9063 case TRUTH_OR_EXPR:
9064 case RSHIFT_EXPR:
9065 case LSHIFT_EXPR:
9066 case RROTATE_EXPR:
9067 case LROTATE_EXPR:
9068 case EQ_EXPR:
9069 case NE_EXPR:
9070 case MAX_EXPR:
9071 case MIN_EXPR:
9072 case LE_EXPR:
9073 case GE_EXPR:
9074 case LT_EXPR:
9075 case GT_EXPR:
9076 case MEMBER_REF:
9077 case DOTSTAR_EXPR:
9078 return build_x_binary_op
9079 (TREE_CODE (t),
9080 RECUR (TREE_OPERAND (t, 0)),
9081 RECUR (TREE_OPERAND (t, 1)),
9082 /*overloaded_p=*/NULL);
9083
9084 case SCOPE_REF:
9085 return tsubst_qualified_id (t, args, complain, in_decl, /*done=*/true,
9086 /*address_p=*/false);
9087 case ARRAY_REF:
9088 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
9089 args, complain, in_decl);
9090 return build_x_binary_op (ARRAY_REF, op1, RECUR (TREE_OPERAND (t, 1)),
9091 /*overloaded_p=*/NULL);
9092
9093 case SIZEOF_EXPR:
9094 case ALIGNOF_EXPR:
9095 op1 = TREE_OPERAND (t, 0);
9096 if (!args)
9097 {
9098 /* When there are no ARGS, we are trying to evaluate a
9099 non-dependent expression from the parser. Trying to do
9100 the substitutions may not work. */
9101 if (!TYPE_P (op1))
9102 op1 = TREE_TYPE (op1);
9103 }
9104 else
9105 {
9106 ++skip_evaluation;
9107 op1 = tsubst_copy_and_build (op1, args, complain, in_decl,
9108 /*function_p=*/false,
9109 /*integral_constant_expression_p=*/false);
9110 --skip_evaluation;
9111 }
9112 if (TYPE_P (op1))
9113 return cxx_sizeof_or_alignof_type (op1, TREE_CODE (t), true);
9114 else
9115 return cxx_sizeof_or_alignof_expr (op1, TREE_CODE (t));
9116
9117 case MODOP_EXPR:
9118 {
9119 tree r = build_x_modify_expr
9120 (RECUR (TREE_OPERAND (t, 0)),
9121 TREE_CODE (TREE_OPERAND (t, 1)),
9122 RECUR (TREE_OPERAND (t, 2)));
9123 /* TREE_NO_WARNING must be set if either the expression was
9124 parenthesized or it uses an operator such as >>= rather
9125 than plain assignment. In the former case, it was already
9126 set and must be copied. In the latter case,
9127 build_x_modify_expr sets it and it must not be reset
9128 here. */
9129 if (TREE_NO_WARNING (t))
9130 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
9131 return r;
9132 }
9133
9134 case ARROW_EXPR:
9135 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
9136 args, complain, in_decl);
9137 /* Remember that there was a reference to this entity. */
9138 if (DECL_P (op1))
9139 mark_used (op1);
9140 return build_x_arrow (op1);
9141
9142 case NEW_EXPR:
9143 return build_new
9144 (RECUR (TREE_OPERAND (t, 0)),
9145 RECUR (TREE_OPERAND (t, 1)),
9146 RECUR (TREE_OPERAND (t, 2)),
9147 RECUR (TREE_OPERAND (t, 3)),
9148 NEW_EXPR_USE_GLOBAL (t));
9149
9150 case DELETE_EXPR:
9151 return delete_sanity
9152 (RECUR (TREE_OPERAND (t, 0)),
9153 RECUR (TREE_OPERAND (t, 1)),
9154 DELETE_EXPR_USE_VEC (t),
9155 DELETE_EXPR_USE_GLOBAL (t));
9156
9157 case COMPOUND_EXPR:
9158 return build_x_compound_expr (RECUR (TREE_OPERAND (t, 0)),
9159 RECUR (TREE_OPERAND (t, 1)));
9160
9161 case CALL_EXPR:
9162 {
9163 tree function;
9164 tree call_args;
9165 bool qualified_p;
9166 bool koenig_p;
9167
9168 function = TREE_OPERAND (t, 0);
9169 /* When we parsed the expression, we determined whether or
9170 not Koenig lookup should be performed. */
9171 koenig_p = KOENIG_LOOKUP_P (t);
9172 if (TREE_CODE (function) == SCOPE_REF)
9173 {
9174 qualified_p = true;
9175 function = tsubst_qualified_id (function, args, complain, in_decl,
9176 /*done=*/false,
9177 /*address_p=*/false);
9178 }
9179 else
9180 {
9181 if (TREE_CODE (function) == COMPONENT_REF)
9182 {
9183 tree op = TREE_OPERAND (function, 1);
9184
9185 qualified_p = (TREE_CODE (op) == SCOPE_REF
9186 || (BASELINK_P (op)
9187 && BASELINK_QUALIFIED_P (op)));
9188 }
9189 else
9190 qualified_p = false;
9191
9192 function = tsubst_copy_and_build (function, args, complain,
9193 in_decl,
9194 !qualified_p,
9195 integral_constant_expression_p);
9196
9197 if (BASELINK_P (function))
9198 qualified_p = true;
9199 }
9200
9201 call_args = RECUR (TREE_OPERAND (t, 1));
9202
9203 /* We do not perform argument-dependent lookup if normal
9204 lookup finds a non-function, in accordance with the
9205 expected resolution of DR 218. */
9206 if (koenig_p
9207 && ((is_overloaded_fn (function)
9208 /* If lookup found a member function, the Koenig lookup is
9209 not appropriate, even if an unqualified-name was used
9210 to denote the function. */
9211 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function)))
9212 || TREE_CODE (function) == IDENTIFIER_NODE))
9213 function = perform_koenig_lookup (function, call_args);
9214
9215 if (TREE_CODE (function) == IDENTIFIER_NODE)
9216 {
9217 unqualified_name_lookup_error (function);
9218 return error_mark_node;
9219 }
9220
9221 /* Remember that there was a reference to this entity. */
9222 if (DECL_P (function))
9223 mark_used (function);
9224
9225 if (TREE_CODE (function) == OFFSET_REF)
9226 return build_offset_ref_call_from_tree (function, call_args);
9227 if (TREE_CODE (function) == COMPONENT_REF)
9228 {
9229 if (!BASELINK_P (TREE_OPERAND (function, 1)))
9230 return finish_call_expr (function, call_args,
9231 /*disallow_virtual=*/false,
9232 /*koenig_p=*/false);
9233 else
9234 return (build_new_method_call
9235 (TREE_OPERAND (function, 0),
9236 TREE_OPERAND (function, 1),
9237 call_args, NULL_TREE,
9238 qualified_p ? LOOKUP_NONVIRTUAL : LOOKUP_NORMAL,
9239 /*fn_p=*/NULL));
9240 }
9241 return finish_call_expr (function, call_args,
9242 /*disallow_virtual=*/qualified_p,
9243 koenig_p);
9244 }
9245
9246 case COND_EXPR:
9247 return build_x_conditional_expr
9248 (RECUR (TREE_OPERAND (t, 0)),
9249 RECUR (TREE_OPERAND (t, 1)),
9250 RECUR (TREE_OPERAND (t, 2)));
9251
9252 case PSEUDO_DTOR_EXPR:
9253 return finish_pseudo_destructor_expr
9254 (RECUR (TREE_OPERAND (t, 0)),
9255 RECUR (TREE_OPERAND (t, 1)),
9256 RECUR (TREE_OPERAND (t, 2)));
9257
9258 case TREE_LIST:
9259 {
9260 tree purpose, value, chain;
9261
9262 if (t == void_list_node)
9263 return t;
9264
9265 purpose = TREE_PURPOSE (t);
9266 if (purpose)
9267 purpose = RECUR (purpose);
9268 value = TREE_VALUE (t);
9269 if (value)
9270 value = RECUR (value);
9271 chain = TREE_CHAIN (t);
9272 if (chain && chain != void_type_node)
9273 chain = RECUR (chain);
9274 if (purpose == TREE_PURPOSE (t)
9275 && value == TREE_VALUE (t)
9276 && chain == TREE_CHAIN (t))
9277 return t;
9278 return tree_cons (purpose, value, chain);
9279 }
9280
9281 case COMPONENT_REF:
9282 {
9283 tree object;
9284 tree object_type;
9285 tree member;
9286
9287 object = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
9288 args, complain, in_decl);
9289 /* Remember that there was a reference to this entity. */
9290 if (DECL_P (object))
9291 mark_used (object);
9292 object_type = TREE_TYPE (object);
9293
9294 member = TREE_OPERAND (t, 1);
9295 if (BASELINK_P (member))
9296 member = tsubst_baselink (member,
9297 non_reference (TREE_TYPE (object)),
9298 args, complain, in_decl);
9299 else
9300 member = tsubst_copy (member, args, complain, in_decl);
9301 if (member == error_mark_node)
9302 return error_mark_node;
9303
9304 if (object_type && !CLASS_TYPE_P (object_type))
9305 {
9306 if (TREE_CODE (member) == BIT_NOT_EXPR)
9307 return finish_pseudo_destructor_expr (object,
9308 NULL_TREE,
9309 object_type);
9310 else if (TREE_CODE (member) == SCOPE_REF
9311 && (TREE_CODE (TREE_OPERAND (member, 1)) == BIT_NOT_EXPR))
9312 return finish_pseudo_destructor_expr (object,
9313 object,
9314 object_type);
9315 }
9316 else if (TREE_CODE (member) == SCOPE_REF
9317 && TREE_CODE (TREE_OPERAND (member, 1)) == TEMPLATE_ID_EXPR)
9318 {
9319 tree tmpl;
9320 tree args;
9321
9322 /* Lookup the template functions now that we know what the
9323 scope is. */
9324 tmpl = TREE_OPERAND (TREE_OPERAND (member, 1), 0);
9325 args = TREE_OPERAND (TREE_OPERAND (member, 1), 1);
9326 member = lookup_qualified_name (TREE_OPERAND (member, 0), tmpl,
9327 /*is_type_p=*/false,
9328 /*complain=*/false);
9329 if (BASELINK_P (member))
9330 {
9331 BASELINK_FUNCTIONS (member)
9332 = build_nt (TEMPLATE_ID_EXPR, BASELINK_FUNCTIONS (member),
9333 args);
9334 member = (adjust_result_of_qualified_name_lookup
9335 (member, BINFO_TYPE (BASELINK_BINFO (member)),
9336 object_type));
9337 }
9338 else
9339 {
9340 qualified_name_lookup_error (object_type, tmpl, member);
9341 return error_mark_node;
9342 }
9343 }
9344 else if (TREE_CODE (member) == SCOPE_REF
9345 && !CLASS_TYPE_P (TREE_OPERAND (member, 0))
9346 && TREE_CODE (TREE_OPERAND (member, 0)) != NAMESPACE_DECL)
9347 {
9348 if (complain & tf_error)
9349 {
9350 if (TYPE_P (TREE_OPERAND (member, 0)))
9351 error ("%qT is not a class or namespace",
9352 TREE_OPERAND (member, 0));
9353 else
9354 error ("%qD is not a class or namespace",
9355 TREE_OPERAND (member, 0));
9356 }
9357 return error_mark_node;
9358 }
9359 else if (TREE_CODE (member) == FIELD_DECL)
9360 return finish_non_static_data_member (member, object, NULL_TREE);
9361
9362 return finish_class_member_access_expr (object, member,
9363 /*template_p=*/false);
9364 }
9365
9366 case THROW_EXPR:
9367 return build_throw
9368 (RECUR (TREE_OPERAND (t, 0)));
9369
9370 case CONSTRUCTOR:
9371 {
9372 VEC(constructor_elt,gc) *n;
9373 constructor_elt *ce;
9374 unsigned HOST_WIDE_INT idx;
9375 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
9376 bool process_index_p;
9377
9378 if (type == error_mark_node)
9379 return error_mark_node;
9380
9381 /* digest_init will do the wrong thing if we let it. */
9382 if (type && TYPE_PTRMEMFUNC_P (type))
9383 return t;
9384
9385 /* We do not want to process the index of aggregate
9386 initializers as they are identifier nodes which will be
9387 looked up by digest_init. */
9388 process_index_p = !(type && IS_AGGR_TYPE (type));
9389
9390 n = VEC_copy (constructor_elt, gc, CONSTRUCTOR_ELTS (t));
9391 for (idx = 0; VEC_iterate (constructor_elt, n, idx, ce); idx++)
9392 {
9393 if (ce->index && process_index_p)
9394 ce->index = RECUR (ce->index);
9395 ce->value = RECUR (ce->value);
9396 }
9397
9398 if (TREE_HAS_CONSTRUCTOR (t))
9399 return finish_compound_literal (type, n);
9400
9401 return build_constructor (NULL_TREE, n);
9402 }
9403
9404 case TYPEID_EXPR:
9405 {
9406 tree operand_0 = RECUR (TREE_OPERAND (t, 0));
9407 if (TYPE_P (operand_0))
9408 return get_typeid (operand_0);
9409 return build_typeid (operand_0);
9410 }
9411
9412 case VAR_DECL:
9413 if (!args)
9414 return t;
9415 /* Fall through */
9416
9417 case PARM_DECL:
9418 {
9419 tree r = tsubst_copy (t, args, complain, in_decl);
9420
9421 if (TREE_CODE (TREE_TYPE (t)) != REFERENCE_TYPE)
9422 /* If the original type was a reference, we'll be wrapped in
9423 the appropriate INDIRECT_REF. */
9424 r = convert_from_reference (r);
9425 return r;
9426 }
9427
9428 case VA_ARG_EXPR:
9429 return build_x_va_arg (RECUR (TREE_OPERAND (t, 0)),
9430 tsubst_copy (TREE_TYPE (t), args, complain,
9431 in_decl));
9432
9433 case OFFSETOF_EXPR:
9434 return finish_offsetof (RECUR (TREE_OPERAND (t, 0)));
9435
9436 case STMT_EXPR:
9437 {
9438 tree old_stmt_expr = cur_stmt_expr;
9439 tree stmt_expr = begin_stmt_expr ();
9440
9441 cur_stmt_expr = stmt_expr;
9442 tsubst_expr (STMT_EXPR_STMT (t), args, complain, in_decl,
9443 integral_constant_expression_p);
9444 stmt_expr = finish_stmt_expr (stmt_expr, false);
9445 cur_stmt_expr = old_stmt_expr;
9446
9447 return stmt_expr;
9448 }
9449
9450 case CONST_DECL:
9451 t = tsubst_copy (t, args, complain, in_decl);
9452 /* As in finish_id_expression, we resolve enumeration constants
9453 to their underlying values. */
9454 if (TREE_CODE (t) == CONST_DECL)
9455 {
9456 used_types_insert (TREE_TYPE (t));
9457 return DECL_INITIAL (t);
9458 }
9459 return t;
9460
9461 default:
9462 /* Handle Objective-C++ constructs, if appropriate. */
9463 {
9464 tree subst
9465 = objcp_tsubst_copy_and_build (t, args, complain,
9466 in_decl, /*function_p=*/false);
9467 if (subst)
9468 return subst;
9469 }
9470 return tsubst_copy (t, args, complain, in_decl);
9471 }
9472
9473#undef RECUR
9474}
9475
9476/* Verify that the instantiated ARGS are valid. For type arguments,
9477 make sure that the type's linkage is ok. For non-type arguments,
9478 make sure they are constants if they are integral or enumerations.
9479 Emit an error under control of COMPLAIN, and return TRUE on error. */
9480
9481static bool
9482check_instantiated_args (tree tmpl, tree args, tsubst_flags_t complain)
9483{
9484 int ix, len = DECL_NTPARMS (tmpl);
9485 bool result = false;
9486
9487 for (ix = 0; ix != len; ix++)
9488 {
9489 tree t = TREE_VEC_ELT (args, ix);
9490
9491 if (TYPE_P (t))
9492 {
9493 /* [basic.link]: A name with no linkage (notably, the name
9494 of a class or enumeration declared in a local scope)
9495 shall not be used to declare an entity with linkage.
9496 This implies that names with no linkage cannot be used as
9497 template arguments. */
9498 tree nt = no_linkage_check (t, /*relaxed_p=*/false);
9499
9500 if (nt)
9501 {
9502 /* DR 488 makes use of a type with no linkage cause
9503 type deduction to fail. */
9504 if (complain & tf_error)
9505 {
9506 if (TYPE_ANONYMOUS_P (nt))
9507 error ("%qT is/uses anonymous type", t);
9508 else
9509 error ("template argument for %qD uses local type %qT",
9510 tmpl, t);
9511 }
9512 result = true;
9513 }
9514 /* In order to avoid all sorts of complications, we do not
9515 allow variably-modified types as template arguments. */
9516 else if (variably_modified_type_p (t, NULL_TREE))
9517 {
9518 if (complain & tf_error)
9519 error ("%qT is a variably modified type", t);
9520 result = true;
9521 }
9522 }
9523 /* A non-type argument of integral or enumerated type must be a
9524 constant. */
9525 else if (TREE_TYPE (t)
9526 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t))
9527 && !TREE_CONSTANT (t))
9528 {
9529 if (complain & tf_error)
9530 error ("integral expression %qE is not constant", t);
9531 result = true;
9532 }
9533 }
9534 if (result && (complain & tf_error))
9535 error (" trying to instantiate %qD", tmpl);
9536 return result;
9537}
9538
9539/* Instantiate the indicated variable or function template TMPL with
9540 the template arguments in TARG_PTR. */
9541
9542tree
9543instantiate_template (tree tmpl, tree targ_ptr, tsubst_flags_t complain)
9544{
9545 tree fndecl;
9546 tree gen_tmpl;
9547 tree spec;
9548 HOST_WIDE_INT saved_processing_template_decl;
9549
9550 if (tmpl == error_mark_node)
9551 return error_mark_node;
9552
9553 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
9554
9555 /* If this function is a clone, handle it specially. */
9556 if (DECL_CLONED_FUNCTION_P (tmpl))
9557 {
9558 tree spec;
9559 tree clone;
9560
9561 spec = instantiate_template (DECL_CLONED_FUNCTION (tmpl), targ_ptr,
9562 complain);
9563 if (spec == error_mark_node)
9564 return error_mark_node;
9565
9566 /* Look for the clone. */
9567 FOR_EACH_CLONE (clone, spec)
9568 if (DECL_NAME (clone) == DECL_NAME (tmpl))
9569 return clone;
9570 /* We should always have found the clone by now. */
9571 gcc_unreachable ();
9572 return NULL_TREE;
9573 }
9574
9575 /* Check to see if we already have this specialization. */
9576 spec = retrieve_specialization (tmpl, targ_ptr,
9577 /*class_specializations_p=*/false);
9578 if (spec != NULL_TREE)
9579 return spec;
9580
9581 gen_tmpl = most_general_template (tmpl);
9582 if (tmpl != gen_tmpl)
9583 {
9584 /* The TMPL is a partial instantiation. To get a full set of
9585 arguments we must add the arguments used to perform the
9586 partial instantiation. */
9587 targ_ptr = add_outermost_template_args (DECL_TI_ARGS (tmpl),
9588 targ_ptr);
9589
9590 /* Check to see if we already have this specialization. */
9591 spec = retrieve_specialization (gen_tmpl, targ_ptr,
9592 /*class_specializations_p=*/false);
9593 if (spec != NULL_TREE)
9594 return spec;
9595 }
9596
9597 if (check_instantiated_args (gen_tmpl, INNERMOST_TEMPLATE_ARGS (targ_ptr),
9598 complain))
9599 return error_mark_node;
9600
9601 /* We are building a FUNCTION_DECL, during which the access of its
9602 parameters and return types have to be checked. However this
9603 FUNCTION_DECL which is the desired context for access checking
9604 is not built yet. We solve this chicken-and-egg problem by
9605 deferring all checks until we have the FUNCTION_DECL. */
9606 push_deferring_access_checks (dk_deferred);
9607
9608 /* Although PROCESSING_TEMPLATE_DECL may be true at this point
9609 (because, for example, we have encountered a non-dependent
9610 function call in the body of a template function and must now
9611 determine which of several overloaded functions will be called),
9612 within the instantiation itself we are not processing a
9613 template. */
9614 saved_processing_template_decl = processing_template_decl;
9615 processing_template_decl = 0;
9616 /* Substitute template parameters to obtain the specialization. */
9617 fndecl = tsubst (DECL_TEMPLATE_RESULT (gen_tmpl),
9618 targ_ptr, complain, gen_tmpl);
9619 processing_template_decl = saved_processing_template_decl;
9620 if (fndecl == error_mark_node)
9621 return error_mark_node;
9622
9623 /* Now we know the specialization, compute access previously
9624 deferred. */
9625 push_access_scope (fndecl);
9626 perform_deferred_access_checks ();
9627 pop_access_scope (fndecl);
9628 pop_deferring_access_checks ();
9629
9630 /* The DECL_TI_TEMPLATE should always be the immediate parent
9631 template, not the most general template. */
9632 DECL_TI_TEMPLATE (fndecl) = tmpl;
9633
9634 /* If we've just instantiated the main entry point for a function,
9635 instantiate all the alternate entry points as well. We do this
9636 by cloning the instantiation of the main entry point, not by
9637 instantiating the template clones. */
9638 if (TREE_CHAIN (gen_tmpl) && DECL_CLONED_FUNCTION_P (TREE_CHAIN (gen_tmpl)))
9639 clone_function_decl (fndecl, /*update_method_vec_p=*/0);
9640
9641 return fndecl;
9642}
9643
9644/* The FN is a TEMPLATE_DECL for a function. The ARGS are the
9645 arguments that are being used when calling it. TARGS is a vector
9646 into which the deduced template arguments are placed.
9647
9648 Return zero for success, 2 for an incomplete match that doesn't resolve
9649 all the types, and 1 for complete failure. An error message will be
9650 printed only for an incomplete match.
9651
9652 If FN is a conversion operator, or we are trying to produce a specific
9653 specialization, RETURN_TYPE is the return type desired.
9654
9655 The EXPLICIT_TARGS are explicit template arguments provided via a
9656 template-id.
9657
9658 The parameter STRICT is one of:
9659
9660 DEDUCE_CALL:
9661 We are deducing arguments for a function call, as in
9662 [temp.deduct.call].
9663
9664 DEDUCE_CONV:
9665 We are deducing arguments for a conversion function, as in
9666 [temp.deduct.conv].
9667
9668 DEDUCE_EXACT:
9669 We are deducing arguments when doing an explicit instantiation
9670 as in [temp.explicit], when determining an explicit specialization
9671 as in [temp.expl.spec], or when taking the address of a function
9672 template, as in [temp.deduct.funcaddr]. */
9673
9674int
9675fn_type_unification (tree fn,
9676 tree explicit_targs,
9677 tree targs,
9678 tree args,
9679 tree return_type,
9680 unification_kind_t strict,
9681 int flags)
9682{
9683 tree parms;
9684 tree fntype;
9685 int result;
9686
9687 gcc_assert (TREE_CODE (fn) == TEMPLATE_DECL);
9688
9689 fntype = TREE_TYPE (fn);
9690 if (explicit_targs)
9691 {
9692 /* [temp.deduct]
9693
9694 The specified template arguments must match the template
9695 parameters in kind (i.e., type, nontype, template), and there
9696 must not be more arguments than there are parameters;
9697 otherwise type deduction fails.
9698
9699 Nontype arguments must match the types of the corresponding
9700 nontype template parameters, or must be convertible to the
9701 types of the corresponding nontype parameters as specified in
9702 _temp.arg.nontype_, otherwise type deduction fails.
9703
9704 All references in the function type of the function template
9705 to the corresponding template parameters are replaced by the
9706 specified template argument values. If a substitution in a
9707 template parameter or in the function type of the function
9708 template results in an invalid type, type deduction fails. */
9709 int i;
9710 tree converted_args;
9711 bool incomplete;
9712
9713 if (explicit_targs == error_mark_node)
9714 return 1;
9715
9716 converted_args
9717 = (coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn),
9718 explicit_targs, NULL_TREE, tf_none,
9719 /*require_all_args=*/false,
9720 /*use_default_args=*/false));
9721 if (converted_args == error_mark_node)
9722 return 1;
9723
9724 /* Substitute the explicit args into the function type. This is
9725 necessary so that, for instance, explicitly declared function
9726 arguments can match null pointed constants. If we were given
9727 an incomplete set of explicit args, we must not do semantic
9728 processing during substitution as we could create partial
9729 instantiations. */
9730 incomplete = NUM_TMPL_ARGS (explicit_targs) != NUM_TMPL_ARGS (targs);
9731 processing_template_decl += incomplete;
9732 fntype = tsubst (fntype, converted_args, tf_none, NULL_TREE);
9733 processing_template_decl -= incomplete;
9734
9735 if (fntype == error_mark_node)
9736 return 1;
9737
9738 /* Place the explicitly specified arguments in TARGS. */
9739 for (i = NUM_TMPL_ARGS (converted_args); i--;)
9740 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (converted_args, i);
9741 }
9742
9743 /* Never do unification on the 'this' parameter. */
9744 parms = skip_artificial_parms_for (fn, TYPE_ARG_TYPES (fntype));
9745
9746 if (return_type)
9747 {
9748 parms = tree_cons (NULL_TREE, TREE_TYPE (fntype), parms);
9749 args = tree_cons (NULL_TREE, return_type, args);
9750 }
9751
9752 /* We allow incomplete unification without an error message here
9753 because the standard doesn't seem to explicitly prohibit it. Our
9754 callers must be ready to deal with unification failures in any
9755 event. */
9756 result = type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn),
9757 targs, parms, args, /*subr=*/0,
9758 strict, flags);
9759
9760 if (result == 0)
9761 /* All is well so far. Now, check:
9762
9763 [temp.deduct]
9764
9765 When all template arguments have been deduced, all uses of
9766 template parameters in nondeduced contexts are replaced with
9767 the corresponding deduced argument values. If the
9768 substitution results in an invalid type, as described above,
9769 type deduction fails. */
9770 if (tsubst (TREE_TYPE (fn), targs, tf_none, NULL_TREE)
9771 == error_mark_node)
9772 return 1;
9773
9774 return result;
9775}
9776
9777/* Adjust types before performing type deduction, as described in
9778 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
9779 sections are symmetric. PARM is the type of a function parameter
9780 or the return type of the conversion function. ARG is the type of
9781 the argument passed to the call, or the type of the value
9782 initialized with the result of the conversion function. */
9783
9784static int
9785maybe_adjust_types_for_deduction (unification_kind_t strict,
9786 tree* parm,
9787 tree* arg)
9788{
9789 int result = 0;
9790
9791 switch (strict)
9792 {
9793 case DEDUCE_CALL:
9794 break;
9795
9796 case DEDUCE_CONV:
9797 {
9798 /* Swap PARM and ARG throughout the remainder of this
9799 function; the handling is precisely symmetric since PARM
9800 will initialize ARG rather than vice versa. */
9801 tree* temp = parm;
9802 parm = arg;
9803 arg = temp;
9804 break;
9805 }
9806
9807 case DEDUCE_EXACT:
9808 /* There is nothing to do in this case. */
9809 return 0;
9810
9811 default:
9812 gcc_unreachable ();
9813 }
9814
9815 if (TREE_CODE (*parm) != REFERENCE_TYPE)
9816 {
9817 /* [temp.deduct.call]
9818
9819 If P is not a reference type:
9820
9821 --If A is an array type, the pointer type produced by the
9822 array-to-pointer standard conversion (_conv.array_) is
9823 used in place of A for type deduction; otherwise,
9824
9825 --If A is a function type, the pointer type produced by
9826 the function-to-pointer standard conversion
9827 (_conv.func_) is used in place of A for type deduction;
9828 otherwise,
9829
9830 --If A is a cv-qualified type, the top level
9831 cv-qualifiers of A's type are ignored for type
9832 deduction. */
9833 if (TREE_CODE (*arg) == ARRAY_TYPE)
9834 *arg = build_pointer_type (TREE_TYPE (*arg));
9835 else if (TREE_CODE (*arg) == FUNCTION_TYPE)
9836 *arg = build_pointer_type (*arg);
9837 else
9838 *arg = TYPE_MAIN_VARIANT (*arg);
9839 }
9840
9841 /* [temp.deduct.call]
9842
9843 If P is a cv-qualified type, the top level cv-qualifiers
9844 of P's type are ignored for type deduction. If P is a
9845 reference type, the type referred to by P is used for
9846 type deduction. */
9847 *parm = TYPE_MAIN_VARIANT (*parm);
9848 if (TREE_CODE (*parm) == REFERENCE_TYPE)
9849 {
9850 *parm = TREE_TYPE (*parm);
9851 result |= UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
9852 }
9853
9854 /* DR 322. For conversion deduction, remove a reference type on parm
9855 too (which has been swapped into ARG). */
9856 if (strict == DEDUCE_CONV && TREE_CODE (*arg) == REFERENCE_TYPE)
9857 *arg = TREE_TYPE (*arg);
9858
9859 return result;
9860}
9861
9862/* Most parms like fn_type_unification.
9863
9864 If SUBR is 1, we're being called recursively (to unify the
9865 arguments of a function or method parameter of a function
9866 template). */
9867
9868static int
9869type_unification_real (tree tparms,
9870 tree targs,
9871 tree xparms,
9872 tree xargs,
9873 int subr,
9874 unification_kind_t strict,
9875 int flags)
9876{
9877 tree parm, arg;
9878 int i;
9879 int ntparms = TREE_VEC_LENGTH (tparms);
9880 int sub_strict;
9881 int saw_undeduced = 0;
9882 tree parms, args;
9883
9884 gcc_assert (TREE_CODE (tparms) == TREE_VEC);
9885 gcc_assert (xparms == NULL_TREE || TREE_CODE (xparms) == TREE_LIST);
9886 gcc_assert (!xargs || TREE_CODE (xargs) == TREE_LIST);
9887 gcc_assert (ntparms > 0);
9888
9889 switch (strict)
9890 {
9891 case DEDUCE_CALL:
9892 sub_strict = (UNIFY_ALLOW_OUTER_LEVEL | UNIFY_ALLOW_MORE_CV_QUAL
9893 | UNIFY_ALLOW_DERIVED);
9894 break;
9895
9896 case DEDUCE_CONV:
9897 sub_strict = UNIFY_ALLOW_LESS_CV_QUAL;
9898 break;
9899
9900 case DEDUCE_EXACT:
9901 sub_strict = UNIFY_ALLOW_NONE;
9902 break;
9903
9904 default:
9905 gcc_unreachable ();
9906 }
9907
9908 again:
9909 parms = xparms;
9910 args = xargs;
9911
9912 while (parms && parms != void_list_node
9913 && args && args != void_list_node)
9914 {
9915 parm = TREE_VALUE (parms);
9916 parms = TREE_CHAIN (parms);
9917 arg = TREE_VALUE (args);
9918 args = TREE_CHAIN (args);
9919
9920 if (arg == error_mark_node)
9921 return 1;
9922 if (arg == unknown_type_node)
9923 /* We can't deduce anything from this, but we might get all the
9924 template args from other function args. */
9925 continue;
9926
9927 /* Conversions will be performed on a function argument that
9928 corresponds with a function parameter that contains only
9929 non-deducible template parameters and explicitly specified
9930 template parameters. */
9931 if (!uses_template_parms (parm))
9932 {
9933 tree type;
9934
9935 if (!TYPE_P (arg))
9936 type = TREE_TYPE (arg);
9937 else
9938 type = arg;
9939
9940 if (same_type_p (parm, type))
9941 continue;
9942 if (strict != DEDUCE_EXACT
9943 && can_convert_arg (parm, type, TYPE_P (arg) ? NULL_TREE : arg,
9944 flags))
9945 continue;
9946
9947 return 1;
9948 }
9949
9950 if (!TYPE_P (arg))
9951 {
9952 gcc_assert (TREE_TYPE (arg) != NULL_TREE);
9953 if (type_unknown_p (arg))
9954 {
9955 /* [temp.deduct.type]
9956
9957 A template-argument can be deduced from a pointer to
9958 function or pointer to member function argument if
9959 the set of overloaded functions does not contain
9960 function templates and at most one of a set of
9961 overloaded functions provides a unique match. */
9962 if (resolve_overloaded_unification
9963 (tparms, targs, parm, arg, strict, sub_strict))
9964 continue;
9965
9966 return 1;
9967 }
9968 arg = unlowered_expr_type (arg);
9969 if (arg == error_mark_node)
9970 return 1;
9971 }
9972
9973 {
9974 int arg_strict = sub_strict;
9975
9976 if (!subr)
9977 arg_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg);
9978
9979 if (unify (tparms, targs, parm, arg, arg_strict))
9980 return 1;
9981 }
9982 }
9983
9984 /* Fail if we've reached the end of the parm list, and more args
9985 are present, and the parm list isn't variadic. */
9986 if (args && args != void_list_node && parms == void_list_node)
9987 return 1;
9988 /* Fail if parms are left and they don't have default values. */
9989 if (parms && parms != void_list_node
9990 && TREE_PURPOSE (parms) == NULL_TREE)
9991 return 1;
9992
9993 if (!subr)
9994 for (i = 0; i < ntparms; i++)
9995 if (!TREE_VEC_ELT (targs, i))
9996 {
9997 tree tparm;
9998
9999 if (TREE_VEC_ELT (tparms, i) == error_mark_node)
10000 continue;
10001
10002 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
10003
10004 /* If this is an undeduced nontype parameter that depends on
10005 a type parameter, try another pass; its type may have been
10006 deduced from a later argument than the one from which
10007 this parameter can be deduced. */
10008 if (TREE_CODE (tparm) == PARM_DECL
10009 && uses_template_parms (TREE_TYPE (tparm))
10010 && !saw_undeduced++)
10011 goto again;
10012
10013 return 2;
10014 }
10015
10016 return 0;
10017}
10018
10019/* Subroutine of type_unification_real. Args are like the variables
10020 at the call site. ARG is an overloaded function (or template-id);
10021 we try deducing template args from each of the overloads, and if
10022 only one succeeds, we go with that. Modifies TARGS and returns
10023 true on success. */
10024
10025static bool
10026resolve_overloaded_unification (tree tparms,
10027 tree targs,
10028 tree parm,
10029 tree arg,
10030 unification_kind_t strict,
10031 int sub_strict)
10032{
10033 tree tempargs = copy_node (targs);
10034 int good = 0;
10035 bool addr_p;
10036
10037 if (TREE_CODE (arg) == ADDR_EXPR)
10038 {
10039 arg = TREE_OPERAND (arg, 0);
10040 addr_p = true;
10041 }
10042 else
10043 addr_p = false;
10044
10045 if (TREE_CODE (arg) == COMPONENT_REF)
10046 /* Handle `&x' where `x' is some static or non-static member
10047 function name. */
10048 arg = TREE_OPERAND (arg, 1);
10049
10050 if (TREE_CODE (arg) == OFFSET_REF)
10051 arg = TREE_OPERAND (arg, 1);
10052
10053 /* Strip baselink information. */
10054 if (BASELINK_P (arg))
10055 arg = BASELINK_FUNCTIONS (arg);
10056
10057 if (TREE_CODE (arg) == TEMPLATE_ID_EXPR)
10058 {
10059 /* If we got some explicit template args, we need to plug them into
10060 the affected templates before we try to unify, in case the
10061 explicit args will completely resolve the templates in question. */
10062
10063 tree expl_subargs = TREE_OPERAND (arg, 1);
10064 arg = TREE_OPERAND (arg, 0);
10065
10066 for (; arg; arg = OVL_NEXT (arg))
10067 {
10068 tree fn = OVL_CURRENT (arg);
10069 tree subargs, elem;
10070
10071 if (TREE_CODE (fn) != TEMPLATE_DECL)
10072 continue;
10073
10074 subargs = get_bindings (fn, DECL_TEMPLATE_RESULT (fn),
10075 expl_subargs, /*check_ret=*/false);
10076 if (subargs)
10077 {
10078 elem = tsubst (TREE_TYPE (fn), subargs, tf_none, NULL_TREE);
10079 good += try_one_overload (tparms, targs, tempargs, parm,
10080 elem, strict, sub_strict, addr_p);
10081 }
10082 }
10083 }
10084 else if (TREE_CODE (arg) != OVERLOAD
10085 && TREE_CODE (arg) != FUNCTION_DECL)
10086 /* If ARG is, for example, "(0, &f)" then its type will be unknown
10087 -- but the deduction does not succeed because the expression is
10088 not just the function on its own. */
10089 return false;
10090 else
10091 for (; arg; arg = OVL_NEXT (arg))
10092 good += try_one_overload (tparms, targs, tempargs, parm,
10093 TREE_TYPE (OVL_CURRENT (arg)),
10094 strict, sub_strict, addr_p);
10095
10096 /* [temp.deduct.type] A template-argument can be deduced from a pointer
10097 to function or pointer to member function argument if the set of
10098 overloaded functions does not contain function templates and at most
10099 one of a set of overloaded functions provides a unique match.
10100
10101 So if we found multiple possibilities, we return success but don't
10102 deduce anything. */
10103
10104 if (good == 1)
10105 {
10106 int i = TREE_VEC_LENGTH (targs);
10107 for (; i--; )
10108 if (TREE_VEC_ELT (tempargs, i))
10109 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (tempargs, i);
10110 }
10111 if (good)
10112 return true;
10113
10114 return false;
10115}
10116
10117/* Subroutine of resolve_overloaded_unification; does deduction for a single
10118 overload. Fills TARGS with any deduced arguments, or error_mark_node if
10119 different overloads deduce different arguments for a given parm.
10120 ADDR_P is true if the expression for which deduction is being
10121 performed was of the form "& fn" rather than simply "fn".
10122
10123 Returns 1 on success. */
10124
10125static int
10126try_one_overload (tree tparms,
10127 tree orig_targs,
10128 tree targs,
10129 tree parm,
10130 tree arg,
10131 unification_kind_t strict,
10132 int sub_strict,
10133 bool addr_p)
10134{
10135 int nargs;
10136 tree tempargs;
10137 int i;
10138
10139 /* [temp.deduct.type] A template-argument can be deduced from a pointer
10140 to function or pointer to member function argument if the set of
10141 overloaded functions does not contain function templates and at most
10142 one of a set of overloaded functions provides a unique match.
10143
10144 So if this is a template, just return success. */
10145
10146 if (uses_template_parms (arg))
10147 return 1;
10148
10149 if (TREE_CODE (arg) == METHOD_TYPE)
10150 arg = build_ptrmemfunc_type (build_pointer_type (arg));
10151 else if (addr_p)
10152 arg = build_pointer_type (arg);
10153
10154 sub_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg);
10155
10156 /* We don't copy orig_targs for this because if we have already deduced
10157 some template args from previous args, unify would complain when we
10158 try to deduce a template parameter for the same argument, even though
10159 there isn't really a conflict. */
10160 nargs = TREE_VEC_LENGTH (targs);
10161 tempargs = make_tree_vec (nargs);
10162
10163 if (unify (tparms, tempargs, parm, arg, sub_strict) != 0)
10164 return 0;
10165
10166 /* First make sure we didn't deduce anything that conflicts with
10167 explicitly specified args. */
10168 for (i = nargs; i--; )
10169 {
10170 tree elt = TREE_VEC_ELT (tempargs, i);
10171 tree oldelt = TREE_VEC_ELT (orig_targs, i);
10172
10173 if (!elt)
10174 /*NOP*/;
10175 else if (uses_template_parms (elt))
10176 /* Since we're unifying against ourselves, we will fill in
10177 template args used in the function parm list with our own
10178 template parms. Discard them. */
10179 TREE_VEC_ELT (tempargs, i) = NULL_TREE;
10180 else if (oldelt && !template_args_equal (oldelt, elt))
10181 return 0;
10182 }
10183
10184 for (i = nargs; i--; )
10185 {
10186 tree elt = TREE_VEC_ELT (tempargs, i);
10187
10188 if (elt)
10189 TREE_VEC_ELT (targs, i) = elt;
10190 }
10191
10192 return 1;
10193}
10194
10195/* PARM is a template class (perhaps with unbound template
10196 parameters). ARG is a fully instantiated type. If ARG can be
10197 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
10198 TARGS are as for unify. */
10199
10200static tree
10201try_class_unification (tree tparms, tree targs, tree parm, tree arg)
10202{
10203 tree copy_of_targs;
10204
10205 if (!CLASSTYPE_TEMPLATE_INFO (arg)
10206 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg))
10207 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm))))
10208 return NULL_TREE;
10209
10210 /* We need to make a new template argument vector for the call to
10211 unify. If we used TARGS, we'd clutter it up with the result of
10212 the attempted unification, even if this class didn't work out.
10213 We also don't want to commit ourselves to all the unifications
10214 we've already done, since unification is supposed to be done on
10215 an argument-by-argument basis. In other words, consider the
10216 following pathological case:
10217
10218 template <int I, int J, int K>
10219 struct S {};
10220
10221 template <int I, int J>
10222 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
10223
10224 template <int I, int J, int K>
10225 void f(S<I, J, K>, S<I, I, I>);
10226
10227 void g() {
10228 S<0, 0, 0> s0;
10229 S<0, 1, 2> s2;
10230
10231 f(s0, s2);
10232 }
10233
10234 Now, by the time we consider the unification involving `s2', we
10235 already know that we must have `f<0, 0, 0>'. But, even though
10236 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
10237 because there are two ways to unify base classes of S<0, 1, 2>
10238 with S<I, I, I>. If we kept the already deduced knowledge, we
10239 would reject the possibility I=1. */
10240 copy_of_targs = make_tree_vec (TREE_VEC_LENGTH (targs));
10241
10242 /* If unification failed, we're done. */
10243 if (unify (tparms, copy_of_targs, CLASSTYPE_TI_ARGS (parm),
10244 CLASSTYPE_TI_ARGS (arg), UNIFY_ALLOW_NONE))
10245 return NULL_TREE;
10246
10247 return arg;
10248}
10249
10250/* Given a template type PARM and a class type ARG, find the unique
10251 base type in ARG that is an instance of PARM. We do not examine
10252 ARG itself; only its base-classes. If there is not exactly one
10253 appropriate base class, return NULL_TREE. PARM may be the type of
10254 a partial specialization, as well as a plain template type. Used
10255 by unify. */
10256
10257static tree
10258get_template_base (tree tparms, tree targs, tree parm, tree arg)
10259{
10260 tree rval = NULL_TREE;
10261 tree binfo;
10262
10263 gcc_assert (IS_AGGR_TYPE_CODE (TREE_CODE (arg)));
10264
10265 binfo = TYPE_BINFO (complete_type (arg));
10266 if (!binfo)
10267 /* The type could not be completed. */
10268 return NULL_TREE;
10269
10270 /* Walk in inheritance graph order. The search order is not
10271 important, and this avoids multiple walks of virtual bases. */
10272 for (binfo = TREE_CHAIN (binfo); binfo; binfo = TREE_CHAIN (binfo))
10273 {
10274 tree r = try_class_unification (tparms, targs, parm, BINFO_TYPE (binfo));
10275
10276 if (r)
10277 {
10278 /* If there is more than one satisfactory baseclass, then:
10279
10280 [temp.deduct.call]
10281
10282 If they yield more than one possible deduced A, the type
10283 deduction fails.
10284
10285 applies. */
10286 if (rval && !same_type_p (r, rval))
10287 return NULL_TREE;
10288
10289 rval = r;
10290 }
10291 }
10292
10293 return rval;
10294}
10295
10296/* Returns the level of DECL, which declares a template parameter. */
10297
10298static int
10299template_decl_level (tree decl)
10300{
10301 switch (TREE_CODE (decl))
10302 {
10303 case TYPE_DECL:
10304 case TEMPLATE_DECL:
10305 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl));
10306
10307 case PARM_DECL:
10308 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl));
10309
10310 default:
10311 gcc_unreachable ();
10312 }
10313 return 0;
10314}
10315
10316/* Decide whether ARG can be unified with PARM, considering only the
10317 cv-qualifiers of each type, given STRICT as documented for unify.
10318 Returns nonzero iff the unification is OK on that basis. */
10319
10320static int
10321check_cv_quals_for_unify (int strict, tree arg, tree parm)
10322{
10323 int arg_quals = cp_type_quals (arg);
10324 int parm_quals = cp_type_quals (parm);
10325
10326 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
10327 && !(strict & UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
10328 {
10329 /* Although a CVR qualifier is ignored when being applied to a
10330 substituted template parameter ([8.3.2]/1 for example), that
10331 does not apply during deduction [14.8.2.4]/1, (even though
10332 that is not explicitly mentioned, [14.8.2.4]/9 indicates
10333 this). Except when we're allowing additional CV qualifiers
10334 at the outer level [14.8.2.1]/3,1st bullet. */
10335 if ((TREE_CODE (arg) == REFERENCE_TYPE
10336 || TREE_CODE (arg) == FUNCTION_TYPE
10337 || TREE_CODE (arg) == METHOD_TYPE)
10338 && (parm_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)))
10339 return 0;
10340
10341 if ((!POINTER_TYPE_P (arg) && TREE_CODE (arg) != TEMPLATE_TYPE_PARM)
10342 && (parm_quals & TYPE_QUAL_RESTRICT))
10343 return 0;
10344 }
10345
10346 if (!(strict & (UNIFY_ALLOW_MORE_CV_QUAL | UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
10347 && (arg_quals & parm_quals) != parm_quals)
10348 return 0;
10349
10350 if (!(strict & (UNIFY_ALLOW_LESS_CV_QUAL | UNIFY_ALLOW_OUTER_LESS_CV_QUAL))
10351 && (parm_quals & arg_quals) != arg_quals)
10352 return 0;
10353
10354 return 1;
10355}
10356
10357/* Deduce the value of template parameters. TPARMS is the (innermost)
10358 set of template parameters to a template. TARGS is the bindings
10359 for those template parameters, as determined thus far; TARGS may
10360 include template arguments for outer levels of template parameters
10361 as well. PARM is a parameter to a template function, or a
10362 subcomponent of that parameter; ARG is the corresponding argument.
10363 This function attempts to match PARM with ARG in a manner
10364 consistent with the existing assignments in TARGS. If more values
10365 are deduced, then TARGS is updated.
10366
10367 Returns 0 if the type deduction succeeds, 1 otherwise. The
10368 parameter STRICT is a bitwise or of the following flags:
10369
10370 UNIFY_ALLOW_NONE:
10371 Require an exact match between PARM and ARG.
10372 UNIFY_ALLOW_MORE_CV_QUAL:
10373 Allow the deduced ARG to be more cv-qualified (by qualification
10374 conversion) than ARG.
10375 UNIFY_ALLOW_LESS_CV_QUAL:
10376 Allow the deduced ARG to be less cv-qualified than ARG.
10377 UNIFY_ALLOW_DERIVED:
10378 Allow the deduced ARG to be a template base class of ARG,
10379 or a pointer to a template base class of the type pointed to by
10380 ARG.
10381 UNIFY_ALLOW_INTEGER:
10382 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
10383 case for more information.
10384 UNIFY_ALLOW_OUTER_LEVEL:
10385 This is the outermost level of a deduction. Used to determine validity
10386 of qualification conversions. A valid qualification conversion must
10387 have const qualified pointers leading up to the inner type which
10388 requires additional CV quals, except at the outer level, where const
10389 is not required [conv.qual]. It would be normal to set this flag in
10390 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
10391 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
10392 This is the outermost level of a deduction, and PARM can be more CV
10393 qualified at this point.
10394 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
10395 This is the outermost level of a deduction, and PARM can be less CV
10396 qualified at this point. */
10397
10398static int
10399unify (tree tparms, tree targs, tree parm, tree arg, int strict)
10400{
10401 int idx;
10402 tree targ;
10403 tree tparm;
10404 int strict_in = strict;
10405
10406 /* I don't think this will do the right thing with respect to types.
10407 But the only case I've seen it in so far has been array bounds, where
10408 signedness is the only information lost, and I think that will be
10409 okay. */
10410 while (TREE_CODE (parm) == NOP_EXPR)
10411 parm = TREE_OPERAND (parm, 0);
10412
10413 if (arg == error_mark_node)
10414 return 1;
10415 if (arg == unknown_type_node)
10416 /* We can't deduce anything from this, but we might get all the
10417 template args from other function args. */
10418 return 0;
10419
10420 /* If PARM uses template parameters, then we can't bail out here,
10421 even if ARG == PARM, since we won't record unifications for the
10422 template parameters. We might need them if we're trying to
10423 figure out which of two things is more specialized. */
10424 if (arg == parm && !uses_template_parms (parm))
10425 return 0;
10426
10427 /* Immediately reject some pairs that won't unify because of
10428 cv-qualification mismatches. */
10429 if (TREE_CODE (arg) == TREE_CODE (parm)
10430 && TYPE_P (arg)
10431 /* It is the elements of the array which hold the cv quals of an array
10432 type, and the elements might be template type parms. We'll check
10433 when we recurse. */
10434 && TREE_CODE (arg) != ARRAY_TYPE
10435 /* We check the cv-qualifiers when unifying with template type
10436 parameters below. We want to allow ARG `const T' to unify with
10437 PARM `T' for example, when computing which of two templates
10438 is more specialized, for example. */
10439 && TREE_CODE (arg) != TEMPLATE_TYPE_PARM
10440 && !check_cv_quals_for_unify (strict_in, arg, parm))
10441 return 1;
10442
10443 if (!(strict & UNIFY_ALLOW_OUTER_LEVEL)
10444 && TYPE_P (parm) && !CP_TYPE_CONST_P (parm))
10445 strict &= ~UNIFY_ALLOW_MORE_CV_QUAL;
10446 strict &= ~UNIFY_ALLOW_OUTER_LEVEL;
10447 strict &= ~UNIFY_ALLOW_DERIVED;
10448 strict &= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
10449 strict &= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL;
10450
10451 switch (TREE_CODE (parm))
10452 {
10453 case TYPENAME_TYPE:
10454 case SCOPE_REF:
10455 case UNBOUND_CLASS_TEMPLATE:
10456 /* In a type which contains a nested-name-specifier, template
10457 argument values cannot be deduced for template parameters used
10458 within the nested-name-specifier. */
10459 return 0;
10460
10461 case TEMPLATE_TYPE_PARM:
10462 case TEMPLATE_TEMPLATE_PARM:
10463 case BOUND_TEMPLATE_TEMPLATE_PARM:
10464 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
|
| 10465 if (tparm == error_mark_node)
10466 return 1;
|
10456
10457 if (TEMPLATE_TYPE_LEVEL (parm)
10458 != template_decl_level (tparm))
10459 /* The PARM is not one we're trying to unify. Just check
10460 to see if it matches ARG. */
10461 return (TREE_CODE (arg) == TREE_CODE (parm)
10462 && same_type_p (parm, arg)) ? 0 : 1;
10463 idx = TEMPLATE_TYPE_IDX (parm);
10464 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
10465 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, idx));
10466
10467 /* Check for mixed types and values. */
10468 if ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
10469 && TREE_CODE (tparm) != TYPE_DECL)
10470 || (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
10471 && TREE_CODE (tparm) != TEMPLATE_DECL))
10472 return 1;
10473
10474 if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
10475 {
10476 /* ARG must be constructed from a template class or a template
10477 template parameter. */
10478 if (TREE_CODE (arg) != BOUND_TEMPLATE_TEMPLATE_PARM
10479 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg))
10480 return 1;
10481
10482 {
10483 tree parmvec = TYPE_TI_ARGS (parm);
10484 tree argvec = INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg));
10485 tree argtmplvec
10486 = DECL_INNERMOST_TEMPLATE_PARMS (TYPE_TI_TEMPLATE (arg));
10487 int i;
10488
10489 /* The resolution to DR150 makes clear that default
10490 arguments for an N-argument may not be used to bind T
10491 to a template template parameter with fewer than N
10492 parameters. It is not safe to permit the binding of
10493 default arguments as an extension, as that may change
10494 the meaning of a conforming program. Consider:
10495
10496 struct Dense { static const unsigned int dim = 1; };
10497
10498 template <template <typename> class View,
10499 typename Block>
10500 void operator+(float, View<Block> const&);
10501
10502 template <typename Block,
10503 unsigned int Dim = Block::dim>
10504 struct Lvalue_proxy { operator float() const; };
10505
10506 void
10507 test_1d (void) {
10508 Lvalue_proxy<Dense> p;
10509 float b;
10510 b + p;
10511 }
10512
10513 Here, if Lvalue_proxy is permitted to bind to View, then
10514 the global operator+ will be used; if they are not, the
10515 Lvalue_proxy will be converted to float. */
10516 if (coerce_template_parms (argtmplvec, parmvec,
10517 TYPE_TI_TEMPLATE (parm),
10518 tf_none,
10519 /*require_all_args=*/true,
10520 /*use_default_args=*/false)
10521 == error_mark_node)
10522 return 1;
10523
10524 /* Deduce arguments T, i from TT<T> or TT<i>.
10525 We check each element of PARMVEC and ARGVEC individually
10526 rather than the whole TREE_VEC since they can have
10527 different number of elements. */
10528
10529 for (i = 0; i < TREE_VEC_LENGTH (parmvec); ++i)
10530 {
10531 if (unify (tparms, targs,
10532 TREE_VEC_ELT (parmvec, i),
10533 TREE_VEC_ELT (argvec, i),
10534 UNIFY_ALLOW_NONE))
10535 return 1;
10536 }
10537 }
10538 arg = TYPE_TI_TEMPLATE (arg);
10539
10540 /* Fall through to deduce template name. */
10541 }
10542
10543 if (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
10544 || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
10545 {
10546 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
10547
10548 /* Simple cases: Value already set, does match or doesn't. */
10549 if (targ != NULL_TREE && template_args_equal (targ, arg))
10550 return 0;
10551 else if (targ)
10552 return 1;
10553 }
10554 else
10555 {
10556 /* If PARM is `const T' and ARG is only `int', we don't have
10557 a match unless we are allowing additional qualification.
10558 If ARG is `const int' and PARM is just `T' that's OK;
10559 that binds `const int' to `T'. */
10560 if (!check_cv_quals_for_unify (strict_in | UNIFY_ALLOW_LESS_CV_QUAL,
10561 arg, parm))
10562 return 1;
10563
10564 /* Consider the case where ARG is `const volatile int' and
10565 PARM is `const T'. Then, T should be `volatile int'. */
10566 arg = cp_build_qualified_type_real
10567 (arg, cp_type_quals (arg) & ~cp_type_quals (parm), tf_none);
10568 if (arg == error_mark_node)
10569 return 1;
10570
10571 /* Simple cases: Value already set, does match or doesn't. */
10572 if (targ != NULL_TREE && same_type_p (targ, arg))
10573 return 0;
10574 else if (targ)
10575 return 1;
10576
10577 /* Make sure that ARG is not a variable-sized array. (Note
10578 that were talking about variable-sized arrays (like
10579 `int[n]'), rather than arrays of unknown size (like
10580 `int[]').) We'll get very confused by such a type since
10581 the bound of the array will not be computable in an
10582 instantiation. Besides, such types are not allowed in
10583 ISO C++, so we can do as we please here. */
10584 if (variably_modified_type_p (arg, NULL_TREE))
10585 return 1;
10586 }
10587
10588 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
10589 return 0;
10590
10591 case TEMPLATE_PARM_INDEX:
10592 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
10593 if (tparm == error_mark_node)
10594 return 1;
10595
10596 if (TEMPLATE_PARM_LEVEL (parm)
10597 != template_decl_level (tparm))
10598 /* The PARM is not one we're trying to unify. Just check
10599 to see if it matches ARG. */
10600 return !(TREE_CODE (arg) == TREE_CODE (parm)
10601 && cp_tree_equal (parm, arg));
10602
10603 idx = TEMPLATE_PARM_IDX (parm);
10604 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
10605
10606 if (targ)
10607 return !cp_tree_equal (targ, arg);
10608
10609 /* [temp.deduct.type] If, in the declaration of a function template
10610 with a non-type template-parameter, the non-type
10611 template-parameter is used in an expression in the function
10612 parameter-list and, if the corresponding template-argument is
10613 deduced, the template-argument type shall match the type of the
10614 template-parameter exactly, except that a template-argument
10615 deduced from an array bound may be of any integral type.
10616 The non-type parameter might use already deduced type parameters. */
10617 tparm = tsubst (TREE_TYPE (parm), targs, 0, NULL_TREE);
10618 if (!TREE_TYPE (arg))
10619 /* Template-parameter dependent expression. Just accept it for now.
10620 It will later be processed in convert_template_argument. */
10621 ;
10622 else if (same_type_p (TREE_TYPE (arg), tparm))
10623 /* OK */;
10624 else if ((strict & UNIFY_ALLOW_INTEGER)
10625 && (TREE_CODE (tparm) == INTEGER_TYPE
10626 || TREE_CODE (tparm) == BOOLEAN_TYPE))
10627 /* Convert the ARG to the type of PARM; the deduced non-type
10628 template argument must exactly match the types of the
10629 corresponding parameter. */
10630 arg = fold (build_nop (TREE_TYPE (parm), arg));
10631 else if (uses_template_parms (tparm))
10632 /* We haven't deduced the type of this parameter yet. Try again
10633 later. */
10634 return 0;
10635 else
10636 return 1;
10637
10638 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
10639 return 0;
10640
10641 case PTRMEM_CST:
10642 {
10643 /* A pointer-to-member constant can be unified only with
10644 another constant. */
10645 if (TREE_CODE (arg) != PTRMEM_CST)
10646 return 1;
10647
10648 /* Just unify the class member. It would be useless (and possibly
10649 wrong, depending on the strict flags) to unify also
10650 PTRMEM_CST_CLASS, because we want to be sure that both parm and
10651 arg refer to the same variable, even if through different
10652 classes. For instance:
10653
10654 struct A { int x; };
10655 struct B : A { };
10656
10657 Unification of &A::x and &B::x must succeed. */
10658 return unify (tparms, targs, PTRMEM_CST_MEMBER (parm),
10659 PTRMEM_CST_MEMBER (arg), strict);
10660 }
10661
10662 case POINTER_TYPE:
10663 {
10664 if (TREE_CODE (arg) != POINTER_TYPE)
10665 return 1;
10666
10667 /* [temp.deduct.call]
10668
10669 A can be another pointer or pointer to member type that can
10670 be converted to the deduced A via a qualification
10671 conversion (_conv.qual_).
10672
10673 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
10674 This will allow for additional cv-qualification of the
10675 pointed-to types if appropriate. */
10676
10677 if (TREE_CODE (TREE_TYPE (arg)) == RECORD_TYPE)
10678 /* The derived-to-base conversion only persists through one
10679 level of pointers. */
10680 strict |= (strict_in & UNIFY_ALLOW_DERIVED);
10681
10682 return unify (tparms, targs, TREE_TYPE (parm),
10683 TREE_TYPE (arg), strict);
10684 }
10685
10686 case REFERENCE_TYPE:
10687 if (TREE_CODE (arg) != REFERENCE_TYPE)
10688 return 1;
10689 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
10690 strict & UNIFY_ALLOW_MORE_CV_QUAL);
10691
10692 case ARRAY_TYPE:
10693 if (TREE_CODE (arg) != ARRAY_TYPE)
10694 return 1;
10695 if ((TYPE_DOMAIN (parm) == NULL_TREE)
10696 != (TYPE_DOMAIN (arg) == NULL_TREE))
10697 return 1;
10698 if (TYPE_DOMAIN (parm) != NULL_TREE)
10699 {
10700 tree parm_max;
10701 tree arg_max;
10702 bool parm_cst;
10703 bool arg_cst;
10704
10705 /* Our representation of array types uses "N - 1" as the
10706 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
10707 not an integer constant. We cannot unify arbitrarily
10708 complex expressions, so we eliminate the MINUS_EXPRs
10709 here. */
10710 parm_max = TYPE_MAX_VALUE (TYPE_DOMAIN (parm));
10711 parm_cst = TREE_CODE (parm_max) == INTEGER_CST;
10712 if (!parm_cst)
10713 {
10714 gcc_assert (TREE_CODE (parm_max) == MINUS_EXPR);
10715 parm_max = TREE_OPERAND (parm_max, 0);
10716 }
10717 arg_max = TYPE_MAX_VALUE (TYPE_DOMAIN (arg));
10718 arg_cst = TREE_CODE (arg_max) == INTEGER_CST;
10719 if (!arg_cst)
10720 {
10721 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
10722 trying to unify the type of a variable with the type
10723 of a template parameter. For example:
10724
10725 template <unsigned int N>
10726 void f (char (&) [N]);
10727 int g();
10728 void h(int i) {
10729 char a[g(i)];
10730 f(a);
10731 }
10732
10733 Here, the type of the ARG will be "int [g(i)]", and
10734 may be a SAVE_EXPR, etc. */
10735 if (TREE_CODE (arg_max) != MINUS_EXPR)
10736 return 1;
10737 arg_max = TREE_OPERAND (arg_max, 0);
10738 }
10739
10740 /* If only one of the bounds used a MINUS_EXPR, compensate
10741 by adding one to the other bound. */
10742 if (parm_cst && !arg_cst)
10743 parm_max = fold_build2 (PLUS_EXPR,
10744 integer_type_node,
10745 parm_max,
10746 integer_one_node);
10747 else if (arg_cst && !parm_cst)
10748 arg_max = fold_build2 (PLUS_EXPR,
10749 integer_type_node,
10750 arg_max,
10751 integer_one_node);
10752
10753 if (unify (tparms, targs, parm_max, arg_max, UNIFY_ALLOW_INTEGER))
10754 return 1;
10755 }
10756 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
10757 strict & UNIFY_ALLOW_MORE_CV_QUAL);
10758
10759 case REAL_TYPE:
10760 case COMPLEX_TYPE:
10761 case VECTOR_TYPE:
10762 case INTEGER_TYPE:
10763 case BOOLEAN_TYPE:
10764 case ENUMERAL_TYPE:
10765 case VOID_TYPE:
10766 if (TREE_CODE (arg) != TREE_CODE (parm))
10767 return 1;
10768
10769 /* We have already checked cv-qualification at the top of the
10770 function. */
10771 if (!same_type_ignoring_top_level_qualifiers_p (arg, parm))
10772 return 1;
10773
10774 /* As far as unification is concerned, this wins. Later checks
10775 will invalidate it if necessary. */
10776 return 0;
10777
10778 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
10779 /* Type INTEGER_CST can come from ordinary constant template args. */
10780 case INTEGER_CST:
10781 while (TREE_CODE (arg) == NOP_EXPR)
10782 arg = TREE_OPERAND (arg, 0);
10783
10784 if (TREE_CODE (arg) != INTEGER_CST)
10785 return 1;
10786 return !tree_int_cst_equal (parm, arg);
10787
10788 case TREE_VEC:
10789 {
10790 int i;
10791 if (TREE_CODE (arg) != TREE_VEC)
10792 return 1;
10793 if (TREE_VEC_LENGTH (parm) != TREE_VEC_LENGTH (arg))
10794 return 1;
10795 for (i = 0; i < TREE_VEC_LENGTH (parm); ++i)
10796 if (unify (tparms, targs,
10797 TREE_VEC_ELT (parm, i), TREE_VEC_ELT (arg, i),
10798 UNIFY_ALLOW_NONE))
10799 return 1;
10800 return 0;
10801 }
10802
10803 case RECORD_TYPE:
10804 case UNION_TYPE:
10805 if (TREE_CODE (arg) != TREE_CODE (parm))
10806 return 1;
10807
10808 if (TYPE_PTRMEMFUNC_P (parm))
10809 {
10810 if (!TYPE_PTRMEMFUNC_P (arg))
10811 return 1;
10812
10813 return unify (tparms, targs,
10814 TYPE_PTRMEMFUNC_FN_TYPE (parm),
10815 TYPE_PTRMEMFUNC_FN_TYPE (arg),
10816 strict);
10817 }
10818
10819 if (CLASSTYPE_TEMPLATE_INFO (parm))
10820 {
10821 tree t = NULL_TREE;
10822
10823 if (strict_in & UNIFY_ALLOW_DERIVED)
10824 {
10825 /* First, we try to unify the PARM and ARG directly. */
10826 t = try_class_unification (tparms, targs,
10827 parm, arg);
10828
10829 if (!t)
10830 {
10831 /* Fallback to the special case allowed in
10832 [temp.deduct.call]:
10833
10834 If P is a class, and P has the form
10835 template-id, then A can be a derived class of
10836 the deduced A. Likewise, if P is a pointer to
10837 a class of the form template-id, A can be a
10838 pointer to a derived class pointed to by the
10839 deduced A. */
10840 t = get_template_base (tparms, targs, parm, arg);
10841
10842 if (!t)
10843 return 1;
10844 }
10845 }
10846 else if (CLASSTYPE_TEMPLATE_INFO (arg)
10847 && (CLASSTYPE_TI_TEMPLATE (parm)
10848 == CLASSTYPE_TI_TEMPLATE (arg)))
10849 /* Perhaps PARM is something like S<U> and ARG is S<int>.
10850 Then, we should unify `int' and `U'. */
10851 t = arg;
10852 else
10853 /* There's no chance of unification succeeding. */
10854 return 1;
10855
10856 return unify (tparms, targs, CLASSTYPE_TI_ARGS (parm),
10857 CLASSTYPE_TI_ARGS (t), UNIFY_ALLOW_NONE);
10858 }
10859 else if (!same_type_ignoring_top_level_qualifiers_p (parm, arg))
10860 return 1;
10861 return 0;
10862
10863 case METHOD_TYPE:
10864 case FUNCTION_TYPE:
10865 if (TREE_CODE (arg) != TREE_CODE (parm))
10866 return 1;
10867
10868 /* CV qualifications for methods can never be deduced, they must
10869 match exactly. We need to check them explicitly here,
10870 because type_unification_real treats them as any other
10871 cvqualified parameter. */
10872 if (TREE_CODE (parm) == METHOD_TYPE
10873 && (!check_cv_quals_for_unify
10874 (UNIFY_ALLOW_NONE,
10875 TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (arg))),
10876 TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (parm))))))
10877 return 1;
10878
10879 if (unify (tparms, targs, TREE_TYPE (parm),
10880 TREE_TYPE (arg), UNIFY_ALLOW_NONE))
10881 return 1;
10882 return type_unification_real (tparms, targs, TYPE_ARG_TYPES (parm),
10883 TYPE_ARG_TYPES (arg), 1, DEDUCE_EXACT,
10884 LOOKUP_NORMAL);
10885
10886 case OFFSET_TYPE:
10887 /* Unify a pointer to member with a pointer to member function, which
10888 deduces the type of the member as a function type. */
10889 if (TYPE_PTRMEMFUNC_P (arg))
10890 {
10891 tree method_type;
10892 tree fntype;
10893 cp_cv_quals cv_quals;
10894
10895 /* Check top-level cv qualifiers */
10896 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE, arg, parm))
10897 return 1;
10898
10899 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
10900 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg), UNIFY_ALLOW_NONE))
10901 return 1;
10902
10903 /* Determine the type of the function we are unifying against. */
10904 method_type = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (arg));
10905 fntype =
10906 build_function_type (TREE_TYPE (method_type),
10907 TREE_CHAIN (TYPE_ARG_TYPES (method_type)));
10908
10909 /* Extract the cv-qualifiers of the member function from the
10910 implicit object parameter and place them on the function
10911 type to be restored later. */
10912 cv_quals =
10913 cp_type_quals(TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (method_type))));
10914 fntype = build_qualified_type (fntype, cv_quals);
10915 return unify (tparms, targs, TREE_TYPE (parm), fntype, strict);
10916 }
10917
10918 if (TREE_CODE (arg) != OFFSET_TYPE)
10919 return 1;
10920 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
10921 TYPE_OFFSET_BASETYPE (arg), UNIFY_ALLOW_NONE))
10922 return 1;
10923 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
10924 strict);
10925
10926 case CONST_DECL:
10927 if (DECL_TEMPLATE_PARM_P (parm))
10928 return unify (tparms, targs, DECL_INITIAL (parm), arg, strict);
10929 if (arg != integral_constant_value (parm))
10930 return 1;
10931 return 0;
10932
10933 case FIELD_DECL:
10934 case TEMPLATE_DECL:
10935 /* Matched cases are handled by the ARG == PARM test above. */
10936 return 1;
10937
10938 default:
10939 gcc_assert (EXPR_P (parm));
10940
10941 /* We must be looking at an expression. This can happen with
10942 something like:
10943
10944 template <int I>
10945 void foo(S<I>, S<I + 2>);
10946
10947 This is a "nondeduced context":
10948
10949 [deduct.type]
10950
10951 The nondeduced contexts are:
10952
10953 --A type that is a template-id in which one or more of
10954 the template-arguments is an expression that references
10955 a template-parameter.
10956
10957 In these cases, we assume deduction succeeded, but don't
10958 actually infer any unifications. */
10959
10960 if (!uses_template_parms (parm)
10961 && !template_args_equal (parm, arg))
10962 return 1;
10963 else
10964 return 0;
10965 }
10966}
10967
10968/* Note that DECL can be defined in this translation unit, if
10969 required. */
10970
10971static void
10972mark_definable (tree decl)
10973{
10974 tree clone;
10975 DECL_NOT_REALLY_EXTERN (decl) = 1;
10976 FOR_EACH_CLONE (clone, decl)
10977 DECL_NOT_REALLY_EXTERN (clone) = 1;
10978}
10979
10980/* Called if RESULT is explicitly instantiated, or is a member of an
10981 explicitly instantiated class. */
10982
10983void
10984mark_decl_instantiated (tree result, int extern_p)
10985{
10986 SET_DECL_EXPLICIT_INSTANTIATION (result);
10987
10988 /* If this entity has already been written out, it's too late to
10989 make any modifications. */
10990 if (TREE_ASM_WRITTEN (result))
10991 return;
10992
10993 if (TREE_CODE (result) != FUNCTION_DECL)
10994 /* The TREE_PUBLIC flag for function declarations will have been
10995 set correctly by tsubst. */
10996 TREE_PUBLIC (result) = 1;
10997
10998 /* This might have been set by an earlier implicit instantiation. */
10999 DECL_COMDAT (result) = 0;
11000
11001 if (extern_p)
11002 DECL_NOT_REALLY_EXTERN (result) = 0;
11003 else
11004 {
11005 mark_definable (result);
11006 /* Always make artificials weak. */
11007 if (DECL_ARTIFICIAL (result) && flag_weak)
11008 comdat_linkage (result);
11009 /* For WIN32 we also want to put explicit instantiations in
11010 linkonce sections. */
11011 else if (TREE_PUBLIC (result))
11012 maybe_make_one_only (result);
11013 }
11014
11015 /* If EXTERN_P, then this function will not be emitted -- unless
11016 followed by an explicit instantiation, at which point its linkage
11017 will be adjusted. If !EXTERN_P, then this function will be
11018 emitted here. In neither circumstance do we want
11019 import_export_decl to adjust the linkage. */
11020 DECL_INTERFACE_KNOWN (result) = 1;
11021}
11022
11023/* Given two function templates PAT1 and PAT2, return:
11024
11025 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
11026 -1 if PAT2 is more specialized than PAT1.
11027 0 if neither is more specialized.
11028
11029 LEN indicates the number of parameters we should consider
11030 (defaulted parameters should not be considered).
11031
11032 The 1998 std underspecified function template partial ordering, and
11033 DR214 addresses the issue. We take pairs of arguments, one from
11034 each of the templates, and deduce them against each other. One of
11035 the templates will be more specialized if all the *other*
11036 template's arguments deduce against its arguments and at least one
11037 of its arguments *does* *not* deduce against the other template's
11038 corresponding argument. Deduction is done as for class templates.
11039 The arguments used in deduction have reference and top level cv
11040 qualifiers removed. Iff both arguments were originally reference
11041 types *and* deduction succeeds in both directions, the template
11042 with the more cv-qualified argument wins for that pairing (if
11043 neither is more cv-qualified, they both are equal). Unlike regular
11044 deduction, after all the arguments have been deduced in this way,
11045 we do *not* verify the deduced template argument values can be
11046 substituted into non-deduced contexts, nor do we have to verify
11047 that all template arguments have been deduced. */
11048
11049int
11050more_specialized_fn (tree pat1, tree pat2, int len)
11051{
11052 tree decl1 = DECL_TEMPLATE_RESULT (pat1);
11053 tree decl2 = DECL_TEMPLATE_RESULT (pat2);
11054 tree targs1 = make_tree_vec (DECL_NTPARMS (pat1));
11055 tree targs2 = make_tree_vec (DECL_NTPARMS (pat2));
11056 tree tparms1 = DECL_INNERMOST_TEMPLATE_PARMS (pat1);
11057 tree tparms2 = DECL_INNERMOST_TEMPLATE_PARMS (pat2);
11058 tree args1 = TYPE_ARG_TYPES (TREE_TYPE (decl1));
11059 tree args2 = TYPE_ARG_TYPES (TREE_TYPE (decl2));
11060 int better1 = 0;
11061 int better2 = 0;
11062
11063 /* Remove the this parameter from non-static member functions. If
11064 one is a non-static member function and the other is not a static
11065 member function, remove the first parameter from that function
11066 also. This situation occurs for operator functions where we
11067 locate both a member function (with this pointer) and non-member
11068 operator (with explicit first operand). */
11069 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1))
11070 {
11071 len--; /* LEN is the number of significant arguments for DECL1 */
11072 args1 = TREE_CHAIN (args1);
11073 if (!DECL_STATIC_FUNCTION_P (decl2))
11074 args2 = TREE_CHAIN (args2);
11075 }
11076 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2))
11077 {
11078 args2 = TREE_CHAIN (args2);
11079 if (!DECL_STATIC_FUNCTION_P (decl1))
11080 {
11081 len--;
11082 args1 = TREE_CHAIN (args1);
11083 }
11084 }
11085
11086 /* If only one is a conversion operator, they are unordered. */
11087 if (DECL_CONV_FN_P (decl1) != DECL_CONV_FN_P (decl2))
11088 return 0;
11089
11090 /* Consider the return type for a conversion function */
11091 if (DECL_CONV_FN_P (decl1))
11092 {
11093 args1 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl1)), args1);
11094 args2 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl2)), args2);
11095 len++;
11096 }
11097
11098 processing_template_decl++;
11099
11100 while (len--)
11101 {
11102 tree arg1 = TREE_VALUE (args1);
11103 tree arg2 = TREE_VALUE (args2);
11104 int deduce1, deduce2;
11105 int quals1 = -1;
11106 int quals2 = -1;
11107
11108 if (TREE_CODE (arg1) == REFERENCE_TYPE)
11109 {
11110 arg1 = TREE_TYPE (arg1);
11111 quals1 = cp_type_quals (arg1);
11112 }
11113
11114 if (TREE_CODE (arg2) == REFERENCE_TYPE)
11115 {
11116 arg2 = TREE_TYPE (arg2);
11117 quals2 = cp_type_quals (arg2);
11118 }
11119
11120 if ((quals1 < 0) != (quals2 < 0))
11121 {
11122 /* Only of the args is a reference, see if we should apply
11123 array/function pointer decay to it. This is not part of
11124 DR214, but is, IMHO, consistent with the deduction rules
11125 for the function call itself, and with our earlier
11126 implementation of the underspecified partial ordering
11127 rules. (nathan). */
11128 if (quals1 >= 0)
11129 {
11130 switch (TREE_CODE (arg1))
11131 {
11132 case ARRAY_TYPE:
11133 arg1 = TREE_TYPE (arg1);
11134 /* FALLTHROUGH. */
11135 case FUNCTION_TYPE:
11136 arg1 = build_pointer_type (arg1);
11137 break;
11138
11139 default:
11140 break;
11141 }
11142 }
11143 else
11144 {
11145 switch (TREE_CODE (arg2))
11146 {
11147 case ARRAY_TYPE:
11148 arg2 = TREE_TYPE (arg2);
11149 /* FALLTHROUGH. */
11150 case FUNCTION_TYPE:
11151 arg2 = build_pointer_type (arg2);
11152 break;
11153
11154 default:
11155 break;
11156 }
11157 }
11158 }
11159
11160 arg1 = TYPE_MAIN_VARIANT (arg1);
11161 arg2 = TYPE_MAIN_VARIANT (arg2);
11162
11163 deduce1 = !unify (tparms1, targs1, arg1, arg2, UNIFY_ALLOW_NONE);
11164 deduce2 = !unify (tparms2, targs2, arg2, arg1, UNIFY_ALLOW_NONE);
11165
11166 if (!deduce1)
11167 better2 = -1;
11168 if (!deduce2)
11169 better1 = -1;
11170 if (better1 < 0 && better2 < 0)
11171 /* We've failed to deduce something in either direction.
11172 These must be unordered. */
11173 break;
11174
11175 if (deduce1 && deduce2 && quals1 >= 0 && quals2 >= 0)
11176 {
11177 /* Deduces in both directions, see if quals can
11178 disambiguate. Pretend the worse one failed to deduce. */
11179 if ((quals1 & quals2) == quals2)
11180 deduce1 = 0;
11181 if ((quals1 & quals2) == quals1)
11182 deduce2 = 0;
11183 }
11184 if (deduce1 && !deduce2 && !better2)
11185 better2 = 1;
11186 if (deduce2 && !deduce1 && !better1)
11187 better1 = 1;
11188
11189 args1 = TREE_CHAIN (args1);
11190 args2 = TREE_CHAIN (args2);
11191 }
11192
11193 processing_template_decl--;
11194
11195 return (better1 > 0) - (better2 > 0);
11196}
11197
11198/* Determine which of two partial specializations is more specialized.
11199
11200 PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
11201 to the first partial specialization. The TREE_VALUE is the
11202 innermost set of template parameters for the partial
11203 specialization. PAT2 is similar, but for the second template.
11204
11205 Return 1 if the first partial specialization is more specialized;
11206 -1 if the second is more specialized; 0 if neither is more
11207 specialized.
11208
11209 See [temp.class.order] for information about determining which of
11210 two templates is more specialized. */
11211
11212static int
11213more_specialized_class (tree pat1, tree pat2)
11214{
11215 tree targs;
11216 tree tmpl1, tmpl2;
11217 int winner = 0;
11218
11219 tmpl1 = TREE_TYPE (pat1);
11220 tmpl2 = TREE_TYPE (pat2);
11221
11222 /* Just like what happens for functions, if we are ordering between
11223 different class template specializations, we may encounter dependent
11224 types in the arguments, and we need our dependency check functions
11225 to behave correctly. */
11226 ++processing_template_decl;
11227 targs = get_class_bindings (TREE_VALUE (pat1),
11228 CLASSTYPE_TI_ARGS (tmpl1),
11229 CLASSTYPE_TI_ARGS (tmpl2));
11230 if (targs)
11231 --winner;
11232
11233 targs = get_class_bindings (TREE_VALUE (pat2),
11234 CLASSTYPE_TI_ARGS (tmpl2),
11235 CLASSTYPE_TI_ARGS (tmpl1));
11236 if (targs)
11237 ++winner;
11238 --processing_template_decl;
11239
11240 return winner;
11241}
11242
11243/* Return the template arguments that will produce the function signature
11244 DECL from the function template FN, with the explicit template
11245 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
11246 also match. Return NULL_TREE if no satisfactory arguments could be
11247 found. */
11248
11249static tree
11250get_bindings (tree fn, tree decl, tree explicit_args, bool check_rettype)
11251{
11252 int ntparms = DECL_NTPARMS (fn);
11253 tree targs = make_tree_vec (ntparms);
11254 tree decl_type;
11255 tree decl_arg_types;
11256
11257 /* Substitute the explicit template arguments into the type of DECL.
11258 The call to fn_type_unification will handle substitution into the
11259 FN. */
11260 decl_type = TREE_TYPE (decl);
11261 if (explicit_args && uses_template_parms (decl_type))
11262 {
11263 tree tmpl;
11264 tree converted_args;
11265
11266 if (DECL_TEMPLATE_INFO (decl))
11267 tmpl = DECL_TI_TEMPLATE (decl);
11268 else
11269 /* We can get here for some invalid specializations. */
11270 return NULL_TREE;
11271
11272 converted_args
11273 = coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
11274 explicit_args, NULL_TREE,
11275 tf_none,
11276 /*require_all_args=*/false,
11277 /*use_default_args=*/false);
11278 if (converted_args == error_mark_node)
11279 return NULL_TREE;
11280
11281 decl_type = tsubst (decl_type, converted_args, tf_none, NULL_TREE);
11282 if (decl_type == error_mark_node)
11283 return NULL_TREE;
11284 }
11285
11286 /* Never do unification on the 'this' parameter. */
11287 decl_arg_types = skip_artificial_parms_for (decl,
11288 TYPE_ARG_TYPES (decl_type));
11289
11290 if (fn_type_unification (fn, explicit_args, targs,
11291 decl_arg_types,
11292 (check_rettype || DECL_CONV_FN_P (fn)
11293 ? TREE_TYPE (decl_type) : NULL_TREE),
11294 DEDUCE_EXACT, LOOKUP_NORMAL))
11295 return NULL_TREE;
11296
11297 return targs;
11298}
11299
11300/* Return the innermost template arguments that, when applied to a
11301 template specialization whose innermost template parameters are
11302 TPARMS, and whose specialization arguments are PARMS, yield the
11303 ARGS.
11304
11305 For example, suppose we have:
11306
11307 template <class T, class U> struct S {};
11308 template <class T> struct S<T*, int> {};
11309
11310 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
11311 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
11312 int}. The resulting vector will be {double}, indicating that `T'
11313 is bound to `double'. */
11314
11315static tree
11316get_class_bindings (tree tparms, tree spec_args, tree args)
11317{
11318 int i, ntparms = TREE_VEC_LENGTH (tparms);
11319 tree deduced_args;
11320 tree innermost_deduced_args;
11321
11322 innermost_deduced_args = make_tree_vec (ntparms);
11323 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
11324 {
11325 deduced_args = copy_node (args);
11326 SET_TMPL_ARGS_LEVEL (deduced_args,
11327 TMPL_ARGS_DEPTH (deduced_args),
11328 innermost_deduced_args);
11329 }
11330 else
11331 deduced_args = innermost_deduced_args;
11332
11333 if (unify (tparms, deduced_args,
11334 INNERMOST_TEMPLATE_ARGS (spec_args),
11335 INNERMOST_TEMPLATE_ARGS (args),
11336 UNIFY_ALLOW_NONE))
11337 return NULL_TREE;
11338
11339 for (i = 0; i < ntparms; ++i)
11340 if (! TREE_VEC_ELT (innermost_deduced_args, i))
11341 return NULL_TREE;
11342
11343 /* Verify that nondeduced template arguments agree with the type
11344 obtained from argument deduction.
11345
11346 For example:
11347
11348 struct A { typedef int X; };
11349 template <class T, class U> struct C {};
11350 template <class T> struct C<T, typename T::X> {};
11351
11352 Then with the instantiation `C<A, int>', we can deduce that
11353 `T' is `A' but unify () does not check whether `typename T::X'
11354 is `int'. */
11355 spec_args = tsubst (spec_args, deduced_args, tf_none, NULL_TREE);
11356 if (spec_args == error_mark_node
11357 /* We only need to check the innermost arguments; the other
11358 arguments will always agree. */
11359 || !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args),
11360 INNERMOST_TEMPLATE_ARGS (args)))
11361 return NULL_TREE;
11362
11363 return deduced_args;
11364}
11365
11366/* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
11367 Return the TREE_LIST node with the most specialized template, if
11368 any. If there is no most specialized template, the error_mark_node
11369 is returned.
11370
11371 Note that this function does not look at, or modify, the
11372 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
11373 returned is one of the elements of INSTANTIATIONS, callers may
11374 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
11375 and retrieve it from the value returned. */
11376
11377tree
11378most_specialized_instantiation (tree templates)
11379{
11380 tree fn, champ;
11381
11382 ++processing_template_decl;
11383
11384 champ = templates;
11385 for (fn = TREE_CHAIN (templates); fn; fn = TREE_CHAIN (fn))
11386 {
11387 int fate = 0;
11388
11389 if (get_bindings (TREE_VALUE (champ),
11390 DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
11391 NULL_TREE, /*check_ret=*/false))
11392 fate--;
11393
11394 if (get_bindings (TREE_VALUE (fn),
11395 DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
11396 NULL_TREE, /*check_ret=*/false))
11397 fate++;
11398
11399 if (fate == -1)
11400 champ = fn;
11401 else if (!fate)
11402 {
11403 /* Equally specialized, move to next function. If there
11404 is no next function, nothing's most specialized. */
11405 fn = TREE_CHAIN (fn);
11406 champ = fn;
11407 if (!fn)
11408 break;
11409 }
11410 }
11411
11412 if (champ)
11413 /* Now verify that champ is better than everything earlier in the
11414 instantiation list. */
11415 for (fn = templates; fn != champ; fn = TREE_CHAIN (fn))
11416 if (get_bindings (TREE_VALUE (champ),
11417 DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
11418 NULL_TREE, /*check_ret=*/false)
11419 || !get_bindings (TREE_VALUE (fn),
11420 DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
11421 NULL_TREE, /*check_ret=*/false))
11422 {
11423 champ = NULL_TREE;
11424 break;
11425 }
11426
11427 processing_template_decl--;
11428
11429 if (!champ)
11430 return error_mark_node;
11431
11432 return champ;
11433}
11434
11435/* If DECL is a specialization of some template, return the most
11436 general such template. Otherwise, returns NULL_TREE.
11437
11438 For example, given:
11439
11440 template <class T> struct S { template <class U> void f(U); };
11441
11442 if TMPL is `template <class U> void S<int>::f(U)' this will return
11443 the full template. This function will not trace past partial
11444 specializations, however. For example, given in addition:
11445
11446 template <class T> struct S<T*> { template <class U> void f(U); };
11447
11448 if TMPL is `template <class U> void S<int*>::f(U)' this will return
11449 `template <class T> template <class U> S<T*>::f(U)'. */
11450
11451tree
11452most_general_template (tree decl)
11453{
11454 /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
11455 an immediate specialization. */
11456 if (TREE_CODE (decl) == FUNCTION_DECL)
11457 {
11458 if (DECL_TEMPLATE_INFO (decl)) {
11459 decl = DECL_TI_TEMPLATE (decl);
11460
11461 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
11462 template friend. */
11463 if (TREE_CODE (decl) != TEMPLATE_DECL)
11464 return NULL_TREE;
11465 } else
11466 return NULL_TREE;
11467 }
11468
11469 /* Look for more and more general templates. */
11470 while (DECL_TEMPLATE_INFO (decl))
11471 {
11472 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
11473 (See cp-tree.h for details.) */
11474 if (TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
11475 break;
11476
11477 if (CLASS_TYPE_P (TREE_TYPE (decl))
11478 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)))
11479 break;
11480
11481 /* Stop if we run into an explicitly specialized class template. */
11482 if (!DECL_NAMESPACE_SCOPE_P (decl)
11483 && DECL_CONTEXT (decl)
11484 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl)))
11485 break;
11486
11487 decl = DECL_TI_TEMPLATE (decl);
11488 }
11489
11490 return decl;
11491}
11492
11493/* Return the most specialized of the class template partial
11494 specializations of TMPL which can produce TYPE, a specialization of
11495 TMPL. The value returned is actually a TREE_LIST; the TREE_TYPE is
11496 a _TYPE node corresponding to the partial specialization, while the
11497 TREE_PURPOSE is the set of template arguments that must be
11498 substituted into the TREE_TYPE in order to generate TYPE.
11499
11500 If the choice of partial specialization is ambiguous, a diagnostic
11501 is issued, and the error_mark_node is returned. If there are no
11502 partial specializations of TMPL matching TYPE, then NULL_TREE is
11503 returned. */
11504
11505static tree
11506most_specialized_class (tree type, tree tmpl)
11507{
11508 tree list = NULL_TREE;
11509 tree t;
11510 tree champ;
11511 int fate;
11512 bool ambiguous_p;
11513 tree args;
11514
11515 tmpl = most_general_template (tmpl);
11516 args = CLASSTYPE_TI_ARGS (type);
11517 for (t = DECL_TEMPLATE_SPECIALIZATIONS (tmpl); t; t = TREE_CHAIN (t))
11518 {
11519 tree partial_spec_args;
11520 tree spec_args;
11521
11522 partial_spec_args = CLASSTYPE_TI_ARGS (TREE_TYPE (t));
11523 spec_args = get_class_bindings (TREE_VALUE (t),
11524 partial_spec_args,
11525 args);
11526 if (spec_args)
11527 {
11528 list = tree_cons (spec_args, TREE_VALUE (t), list);
11529 TREE_TYPE (list) = TREE_TYPE (t);
11530 }
11531 }
11532
11533 if (! list)
11534 return NULL_TREE;
11535
11536 ambiguous_p = false;
11537 t = list;
11538 champ = t;
11539 t = TREE_CHAIN (t);
11540 for (; t; t = TREE_CHAIN (t))
11541 {
11542 fate = more_specialized_class (champ, t);
11543 if (fate == 1)
11544 ;
11545 else
11546 {
11547 if (fate == 0)
11548 {
11549 t = TREE_CHAIN (t);
11550 if (! t)
11551 {
11552 ambiguous_p = true;
11553 break;
11554 }
11555 }
11556 champ = t;
11557 }
11558 }
11559
11560 if (!ambiguous_p)
11561 for (t = list; t && t != champ; t = TREE_CHAIN (t))
11562 {
11563 fate = more_specialized_class (champ, t);
11564 if (fate != 1)
11565 {
11566 ambiguous_p = true;
11567 break;
11568 }
11569 }
11570
11571 if (ambiguous_p)
11572 {
11573 const char *str = "candidates are:";
11574 error ("ambiguous class template instantiation for %q#T", type);
11575 for (t = list; t; t = TREE_CHAIN (t))
11576 {
11577 error ("%s %+#T", str, TREE_TYPE (t));
11578 str = " ";
11579 }
11580 return error_mark_node;
11581 }
11582
11583 return champ;
11584}
11585
11586/* Explicitly instantiate DECL. */
11587
11588void
11589do_decl_instantiation (tree decl, tree storage)
11590{
11591 tree result = NULL_TREE;
11592 int extern_p = 0;
11593
11594 if (!decl || decl == error_mark_node)
11595 /* An error occurred, for which grokdeclarator has already issued
11596 an appropriate message. */
11597 return;
11598 else if (! DECL_LANG_SPECIFIC (decl))
11599 {
11600 error ("explicit instantiation of non-template %q#D", decl);
11601 return;
11602 }
11603 else if (TREE_CODE (decl) == VAR_DECL)
11604 {
11605 /* There is an asymmetry here in the way VAR_DECLs and
11606 FUNCTION_DECLs are handled by grokdeclarator. In the case of
11607 the latter, the DECL we get back will be marked as a
11608 template instantiation, and the appropriate
11609 DECL_TEMPLATE_INFO will be set up. This does not happen for
11610 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
11611 should handle VAR_DECLs as it currently handles
11612 FUNCTION_DECLs. */
11613 result = lookup_field (DECL_CONTEXT (decl), DECL_NAME (decl), 0, false);
11614 if (!result || TREE_CODE (result) != VAR_DECL)
11615 {
11616 error ("no matching template for %qD found", decl);
11617 return;
11618 }
11619 }
11620 else if (TREE_CODE (decl) != FUNCTION_DECL)
11621 {
11622 error ("explicit instantiation of %q#D", decl);
11623 return;
11624 }
11625 else
11626 result = decl;
11627
11628 /* Check for various error cases. Note that if the explicit
11629 instantiation is valid the RESULT will currently be marked as an
11630 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
11631 until we get here. */
11632
11633 if (DECL_TEMPLATE_SPECIALIZATION (result))
11634 {
11635 /* DR 259 [temp.spec].
11636
11637 Both an explicit instantiation and a declaration of an explicit
11638 specialization shall not appear in a program unless the explicit
11639 instantiation follows a declaration of the explicit specialization.
11640
11641 For a given set of template parameters, if an explicit
11642 instantiation of a template appears after a declaration of an
11643 explicit specialization for that template, the explicit
11644 instantiation has no effect. */
11645 return;
11646 }
11647 else if (DECL_EXPLICIT_INSTANTIATION (result))
11648 {
11649 /* [temp.spec]
11650
11651 No program shall explicitly instantiate any template more
11652 than once.
11653
11654 We check DECL_NOT_REALLY_EXTERN so as not to complain when
11655 the first instantiation was `extern' and the second is not,
11656 and EXTERN_P for the opposite case. */
11657 if (DECL_NOT_REALLY_EXTERN (result) && !extern_p)
11658 pedwarn ("duplicate explicit instantiation of %q#D", result);
11659 /* If an "extern" explicit instantiation follows an ordinary
11660 explicit instantiation, the template is instantiated. */
11661 if (extern_p)
11662 return;
11663 }
11664 else if (!DECL_IMPLICIT_INSTANTIATION (result))
11665 {
11666 error ("no matching template for %qD found", result);
11667 return;
11668 }
11669 else if (!DECL_TEMPLATE_INFO (result))
11670 {
11671 pedwarn ("explicit instantiation of non-template %q#D", result);
11672 return;
11673 }
11674
11675 if (storage == NULL_TREE)
11676 ;
11677 else if (storage == ridpointers[(int) RID_EXTERN])
11678 {
11679 if (pedantic && !in_system_header)
11680 pedwarn ("ISO C++ forbids the use of %<extern%> on explicit "
11681 "instantiations");
11682 extern_p = 1;
11683 }
11684 else
11685 error ("storage class %qD applied to template instantiation", storage);
11686
11687 check_explicit_instantiation_namespace (result);
11688 mark_decl_instantiated (result, extern_p);
11689 if (! extern_p)
11690 instantiate_decl (result, /*defer_ok=*/1,
11691 /*expl_inst_class_mem_p=*/false);
11692}
11693
11694static void
11695mark_class_instantiated (tree t, int extern_p)
11696{
11697 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t);
11698 SET_CLASSTYPE_INTERFACE_KNOWN (t);
11699 CLASSTYPE_INTERFACE_ONLY (t) = extern_p;
11700 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = extern_p;
11701 if (! extern_p)
11702 {
11703 CLASSTYPE_DEBUG_REQUESTED (t) = 1;
11704 rest_of_type_compilation (t, 1);
11705 }
11706}
11707
11708/* Called from do_type_instantiation through binding_table_foreach to
11709 do recursive instantiation for the type bound in ENTRY. */
11710static void
11711bt_instantiate_type_proc (binding_entry entry, void *data)
11712{
11713 tree storage = *(tree *) data;
11714
11715 if (IS_AGGR_TYPE (entry->type)
11716 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry->type)))
11717 do_type_instantiation (TYPE_MAIN_DECL (entry->type), storage, 0);
11718}
11719
11720/* Called from do_type_instantiation to instantiate a member
11721 (a member function or a static member variable) of an
11722 explicitly instantiated class template. */
11723static void
11724instantiate_class_member (tree decl, int extern_p)
11725{
11726 mark_decl_instantiated (decl, extern_p);
11727 if (! extern_p)
11728 instantiate_decl (decl, /*defer_ok=*/1,
11729 /*expl_inst_class_mem_p=*/true);
11730}
11731
11732/* Perform an explicit instantiation of template class T. STORAGE, if
11733 non-null, is the RID for extern, inline or static. COMPLAIN is
11734 nonzero if this is called from the parser, zero if called recursively,
11735 since the standard is unclear (as detailed below). */
11736
11737void
11738do_type_instantiation (tree t, tree storage, tsubst_flags_t complain)
11739{
11740 int extern_p = 0;
11741 int nomem_p = 0;
11742 int static_p = 0;
11743 int previous_instantiation_extern_p = 0;
11744
11745 if (TREE_CODE (t) == TYPE_DECL)
11746 t = TREE_TYPE (t);
11747
11748 if (! CLASS_TYPE_P (t) || ! CLASSTYPE_TEMPLATE_INFO (t))
11749 {
11750 error ("explicit instantiation of non-template type %qT", t);
11751 return;
11752 }
11753
11754 complete_type (t);
11755
11756 if (!COMPLETE_TYPE_P (t))
11757 {
11758 if (complain & tf_error)
11759 error ("explicit instantiation of %q#T before definition of template",
11760 t);
11761 return;
11762 }
11763
11764 if (storage != NULL_TREE)
11765 {
11766 if (pedantic && !in_system_header)
11767 pedwarn("ISO C++ forbids the use of %qE on explicit instantiations",
11768 storage);
11769
11770 if (storage == ridpointers[(int) RID_INLINE])
11771 nomem_p = 1;
11772 else if (storage == ridpointers[(int) RID_EXTERN])
11773 extern_p = 1;
11774 else if (storage == ridpointers[(int) RID_STATIC])
11775 static_p = 1;
11776 else
11777 {
11778 error ("storage class %qD applied to template instantiation",
11779 storage);
11780 extern_p = 0;
11781 }
11782 }
11783
11784 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
11785 {
11786 /* DR 259 [temp.spec].
11787
11788 Both an explicit instantiation and a declaration of an explicit
11789 specialization shall not appear in a program unless the explicit
11790 instantiation follows a declaration of the explicit specialization.
11791
11792 For a given set of template parameters, if an explicit
11793 instantiation of a template appears after a declaration of an
11794 explicit specialization for that template, the explicit
11795 instantiation has no effect. */
11796 return;
11797 }
11798 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t))
11799 {
11800 /* [temp.spec]
11801
11802 No program shall explicitly instantiate any template more
11803 than once.
11804
11805 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
11806 instantiation was `extern'. If EXTERN_P then the second is.
11807 These cases are OK. */
11808 previous_instantiation_extern_p = CLASSTYPE_INTERFACE_ONLY (t);
11809
11810 if (!previous_instantiation_extern_p && !extern_p
11811 && (complain & tf_error))
11812 pedwarn ("duplicate explicit instantiation of %q#T", t);
11813
11814 /* If we've already instantiated the template, just return now. */
11815 if (!CLASSTYPE_INTERFACE_ONLY (t))
11816 return;
11817 }
11818
11819 check_explicit_instantiation_namespace (TYPE_NAME (t));
11820 mark_class_instantiated (t, extern_p);
11821
11822 if (nomem_p)
11823 return;
11824
11825 {
11826 tree tmp;
11827
11828 /* In contrast to implicit instantiation, where only the
11829 declarations, and not the definitions, of members are
11830 instantiated, we have here:
11831
11832 [temp.explicit]
11833
11834 The explicit instantiation of a class template specialization
11835 implies the instantiation of all of its members not
11836 previously explicitly specialized in the translation unit
11837 containing the explicit instantiation.
11838
11839 Of course, we can't instantiate member template classes, since
11840 we don't have any arguments for them. Note that the standard
11841 is unclear on whether the instantiation of the members are
11842 *explicit* instantiations or not. However, the most natural
11843 interpretation is that it should be an explicit instantiation. */
11844
11845 if (! static_p)
11846 for (tmp = TYPE_METHODS (t); tmp; tmp = TREE_CHAIN (tmp))
11847 if (TREE_CODE (tmp) == FUNCTION_DECL
11848 && DECL_TEMPLATE_INSTANTIATION (tmp))
11849 instantiate_class_member (tmp, extern_p);
11850
11851 for (tmp = TYPE_FIELDS (t); tmp; tmp = TREE_CHAIN (tmp))
11852 if (TREE_CODE (tmp) == VAR_DECL && DECL_TEMPLATE_INSTANTIATION (tmp))
11853 instantiate_class_member (tmp, extern_p);
11854
11855 if (CLASSTYPE_NESTED_UTDS (t))
11856 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t),
11857 bt_instantiate_type_proc, &storage);
11858 }
11859}
11860
11861/* Given a function DECL, which is a specialization of TMPL, modify
11862 DECL to be a re-instantiation of TMPL with the same template
11863 arguments. TMPL should be the template into which tsubst'ing
11864 should occur for DECL, not the most general template.
11865
11866 One reason for doing this is a scenario like this:
11867
11868 template <class T>
11869 void f(const T&, int i);
11870
11871 void g() { f(3, 7); }
11872
11873 template <class T>
11874 void f(const T& t, const int i) { }
11875
11876 Note that when the template is first instantiated, with
11877 instantiate_template, the resulting DECL will have no name for the
11878 first parameter, and the wrong type for the second. So, when we go
11879 to instantiate the DECL, we regenerate it. */
11880
11881static void
11882regenerate_decl_from_template (tree decl, tree tmpl)
11883{
11884 /* The arguments used to instantiate DECL, from the most general
11885 template. */
11886 tree args;
11887 tree code_pattern;
11888
11889 args = DECL_TI_ARGS (decl);
11890 code_pattern = DECL_TEMPLATE_RESULT (tmpl);
11891
11892 /* Make sure that we can see identifiers, and compute access
11893 correctly. */
11894 push_access_scope (decl);
11895
11896 if (TREE_CODE (decl) == FUNCTION_DECL)
11897 {
11898 tree decl_parm;
11899 tree pattern_parm;
11900 tree specs;
11901 int args_depth;
11902 int parms_depth;
11903
11904 args_depth = TMPL_ARGS_DEPTH (args);
11905 parms_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
11906 if (args_depth > parms_depth)
11907 args = get_innermost_template_args (args, parms_depth);
11908
11909 specs = tsubst_exception_specification (TREE_TYPE (code_pattern),
11910 args, tf_error, NULL_TREE);
11911 if (specs)
11912 TREE_TYPE (decl) = build_exception_variant (TREE_TYPE (decl),
11913 specs);
11914
11915 /* Merge parameter declarations. */
11916 decl_parm = skip_artificial_parms_for (decl,
11917 DECL_ARGUMENTS (decl));
11918 pattern_parm
11919 = skip_artificial_parms_for (code_pattern,
11920 DECL_ARGUMENTS (code_pattern));
11921 while (decl_parm)
11922 {
11923 tree parm_type;
11924 tree attributes;
11925
11926 if (DECL_NAME (decl_parm) != DECL_NAME (pattern_parm))
11927 DECL_NAME (decl_parm) = DECL_NAME (pattern_parm);
11928 parm_type = tsubst (TREE_TYPE (pattern_parm), args, tf_error,
11929 NULL_TREE);
11930 parm_type = type_decays_to (parm_type);
11931 if (!same_type_p (TREE_TYPE (decl_parm), parm_type))
11932 TREE_TYPE (decl_parm) = parm_type;
11933 attributes = DECL_ATTRIBUTES (pattern_parm);
11934 if (DECL_ATTRIBUTES (decl_parm) != attributes)
11935 {
11936 DECL_ATTRIBUTES (decl_parm) = attributes;
11937 cplus_decl_attributes (&decl_parm, attributes, /*flags=*/0);
11938 }
11939 decl_parm = TREE_CHAIN (decl_parm);
11940 pattern_parm = TREE_CHAIN (pattern_parm);
11941 }
11942
11943 /* Merge additional specifiers from the CODE_PATTERN. */
11944 if (DECL_DECLARED_INLINE_P (code_pattern)
11945 && !DECL_DECLARED_INLINE_P (decl))
11946 DECL_DECLARED_INLINE_P (decl) = 1;
11947 if (DECL_INLINE (code_pattern) && !DECL_INLINE (decl))
11948 DECL_INLINE (decl) = 1;
11949 }
11950 else if (TREE_CODE (decl) == VAR_DECL)
11951 DECL_INITIAL (decl) =
11952 tsubst_expr (DECL_INITIAL (code_pattern), args,
11953 tf_error, DECL_TI_TEMPLATE (decl),
11954 /*integral_constant_expression_p=*/false);
11955 else
11956 gcc_unreachable ();
11957
11958 pop_access_scope (decl);
11959}
11960
11961/* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
11962 substituted to get DECL. */
11963
11964tree
11965template_for_substitution (tree decl)
11966{
11967 tree tmpl = DECL_TI_TEMPLATE (decl);
11968
11969 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
11970 for the instantiation. This is not always the most general
11971 template. Consider, for example:
11972
11973 template <class T>
11974 struct S { template <class U> void f();
11975 template <> void f<int>(); };
11976
11977 and an instantiation of S<double>::f<int>. We want TD to be the
11978 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
11979 while (/* An instantiation cannot have a definition, so we need a
11980 more general template. */
11981 DECL_TEMPLATE_INSTANTIATION (tmpl)
11982 /* We must also deal with friend templates. Given:
11983
11984 template <class T> struct S {
11985 template <class U> friend void f() {};
11986 };
11987
11988 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
11989 so far as the language is concerned, but that's still
11990 where we get the pattern for the instantiation from. On
11991 other hand, if the definition comes outside the class, say:
11992
11993 template <class T> struct S {
11994 template <class U> friend void f();
11995 };
11996 template <class U> friend void f() {}
11997
11998 we don't need to look any further. That's what the check for
11999 DECL_INITIAL is for. */
12000 || (TREE_CODE (decl) == FUNCTION_DECL
12001 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl)
12002 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl))))
12003 {
12004 /* The present template, TD, should not be a definition. If it
12005 were a definition, we should be using it! Note that we
12006 cannot restructure the loop to just keep going until we find
12007 a template with a definition, since that might go too far if
12008 a specialization was declared, but not defined. */
12009 gcc_assert (TREE_CODE (decl) != VAR_DECL
12010 || DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (tmpl)));
12011
12012 /* Fetch the more general template. */
12013 tmpl = DECL_TI_TEMPLATE (tmpl);
12014 }
12015
12016 return tmpl;
12017}
12018
12019/* Produce the definition of D, a _DECL generated from a template. If
12020 DEFER_OK is nonzero, then we don't have to actually do the
12021 instantiation now; we just have to do it sometime. Normally it is
12022 an error if this is an explicit instantiation but D is undefined.
12023 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
12024 explicitly instantiated class template. */
12025
12026tree
12027instantiate_decl (tree d, int defer_ok,
12028 bool expl_inst_class_mem_p)
12029{
12030 tree tmpl = DECL_TI_TEMPLATE (d);
12031 tree gen_args;
12032 tree args;
12033 tree td;
12034 tree code_pattern;
12035 tree spec;
12036 tree gen_tmpl;
12037 bool pattern_defined;
12038 int need_push;
12039 location_t saved_loc = input_location;
12040 int saved_in_system_header = in_system_header;
12041 bool external_p;
12042
12043 /* This function should only be used to instantiate templates for
12044 functions and static member variables. */
12045 gcc_assert (TREE_CODE (d) == FUNCTION_DECL
12046 || TREE_CODE (d) == VAR_DECL);
12047
12048 /* Variables are never deferred; if instantiation is required, they
12049 are instantiated right away. That allows for better code in the
12050 case that an expression refers to the value of the variable --
12051 if the variable has a constant value the referring expression can
12052 take advantage of that fact. */
12053 if (TREE_CODE (d) == VAR_DECL)
12054 defer_ok = 0;
12055
12056 /* Don't instantiate cloned functions. Instead, instantiate the
12057 functions they cloned. */
12058 if (TREE_CODE (d) == FUNCTION_DECL && DECL_CLONED_FUNCTION_P (d))
12059 d = DECL_CLONED_FUNCTION (d);
12060
12061 if (DECL_TEMPLATE_INSTANTIATED (d))
12062 /* D has already been instantiated. It might seem reasonable to
12063 check whether or not D is an explicit instantiation, and, if so,
12064 stop here. But when an explicit instantiation is deferred
12065 until the end of the compilation, DECL_EXPLICIT_INSTANTIATION
12066 is set, even though we still need to do the instantiation. */
12067 return d;
12068
12069 /* If we already have a specialization of this declaration, then
12070 there's no reason to instantiate it. Note that
12071 retrieve_specialization gives us both instantiations and
12072 specializations, so we must explicitly check
12073 DECL_TEMPLATE_SPECIALIZATION. */
12074 gen_tmpl = most_general_template (tmpl);
12075 gen_args = DECL_TI_ARGS (d);
12076 spec = retrieve_specialization (gen_tmpl, gen_args,
12077 /*class_specializations_p=*/false);
12078 if (spec != NULL_TREE && DECL_TEMPLATE_SPECIALIZATION (spec))
12079 return spec;
12080
12081 /* This needs to happen before any tsubsting. */
12082 if (! push_tinst_level (d))
12083 return d;
12084
12085 timevar_push (TV_PARSE);
12086
12087 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
12088 for the instantiation. */
12089 td = template_for_substitution (d);
12090 code_pattern = DECL_TEMPLATE_RESULT (td);
12091
12092 /* We should never be trying to instantiate a member of a class
12093 template or partial specialization. */
12094 gcc_assert (d != code_pattern);
12095
12096 if ((DECL_NAMESPACE_SCOPE_P (d) && !DECL_INITIALIZED_IN_CLASS_P (d))
12097 || DECL_TEMPLATE_SPECIALIZATION (td))
12098 /* In the case of a friend template whose definition is provided
12099 outside the class, we may have too many arguments. Drop the
12100 ones we don't need. The same is true for specializations. */
12101 args = get_innermost_template_args
12102 (gen_args, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td)));
12103 else
12104 args = gen_args;
12105
12106 if (TREE_CODE (d) == FUNCTION_DECL)
12107 pattern_defined = (DECL_SAVED_TREE (code_pattern) != NULL_TREE);
12108 else
12109 pattern_defined = ! DECL_IN_AGGR_P (code_pattern);
12110
12111 /* We may be in the middle of deferred access check. Disable it now. */
12112 push_deferring_access_checks (dk_no_deferred);
12113
12114 /* Unless an explicit instantiation directive has already determined
12115 the linkage of D, remember that a definition is available for
12116 this entity. */
12117 if (pattern_defined
12118 && !DECL_INTERFACE_KNOWN (d)
12119 && !DECL_NOT_REALLY_EXTERN (d))
12120 mark_definable (d);
12121
12122 input_location = DECL_SOURCE_LOCATION (d);
12123 in_system_header = DECL_IN_SYSTEM_HEADER (d);
12124
12125 /* If D is a member of an explicitly instantiated class template,
12126 and no definition is available, treat it like an implicit
12127 instantiation. */
12128 if (!pattern_defined && expl_inst_class_mem_p
12129 && DECL_EXPLICIT_INSTANTIATION (d))
12130 {
12131 DECL_NOT_REALLY_EXTERN (d) = 0;
12132 DECL_INTERFACE_KNOWN (d) = 0;
12133 SET_DECL_IMPLICIT_INSTANTIATION (d);
12134 }
12135
12136 if (!defer_ok)
12137 {
12138 /* Recheck the substitutions to obtain any warning messages
12139 about ignoring cv qualifiers. */
12140 tree gen = DECL_TEMPLATE_RESULT (gen_tmpl);
12141 tree type = TREE_TYPE (gen);
12142
12143 /* Make sure that we can see identifiers, and compute access
12144 correctly. D is already the target FUNCTION_DECL with the
12145 right context. */
12146 push_access_scope (d);
12147
12148 if (TREE_CODE (gen) == FUNCTION_DECL)
12149 {
12150 tsubst (DECL_ARGUMENTS (gen), gen_args, tf_warning_or_error, d);
12151 tsubst (TYPE_RAISES_EXCEPTIONS (type), gen_args,
12152 tf_warning_or_error, d);
12153 /* Don't simply tsubst the function type, as that will give
12154 duplicate warnings about poor parameter qualifications.
12155 The function arguments are the same as the decl_arguments
12156 without the top level cv qualifiers. */
12157 type = TREE_TYPE (type);
12158 }
12159 tsubst (type, gen_args, tf_warning_or_error, d);
12160
12161 pop_access_scope (d);
12162 }
12163
12164 /* Check to see whether we know that this template will be
12165 instantiated in some other file, as with "extern template"
12166 extension. */
12167 external_p = (DECL_INTERFACE_KNOWN (d) && DECL_REALLY_EXTERN (d));
12168 /* In general, we do not instantiate such templates... */
12169 if (external_p
12170 /* ... but we instantiate inline functions so that we can inline
12171 them and ... */
12172 && ! (TREE_CODE (d) == FUNCTION_DECL && DECL_INLINE (d))
12173 /* ... we instantiate static data members whose values are
12174 needed in integral constant expressions. */
12175 && ! (TREE_CODE (d) == VAR_DECL
12176 && DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (d)))
12177 goto out;
12178 /* Defer all other templates, unless we have been explicitly
12179 forbidden from doing so. */
12180 if (/* If there is no definition, we cannot instantiate the
12181 template. */
12182 ! pattern_defined
12183 /* If it's OK to postpone instantiation, do so. */
12184 || defer_ok
12185 /* If this is a static data member that will be defined
12186 elsewhere, we don't want to instantiate the entire data
12187 member, but we do want to instantiate the initializer so that
12188 we can substitute that elsewhere. */
12189 || (external_p && TREE_CODE (d) == VAR_DECL))
12190 {
12191 /* The definition of the static data member is now required so
12192 we must substitute the initializer. */
12193 if (TREE_CODE (d) == VAR_DECL
12194 && !DECL_INITIAL (d)
12195 && DECL_INITIAL (code_pattern))
12196 {
12197 tree ns;
12198 tree init;
12199
12200 ns = decl_namespace_context (d);
12201 push_nested_namespace (ns);
12202 push_nested_class (DECL_CONTEXT (d));
12203 init = tsubst_expr (DECL_INITIAL (code_pattern),
12204 args,
12205 tf_warning_or_error, NULL_TREE,
12206 /*integral_constant_expression_p=*/false);
12207 cp_finish_decl (d, init, /*init_const_expr_p=*/false,
12208 /*asmspec_tree=*/NULL_TREE,
12209 LOOKUP_ONLYCONVERTING);
12210 pop_nested_class ();
12211 pop_nested_namespace (ns);
12212 }
12213
12214 /* We restore the source position here because it's used by
12215 add_pending_template. */
12216 input_location = saved_loc;
12217
12218 if (at_eof && !pattern_defined
12219 && DECL_EXPLICIT_INSTANTIATION (d))
12220 /* [temp.explicit]
12221
12222 The definition of a non-exported function template, a
12223 non-exported member function template, or a non-exported
12224 member function or static data member of a class template
12225 shall be present in every translation unit in which it is
12226 explicitly instantiated. */
12227 pedwarn
12228 ("explicit instantiation of %qD but no definition available", d);
12229
12230 /* ??? Historically, we have instantiated inline functions, even
12231 when marked as "extern template". */
12232 if (!(external_p && TREE_CODE (d) == VAR_DECL))
12233 add_pending_template (d);
12234 goto out;
12235 }
12236 /* Tell the repository that D is available in this translation unit
12237 -- and see if it is supposed to be instantiated here. */
12238 if (TREE_PUBLIC (d) && !DECL_REALLY_EXTERN (d) && !repo_emit_p (d))
12239 {
12240 /* In a PCH file, despite the fact that the repository hasn't
12241 requested instantiation in the PCH it is still possible that
12242 an instantiation will be required in a file that includes the
12243 PCH. */
12244 if (pch_file)
12245 add_pending_template (d);
12246 /* Instantiate inline functions so that the inliner can do its
12247 job, even though we'll not be emitting a copy of this
12248 function. */
12249 if (!(TREE_CODE (d) == FUNCTION_DECL
12250 && flag_inline_trees
12251 && DECL_DECLARED_INLINE_P (d)))
12252 goto out;
12253 }
12254
12255 need_push = !cfun || !global_bindings_p ();
12256 if (need_push)
12257 push_to_top_level ();
12258
12259 /* Mark D as instantiated so that recursive calls to
12260 instantiate_decl do not try to instantiate it again. */
12261 DECL_TEMPLATE_INSTANTIATED (d) = 1;
12262
12263 /* Regenerate the declaration in case the template has been modified
12264 by a subsequent redeclaration. */
12265 regenerate_decl_from_template (d, td);
12266
12267 /* We already set the file and line above. Reset them now in case
12268 they changed as a result of calling regenerate_decl_from_template. */
12269 input_location = DECL_SOURCE_LOCATION (d);
12270
12271 if (TREE_CODE (d) == VAR_DECL)
12272 {
12273 tree init;
12274
12275 /* Clear out DECL_RTL; whatever was there before may not be right
12276 since we've reset the type of the declaration. */
12277 SET_DECL_RTL (d, NULL_RTX);
12278 DECL_IN_AGGR_P (d) = 0;
12279
12280 /* The initializer is placed in DECL_INITIAL by
12281 regenerate_decl_from_template. Pull it out so that
12282 finish_decl can process it. */
12283 init = DECL_INITIAL (d);
12284 DECL_INITIAL (d) = NULL_TREE;
12285 DECL_INITIALIZED_P (d) = 0;
12286
12287 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
12288 initializer. That function will defer actual emission until
12289 we have a chance to determine linkage. */
12290 DECL_EXTERNAL (d) = 0;
12291
12292 /* Enter the scope of D so that access-checking works correctly. */
12293 push_nested_class (DECL_CONTEXT (d));
12294 finish_decl (d, init, NULL_TREE);
12295 pop_nested_class ();
12296 }
12297 else if (TREE_CODE (d) == FUNCTION_DECL)
12298 {
12299 htab_t saved_local_specializations;
12300 tree subst_decl;
12301 tree tmpl_parm;
12302 tree spec_parm;
12303
12304 /* Save away the current list, in case we are instantiating one
12305 template from within the body of another. */
12306 saved_local_specializations = local_specializations;
12307
12308 /* Set up the list of local specializations. */
12309 local_specializations = htab_create (37,
12310 hash_local_specialization,
12311 eq_local_specializations,
12312 NULL);
12313
12314 /* Set up context. */
12315 start_preparsed_function (d, NULL_TREE, SF_PRE_PARSED);
12316
12317 /* Create substitution entries for the parameters. */
12318 subst_decl = DECL_TEMPLATE_RESULT (template_for_substitution (d));
12319 tmpl_parm = DECL_ARGUMENTS (subst_decl);
12320 spec_parm = DECL_ARGUMENTS (d);
12321 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d))
12322 {
12323 register_local_specialization (spec_parm, tmpl_parm);
12324 spec_parm = skip_artificial_parms_for (d, spec_parm);
12325 tmpl_parm = skip_artificial_parms_for (subst_decl, tmpl_parm);
12326 }
12327 while (tmpl_parm)
12328 {
12329 register_local_specialization (spec_parm, tmpl_parm);
12330 tmpl_parm = TREE_CHAIN (tmpl_parm);
12331 spec_parm = TREE_CHAIN (spec_parm);
12332 }
12333 gcc_assert (!spec_parm);
12334
12335 /* Substitute into the body of the function. */
12336 tsubst_expr (DECL_SAVED_TREE (code_pattern), args,
12337 tf_warning_or_error, tmpl,
12338 /*integral_constant_expression_p=*/false);
12339
12340 /* We don't need the local specializations any more. */
12341 htab_delete (local_specializations);
12342 local_specializations = saved_local_specializations;
12343
12344 /* Finish the function. */
12345 d = finish_function (0);
12346 expand_or_defer_fn (d);
12347 }
12348
12349 /* We're not deferring instantiation any more. */
12350 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d)) = 0;
12351
12352 if (need_push)
12353 pop_from_top_level ();
12354
12355out:
12356 input_location = saved_loc;
12357 in_system_header = saved_in_system_header;
12358 pop_deferring_access_checks ();
12359 pop_tinst_level ();
12360
12361 timevar_pop (TV_PARSE);
12362
12363 return d;
12364}
12365
12366/* Run through the list of templates that we wish we could
12367 instantiate, and instantiate any we can. RETRIES is the
12368 number of times we retry pending template instantiation. */
12369
12370void
12371instantiate_pending_templates (int retries)
12372{
12373 tree *t;
12374 tree last = NULL_TREE;
12375 int reconsider;
12376 location_t saved_loc = input_location;
12377 int saved_in_system_header = in_system_header;
12378
12379 /* Instantiating templates may trigger vtable generation. This in turn
12380 may require further template instantiations. We place a limit here
12381 to avoid infinite loop. */
12382 if (pending_templates && retries >= max_tinst_depth)
12383 {
12384 tree decl = TREE_VALUE (pending_templates);
12385
12386 error ("template instantiation depth exceeds maximum of %d"
12387 " instantiating %q+D, possibly from virtual table generation"
12388 " (use -ftemplate-depth-NN to increase the maximum)",
12389 max_tinst_depth, decl);
12390 if (TREE_CODE (decl) == FUNCTION_DECL)
12391 /* Pretend that we defined it. */
12392 DECL_INITIAL (decl) = error_mark_node;
12393 return;
12394 }
12395
12396 do
12397 {
12398 reconsider = 0;
12399
12400 t = &pending_templates;
12401 while (*t)
12402 {
12403 tree instantiation = TREE_VALUE (*t);
12404
12405 reopen_tinst_level (TREE_PURPOSE (*t));
12406
12407 if (TYPE_P (instantiation))
12408 {
12409 tree fn;
12410
12411 if (!COMPLETE_TYPE_P (instantiation))
12412 {
12413 instantiate_class_template (instantiation);
12414 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation))
12415 for (fn = TYPE_METHODS (instantiation);
12416 fn;
12417 fn = TREE_CHAIN (fn))
12418 if (! DECL_ARTIFICIAL (fn))
12419 instantiate_decl (fn,
12420 /*defer_ok=*/0,
12421 /*expl_inst_class_mem_p=*/false);
12422 if (COMPLETE_TYPE_P (instantiation))
12423 reconsider = 1;
12424 }
12425
12426 if (COMPLETE_TYPE_P (instantiation))
12427 /* If INSTANTIATION has been instantiated, then we don't
12428 need to consider it again in the future. */
12429 *t = TREE_CHAIN (*t);
12430 else
12431 {
12432 last = *t;
12433 t = &TREE_CHAIN (*t);
12434 }
12435 }
12436 else
12437 {
12438 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation)
12439 && !DECL_TEMPLATE_INSTANTIATED (instantiation))
12440 {
12441 instantiation
12442 = instantiate_decl (instantiation,
12443 /*defer_ok=*/0,
12444 /*expl_inst_class_mem_p=*/false);
12445 if (DECL_TEMPLATE_INSTANTIATED (instantiation))
12446 reconsider = 1;
12447 }
12448
12449 if (DECL_TEMPLATE_SPECIALIZATION (instantiation)
12450 || DECL_TEMPLATE_INSTANTIATED (instantiation))
12451 /* If INSTANTIATION has been instantiated, then we don't
12452 need to consider it again in the future. */
12453 *t = TREE_CHAIN (*t);
12454 else
12455 {
12456 last = *t;
12457 t = &TREE_CHAIN (*t);
12458 }
12459 }
12460 tinst_depth = 0;
12461 current_tinst_level = NULL_TREE;
12462 }
12463 last_pending_template = last;
12464 }
12465 while (reconsider);
12466
12467 input_location = saved_loc;
12468 in_system_header = saved_in_system_header;
12469}
12470
12471/* Substitute ARGVEC into T, which is a list of initializers for
12472 either base class or a non-static data member. The TREE_PURPOSEs
12473 are DECLs, and the TREE_VALUEs are the initializer values. Used by
12474 instantiate_decl. */
12475
12476static tree
12477tsubst_initializer_list (tree t, tree argvec)
12478{
12479 tree inits = NULL_TREE;
12480
12481 for (; t; t = TREE_CHAIN (t))
12482 {
12483 tree decl;
12484 tree init;
12485
12486 decl = tsubst_copy (TREE_PURPOSE (t), argvec, tf_warning_or_error,
12487 NULL_TREE);
12488 decl = expand_member_init (decl);
12489 if (decl && !DECL_P (decl))
12490 in_base_initializer = 1;
12491
12492 init = tsubst_expr (TREE_VALUE (t), argvec, tf_warning_or_error,
12493 NULL_TREE,
12494 /*integral_constant_expression_p=*/false);
12495 in_base_initializer = 0;
12496
12497 if (decl)
12498 {
12499 init = build_tree_list (decl, init);
12500 TREE_CHAIN (init) = inits;
12501 inits = init;
12502 }
12503 }
12504 return inits;
12505}
12506
12507/* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
12508
12509static void
12510set_current_access_from_decl (tree decl)
12511{
12512 if (TREE_PRIVATE (decl))
12513 current_access_specifier = access_private_node;
12514 else if (TREE_PROTECTED (decl))
12515 current_access_specifier = access_protected_node;
12516 else
12517 current_access_specifier = access_public_node;
12518}
12519
12520/* Instantiate an enumerated type. TAG is the template type, NEWTAG
12521 is the instantiation (which should have been created with
12522 start_enum) and ARGS are the template arguments to use. */
12523
12524static void
12525tsubst_enum (tree tag, tree newtag, tree args)
12526{
12527 tree e;
12528
12529 for (e = TYPE_VALUES (tag); e; e = TREE_CHAIN (e))
12530 {
12531 tree value;
12532 tree decl;
12533
12534 decl = TREE_VALUE (e);
12535 /* Note that in a template enum, the TREE_VALUE is the
12536 CONST_DECL, not the corresponding INTEGER_CST. */
12537 value = tsubst_expr (DECL_INITIAL (decl),
12538 args, tf_warning_or_error, NULL_TREE,
12539 /*integral_constant_expression_p=*/true);
12540
12541 /* Give this enumeration constant the correct access. */
12542 set_current_access_from_decl (decl);
12543
12544 /* Actually build the enumerator itself. */
12545 build_enumerator (DECL_NAME (decl), value, newtag);
12546 }
12547
12548 finish_enum (newtag);
12549 DECL_SOURCE_LOCATION (TYPE_NAME (newtag))
12550 = DECL_SOURCE_LOCATION (TYPE_NAME (tag));
12551}
12552
12553/* DECL is a FUNCTION_DECL that is a template specialization. Return
12554 its type -- but without substituting the innermost set of template
12555 arguments. So, innermost set of template parameters will appear in
12556 the type. */
12557
12558tree
12559get_mostly_instantiated_function_type (tree decl)
12560{
12561 tree fn_type;
12562 tree tmpl;
12563 tree targs;
12564 tree tparms;
12565 int parm_depth;
12566
12567 tmpl = most_general_template (DECL_TI_TEMPLATE (decl));
12568 targs = DECL_TI_ARGS (decl);
12569 tparms = DECL_TEMPLATE_PARMS (tmpl);
12570 parm_depth = TMPL_PARMS_DEPTH (tparms);
12571
12572 /* There should be as many levels of arguments as there are levels
12573 of parameters. */
12574 gcc_assert (parm_depth == TMPL_ARGS_DEPTH (targs));
12575
12576 fn_type = TREE_TYPE (tmpl);
12577
12578 if (parm_depth == 1)
12579 /* No substitution is necessary. */
12580 ;
12581 else
12582 {
12583 int i, save_access_control;
12584 tree partial_args;
12585
12586 /* Replace the innermost level of the TARGS with NULL_TREEs to
12587 let tsubst know not to substitute for those parameters. */
12588 partial_args = make_tree_vec (TREE_VEC_LENGTH (targs));
12589 for (i = 1; i < TMPL_ARGS_DEPTH (targs); ++i)
12590 SET_TMPL_ARGS_LEVEL (partial_args, i,
12591 TMPL_ARGS_LEVEL (targs, i));
12592 SET_TMPL_ARGS_LEVEL (partial_args,
12593 TMPL_ARGS_DEPTH (targs),
12594 make_tree_vec (DECL_NTPARMS (tmpl)));
12595
12596 /* Disable access control as this function is used only during
12597 name-mangling. */
12598 save_access_control = flag_access_control;
12599 flag_access_control = 0;
12600
12601 ++processing_template_decl;
12602 /* Now, do the (partial) substitution to figure out the
12603 appropriate function type. */
12604 fn_type = tsubst (fn_type, partial_args, tf_error, NULL_TREE);
12605 --processing_template_decl;
12606
12607 /* Substitute into the template parameters to obtain the real
12608 innermost set of parameters. This step is important if the
12609 innermost set of template parameters contains value
12610 parameters whose types depend on outer template parameters. */
12611 TREE_VEC_LENGTH (partial_args)--;
12612 tparms = tsubst_template_parms (tparms, partial_args, tf_error);
12613
12614 flag_access_control = save_access_control;
12615 }
12616
12617 return fn_type;
12618}
12619
12620/* Return truthvalue if we're processing a template different from
12621 the last one involved in diagnostics. */
12622int
12623problematic_instantiation_changed (void)
12624{
12625 return last_template_error_tick != tinst_level_tick;
12626}
12627
12628/* Remember current template involved in diagnostics. */
12629void
12630record_last_problematic_instantiation (void)
12631{
12632 last_template_error_tick = tinst_level_tick;
12633}
12634
12635tree
12636current_instantiation (void)
12637{
12638 return current_tinst_level;
12639}
12640
12641/* [temp.param] Check that template non-type parm TYPE is of an allowable
12642 type. Return zero for ok, nonzero for disallowed. Issue error and
12643 warning messages under control of COMPLAIN. */
12644
12645static int
12646invalid_nontype_parm_type_p (tree type, tsubst_flags_t complain)
12647{
12648 if (INTEGRAL_TYPE_P (type))
12649 return 0;
12650 else if (POINTER_TYPE_P (type))
12651 return 0;
12652 else if (TYPE_PTR_TO_MEMBER_P (type))
12653 return 0;
12654 else if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
12655 return 0;
12656 else if (TREE_CODE (type) == TYPENAME_TYPE)
12657 return 0;
12658
12659 if (complain & tf_error)
12660 error ("%q#T is not a valid type for a template constant parameter", type);
12661 return 1;
12662}
12663
12664/* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
12665 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
12666
12667static bool
12668dependent_type_p_r (tree type)
12669{
12670 tree scope;
12671
12672 /* [temp.dep.type]
12673
12674 A type is dependent if it is:
12675
12676 -- a template parameter. Template template parameters are types
12677 for us (since TYPE_P holds true for them) so we handle
12678 them here. */
12679 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
12680 || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM)
12681 return true;
12682 /* -- a qualified-id with a nested-name-specifier which contains a
12683 class-name that names a dependent type or whose unqualified-id
12684 names a dependent type. */
12685 if (TREE_CODE (type) == TYPENAME_TYPE)
12686 return true;
12687 /* -- a cv-qualified type where the cv-unqualified type is
12688 dependent. */
12689 type = TYPE_MAIN_VARIANT (type);
12690 /* -- a compound type constructed from any dependent type. */
12691 if (TYPE_PTR_TO_MEMBER_P (type))
12692 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type))
12693 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
12694 (type)));
12695 else if (TREE_CODE (type) == POINTER_TYPE
12696 || TREE_CODE (type) == REFERENCE_TYPE)
12697 return dependent_type_p (TREE_TYPE (type));
12698 else if (TREE_CODE (type) == FUNCTION_TYPE
12699 || TREE_CODE (type) == METHOD_TYPE)
12700 {
12701 tree arg_type;
12702
12703 if (dependent_type_p (TREE_TYPE (type)))
12704 return true;
12705 for (arg_type = TYPE_ARG_TYPES (type);
12706 arg_type;
12707 arg_type = TREE_CHAIN (arg_type))
12708 if (dependent_type_p (TREE_VALUE (arg_type)))
12709 return true;
12710 return false;
12711 }
12712 /* -- an array type constructed from any dependent type or whose
12713 size is specified by a constant expression that is
12714 value-dependent. */
12715 if (TREE_CODE (type) == ARRAY_TYPE)
12716 {
12717 if (TYPE_DOMAIN (type)
12718 && ((value_dependent_expression_p
12719 (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
12720 || (type_dependent_expression_p
12721 (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))))
12722 return true;
12723 return dependent_type_p (TREE_TYPE (type));
12724 }
12725
12726 /* -- a template-id in which either the template name is a template
12727 parameter ... */
12728 if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
12729 return true;
12730 /* ... or any of the template arguments is a dependent type or
12731 an expression that is type-dependent or value-dependent. */
12732 else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INFO (type)
12733 && (any_dependent_template_arguments_p
12734 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type)))))
12735 return true;
12736
12737 /* All TYPEOF_TYPEs are dependent; if the argument of the `typeof'
12738 expression is not type-dependent, then it should already been
12739 have resolved. */
12740 if (TREE_CODE (type) == TYPEOF_TYPE)
12741 return true;
12742
12743 /* The standard does not specifically mention types that are local
12744 to template functions or local classes, but they should be
12745 considered dependent too. For example:
12746
12747 template <int I> void f() {
12748 enum E { a = I };
12749 S<sizeof (E)> s;
12750 }
12751
12752 The size of `E' cannot be known until the value of `I' has been
12753 determined. Therefore, `E' must be considered dependent. */
12754 scope = TYPE_CONTEXT (type);
12755 if (scope && TYPE_P (scope))
12756 return dependent_type_p (scope);
12757 else if (scope && TREE_CODE (scope) == FUNCTION_DECL)
12758 return type_dependent_expression_p (scope);
12759
12760 /* Other types are non-dependent. */
12761 return false;
12762}
12763
12764/* Returns TRUE if TYPE is dependent, in the sense of
12765 [temp.dep.type]. */
12766
12767bool
12768dependent_type_p (tree type)
12769{
12770 /* If there are no template parameters in scope, then there can't be
12771 any dependent types. */
12772 if (!processing_template_decl)
12773 {
12774 /* If we are not processing a template, then nobody should be
12775 providing us with a dependent type. */
12776 gcc_assert (type);
12777 gcc_assert (TREE_CODE (type) != TEMPLATE_TYPE_PARM);
12778 return false;
12779 }
12780
12781 /* If the type is NULL, we have not computed a type for the entity
12782 in question; in that case, the type is dependent. */
12783 if (!type)
12784 return true;
12785
12786 /* Erroneous types can be considered non-dependent. */
12787 if (type == error_mark_node)
12788 return false;
12789
12790 /* If we have not already computed the appropriate value for TYPE,
12791 do so now. */
12792 if (!TYPE_DEPENDENT_P_VALID (type))
12793 {
12794 TYPE_DEPENDENT_P (type) = dependent_type_p_r (type);
12795 TYPE_DEPENDENT_P_VALID (type) = 1;
12796 }
12797
12798 return TYPE_DEPENDENT_P (type);
12799}
12800
12801/* Returns TRUE if EXPRESSION is dependent, according to CRITERION. */
12802
12803static bool
12804dependent_scope_ref_p (tree expression, bool criterion (tree))
12805{
12806 tree scope;
12807 tree name;
12808
12809 gcc_assert (TREE_CODE (expression) == SCOPE_REF);
12810
12811 if (!TYPE_P (TREE_OPERAND (expression, 0)))
12812 return true;
12813
12814 scope = TREE_OPERAND (expression, 0);
12815 name = TREE_OPERAND (expression, 1);
12816
12817 /* [temp.dep.expr]
12818
12819 An id-expression is type-dependent if it contains a
12820 nested-name-specifier that contains a class-name that names a
12821 dependent type. */
12822 /* The suggested resolution to Core Issue 2 implies that if the
12823 qualifying type is the current class, then we must peek
12824 inside it. */
12825 if (DECL_P (name)
12826 && currently_open_class (scope)
12827 && !criterion (name))
12828 return false;
12829 if (dependent_type_p (scope))
12830 return true;
12831
12832 return false;
12833}
12834
12835/* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
12836 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
12837 expression. */
12838
12839bool
12840value_dependent_expression_p (tree expression)
12841{
12842 if (!processing_template_decl)
12843 return false;
12844
12845 /* A name declared with a dependent type. */
12846 if (DECL_P (expression) && type_dependent_expression_p (expression))
12847 return true;
12848
12849 switch (TREE_CODE (expression))
12850 {
12851 case IDENTIFIER_NODE:
12852 /* A name that has not been looked up -- must be dependent. */
12853 return true;
12854
12855 case TEMPLATE_PARM_INDEX:
12856 /* A non-type template parm. */
12857 return true;
12858
12859 case CONST_DECL:
12860 /* A non-type template parm. */
12861 if (DECL_TEMPLATE_PARM_P (expression))
12862 return true;
12863 return false;
12864
12865 case VAR_DECL:
12866 /* A constant with integral or enumeration type and is initialized
12867 with an expression that is value-dependent. */
12868 if (DECL_INITIAL (expression)
12869 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (expression))
12870 && value_dependent_expression_p (DECL_INITIAL (expression)))
12871 return true;
12872 return false;
12873
12874 case DYNAMIC_CAST_EXPR:
12875 case STATIC_CAST_EXPR:
12876 case CONST_CAST_EXPR:
12877 case REINTERPRET_CAST_EXPR:
12878 case CAST_EXPR:
12879 /* These expressions are value-dependent if the type to which
12880 the cast occurs is dependent or the expression being casted
12881 is value-dependent. */
12882 {
12883 tree type = TREE_TYPE (expression);
12884
12885 if (dependent_type_p (type))
12886 return true;
12887
12888 /* A functional cast has a list of operands. */
12889 expression = TREE_OPERAND (expression, 0);
12890 if (!expression)
12891 {
12892 /* If there are no operands, it must be an expression such
12893 as "int()". This should not happen for aggregate types
12894 because it would form non-constant expressions. */
12895 gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type));
12896
12897 return false;
12898 }
12899
12900 if (TREE_CODE (expression) == TREE_LIST)
12901 return any_value_dependent_elements_p (expression);
12902
12903 return value_dependent_expression_p (expression);
12904 }
12905
12906 case SIZEOF_EXPR:
12907 case ALIGNOF_EXPR:
12908 /* A `sizeof' expression is value-dependent if the operand is
12909 type-dependent. */
12910 expression = TREE_OPERAND (expression, 0);
12911 if (TYPE_P (expression))
12912 return dependent_type_p (expression);
12913 return type_dependent_expression_p (expression);
12914
12915 case SCOPE_REF:
12916 return dependent_scope_ref_p (expression, value_dependent_expression_p);
12917
12918 case COMPONENT_REF:
12919 return (value_dependent_expression_p (TREE_OPERAND (expression, 0))
12920 || value_dependent_expression_p (TREE_OPERAND (expression, 1)));
12921
12922 case CALL_EXPR:
12923 /* A CALL_EXPR may appear in a constant expression if it is a
12924 call to a builtin function, e.g., __builtin_constant_p. All
12925 such calls are value-dependent. */
12926 return true;
12927
12928 case MODOP_EXPR:
12929 return ((value_dependent_expression_p (TREE_OPERAND (expression, 0)))
12930 || (value_dependent_expression_p (TREE_OPERAND (expression, 2))));
12931
12932 default:
12933 /* A constant expression is value-dependent if any subexpression is
12934 value-dependent. */
12935 switch (TREE_CODE_CLASS (TREE_CODE (expression)))
12936 {
12937 case tcc_reference:
12938 case tcc_unary:
12939 return (value_dependent_expression_p
12940 (TREE_OPERAND (expression, 0)));
12941
12942 case tcc_comparison:
12943 case tcc_binary:
12944 return ((value_dependent_expression_p
12945 (TREE_OPERAND (expression, 0)))
12946 || (value_dependent_expression_p
12947 (TREE_OPERAND (expression, 1))));
12948
12949 case tcc_expression:
12950 {
12951 int i;
12952 for (i = 0; i < TREE_CODE_LENGTH (TREE_CODE (expression)); ++i)
12953 /* In some cases, some of the operands may be missing.
12954 (For example, in the case of PREDECREMENT_EXPR, the
12955 amount to increment by may be missing.) That doesn't
12956 make the expression dependent. */
12957 if (TREE_OPERAND (expression, i)
12958 && (value_dependent_expression_p
12959 (TREE_OPERAND (expression, i))))
12960 return true;
12961 return false;
12962 }
12963
12964 default:
12965 break;
12966 }
12967 }
12968
12969 /* The expression is not value-dependent. */
12970 return false;
12971}
12972
12973/* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
12974 [temp.dep.expr]. */
12975
12976bool
12977type_dependent_expression_p (tree expression)
12978{
12979 if (!processing_template_decl)
12980 return false;
12981
12982 if (expression == error_mark_node)
12983 return false;
12984
12985 /* An unresolved name is always dependent. */
12986 if (TREE_CODE (expression) == IDENTIFIER_NODE
12987 || TREE_CODE (expression) == USING_DECL)
12988 return true;
12989
12990 /* Some expression forms are never type-dependent. */
12991 if (TREE_CODE (expression) == PSEUDO_DTOR_EXPR
12992 || TREE_CODE (expression) == SIZEOF_EXPR
12993 || TREE_CODE (expression) == ALIGNOF_EXPR
12994 || TREE_CODE (expression) == TYPEID_EXPR
12995 || TREE_CODE (expression) == DELETE_EXPR
12996 || TREE_CODE (expression) == VEC_DELETE_EXPR
12997 || TREE_CODE (expression) == THROW_EXPR)
12998 return false;
12999
13000 /* The types of these expressions depends only on the type to which
13001 the cast occurs. */
13002 if (TREE_CODE (expression) == DYNAMIC_CAST_EXPR
13003 || TREE_CODE (expression) == STATIC_CAST_EXPR
13004 || TREE_CODE (expression) == CONST_CAST_EXPR
13005 || TREE_CODE (expression) == REINTERPRET_CAST_EXPR
13006 || TREE_CODE (expression) == CAST_EXPR)
13007 return dependent_type_p (TREE_TYPE (expression));
13008
13009 /* The types of these expressions depends only on the type created
13010 by the expression. */
13011 if (TREE_CODE (expression) == NEW_EXPR
13012 || TREE_CODE (expression) == VEC_NEW_EXPR)
13013 {
13014 /* For NEW_EXPR tree nodes created inside a template, either
13015 the object type itself or a TREE_LIST may appear as the
13016 operand 1. */
13017 tree type = TREE_OPERAND (expression, 1);
13018 if (TREE_CODE (type) == TREE_LIST)
13019 /* This is an array type. We need to check array dimensions
13020 as well. */
13021 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type)))
13022 || value_dependent_expression_p
13023 (TREE_OPERAND (TREE_VALUE (type), 1));
13024 else
13025 return dependent_type_p (type);
13026 }
13027
13028 if (TREE_CODE (expression) == SCOPE_REF
13029 && dependent_scope_ref_p (expression,
13030 type_dependent_expression_p))
13031 return true;
13032
13033 if (TREE_CODE (expression) == FUNCTION_DECL
13034 && DECL_LANG_SPECIFIC (expression)
13035 && DECL_TEMPLATE_INFO (expression)
13036 && (any_dependent_template_arguments_p
13037 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression)))))
13038 return true;
13039
13040 if (TREE_CODE (expression) == TEMPLATE_DECL
13041 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression))
13042 return false;
13043
13044 if (TREE_TYPE (expression) == unknown_type_node)
13045 {
13046 if (TREE_CODE (expression) == ADDR_EXPR)
13047 return type_dependent_expression_p (TREE_OPERAND (expression, 0));
13048 if (TREE_CODE (expression) == COMPONENT_REF
13049 || TREE_CODE (expression) == OFFSET_REF)
13050 {
13051 if (type_dependent_expression_p (TREE_OPERAND (expression, 0)))
13052 return true;
13053 expression = TREE_OPERAND (expression, 1);
13054 if (TREE_CODE (expression) == IDENTIFIER_NODE)
13055 return false;
13056 }
13057 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
13058 if (TREE_CODE (expression) == SCOPE_REF)
13059 return false;
13060
13061 if (TREE_CODE (expression) == BASELINK)
13062 expression = BASELINK_FUNCTIONS (expression);
13063
13064 if (TREE_CODE (expression) == TEMPLATE_ID_EXPR)
13065 {
13066 if (any_dependent_template_arguments_p
13067 (TREE_OPERAND (expression, 1)))
13068 return true;
13069 expression = TREE_OPERAND (expression, 0);
13070 }
13071 gcc_assert (TREE_CODE (expression) == OVERLOAD
13072 || TREE_CODE (expression) == FUNCTION_DECL);
13073
13074 while (expression)
13075 {
13076 if (type_dependent_expression_p (OVL_CURRENT (expression)))
13077 return true;
13078 expression = OVL_NEXT (expression);
13079 }
13080 return false;
13081 }
13082
13083 gcc_assert (TREE_CODE (expression) != TYPE_DECL);
13084
13085 return (dependent_type_p (TREE_TYPE (expression)));
13086}
13087
13088/* Returns TRUE if ARGS (a TREE_LIST of arguments to a function call)
13089 contains a type-dependent expression. */
13090
13091bool
13092any_type_dependent_arguments_p (tree args)
13093{
13094 while (args)
13095 {
13096 tree arg = TREE_VALUE (args);
13097
13098 if (type_dependent_expression_p (arg))
13099 return true;
13100 args = TREE_CHAIN (args);
13101 }
13102 return false;
13103}
13104
13105/* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
13106 expressions) contains any value-dependent expressions. */
13107
13108bool
13109any_value_dependent_elements_p (tree list)
13110{
13111 for (; list; list = TREE_CHAIN (list))
13112 if (value_dependent_expression_p (TREE_VALUE (list)))
13113 return true;
13114
13115 return false;
13116}
13117
13118/* Returns TRUE if the ARG (a template argument) is dependent. */
13119
13120static bool
13121dependent_template_arg_p (tree arg)
13122{
13123 if (!processing_template_decl)
13124 return false;
13125
13126 if (TREE_CODE (arg) == TEMPLATE_DECL
13127 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
13128 return dependent_template_p (arg);
13129 else if (TYPE_P (arg))
13130 return dependent_type_p (arg);
13131 else
13132 return (type_dependent_expression_p (arg)
13133 || value_dependent_expression_p (arg));
13134}
13135
13136/* Returns true if ARGS (a collection of template arguments) contains
13137 any dependent arguments. */
13138
13139bool
13140any_dependent_template_arguments_p (tree args)
13141{
13142 int i;
13143 int j;
13144
13145 if (!args)
13146 return false;
13147 if (args == error_mark_node)
13148 return true;
13149
13150 for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i)
13151 {
13152 tree level = TMPL_ARGS_LEVEL (args, i + 1);
13153 for (j = 0; j < TREE_VEC_LENGTH (level); ++j)
13154 if (dependent_template_arg_p (TREE_VEC_ELT (level, j)))
13155 return true;
13156 }
13157
13158 return false;
13159}
13160
13161/* Returns TRUE if the template TMPL is dependent. */
13162
13163bool
13164dependent_template_p (tree tmpl)
13165{
13166 if (TREE_CODE (tmpl) == OVERLOAD)
13167 {
13168 while (tmpl)
13169 {
13170 if (dependent_template_p (OVL_FUNCTION (tmpl)))
13171 return true;
13172 tmpl = OVL_CHAIN (tmpl);
13173 }
13174 return false;
13175 }
13176
13177 /* Template template parameters are dependent. */
13178 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl)
13179 || TREE_CODE (tmpl) == TEMPLATE_TEMPLATE_PARM)
13180 return true;
13181 /* So are names that have not been looked up. */
13182 if (TREE_CODE (tmpl) == SCOPE_REF
13183 || TREE_CODE (tmpl) == IDENTIFIER_NODE)
13184 return true;
13185 /* So are member templates of dependent classes. */
13186 if (TYPE_P (CP_DECL_CONTEXT (tmpl)))
13187 return dependent_type_p (DECL_CONTEXT (tmpl));
13188 return false;
13189}
13190
13191/* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
13192
13193bool
13194dependent_template_id_p (tree tmpl, tree args)
13195{
13196 return (dependent_template_p (tmpl)
13197 || any_dependent_template_arguments_p (args));
13198}
13199
13200/* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
13201 TYPENAME_TYPE corresponds. Returns ERROR_MARK_NODE if no such TYPE
13202 can be found. Note that this function peers inside uninstantiated
13203 templates and therefore should be used only in extremely limited
13204 situations. ONLY_CURRENT_P restricts this peering to the currently
13205 open classes hierarchy (which is required when comparing types). */
13206
13207tree
13208resolve_typename_type (tree type, bool only_current_p)
13209{
13210 tree scope;
13211 tree name;
13212 tree decl;
13213 int quals;
13214 tree pushed_scope;
13215
13216 gcc_assert (TREE_CODE (type) == TYPENAME_TYPE);
13217
13218 scope = TYPE_CONTEXT (type);
13219 name = TYPE_IDENTIFIER (type);
13220
13221 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
13222 it first before we can figure out what NAME refers to. */
13223 if (TREE_CODE (scope) == TYPENAME_TYPE)
13224 scope = resolve_typename_type (scope, only_current_p);
13225 /* If we don't know what SCOPE refers to, then we cannot resolve the
13226 TYPENAME_TYPE. */
13227 if (scope == error_mark_node || TREE_CODE (scope) == TYPENAME_TYPE)
13228 return error_mark_node;
13229 /* If the SCOPE is a template type parameter, we have no way of
13230 resolving the name. */
13231 if (TREE_CODE (scope) == TEMPLATE_TYPE_PARM)
13232 return type;
13233 /* If the SCOPE is not the current instantiation, there's no reason
13234 to look inside it. */
13235 if (only_current_p && !currently_open_class (scope))
13236 return error_mark_node;
13237 /* If SCOPE is a partial instantiation, it will not have a valid
13238 TYPE_FIELDS list, so use the original template. */
13239 scope = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope);
13240 /* Enter the SCOPE so that name lookup will be resolved as if we
13241 were in the class definition. In particular, SCOPE will no
13242 longer be considered a dependent type. */
13243 pushed_scope = push_scope (scope);
13244 /* Look up the declaration. */
13245 decl = lookup_member (scope, name, /*protect=*/0, /*want_type=*/true);
13246 /* Obtain the set of qualifiers applied to the TYPE. */
13247 quals = cp_type_quals (type);
13248 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
13249 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
13250 if (!decl)
13251 type = error_mark_node;
13252 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == IDENTIFIER_NODE
13253 && TREE_CODE (decl) == TYPE_DECL)
13254 type = TREE_TYPE (decl);
13255 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == TEMPLATE_ID_EXPR
13256 && DECL_CLASS_TEMPLATE_P (decl))
13257 {
13258 tree tmpl;
13259 tree args;
13260 /* Obtain the template and the arguments. */
13261 tmpl = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 0);
13262 args = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 1);
13263 /* Instantiate the template. */
13264 type = lookup_template_class (tmpl, args, NULL_TREE, NULL_TREE,
13265 /*entering_scope=*/0, tf_error | tf_user);
13266 }
13267 else
13268 type = error_mark_node;
13269 /* Qualify the resulting type. */
13270 if (type != error_mark_node && quals)
13271 type = cp_build_qualified_type (type, quals);
13272 /* Leave the SCOPE. */
13273 if (pushed_scope)
13274 pop_scope (pushed_scope);
13275
13276 return type;
13277}
13278
13279/* EXPR is an expression which is not type-dependent. Return a proxy
13280 for EXPR that can be used to compute the types of larger
13281 expressions containing EXPR. */
13282
13283tree
13284build_non_dependent_expr (tree expr)
13285{
13286 tree inner_expr;
13287
13288 /* Preserve null pointer constants so that the type of things like
13289 "p == 0" where "p" is a pointer can be determined. */
13290 if (null_ptr_cst_p (expr))
13291 return expr;
13292 /* Preserve OVERLOADs; the functions must be available to resolve
13293 types. */
13294 inner_expr = expr;
13295 if (TREE_CODE (inner_expr) == ADDR_EXPR)
13296 inner_expr = TREE_OPERAND (inner_expr, 0);
13297 if (TREE_CODE (inner_expr) == COMPONENT_REF)
13298 inner_expr = TREE_OPERAND (inner_expr, 1);
13299 if (is_overloaded_fn (inner_expr)
13300 || TREE_CODE (inner_expr) == OFFSET_REF)
13301 return expr;
13302 /* There is no need to return a proxy for a variable. */
13303 if (TREE_CODE (expr) == VAR_DECL)
13304 return expr;
13305 /* Preserve string constants; conversions from string constants to
13306 "char *" are allowed, even though normally a "const char *"
13307 cannot be used to initialize a "char *". */
13308 if (TREE_CODE (expr) == STRING_CST)
13309 return expr;
13310 /* Preserve arithmetic constants, as an optimization -- there is no
13311 reason to create a new node. */
13312 if (TREE_CODE (expr) == INTEGER_CST || TREE_CODE (expr) == REAL_CST)
13313 return expr;
13314 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
13315 There is at least one place where we want to know that a
13316 particular expression is a throw-expression: when checking a ?:
13317 expression, there are special rules if the second or third
13318 argument is a throw-expression. */
13319 if (TREE_CODE (expr) == THROW_EXPR)
13320 return expr;
13321
13322 if (TREE_CODE (expr) == COND_EXPR)
13323 return build3 (COND_EXPR,
13324 TREE_TYPE (expr),
13325 TREE_OPERAND (expr, 0),
13326 (TREE_OPERAND (expr, 1)
13327 ? build_non_dependent_expr (TREE_OPERAND (expr, 1))
13328 : build_non_dependent_expr (TREE_OPERAND (expr, 0))),
13329 build_non_dependent_expr (TREE_OPERAND (expr, 2)));
13330 if (TREE_CODE (expr) == COMPOUND_EXPR
13331 && !COMPOUND_EXPR_OVERLOADED (expr))
13332 return build2 (COMPOUND_EXPR,
13333 TREE_TYPE (expr),
13334 TREE_OPERAND (expr, 0),
13335 build_non_dependent_expr (TREE_OPERAND (expr, 1)));
13336
13337 /* If the type is unknown, it can't really be non-dependent */
13338 gcc_assert (TREE_TYPE (expr) != unknown_type_node);
13339
13340 /* Otherwise, build a NON_DEPENDENT_EXPR.
13341
13342 REFERENCE_TYPEs are not stripped for expressions in templates
13343 because doing so would play havoc with mangling. Consider, for
13344 example:
13345
13346 template <typename T> void f<T& g>() { g(); }
13347
13348 In the body of "f", the expression for "g" will have
13349 REFERENCE_TYPE, even though the standard says that it should
13350 not. The reason is that we must preserve the syntactic form of
13351 the expression so that mangling (say) "f<g>" inside the body of
13352 "f" works out correctly. Therefore, the REFERENCE_TYPE is
13353 stripped here. */
13354 return build1 (NON_DEPENDENT_EXPR, non_reference (TREE_TYPE (expr)), expr);
13355}
13356
13357/* ARGS is a TREE_LIST of expressions as arguments to a function call.
13358 Return a new TREE_LIST with the various arguments replaced with
13359 equivalent non-dependent expressions. */
13360
13361tree
13362build_non_dependent_args (tree args)
13363{
13364 tree a;
13365 tree new_args;
13366
13367 new_args = NULL_TREE;
13368 for (a = args; a; a = TREE_CHAIN (a))
13369 new_args = tree_cons (NULL_TREE,
13370 build_non_dependent_expr (TREE_VALUE (a)),
13371 new_args);
13372 return nreverse (new_args);
13373}
13374
13375#include "gt-cp-pt.h"
| 10467
10468 if (TEMPLATE_TYPE_LEVEL (parm)
10469 != template_decl_level (tparm))
10470 /* The PARM is not one we're trying to unify. Just check
10471 to see if it matches ARG. */
10472 return (TREE_CODE (arg) == TREE_CODE (parm)
10473 && same_type_p (parm, arg)) ? 0 : 1;
10474 idx = TEMPLATE_TYPE_IDX (parm);
10475 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
10476 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, idx));
10477
10478 /* Check for mixed types and values. */
10479 if ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
10480 && TREE_CODE (tparm) != TYPE_DECL)
10481 || (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
10482 && TREE_CODE (tparm) != TEMPLATE_DECL))
10483 return 1;
10484
10485 if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
10486 {
10487 /* ARG must be constructed from a template class or a template
10488 template parameter. */
10489 if (TREE_CODE (arg) != BOUND_TEMPLATE_TEMPLATE_PARM
10490 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg))
10491 return 1;
10492
10493 {
10494 tree parmvec = TYPE_TI_ARGS (parm);
10495 tree argvec = INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg));
10496 tree argtmplvec
10497 = DECL_INNERMOST_TEMPLATE_PARMS (TYPE_TI_TEMPLATE (arg));
10498 int i;
10499
10500 /* The resolution to DR150 makes clear that default
10501 arguments for an N-argument may not be used to bind T
10502 to a template template parameter with fewer than N
10503 parameters. It is not safe to permit the binding of
10504 default arguments as an extension, as that may change
10505 the meaning of a conforming program. Consider:
10506
10507 struct Dense { static const unsigned int dim = 1; };
10508
10509 template <template <typename> class View,
10510 typename Block>
10511 void operator+(float, View<Block> const&);
10512
10513 template <typename Block,
10514 unsigned int Dim = Block::dim>
10515 struct Lvalue_proxy { operator float() const; };
10516
10517 void
10518 test_1d (void) {
10519 Lvalue_proxy<Dense> p;
10520 float b;
10521 b + p;
10522 }
10523
10524 Here, if Lvalue_proxy is permitted to bind to View, then
10525 the global operator+ will be used; if they are not, the
10526 Lvalue_proxy will be converted to float. */
10527 if (coerce_template_parms (argtmplvec, parmvec,
10528 TYPE_TI_TEMPLATE (parm),
10529 tf_none,
10530 /*require_all_args=*/true,
10531 /*use_default_args=*/false)
10532 == error_mark_node)
10533 return 1;
10534
10535 /* Deduce arguments T, i from TT<T> or TT<i>.
10536 We check each element of PARMVEC and ARGVEC individually
10537 rather than the whole TREE_VEC since they can have
10538 different number of elements. */
10539
10540 for (i = 0; i < TREE_VEC_LENGTH (parmvec); ++i)
10541 {
10542 if (unify (tparms, targs,
10543 TREE_VEC_ELT (parmvec, i),
10544 TREE_VEC_ELT (argvec, i),
10545 UNIFY_ALLOW_NONE))
10546 return 1;
10547 }
10548 }
10549 arg = TYPE_TI_TEMPLATE (arg);
10550
10551 /* Fall through to deduce template name. */
10552 }
10553
10554 if (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
10555 || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
10556 {
10557 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
10558
10559 /* Simple cases: Value already set, does match or doesn't. */
10560 if (targ != NULL_TREE && template_args_equal (targ, arg))
10561 return 0;
10562 else if (targ)
10563 return 1;
10564 }
10565 else
10566 {
10567 /* If PARM is `const T' and ARG is only `int', we don't have
10568 a match unless we are allowing additional qualification.
10569 If ARG is `const int' and PARM is just `T' that's OK;
10570 that binds `const int' to `T'. */
10571 if (!check_cv_quals_for_unify (strict_in | UNIFY_ALLOW_LESS_CV_QUAL,
10572 arg, parm))
10573 return 1;
10574
10575 /* Consider the case where ARG is `const volatile int' and
10576 PARM is `const T'. Then, T should be `volatile int'. */
10577 arg = cp_build_qualified_type_real
10578 (arg, cp_type_quals (arg) & ~cp_type_quals (parm), tf_none);
10579 if (arg == error_mark_node)
10580 return 1;
10581
10582 /* Simple cases: Value already set, does match or doesn't. */
10583 if (targ != NULL_TREE && same_type_p (targ, arg))
10584 return 0;
10585 else if (targ)
10586 return 1;
10587
10588 /* Make sure that ARG is not a variable-sized array. (Note
10589 that were talking about variable-sized arrays (like
10590 `int[n]'), rather than arrays of unknown size (like
10591 `int[]').) We'll get very confused by such a type since
10592 the bound of the array will not be computable in an
10593 instantiation. Besides, such types are not allowed in
10594 ISO C++, so we can do as we please here. */
10595 if (variably_modified_type_p (arg, NULL_TREE))
10596 return 1;
10597 }
10598
10599 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
10600 return 0;
10601
10602 case TEMPLATE_PARM_INDEX:
10603 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
10604 if (tparm == error_mark_node)
10605 return 1;
10606
10607 if (TEMPLATE_PARM_LEVEL (parm)
10608 != template_decl_level (tparm))
10609 /* The PARM is not one we're trying to unify. Just check
10610 to see if it matches ARG. */
10611 return !(TREE_CODE (arg) == TREE_CODE (parm)
10612 && cp_tree_equal (parm, arg));
10613
10614 idx = TEMPLATE_PARM_IDX (parm);
10615 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
10616
10617 if (targ)
10618 return !cp_tree_equal (targ, arg);
10619
10620 /* [temp.deduct.type] If, in the declaration of a function template
10621 with a non-type template-parameter, the non-type
10622 template-parameter is used in an expression in the function
10623 parameter-list and, if the corresponding template-argument is
10624 deduced, the template-argument type shall match the type of the
10625 template-parameter exactly, except that a template-argument
10626 deduced from an array bound may be of any integral type.
10627 The non-type parameter might use already deduced type parameters. */
10628 tparm = tsubst (TREE_TYPE (parm), targs, 0, NULL_TREE);
10629 if (!TREE_TYPE (arg))
10630 /* Template-parameter dependent expression. Just accept it for now.
10631 It will later be processed in convert_template_argument. */
10632 ;
10633 else if (same_type_p (TREE_TYPE (arg), tparm))
10634 /* OK */;
10635 else if ((strict & UNIFY_ALLOW_INTEGER)
10636 && (TREE_CODE (tparm) == INTEGER_TYPE
10637 || TREE_CODE (tparm) == BOOLEAN_TYPE))
10638 /* Convert the ARG to the type of PARM; the deduced non-type
10639 template argument must exactly match the types of the
10640 corresponding parameter. */
10641 arg = fold (build_nop (TREE_TYPE (parm), arg));
10642 else if (uses_template_parms (tparm))
10643 /* We haven't deduced the type of this parameter yet. Try again
10644 later. */
10645 return 0;
10646 else
10647 return 1;
10648
10649 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
10650 return 0;
10651
10652 case PTRMEM_CST:
10653 {
10654 /* A pointer-to-member constant can be unified only with
10655 another constant. */
10656 if (TREE_CODE (arg) != PTRMEM_CST)
10657 return 1;
10658
10659 /* Just unify the class member. It would be useless (and possibly
10660 wrong, depending on the strict flags) to unify also
10661 PTRMEM_CST_CLASS, because we want to be sure that both parm and
10662 arg refer to the same variable, even if through different
10663 classes. For instance:
10664
10665 struct A { int x; };
10666 struct B : A { };
10667
10668 Unification of &A::x and &B::x must succeed. */
10669 return unify (tparms, targs, PTRMEM_CST_MEMBER (parm),
10670 PTRMEM_CST_MEMBER (arg), strict);
10671 }
10672
10673 case POINTER_TYPE:
10674 {
10675 if (TREE_CODE (arg) != POINTER_TYPE)
10676 return 1;
10677
10678 /* [temp.deduct.call]
10679
10680 A can be another pointer or pointer to member type that can
10681 be converted to the deduced A via a qualification
10682 conversion (_conv.qual_).
10683
10684 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
10685 This will allow for additional cv-qualification of the
10686 pointed-to types if appropriate. */
10687
10688 if (TREE_CODE (TREE_TYPE (arg)) == RECORD_TYPE)
10689 /* The derived-to-base conversion only persists through one
10690 level of pointers. */
10691 strict |= (strict_in & UNIFY_ALLOW_DERIVED);
10692
10693 return unify (tparms, targs, TREE_TYPE (parm),
10694 TREE_TYPE (arg), strict);
10695 }
10696
10697 case REFERENCE_TYPE:
10698 if (TREE_CODE (arg) != REFERENCE_TYPE)
10699 return 1;
10700 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
10701 strict & UNIFY_ALLOW_MORE_CV_QUAL);
10702
10703 case ARRAY_TYPE:
10704 if (TREE_CODE (arg) != ARRAY_TYPE)
10705 return 1;
10706 if ((TYPE_DOMAIN (parm) == NULL_TREE)
10707 != (TYPE_DOMAIN (arg) == NULL_TREE))
10708 return 1;
10709 if (TYPE_DOMAIN (parm) != NULL_TREE)
10710 {
10711 tree parm_max;
10712 tree arg_max;
10713 bool parm_cst;
10714 bool arg_cst;
10715
10716 /* Our representation of array types uses "N - 1" as the
10717 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
10718 not an integer constant. We cannot unify arbitrarily
10719 complex expressions, so we eliminate the MINUS_EXPRs
10720 here. */
10721 parm_max = TYPE_MAX_VALUE (TYPE_DOMAIN (parm));
10722 parm_cst = TREE_CODE (parm_max) == INTEGER_CST;
10723 if (!parm_cst)
10724 {
10725 gcc_assert (TREE_CODE (parm_max) == MINUS_EXPR);
10726 parm_max = TREE_OPERAND (parm_max, 0);
10727 }
10728 arg_max = TYPE_MAX_VALUE (TYPE_DOMAIN (arg));
10729 arg_cst = TREE_CODE (arg_max) == INTEGER_CST;
10730 if (!arg_cst)
10731 {
10732 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
10733 trying to unify the type of a variable with the type
10734 of a template parameter. For example:
10735
10736 template <unsigned int N>
10737 void f (char (&) [N]);
10738 int g();
10739 void h(int i) {
10740 char a[g(i)];
10741 f(a);
10742 }
10743
10744 Here, the type of the ARG will be "int [g(i)]", and
10745 may be a SAVE_EXPR, etc. */
10746 if (TREE_CODE (arg_max) != MINUS_EXPR)
10747 return 1;
10748 arg_max = TREE_OPERAND (arg_max, 0);
10749 }
10750
10751 /* If only one of the bounds used a MINUS_EXPR, compensate
10752 by adding one to the other bound. */
10753 if (parm_cst && !arg_cst)
10754 parm_max = fold_build2 (PLUS_EXPR,
10755 integer_type_node,
10756 parm_max,
10757 integer_one_node);
10758 else if (arg_cst && !parm_cst)
10759 arg_max = fold_build2 (PLUS_EXPR,
10760 integer_type_node,
10761 arg_max,
10762 integer_one_node);
10763
10764 if (unify (tparms, targs, parm_max, arg_max, UNIFY_ALLOW_INTEGER))
10765 return 1;
10766 }
10767 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
10768 strict & UNIFY_ALLOW_MORE_CV_QUAL);
10769
10770 case REAL_TYPE:
10771 case COMPLEX_TYPE:
10772 case VECTOR_TYPE:
10773 case INTEGER_TYPE:
10774 case BOOLEAN_TYPE:
10775 case ENUMERAL_TYPE:
10776 case VOID_TYPE:
10777 if (TREE_CODE (arg) != TREE_CODE (parm))
10778 return 1;
10779
10780 /* We have already checked cv-qualification at the top of the
10781 function. */
10782 if (!same_type_ignoring_top_level_qualifiers_p (arg, parm))
10783 return 1;
10784
10785 /* As far as unification is concerned, this wins. Later checks
10786 will invalidate it if necessary. */
10787 return 0;
10788
10789 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
10790 /* Type INTEGER_CST can come from ordinary constant template args. */
10791 case INTEGER_CST:
10792 while (TREE_CODE (arg) == NOP_EXPR)
10793 arg = TREE_OPERAND (arg, 0);
10794
10795 if (TREE_CODE (arg) != INTEGER_CST)
10796 return 1;
10797 return !tree_int_cst_equal (parm, arg);
10798
10799 case TREE_VEC:
10800 {
10801 int i;
10802 if (TREE_CODE (arg) != TREE_VEC)
10803 return 1;
10804 if (TREE_VEC_LENGTH (parm) != TREE_VEC_LENGTH (arg))
10805 return 1;
10806 for (i = 0; i < TREE_VEC_LENGTH (parm); ++i)
10807 if (unify (tparms, targs,
10808 TREE_VEC_ELT (parm, i), TREE_VEC_ELT (arg, i),
10809 UNIFY_ALLOW_NONE))
10810 return 1;
10811 return 0;
10812 }
10813
10814 case RECORD_TYPE:
10815 case UNION_TYPE:
10816 if (TREE_CODE (arg) != TREE_CODE (parm))
10817 return 1;
10818
10819 if (TYPE_PTRMEMFUNC_P (parm))
10820 {
10821 if (!TYPE_PTRMEMFUNC_P (arg))
10822 return 1;
10823
10824 return unify (tparms, targs,
10825 TYPE_PTRMEMFUNC_FN_TYPE (parm),
10826 TYPE_PTRMEMFUNC_FN_TYPE (arg),
10827 strict);
10828 }
10829
10830 if (CLASSTYPE_TEMPLATE_INFO (parm))
10831 {
10832 tree t = NULL_TREE;
10833
10834 if (strict_in & UNIFY_ALLOW_DERIVED)
10835 {
10836 /* First, we try to unify the PARM and ARG directly. */
10837 t = try_class_unification (tparms, targs,
10838 parm, arg);
10839
10840 if (!t)
10841 {
10842 /* Fallback to the special case allowed in
10843 [temp.deduct.call]:
10844
10845 If P is a class, and P has the form
10846 template-id, then A can be a derived class of
10847 the deduced A. Likewise, if P is a pointer to
10848 a class of the form template-id, A can be a
10849 pointer to a derived class pointed to by the
10850 deduced A. */
10851 t = get_template_base (tparms, targs, parm, arg);
10852
10853 if (!t)
10854 return 1;
10855 }
10856 }
10857 else if (CLASSTYPE_TEMPLATE_INFO (arg)
10858 && (CLASSTYPE_TI_TEMPLATE (parm)
10859 == CLASSTYPE_TI_TEMPLATE (arg)))
10860 /* Perhaps PARM is something like S<U> and ARG is S<int>.
10861 Then, we should unify `int' and `U'. */
10862 t = arg;
10863 else
10864 /* There's no chance of unification succeeding. */
10865 return 1;
10866
10867 return unify (tparms, targs, CLASSTYPE_TI_ARGS (parm),
10868 CLASSTYPE_TI_ARGS (t), UNIFY_ALLOW_NONE);
10869 }
10870 else if (!same_type_ignoring_top_level_qualifiers_p (parm, arg))
10871 return 1;
10872 return 0;
10873
10874 case METHOD_TYPE:
10875 case FUNCTION_TYPE:
10876 if (TREE_CODE (arg) != TREE_CODE (parm))
10877 return 1;
10878
10879 /* CV qualifications for methods can never be deduced, they must
10880 match exactly. We need to check them explicitly here,
10881 because type_unification_real treats them as any other
10882 cvqualified parameter. */
10883 if (TREE_CODE (parm) == METHOD_TYPE
10884 && (!check_cv_quals_for_unify
10885 (UNIFY_ALLOW_NONE,
10886 TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (arg))),
10887 TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (parm))))))
10888 return 1;
10889
10890 if (unify (tparms, targs, TREE_TYPE (parm),
10891 TREE_TYPE (arg), UNIFY_ALLOW_NONE))
10892 return 1;
10893 return type_unification_real (tparms, targs, TYPE_ARG_TYPES (parm),
10894 TYPE_ARG_TYPES (arg), 1, DEDUCE_EXACT,
10895 LOOKUP_NORMAL);
10896
10897 case OFFSET_TYPE:
10898 /* Unify a pointer to member with a pointer to member function, which
10899 deduces the type of the member as a function type. */
10900 if (TYPE_PTRMEMFUNC_P (arg))
10901 {
10902 tree method_type;
10903 tree fntype;
10904 cp_cv_quals cv_quals;
10905
10906 /* Check top-level cv qualifiers */
10907 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE, arg, parm))
10908 return 1;
10909
10910 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
10911 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg), UNIFY_ALLOW_NONE))
10912 return 1;
10913
10914 /* Determine the type of the function we are unifying against. */
10915 method_type = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (arg));
10916 fntype =
10917 build_function_type (TREE_TYPE (method_type),
10918 TREE_CHAIN (TYPE_ARG_TYPES (method_type)));
10919
10920 /* Extract the cv-qualifiers of the member function from the
10921 implicit object parameter and place them on the function
10922 type to be restored later. */
10923 cv_quals =
10924 cp_type_quals(TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (method_type))));
10925 fntype = build_qualified_type (fntype, cv_quals);
10926 return unify (tparms, targs, TREE_TYPE (parm), fntype, strict);
10927 }
10928
10929 if (TREE_CODE (arg) != OFFSET_TYPE)
10930 return 1;
10931 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
10932 TYPE_OFFSET_BASETYPE (arg), UNIFY_ALLOW_NONE))
10933 return 1;
10934 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
10935 strict);
10936
10937 case CONST_DECL:
10938 if (DECL_TEMPLATE_PARM_P (parm))
10939 return unify (tparms, targs, DECL_INITIAL (parm), arg, strict);
10940 if (arg != integral_constant_value (parm))
10941 return 1;
10942 return 0;
10943
10944 case FIELD_DECL:
10945 case TEMPLATE_DECL:
10946 /* Matched cases are handled by the ARG == PARM test above. */
10947 return 1;
10948
10949 default:
10950 gcc_assert (EXPR_P (parm));
10951
10952 /* We must be looking at an expression. This can happen with
10953 something like:
10954
10955 template <int I>
10956 void foo(S<I>, S<I + 2>);
10957
10958 This is a "nondeduced context":
10959
10960 [deduct.type]
10961
10962 The nondeduced contexts are:
10963
10964 --A type that is a template-id in which one or more of
10965 the template-arguments is an expression that references
10966 a template-parameter.
10967
10968 In these cases, we assume deduction succeeded, but don't
10969 actually infer any unifications. */
10970
10971 if (!uses_template_parms (parm)
10972 && !template_args_equal (parm, arg))
10973 return 1;
10974 else
10975 return 0;
10976 }
10977}
10978
10979/* Note that DECL can be defined in this translation unit, if
10980 required. */
10981
10982static void
10983mark_definable (tree decl)
10984{
10985 tree clone;
10986 DECL_NOT_REALLY_EXTERN (decl) = 1;
10987 FOR_EACH_CLONE (clone, decl)
10988 DECL_NOT_REALLY_EXTERN (clone) = 1;
10989}
10990
10991/* Called if RESULT is explicitly instantiated, or is a member of an
10992 explicitly instantiated class. */
10993
10994void
10995mark_decl_instantiated (tree result, int extern_p)
10996{
10997 SET_DECL_EXPLICIT_INSTANTIATION (result);
10998
10999 /* If this entity has already been written out, it's too late to
11000 make any modifications. */
11001 if (TREE_ASM_WRITTEN (result))
11002 return;
11003
11004 if (TREE_CODE (result) != FUNCTION_DECL)
11005 /* The TREE_PUBLIC flag for function declarations will have been
11006 set correctly by tsubst. */
11007 TREE_PUBLIC (result) = 1;
11008
11009 /* This might have been set by an earlier implicit instantiation. */
11010 DECL_COMDAT (result) = 0;
11011
11012 if (extern_p)
11013 DECL_NOT_REALLY_EXTERN (result) = 0;
11014 else
11015 {
11016 mark_definable (result);
11017 /* Always make artificials weak. */
11018 if (DECL_ARTIFICIAL (result) && flag_weak)
11019 comdat_linkage (result);
11020 /* For WIN32 we also want to put explicit instantiations in
11021 linkonce sections. */
11022 else if (TREE_PUBLIC (result))
11023 maybe_make_one_only (result);
11024 }
11025
11026 /* If EXTERN_P, then this function will not be emitted -- unless
11027 followed by an explicit instantiation, at which point its linkage
11028 will be adjusted. If !EXTERN_P, then this function will be
11029 emitted here. In neither circumstance do we want
11030 import_export_decl to adjust the linkage. */
11031 DECL_INTERFACE_KNOWN (result) = 1;
11032}
11033
11034/* Given two function templates PAT1 and PAT2, return:
11035
11036 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
11037 -1 if PAT2 is more specialized than PAT1.
11038 0 if neither is more specialized.
11039
11040 LEN indicates the number of parameters we should consider
11041 (defaulted parameters should not be considered).
11042
11043 The 1998 std underspecified function template partial ordering, and
11044 DR214 addresses the issue. We take pairs of arguments, one from
11045 each of the templates, and deduce them against each other. One of
11046 the templates will be more specialized if all the *other*
11047 template's arguments deduce against its arguments and at least one
11048 of its arguments *does* *not* deduce against the other template's
11049 corresponding argument. Deduction is done as for class templates.
11050 The arguments used in deduction have reference and top level cv
11051 qualifiers removed. Iff both arguments were originally reference
11052 types *and* deduction succeeds in both directions, the template
11053 with the more cv-qualified argument wins for that pairing (if
11054 neither is more cv-qualified, they both are equal). Unlike regular
11055 deduction, after all the arguments have been deduced in this way,
11056 we do *not* verify the deduced template argument values can be
11057 substituted into non-deduced contexts, nor do we have to verify
11058 that all template arguments have been deduced. */
11059
11060int
11061more_specialized_fn (tree pat1, tree pat2, int len)
11062{
11063 tree decl1 = DECL_TEMPLATE_RESULT (pat1);
11064 tree decl2 = DECL_TEMPLATE_RESULT (pat2);
11065 tree targs1 = make_tree_vec (DECL_NTPARMS (pat1));
11066 tree targs2 = make_tree_vec (DECL_NTPARMS (pat2));
11067 tree tparms1 = DECL_INNERMOST_TEMPLATE_PARMS (pat1);
11068 tree tparms2 = DECL_INNERMOST_TEMPLATE_PARMS (pat2);
11069 tree args1 = TYPE_ARG_TYPES (TREE_TYPE (decl1));
11070 tree args2 = TYPE_ARG_TYPES (TREE_TYPE (decl2));
11071 int better1 = 0;
11072 int better2 = 0;
11073
11074 /* Remove the this parameter from non-static member functions. If
11075 one is a non-static member function and the other is not a static
11076 member function, remove the first parameter from that function
11077 also. This situation occurs for operator functions where we
11078 locate both a member function (with this pointer) and non-member
11079 operator (with explicit first operand). */
11080 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1))
11081 {
11082 len--; /* LEN is the number of significant arguments for DECL1 */
11083 args1 = TREE_CHAIN (args1);
11084 if (!DECL_STATIC_FUNCTION_P (decl2))
11085 args2 = TREE_CHAIN (args2);
11086 }
11087 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2))
11088 {
11089 args2 = TREE_CHAIN (args2);
11090 if (!DECL_STATIC_FUNCTION_P (decl1))
11091 {
11092 len--;
11093 args1 = TREE_CHAIN (args1);
11094 }
11095 }
11096
11097 /* If only one is a conversion operator, they are unordered. */
11098 if (DECL_CONV_FN_P (decl1) != DECL_CONV_FN_P (decl2))
11099 return 0;
11100
11101 /* Consider the return type for a conversion function */
11102 if (DECL_CONV_FN_P (decl1))
11103 {
11104 args1 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl1)), args1);
11105 args2 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl2)), args2);
11106 len++;
11107 }
11108
11109 processing_template_decl++;
11110
11111 while (len--)
11112 {
11113 tree arg1 = TREE_VALUE (args1);
11114 tree arg2 = TREE_VALUE (args2);
11115 int deduce1, deduce2;
11116 int quals1 = -1;
11117 int quals2 = -1;
11118
11119 if (TREE_CODE (arg1) == REFERENCE_TYPE)
11120 {
11121 arg1 = TREE_TYPE (arg1);
11122 quals1 = cp_type_quals (arg1);
11123 }
11124
11125 if (TREE_CODE (arg2) == REFERENCE_TYPE)
11126 {
11127 arg2 = TREE_TYPE (arg2);
11128 quals2 = cp_type_quals (arg2);
11129 }
11130
11131 if ((quals1 < 0) != (quals2 < 0))
11132 {
11133 /* Only of the args is a reference, see if we should apply
11134 array/function pointer decay to it. This is not part of
11135 DR214, but is, IMHO, consistent with the deduction rules
11136 for the function call itself, and with our earlier
11137 implementation of the underspecified partial ordering
11138 rules. (nathan). */
11139 if (quals1 >= 0)
11140 {
11141 switch (TREE_CODE (arg1))
11142 {
11143 case ARRAY_TYPE:
11144 arg1 = TREE_TYPE (arg1);
11145 /* FALLTHROUGH. */
11146 case FUNCTION_TYPE:
11147 arg1 = build_pointer_type (arg1);
11148 break;
11149
11150 default:
11151 break;
11152 }
11153 }
11154 else
11155 {
11156 switch (TREE_CODE (arg2))
11157 {
11158 case ARRAY_TYPE:
11159 arg2 = TREE_TYPE (arg2);
11160 /* FALLTHROUGH. */
11161 case FUNCTION_TYPE:
11162 arg2 = build_pointer_type (arg2);
11163 break;
11164
11165 default:
11166 break;
11167 }
11168 }
11169 }
11170
11171 arg1 = TYPE_MAIN_VARIANT (arg1);
11172 arg2 = TYPE_MAIN_VARIANT (arg2);
11173
11174 deduce1 = !unify (tparms1, targs1, arg1, arg2, UNIFY_ALLOW_NONE);
11175 deduce2 = !unify (tparms2, targs2, arg2, arg1, UNIFY_ALLOW_NONE);
11176
11177 if (!deduce1)
11178 better2 = -1;
11179 if (!deduce2)
11180 better1 = -1;
11181 if (better1 < 0 && better2 < 0)
11182 /* We've failed to deduce something in either direction.
11183 These must be unordered. */
11184 break;
11185
11186 if (deduce1 && deduce2 && quals1 >= 0 && quals2 >= 0)
11187 {
11188 /* Deduces in both directions, see if quals can
11189 disambiguate. Pretend the worse one failed to deduce. */
11190 if ((quals1 & quals2) == quals2)
11191 deduce1 = 0;
11192 if ((quals1 & quals2) == quals1)
11193 deduce2 = 0;
11194 }
11195 if (deduce1 && !deduce2 && !better2)
11196 better2 = 1;
11197 if (deduce2 && !deduce1 && !better1)
11198 better1 = 1;
11199
11200 args1 = TREE_CHAIN (args1);
11201 args2 = TREE_CHAIN (args2);
11202 }
11203
11204 processing_template_decl--;
11205
11206 return (better1 > 0) - (better2 > 0);
11207}
11208
11209/* Determine which of two partial specializations is more specialized.
11210
11211 PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
11212 to the first partial specialization. The TREE_VALUE is the
11213 innermost set of template parameters for the partial
11214 specialization. PAT2 is similar, but for the second template.
11215
11216 Return 1 if the first partial specialization is more specialized;
11217 -1 if the second is more specialized; 0 if neither is more
11218 specialized.
11219
11220 See [temp.class.order] for information about determining which of
11221 two templates is more specialized. */
11222
11223static int
11224more_specialized_class (tree pat1, tree pat2)
11225{
11226 tree targs;
11227 tree tmpl1, tmpl2;
11228 int winner = 0;
11229
11230 tmpl1 = TREE_TYPE (pat1);
11231 tmpl2 = TREE_TYPE (pat2);
11232
11233 /* Just like what happens for functions, if we are ordering between
11234 different class template specializations, we may encounter dependent
11235 types in the arguments, and we need our dependency check functions
11236 to behave correctly. */
11237 ++processing_template_decl;
11238 targs = get_class_bindings (TREE_VALUE (pat1),
11239 CLASSTYPE_TI_ARGS (tmpl1),
11240 CLASSTYPE_TI_ARGS (tmpl2));
11241 if (targs)
11242 --winner;
11243
11244 targs = get_class_bindings (TREE_VALUE (pat2),
11245 CLASSTYPE_TI_ARGS (tmpl2),
11246 CLASSTYPE_TI_ARGS (tmpl1));
11247 if (targs)
11248 ++winner;
11249 --processing_template_decl;
11250
11251 return winner;
11252}
11253
11254/* Return the template arguments that will produce the function signature
11255 DECL from the function template FN, with the explicit template
11256 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
11257 also match. Return NULL_TREE if no satisfactory arguments could be
11258 found. */
11259
11260static tree
11261get_bindings (tree fn, tree decl, tree explicit_args, bool check_rettype)
11262{
11263 int ntparms = DECL_NTPARMS (fn);
11264 tree targs = make_tree_vec (ntparms);
11265 tree decl_type;
11266 tree decl_arg_types;
11267
11268 /* Substitute the explicit template arguments into the type of DECL.
11269 The call to fn_type_unification will handle substitution into the
11270 FN. */
11271 decl_type = TREE_TYPE (decl);
11272 if (explicit_args && uses_template_parms (decl_type))
11273 {
11274 tree tmpl;
11275 tree converted_args;
11276
11277 if (DECL_TEMPLATE_INFO (decl))
11278 tmpl = DECL_TI_TEMPLATE (decl);
11279 else
11280 /* We can get here for some invalid specializations. */
11281 return NULL_TREE;
11282
11283 converted_args
11284 = coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
11285 explicit_args, NULL_TREE,
11286 tf_none,
11287 /*require_all_args=*/false,
11288 /*use_default_args=*/false);
11289 if (converted_args == error_mark_node)
11290 return NULL_TREE;
11291
11292 decl_type = tsubst (decl_type, converted_args, tf_none, NULL_TREE);
11293 if (decl_type == error_mark_node)
11294 return NULL_TREE;
11295 }
11296
11297 /* Never do unification on the 'this' parameter. */
11298 decl_arg_types = skip_artificial_parms_for (decl,
11299 TYPE_ARG_TYPES (decl_type));
11300
11301 if (fn_type_unification (fn, explicit_args, targs,
11302 decl_arg_types,
11303 (check_rettype || DECL_CONV_FN_P (fn)
11304 ? TREE_TYPE (decl_type) : NULL_TREE),
11305 DEDUCE_EXACT, LOOKUP_NORMAL))
11306 return NULL_TREE;
11307
11308 return targs;
11309}
11310
11311/* Return the innermost template arguments that, when applied to a
11312 template specialization whose innermost template parameters are
11313 TPARMS, and whose specialization arguments are PARMS, yield the
11314 ARGS.
11315
11316 For example, suppose we have:
11317
11318 template <class T, class U> struct S {};
11319 template <class T> struct S<T*, int> {};
11320
11321 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
11322 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
11323 int}. The resulting vector will be {double}, indicating that `T'
11324 is bound to `double'. */
11325
11326static tree
11327get_class_bindings (tree tparms, tree spec_args, tree args)
11328{
11329 int i, ntparms = TREE_VEC_LENGTH (tparms);
11330 tree deduced_args;
11331 tree innermost_deduced_args;
11332
11333 innermost_deduced_args = make_tree_vec (ntparms);
11334 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
11335 {
11336 deduced_args = copy_node (args);
11337 SET_TMPL_ARGS_LEVEL (deduced_args,
11338 TMPL_ARGS_DEPTH (deduced_args),
11339 innermost_deduced_args);
11340 }
11341 else
11342 deduced_args = innermost_deduced_args;
11343
11344 if (unify (tparms, deduced_args,
11345 INNERMOST_TEMPLATE_ARGS (spec_args),
11346 INNERMOST_TEMPLATE_ARGS (args),
11347 UNIFY_ALLOW_NONE))
11348 return NULL_TREE;
11349
11350 for (i = 0; i < ntparms; ++i)
11351 if (! TREE_VEC_ELT (innermost_deduced_args, i))
11352 return NULL_TREE;
11353
11354 /* Verify that nondeduced template arguments agree with the type
11355 obtained from argument deduction.
11356
11357 For example:
11358
11359 struct A { typedef int X; };
11360 template <class T, class U> struct C {};
11361 template <class T> struct C<T, typename T::X> {};
11362
11363 Then with the instantiation `C<A, int>', we can deduce that
11364 `T' is `A' but unify () does not check whether `typename T::X'
11365 is `int'. */
11366 spec_args = tsubst (spec_args, deduced_args, tf_none, NULL_TREE);
11367 if (spec_args == error_mark_node
11368 /* We only need to check the innermost arguments; the other
11369 arguments will always agree. */
11370 || !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args),
11371 INNERMOST_TEMPLATE_ARGS (args)))
11372 return NULL_TREE;
11373
11374 return deduced_args;
11375}
11376
11377/* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
11378 Return the TREE_LIST node with the most specialized template, if
11379 any. If there is no most specialized template, the error_mark_node
11380 is returned.
11381
11382 Note that this function does not look at, or modify, the
11383 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
11384 returned is one of the elements of INSTANTIATIONS, callers may
11385 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
11386 and retrieve it from the value returned. */
11387
11388tree
11389most_specialized_instantiation (tree templates)
11390{
11391 tree fn, champ;
11392
11393 ++processing_template_decl;
11394
11395 champ = templates;
11396 for (fn = TREE_CHAIN (templates); fn; fn = TREE_CHAIN (fn))
11397 {
11398 int fate = 0;
11399
11400 if (get_bindings (TREE_VALUE (champ),
11401 DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
11402 NULL_TREE, /*check_ret=*/false))
11403 fate--;
11404
11405 if (get_bindings (TREE_VALUE (fn),
11406 DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
11407 NULL_TREE, /*check_ret=*/false))
11408 fate++;
11409
11410 if (fate == -1)
11411 champ = fn;
11412 else if (!fate)
11413 {
11414 /* Equally specialized, move to next function. If there
11415 is no next function, nothing's most specialized. */
11416 fn = TREE_CHAIN (fn);
11417 champ = fn;
11418 if (!fn)
11419 break;
11420 }
11421 }
11422
11423 if (champ)
11424 /* Now verify that champ is better than everything earlier in the
11425 instantiation list. */
11426 for (fn = templates; fn != champ; fn = TREE_CHAIN (fn))
11427 if (get_bindings (TREE_VALUE (champ),
11428 DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
11429 NULL_TREE, /*check_ret=*/false)
11430 || !get_bindings (TREE_VALUE (fn),
11431 DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
11432 NULL_TREE, /*check_ret=*/false))
11433 {
11434 champ = NULL_TREE;
11435 break;
11436 }
11437
11438 processing_template_decl--;
11439
11440 if (!champ)
11441 return error_mark_node;
11442
11443 return champ;
11444}
11445
11446/* If DECL is a specialization of some template, return the most
11447 general such template. Otherwise, returns NULL_TREE.
11448
11449 For example, given:
11450
11451 template <class T> struct S { template <class U> void f(U); };
11452
11453 if TMPL is `template <class U> void S<int>::f(U)' this will return
11454 the full template. This function will not trace past partial
11455 specializations, however. For example, given in addition:
11456
11457 template <class T> struct S<T*> { template <class U> void f(U); };
11458
11459 if TMPL is `template <class U> void S<int*>::f(U)' this will return
11460 `template <class T> template <class U> S<T*>::f(U)'. */
11461
11462tree
11463most_general_template (tree decl)
11464{
11465 /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
11466 an immediate specialization. */
11467 if (TREE_CODE (decl) == FUNCTION_DECL)
11468 {
11469 if (DECL_TEMPLATE_INFO (decl)) {
11470 decl = DECL_TI_TEMPLATE (decl);
11471
11472 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
11473 template friend. */
11474 if (TREE_CODE (decl) != TEMPLATE_DECL)
11475 return NULL_TREE;
11476 } else
11477 return NULL_TREE;
11478 }
11479
11480 /* Look for more and more general templates. */
11481 while (DECL_TEMPLATE_INFO (decl))
11482 {
11483 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
11484 (See cp-tree.h for details.) */
11485 if (TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
11486 break;
11487
11488 if (CLASS_TYPE_P (TREE_TYPE (decl))
11489 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)))
11490 break;
11491
11492 /* Stop if we run into an explicitly specialized class template. */
11493 if (!DECL_NAMESPACE_SCOPE_P (decl)
11494 && DECL_CONTEXT (decl)
11495 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl)))
11496 break;
11497
11498 decl = DECL_TI_TEMPLATE (decl);
11499 }
11500
11501 return decl;
11502}
11503
11504/* Return the most specialized of the class template partial
11505 specializations of TMPL which can produce TYPE, a specialization of
11506 TMPL. The value returned is actually a TREE_LIST; the TREE_TYPE is
11507 a _TYPE node corresponding to the partial specialization, while the
11508 TREE_PURPOSE is the set of template arguments that must be
11509 substituted into the TREE_TYPE in order to generate TYPE.
11510
11511 If the choice of partial specialization is ambiguous, a diagnostic
11512 is issued, and the error_mark_node is returned. If there are no
11513 partial specializations of TMPL matching TYPE, then NULL_TREE is
11514 returned. */
11515
11516static tree
11517most_specialized_class (tree type, tree tmpl)
11518{
11519 tree list = NULL_TREE;
11520 tree t;
11521 tree champ;
11522 int fate;
11523 bool ambiguous_p;
11524 tree args;
11525
11526 tmpl = most_general_template (tmpl);
11527 args = CLASSTYPE_TI_ARGS (type);
11528 for (t = DECL_TEMPLATE_SPECIALIZATIONS (tmpl); t; t = TREE_CHAIN (t))
11529 {
11530 tree partial_spec_args;
11531 tree spec_args;
11532
11533 partial_spec_args = CLASSTYPE_TI_ARGS (TREE_TYPE (t));
11534 spec_args = get_class_bindings (TREE_VALUE (t),
11535 partial_spec_args,
11536 args);
11537 if (spec_args)
11538 {
11539 list = tree_cons (spec_args, TREE_VALUE (t), list);
11540 TREE_TYPE (list) = TREE_TYPE (t);
11541 }
11542 }
11543
11544 if (! list)
11545 return NULL_TREE;
11546
11547 ambiguous_p = false;
11548 t = list;
11549 champ = t;
11550 t = TREE_CHAIN (t);
11551 for (; t; t = TREE_CHAIN (t))
11552 {
11553 fate = more_specialized_class (champ, t);
11554 if (fate == 1)
11555 ;
11556 else
11557 {
11558 if (fate == 0)
11559 {
11560 t = TREE_CHAIN (t);
11561 if (! t)
11562 {
11563 ambiguous_p = true;
11564 break;
11565 }
11566 }
11567 champ = t;
11568 }
11569 }
11570
11571 if (!ambiguous_p)
11572 for (t = list; t && t != champ; t = TREE_CHAIN (t))
11573 {
11574 fate = more_specialized_class (champ, t);
11575 if (fate != 1)
11576 {
11577 ambiguous_p = true;
11578 break;
11579 }
11580 }
11581
11582 if (ambiguous_p)
11583 {
11584 const char *str = "candidates are:";
11585 error ("ambiguous class template instantiation for %q#T", type);
11586 for (t = list; t; t = TREE_CHAIN (t))
11587 {
11588 error ("%s %+#T", str, TREE_TYPE (t));
11589 str = " ";
11590 }
11591 return error_mark_node;
11592 }
11593
11594 return champ;
11595}
11596
11597/* Explicitly instantiate DECL. */
11598
11599void
11600do_decl_instantiation (tree decl, tree storage)
11601{
11602 tree result = NULL_TREE;
11603 int extern_p = 0;
11604
11605 if (!decl || decl == error_mark_node)
11606 /* An error occurred, for which grokdeclarator has already issued
11607 an appropriate message. */
11608 return;
11609 else if (! DECL_LANG_SPECIFIC (decl))
11610 {
11611 error ("explicit instantiation of non-template %q#D", decl);
11612 return;
11613 }
11614 else if (TREE_CODE (decl) == VAR_DECL)
11615 {
11616 /* There is an asymmetry here in the way VAR_DECLs and
11617 FUNCTION_DECLs are handled by grokdeclarator. In the case of
11618 the latter, the DECL we get back will be marked as a
11619 template instantiation, and the appropriate
11620 DECL_TEMPLATE_INFO will be set up. This does not happen for
11621 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
11622 should handle VAR_DECLs as it currently handles
11623 FUNCTION_DECLs. */
11624 result = lookup_field (DECL_CONTEXT (decl), DECL_NAME (decl), 0, false);
11625 if (!result || TREE_CODE (result) != VAR_DECL)
11626 {
11627 error ("no matching template for %qD found", decl);
11628 return;
11629 }
11630 }
11631 else if (TREE_CODE (decl) != FUNCTION_DECL)
11632 {
11633 error ("explicit instantiation of %q#D", decl);
11634 return;
11635 }
11636 else
11637 result = decl;
11638
11639 /* Check for various error cases. Note that if the explicit
11640 instantiation is valid the RESULT will currently be marked as an
11641 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
11642 until we get here. */
11643
11644 if (DECL_TEMPLATE_SPECIALIZATION (result))
11645 {
11646 /* DR 259 [temp.spec].
11647
11648 Both an explicit instantiation and a declaration of an explicit
11649 specialization shall not appear in a program unless the explicit
11650 instantiation follows a declaration of the explicit specialization.
11651
11652 For a given set of template parameters, if an explicit
11653 instantiation of a template appears after a declaration of an
11654 explicit specialization for that template, the explicit
11655 instantiation has no effect. */
11656 return;
11657 }
11658 else if (DECL_EXPLICIT_INSTANTIATION (result))
11659 {
11660 /* [temp.spec]
11661
11662 No program shall explicitly instantiate any template more
11663 than once.
11664
11665 We check DECL_NOT_REALLY_EXTERN so as not to complain when
11666 the first instantiation was `extern' and the second is not,
11667 and EXTERN_P for the opposite case. */
11668 if (DECL_NOT_REALLY_EXTERN (result) && !extern_p)
11669 pedwarn ("duplicate explicit instantiation of %q#D", result);
11670 /* If an "extern" explicit instantiation follows an ordinary
11671 explicit instantiation, the template is instantiated. */
11672 if (extern_p)
11673 return;
11674 }
11675 else if (!DECL_IMPLICIT_INSTANTIATION (result))
11676 {
11677 error ("no matching template for %qD found", result);
11678 return;
11679 }
11680 else if (!DECL_TEMPLATE_INFO (result))
11681 {
11682 pedwarn ("explicit instantiation of non-template %q#D", result);
11683 return;
11684 }
11685
11686 if (storage == NULL_TREE)
11687 ;
11688 else if (storage == ridpointers[(int) RID_EXTERN])
11689 {
11690 if (pedantic && !in_system_header)
11691 pedwarn ("ISO C++ forbids the use of %<extern%> on explicit "
11692 "instantiations");
11693 extern_p = 1;
11694 }
11695 else
11696 error ("storage class %qD applied to template instantiation", storage);
11697
11698 check_explicit_instantiation_namespace (result);
11699 mark_decl_instantiated (result, extern_p);
11700 if (! extern_p)
11701 instantiate_decl (result, /*defer_ok=*/1,
11702 /*expl_inst_class_mem_p=*/false);
11703}
11704
11705static void
11706mark_class_instantiated (tree t, int extern_p)
11707{
11708 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t);
11709 SET_CLASSTYPE_INTERFACE_KNOWN (t);
11710 CLASSTYPE_INTERFACE_ONLY (t) = extern_p;
11711 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = extern_p;
11712 if (! extern_p)
11713 {
11714 CLASSTYPE_DEBUG_REQUESTED (t) = 1;
11715 rest_of_type_compilation (t, 1);
11716 }
11717}
11718
11719/* Called from do_type_instantiation through binding_table_foreach to
11720 do recursive instantiation for the type bound in ENTRY. */
11721static void
11722bt_instantiate_type_proc (binding_entry entry, void *data)
11723{
11724 tree storage = *(tree *) data;
11725
11726 if (IS_AGGR_TYPE (entry->type)
11727 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry->type)))
11728 do_type_instantiation (TYPE_MAIN_DECL (entry->type), storage, 0);
11729}
11730
11731/* Called from do_type_instantiation to instantiate a member
11732 (a member function or a static member variable) of an
11733 explicitly instantiated class template. */
11734static void
11735instantiate_class_member (tree decl, int extern_p)
11736{
11737 mark_decl_instantiated (decl, extern_p);
11738 if (! extern_p)
11739 instantiate_decl (decl, /*defer_ok=*/1,
11740 /*expl_inst_class_mem_p=*/true);
11741}
11742
11743/* Perform an explicit instantiation of template class T. STORAGE, if
11744 non-null, is the RID for extern, inline or static. COMPLAIN is
11745 nonzero if this is called from the parser, zero if called recursively,
11746 since the standard is unclear (as detailed below). */
11747
11748void
11749do_type_instantiation (tree t, tree storage, tsubst_flags_t complain)
11750{
11751 int extern_p = 0;
11752 int nomem_p = 0;
11753 int static_p = 0;
11754 int previous_instantiation_extern_p = 0;
11755
11756 if (TREE_CODE (t) == TYPE_DECL)
11757 t = TREE_TYPE (t);
11758
11759 if (! CLASS_TYPE_P (t) || ! CLASSTYPE_TEMPLATE_INFO (t))
11760 {
11761 error ("explicit instantiation of non-template type %qT", t);
11762 return;
11763 }
11764
11765 complete_type (t);
11766
11767 if (!COMPLETE_TYPE_P (t))
11768 {
11769 if (complain & tf_error)
11770 error ("explicit instantiation of %q#T before definition of template",
11771 t);
11772 return;
11773 }
11774
11775 if (storage != NULL_TREE)
11776 {
11777 if (pedantic && !in_system_header)
11778 pedwarn("ISO C++ forbids the use of %qE on explicit instantiations",
11779 storage);
11780
11781 if (storage == ridpointers[(int) RID_INLINE])
11782 nomem_p = 1;
11783 else if (storage == ridpointers[(int) RID_EXTERN])
11784 extern_p = 1;
11785 else if (storage == ridpointers[(int) RID_STATIC])
11786 static_p = 1;
11787 else
11788 {
11789 error ("storage class %qD applied to template instantiation",
11790 storage);
11791 extern_p = 0;
11792 }
11793 }
11794
11795 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
11796 {
11797 /* DR 259 [temp.spec].
11798
11799 Both an explicit instantiation and a declaration of an explicit
11800 specialization shall not appear in a program unless the explicit
11801 instantiation follows a declaration of the explicit specialization.
11802
11803 For a given set of template parameters, if an explicit
11804 instantiation of a template appears after a declaration of an
11805 explicit specialization for that template, the explicit
11806 instantiation has no effect. */
11807 return;
11808 }
11809 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t))
11810 {
11811 /* [temp.spec]
11812
11813 No program shall explicitly instantiate any template more
11814 than once.
11815
11816 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
11817 instantiation was `extern'. If EXTERN_P then the second is.
11818 These cases are OK. */
11819 previous_instantiation_extern_p = CLASSTYPE_INTERFACE_ONLY (t);
11820
11821 if (!previous_instantiation_extern_p && !extern_p
11822 && (complain & tf_error))
11823 pedwarn ("duplicate explicit instantiation of %q#T", t);
11824
11825 /* If we've already instantiated the template, just return now. */
11826 if (!CLASSTYPE_INTERFACE_ONLY (t))
11827 return;
11828 }
11829
11830 check_explicit_instantiation_namespace (TYPE_NAME (t));
11831 mark_class_instantiated (t, extern_p);
11832
11833 if (nomem_p)
11834 return;
11835
11836 {
11837 tree tmp;
11838
11839 /* In contrast to implicit instantiation, where only the
11840 declarations, and not the definitions, of members are
11841 instantiated, we have here:
11842
11843 [temp.explicit]
11844
11845 The explicit instantiation of a class template specialization
11846 implies the instantiation of all of its members not
11847 previously explicitly specialized in the translation unit
11848 containing the explicit instantiation.
11849
11850 Of course, we can't instantiate member template classes, since
11851 we don't have any arguments for them. Note that the standard
11852 is unclear on whether the instantiation of the members are
11853 *explicit* instantiations or not. However, the most natural
11854 interpretation is that it should be an explicit instantiation. */
11855
11856 if (! static_p)
11857 for (tmp = TYPE_METHODS (t); tmp; tmp = TREE_CHAIN (tmp))
11858 if (TREE_CODE (tmp) == FUNCTION_DECL
11859 && DECL_TEMPLATE_INSTANTIATION (tmp))
11860 instantiate_class_member (tmp, extern_p);
11861
11862 for (tmp = TYPE_FIELDS (t); tmp; tmp = TREE_CHAIN (tmp))
11863 if (TREE_CODE (tmp) == VAR_DECL && DECL_TEMPLATE_INSTANTIATION (tmp))
11864 instantiate_class_member (tmp, extern_p);
11865
11866 if (CLASSTYPE_NESTED_UTDS (t))
11867 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t),
11868 bt_instantiate_type_proc, &storage);
11869 }
11870}
11871
11872/* Given a function DECL, which is a specialization of TMPL, modify
11873 DECL to be a re-instantiation of TMPL with the same template
11874 arguments. TMPL should be the template into which tsubst'ing
11875 should occur for DECL, not the most general template.
11876
11877 One reason for doing this is a scenario like this:
11878
11879 template <class T>
11880 void f(const T&, int i);
11881
11882 void g() { f(3, 7); }
11883
11884 template <class T>
11885 void f(const T& t, const int i) { }
11886
11887 Note that when the template is first instantiated, with
11888 instantiate_template, the resulting DECL will have no name for the
11889 first parameter, and the wrong type for the second. So, when we go
11890 to instantiate the DECL, we regenerate it. */
11891
11892static void
11893regenerate_decl_from_template (tree decl, tree tmpl)
11894{
11895 /* The arguments used to instantiate DECL, from the most general
11896 template. */
11897 tree args;
11898 tree code_pattern;
11899
11900 args = DECL_TI_ARGS (decl);
11901 code_pattern = DECL_TEMPLATE_RESULT (tmpl);
11902
11903 /* Make sure that we can see identifiers, and compute access
11904 correctly. */
11905 push_access_scope (decl);
11906
11907 if (TREE_CODE (decl) == FUNCTION_DECL)
11908 {
11909 tree decl_parm;
11910 tree pattern_parm;
11911 tree specs;
11912 int args_depth;
11913 int parms_depth;
11914
11915 args_depth = TMPL_ARGS_DEPTH (args);
11916 parms_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
11917 if (args_depth > parms_depth)
11918 args = get_innermost_template_args (args, parms_depth);
11919
11920 specs = tsubst_exception_specification (TREE_TYPE (code_pattern),
11921 args, tf_error, NULL_TREE);
11922 if (specs)
11923 TREE_TYPE (decl) = build_exception_variant (TREE_TYPE (decl),
11924 specs);
11925
11926 /* Merge parameter declarations. */
11927 decl_parm = skip_artificial_parms_for (decl,
11928 DECL_ARGUMENTS (decl));
11929 pattern_parm
11930 = skip_artificial_parms_for (code_pattern,
11931 DECL_ARGUMENTS (code_pattern));
11932 while (decl_parm)
11933 {
11934 tree parm_type;
11935 tree attributes;
11936
11937 if (DECL_NAME (decl_parm) != DECL_NAME (pattern_parm))
11938 DECL_NAME (decl_parm) = DECL_NAME (pattern_parm);
11939 parm_type = tsubst (TREE_TYPE (pattern_parm), args, tf_error,
11940 NULL_TREE);
11941 parm_type = type_decays_to (parm_type);
11942 if (!same_type_p (TREE_TYPE (decl_parm), parm_type))
11943 TREE_TYPE (decl_parm) = parm_type;
11944 attributes = DECL_ATTRIBUTES (pattern_parm);
11945 if (DECL_ATTRIBUTES (decl_parm) != attributes)
11946 {
11947 DECL_ATTRIBUTES (decl_parm) = attributes;
11948 cplus_decl_attributes (&decl_parm, attributes, /*flags=*/0);
11949 }
11950 decl_parm = TREE_CHAIN (decl_parm);
11951 pattern_parm = TREE_CHAIN (pattern_parm);
11952 }
11953
11954 /* Merge additional specifiers from the CODE_PATTERN. */
11955 if (DECL_DECLARED_INLINE_P (code_pattern)
11956 && !DECL_DECLARED_INLINE_P (decl))
11957 DECL_DECLARED_INLINE_P (decl) = 1;
11958 if (DECL_INLINE (code_pattern) && !DECL_INLINE (decl))
11959 DECL_INLINE (decl) = 1;
11960 }
11961 else if (TREE_CODE (decl) == VAR_DECL)
11962 DECL_INITIAL (decl) =
11963 tsubst_expr (DECL_INITIAL (code_pattern), args,
11964 tf_error, DECL_TI_TEMPLATE (decl),
11965 /*integral_constant_expression_p=*/false);
11966 else
11967 gcc_unreachable ();
11968
11969 pop_access_scope (decl);
11970}
11971
11972/* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
11973 substituted to get DECL. */
11974
11975tree
11976template_for_substitution (tree decl)
11977{
11978 tree tmpl = DECL_TI_TEMPLATE (decl);
11979
11980 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
11981 for the instantiation. This is not always the most general
11982 template. Consider, for example:
11983
11984 template <class T>
11985 struct S { template <class U> void f();
11986 template <> void f<int>(); };
11987
11988 and an instantiation of S<double>::f<int>. We want TD to be the
11989 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
11990 while (/* An instantiation cannot have a definition, so we need a
11991 more general template. */
11992 DECL_TEMPLATE_INSTANTIATION (tmpl)
11993 /* We must also deal with friend templates. Given:
11994
11995 template <class T> struct S {
11996 template <class U> friend void f() {};
11997 };
11998
11999 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
12000 so far as the language is concerned, but that's still
12001 where we get the pattern for the instantiation from. On
12002 other hand, if the definition comes outside the class, say:
12003
12004 template <class T> struct S {
12005 template <class U> friend void f();
12006 };
12007 template <class U> friend void f() {}
12008
12009 we don't need to look any further. That's what the check for
12010 DECL_INITIAL is for. */
12011 || (TREE_CODE (decl) == FUNCTION_DECL
12012 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl)
12013 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl))))
12014 {
12015 /* The present template, TD, should not be a definition. If it
12016 were a definition, we should be using it! Note that we
12017 cannot restructure the loop to just keep going until we find
12018 a template with a definition, since that might go too far if
12019 a specialization was declared, but not defined. */
12020 gcc_assert (TREE_CODE (decl) != VAR_DECL
12021 || DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (tmpl)));
12022
12023 /* Fetch the more general template. */
12024 tmpl = DECL_TI_TEMPLATE (tmpl);
12025 }
12026
12027 return tmpl;
12028}
12029
12030/* Produce the definition of D, a _DECL generated from a template. If
12031 DEFER_OK is nonzero, then we don't have to actually do the
12032 instantiation now; we just have to do it sometime. Normally it is
12033 an error if this is an explicit instantiation but D is undefined.
12034 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
12035 explicitly instantiated class template. */
12036
12037tree
12038instantiate_decl (tree d, int defer_ok,
12039 bool expl_inst_class_mem_p)
12040{
12041 tree tmpl = DECL_TI_TEMPLATE (d);
12042 tree gen_args;
12043 tree args;
12044 tree td;
12045 tree code_pattern;
12046 tree spec;
12047 tree gen_tmpl;
12048 bool pattern_defined;
12049 int need_push;
12050 location_t saved_loc = input_location;
12051 int saved_in_system_header = in_system_header;
12052 bool external_p;
12053
12054 /* This function should only be used to instantiate templates for
12055 functions and static member variables. */
12056 gcc_assert (TREE_CODE (d) == FUNCTION_DECL
12057 || TREE_CODE (d) == VAR_DECL);
12058
12059 /* Variables are never deferred; if instantiation is required, they
12060 are instantiated right away. That allows for better code in the
12061 case that an expression refers to the value of the variable --
12062 if the variable has a constant value the referring expression can
12063 take advantage of that fact. */
12064 if (TREE_CODE (d) == VAR_DECL)
12065 defer_ok = 0;
12066
12067 /* Don't instantiate cloned functions. Instead, instantiate the
12068 functions they cloned. */
12069 if (TREE_CODE (d) == FUNCTION_DECL && DECL_CLONED_FUNCTION_P (d))
12070 d = DECL_CLONED_FUNCTION (d);
12071
12072 if (DECL_TEMPLATE_INSTANTIATED (d))
12073 /* D has already been instantiated. It might seem reasonable to
12074 check whether or not D is an explicit instantiation, and, if so,
12075 stop here. But when an explicit instantiation is deferred
12076 until the end of the compilation, DECL_EXPLICIT_INSTANTIATION
12077 is set, even though we still need to do the instantiation. */
12078 return d;
12079
12080 /* If we already have a specialization of this declaration, then
12081 there's no reason to instantiate it. Note that
12082 retrieve_specialization gives us both instantiations and
12083 specializations, so we must explicitly check
12084 DECL_TEMPLATE_SPECIALIZATION. */
12085 gen_tmpl = most_general_template (tmpl);
12086 gen_args = DECL_TI_ARGS (d);
12087 spec = retrieve_specialization (gen_tmpl, gen_args,
12088 /*class_specializations_p=*/false);
12089 if (spec != NULL_TREE && DECL_TEMPLATE_SPECIALIZATION (spec))
12090 return spec;
12091
12092 /* This needs to happen before any tsubsting. */
12093 if (! push_tinst_level (d))
12094 return d;
12095
12096 timevar_push (TV_PARSE);
12097
12098 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
12099 for the instantiation. */
12100 td = template_for_substitution (d);
12101 code_pattern = DECL_TEMPLATE_RESULT (td);
12102
12103 /* We should never be trying to instantiate a member of a class
12104 template or partial specialization. */
12105 gcc_assert (d != code_pattern);
12106
12107 if ((DECL_NAMESPACE_SCOPE_P (d) && !DECL_INITIALIZED_IN_CLASS_P (d))
12108 || DECL_TEMPLATE_SPECIALIZATION (td))
12109 /* In the case of a friend template whose definition is provided
12110 outside the class, we may have too many arguments. Drop the
12111 ones we don't need. The same is true for specializations. */
12112 args = get_innermost_template_args
12113 (gen_args, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td)));
12114 else
12115 args = gen_args;
12116
12117 if (TREE_CODE (d) == FUNCTION_DECL)
12118 pattern_defined = (DECL_SAVED_TREE (code_pattern) != NULL_TREE);
12119 else
12120 pattern_defined = ! DECL_IN_AGGR_P (code_pattern);
12121
12122 /* We may be in the middle of deferred access check. Disable it now. */
12123 push_deferring_access_checks (dk_no_deferred);
12124
12125 /* Unless an explicit instantiation directive has already determined
12126 the linkage of D, remember that a definition is available for
12127 this entity. */
12128 if (pattern_defined
12129 && !DECL_INTERFACE_KNOWN (d)
12130 && !DECL_NOT_REALLY_EXTERN (d))
12131 mark_definable (d);
12132
12133 input_location = DECL_SOURCE_LOCATION (d);
12134 in_system_header = DECL_IN_SYSTEM_HEADER (d);
12135
12136 /* If D is a member of an explicitly instantiated class template,
12137 and no definition is available, treat it like an implicit
12138 instantiation. */
12139 if (!pattern_defined && expl_inst_class_mem_p
12140 && DECL_EXPLICIT_INSTANTIATION (d))
12141 {
12142 DECL_NOT_REALLY_EXTERN (d) = 0;
12143 DECL_INTERFACE_KNOWN (d) = 0;
12144 SET_DECL_IMPLICIT_INSTANTIATION (d);
12145 }
12146
12147 if (!defer_ok)
12148 {
12149 /* Recheck the substitutions to obtain any warning messages
12150 about ignoring cv qualifiers. */
12151 tree gen = DECL_TEMPLATE_RESULT (gen_tmpl);
12152 tree type = TREE_TYPE (gen);
12153
12154 /* Make sure that we can see identifiers, and compute access
12155 correctly. D is already the target FUNCTION_DECL with the
12156 right context. */
12157 push_access_scope (d);
12158
12159 if (TREE_CODE (gen) == FUNCTION_DECL)
12160 {
12161 tsubst (DECL_ARGUMENTS (gen), gen_args, tf_warning_or_error, d);
12162 tsubst (TYPE_RAISES_EXCEPTIONS (type), gen_args,
12163 tf_warning_or_error, d);
12164 /* Don't simply tsubst the function type, as that will give
12165 duplicate warnings about poor parameter qualifications.
12166 The function arguments are the same as the decl_arguments
12167 without the top level cv qualifiers. */
12168 type = TREE_TYPE (type);
12169 }
12170 tsubst (type, gen_args, tf_warning_or_error, d);
12171
12172 pop_access_scope (d);
12173 }
12174
12175 /* Check to see whether we know that this template will be
12176 instantiated in some other file, as with "extern template"
12177 extension. */
12178 external_p = (DECL_INTERFACE_KNOWN (d) && DECL_REALLY_EXTERN (d));
12179 /* In general, we do not instantiate such templates... */
12180 if (external_p
12181 /* ... but we instantiate inline functions so that we can inline
12182 them and ... */
12183 && ! (TREE_CODE (d) == FUNCTION_DECL && DECL_INLINE (d))
12184 /* ... we instantiate static data members whose values are
12185 needed in integral constant expressions. */
12186 && ! (TREE_CODE (d) == VAR_DECL
12187 && DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (d)))
12188 goto out;
12189 /* Defer all other templates, unless we have been explicitly
12190 forbidden from doing so. */
12191 if (/* If there is no definition, we cannot instantiate the
12192 template. */
12193 ! pattern_defined
12194 /* If it's OK to postpone instantiation, do so. */
12195 || defer_ok
12196 /* If this is a static data member that will be defined
12197 elsewhere, we don't want to instantiate the entire data
12198 member, but we do want to instantiate the initializer so that
12199 we can substitute that elsewhere. */
12200 || (external_p && TREE_CODE (d) == VAR_DECL))
12201 {
12202 /* The definition of the static data member is now required so
12203 we must substitute the initializer. */
12204 if (TREE_CODE (d) == VAR_DECL
12205 && !DECL_INITIAL (d)
12206 && DECL_INITIAL (code_pattern))
12207 {
12208 tree ns;
12209 tree init;
12210
12211 ns = decl_namespace_context (d);
12212 push_nested_namespace (ns);
12213 push_nested_class (DECL_CONTEXT (d));
12214 init = tsubst_expr (DECL_INITIAL (code_pattern),
12215 args,
12216 tf_warning_or_error, NULL_TREE,
12217 /*integral_constant_expression_p=*/false);
12218 cp_finish_decl (d, init, /*init_const_expr_p=*/false,
12219 /*asmspec_tree=*/NULL_TREE,
12220 LOOKUP_ONLYCONVERTING);
12221 pop_nested_class ();
12222 pop_nested_namespace (ns);
12223 }
12224
12225 /* We restore the source position here because it's used by
12226 add_pending_template. */
12227 input_location = saved_loc;
12228
12229 if (at_eof && !pattern_defined
12230 && DECL_EXPLICIT_INSTANTIATION (d))
12231 /* [temp.explicit]
12232
12233 The definition of a non-exported function template, a
12234 non-exported member function template, or a non-exported
12235 member function or static data member of a class template
12236 shall be present in every translation unit in which it is
12237 explicitly instantiated. */
12238 pedwarn
12239 ("explicit instantiation of %qD but no definition available", d);
12240
12241 /* ??? Historically, we have instantiated inline functions, even
12242 when marked as "extern template". */
12243 if (!(external_p && TREE_CODE (d) == VAR_DECL))
12244 add_pending_template (d);
12245 goto out;
12246 }
12247 /* Tell the repository that D is available in this translation unit
12248 -- and see if it is supposed to be instantiated here. */
12249 if (TREE_PUBLIC (d) && !DECL_REALLY_EXTERN (d) && !repo_emit_p (d))
12250 {
12251 /* In a PCH file, despite the fact that the repository hasn't
12252 requested instantiation in the PCH it is still possible that
12253 an instantiation will be required in a file that includes the
12254 PCH. */
12255 if (pch_file)
12256 add_pending_template (d);
12257 /* Instantiate inline functions so that the inliner can do its
12258 job, even though we'll not be emitting a copy of this
12259 function. */
12260 if (!(TREE_CODE (d) == FUNCTION_DECL
12261 && flag_inline_trees
12262 && DECL_DECLARED_INLINE_P (d)))
12263 goto out;
12264 }
12265
12266 need_push = !cfun || !global_bindings_p ();
12267 if (need_push)
12268 push_to_top_level ();
12269
12270 /* Mark D as instantiated so that recursive calls to
12271 instantiate_decl do not try to instantiate it again. */
12272 DECL_TEMPLATE_INSTANTIATED (d) = 1;
12273
12274 /* Regenerate the declaration in case the template has been modified
12275 by a subsequent redeclaration. */
12276 regenerate_decl_from_template (d, td);
12277
12278 /* We already set the file and line above. Reset them now in case
12279 they changed as a result of calling regenerate_decl_from_template. */
12280 input_location = DECL_SOURCE_LOCATION (d);
12281
12282 if (TREE_CODE (d) == VAR_DECL)
12283 {
12284 tree init;
12285
12286 /* Clear out DECL_RTL; whatever was there before may not be right
12287 since we've reset the type of the declaration. */
12288 SET_DECL_RTL (d, NULL_RTX);
12289 DECL_IN_AGGR_P (d) = 0;
12290
12291 /* The initializer is placed in DECL_INITIAL by
12292 regenerate_decl_from_template. Pull it out so that
12293 finish_decl can process it. */
12294 init = DECL_INITIAL (d);
12295 DECL_INITIAL (d) = NULL_TREE;
12296 DECL_INITIALIZED_P (d) = 0;
12297
12298 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
12299 initializer. That function will defer actual emission until
12300 we have a chance to determine linkage. */
12301 DECL_EXTERNAL (d) = 0;
12302
12303 /* Enter the scope of D so that access-checking works correctly. */
12304 push_nested_class (DECL_CONTEXT (d));
12305 finish_decl (d, init, NULL_TREE);
12306 pop_nested_class ();
12307 }
12308 else if (TREE_CODE (d) == FUNCTION_DECL)
12309 {
12310 htab_t saved_local_specializations;
12311 tree subst_decl;
12312 tree tmpl_parm;
12313 tree spec_parm;
12314
12315 /* Save away the current list, in case we are instantiating one
12316 template from within the body of another. */
12317 saved_local_specializations = local_specializations;
12318
12319 /* Set up the list of local specializations. */
12320 local_specializations = htab_create (37,
12321 hash_local_specialization,
12322 eq_local_specializations,
12323 NULL);
12324
12325 /* Set up context. */
12326 start_preparsed_function (d, NULL_TREE, SF_PRE_PARSED);
12327
12328 /* Create substitution entries for the parameters. */
12329 subst_decl = DECL_TEMPLATE_RESULT (template_for_substitution (d));
12330 tmpl_parm = DECL_ARGUMENTS (subst_decl);
12331 spec_parm = DECL_ARGUMENTS (d);
12332 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d))
12333 {
12334 register_local_specialization (spec_parm, tmpl_parm);
12335 spec_parm = skip_artificial_parms_for (d, spec_parm);
12336 tmpl_parm = skip_artificial_parms_for (subst_decl, tmpl_parm);
12337 }
12338 while (tmpl_parm)
12339 {
12340 register_local_specialization (spec_parm, tmpl_parm);
12341 tmpl_parm = TREE_CHAIN (tmpl_parm);
12342 spec_parm = TREE_CHAIN (spec_parm);
12343 }
12344 gcc_assert (!spec_parm);
12345
12346 /* Substitute into the body of the function. */
12347 tsubst_expr (DECL_SAVED_TREE (code_pattern), args,
12348 tf_warning_or_error, tmpl,
12349 /*integral_constant_expression_p=*/false);
12350
12351 /* We don't need the local specializations any more. */
12352 htab_delete (local_specializations);
12353 local_specializations = saved_local_specializations;
12354
12355 /* Finish the function. */
12356 d = finish_function (0);
12357 expand_or_defer_fn (d);
12358 }
12359
12360 /* We're not deferring instantiation any more. */
12361 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d)) = 0;
12362
12363 if (need_push)
12364 pop_from_top_level ();
12365
12366out:
12367 input_location = saved_loc;
12368 in_system_header = saved_in_system_header;
12369 pop_deferring_access_checks ();
12370 pop_tinst_level ();
12371
12372 timevar_pop (TV_PARSE);
12373
12374 return d;
12375}
12376
12377/* Run through the list of templates that we wish we could
12378 instantiate, and instantiate any we can. RETRIES is the
12379 number of times we retry pending template instantiation. */
12380
12381void
12382instantiate_pending_templates (int retries)
12383{
12384 tree *t;
12385 tree last = NULL_TREE;
12386 int reconsider;
12387 location_t saved_loc = input_location;
12388 int saved_in_system_header = in_system_header;
12389
12390 /* Instantiating templates may trigger vtable generation. This in turn
12391 may require further template instantiations. We place a limit here
12392 to avoid infinite loop. */
12393 if (pending_templates && retries >= max_tinst_depth)
12394 {
12395 tree decl = TREE_VALUE (pending_templates);
12396
12397 error ("template instantiation depth exceeds maximum of %d"
12398 " instantiating %q+D, possibly from virtual table generation"
12399 " (use -ftemplate-depth-NN to increase the maximum)",
12400 max_tinst_depth, decl);
12401 if (TREE_CODE (decl) == FUNCTION_DECL)
12402 /* Pretend that we defined it. */
12403 DECL_INITIAL (decl) = error_mark_node;
12404 return;
12405 }
12406
12407 do
12408 {
12409 reconsider = 0;
12410
12411 t = &pending_templates;
12412 while (*t)
12413 {
12414 tree instantiation = TREE_VALUE (*t);
12415
12416 reopen_tinst_level (TREE_PURPOSE (*t));
12417
12418 if (TYPE_P (instantiation))
12419 {
12420 tree fn;
12421
12422 if (!COMPLETE_TYPE_P (instantiation))
12423 {
12424 instantiate_class_template (instantiation);
12425 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation))
12426 for (fn = TYPE_METHODS (instantiation);
12427 fn;
12428 fn = TREE_CHAIN (fn))
12429 if (! DECL_ARTIFICIAL (fn))
12430 instantiate_decl (fn,
12431 /*defer_ok=*/0,
12432 /*expl_inst_class_mem_p=*/false);
12433 if (COMPLETE_TYPE_P (instantiation))
12434 reconsider = 1;
12435 }
12436
12437 if (COMPLETE_TYPE_P (instantiation))
12438 /* If INSTANTIATION has been instantiated, then we don't
12439 need to consider it again in the future. */
12440 *t = TREE_CHAIN (*t);
12441 else
12442 {
12443 last = *t;
12444 t = &TREE_CHAIN (*t);
12445 }
12446 }
12447 else
12448 {
12449 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation)
12450 && !DECL_TEMPLATE_INSTANTIATED (instantiation))
12451 {
12452 instantiation
12453 = instantiate_decl (instantiation,
12454 /*defer_ok=*/0,
12455 /*expl_inst_class_mem_p=*/false);
12456 if (DECL_TEMPLATE_INSTANTIATED (instantiation))
12457 reconsider = 1;
12458 }
12459
12460 if (DECL_TEMPLATE_SPECIALIZATION (instantiation)
12461 || DECL_TEMPLATE_INSTANTIATED (instantiation))
12462 /* If INSTANTIATION has been instantiated, then we don't
12463 need to consider it again in the future. */
12464 *t = TREE_CHAIN (*t);
12465 else
12466 {
12467 last = *t;
12468 t = &TREE_CHAIN (*t);
12469 }
12470 }
12471 tinst_depth = 0;
12472 current_tinst_level = NULL_TREE;
12473 }
12474 last_pending_template = last;
12475 }
12476 while (reconsider);
12477
12478 input_location = saved_loc;
12479 in_system_header = saved_in_system_header;
12480}
12481
12482/* Substitute ARGVEC into T, which is a list of initializers for
12483 either base class or a non-static data member. The TREE_PURPOSEs
12484 are DECLs, and the TREE_VALUEs are the initializer values. Used by
12485 instantiate_decl. */
12486
12487static tree
12488tsubst_initializer_list (tree t, tree argvec)
12489{
12490 tree inits = NULL_TREE;
12491
12492 for (; t; t = TREE_CHAIN (t))
12493 {
12494 tree decl;
12495 tree init;
12496
12497 decl = tsubst_copy (TREE_PURPOSE (t), argvec, tf_warning_or_error,
12498 NULL_TREE);
12499 decl = expand_member_init (decl);
12500 if (decl && !DECL_P (decl))
12501 in_base_initializer = 1;
12502
12503 init = tsubst_expr (TREE_VALUE (t), argvec, tf_warning_or_error,
12504 NULL_TREE,
12505 /*integral_constant_expression_p=*/false);
12506 in_base_initializer = 0;
12507
12508 if (decl)
12509 {
12510 init = build_tree_list (decl, init);
12511 TREE_CHAIN (init) = inits;
12512 inits = init;
12513 }
12514 }
12515 return inits;
12516}
12517
12518/* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
12519
12520static void
12521set_current_access_from_decl (tree decl)
12522{
12523 if (TREE_PRIVATE (decl))
12524 current_access_specifier = access_private_node;
12525 else if (TREE_PROTECTED (decl))
12526 current_access_specifier = access_protected_node;
12527 else
12528 current_access_specifier = access_public_node;
12529}
12530
12531/* Instantiate an enumerated type. TAG is the template type, NEWTAG
12532 is the instantiation (which should have been created with
12533 start_enum) and ARGS are the template arguments to use. */
12534
12535static void
12536tsubst_enum (tree tag, tree newtag, tree args)
12537{
12538 tree e;
12539
12540 for (e = TYPE_VALUES (tag); e; e = TREE_CHAIN (e))
12541 {
12542 tree value;
12543 tree decl;
12544
12545 decl = TREE_VALUE (e);
12546 /* Note that in a template enum, the TREE_VALUE is the
12547 CONST_DECL, not the corresponding INTEGER_CST. */
12548 value = tsubst_expr (DECL_INITIAL (decl),
12549 args, tf_warning_or_error, NULL_TREE,
12550 /*integral_constant_expression_p=*/true);
12551
12552 /* Give this enumeration constant the correct access. */
12553 set_current_access_from_decl (decl);
12554
12555 /* Actually build the enumerator itself. */
12556 build_enumerator (DECL_NAME (decl), value, newtag);
12557 }
12558
12559 finish_enum (newtag);
12560 DECL_SOURCE_LOCATION (TYPE_NAME (newtag))
12561 = DECL_SOURCE_LOCATION (TYPE_NAME (tag));
12562}
12563
12564/* DECL is a FUNCTION_DECL that is a template specialization. Return
12565 its type -- but without substituting the innermost set of template
12566 arguments. So, innermost set of template parameters will appear in
12567 the type. */
12568
12569tree
12570get_mostly_instantiated_function_type (tree decl)
12571{
12572 tree fn_type;
12573 tree tmpl;
12574 tree targs;
12575 tree tparms;
12576 int parm_depth;
12577
12578 tmpl = most_general_template (DECL_TI_TEMPLATE (decl));
12579 targs = DECL_TI_ARGS (decl);
12580 tparms = DECL_TEMPLATE_PARMS (tmpl);
12581 parm_depth = TMPL_PARMS_DEPTH (tparms);
12582
12583 /* There should be as many levels of arguments as there are levels
12584 of parameters. */
12585 gcc_assert (parm_depth == TMPL_ARGS_DEPTH (targs));
12586
12587 fn_type = TREE_TYPE (tmpl);
12588
12589 if (parm_depth == 1)
12590 /* No substitution is necessary. */
12591 ;
12592 else
12593 {
12594 int i, save_access_control;
12595 tree partial_args;
12596
12597 /* Replace the innermost level of the TARGS with NULL_TREEs to
12598 let tsubst know not to substitute for those parameters. */
12599 partial_args = make_tree_vec (TREE_VEC_LENGTH (targs));
12600 for (i = 1; i < TMPL_ARGS_DEPTH (targs); ++i)
12601 SET_TMPL_ARGS_LEVEL (partial_args, i,
12602 TMPL_ARGS_LEVEL (targs, i));
12603 SET_TMPL_ARGS_LEVEL (partial_args,
12604 TMPL_ARGS_DEPTH (targs),
12605 make_tree_vec (DECL_NTPARMS (tmpl)));
12606
12607 /* Disable access control as this function is used only during
12608 name-mangling. */
12609 save_access_control = flag_access_control;
12610 flag_access_control = 0;
12611
12612 ++processing_template_decl;
12613 /* Now, do the (partial) substitution to figure out the
12614 appropriate function type. */
12615 fn_type = tsubst (fn_type, partial_args, tf_error, NULL_TREE);
12616 --processing_template_decl;
12617
12618 /* Substitute into the template parameters to obtain the real
12619 innermost set of parameters. This step is important if the
12620 innermost set of template parameters contains value
12621 parameters whose types depend on outer template parameters. */
12622 TREE_VEC_LENGTH (partial_args)--;
12623 tparms = tsubst_template_parms (tparms, partial_args, tf_error);
12624
12625 flag_access_control = save_access_control;
12626 }
12627
12628 return fn_type;
12629}
12630
12631/* Return truthvalue if we're processing a template different from
12632 the last one involved in diagnostics. */
12633int
12634problematic_instantiation_changed (void)
12635{
12636 return last_template_error_tick != tinst_level_tick;
12637}
12638
12639/* Remember current template involved in diagnostics. */
12640void
12641record_last_problematic_instantiation (void)
12642{
12643 last_template_error_tick = tinst_level_tick;
12644}
12645
12646tree
12647current_instantiation (void)
12648{
12649 return current_tinst_level;
12650}
12651
12652/* [temp.param] Check that template non-type parm TYPE is of an allowable
12653 type. Return zero for ok, nonzero for disallowed. Issue error and
12654 warning messages under control of COMPLAIN. */
12655
12656static int
12657invalid_nontype_parm_type_p (tree type, tsubst_flags_t complain)
12658{
12659 if (INTEGRAL_TYPE_P (type))
12660 return 0;
12661 else if (POINTER_TYPE_P (type))
12662 return 0;
12663 else if (TYPE_PTR_TO_MEMBER_P (type))
12664 return 0;
12665 else if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
12666 return 0;
12667 else if (TREE_CODE (type) == TYPENAME_TYPE)
12668 return 0;
12669
12670 if (complain & tf_error)
12671 error ("%q#T is not a valid type for a template constant parameter", type);
12672 return 1;
12673}
12674
12675/* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
12676 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
12677
12678static bool
12679dependent_type_p_r (tree type)
12680{
12681 tree scope;
12682
12683 /* [temp.dep.type]
12684
12685 A type is dependent if it is:
12686
12687 -- a template parameter. Template template parameters are types
12688 for us (since TYPE_P holds true for them) so we handle
12689 them here. */
12690 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
12691 || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM)
12692 return true;
12693 /* -- a qualified-id with a nested-name-specifier which contains a
12694 class-name that names a dependent type or whose unqualified-id
12695 names a dependent type. */
12696 if (TREE_CODE (type) == TYPENAME_TYPE)
12697 return true;
12698 /* -- a cv-qualified type where the cv-unqualified type is
12699 dependent. */
12700 type = TYPE_MAIN_VARIANT (type);
12701 /* -- a compound type constructed from any dependent type. */
12702 if (TYPE_PTR_TO_MEMBER_P (type))
12703 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type))
12704 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
12705 (type)));
12706 else if (TREE_CODE (type) == POINTER_TYPE
12707 || TREE_CODE (type) == REFERENCE_TYPE)
12708 return dependent_type_p (TREE_TYPE (type));
12709 else if (TREE_CODE (type) == FUNCTION_TYPE
12710 || TREE_CODE (type) == METHOD_TYPE)
12711 {
12712 tree arg_type;
12713
12714 if (dependent_type_p (TREE_TYPE (type)))
12715 return true;
12716 for (arg_type = TYPE_ARG_TYPES (type);
12717 arg_type;
12718 arg_type = TREE_CHAIN (arg_type))
12719 if (dependent_type_p (TREE_VALUE (arg_type)))
12720 return true;
12721 return false;
12722 }
12723 /* -- an array type constructed from any dependent type or whose
12724 size is specified by a constant expression that is
12725 value-dependent. */
12726 if (TREE_CODE (type) == ARRAY_TYPE)
12727 {
12728 if (TYPE_DOMAIN (type)
12729 && ((value_dependent_expression_p
12730 (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
12731 || (type_dependent_expression_p
12732 (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))))
12733 return true;
12734 return dependent_type_p (TREE_TYPE (type));
12735 }
12736
12737 /* -- a template-id in which either the template name is a template
12738 parameter ... */
12739 if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
12740 return true;
12741 /* ... or any of the template arguments is a dependent type or
12742 an expression that is type-dependent or value-dependent. */
12743 else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INFO (type)
12744 && (any_dependent_template_arguments_p
12745 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type)))))
12746 return true;
12747
12748 /* All TYPEOF_TYPEs are dependent; if the argument of the `typeof'
12749 expression is not type-dependent, then it should already been
12750 have resolved. */
12751 if (TREE_CODE (type) == TYPEOF_TYPE)
12752 return true;
12753
12754 /* The standard does not specifically mention types that are local
12755 to template functions or local classes, but they should be
12756 considered dependent too. For example:
12757
12758 template <int I> void f() {
12759 enum E { a = I };
12760 S<sizeof (E)> s;
12761 }
12762
12763 The size of `E' cannot be known until the value of `I' has been
12764 determined. Therefore, `E' must be considered dependent. */
12765 scope = TYPE_CONTEXT (type);
12766 if (scope && TYPE_P (scope))
12767 return dependent_type_p (scope);
12768 else if (scope && TREE_CODE (scope) == FUNCTION_DECL)
12769 return type_dependent_expression_p (scope);
12770
12771 /* Other types are non-dependent. */
12772 return false;
12773}
12774
12775/* Returns TRUE if TYPE is dependent, in the sense of
12776 [temp.dep.type]. */
12777
12778bool
12779dependent_type_p (tree type)
12780{
12781 /* If there are no template parameters in scope, then there can't be
12782 any dependent types. */
12783 if (!processing_template_decl)
12784 {
12785 /* If we are not processing a template, then nobody should be
12786 providing us with a dependent type. */
12787 gcc_assert (type);
12788 gcc_assert (TREE_CODE (type) != TEMPLATE_TYPE_PARM);
12789 return false;
12790 }
12791
12792 /* If the type is NULL, we have not computed a type for the entity
12793 in question; in that case, the type is dependent. */
12794 if (!type)
12795 return true;
12796
12797 /* Erroneous types can be considered non-dependent. */
12798 if (type == error_mark_node)
12799 return false;
12800
12801 /* If we have not already computed the appropriate value for TYPE,
12802 do so now. */
12803 if (!TYPE_DEPENDENT_P_VALID (type))
12804 {
12805 TYPE_DEPENDENT_P (type) = dependent_type_p_r (type);
12806 TYPE_DEPENDENT_P_VALID (type) = 1;
12807 }
12808
12809 return TYPE_DEPENDENT_P (type);
12810}
12811
12812/* Returns TRUE if EXPRESSION is dependent, according to CRITERION. */
12813
12814static bool
12815dependent_scope_ref_p (tree expression, bool criterion (tree))
12816{
12817 tree scope;
12818 tree name;
12819
12820 gcc_assert (TREE_CODE (expression) == SCOPE_REF);
12821
12822 if (!TYPE_P (TREE_OPERAND (expression, 0)))
12823 return true;
12824
12825 scope = TREE_OPERAND (expression, 0);
12826 name = TREE_OPERAND (expression, 1);
12827
12828 /* [temp.dep.expr]
12829
12830 An id-expression is type-dependent if it contains a
12831 nested-name-specifier that contains a class-name that names a
12832 dependent type. */
12833 /* The suggested resolution to Core Issue 2 implies that if the
12834 qualifying type is the current class, then we must peek
12835 inside it. */
12836 if (DECL_P (name)
12837 && currently_open_class (scope)
12838 && !criterion (name))
12839 return false;
12840 if (dependent_type_p (scope))
12841 return true;
12842
12843 return false;
12844}
12845
12846/* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
12847 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
12848 expression. */
12849
12850bool
12851value_dependent_expression_p (tree expression)
12852{
12853 if (!processing_template_decl)
12854 return false;
12855
12856 /* A name declared with a dependent type. */
12857 if (DECL_P (expression) && type_dependent_expression_p (expression))
12858 return true;
12859
12860 switch (TREE_CODE (expression))
12861 {
12862 case IDENTIFIER_NODE:
12863 /* A name that has not been looked up -- must be dependent. */
12864 return true;
12865
12866 case TEMPLATE_PARM_INDEX:
12867 /* A non-type template parm. */
12868 return true;
12869
12870 case CONST_DECL:
12871 /* A non-type template parm. */
12872 if (DECL_TEMPLATE_PARM_P (expression))
12873 return true;
12874 return false;
12875
12876 case VAR_DECL:
12877 /* A constant with integral or enumeration type and is initialized
12878 with an expression that is value-dependent. */
12879 if (DECL_INITIAL (expression)
12880 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (expression))
12881 && value_dependent_expression_p (DECL_INITIAL (expression)))
12882 return true;
12883 return false;
12884
12885 case DYNAMIC_CAST_EXPR:
12886 case STATIC_CAST_EXPR:
12887 case CONST_CAST_EXPR:
12888 case REINTERPRET_CAST_EXPR:
12889 case CAST_EXPR:
12890 /* These expressions are value-dependent if the type to which
12891 the cast occurs is dependent or the expression being casted
12892 is value-dependent. */
12893 {
12894 tree type = TREE_TYPE (expression);
12895
12896 if (dependent_type_p (type))
12897 return true;
12898
12899 /* A functional cast has a list of operands. */
12900 expression = TREE_OPERAND (expression, 0);
12901 if (!expression)
12902 {
12903 /* If there are no operands, it must be an expression such
12904 as "int()". This should not happen for aggregate types
12905 because it would form non-constant expressions. */
12906 gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type));
12907
12908 return false;
12909 }
12910
12911 if (TREE_CODE (expression) == TREE_LIST)
12912 return any_value_dependent_elements_p (expression);
12913
12914 return value_dependent_expression_p (expression);
12915 }
12916
12917 case SIZEOF_EXPR:
12918 case ALIGNOF_EXPR:
12919 /* A `sizeof' expression is value-dependent if the operand is
12920 type-dependent. */
12921 expression = TREE_OPERAND (expression, 0);
12922 if (TYPE_P (expression))
12923 return dependent_type_p (expression);
12924 return type_dependent_expression_p (expression);
12925
12926 case SCOPE_REF:
12927 return dependent_scope_ref_p (expression, value_dependent_expression_p);
12928
12929 case COMPONENT_REF:
12930 return (value_dependent_expression_p (TREE_OPERAND (expression, 0))
12931 || value_dependent_expression_p (TREE_OPERAND (expression, 1)));
12932
12933 case CALL_EXPR:
12934 /* A CALL_EXPR may appear in a constant expression if it is a
12935 call to a builtin function, e.g., __builtin_constant_p. All
12936 such calls are value-dependent. */
12937 return true;
12938
12939 case MODOP_EXPR:
12940 return ((value_dependent_expression_p (TREE_OPERAND (expression, 0)))
12941 || (value_dependent_expression_p (TREE_OPERAND (expression, 2))));
12942
12943 default:
12944 /* A constant expression is value-dependent if any subexpression is
12945 value-dependent. */
12946 switch (TREE_CODE_CLASS (TREE_CODE (expression)))
12947 {
12948 case tcc_reference:
12949 case tcc_unary:
12950 return (value_dependent_expression_p
12951 (TREE_OPERAND (expression, 0)));
12952
12953 case tcc_comparison:
12954 case tcc_binary:
12955 return ((value_dependent_expression_p
12956 (TREE_OPERAND (expression, 0)))
12957 || (value_dependent_expression_p
12958 (TREE_OPERAND (expression, 1))));
12959
12960 case tcc_expression:
12961 {
12962 int i;
12963 for (i = 0; i < TREE_CODE_LENGTH (TREE_CODE (expression)); ++i)
12964 /* In some cases, some of the operands may be missing.
12965 (For example, in the case of PREDECREMENT_EXPR, the
12966 amount to increment by may be missing.) That doesn't
12967 make the expression dependent. */
12968 if (TREE_OPERAND (expression, i)
12969 && (value_dependent_expression_p
12970 (TREE_OPERAND (expression, i))))
12971 return true;
12972 return false;
12973 }
12974
12975 default:
12976 break;
12977 }
12978 }
12979
12980 /* The expression is not value-dependent. */
12981 return false;
12982}
12983
12984/* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
12985 [temp.dep.expr]. */
12986
12987bool
12988type_dependent_expression_p (tree expression)
12989{
12990 if (!processing_template_decl)
12991 return false;
12992
12993 if (expression == error_mark_node)
12994 return false;
12995
12996 /* An unresolved name is always dependent. */
12997 if (TREE_CODE (expression) == IDENTIFIER_NODE
12998 || TREE_CODE (expression) == USING_DECL)
12999 return true;
13000
13001 /* Some expression forms are never type-dependent. */
13002 if (TREE_CODE (expression) == PSEUDO_DTOR_EXPR
13003 || TREE_CODE (expression) == SIZEOF_EXPR
13004 || TREE_CODE (expression) == ALIGNOF_EXPR
13005 || TREE_CODE (expression) == TYPEID_EXPR
13006 || TREE_CODE (expression) == DELETE_EXPR
13007 || TREE_CODE (expression) == VEC_DELETE_EXPR
13008 || TREE_CODE (expression) == THROW_EXPR)
13009 return false;
13010
13011 /* The types of these expressions depends only on the type to which
13012 the cast occurs. */
13013 if (TREE_CODE (expression) == DYNAMIC_CAST_EXPR
13014 || TREE_CODE (expression) == STATIC_CAST_EXPR
13015 || TREE_CODE (expression) == CONST_CAST_EXPR
13016 || TREE_CODE (expression) == REINTERPRET_CAST_EXPR
13017 || TREE_CODE (expression) == CAST_EXPR)
13018 return dependent_type_p (TREE_TYPE (expression));
13019
13020 /* The types of these expressions depends only on the type created
13021 by the expression. */
13022 if (TREE_CODE (expression) == NEW_EXPR
13023 || TREE_CODE (expression) == VEC_NEW_EXPR)
13024 {
13025 /* For NEW_EXPR tree nodes created inside a template, either
13026 the object type itself or a TREE_LIST may appear as the
13027 operand 1. */
13028 tree type = TREE_OPERAND (expression, 1);
13029 if (TREE_CODE (type) == TREE_LIST)
13030 /* This is an array type. We need to check array dimensions
13031 as well. */
13032 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type)))
13033 || value_dependent_expression_p
13034 (TREE_OPERAND (TREE_VALUE (type), 1));
13035 else
13036 return dependent_type_p (type);
13037 }
13038
13039 if (TREE_CODE (expression) == SCOPE_REF
13040 && dependent_scope_ref_p (expression,
13041 type_dependent_expression_p))
13042 return true;
13043
13044 if (TREE_CODE (expression) == FUNCTION_DECL
13045 && DECL_LANG_SPECIFIC (expression)
13046 && DECL_TEMPLATE_INFO (expression)
13047 && (any_dependent_template_arguments_p
13048 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression)))))
13049 return true;
13050
13051 if (TREE_CODE (expression) == TEMPLATE_DECL
13052 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression))
13053 return false;
13054
13055 if (TREE_TYPE (expression) == unknown_type_node)
13056 {
13057 if (TREE_CODE (expression) == ADDR_EXPR)
13058 return type_dependent_expression_p (TREE_OPERAND (expression, 0));
13059 if (TREE_CODE (expression) == COMPONENT_REF
13060 || TREE_CODE (expression) == OFFSET_REF)
13061 {
13062 if (type_dependent_expression_p (TREE_OPERAND (expression, 0)))
13063 return true;
13064 expression = TREE_OPERAND (expression, 1);
13065 if (TREE_CODE (expression) == IDENTIFIER_NODE)
13066 return false;
13067 }
13068 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
13069 if (TREE_CODE (expression) == SCOPE_REF)
13070 return false;
13071
13072 if (TREE_CODE (expression) == BASELINK)
13073 expression = BASELINK_FUNCTIONS (expression);
13074
13075 if (TREE_CODE (expression) == TEMPLATE_ID_EXPR)
13076 {
13077 if (any_dependent_template_arguments_p
13078 (TREE_OPERAND (expression, 1)))
13079 return true;
13080 expression = TREE_OPERAND (expression, 0);
13081 }
13082 gcc_assert (TREE_CODE (expression) == OVERLOAD
13083 || TREE_CODE (expression) == FUNCTION_DECL);
13084
13085 while (expression)
13086 {
13087 if (type_dependent_expression_p (OVL_CURRENT (expression)))
13088 return true;
13089 expression = OVL_NEXT (expression);
13090 }
13091 return false;
13092 }
13093
13094 gcc_assert (TREE_CODE (expression) != TYPE_DECL);
13095
13096 return (dependent_type_p (TREE_TYPE (expression)));
13097}
13098
13099/* Returns TRUE if ARGS (a TREE_LIST of arguments to a function call)
13100 contains a type-dependent expression. */
13101
13102bool
13103any_type_dependent_arguments_p (tree args)
13104{
13105 while (args)
13106 {
13107 tree arg = TREE_VALUE (args);
13108
13109 if (type_dependent_expression_p (arg))
13110 return true;
13111 args = TREE_CHAIN (args);
13112 }
13113 return false;
13114}
13115
13116/* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
13117 expressions) contains any value-dependent expressions. */
13118
13119bool
13120any_value_dependent_elements_p (tree list)
13121{
13122 for (; list; list = TREE_CHAIN (list))
13123 if (value_dependent_expression_p (TREE_VALUE (list)))
13124 return true;
13125
13126 return false;
13127}
13128
13129/* Returns TRUE if the ARG (a template argument) is dependent. */
13130
13131static bool
13132dependent_template_arg_p (tree arg)
13133{
13134 if (!processing_template_decl)
13135 return false;
13136
13137 if (TREE_CODE (arg) == TEMPLATE_DECL
13138 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
13139 return dependent_template_p (arg);
13140 else if (TYPE_P (arg))
13141 return dependent_type_p (arg);
13142 else
13143 return (type_dependent_expression_p (arg)
13144 || value_dependent_expression_p (arg));
13145}
13146
13147/* Returns true if ARGS (a collection of template arguments) contains
13148 any dependent arguments. */
13149
13150bool
13151any_dependent_template_arguments_p (tree args)
13152{
13153 int i;
13154 int j;
13155
13156 if (!args)
13157 return false;
13158 if (args == error_mark_node)
13159 return true;
13160
13161 for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i)
13162 {
13163 tree level = TMPL_ARGS_LEVEL (args, i + 1);
13164 for (j = 0; j < TREE_VEC_LENGTH (level); ++j)
13165 if (dependent_template_arg_p (TREE_VEC_ELT (level, j)))
13166 return true;
13167 }
13168
13169 return false;
13170}
13171
13172/* Returns TRUE if the template TMPL is dependent. */
13173
13174bool
13175dependent_template_p (tree tmpl)
13176{
13177 if (TREE_CODE (tmpl) == OVERLOAD)
13178 {
13179 while (tmpl)
13180 {
13181 if (dependent_template_p (OVL_FUNCTION (tmpl)))
13182 return true;
13183 tmpl = OVL_CHAIN (tmpl);
13184 }
13185 return false;
13186 }
13187
13188 /* Template template parameters are dependent. */
13189 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl)
13190 || TREE_CODE (tmpl) == TEMPLATE_TEMPLATE_PARM)
13191 return true;
13192 /* So are names that have not been looked up. */
13193 if (TREE_CODE (tmpl) == SCOPE_REF
13194 || TREE_CODE (tmpl) == IDENTIFIER_NODE)
13195 return true;
13196 /* So are member templates of dependent classes. */
13197 if (TYPE_P (CP_DECL_CONTEXT (tmpl)))
13198 return dependent_type_p (DECL_CONTEXT (tmpl));
13199 return false;
13200}
13201
13202/* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
13203
13204bool
13205dependent_template_id_p (tree tmpl, tree args)
13206{
13207 return (dependent_template_p (tmpl)
13208 || any_dependent_template_arguments_p (args));
13209}
13210
13211/* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
13212 TYPENAME_TYPE corresponds. Returns ERROR_MARK_NODE if no such TYPE
13213 can be found. Note that this function peers inside uninstantiated
13214 templates and therefore should be used only in extremely limited
13215 situations. ONLY_CURRENT_P restricts this peering to the currently
13216 open classes hierarchy (which is required when comparing types). */
13217
13218tree
13219resolve_typename_type (tree type, bool only_current_p)
13220{
13221 tree scope;
13222 tree name;
13223 tree decl;
13224 int quals;
13225 tree pushed_scope;
13226
13227 gcc_assert (TREE_CODE (type) == TYPENAME_TYPE);
13228
13229 scope = TYPE_CONTEXT (type);
13230 name = TYPE_IDENTIFIER (type);
13231
13232 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
13233 it first before we can figure out what NAME refers to. */
13234 if (TREE_CODE (scope) == TYPENAME_TYPE)
13235 scope = resolve_typename_type (scope, only_current_p);
13236 /* If we don't know what SCOPE refers to, then we cannot resolve the
13237 TYPENAME_TYPE. */
13238 if (scope == error_mark_node || TREE_CODE (scope) == TYPENAME_TYPE)
13239 return error_mark_node;
13240 /* If the SCOPE is a template type parameter, we have no way of
13241 resolving the name. */
13242 if (TREE_CODE (scope) == TEMPLATE_TYPE_PARM)
13243 return type;
13244 /* If the SCOPE is not the current instantiation, there's no reason
13245 to look inside it. */
13246 if (only_current_p && !currently_open_class (scope))
13247 return error_mark_node;
13248 /* If SCOPE is a partial instantiation, it will not have a valid
13249 TYPE_FIELDS list, so use the original template. */
13250 scope = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope);
13251 /* Enter the SCOPE so that name lookup will be resolved as if we
13252 were in the class definition. In particular, SCOPE will no
13253 longer be considered a dependent type. */
13254 pushed_scope = push_scope (scope);
13255 /* Look up the declaration. */
13256 decl = lookup_member (scope, name, /*protect=*/0, /*want_type=*/true);
13257 /* Obtain the set of qualifiers applied to the TYPE. */
13258 quals = cp_type_quals (type);
13259 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
13260 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
13261 if (!decl)
13262 type = error_mark_node;
13263 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == IDENTIFIER_NODE
13264 && TREE_CODE (decl) == TYPE_DECL)
13265 type = TREE_TYPE (decl);
13266 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == TEMPLATE_ID_EXPR
13267 && DECL_CLASS_TEMPLATE_P (decl))
13268 {
13269 tree tmpl;
13270 tree args;
13271 /* Obtain the template and the arguments. */
13272 tmpl = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 0);
13273 args = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 1);
13274 /* Instantiate the template. */
13275 type = lookup_template_class (tmpl, args, NULL_TREE, NULL_TREE,
13276 /*entering_scope=*/0, tf_error | tf_user);
13277 }
13278 else
13279 type = error_mark_node;
13280 /* Qualify the resulting type. */
13281 if (type != error_mark_node && quals)
13282 type = cp_build_qualified_type (type, quals);
13283 /* Leave the SCOPE. */
13284 if (pushed_scope)
13285 pop_scope (pushed_scope);
13286
13287 return type;
13288}
13289
13290/* EXPR is an expression which is not type-dependent. Return a proxy
13291 for EXPR that can be used to compute the types of larger
13292 expressions containing EXPR. */
13293
13294tree
13295build_non_dependent_expr (tree expr)
13296{
13297 tree inner_expr;
13298
13299 /* Preserve null pointer constants so that the type of things like
13300 "p == 0" where "p" is a pointer can be determined. */
13301 if (null_ptr_cst_p (expr))
13302 return expr;
13303 /* Preserve OVERLOADs; the functions must be available to resolve
13304 types. */
13305 inner_expr = expr;
13306 if (TREE_CODE (inner_expr) == ADDR_EXPR)
13307 inner_expr = TREE_OPERAND (inner_expr, 0);
13308 if (TREE_CODE (inner_expr) == COMPONENT_REF)
13309 inner_expr = TREE_OPERAND (inner_expr, 1);
13310 if (is_overloaded_fn (inner_expr)
13311 || TREE_CODE (inner_expr) == OFFSET_REF)
13312 return expr;
13313 /* There is no need to return a proxy for a variable. */
13314 if (TREE_CODE (expr) == VAR_DECL)
13315 return expr;
13316 /* Preserve string constants; conversions from string constants to
13317 "char *" are allowed, even though normally a "const char *"
13318 cannot be used to initialize a "char *". */
13319 if (TREE_CODE (expr) == STRING_CST)
13320 return expr;
13321 /* Preserve arithmetic constants, as an optimization -- there is no
13322 reason to create a new node. */
13323 if (TREE_CODE (expr) == INTEGER_CST || TREE_CODE (expr) == REAL_CST)
13324 return expr;
13325 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
13326 There is at least one place where we want to know that a
13327 particular expression is a throw-expression: when checking a ?:
13328 expression, there are special rules if the second or third
13329 argument is a throw-expression. */
13330 if (TREE_CODE (expr) == THROW_EXPR)
13331 return expr;
13332
13333 if (TREE_CODE (expr) == COND_EXPR)
13334 return build3 (COND_EXPR,
13335 TREE_TYPE (expr),
13336 TREE_OPERAND (expr, 0),
13337 (TREE_OPERAND (expr, 1)
13338 ? build_non_dependent_expr (TREE_OPERAND (expr, 1))
13339 : build_non_dependent_expr (TREE_OPERAND (expr, 0))),
13340 build_non_dependent_expr (TREE_OPERAND (expr, 2)));
13341 if (TREE_CODE (expr) == COMPOUND_EXPR
13342 && !COMPOUND_EXPR_OVERLOADED (expr))
13343 return build2 (COMPOUND_EXPR,
13344 TREE_TYPE (expr),
13345 TREE_OPERAND (expr, 0),
13346 build_non_dependent_expr (TREE_OPERAND (expr, 1)));
13347
13348 /* If the type is unknown, it can't really be non-dependent */
13349 gcc_assert (TREE_TYPE (expr) != unknown_type_node);
13350
13351 /* Otherwise, build a NON_DEPENDENT_EXPR.
13352
13353 REFERENCE_TYPEs are not stripped for expressions in templates
13354 because doing so would play havoc with mangling. Consider, for
13355 example:
13356
13357 template <typename T> void f<T& g>() { g(); }
13358
13359 In the body of "f", the expression for "g" will have
13360 REFERENCE_TYPE, even though the standard says that it should
13361 not. The reason is that we must preserve the syntactic form of
13362 the expression so that mangling (say) "f<g>" inside the body of
13363 "f" works out correctly. Therefore, the REFERENCE_TYPE is
13364 stripped here. */
13365 return build1 (NON_DEPENDENT_EXPR, non_reference (TREE_TYPE (expr)), expr);
13366}
13367
13368/* ARGS is a TREE_LIST of expressions as arguments to a function call.
13369 Return a new TREE_LIST with the various arguments replaced with
13370 equivalent non-dependent expressions. */
13371
13372tree
13373build_non_dependent_args (tree args)
13374{
13375 tree a;
13376 tree new_args;
13377
13378 new_args = NULL_TREE;
13379 for (a = args; a; a = TREE_CHAIN (a))
13380 new_args = tree_cons (NULL_TREE,
13381 build_non_dependent_expr (TREE_VALUE (a)),
13382 new_args);
13383 return nreverse (new_args);
13384}
13385
13386#include "gt-cp-pt.h"
|