1 /* Handle parameterized types (templates) for GNU C++.
2 Copyright (C) 1992, 93-97, 1998 Free Software Foundation, Inc.
3 Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing.
4 Rewritten by Jason Merrill (jason@cygnus.com).
6 This file is part of GNU CC.
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
23 /* Known bugs or deficiencies include:
25 all methods must be provided in header files; can't use a source
26 file that contains only the method templates and "just win". */
43 /* The type of functions taking a tree, and some additional data, and
45 typedef int (*tree_fn_t
) PROTO((tree
, void*));
47 extern struct obstack permanent_obstack
;
50 extern char *input_filename
;
51 struct pending_inline
*pending_template_expansions
;
53 tree current_template_parms
;
54 HOST_WIDE_INT processing_template_decl
;
56 tree pending_templates
;
57 static tree
*template_tail
= &pending_templates
;
60 static tree
*maybe_template_tail
= &maybe_templates
;
62 int minimal_parse_mode
;
64 int processing_specialization
;
65 int processing_explicit_instantiation
;
66 int processing_template_parmlist
;
67 static int template_header_count
;
69 static tree saved_trees
;
71 #define obstack_chunk_alloc xmalloc
72 #define obstack_chunk_free free
74 #define UNIFY_ALLOW_NONE 0
75 #define UNIFY_ALLOW_MORE_CV_QUAL 1
76 #define UNIFY_ALLOW_LESS_CV_QUAL 2
77 #define UNIFY_ALLOW_DERIVED 4
78 #define UNIFY_ALLOW_INTEGER 8
80 static int unify
PROTO((tree
, tree
, tree
, tree
, int, int*));
81 static int resolve_overloaded_unification
PROTO((tree
, tree
, tree
, tree
,
82 unification_kind_t
, int,
84 static int try_one_overload
PROTO((tree
, tree
, tree
, tree
, tree
,
85 unification_kind_t
, int, int*));
86 static int unify
PROTO((tree
, tree
, tree
, tree
, int, int*));
87 static void add_pending_template
PROTO((tree
));
88 static int push_tinst_level
PROTO((tree
));
89 static tree classtype_mangled_name
PROTO((tree
));
90 static char *mangle_class_name_for_template
PROTO((char *, tree
, tree
));
91 static tree tsubst_expr_values
PROTO((tree
, tree
));
92 static int list_eq
PROTO((tree
, tree
));
93 static tree get_class_bindings
PROTO((tree
, tree
, tree
));
94 static tree coerce_template_parms
PROTO((tree
, tree
, tree
, int, int));
95 static void tsubst_enum
PROTO((tree
, tree
, tree
));
96 static tree add_to_template_args
PROTO((tree
, tree
));
97 static tree add_outermost_template_args
PROTO((tree
, tree
));
98 static void maybe_adjust_types_for_deduction
PROTO((unification_kind_t
, tree
*,
100 static int type_unification_real
PROTO((tree
, tree
, tree
, tree
,
101 int, unification_kind_t
, int, int*));
102 static void note_template_header
PROTO((int));
103 static tree maybe_fold_nontype_arg
PROTO((tree
));
104 static tree convert_nontype_argument
PROTO((tree
, tree
));
105 static tree convert_template_argument
PROTO ((tree
, tree
, tree
, int,
107 static tree get_bindings_overload
PROTO((tree
, tree
, tree
));
108 static int for_each_template_parm
PROTO((tree
, tree_fn_t
, void*));
109 static tree build_template_parm_index
PROTO((int, int, int, tree
, tree
));
110 static int inline_needs_template_parms
PROTO((tree
));
111 static void push_inline_template_parms_recursive
PROTO((tree
, int));
112 static tree retrieve_specialization
PROTO((tree
, tree
));
113 static tree register_specialization
PROTO((tree
, tree
, tree
));
114 static int unregister_specialization
PROTO((tree
, tree
));
115 static tree reduce_template_parm_level
PROTO((tree
, tree
, int));
116 static tree build_template_decl
PROTO((tree
, tree
));
117 static int mark_template_parm
PROTO((tree
, void *));
118 static tree tsubst_friend_function
PROTO((tree
, tree
));
119 static tree tsubst_friend_class
PROTO((tree
, tree
));
120 static tree get_bindings_real
PROTO((tree
, tree
, tree
, int));
121 static int template_decl_level
PROTO((tree
));
122 static tree maybe_get_template_decl_from_type_decl
PROTO((tree
));
123 static int check_cv_quals_for_unify
PROTO((int, tree
, tree
));
124 static tree tsubst_template_arg_vector
PROTO((tree
, tree
));
125 static tree tsubst_template_parms
PROTO((tree
, tree
));
126 static void regenerate_decl_from_template
PROTO((tree
, tree
));
127 static tree most_specialized
PROTO((tree
, tree
, tree
));
128 static tree most_specialized_class
PROTO((tree
, tree
));
129 static tree most_general_template
PROTO((tree
));
130 static void set_mangled_name_for_template_decl
PROTO((tree
));
131 static int template_class_depth_real
PROTO((tree
, int));
132 static tree tsubst_aggr_type
PROTO((tree
, tree
, tree
, int));
133 static tree tsubst_decl
PROTO((tree
, tree
, tree
, tree
));
134 static tree tsubst_arg_types
PROTO((tree
, tree
, tree
));
135 static void check_specialization_scope
PROTO((void));
136 static tree process_partial_specialization
PROTO((tree
));
137 static void set_current_access_from_decl
PROTO((tree
));
138 static void check_default_tmpl_args
PROTO((tree
, tree
, int, int));
140 /* We use TREE_VECs to hold template arguments. If there is only one
141 level of template arguments, then the TREE_VEC contains the
142 arguments directly. If there is more than one level of template
143 arguments, then each entry in the TREE_VEC is itself a TREE_VEC,
144 containing the template arguments for a single level. The first
145 entry in the outer TREE_VEC is the outermost level of template
146 parameters; the last is the innermost.
148 It is incorrect to ever form a template argument vector containing
149 only one level of arguments, but which is a TREE_VEC containing as
150 its only entry the TREE_VEC for that level. */
152 /* Non-zero if the template arguments is actually a vector of vectors,
153 rather than just a vector. */
154 #define TMPL_ARGS_HAVE_MULTIPLE_LEVELS(NODE) \
156 && TREE_CODE (NODE) == TREE_VEC \
157 && TREE_VEC_LENGTH (NODE) > 0 \
158 && TREE_VEC_ELT (NODE, 0) != NULL_TREE \
159 && TREE_CODE (TREE_VEC_ELT (NODE, 0)) == TREE_VEC)
161 /* The depth of a template argument vector. When called directly by
162 the parser, we use a TREE_LIST rather than a TREE_VEC to represent
163 template arguments. In fact, we may even see NULL_TREE if there
164 are no template arguments. In both of those cases, there is only
165 one level of template arguments. */
166 #define TMPL_ARGS_DEPTH(NODE) \
167 (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (NODE) ? TREE_VEC_LENGTH (NODE) : 1)
169 /* The LEVELth level of the template ARGS. Note that template
170 parameter levels are indexed from 1, not from 0. */
171 #define TMPL_ARGS_LEVEL(ARGS, LEVEL) \
172 (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (ARGS) \
173 ? TREE_VEC_ELT ((ARGS), (LEVEL) - 1) : ARGS)
175 /* Set the LEVELth level of the template ARGS to VAL. This macro does
176 not work with single-level argument vectors. */
177 #define SET_TMPL_ARGS_LEVEL(ARGS, LEVEL, VAL) \
178 (TREE_VEC_ELT ((ARGS), (LEVEL) - 1) = (VAL))
180 /* Accesses the IDXth parameter in the LEVELth level of the ARGS. */
181 #define TMPL_ARG(ARGS, LEVEL, IDX) \
182 (TREE_VEC_ELT (TMPL_ARGS_LEVEL (ARGS, LEVEL), IDX))
184 /* Set the IDXth element in the LEVELth level of ARGS to VAL. This
185 macro does not work with single-level argument vectors. */
186 #define SET_TMPL_ARG(ARGS, LEVEL, IDX, VAL) \
187 (TREE_VEC_ELT (TREE_VEC_ELT ((ARGS), (LEVEL) - 1), (IDX)) = (VAL))
189 /* Given a single level of template arguments in NODE, return the
190 number of arguments. */
191 #define NUM_TMPL_ARGS(NODE) \
192 ((NODE) == NULL_TREE ? 0 \
193 : (TREE_CODE (NODE) == TREE_VEC \
194 ? TREE_VEC_LENGTH (NODE) : list_length (NODE)))
196 /* The number of levels of template parameters given by NODE. */
197 #define TMPL_PARMS_DEPTH(NODE) \
198 (TREE_INT_CST_HIGH (TREE_PURPOSE (NODE)))
200 /* Do any processing required when DECL (a member template declaration
201 using TEMPLATE_PARAMETERS as its innermost parameter list) is
202 finished. Returns the TEMPLATE_DECL corresponding to DECL, unless
203 it is a specialization, in which case the DECL itself is returned. */
206 finish_member_template_decl (decl
)
209 if (decl
== NULL_TREE
|| decl
== void_type_node
)
211 else if (decl
== error_mark_node
)
212 /* By returning NULL_TREE, the parser will just ignore this
213 declaration. We have already issued the error. */
215 else if (TREE_CODE (decl
) == TREE_LIST
)
217 /* Assume that the class is the only declspec. */
218 decl
= TREE_VALUE (decl
);
219 if (IS_AGGR_TYPE (decl
) && CLASSTYPE_TEMPLATE_INFO (decl
)
220 && ! CLASSTYPE_TEMPLATE_SPECIALIZATION (decl
))
222 tree tmpl
= CLASSTYPE_TI_TEMPLATE (decl
);
223 check_member_template (tmpl
);
228 else if (DECL_TEMPLATE_INFO (decl
))
230 if (!DECL_TEMPLATE_SPECIALIZATION (decl
))
232 check_member_template (DECL_TI_TEMPLATE (decl
));
233 return DECL_TI_TEMPLATE (decl
);
239 cp_error ("invalid member template declaration `%D'", decl
);
241 return error_mark_node
;
244 /* Returns the template nesting level of the indicated class TYPE.
254 A<T>::B<U> has depth two, while A<T> has depth one.
255 Both A<T>::B<int> and A<int>::B<U> have depth one, if
256 COUNT_SPECIALIZATIONS is 0 or if they are instantiations, not
259 This function is guaranteed to return 0 if passed NULL_TREE so
260 that, for example, `template_class_depth (current_class_type)' is
264 template_class_depth_real (type
, count_specializations
)
266 int count_specializations
;
271 type
&& TREE_CODE (type
) != NAMESPACE_DECL
;
272 type
= (TREE_CODE (type
) == FUNCTION_DECL
)
273 ? DECL_REAL_CONTEXT (type
) : TYPE_CONTEXT (type
))
275 if (TREE_CODE (type
) != FUNCTION_DECL
)
277 if (CLASSTYPE_TEMPLATE_INFO (type
)
278 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
))
279 && ((count_specializations
280 && CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
281 || uses_template_parms (CLASSTYPE_TI_ARGS (type
))))
286 if (DECL_TEMPLATE_INFO (type
)
287 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (type
))
288 && ((count_specializations
289 && DECL_TEMPLATE_SPECIALIZATION (type
))
290 || uses_template_parms (DECL_TI_ARGS (type
))))
298 /* Returns the template nesting level of the indicated class TYPE.
299 Like template_class_depth_real, but instantiations do not count in
303 template_class_depth (type
)
306 return template_class_depth_real (type
, /*count_specializations=*/0);
309 /* Returns 1 if processing DECL as part of do_pending_inlines
310 needs us to push template parms. */
313 inline_needs_template_parms (decl
)
316 if (! DECL_TEMPLATE_INFO (decl
))
319 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl
)))
320 > (processing_template_decl
+ DECL_TEMPLATE_SPECIALIZATION (decl
)));
323 /* Subroutine of maybe_begin_member_template_processing.
324 Push the template parms in PARMS, starting from LEVELS steps into the
325 chain, and ending at the beginning, since template parms are listed
329 push_inline_template_parms_recursive (parmlist
, levels
)
333 tree parms
= TREE_VALUE (parmlist
);
337 push_inline_template_parms_recursive (TREE_CHAIN (parmlist
), levels
- 1);
339 ++processing_template_decl
;
340 current_template_parms
341 = tree_cons (build_int_2 (0, processing_template_decl
),
342 parms
, current_template_parms
);
343 TEMPLATE_PARMS_FOR_INLINE (current_template_parms
) = 1;
346 for (i
= 0; i
< TREE_VEC_LENGTH (parms
); ++i
)
348 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
349 my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (parm
)) == 'd', 0);
351 switch (TREE_CODE (parm
))
360 /* Make a CONST_DECL as is done in process_template_parm. */
361 tree decl
= build_decl (CONST_DECL
, DECL_NAME (parm
),
363 DECL_INITIAL (decl
) = DECL_INITIAL (parm
);
369 my_friendly_abort (0);
374 /* Restore the template parameter context for a member template or
375 a friend template defined in a class definition. */
378 maybe_begin_member_template_processing (decl
)
384 if (! inline_needs_template_parms (decl
))
387 parms
= DECL_TEMPLATE_PARMS (most_general_template (decl
));
389 levels
= TMPL_PARMS_DEPTH (parms
) - processing_template_decl
;
391 if (DECL_TEMPLATE_SPECIALIZATION (decl
))
394 parms
= TREE_CHAIN (parms
);
397 push_inline_template_parms_recursive (parms
, levels
);
400 /* Undo the effects of begin_member_template_processing. */
403 maybe_end_member_template_processing ()
405 if (! processing_template_decl
)
408 while (current_template_parms
409 && TEMPLATE_PARMS_FOR_INLINE (current_template_parms
))
411 --processing_template_decl
;
412 current_template_parms
= TREE_CHAIN (current_template_parms
);
417 /* Returns non-zero iff T is a member template function. We must be
420 template <class T> class C { void f(); }
422 Here, f is a template function, and a member, but not a member
423 template. This function does not concern itself with the origin of
424 T, only its present state. So if we have
426 template <class T> class C { template <class U> void f(U); }
428 then neither C<int>::f<char> nor C<T>::f<double> is considered
429 to be a member template. But, `template <class U> void
430 C<int>::f(U)' is considered a member template. */
433 is_member_template (t
)
436 if (!DECL_FUNCTION_TEMPLATE_P (t
))
437 /* Anything that isn't a function or a template function is
438 certainly not a member template. */
441 /* A local class can't have member templates. */
442 if (hack_decl_function_context (t
))
445 return (DECL_FUNCTION_MEMBER_P (DECL_TEMPLATE_RESULT (t
))
446 /* If there are more levels of template parameters than
447 there are template classes surrounding the declaration,
448 then we have a member template. */
449 && (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (t
)) >
450 template_class_depth (DECL_CLASS_CONTEXT (t
))));
454 /* Returns non-zero iff T is a member template class. See
455 is_member_template for a description of what precisely constitutes
456 a member template. */
459 is_member_template_class (t
)
462 if (!DECL_CLASS_TEMPLATE_P (t
))
463 /* Anything that isn't a class template, is certainly not a member
467 if (!DECL_CLASS_SCOPE_P (t
))
468 /* Anything whose context isn't a class type is surely not a
472 /* If there are more levels of template parameters than there are
473 template classes surrounding the declaration, then we have a
475 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (t
)) >
476 template_class_depth (DECL_CONTEXT (t
)));
480 /* Return a new template argument vector which contains all of ARGS,
481 but has as its innermost set of arguments the EXTRA_ARGS. The
482 resulting vector will be built on a temporary obstack, and so must
483 be explicitly copied to the permanent obstack, if required. */
486 add_to_template_args (args
, extra_args
)
495 extra_depth
= TMPL_ARGS_DEPTH (extra_args
);
496 new_args
= make_temp_vec (TMPL_ARGS_DEPTH (args
) + extra_depth
);
498 for (i
= 1; i
<= TMPL_ARGS_DEPTH (args
); ++i
)
499 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (args
, i
));
501 for (j
= 1; j
<= extra_depth
; ++j
, ++i
)
502 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (extra_args
, j
));
507 /* Like add_to_template_args, but only the outermost ARGS are added to
508 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
509 (EXTRA_ARGS) levels are added. This function is used to combine
510 the template arguments from a partial instantiation with the
511 template arguments used to attain the full instantiation from the
512 partial instantiation. */
515 add_outermost_template_args (args
, extra_args
)
521 /* If there are more levels of EXTRA_ARGS than there are ARGS,
522 something very fishy is going on. */
523 my_friendly_assert (TMPL_ARGS_DEPTH (args
) >= TMPL_ARGS_DEPTH (extra_args
),
526 /* If *all* the new arguments will be the EXTRA_ARGS, just return
528 if (TMPL_ARGS_DEPTH (args
) == TMPL_ARGS_DEPTH (extra_args
))
531 /* For the moment, we make ARGS look like it contains fewer levels. */
532 TREE_VEC_LENGTH (args
) -= TMPL_ARGS_DEPTH (extra_args
);
534 new_args
= add_to_template_args (args
, extra_args
);
536 /* Now, we restore ARGS to its full dimensions. */
537 TREE_VEC_LENGTH (args
) += TMPL_ARGS_DEPTH (extra_args
);
542 /* We've got a template header coming up; push to a new level for storing
546 begin_template_parm_list ()
548 /* We use a non-tag-transparent scope here, which causes pushtag to
549 put tags in this scope, rather than in the enclosing class or
550 namespace scope. This is the right thing, since we want
551 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
552 global template class, push_template_decl handles putting the
553 TEMPLATE_DECL into top-level scope. For a nested template class,
556 template <class T> struct S1 {
557 template <class T> struct S2 {};
560 pushtag contains special code to call pushdecl_with_scope on the
561 TEMPLATE_DECL for S2. */
563 declare_pseudo_global_level ();
564 ++processing_template_decl
;
565 ++processing_template_parmlist
;
566 note_template_header (0);
569 /* This routine is called when a specialization is declared. If it is
570 illegal to declare a specialization here, an error is reported. */
573 check_specialization_scope ()
575 tree scope
= current_scope ();
579 An explicit specialization shall be declared in the namespace of
580 which the template is a member, or, for member templates, in the
581 namespace of which the enclosing class or enclosing class
582 template is a member. An explicit specialization of a member
583 function, member class or static data member of a class template
584 shall be declared in the namespace of which the class template
586 if (scope
&& TREE_CODE (scope
) != NAMESPACE_DECL
)
587 cp_error ("explicit specialization in non-namespace scope `%D'",
592 In an explicit specialization declaration for a member of a class
593 template or a member template that appears in namespace scope,
594 the member template and some of its enclosing class templates may
595 remain unspecialized, except that the declaration shall not
596 explicitly specialize a class member template if its enclosing
597 class templates are not explicitly specialized as well. */
598 if (current_template_parms
)
599 cp_error ("enclosing class templates are not explicitly specialized");
602 /* We've just seen template <>. */
605 begin_specialization ()
607 note_template_header (1);
608 check_specialization_scope ();
611 /* Called at then end of processing a declaration preceeded by
615 end_specialization ()
617 reset_specialization ();
620 /* Any template <>'s that we have seen thus far are not referring to a
621 function specialization. */
624 reset_specialization ()
626 processing_specialization
= 0;
627 template_header_count
= 0;
630 /* We've just seen a template header. If SPECIALIZATION is non-zero,
631 it was of the form template <>. */
634 note_template_header (specialization
)
637 processing_specialization
= specialization
;
638 template_header_count
++;
641 /* We're beginning an explicit instantiation. */
644 begin_explicit_instantiation ()
646 ++processing_explicit_instantiation
;
651 end_explicit_instantiation ()
653 my_friendly_assert(processing_explicit_instantiation
> 0, 0);
654 --processing_explicit_instantiation
;
657 /* The TYPE is being declared. If it is a template type, that means it
658 is a partial specialization. Do appropriate error-checking. */
661 maybe_process_partial_specialization (type
)
664 if (IS_AGGR_TYPE (type
) && CLASSTYPE_USE_TEMPLATE (type
))
666 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type
)
667 && TYPE_SIZE (type
) == NULL_TREE
)
669 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type
);
670 if (processing_template_decl
)
671 push_template_decl (TYPE_MAIN_DECL (type
));
673 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type
))
674 cp_error ("specialization of `%T' after instantiation", type
);
678 /* Retrieve the specialization (in the sense of [temp.spec] - a
679 specialization is either an instantiation or an explicit
680 specialization) of TMPL for the given template ARGS. If there is
681 no such specialization, return NULL_TREE. The ARGS are a vector of
682 arguments, or a vector of vectors of arguments, in the case of
683 templates with more than one level of parameters. */
686 retrieve_specialization (tmpl
, args
)
692 my_friendly_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
, 0);
694 /* There should be as many levels of arguments as there are
695 levels of parameters. */
696 my_friendly_assert (TMPL_ARGS_DEPTH (args
)
697 == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
)),
700 for (s
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
703 if (comp_template_args (TREE_PURPOSE (s
), args
))
704 return TREE_VALUE (s
);
709 /* Returns non-zero iff DECL is a specialization of TMPL. */
712 is_specialization_of (decl
, tmpl
)
718 if (TREE_CODE (decl
) == FUNCTION_DECL
)
722 t
= DECL_TEMPLATE_INFO (t
) ? DECL_TI_TEMPLATE (t
) : NULL_TREE
)
728 my_friendly_assert (TREE_CODE (decl
) == TYPE_DECL
, 0);
730 for (t
= TREE_TYPE (decl
);
732 t
= CLASSTYPE_USE_TEMPLATE (t
)
733 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t
)) : NULL_TREE
)
734 if (same_type_p (TYPE_MAIN_VARIANT (t
),
735 TYPE_MAIN_VARIANT (TREE_TYPE (tmpl
))))
742 /* Register the specialization SPEC as a specialization of TMPL with
743 the indicated ARGS. Returns SPEC, or an equivalent prior
744 declaration, if available. */
747 register_specialization (spec
, tmpl
, args
)
754 my_friendly_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
, 0);
756 if (TREE_CODE (spec
) == FUNCTION_DECL
757 && uses_template_parms (DECL_TI_ARGS (spec
)))
758 /* This is the FUNCTION_DECL for a partial instantiation. Don't
759 register it; we want the corresponding TEMPLATE_DECL instead.
760 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
761 the more obvious `uses_template_parms (spec)' to avoid problems
762 with default function arguments. In particular, given
765 template <class T> void f(T t1, T t = T())
767 the default argument expression is not substituted for in an
768 instantiation unless and until it is actually needed. */
771 /* There should be as many levels of arguments as there are
772 levels of parameters. */
773 my_friendly_assert (TMPL_ARGS_DEPTH (args
)
774 == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
)),
777 for (s
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
780 if (comp_template_args (TREE_PURPOSE (s
), args
))
782 tree fn
= TREE_VALUE (s
);
784 if (DECL_TEMPLATE_SPECIALIZATION (spec
))
786 if (DECL_TEMPLATE_INSTANTIATION (fn
))
789 || DECL_EXPLICIT_INSTANTIATION (fn
))
791 cp_error ("specialization of %D after instantiation",
797 /* This situation should occur only if the first
798 specialization is an implicit instantiation,
799 the second is an explicit specialization, and
800 the implicit instantiation has not yet been
801 used. That situation can occur if we have
802 implicitly instantiated a member function and
803 then specialized it later.
805 We can also wind up here if a friend
806 declaration that looked like an instantiation
807 turns out to be a specialization:
809 template <class T> void foo(T);
810 class S { friend void foo<>(int) };
811 template <> void foo(int);
813 We transform the existing DECL in place so that
814 any pointers to it become pointers to the
817 If there was a definition for the template, but
818 not for the specialization, we want this to
819 look as if there is no definition, and vice
821 DECL_INITIAL (fn
) = NULL_TREE
;
822 duplicate_decls (spec
, fn
);
827 else if (DECL_TEMPLATE_SPECIALIZATION (fn
))
829 duplicate_decls (spec
, fn
);
835 DECL_TEMPLATE_SPECIALIZATIONS (tmpl
)
836 = perm_tree_cons (args
, spec
, DECL_TEMPLATE_SPECIALIZATIONS (tmpl
));
841 /* Unregister the specialization SPEC as a specialization of TMPL.
842 Returns nonzero if the SPEC was listed as a specialization of
846 unregister_specialization (spec
, tmpl
)
852 for (s
= &DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
854 s
= &TREE_CHAIN (*s
))
855 if (TREE_VALUE (*s
) == spec
)
857 *s
= TREE_CHAIN (*s
);
864 /* Print the list of candidate FNS in an error message. */
867 print_candidates (fns
)
872 char* str
= "candidates are:";
874 for (fn
= fns
; fn
!= NULL_TREE
; fn
= TREE_CHAIN (fn
))
876 cp_error_at ("%s %+#D", str
, TREE_VALUE (fn
));
881 /* Returns the template (one of the functions given by TEMPLATE_ID)
882 which can be specialized to match the indicated DECL with the
883 explicit template args given in TEMPLATE_ID. If
884 NEED_MEMBER_TEMPLATE is true the function is a specialization of a
885 member template. The template args (those explicitly specified and
886 those deduced) are output in a newly created vector *TARGS_OUT. If
887 it is impossible to determine the result, an error message is
888 issued, unless COMPLAIN is 0. The DECL may be NULL_TREE if none is
892 determine_specialization (template_id
, decl
, targs_out
,
893 need_member_template
,
898 int need_member_template
;
902 tree templates
= NULL_TREE
;
905 *targs_out
= NULL_TREE
;
907 if (template_id
== error_mark_node
)
908 return error_mark_node
;
910 fns
= TREE_OPERAND (template_id
, 0);
911 targs_in
= TREE_OPERAND (template_id
, 1);
913 if (fns
== error_mark_node
)
914 return error_mark_node
;
916 /* Check for baselinks. */
917 if (TREE_CODE (fns
) == TREE_LIST
)
918 fns
= TREE_VALUE (fns
);
920 for (; fns
; fns
= OVL_NEXT (fns
))
924 fn
= OVL_CURRENT (fns
);
925 if (!need_member_template
926 && TREE_CODE (fn
) == FUNCTION_DECL
927 && DECL_FUNCTION_MEMBER_P (fn
)
928 && DECL_USE_TEMPLATE (fn
)
929 && DECL_TI_TEMPLATE (fn
))
930 /* We can get here when processing something like:
931 template <class T> class X { void f(); }
932 template <> void X<int>::f() {}
933 We're specializing a member function, but not a member
935 tmpl
= DECL_TI_TEMPLATE (fn
);
936 else if (TREE_CODE (fn
) != TEMPLATE_DECL
937 || (need_member_template
&& !is_member_template (fn
)))
942 if (list_length (targs_in
) > DECL_NTPARMS (tmpl
))
945 if (decl
== NULL_TREE
)
947 /* Unify against ourselves to make sure that the args we have
948 make sense and there aren't any undeducible parms. It's OK if
949 not all the parms are specified; they might be deduced
951 tree targs
= get_bindings_overload (tmpl
, DECL_RESULT (tmpl
),
955 /* Unification was successful. */
956 templates
= scratch_tree_cons (targs
, tmpl
, templates
);
959 templates
= scratch_tree_cons (NULL_TREE
, tmpl
, templates
);
962 if (decl
!= NULL_TREE
)
964 tree tmpl
= most_specialized (templates
, decl
, targs_in
);
968 if (tmpl
== error_mark_node
)
970 else if (tmpl
== NULL_TREE
)
973 inner_args
= get_bindings (tmpl
, decl
, targs_in
);
974 tmpl_args
= DECL_TI_ARGS (DECL_RESULT (tmpl
));
975 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (tmpl_args
))
977 *targs_out
= copy_node (tmpl_args
);
978 SET_TMPL_ARGS_LEVEL (*targs_out
,
979 TMPL_ARGS_DEPTH (*targs_out
),
983 *targs_out
= inner_args
;
988 if (templates
== NULL_TREE
)
993 cp_error_at ("template-id `%D' for `%+D' does not match any template declaration",
995 return error_mark_node
;
999 else if (TREE_CHAIN (templates
) != NULL_TREE
1000 || uses_template_parms (TREE_PURPOSE (templates
)))
1005 cp_error_at ("ambiguous template specialization `%D' for `%+D'",
1007 print_candidates (templates
);
1008 return error_mark_node
;
1013 /* We have one, and exactly one, match. */
1014 *targs_out
= TREE_PURPOSE (templates
);
1015 return TREE_VALUE (templates
);
1018 /* Check to see if the function just declared, as indicated in
1019 DECLARATOR, and in DECL, is a specialization of a function
1020 template. We may also discover that the declaration is an explicit
1021 instantiation at this point.
1023 Returns DECL, or an equivalent declaration that should be used
1026 FLAGS is a bitmask consisting of the following flags:
1028 2: The function has a definition.
1029 4: The function is a friend.
1031 The TEMPLATE_COUNT is the number of references to qualifying
1032 template classes that appeared in the name of the function. For
1035 template <class T> struct S { void f(); };
1038 the TEMPLATE_COUNT would be 1. However, explicitly specialized
1039 classes are not counted in the TEMPLATE_COUNT, so that in
1041 template <class T> struct S {};
1042 template <> struct S<int> { void f(); }
1043 template <> void S<int>::f();
1045 the TEMPLATE_COUNT would be 0. (Note that this declaration is
1046 illegal; there should be no template <>.)
1048 If the function is a specialization, it is marked as such via
1049 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
1050 is set up correctly, and it is added to the list of specializations
1051 for that template. */
1054 check_explicit_specialization (declarator
, decl
, template_count
, flags
)
1060 int have_def
= flags
& 2;
1061 int is_friend
= flags
& 4;
1062 int specialization
= 0;
1063 int explicit_instantiation
= 0;
1064 int member_specialization
= 0;
1066 tree ctype
= DECL_CLASS_CONTEXT (decl
);
1067 tree dname
= DECL_NAME (decl
);
1069 if (processing_specialization
)
1071 /* The last template header was of the form template <>. */
1073 if (template_header_count
> template_count
)
1075 /* There were more template headers than qualifying template
1077 if (template_header_count
- template_count
> 1)
1078 /* There shouldn't be that many template parameter
1079 lists. There can be at most one parameter list for
1080 every qualifying class, plus one for the function
1082 cp_error ("too many template parameter lists in declaration of `%D'", decl
);
1084 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
1086 member_specialization
= 1;
1090 else if (template_header_count
== template_count
)
1092 /* The counts are equal. So, this might be a
1093 specialization, but it is not a specialization of a
1094 member template. It might be something like
1096 template <class T> struct S {
1100 void S<int>::f(int i) {} */
1102 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
1106 /* This cannot be an explicit specialization. There are not
1107 enough headers for all of the qualifying classes. For
1108 example, we might have:
1111 void S<int>::T<char>::f();
1113 But, we're missing another template <>. */
1114 cp_error("too few template parameter lists in declaration of `%D'", decl
);
1118 else if (processing_explicit_instantiation
)
1120 if (template_header_count
)
1121 cp_error ("template parameter list used in explicit instantiation");
1124 cp_error ("definition provided for explicit instantiation");
1126 explicit_instantiation
= 1;
1128 else if (ctype
!= NULL_TREE
1129 && !TYPE_BEING_DEFINED (ctype
)
1130 && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype
)
1133 /* This case catches outdated code that looks like this:
1135 template <class T> struct S { void f(); };
1136 void S<int>::f() {} // Missing template <>
1138 We disable this check when the type is being defined to
1139 avoid complaining about default compiler-generated
1140 constructors, destructors, and assignment operators.
1141 Since the type is an instantiation, not a specialization,
1142 these are the only functions that can be defined before
1143 the class is complete. */
1146 template <class T> void S<int>::f() {}
1148 if (template_header_count
)
1150 cp_error ("template parameters specified in specialization");
1156 ("explicit specialization not preceded by `template <>'");
1158 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
1160 else if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
1163 /* This could be something like:
1165 template <class T> void f(T);
1166 class S { friend void f<>(int); } */
1170 /* This case handles bogus declarations like template <>
1171 template <class T> void f<int>(); */
1173 cp_error ("template-id `%D' in declaration of primary template",
1179 if (specialization
|| member_specialization
)
1181 tree t
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
1182 for (; t
; t
= TREE_CHAIN (t
))
1183 if (TREE_PURPOSE (t
))
1186 ("default argument specified in explicit specialization");
1189 if (current_lang_name
== lang_name_c
)
1190 cp_error ("template specialization with C linkage");
1193 if (specialization
|| member_specialization
|| explicit_instantiation
)
1196 tree tmpl
= NULL_TREE
;
1197 tree targs
= NULL_TREE
;
1199 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
1200 if (TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
1204 my_friendly_assert (TREE_CODE (declarator
) == IDENTIFIER_NODE
,
1207 fns
= IDENTIFIER_NAMESPACE_VALUE (dname
);
1212 lookup_template_function (fns
, NULL_TREE
);
1215 if (declarator
== error_mark_node
)
1216 return error_mark_node
;
1218 if (TREE_CODE (TREE_OPERAND (declarator
, 0)) == LOOKUP_EXPR
)
1220 /* A friend declaration. We can't do much, because we don't
1221 know what this resolves to, yet. */
1222 my_friendly_assert (is_friend
!= 0, 0);
1223 my_friendly_assert (!explicit_instantiation
, 0);
1224 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
1228 if (ctype
!= NULL_TREE
&& TYPE_BEING_DEFINED (ctype
))
1230 if (!explicit_instantiation
)
1231 /* A specialization in class scope. This is illegal,
1232 but the error will already have been flagged by
1233 check_specialization_scope. */
1234 return error_mark_node
;
1237 /* It's not legal to write an explicit instantiation in
1240 class C { template void f(); }
1242 This case is caught by the parser. However, on
1245 template class C { void f(); };
1247 (which is illegal) we can get here. The error will be
1254 else if (ctype
!= NULL_TREE
1255 && (TREE_CODE (TREE_OPERAND (declarator
, 0)) ==
1258 /* Find the list of functions in ctype that have the same
1259 name as the declared function. */
1260 tree name
= TREE_OPERAND (declarator
, 0);
1263 if (name
== constructor_name (ctype
)
1264 || name
== constructor_name_full (ctype
))
1266 int is_constructor
= DECL_CONSTRUCTOR_P (decl
);
1268 if (is_constructor
? !TYPE_HAS_CONSTRUCTOR (ctype
)
1269 : !TYPE_HAS_DESTRUCTOR (ctype
))
1271 /* From [temp.expl.spec]:
1273 If such an explicit specialization for the member
1274 of a class template names an implicitly-declared
1275 special member function (clause _special_), the
1276 program is ill-formed.
1278 Similar language is found in [temp.explicit]. */
1279 cp_error ("specialization of implicitly-declared special member function");
1284 name
= is_constructor
? ctor_identifier
: dtor_identifier
;
1287 fns
= lookup_fnfields (TYPE_BINFO (ctype
), name
, 1);
1289 if (fns
== NULL_TREE
)
1291 cp_error ("no member function `%s' declared in `%T'",
1292 IDENTIFIER_POINTER (name
),
1297 TREE_OPERAND (declarator
, 0) = fns
;
1300 /* Figure out what exactly is being specialized at this point.
1301 Note that for an explicit instantiation, even one for a
1302 member function, we cannot tell apriori whether the
1303 instantiation is for a member template, or just a member
1304 function of a template class. Even if a member template is
1305 being instantiated, the member template arguments may be
1306 elided if they can be deduced from the rest of the
1308 tmpl
= determine_specialization (declarator
, decl
,
1310 member_specialization
,
1313 if (tmpl
&& tmpl
!= error_mark_node
)
1315 gen_tmpl
= most_general_template (tmpl
);
1317 if (explicit_instantiation
)
1319 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
1320 is done by do_decl_instantiation later. */
1321 decl
= instantiate_template (tmpl
, innermost_args (targs
));
1325 /* If we though that the DECL was a member function, but it
1326 turns out to be specializing a static member function,
1327 make DECL a static member function as well. */
1328 if (DECL_STATIC_FUNCTION_P (tmpl
)
1329 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
1331 revert_static_member_fn (&decl
, 0, 0);
1332 last_function_parms
= TREE_CHAIN (last_function_parms
);
1335 /* Set up the DECL_TEMPLATE_INFO for DECL. */
1336 DECL_TEMPLATE_INFO (decl
)
1337 = perm_tree_cons (tmpl
, targs
, NULL_TREE
);
1339 /* Mangle the function name appropriately. Note that we do
1340 not mangle specializations of non-template member
1341 functions of template classes, e.g. with
1343 template <class T> struct S { void f(); }
1345 and given the specialization
1347 template <> void S<int>::f() {}
1349 we do not mangle S<int>::f() here. That's because it's
1350 just an ordinary member function and doesn't need special
1351 treatment. We do this here so that the ordinary,
1352 non-template, name-mangling algorith will not be used
1354 if ((is_member_template (tmpl
) || ctype
== NULL_TREE
)
1355 && name_mangling_version
>= 1)
1356 set_mangled_name_for_template_decl (decl
);
1358 if (is_friend
&& !have_def
)
1359 /* This is not really a declaration of a specialization.
1360 It's just the name of an instantiation. But, it's not
1361 a request for an instantiation, either. */
1362 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
1364 /* Register this specialization so that we can find it
1366 decl
= register_specialization (decl
, gen_tmpl
, targs
);
1375 /* TYPE is being declared. Verify that the use of template headers
1376 and such is reasonable. Issue error messages if not. */
1379 maybe_check_template_type (type
)
1382 if (template_header_count
)
1384 /* We are in the scope of some `template <...>' header. */
1387 = template_class_depth_real (TYPE_CONTEXT (type
),
1388 /*count_specializations=*/1);
1390 if (template_header_count
<= context_depth
)
1391 /* This is OK; the template headers are for the context. We
1392 are actually too lenient here; like
1393 check_explicit_specialization we should consider the number
1394 of template types included in the actual declaration. For
1397 template <class T> struct S {
1398 template <class U> template <class V>
1404 template <class T> struct S {
1405 template <class U> struct I;
1408 template <class T> template <class U.
1413 else if (template_header_count
> context_depth
+ 1)
1414 /* There are two many template parameter lists. */
1415 cp_error ("too many template parameter lists in declaration of `%T'", type
);
1419 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
1420 parameters. These are represented in the same format used for
1421 DECL_TEMPLATE_PARMS. */
1423 int comp_template_parms (parms1
, parms2
)
1430 if (parms1
== parms2
)
1433 for (p1
= parms1
, p2
= parms2
;
1434 p1
!= NULL_TREE
&& p2
!= NULL_TREE
;
1435 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
))
1437 tree t1
= TREE_VALUE (p1
);
1438 tree t2
= TREE_VALUE (p2
);
1441 my_friendly_assert (TREE_CODE (t1
) == TREE_VEC
, 0);
1442 my_friendly_assert (TREE_CODE (t2
) == TREE_VEC
, 0);
1444 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
1447 for (i
= 0; i
< TREE_VEC_LENGTH (t2
); ++i
)
1449 tree parm1
= TREE_VALUE (TREE_VEC_ELT (t1
, i
));
1450 tree parm2
= TREE_VALUE (TREE_VEC_ELT (t2
, i
));
1452 if (TREE_CODE (parm1
) != TREE_CODE (parm2
))
1455 if (TREE_CODE (parm1
) == TEMPLATE_TYPE_PARM
)
1457 else if (!same_type_p (TREE_TYPE (parm1
), TREE_TYPE (parm2
)))
1462 if ((p1
!= NULL_TREE
) != (p2
!= NULL_TREE
))
1463 /* One set of parameters has more parameters lists than the
1471 /* Returns 1 iff DECL is a template parameter. */
1473 int decl_template_parm_p (decl
)
1476 /* For template template parms. */
1477 if (TREE_CODE (decl
) == TEMPLATE_DECL
1479 && TREE_CODE (TREE_TYPE (decl
)) == TEMPLATE_TEMPLATE_PARM
)
1482 /* For template type parms. */
1483 if (TREE_CODE (decl
) == TYPE_DECL
1485 && TREE_CODE (TREE_TYPE (decl
)) == TEMPLATE_TYPE_PARM
)
1488 /* For template non-type parms. */
1489 if (TREE_CODE (decl
) == CONST_DECL
1490 && DECL_INITIAL (decl
)
1491 && TREE_CODE (DECL_INITIAL (decl
)) == TEMPLATE_PARM_INDEX
)
1497 /* Complain if DECL shadows a template parameter.
1499 [temp.local]: A template-parameter shall not be redeclared within its
1500 scope (including nested scopes). */
1503 check_template_shadow (decl
)
1506 tree olddecl
= IDENTIFIER_VALUE (DECL_NAME (decl
));
1508 if (current_template_parms
&& olddecl
)
1510 /* We check for decl != olddecl to avoid bogus errors for using a
1511 name inside a class. We check TPFI to avoid duplicate errors for
1512 inline member templates. */
1513 if (decl
!= olddecl
&& decl_template_parm_p (olddecl
)
1514 && ! TEMPLATE_PARMS_FOR_INLINE (current_template_parms
))
1516 cp_error_at ("declaration of `%#D'", decl
);
1517 cp_error_at (" shadows template parm `%#D'", olddecl
);
1522 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
1523 ORIG_LEVEL, DECL, and TYPE. */
1526 build_template_parm_index (index
, level
, orig_level
, decl
, type
)
1533 tree t
= make_node (TEMPLATE_PARM_INDEX
);
1534 TEMPLATE_PARM_IDX (t
) = index
;
1535 TEMPLATE_PARM_LEVEL (t
) = level
;
1536 TEMPLATE_PARM_ORIG_LEVEL (t
) = orig_level
;
1537 TEMPLATE_PARM_DECL (t
) = decl
;
1538 TREE_TYPE (t
) = type
;
1543 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
1544 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
1545 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
1546 new one is created. */
1549 reduce_template_parm_level (index
, type
, levels
)
1554 if (TEMPLATE_PARM_DESCENDANTS (index
) == NULL_TREE
1555 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index
))
1556 != TEMPLATE_PARM_LEVEL (index
) - levels
))
1559 = build_decl (TREE_CODE (TEMPLATE_PARM_DECL (index
)),
1560 DECL_NAME (TEMPLATE_PARM_DECL (index
)),
1563 = build_template_parm_index (TEMPLATE_PARM_IDX (index
),
1564 TEMPLATE_PARM_LEVEL (index
) - levels
,
1565 TEMPLATE_PARM_ORIG_LEVEL (index
),
1567 TEMPLATE_PARM_DESCENDANTS (index
) = t
;
1569 /* Template template parameters need this. */
1570 DECL_TEMPLATE_PARMS (decl
)
1571 = DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index
));
1574 return TEMPLATE_PARM_DESCENDANTS (index
);
1577 /* Process information from new template parameter NEXT and append it to the
1578 LIST being built. */
1581 process_template_parm (list
, next
)
1590 my_friendly_assert (TREE_CODE (parm
) == TREE_LIST
, 259);
1591 defval
= TREE_PURPOSE (parm
);
1592 parm
= TREE_VALUE (parm
);
1593 is_type
= TREE_PURPOSE (parm
) == class_type_node
;
1597 tree p
= TREE_VALUE (tree_last (list
));
1599 if (TREE_CODE (p
) == TYPE_DECL
)
1600 idx
= TEMPLATE_TYPE_IDX (TREE_TYPE (p
));
1601 else if (TREE_CODE (p
) == TEMPLATE_DECL
)
1602 idx
= TEMPLATE_TYPE_IDX (TREE_TYPE (DECL_TEMPLATE_RESULT (p
)));
1604 idx
= TEMPLATE_PARM_IDX (DECL_INITIAL (p
));
1612 my_friendly_assert (TREE_CODE (TREE_PURPOSE (parm
)) == TREE_LIST
, 260);
1613 /* is a const-param */
1614 parm
= grokdeclarator (TREE_VALUE (parm
), TREE_PURPOSE (parm
),
1615 PARM
, 0, NULL_TREE
);
1616 /* A template parameter is not modifiable. */
1617 TREE_READONLY (parm
) = 1;
1618 if (IS_AGGR_TYPE (TREE_TYPE (parm
))
1619 && TREE_CODE (TREE_TYPE (parm
)) != TEMPLATE_TYPE_PARM
1620 && TREE_CODE (TREE_TYPE (parm
)) != TYPENAME_TYPE
)
1622 cp_error ("`%#T' is not a valid type for a template constant parameter",
1624 if (DECL_NAME (parm
) == NULL_TREE
)
1625 error (" a template type parameter must begin with `class' or `typename'");
1626 TREE_TYPE (parm
) = void_type_node
;
1629 && (TREE_CODE (TREE_TYPE (parm
)) == REAL_TYPE
1630 || TREE_CODE (TREE_TYPE (parm
)) == COMPLEX_TYPE
))
1631 cp_pedwarn ("`%T' is not a valid type for a template constant parameter",
1633 if (TREE_PERMANENT (parm
) == 0)
1635 parm
= copy_node (parm
);
1636 TREE_PERMANENT (parm
) = 1;
1638 decl
= build_decl (CONST_DECL
, DECL_NAME (parm
), TREE_TYPE (parm
));
1639 DECL_INITIAL (parm
) = DECL_INITIAL (decl
)
1640 = build_template_parm_index (idx
, processing_template_decl
,
1641 processing_template_decl
,
1642 decl
, TREE_TYPE (parm
));
1647 parm
= TREE_VALUE (parm
);
1649 if (parm
&& TREE_CODE (parm
) == TEMPLATE_DECL
)
1651 t
= make_lang_type (TEMPLATE_TEMPLATE_PARM
);
1652 /* This is for distinguishing between real templates and template
1653 template parameters */
1654 TREE_TYPE (parm
) = t
;
1655 TREE_TYPE (DECL_TEMPLATE_RESULT (parm
)) = t
;
1660 t
= make_lang_type (TEMPLATE_TYPE_PARM
);
1661 /* parm is either IDENTIFIER_NODE or NULL_TREE */
1662 decl
= build_decl (TYPE_DECL
, parm
, t
);
1665 TYPE_NAME (t
) = decl
;
1666 TYPE_STUB_DECL (t
) = decl
;
1668 TEMPLATE_TYPE_PARM_INDEX (t
)
1669 = build_template_parm_index (idx
, processing_template_decl
,
1670 processing_template_decl
,
1671 decl
, TREE_TYPE (parm
));
1673 SET_DECL_ARTIFICIAL (decl
);
1675 parm
= build_tree_list (defval
, parm
);
1676 return chainon (list
, parm
);
1679 /* The end of a template parameter list has been reached. Process the
1680 tree list into a parameter vector, converting each parameter into a more
1681 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
1685 end_template_parm_list (parms
)
1690 tree saved_parmlist
= make_tree_vec (list_length (parms
));
1692 current_template_parms
1693 = tree_cons (build_int_2 (0, processing_template_decl
),
1694 saved_parmlist
, current_template_parms
);
1696 for (parm
= parms
, nparms
= 0; parm
; parm
= TREE_CHAIN (parm
), nparms
++)
1697 TREE_VEC_ELT (saved_parmlist
, nparms
) = parm
;
1699 --processing_template_parmlist
;
1701 return saved_parmlist
;
1704 /* end_template_decl is called after a template declaration is seen. */
1707 end_template_decl ()
1709 reset_specialization ();
1711 if (! processing_template_decl
)
1714 /* This matches the pushlevel in begin_template_parm_list. */
1717 --processing_template_decl
;
1718 current_template_parms
= TREE_CHAIN (current_template_parms
);
1719 (void) get_pending_sizes (); /* Why? */
1722 /* Given a template argument vector containing the template PARMS.
1723 The innermost PARMS are given first. */
1726 current_template_args ()
1729 tree args
= NULL_TREE
;
1730 int length
= TMPL_PARMS_DEPTH (current_template_parms
);
1733 /* If there is only one level of template parameters, we do not
1734 create a TREE_VEC of TREE_VECs. Instead, we return a single
1735 TREE_VEC containing the arguments. */
1737 args
= make_tree_vec (length
);
1739 for (header
= current_template_parms
; header
; header
= TREE_CHAIN (header
))
1741 tree a
= copy_node (TREE_VALUE (header
));
1744 TREE_TYPE (a
) = NULL_TREE
;
1745 for (i
= TREE_VEC_LENGTH (a
) - 1; i
>= 0; --i
)
1747 tree t
= TREE_VEC_ELT (a
, i
);
1749 /* T will be a list if we are called from within a
1750 begin/end_template_parm_list pair, but a vector directly
1751 if within a begin/end_member_template_processing pair. */
1752 if (TREE_CODE (t
) == TREE_LIST
)
1756 if (TREE_CODE (t
) == TYPE_DECL
1757 || TREE_CODE (t
) == TEMPLATE_DECL
)
1760 t
= DECL_INITIAL (t
);
1761 TREE_VEC_ELT (a
, i
) = t
;
1766 TREE_VEC_ELT (args
, --l
) = a
;
1774 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
1775 template PARMS. Used by push_template_decl below. */
1778 build_template_decl (decl
, parms
)
1782 tree tmpl
= build_lang_decl (TEMPLATE_DECL
, DECL_NAME (decl
), NULL_TREE
);
1783 DECL_TEMPLATE_PARMS (tmpl
) = parms
;
1784 DECL_CONTEXT (tmpl
) = DECL_CONTEXT (decl
);
1785 if (DECL_LANG_SPECIFIC (decl
))
1787 DECL_CLASS_CONTEXT (tmpl
) = DECL_CLASS_CONTEXT (decl
);
1788 DECL_STATIC_FUNCTION_P (tmpl
) =
1789 DECL_STATIC_FUNCTION_P (decl
);
1795 struct template_parm_data
1797 /* The level of the template parameters we are currently
1801 /* The index of the specialization argument we are currently
1805 /* An array whose size is the number of template parameters. The
1806 elements are non-zero if the parameter has been used in any one
1807 of the arguments processed so far. */
1810 /* An array whose size is the number of template arguments. The
1811 elements are non-zero if the argument makes use of template
1812 parameters of this level. */
1813 int* arg_uses_template_parms
;
1816 /* Subroutine of push_template_decl used to see if each template
1817 parameter in a partial specialization is used in the explicit
1818 argument list. If T is of the LEVEL given in DATA (which is
1819 treated as a template_parm_data*), then DATA->PARMS is marked
1823 mark_template_parm (t
, data
)
1829 struct template_parm_data
* tpd
= (struct template_parm_data
*) data
;
1831 if (TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
1833 level
= TEMPLATE_PARM_LEVEL (t
);
1834 idx
= TEMPLATE_PARM_IDX (t
);
1838 level
= TEMPLATE_TYPE_LEVEL (t
);
1839 idx
= TEMPLATE_TYPE_IDX (t
);
1842 if (level
== tpd
->level
)
1844 tpd
->parms
[idx
] = 1;
1845 tpd
->arg_uses_template_parms
[tpd
->current_arg
] = 1;
1848 /* Return zero so that for_each_template_parm will continue the
1849 traversal of the tree; we want to mark *every* template parm. */
1853 /* Process the partial specialization DECL. */
1856 process_partial_specialization (decl
)
1859 tree type
= TREE_TYPE (decl
);
1860 tree maintmpl
= CLASSTYPE_TI_TEMPLATE (type
);
1861 tree specargs
= CLASSTYPE_TI_ARGS (type
);
1862 tree inner_args
= innermost_args (specargs
);
1863 tree inner_parms
= INNERMOST_TEMPLATE_PARMS (current_template_parms
);
1864 tree main_inner_parms
= DECL_INNERMOST_TEMPLATE_PARMS (maintmpl
);
1865 int nargs
= TREE_VEC_LENGTH (inner_args
);
1866 int ntparms
= TREE_VEC_LENGTH (inner_parms
);
1868 int did_error_intro
= 0;
1869 struct template_parm_data tpd
;
1870 struct template_parm_data tpd2
;
1872 /* We check that each of the template parameters given in the
1873 partial specialization is used in the argument list to the
1874 specialization. For example:
1876 template <class T> struct S;
1877 template <class T> struct S<T*>;
1879 The second declaration is OK because `T*' uses the template
1880 parameter T, whereas
1882 template <class T> struct S<int>;
1884 is no good. Even trickier is:
1895 The S2<T> declaration is actually illegal; it is a
1896 full-specialization. Of course,
1899 struct S2<T (*)(U)>;
1901 or some such would have been OK. */
1902 tpd
.level
= TMPL_PARMS_DEPTH (current_template_parms
);
1903 tpd
.parms
= alloca (sizeof (int) * ntparms
);
1904 bzero ((PTR
) tpd
.parms
, sizeof (int) * ntparms
);
1906 tpd
.arg_uses_template_parms
= alloca (sizeof (int) * nargs
);
1907 bzero ((PTR
) tpd
.arg_uses_template_parms
, sizeof (int) * nargs
);
1908 for (i
= 0; i
< nargs
; ++i
)
1910 tpd
.current_arg
= i
;
1911 for_each_template_parm (TREE_VEC_ELT (inner_args
, i
),
1912 &mark_template_parm
,
1915 for (i
= 0; i
< ntparms
; ++i
)
1916 if (tpd
.parms
[i
] == 0)
1918 /* One of the template parms was not used in the
1920 if (!did_error_intro
)
1922 cp_error ("template parameters not used in partial specialization:");
1923 did_error_intro
= 1;
1927 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
)));
1930 /* [temp.class.spec]
1932 The argument list of the specialization shall not be identical to
1933 the implicit argument list of the primary template. */
1934 if (comp_template_args (inner_args
,
1935 innermost_args (CLASSTYPE_TI_ARGS (TREE_TYPE
1937 cp_error ("partial specialization `%T' does not specialize any template arguments", type
);
1939 /* [temp.class.spec]
1941 A partially specialized non-type argument expression shall not
1942 involve template parameters of the partial specialization except
1943 when the argument expression is a simple identifier.
1945 The type of a template parameter corresponding to a specialized
1946 non-type argument shall not be dependent on a parameter of the
1948 my_friendly_assert (nargs
== DECL_NTPARMS (maintmpl
), 0);
1950 for (i
= 0; i
< nargs
; ++i
)
1952 tree arg
= TREE_VEC_ELT (inner_args
, i
);
1953 if (/* These first two lines are the `non-type' bit. */
1954 TREE_CODE_CLASS (TREE_CODE (arg
)) != 't'
1955 && TREE_CODE (arg
) != TEMPLATE_DECL
1956 /* This next line is the `argument expression is not just a
1957 simple identifier' condition and also the `specialized
1958 non-type argument' bit. */
1959 && TREE_CODE (arg
) != TEMPLATE_PARM_INDEX
)
1961 if (tpd
.arg_uses_template_parms
[i
])
1962 cp_error ("template argument `%E' involves template parameter(s)", arg
);
1965 /* Look at the corresponding template parameter,
1966 marking which template parameters its type depends
1969 TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (main_inner_parms
,
1974 /* We haven't yet initialized TPD2. Do so now. */
1975 tpd2
.arg_uses_template_parms
1976 = (int*) alloca (sizeof (int) * nargs
);
1977 /* The number of parameters here is the number in the
1978 main template, which, as checked in the assertion
1980 tpd2
.parms
= (int*) alloca (sizeof (int) * nargs
);
1982 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl
));
1985 /* Mark the template parameters. But this time, we're
1986 looking for the template parameters of the main
1987 template, not in the specialization. */
1988 tpd2
.current_arg
= i
;
1989 tpd2
.arg_uses_template_parms
[i
] = 0;
1990 bzero ((PTR
) tpd2
.parms
, sizeof (int) * nargs
);
1991 for_each_template_parm (type
,
1992 &mark_template_parm
,
1995 if (tpd2
.arg_uses_template_parms
[i
])
1997 /* The type depended on some template parameters.
1998 If they are fully specialized in the
1999 specialization, that's OK. */
2001 for (j
= 0; j
< nargs
; ++j
)
2002 if (tpd2
.parms
[j
] != 0
2003 && tpd
.arg_uses_template_parms
[j
])
2005 cp_error ("type `%T' of template argument `%E' depends on template parameter(s)",
2015 if (retrieve_specialization (maintmpl
, specargs
))
2016 /* We've already got this specialization. */
2019 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
) = CLASSTYPE_TI_SPEC_INFO (type
)
2020 = perm_tree_cons (inner_args
, inner_parms
,
2021 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
));
2022 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)) = type
;
2026 /* Check that a template declaration's use of default arguments is not
2027 invalid. Here, PARMS are the template parameters. IS_PRIMARY is
2028 non-zero if DECL is the thing declared by a primary template.
2029 IS_PARTIAL is non-zero if DECL is a partial specialization. */
2032 check_default_tmpl_args (decl
, parms
, is_primary
, is_partial
)
2039 int last_level_to_check
;
2043 A default template-argument shall not be specified in a
2044 function template declaration or a function template definition, nor
2045 in the template-parameter-list of the definition of a member of a
2048 if (current_class_type
2049 && !TYPE_BEING_DEFINED (current_class_type
)
2050 && DECL_REAL_CONTEXT (decl
) == current_class_type
2051 && DECL_DEFINED_IN_CLASS_P (decl
))
2052 /* We already checked these parameters when the template was
2053 declared, so there's no need to do it again now. This is an
2054 inline member function definition. */
2057 if (TREE_CODE (decl
) != TYPE_DECL
|| is_partial
|| !is_primary
)
2058 /* For an ordinary class template, default template arguments are
2059 allowed at the innermost level, e.g.:
2060 template <class T = int>
2062 but, in a partial specialization, they're not allowed even
2063 there, as we have in [temp.class.spec]:
2065 The template parameter list of a specialization shall not
2066 contain default template argument values.
2068 So, for a partial specialization, or for a function template,
2069 we look at all of them. */
2072 /* But, for a primary class template that is not a partial
2073 specialization we look at all template parameters except the
2075 parms
= TREE_CHAIN (parms
);
2077 /* Figure out what error message to issue. */
2078 if (TREE_CODE (decl
) == FUNCTION_DECL
)
2079 msg
= "default argument for template parameter in function template `%D'";
2080 else if (is_partial
)
2081 msg
= "default argument in partial specialization `%D'";
2083 msg
= "default argument for template parameter for class enclosing `%D'";
2085 if (current_class_type
&& TYPE_BEING_DEFINED (current_class_type
))
2086 /* If we're inside a class definition, there's no need to
2087 examine the parameters to the class itself. On the one
2088 hand, they will be checked when the class is defined, and,
2089 on the other, default arguments are legal in things like:
2090 template <class T = double>
2091 struct S { template <class U> void f(U); };
2092 Here the default argument for `S' has no bearing on the
2093 declaration of `f'. */
2094 last_level_to_check
= template_class_depth (current_class_type
) + 1;
2096 /* Check everything. */
2097 last_level_to_check
= 0;
2099 for (; parms
&& TMPL_PARMS_DEPTH (parms
) >= last_level_to_check
;
2100 parms
= TREE_CHAIN (parms
))
2102 tree inner_parms
= TREE_VALUE (parms
);
2105 ntparms
= TREE_VEC_LENGTH (inner_parms
);
2106 for (i
= 0; i
< ntparms
; ++i
)
2107 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)))
2111 cp_error (msg
, decl
);
2115 /* Clear out the default argument so that we are not
2117 TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)) = NULL_TREE
;
2120 /* At this point, if we're still interested in issuing messages,
2121 they must apply to classes surrounding the object declared. */
2123 msg
= "default argument for template parameter for class enclosing `%D'";
2127 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
2128 parameters given by current_template_args, or reuses a
2129 previously existing one, if appropriate. Returns the DECL, or an
2130 equivalent one, if it is replaced via a call to duplicate_decls.
2132 If IS_FRIEND is non-zero, DECL is a friend declaration. */
2135 push_template_decl_real (decl
, is_friend
)
2146 /* See if this is a partial specialization. */
2147 is_partial
= (TREE_CODE (decl
) == TYPE_DECL
&& DECL_ARTIFICIAL (decl
)
2148 && TREE_CODE (TREE_TYPE (decl
)) != ENUMERAL_TYPE
2149 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)));
2151 is_friend
|= (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_FRIEND_P (decl
));
2154 /* For a friend, we want the context of the friend function, not
2155 the type of which it is a friend. */
2156 ctx
= DECL_CONTEXT (decl
);
2157 else if (DECL_REAL_CONTEXT (decl
)
2158 && TREE_CODE (DECL_REAL_CONTEXT (decl
)) != NAMESPACE_DECL
)
2159 /* In the case of a virtual function, we want the class in which
2161 ctx
= DECL_REAL_CONTEXT (decl
);
2163 /* Otherwise, if we're currently definining some class, the DECL
2164 is assumed to be a member of the class. */
2165 ctx
= current_class_type
;
2167 if (ctx
&& TREE_CODE (ctx
) == NAMESPACE_DECL
)
2170 if (!DECL_CONTEXT (decl
))
2171 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
2173 /* For determining whether this is a primary template or not, we're really
2174 interested in the lexical context, not the true context. */
2176 info
= current_class_type
;
2180 /* See if this is a primary template. */
2181 if (info
&& TREE_CODE (info
) == FUNCTION_DECL
)
2183 /* Note that template_class_depth returns 0 if given NULL_TREE, so
2184 this next line works even when we are at global scope. */
2185 else if (processing_template_decl
> template_class_depth (info
))
2192 if (current_lang_name
== lang_name_c
)
2193 cp_error ("template with C linkage");
2194 if (TREE_CODE (decl
) == TYPE_DECL
&& ANON_AGGRNAME_P (DECL_NAME (decl
)))
2195 cp_error ("template class without a name");
2196 if (TREE_CODE (decl
) == TYPE_DECL
2197 && TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
2198 cp_error ("template declaration of `%#T'", TREE_TYPE (decl
));
2201 /* Check to see that the rules regarding the use of default
2202 arguments are not being violated. */
2203 check_default_tmpl_args (decl
, current_template_parms
,
2204 primary
, is_partial
);
2207 return process_partial_specialization (decl
);
2209 args
= current_template_args ();
2212 || TREE_CODE (ctx
) == FUNCTION_DECL
2213 || TYPE_BEING_DEFINED (ctx
)
2214 || (is_friend
&& !DECL_TEMPLATE_INFO (decl
)))
2216 if (DECL_LANG_SPECIFIC (decl
)
2217 && DECL_TEMPLATE_INFO (decl
)
2218 && DECL_TI_TEMPLATE (decl
))
2219 tmpl
= DECL_TI_TEMPLATE (decl
);
2222 tmpl
= build_template_decl (decl
, current_template_parms
);
2224 if (DECL_LANG_SPECIFIC (decl
)
2225 && DECL_TEMPLATE_SPECIALIZATION (decl
))
2227 /* A specialization of a member template of a template
2229 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
2230 DECL_TEMPLATE_INFO (tmpl
) = DECL_TEMPLATE_INFO (decl
);
2231 DECL_TEMPLATE_INFO (decl
) = NULL_TREE
;
2237 tree a
, t
, current
, parms
;
2240 if (CLASSTYPE_TEMPLATE_INSTANTIATION (ctx
))
2241 cp_error ("must specialize `%#T' before defining member `%#D'",
2243 if (TREE_CODE (decl
) == TYPE_DECL
)
2245 if ((IS_AGGR_TYPE_CODE (TREE_CODE (TREE_TYPE (decl
)))
2246 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
2247 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl
))
2248 && TYPE_TI_TEMPLATE (TREE_TYPE (decl
)))
2249 tmpl
= TYPE_TI_TEMPLATE (TREE_TYPE (decl
));
2252 cp_error ("`%D' does not declare a template type", decl
);
2256 else if (! DECL_TEMPLATE_INFO (decl
))
2258 cp_error ("template definition of non-template `%#D'", decl
);
2262 tmpl
= DECL_TI_TEMPLATE (decl
);
2264 if (is_member_template (tmpl
)
2265 && DECL_FUNCTION_TEMPLATE_P (tmpl
)
2266 && DECL_TEMPLATE_INFO (decl
) && DECL_TI_ARGS (decl
)
2267 && DECL_TEMPLATE_SPECIALIZATION (decl
))
2271 /* The declaration is a specialization of a member
2272 template, declared outside the class. Therefore, the
2273 innermost template arguments will be NULL, so we
2274 replace them with the arguments determined by the
2275 earlier call to check_explicit_specialization. */
2276 args
= DECL_TI_ARGS (decl
);
2279 = build_template_decl (decl
, current_template_parms
);
2280 DECL_TEMPLATE_RESULT (new_tmpl
) = decl
;
2281 TREE_TYPE (new_tmpl
) = TREE_TYPE (decl
);
2282 DECL_TI_TEMPLATE (decl
) = new_tmpl
;
2283 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl
);
2284 DECL_TEMPLATE_INFO (new_tmpl
) =
2285 perm_tree_cons (tmpl
, args
, NULL_TREE
);
2287 register_specialization (new_tmpl
, tmpl
, args
);
2291 /* Make sure the template headers we got make sense. */
2293 parms
= DECL_TEMPLATE_PARMS (tmpl
);
2294 i
= TMPL_PARMS_DEPTH (parms
);
2295 if (TMPL_ARGS_DEPTH (args
) != i
)
2297 cp_error ("expected %d levels of template parms for `%#D', got %d",
2298 i
, decl
, TMPL_ARGS_DEPTH (args
));
2301 for (current
= decl
; i
> 0; --i
, parms
= TREE_CHAIN (parms
))
2303 a
= TMPL_ARGS_LEVEL (args
, i
);
2304 t
= INNERMOST_TEMPLATE_PARMS (parms
);
2306 if (TREE_VEC_LENGTH (t
) != TREE_VEC_LENGTH (a
))
2308 if (current
== decl
)
2309 cp_error ("got %d template parameters for `%#D'",
2310 TREE_VEC_LENGTH (a
), decl
);
2312 cp_error ("got %d template parameters for `%#T'",
2313 TREE_VEC_LENGTH (a
), current
);
2314 cp_error (" but %d required", TREE_VEC_LENGTH (t
));
2317 /* Perhaps we should also check that the parms are used in the
2318 appropriate qualifying scopes in the declarator? */
2320 if (current
== decl
)
2323 current
= TYPE_CONTEXT (current
);
2327 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
2328 TREE_TYPE (tmpl
) = TREE_TYPE (decl
);
2330 /* Push template declarations for global functions and types. Note
2331 that we do not try to push a global template friend declared in a
2332 template class; such a thing may well depend on the template
2333 parameters of the class. */
2335 && !(is_friend
&& template_class_depth (current_class_type
) > 0))
2336 tmpl
= pushdecl_namespace_level (tmpl
);
2339 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
2341 info
= perm_tree_cons (tmpl
, args
, NULL_TREE
);
2343 if (TREE_CODE (decl
) == TYPE_DECL
&& DECL_ARTIFICIAL (decl
))
2345 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl
), info
);
2346 if ((!ctx
|| TREE_CODE (ctx
) != FUNCTION_DECL
)
2347 && TREE_CODE (TREE_TYPE (decl
)) != ENUMERAL_TYPE
)
2348 DECL_NAME (decl
) = classtype_mangled_name (TREE_TYPE (decl
));
2350 else if (! DECL_LANG_SPECIFIC (decl
))
2351 cp_error ("template declaration of `%#D'", decl
);
2353 DECL_TEMPLATE_INFO (decl
) = info
;
2355 return DECL_TEMPLATE_RESULT (tmpl
);
2359 push_template_decl (decl
)
2362 return push_template_decl_real (decl
, 0);
2365 /* Called when a class template TYPE is redeclared with the indicated
2366 template PARMS, e.g.:
2368 template <class T> struct S;
2369 template <class T> struct S {}; */
2372 redeclare_class_template (type
, parms
)
2376 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
2380 if (!PRIMARY_TEMPLATE_P (tmpl
))
2381 /* The type is nested in some template class. Nothing to worry
2382 about here; there are no new template parameters for the nested
2386 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
2387 tmpl_parms
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl
);
2389 if (TREE_VEC_LENGTH (parms
) != TREE_VEC_LENGTH (tmpl_parms
))
2391 cp_error_at ("previous declaration `%D'", tmpl
);
2392 cp_error ("used %d template parameter%s instead of %d",
2393 TREE_VEC_LENGTH (tmpl_parms
),
2394 TREE_VEC_LENGTH (tmpl_parms
) == 1 ? "" : "s",
2395 TREE_VEC_LENGTH (parms
));
2399 for (i
= 0; i
< TREE_VEC_LENGTH (tmpl_parms
); ++i
)
2401 tree tmpl_parm
= TREE_VALUE (TREE_VEC_ELT (tmpl_parms
, i
));
2402 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
2403 tree tmpl_default
= TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
));
2404 tree parm_default
= TREE_PURPOSE (TREE_VEC_ELT (parms
, i
));
2406 if (TREE_CODE (tmpl_parm
) != TREE_CODE (parm
))
2408 cp_error_at ("template parameter `%#D'", tmpl_parm
);
2409 cp_error ("redeclared here as `%#D'", parm
);
2413 if (tmpl_default
!= NULL_TREE
&& parm_default
!= NULL_TREE
)
2415 /* We have in [temp.param]:
2417 A template-parameter may not be given default arguments
2418 by two different declarations in the same scope. */
2419 cp_error ("redefinition of default argument for `%#D'", parm
);
2420 cp_error_at (" original definition appeared here", tmpl_parm
);
2424 if (parm_default
!= NULL_TREE
)
2425 /* Update the previous template parameters (which are the ones
2426 that will really count) with the new default value. */
2427 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
)) = parm_default
;
2431 /* Attempt to convert the non-type template parameter EXPR to the
2432 indicated TYPE. If the conversion is successful, return the
2433 converted value. If the conversion is unsuccesful, return
2434 NULL_TREE if we issued an error message, or error_mark_node if we
2435 did not. We issue error messages for out-and-out bad template
2436 parameters, but not simply because the conversion failed, since we
2437 might be just trying to do argument deduction. By the time this
2438 function is called, neither TYPE nor EXPR may make use of template
2442 convert_nontype_argument (type
, expr
)
2446 tree expr_type
= TREE_TYPE (expr
);
2448 /* A template-argument for a non-type, non-template
2449 template-parameter shall be one of:
2451 --an integral constant-expression of integral or enumeration
2454 --the name of a non-type template-parameter; or
2456 --the name of an object or function with external linkage,
2457 including function templates and function template-ids but
2458 excluding non-static class members, expressed as id-expression;
2461 --the address of an object or function with external linkage,
2462 including function templates and function template-ids but
2463 excluding non-static class members, expressed as & id-expression
2464 where the & is optional if the name refers to a function or
2467 --a pointer to member expressed as described in _expr.unary.op_. */
2469 /* An integral constant-expression can include const variables
2471 if (INTEGRAL_TYPE_P (expr_type
) && TREE_READONLY_DECL_P (expr
))
2472 expr
= decl_constant_value (expr
);
2474 if (is_overloaded_fn (expr
))
2475 /* OK for now. We'll check that it has external linkage later.
2476 Check this first since if expr_type is the unknown_type_node
2477 we would otherwise complain below. */
2479 else if (TYPE_PTR_P (expr_type
)
2480 || TREE_CODE (expr_type
) == ARRAY_TYPE
2481 || TREE_CODE (type
) == REFERENCE_TYPE
2482 /* If expr is the address of an overloaded function, we
2483 will get the unknown_type_node at this point. */
2484 || expr_type
== unknown_type_node
)
2490 if (TREE_CODE (type
) == REFERENCE_TYPE
2491 || TREE_CODE (expr_type
) == ARRAY_TYPE
)
2495 if (TREE_CODE (e
) != ADDR_EXPR
)
2498 cp_error ("`%E' is not a valid template argument", expr
);
2499 error ("it must be %s%s with external linkage",
2500 TREE_CODE (TREE_TYPE (expr
)) == POINTER_TYPE
2501 ? "a pointer to " : "",
2502 TREE_CODE (TREE_TYPE (TREE_TYPE (expr
))) == FUNCTION_TYPE
2503 ? "a function" : "an object");
2507 referent
= TREE_OPERAND (e
, 0);
2508 STRIP_NOPS (referent
);
2511 if (TREE_CODE (referent
) == STRING_CST
)
2513 cp_error ("string literal %E is not a valid template argument",
2515 error ("because it is the address of an object with static linkage");
2519 if (is_overloaded_fn (referent
))
2520 /* We'll check that it has external linkage later. */
2522 else if (TREE_CODE (referent
) != VAR_DECL
)
2524 else if (!TREE_PUBLIC (referent
))
2526 cp_error ("address of non-extern `%E' cannot be used as template argument", referent
);
2527 return error_mark_node
;
2530 else if (INTEGRAL_TYPE_P (expr_type
)
2531 || TYPE_PTRMEM_P (expr_type
)
2532 || TYPE_PTRMEMFUNC_P (expr_type
)
2533 /* The next two are g++ extensions. */
2534 || TREE_CODE (expr_type
) == REAL_TYPE
2535 || TREE_CODE (expr_type
) == COMPLEX_TYPE
)
2537 if (! TREE_CONSTANT (expr
))
2540 cp_error ("non-constant `%E' cannot be used as template argument",
2547 cp_error ("object `%E' cannot be used as template argument", expr
);
2551 switch (TREE_CODE (type
))
2556 /* For a non-type template-parameter of integral or enumeration
2557 type, integral promotions (_conv.prom_) and integral
2558 conversions (_conv.integral_) are applied. */
2559 if (!INTEGRAL_TYPE_P (expr_type
))
2560 return error_mark_node
;
2562 /* It's safe to call digest_init in this case; we know we're
2563 just converting one integral constant expression to another. */
2564 expr
= digest_init (type
, expr
, (tree
*) 0);
2566 if (TREE_CODE (expr
) != INTEGER_CST
)
2567 /* Curiously, some TREE_CONSTANT integral expressions do not
2568 simplify to integer constants. For example, `3 % 0',
2569 remains a TRUNC_MOD_EXPR. */
2576 /* These are g++ extensions. */
2577 if (TREE_CODE (expr_type
) != TREE_CODE (type
))
2578 return error_mark_node
;
2580 expr
= digest_init (type
, expr
, (tree
*) 0);
2582 if (TREE_CODE (expr
) != REAL_CST
)
2589 tree type_pointed_to
= TREE_TYPE (type
);
2591 if (TYPE_PTRMEM_P (type
))
2592 /* For a non-type template-parameter of type pointer to data
2593 member, qualification conversions (_conv.qual_) are
2595 return perform_qualification_conversions (type
, expr
);
2596 else if (TREE_CODE (type_pointed_to
) == FUNCTION_TYPE
)
2598 /* For a non-type template-parameter of type pointer to
2599 function, only the function-to-pointer conversion
2600 (_conv.func_) is applied. If the template-argument
2601 represents a set of overloaded functions (or a pointer to
2602 such), the matching function is selected from the set
2607 if (TREE_CODE (expr
) == ADDR_EXPR
)
2608 fns
= TREE_OPERAND (expr
, 0);
2612 fn
= instantiate_type (type_pointed_to
, fns
, 0);
2614 if (fn
== error_mark_node
)
2615 return error_mark_node
;
2617 if (!TREE_PUBLIC (fn
))
2619 if (really_overloaded_fn (fns
))
2620 return error_mark_node
;
2625 expr
= build_unary_op (ADDR_EXPR
, fn
, 0);
2627 my_friendly_assert (same_type_p (type
, TREE_TYPE (expr
)),
2633 /* For a non-type template-parameter of type pointer to
2634 object, qualification conversions (_conv.qual_) and the
2635 array-to-pointer conversion (_conv.array_) are applied.
2636 [Note: In particular, neither the null pointer conversion
2637 (_conv.ptr_) nor the derived-to-base conversion
2638 (_conv.ptr_) are applied. Although 0 is a valid
2639 template-argument for a non-type template-parameter of
2640 integral type, it is not a valid template-argument for a
2641 non-type template-parameter of pointer type.]
2643 The call to decay_conversion performs the
2644 array-to-pointer conversion, if appropriate. */
2645 expr
= decay_conversion (expr
);
2647 if (expr
== error_mark_node
)
2648 return error_mark_node
;
2650 return perform_qualification_conversions (type
, expr
);
2655 case REFERENCE_TYPE
:
2657 tree type_referred_to
= TREE_TYPE (type
);
2659 if (TREE_CODE (type_referred_to
) == FUNCTION_TYPE
)
2661 /* For a non-type template-parameter of type reference to
2662 function, no conversions apply. If the
2663 template-argument represents a set of overloaded
2664 functions, the matching function is selected from the
2665 set (_over.over_). */
2669 fn
= instantiate_type (type_referred_to
, fns
, 0);
2671 if (fn
== error_mark_node
)
2672 return error_mark_node
;
2674 if (!TREE_PUBLIC (fn
))
2676 if (really_overloaded_fn (fns
))
2677 /* Don't issue an error here; we might get a different
2678 function if the overloading had worked out
2680 return error_mark_node
;
2685 my_friendly_assert (same_type_p (type_referred_to
,
2693 /* For a non-type template-parameter of type reference to
2694 object, no conversions apply. The type referred to by the
2695 reference may be more cv-qualified than the (otherwise
2696 identical) type of the template-argument. The
2697 template-parameter is bound directly to the
2698 template-argument, which must be an lvalue. */
2699 if ((TYPE_MAIN_VARIANT (expr_type
)
2700 != TYPE_MAIN_VARIANT (type_referred_to
))
2701 || !at_least_as_qualified_p (type_referred_to
,
2703 || !real_lvalue_p (expr
))
2704 return error_mark_node
;
2716 if (!TYPE_PTRMEMFUNC_P (type
))
2717 /* This handles templates like
2718 template<class T, T t> void f();
2719 when T is substituted with any class. The second template
2720 parameter becomes invalid and the template candidate is
2722 return error_mark_node
;
2724 /* For a non-type template-parameter of type pointer to member
2725 function, no conversions apply. If the template-argument
2726 represents a set of overloaded member functions, the
2727 matching member function is selected from the set
2730 if (!TYPE_PTRMEMFUNC_P (expr_type
) &&
2731 expr_type
!= unknown_type_node
)
2732 return error_mark_node
;
2734 if (TREE_CODE (expr
) == CONSTRUCTOR
)
2736 /* A ptr-to-member constant. */
2737 if (!same_type_p (type
, expr_type
))
2738 return error_mark_node
;
2743 if (TREE_CODE (expr
) != ADDR_EXPR
)
2744 return error_mark_node
;
2746 fns
= TREE_OPERAND (expr
, 0);
2748 fn
= instantiate_type (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type
)),
2751 if (fn
== error_mark_node
)
2752 return error_mark_node
;
2754 expr
= build_unary_op (ADDR_EXPR
, fn
, 0);
2756 my_friendly_assert (same_type_p (type
, TREE_TYPE (expr
)),
2763 /* All non-type parameters must have one of these types. */
2764 my_friendly_abort (0);
2768 return error_mark_node
;
2771 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
2772 template template parameters. Both PARM_PARMS and ARG_PARMS are
2773 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
2776 ARG_PARMS may contain more parameters than PARM_PARMS. If this is
2777 the case, then extra parameters must have default arguments.
2779 Consider the example:
2780 template <class T, class Allocator = allocator> class vector;
2781 template<template <class U> class TT> class C;
2783 C<vector> is a valid instantiation. PARM_PARMS for the above code
2784 contains a TYPE_DECL (for U), ARG_PARMS contains two TYPE_DECLs (for
2785 T and Allocator) and OUTER_ARGS contains the argument that is used to
2786 substitute the TT parameter. */
2789 coerce_template_template_parms (parm_parms
, arg_parms
, in_decl
, outer_args
)
2790 tree parm_parms
, arg_parms
, in_decl
, outer_args
;
2792 int nparms
, nargs
, i
;
2795 my_friendly_assert (TREE_CODE (parm_parms
) == TREE_VEC
, 0);
2796 my_friendly_assert (TREE_CODE (arg_parms
) == TREE_VEC
, 0);
2798 nparms
= TREE_VEC_LENGTH (parm_parms
);
2799 nargs
= TREE_VEC_LENGTH (arg_parms
);
2801 /* The rule here is opposite of coerce_template_parms. */
2804 && TREE_PURPOSE (TREE_VEC_ELT (arg_parms
, nparms
)) == NULL_TREE
))
2807 for (i
= 0; i
< nparms
; ++i
)
2809 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
2810 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
2812 if (arg
== NULL_TREE
|| arg
== error_mark_node
2813 || parm
== NULL_TREE
|| parm
== error_mark_node
)
2816 if (TREE_CODE (arg
) != TREE_CODE (parm
))
2819 switch (TREE_CODE (parm
))
2825 /* We encounter instantiations of templates like
2826 template <template <template <class> class> class TT>
2828 sorry ("nested template template parameter");
2832 /* The tsubst call is used to handle cases such as
2833 template <class T, template <T> class TT> class D;
2834 i.e. the parameter list of TT depends on earlier parameters. */
2835 if (!same_type_p (tsubst (TREE_TYPE (parm
), outer_args
, in_decl
),
2841 my_friendly_abort (0);
2847 /* Convert the indicated template ARG as necessary to match the
2848 indicated template PARM. Returns the converted ARG, or
2849 error_mark_node if the conversion was unsuccessful. Error messages
2850 are issued if COMPLAIN is non-zero. This conversion is for the Ith
2851 parameter in the parameter list. ARGS is the full set of template
2852 arguments deduced so far. */
2855 convert_template_argument (parm
, arg
, args
, complain
, i
, in_decl
)
2865 int is_type
, requires_type
, is_tmpl_type
, requires_tmpl_type
;
2867 inner_args
= innermost_args (args
);
2869 if (TREE_CODE (arg
) == TREE_LIST
2870 && TREE_TYPE (arg
) != NULL_TREE
2871 && TREE_CODE (TREE_TYPE (arg
)) == OFFSET_TYPE
)
2873 /* The template argument was the name of some
2874 member function. That's usually
2875 illegal, but static members are OK. In any
2876 case, grab the underlying fields/functions
2877 and issue an error later if required. */
2878 arg
= TREE_VALUE (arg
);
2879 TREE_TYPE (arg
) = unknown_type_node
;
2882 requires_tmpl_type
= TREE_CODE (parm
) == TEMPLATE_DECL
;
2883 requires_type
= (TREE_CODE (parm
) == TYPE_DECL
2884 || requires_tmpl_type
);
2886 /* Check if it is a class template. If REQUIRES_TMPL_TYPE is true,
2887 we also accept implicitly created TYPE_DECL as a valid argument.
2888 This is necessary to handle the case where we pass a template name
2889 to a template template parameter in a scope where we've derived from
2890 in instantiation of that template, so the template name refers to that
2891 instantiation. We really ought to handle this better. */
2893 = ((TREE_CODE (arg
) == TEMPLATE_DECL
2894 && TREE_CODE (DECL_TEMPLATE_RESULT (arg
)) == TYPE_DECL
)
2895 || (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
2896 && !TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (arg
))
2897 || (TREE_CODE (arg
) == RECORD_TYPE
2898 && CLASSTYPE_TEMPLATE_INFO (arg
)
2899 && TREE_CODE (TYPE_NAME (arg
)) == TYPE_DECL
2900 && DECL_ARTIFICIAL (TYPE_NAME (arg
))
2901 && requires_tmpl_type
2902 && is_base_of_enclosing_class (arg
, current_class_type
)));
2903 if (is_tmpl_type
&& TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
2904 arg
= TYPE_STUB_DECL (arg
);
2905 else if (is_tmpl_type
&& TREE_CODE (arg
) == RECORD_TYPE
)
2906 arg
= CLASSTYPE_TI_TEMPLATE (arg
);
2908 is_type
= TREE_CODE_CLASS (TREE_CODE (arg
)) == 't' || is_tmpl_type
;
2910 if (requires_type
&& ! is_type
&& TREE_CODE (arg
) == SCOPE_REF
2911 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_TYPE_PARM
)
2913 cp_pedwarn ("to refer to a type member of a template parameter,");
2914 cp_pedwarn (" use `typename %E'", arg
);
2916 arg
= make_typename_type (TREE_OPERAND (arg
, 0),
2917 TREE_OPERAND (arg
, 1));
2920 if (is_type
!= requires_type
)
2926 cp_error ("type/value mismatch at argument %d in template parameter list for `%D'",
2929 cp_error (" expected a constant of type `%T', got `%T'",
2931 (is_tmpl_type
? DECL_NAME (arg
) : arg
));
2933 cp_error (" expected a type, got `%E'", arg
);
2936 return error_mark_node
;
2938 if (is_tmpl_type
^ requires_tmpl_type
)
2940 if (in_decl
&& complain
)
2942 cp_error ("type/value mismatch at argument %d in template parameter list for `%D'",
2945 cp_error (" expected a type, got `%T'", DECL_NAME (arg
));
2947 cp_error (" expected a class template, got `%T'", arg
);
2949 return error_mark_node
;
2954 if (requires_tmpl_type
)
2956 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
2957 tree argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
2959 if (coerce_template_template_parms (parmparm
, argparm
,
2960 in_decl
, inner_args
))
2964 /* TEMPLATE_TEMPLATE_PARM node is preferred over
2966 if (val
!= error_mark_node
2967 && DECL_TEMPLATE_TEMPLATE_PARM_P (val
))
2968 val
= TREE_TYPE (val
);
2972 if (in_decl
&& complain
)
2974 cp_error ("type/value mismatch at argument %d in template parameter list for `%D'",
2976 cp_error (" expected a template of type `%D', got `%D'", parm
, arg
);
2979 val
= error_mark_node
;
2984 val
= groktypename (arg
);
2985 if (! processing_template_decl
)
2987 /* [basic.link]: A name with no linkage (notably, the
2988 name of a class or enumeration declared in a local
2989 scope) shall not be used to declare an entity with
2990 linkage. This implies that names with no linkage
2991 cannot be used as template arguments. */
2992 tree t
= no_linkage_check (val
);
2995 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
2997 ("template-argument `%T' uses anonymous type", val
);
3000 ("template-argument `%T' uses local type `%T'",
3002 return error_mark_node
;
3009 tree t
= tsubst (TREE_TYPE (parm
), args
, in_decl
);
3011 if (processing_template_decl
)
3012 arg
= maybe_fold_nontype_arg (arg
);
3014 if (!uses_template_parms (arg
) && !uses_template_parms (t
))
3015 /* We used to call digest_init here. However, digest_init
3016 will report errors, which we don't want when complain
3017 is zero. More importantly, digest_init will try too
3018 hard to convert things: for example, `0' should not be
3019 converted to pointer type at this point according to
3020 the standard. Accepting this is not merely an
3021 extension, since deciding whether or not these
3022 conversions can occur is part of determining which
3023 function template to call, or whether a given epxlicit
3024 argument specification is legal. */
3025 val
= convert_nontype_argument (t
, arg
);
3029 if (val
== NULL_TREE
)
3030 val
= error_mark_node
;
3031 else if (val
== error_mark_node
&& complain
)
3032 cp_error ("could not convert template argument `%E' to `%T'",
3039 /* Convert all template arguments to their appropriate types, and
3040 return a vector containing the innermost resulting template
3041 arguments. If any error occurs, return error_mark_node, and, if
3042 COMPLAIN is non-zero, issue an error message. Some error messages
3043 are issued even if COMPLAIN is zero; for instance, if a template
3044 argument is composed from a local class.
3046 If REQUIRE_ALL_ARGUMENTS is non-zero, all arguments must be
3047 provided in ARGLIST, or else trailing parameters must have default
3048 values. If REQUIRE_ALL_ARGUMENTS is zero, we will attempt argument
3049 deduction for any unspecified trailing arguments.
3051 The resulting TREE_VEC is allocated on a temporary obstack, and
3052 must be explicitly copied if it will be permanent. */
3055 coerce_template_parms (parms
, args
, in_decl
,
3057 require_all_arguments
)
3061 int require_all_arguments
;
3063 int nparms
, nargs
, i
, lost
= 0;
3066 tree new_inner_args
;
3068 inner_args
= innermost_args (args
);
3069 nargs
= NUM_TMPL_ARGS (inner_args
);
3070 nparms
= TREE_VEC_LENGTH (parms
);
3074 && require_all_arguments
3075 && TREE_PURPOSE (TREE_VEC_ELT (parms
, nargs
)) == NULL_TREE
))
3079 cp_error ("wrong number of template arguments (%d, should be %d)",
3083 cp_error_at ("provided for `%D'", in_decl
);
3086 return error_mark_node
;
3089 new_inner_args
= make_temp_vec (nparms
);
3090 new_args
= add_outermost_template_args (args
, new_inner_args
);
3091 for (i
= 0; i
< nparms
; i
++)
3096 /* Get the Ith template parameter. */
3097 parm
= TREE_VEC_ELT (parms
, i
);
3099 /* Calculate the Ith argument. */
3100 if (inner_args
&& TREE_CODE (inner_args
) == TREE_LIST
)
3102 arg
= TREE_VALUE (inner_args
);
3103 inner_args
= TREE_CHAIN (inner_args
);
3106 arg
= TREE_VEC_ELT (inner_args
, i
);
3107 /* If no template argument was supplied, look for a default
3109 else if (TREE_PURPOSE (parm
) == NULL_TREE
)
3111 /* There was no default value. */
3112 my_friendly_assert (!require_all_arguments
, 0);
3115 else if (TREE_CODE (TREE_VALUE (parm
)) == TYPE_DECL
)
3116 arg
= tsubst (TREE_PURPOSE (parm
), new_args
, in_decl
);
3118 arg
= tsubst_expr (TREE_PURPOSE (parm
), new_args
, in_decl
);
3120 /* Now, convert the Ith argument, as necessary. */
3121 if (arg
== NULL_TREE
)
3122 /* We're out of arguments. */
3124 my_friendly_assert (!require_all_arguments
, 0);
3127 else if (arg
== error_mark_node
)
3129 cp_error ("template argument %d is invalid", i
+ 1);
3130 arg
= error_mark_node
;
3133 arg
= convert_template_argument (TREE_VALUE (parm
),
3134 arg
, new_args
, complain
, i
,
3137 if (arg
== error_mark_node
)
3139 TREE_VEC_ELT (new_inner_args
, i
) = arg
;
3143 return error_mark_node
;
3145 return new_inner_args
;
3148 /* Returns 1 if template args OT and NT are equivalent. */
3151 template_args_equal (ot
, nt
)
3156 if (TREE_CODE (nt
) != TREE_CODE (ot
))
3158 if (TREE_CODE (nt
) == TREE_VEC
)
3159 /* For member templates */
3160 return comp_template_args (ot
, nt
);
3161 else if (TREE_CODE_CLASS (TREE_CODE (ot
)) == 't')
3162 return same_type_p (ot
, nt
);
3164 return (cp_tree_equal (ot
, nt
) > 0);
3167 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
3168 of template arguments. Returns 0 otherwise. */
3171 comp_template_args (oldargs
, newargs
)
3172 tree oldargs
, newargs
;
3176 if (TREE_VEC_LENGTH (oldargs
) != TREE_VEC_LENGTH (newargs
))
3179 for (i
= 0; i
< TREE_VEC_LENGTH (oldargs
); ++i
)
3181 tree nt
= TREE_VEC_ELT (newargs
, i
);
3182 tree ot
= TREE_VEC_ELT (oldargs
, i
);
3184 if (! template_args_equal (ot
, nt
))
3190 /* Given class template name and parameter list, produce a user-friendly name
3191 for the instantiation. */
3194 mangle_class_name_for_template (name
, parms
, arglist
)
3196 tree parms
, arglist
;
3198 static struct obstack scratch_obstack
;
3199 static char *scratch_firstobj
;
3202 if (!scratch_firstobj
)
3203 gcc_obstack_init (&scratch_obstack
);
3205 obstack_free (&scratch_obstack
, scratch_firstobj
);
3206 scratch_firstobj
= obstack_alloc (&scratch_obstack
, 1);
3208 #define ccat(c) obstack_1grow (&scratch_obstack, (c));
3209 #define cat(s) obstack_grow (&scratch_obstack, (s), strlen (s))
3213 nparms
= TREE_VEC_LENGTH (parms
);
3214 arglist
= innermost_args (arglist
);
3215 my_friendly_assert (nparms
== TREE_VEC_LENGTH (arglist
), 268);
3216 for (i
= 0; i
< nparms
; i
++)
3218 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
3219 tree arg
= TREE_VEC_ELT (arglist
, i
);
3224 if (TREE_CODE (parm
) == TYPE_DECL
)
3226 cat (type_as_string_real (arg
, 0, 1));
3229 else if (TREE_CODE (parm
) == TEMPLATE_DECL
)
3231 if (TREE_CODE (arg
) == TEMPLATE_DECL
)
3233 /* Already substituted with real template. Just output
3234 the template name here */
3235 tree context
= DECL_CONTEXT (arg
);
3238 my_friendly_assert (TREE_CODE (context
) == NAMESPACE_DECL
, 980422);
3239 cat(decl_as_string (DECL_CONTEXT (arg
), 0));
3242 cat (IDENTIFIER_POINTER (DECL_NAME (arg
)));
3245 /* Output the parameter declaration */
3246 cat (type_as_string_real (arg
, 0, 1));
3250 my_friendly_assert (TREE_CODE (parm
) == PARM_DECL
, 269);
3252 if (TREE_CODE (arg
) == TREE_LIST
)
3254 /* New list cell was built because old chain link was in
3256 my_friendly_assert (TREE_PURPOSE (arg
) == NULL_TREE
, 270);
3257 arg
= TREE_VALUE (arg
);
3259 /* No need to check arglist against parmlist here; we did that
3260 in coerce_template_parms, called from lookup_template_class. */
3261 cat (expr_as_string (arg
, 0));
3264 char *bufp
= obstack_next_free (&scratch_obstack
);
3266 while (bufp
[offset
- 1] == ' ')
3268 obstack_blank_fast (&scratch_obstack
, offset
);
3270 /* B<C<char> >, not B<C<char>> */
3271 if (bufp
[offset
- 1] == '>')
3276 return (char *) obstack_base (&scratch_obstack
);
3280 classtype_mangled_name (t
)
3283 if (CLASSTYPE_TEMPLATE_INFO (t
)
3284 /* Specializations have already had their names set up in
3285 lookup_template_class. */
3286 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
3288 tree tmpl
= most_general_template (CLASSTYPE_TI_TEMPLATE (t
));
3290 /* For non-primary templates, the template parameters are
3291 implicit from their surrounding context. */
3292 if (PRIMARY_TEMPLATE_P (tmpl
))
3294 tree name
= DECL_NAME (tmpl
);
3295 char *mangled_name
= mangle_class_name_for_template
3296 (IDENTIFIER_POINTER (name
),
3297 DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
3298 CLASSTYPE_TI_ARGS (t
));
3299 tree id
= get_identifier (mangled_name
);
3300 IDENTIFIER_TEMPLATE (id
) = name
;
3305 return TYPE_IDENTIFIER (t
);
3309 add_pending_template (d
)
3314 if (TREE_CODE_CLASS (TREE_CODE (d
)) == 't')
3315 ti
= CLASSTYPE_TEMPLATE_INFO (d
);
3317 ti
= DECL_TEMPLATE_INFO (d
);
3319 if (TI_PENDING_TEMPLATE_FLAG (ti
))
3322 *template_tail
= perm_tree_cons
3323 (build_srcloc_here (), d
, NULL_TREE
);
3324 template_tail
= &TREE_CHAIN (*template_tail
);
3325 TI_PENDING_TEMPLATE_FLAG (ti
) = 1;
3329 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS (which
3330 may be either a _DECL or an overloaded function or an
3331 IDENTIFIER_NODE), and ARGLIST. */
3334 lookup_template_function (fns
, arglist
)
3339 if (fns
== NULL_TREE
)
3341 cp_error ("non-template used as template");
3342 return error_mark_node
;
3345 type
= TREE_TYPE (fns
);
3346 if (TREE_CODE (fns
) == OVERLOAD
|| !type
)
3347 type
= unknown_type_node
;
3349 if (processing_template_decl
)
3350 return build_min (TEMPLATE_ID_EXPR
, type
, fns
, arglist
);
3352 return build (TEMPLATE_ID_EXPR
, type
, fns
, arglist
);
3355 /* Within the scope of a template class S<T>, the name S gets bound
3356 (in build_self_reference) to a TYPE_DECL for the class, not a
3357 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
3358 or one of its enclosing classes, and that type is a template,
3359 return the associated TEMPLATE_DECL. Otherwise, the original
3360 DECL is returned. */
3363 maybe_get_template_decl_from_type_decl (decl
)
3366 return (decl
!= NULL_TREE
3367 && TREE_CODE (decl
) == TYPE_DECL
3368 && DECL_ARTIFICIAL (decl
)
3369 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl
)))
3370 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl
)) : decl
;
3373 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
3374 parameters, find the desired type.
3376 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
3377 (Actually ARGLIST may be either a TREE_LIST or a TREE_VEC. It will
3378 be a TREE_LIST if called directly from the parser, and a TREE_VEC
3379 otherwise.) Since ARGLIST is build on the decl_obstack, we must
3380 copy it here to keep it from being reclaimed when the decl storage
3383 IN_DECL, if non-NULL, is the template declaration we are trying to
3386 If ENTERING_SCOPE is non-zero, we are about to enter the scope of
3387 the class we are looking up.
3389 If the template class is really a local class in a template
3390 function, then the FUNCTION_CONTEXT is the function in which it is
3391 being instantiated. */
3394 lookup_template_class (d1
, arglist
, in_decl
, context
, entering_scope
)
3400 tree
template = NULL_TREE
, parmlist
;
3403 if (TREE_CODE (d1
) == IDENTIFIER_NODE
)
3405 if (IDENTIFIER_VALUE (d1
)
3406 && DECL_TEMPLATE_TEMPLATE_PARM_P (IDENTIFIER_VALUE (d1
)))
3407 template = IDENTIFIER_VALUE (d1
);
3411 push_decl_namespace (context
);
3412 if (current_class_type
!= NULL_TREE
)
3414 maybe_get_template_decl_from_type_decl
3415 (IDENTIFIER_CLASS_VALUE (d1
));
3416 if (template == NULL_TREE
)
3417 template = lookup_name_nonclass (d1
);
3419 pop_decl_namespace ();
3422 context
= DECL_CONTEXT (template);
3424 else if (TREE_CODE (d1
) == TYPE_DECL
&& IS_AGGR_TYPE (TREE_TYPE (d1
)))
3426 if (CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (d1
)))
3428 template = CLASSTYPE_TI_TEMPLATE (TREE_TYPE (d1
));
3429 d1
= DECL_NAME (template);
3432 else if (TREE_CODE (d1
) == ENUMERAL_TYPE
3433 || (TREE_CODE_CLASS (TREE_CODE (d1
)) == 't'
3434 && IS_AGGR_TYPE (d1
)))
3436 template = TYPE_TI_TEMPLATE (d1
);
3437 d1
= DECL_NAME (template);
3439 else if (TREE_CODE (d1
) == TEMPLATE_DECL
3440 && TREE_CODE (DECL_RESULT (d1
)) == TYPE_DECL
)
3443 d1
= DECL_NAME (template);
3444 context
= DECL_CONTEXT (template);
3447 my_friendly_abort (272);
3449 /* With something like `template <class T> class X class X { ... };'
3450 we could end up with D1 having nothing but an IDENTIFIER_VALUE.
3451 We don't want to do that, but we have to deal with the situation,
3452 so let's give them some syntax errors to chew on instead of a
3456 cp_error ("`%T' is not a template", d1
);
3457 return error_mark_node
;
3460 if (context
== NULL_TREE
)
3461 context
= global_namespace
;
3463 if (TREE_CODE (template) != TEMPLATE_DECL
)
3465 cp_error ("non-template type `%T' used as a template", d1
);
3467 cp_error_at ("for template declaration `%D'", in_decl
);
3468 return error_mark_node
;
3471 if (DECL_TEMPLATE_TEMPLATE_PARM_P (template))
3473 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
3474 template arguments */
3476 tree parm
= copy_template_template_parm (TREE_TYPE (template));
3477 tree template2
= TYPE_STUB_DECL (parm
);
3480 parmlist
= DECL_INNERMOST_TEMPLATE_PARMS (template);
3482 arglist2
= coerce_template_parms (parmlist
, arglist
, template, 1, 1);
3483 if (arglist2
== error_mark_node
)
3484 return error_mark_node
;
3486 arglist2
= copy_to_permanent (arglist2
);
3487 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm
)
3488 = perm_tree_cons (template2
, arglist2
, NULL_TREE
);
3489 TYPE_SIZE (parm
) = 0;
3494 tree template_type
= TREE_TYPE (template);
3496 tree found
= NULL_TREE
;
3499 int is_partial_instantiation
;
3501 template = most_general_template (template);
3502 parmlist
= DECL_TEMPLATE_PARMS (template);
3503 parm_depth
= TMPL_PARMS_DEPTH (parmlist
);
3504 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
3506 /* We build up the coerced arguments and such on the
3507 momentary_obstack. */
3510 if (arg_depth
== 1 && parm_depth
> 1)
3512 /* We've been given an incomplete set of template arguments.
3515 template <class T> struct S1 {
3516 template <class U> struct S2 {};
3517 template <class U> struct S2<U*> {};
3520 we will be called with an ARGLIST of `U*', but the
3521 TEMPLATE will be `template <class T> template
3522 <class U> struct S1<T>::S2'. We must fill in the missing
3524 my_friendly_assert (context
!= NULL_TREE
, 0);
3525 while (!IS_AGGR_TYPE_CODE (TREE_CODE (context
))
3526 && context
!= global_namespace
)
3527 context
= DECL_REAL_CONTEXT (context
);
3529 if (context
== global_namespace
)
3530 /* This is bad. We cannot get enough arguments, even from
3531 the surrounding context, to resolve this class. One
3532 case where this might happen is (illegal) code like:
3540 We should catch this error sooner (at the opening curly
3541 for `S', but it is better to be safe than sorry here. */
3543 cp_error ("invalid use of `%D'", template);
3544 return error_mark_node
;
3547 arglist
= add_to_template_args (TYPE_TI_ARGS (context
),
3549 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
3552 my_friendly_assert (parm_depth
== arg_depth
, 0);
3554 /* Calculate the BOUND_ARGS. These will be the args that are
3555 actually tsubst'd into the definition to create the
3559 /* We have multiple levels of arguments to coerce, at once. */
3561 int saved_depth
= TMPL_ARGS_DEPTH (arglist
);
3563 tree bound_args
= make_temp_vec (parm_depth
);
3565 for (i
= saved_depth
,
3566 t
= DECL_TEMPLATE_PARMS (template);
3567 i
> 0 && t
!= NULL_TREE
;
3568 --i
, t
= TREE_CHAIN (t
))
3570 tree a
= coerce_template_parms (TREE_VALUE (t
),
3571 arglist
, template, 1, 1);
3572 SET_TMPL_ARGS_LEVEL (bound_args
, i
, a
);
3574 /* We temporarily reduce the length of the ARGLIST so
3575 that coerce_template_parms will see only the arguments
3576 corresponding to the template parameters it is
3578 TREE_VEC_LENGTH (arglist
)--;
3581 /* Restore the ARGLIST to its full size. */
3582 TREE_VEC_LENGTH (arglist
) = saved_depth
;
3584 arglist
= bound_args
;
3588 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist
),
3589 innermost_args (arglist
),
3592 if (arglist
== error_mark_node
)
3593 /* We were unable to bind the arguments. */
3594 return error_mark_node
;
3596 /* In the scope of a template class, explicit references to the
3597 template class refer to the type of the template, not any
3598 instantiation of it. For example, in:
3600 template <class T> class C { void f(C<T>); }
3602 the `C<T>' is just the same as `C'. Outside of the
3603 class, however, such a reference is an instantiation. */
3604 if (comp_template_args (TYPE_TI_ARGS (template_type
),
3607 found
= template_type
;
3609 if (!entering_scope
&& PRIMARY_TEMPLATE_P (template))
3613 /* Note that we use DECL_CONTEXT, rather than
3614 CP_DECL_CONTEXT, so that the termination test is
3615 always just `ctx'. We're not interested in namepace
3617 for (ctx
= current_class_type
;
3619 ctx
= (TREE_CODE_CLASS (TREE_CODE (ctx
)) == 't')
3620 ? TYPE_CONTEXT (ctx
) : DECL_CONTEXT (ctx
))
3621 if (same_type_p (ctx
, template_type
))
3625 /* We're not in the scope of the class, so the
3626 TEMPLATE_TYPE is not the type we want after
3634 for (found
= DECL_TEMPLATE_INSTANTIATIONS (template);
3635 found
; found
= TREE_CHAIN (found
))
3636 if (comp_template_args (TREE_PURPOSE (found
), arglist
))
3640 found
= TREE_VALUE (found
);
3649 /* Since we didn't find the type, we'll have to create it.
3650 Since we'll be saving this type on the
3651 DECL_TEMPLATE_INSTANTIATIONS list, it must be permanent. */
3652 push_obstacks (&permanent_obstack
, &permanent_obstack
);
3654 /* This type is a "partial instantiation" if any of the template
3655 arguments still inolve template parameters. Note that we set
3656 IS_PARTIAL_INSTANTIATION for partial specializations as
3658 is_partial_instantiation
= uses_template_parms (arglist
);
3660 /* Create the type. */
3661 if (TREE_CODE (template_type
) == ENUMERAL_TYPE
)
3663 if (!is_partial_instantiation
)
3664 t
= start_enum (TYPE_IDENTIFIER (template_type
));
3666 /* We don't want to call start_enum for this type, since
3667 the values for the enumeration constants may involve
3668 template parameters. And, no one should be interested
3669 in the enumeration constants for such a type. */
3670 t
= make_node (ENUMERAL_TYPE
);
3674 t
= make_lang_type (TREE_CODE (template_type
));
3675 CLASSTYPE_DECLARED_CLASS (t
)
3676 = CLASSTYPE_DECLARED_CLASS (template_type
);
3677 CLASSTYPE_GOT_SEMICOLON (t
) = 1;
3678 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t
);
3679 TYPE_FOR_JAVA (t
) = TYPE_FOR_JAVA (template_type
);
3682 /* If we called start_enum above, this information will already
3686 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
3688 /* Create a stub TYPE_DECL for it. */
3689 type_decl
= build_decl (TYPE_DECL
, DECL_NAME (template), t
);
3690 SET_DECL_ARTIFICIAL (type_decl
);
3691 DECL_CONTEXT (type_decl
) = TYPE_CONTEXT (t
);
3692 DECL_SOURCE_FILE (type_decl
)
3693 = DECL_SOURCE_FILE (TYPE_STUB_DECL (template_type
));
3694 DECL_SOURCE_LINE (type_decl
)
3695 = DECL_SOURCE_LINE (TYPE_STUB_DECL (template_type
));
3696 TYPE_STUB_DECL (t
) = TYPE_NAME (t
) = type_decl
;
3699 type_decl
= TYPE_NAME (t
);
3701 /* Set up the template information. We have to figure out which
3702 template is the immediate parent if this is a full
3704 if (parm_depth
== 1 || is_partial_instantiation
3705 || !PRIMARY_TEMPLATE_P (template))
3706 /* This case is easy; there are no member templates involved. */
3710 /* This is a full instantiation of a member template. There
3711 should be some partial instantiation of which this is an
3714 for (found
= DECL_TEMPLATE_INSTANTIATIONS (template);
3715 found
; found
= TREE_CHAIN (found
))
3718 tree tmpl
= CLASSTYPE_TI_TEMPLATE (TREE_VALUE (found
));
3720 /* We only want partial instantiations, here, not
3721 specializations or full instantiations. */
3722 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_VALUE (found
))
3723 || !uses_template_parms (TREE_VALUE (found
)))
3726 /* Temporarily reduce by one the number of levels in the
3727 ARGLIST and in FOUND so as to avoid comparing the
3728 last set of arguments. */
3729 TREE_VEC_LENGTH (arglist
)--;
3730 TREE_VEC_LENGTH (TREE_PURPOSE (found
)) --;
3732 /* See if the arguments match. If they do, then TMPL is
3733 the partial instantiation we want. */
3734 success
= comp_template_args (TREE_PURPOSE (found
), arglist
);
3736 /* Restore the argument vectors to their full size. */
3737 TREE_VEC_LENGTH (arglist
)++;
3738 TREE_VEC_LENGTH (TREE_PURPOSE (found
))++;
3748 my_friendly_abort (0);
3751 arglist
= copy_to_permanent (arglist
);
3752 SET_TYPE_TEMPLATE_INFO (t
,
3753 tree_cons (found
, arglist
, NULL_TREE
));
3754 DECL_TEMPLATE_INSTANTIATIONS (template)
3755 = tree_cons (arglist
, t
,
3756 DECL_TEMPLATE_INSTANTIATIONS (template));
3758 if (TREE_CODE (t
) == ENUMERAL_TYPE
3759 && !is_partial_instantiation
)
3760 /* Now that the type has been registered on the instantiations
3761 list, we set up the enumerators. Because the enumeration
3762 constants may involve the enumeration type itself, we make
3763 sure to register the type first, and then create the
3764 constants. That way, doing tsubst_expr for the enumeration
3765 constants won't result in recursive calls here; we'll find
3766 the instantiation and exit above. */
3767 tsubst_enum (template_type
, t
, arglist
);
3769 /* We're done with the permanent obstack, now. */
3771 /* We're also done with the momentary allocation we started
3775 /* Reset the name of the type, now that CLASSTYPE_TEMPLATE_INFO
3777 if (TREE_CODE (t
) != ENUMERAL_TYPE
)
3778 DECL_NAME (type_decl
) = classtype_mangled_name (t
);
3779 DECL_ASSEMBLER_NAME (type_decl
) = DECL_NAME (type_decl
);
3780 if (!is_partial_instantiation
)
3782 DECL_ASSEMBLER_NAME (type_decl
)
3783 = get_identifier (build_overload_name (t
, 1, 1));
3785 /* For backwards compatibility; code that uses
3786 -fexternal-templates expects looking up a template to
3787 instantiate it. I think DDD still relies on this.
3788 (jason 8/20/1998) */
3789 if (TREE_CODE (t
) != ENUMERAL_TYPE
3790 && flag_external_templates
3791 && CLASSTYPE_INTERFACE_KNOWN (TREE_TYPE (template))
3792 && ! CLASSTYPE_INTERFACE_ONLY (TREE_TYPE (template)))
3793 add_pending_template (t
);
3796 /* If the type makes use of template parameters, the
3797 code that generates debugging information will crash. */
3798 DECL_IGNORED_P (TYPE_STUB_DECL (t
)) = 1;
3804 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM, or
3805 TEMPLATE_PARM_INDEX in T, call FN with the parameter and the DATA.
3806 If FN returns non-zero, the iteration is terminated, and
3807 for_each_template_parm returns 1. Otherwise, the iteration
3808 continues. If FN never returns a non-zero value, the value
3809 returned by for_each_template_parm is 0. If FN is NULL, it is
3810 considered to be the function which always returns 1. */
3813 for_each_template_parm (t
, fn
, data
)
3821 if (TREE_CODE_CLASS (TREE_CODE (t
)) == 't'
3822 && for_each_template_parm (TYPE_CONTEXT (t
), fn
, data
))
3825 switch (TREE_CODE (t
))
3829 /* We assume that the object must be instantiated in order to build
3830 the COMPONENT_REF, so we test only whether the type of the
3831 COMPONENT_REF uses template parms. */
3832 return for_each_template_parm (TREE_TYPE (t
), fn
, data
);
3834 case IDENTIFIER_NODE
:
3835 if (!IDENTIFIER_TEMPLATE (t
))
3837 my_friendly_abort (42);
3839 /* aggregates of tree nodes */
3842 int i
= TREE_VEC_LENGTH (t
);
3844 if (for_each_template_parm (TREE_VEC_ELT (t
, i
), fn
, data
))
3849 if (for_each_template_parm (TREE_PURPOSE (t
), fn
, data
)
3850 || for_each_template_parm (TREE_VALUE (t
), fn
, data
))
3852 return for_each_template_parm (TREE_CHAIN (t
), fn
, data
);
3855 if (for_each_template_parm (OVL_FUNCTION (t
), fn
, data
))
3857 return for_each_template_parm (OVL_CHAIN (t
), fn
, data
);
3859 /* constructed type nodes */
3861 case REFERENCE_TYPE
:
3862 return for_each_template_parm (TREE_TYPE (t
), fn
, data
);
3865 if (TYPE_PTRMEMFUNC_FLAG (t
))
3866 return for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE (t
),
3872 if (! TYPE_TEMPLATE_INFO (t
))
3874 return for_each_template_parm (TREE_VALUE
3875 (TYPE_TEMPLATE_INFO (t
)),
3878 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t
), fn
, data
))
3883 /* Check the parameter types. Since default arguments are not
3884 instantiated until they are needed, the TYPE_ARG_TYPES may
3885 contain expressions that involve template parameters. But,
3886 no-one should be looking at them yet. And, once they're
3887 instantiated, they don't contain template parameters, so
3888 there's no point in looking at them then, either. */
3892 for (parm
= TYPE_ARG_TYPES (t
); parm
; parm
= TREE_CHAIN (parm
))
3893 if (for_each_template_parm (TREE_VALUE (parm
), fn
, data
))
3897 /* Check the return type, too. */
3898 return for_each_template_parm (TREE_TYPE (t
), fn
, data
);
3901 if (for_each_template_parm (TYPE_DOMAIN (t
), fn
, data
))
3903 return for_each_template_parm (TREE_TYPE (t
), fn
, data
);
3905 if (for_each_template_parm (TYPE_OFFSET_BASETYPE (t
), fn
, data
))
3907 return for_each_template_parm (TREE_TYPE (t
), fn
, data
);
3911 return for_each_template_parm (TREE_TYPE (t
), fn
, data
);
3914 /* A template template parameter is encountered */
3915 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
3916 return for_each_template_parm (TREE_TYPE (t
), fn
, data
);
3917 /* Already substituted template template parameter */
3921 if (for_each_template_parm (DECL_INITIAL (t
), fn
, data
))
3923 goto check_type_and_context
;
3927 /* ??? What about FIELD_DECLs? */
3928 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
)
3929 && for_each_template_parm (DECL_TI_ARGS (t
), fn
, data
))
3933 check_type_and_context
:
3934 if (for_each_template_parm (TREE_TYPE (t
), fn
, data
))
3936 if (DECL_CONTEXT (t
)
3937 && for_each_template_parm (DECL_CONTEXT (t
), fn
, data
))
3942 return for_each_template_parm (TREE_TYPE (t
), fn
, data
);
3944 return for_each_template_parm (TREE_OPERAND (t
, 0), fn
, data
);
3946 /* template parm nodes */
3947 case TEMPLATE_TEMPLATE_PARM
:
3948 /* Record template parameters such as `T' inside `TT<T>'. */
3949 if (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t
)
3950 && for_each_template_parm (TYPE_TI_ARGS (t
), fn
, data
))
3952 case TEMPLATE_TYPE_PARM
:
3953 case TEMPLATE_PARM_INDEX
:
3955 return (*fn
)(t
, data
);
3959 /* simple type nodes */
3961 if (for_each_template_parm (TYPE_MIN_VALUE (t
), fn
, data
))
3963 return for_each_template_parm (TYPE_MAX_VALUE (t
), fn
, data
);
3969 case NAMESPACE_DECL
:
3979 /* Non-error_mark_node ERROR_MARKs are bad things. */
3980 my_friendly_assert (t
== error_mark_node
, 274);
3989 return for_each_template_parm (TREE_TYPE (t
), fn
, data
);
3992 return for_each_template_parm (TREE_OPERAND (t
, 0), fn
, data
);
3995 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
)))
3996 return for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
3997 (TREE_TYPE (t
)), fn
, data
);
3998 return for_each_template_parm (TREE_OPERAND (t
, 1), fn
, data
);
4002 case REINTERPRET_CAST_EXPR
:
4003 case CONST_CAST_EXPR
:
4004 case STATIC_CAST_EXPR
:
4005 case DYNAMIC_CAST_EXPR
:
4013 return for_each_template_parm (TREE_OPERAND (t
, 0), fn
, data
);
4016 switch (TREE_CODE_CLASS (TREE_CODE (t
)))
4024 for (i
= first_rtl_op (TREE_CODE (t
)); --i
>= 0;)
4025 if (for_each_template_parm (TREE_OPERAND (t
, i
), fn
, data
))
4032 sorry ("testing %s for template parms",
4033 tree_code_name
[(int) TREE_CODE (t
)]);
4034 my_friendly_abort (82);
4041 uses_template_parms (t
)
4044 return for_each_template_parm (t
, 0, 0);
4047 static struct tinst_level
*current_tinst_level
;
4048 static struct tinst_level
*free_tinst_level
;
4049 static int tinst_depth
;
4050 extern int max_tinst_depth
;
4051 #ifdef GATHER_STATISTICS
4054 int tinst_level_tick
;
4055 int last_template_error_tick
;
4057 /* Print out all the template instantiations that we are currently
4058 working on. If ERR, we are being called from cp_thing, so do
4059 the right thing for an error message. */
4062 print_template_context (err
)
4065 struct tinst_level
*p
= current_tinst_level
;
4067 char *file
= input_filename
;
4071 if (current_function_decl
!= p
->decl
4072 && current_function_decl
!= NULL_TREE
)
4073 /* We can get here during the processing of some synthesized
4074 method. Then, p->decl will be the function that's causing
4079 if (current_function_decl
== p
->decl
)
4080 /* Avoid redundancy with the the "In function" line. */;
4082 fprintf (stderr
, "%s: In instantiation of `%s':\n",
4083 file
, decl_as_string (p
->decl
, 0));
4091 for (; p
; p
= p
->next
)
4093 fprintf (stderr
, "%s:%d: instantiated from `%s'\n", file
, line
,
4094 decl_as_string (p
->decl
, 0));
4098 fprintf (stderr
, "%s:%d: instantiated from here\n", file
, line
);
4101 /* Called from cp_thing to print the template context for an error. */
4104 maybe_print_template_context ()
4106 if (last_template_error_tick
== tinst_level_tick
4107 || current_tinst_level
== 0)
4110 last_template_error_tick
= tinst_level_tick
;
4111 print_template_context (1);
4115 push_tinst_level (d
)
4118 struct tinst_level
*new;
4120 if (tinst_depth
>= max_tinst_depth
)
4122 /* If the instantiation in question still has unbound template parms,
4123 we don't really care if we can't instantiate it, so just return.
4124 This happens with base instantiation for implicit `typename'. */
4125 if (uses_template_parms (d
))
4128 last_template_error_tick
= tinst_level_tick
;
4129 error ("template instantiation depth exceeds maximum of %d",
4131 error (" (use -ftemplate-depth-NN to increase the maximum)");
4132 cp_error (" instantiating `%D'", d
);
4134 print_template_context (0);
4139 if (free_tinst_level
)
4141 new = free_tinst_level
;
4142 free_tinst_level
= new->next
;
4145 new = (struct tinst_level
*) xmalloc (sizeof (struct tinst_level
));
4149 new->file
= input_filename
;
4150 new->next
= current_tinst_level
;
4151 current_tinst_level
= new;
4154 #ifdef GATHER_STATISTICS
4155 if (tinst_depth
> depth_reached
)
4156 depth_reached
= tinst_depth
;
4166 struct tinst_level
*old
= current_tinst_level
;
4168 /* Restore the filename and line number stashed away when we started
4169 this instantiation. */
4171 input_filename
= old
->file
;
4172 extract_interface_info ();
4174 current_tinst_level
= old
->next
;
4175 old
->next
= free_tinst_level
;
4176 free_tinst_level
= old
;
4181 struct tinst_level
*
4184 struct tinst_level
*p
= current_tinst_level
;
4187 for (; p
->next
; p
= p
->next
)
4192 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
4193 vector of template arguments, as for tsubst.
4195 Returns an appropriate tsbust'd friend declaration. */
4198 tsubst_friend_function (decl
, args
)
4204 char *file
= input_filename
;
4206 lineno
= DECL_SOURCE_LINE (decl
);
4207 input_filename
= DECL_SOURCE_FILE (decl
);
4209 if (TREE_CODE (decl
) == FUNCTION_DECL
4210 && DECL_TEMPLATE_INSTANTIATION (decl
)
4211 && TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
4212 /* This was a friend declared with an explicit template
4213 argument list, e.g.:
4217 to indicate that f was a template instantiation, not a new
4218 function declaration. Now, we have to figure out what
4219 instantiation of what template. */
4226 = lookup_template_function (tsubst_expr (DECL_TI_TEMPLATE (decl
),
4228 tsubst (DECL_TI_ARGS (decl
),
4230 /* FIXME: The decl we create via the next tsubst could be
4231 created on a temporary obstack. */
4232 new_friend
= tsubst (decl
, args
, NULL_TREE
);
4233 tmpl
= determine_specialization (template_id
, new_friend
,
4235 /*need_member_template=*/0,
4237 new_friend
= instantiate_template (tmpl
, new_args
);
4241 new_friend
= tsubst (decl
, args
, NULL_TREE
);
4243 /* The NEW_FRIEND will look like an instantiation, to the
4244 compiler, but is not an instantiation from the point of view of
4245 the language. For example, we might have had:
4247 template <class T> struct S {
4248 template <class U> friend void f(T, U);
4251 Then, in S<int>, template <class U> void f(int, U) is not an
4252 instantiation of anything. */
4253 DECL_USE_TEMPLATE (new_friend
) = 0;
4254 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
4255 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend
)) = 0;
4257 /* The mangled name for the NEW_FRIEND is incorrect. The call to
4258 tsubst will have resulted in a call to
4259 set_mangled_name_for_template_decl. But, the function is not a
4260 template instantiation and should not be mangled like one.
4261 Therefore, we remangle the function name. We don't have to do
4262 this if the NEW_FRIEND is a template since
4263 set_mangled_name_for_template_decl doesn't do anything if the
4264 function declaration still uses template arguments. */
4265 if (TREE_CODE (new_friend
) != TEMPLATE_DECL
)
4267 set_mangled_name_for_decl (new_friend
);
4268 DECL_RTL (new_friend
) = 0;
4269 make_decl_rtl (new_friend
, NULL_PTR
, 1);
4272 if (DECL_NAMESPACE_SCOPE_P (new_friend
))
4275 tree new_friend_template_info
;
4276 tree new_friend_result_template_info
;
4277 int new_friend_is_defn
;
4279 /* We must save some information from NEW_FRIEND before calling
4280 duplicate decls since that function will free NEW_FRIEND if
4282 new_friend_template_info
= DECL_TEMPLATE_INFO (new_friend
);
4283 if (TREE_CODE (new_friend
) == TEMPLATE_DECL
)
4285 /* This declaration is a `primary' template. */
4286 DECL_PRIMARY_TEMPLATE (new_friend
) = new_friend
;
4289 = DECL_INITIAL (DECL_RESULT (new_friend
)) != NULL_TREE
;
4290 new_friend_result_template_info
4291 = DECL_TEMPLATE_INFO (DECL_RESULT (new_friend
));
4295 new_friend_is_defn
= DECL_INITIAL (new_friend
) != NULL_TREE
;
4296 new_friend_result_template_info
= NULL_TREE
;
4299 old_decl
= pushdecl_namespace_level (new_friend
);
4301 if (old_decl
!= new_friend
)
4303 /* This new friend declaration matched an existing
4304 declaration. For example, given:
4306 template <class T> void f(T);
4307 template <class U> class C {
4308 template <class T> friend void f(T) {}
4311 the friend declaration actually provides the definition
4312 of `f', once C has been instantiated for some type. So,
4313 old_decl will be the out-of-class template declaration,
4314 while new_friend is the in-class definition.
4316 But, if `f' was called before this point, the
4317 instantiation of `f' will have DECL_TI_ARGS corresponding
4318 to `T' but not to `U', references to which might appear
4319 in the definition of `f'. Previously, the most general
4320 template for an instantiation of `f' was the out-of-class
4321 version; now it is the in-class version. Therefore, we
4322 run through all specialization of `f', adding to their
4323 DECL_TI_ARGS appropriately. In particular, they need a
4324 new set of outer arguments, corresponding to the
4325 arguments for this class instantiation.
4327 The same situation can arise with something like this:
4330 template <class T> class C {
4334 when `C<int>' is instantiated. Now, `f(int)' is defined
4337 if (!new_friend_is_defn
)
4338 /* On the other hand, if the in-class declaration does
4339 *not* provide a definition, then we don't want to alter
4340 existing definitions. We can just leave everything
4345 /* Overwrite whatever template info was there before, if
4346 any, with the new template information pertaining to
4348 DECL_TEMPLATE_INFO (old_decl
) = new_friend_template_info
;
4350 if (TREE_CODE (old_decl
) != TEMPLATE_DECL
)
4351 /* duplicate_decls will take care of this case. */
4356 tree new_friend_args
;
4358 DECL_TEMPLATE_INFO (DECL_RESULT (old_decl
))
4359 = new_friend_result_template_info
;
4361 new_friend_args
= TI_ARGS (new_friend_template_info
);
4362 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (old_decl
);
4366 tree spec
= TREE_VALUE (t
);
4369 = add_outermost_template_args (new_friend_args
,
4370 DECL_TI_ARGS (spec
));
4372 = copy_to_permanent (DECL_TI_ARGS (spec
));
4375 /* Now, since specializations are always supposed to
4376 hang off of the most general template, we must move
4378 t
= most_general_template (old_decl
);
4381 DECL_TEMPLATE_SPECIALIZATIONS (t
)
4382 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (t
),
4383 DECL_TEMPLATE_SPECIALIZATIONS (old_decl
));
4384 DECL_TEMPLATE_SPECIALIZATIONS (old_decl
) = NULL_TREE
;
4389 /* The information from NEW_FRIEND has been merged into OLD_DECL
4390 by duplicate_decls. */
4391 new_friend
= old_decl
;
4394 else if (TYPE_SIZE (DECL_CONTEXT (new_friend
)))
4396 /* Check to see that the declaration is really present, and,
4397 possibly obtain an improved declaration. */
4398 tree fn
= check_classfn (DECL_CONTEXT (new_friend
),
4407 input_filename
= file
;
4411 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
4412 template arguments, as for tsubst.
4414 Returns an appropriate tsbust'd friend type. */
4417 tsubst_friend_class (friend_tmpl
, args
)
4422 tree tmpl
= lookup_name (DECL_NAME (friend_tmpl
), 1);
4424 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
4426 if (tmpl
!= NULL_TREE
&& DECL_CLASS_TEMPLATE_P (tmpl
))
4428 /* The friend template has already been declared. Just
4429 check to see that the declarations match, and install any new
4430 default parameters. We must tsubst the default parameters,
4431 of course. We only need the innermost template parameters
4432 because that is all that redeclare_class_template will look
4435 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl
),
4437 redeclare_class_template (TREE_TYPE (tmpl
), parms
);
4438 friend_type
= TREE_TYPE (tmpl
);
4442 /* The friend template has not already been declared. In this
4443 case, the instantiation of the template class will cause the
4444 injection of this template into the global scope. */
4445 tmpl
= tsubst (friend_tmpl
, args
, NULL_TREE
);
4447 /* The new TMPL is not an instantiation of anything, so we
4448 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
4449 the new type because that is supposed to be the corresponding
4450 template decl, i.e., TMPL. */
4451 DECL_USE_TEMPLATE (tmpl
) = 0;
4452 DECL_TEMPLATE_INFO (tmpl
) = NULL_TREE
;
4453 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl
)) = 0;
4455 /* Inject this template into the global scope. */
4456 friend_type
= TREE_TYPE (pushdecl_top_level (tmpl
));
4463 instantiate_class_template (type
)
4466 tree
template, args
, pattern
, t
;
4468 int is_partial_instantiation
;
4470 if (type
== error_mark_node
)
4471 return error_mark_node
;
4473 if (TYPE_BEING_DEFINED (type
) || TYPE_SIZE (type
))
4476 /* We want to allocate temporary vectors of template arguments and
4477 template argument expressions on the momentary obstack, not on
4478 the expression obstack. Otherwise, all the space allocated in
4479 argument coercion and such is simply lost. */
4482 /* Figure out which template is being instantiated. */
4483 template = most_general_template (CLASSTYPE_TI_TEMPLATE (type
));
4484 my_friendly_assert (TREE_CODE (template) == TEMPLATE_DECL
, 279);
4486 /* Figure out which arguments are being used to do the
4488 args
= CLASSTYPE_TI_ARGS (type
);
4489 is_partial_instantiation
= uses_template_parms (args
);
4491 if (is_partial_instantiation
)
4492 /* There's no telling which specialization is appropriate at this
4493 point. Since all peeking at the innards of this partial
4494 instantiation are extensions (like the "implicit typename"
4495 extension, which allows users to omit the keyword `typename' on
4496 names that are declared as types in template base classes), we
4497 are free to do what we please.
4499 Trying to figure out which partial instantiation to use can
4500 cause a crash. (Some of the template arguments don't even have
4501 types.) So, we just use the most general version. */
4505 t
= most_specialized_class (template, args
);
4507 if (t
== error_mark_node
)
4509 char *str
= "candidates are:";
4510 cp_error ("ambiguous class template instantiation for `%#T'", type
);
4511 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (template); t
;
4514 if (get_class_bindings (TREE_VALUE (t
), TREE_PURPOSE (t
),
4517 cp_error_at ("%s %+#T", str
, TREE_TYPE (t
));
4521 TYPE_BEING_DEFINED (type
) = 1;
4522 type
= error_mark_node
;
4528 pattern
= TREE_TYPE (t
);
4530 pattern
= TREE_TYPE (template);
4532 if (TYPE_SIZE (pattern
) == NULL_TREE
)
4537 /* This TYPE is actually a instantiation of of a partial
4538 specialization. We replace the innermost set of ARGS with
4539 the arguments appropriate for substitution. For example,
4542 template <class T> struct S {};
4543 template <class T> struct S<T*> {};
4545 and supposing that we are instantiating S<int*>, ARGS will
4546 present be {int*} but we need {int}. */
4548 = get_class_bindings (TREE_VALUE (t
), TREE_PURPOSE (t
),
4551 /* If there were multiple levels in ARGS, replacing the
4552 innermost level would alter CLASSTYPE_TI_ARGS, which we don't
4553 want, so we make a copy first. */
4554 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
4556 args
= copy_node (args
);
4557 SET_TMPL_ARGS_LEVEL (args
, TMPL_ARGS_DEPTH (args
), inner_args
);
4563 if (pedantic
&& is_partial_instantiation
)
4565 /* If this is a partial instantiation, then we can't instantiate
4566 the type; there's no telling whether or not one of the
4567 template parameters might eventually be instantiated to some
4568 value that results in a specialization being used. We do
4569 mark the type as complete so that, for example, declaring one
4570 of its members to be a friend will not be rejected. */
4571 TYPE_SIZE (type
) = integer_zero_node
;
4575 TYPE_BEING_DEFINED (type
) = 1;
4577 if (! push_tinst_level (type
))
4580 maybe_push_to_top_level (uses_template_parms (type
));
4581 pushclass (type
, 0);
4583 /* We must copy the arguments to the permanent obstack since
4584 during the tsubst'ing below they may wind up in the
4585 DECL_TI_ARGS of some instantiated member template. */
4586 args
= copy_to_permanent (args
);
4588 if (flag_external_templates
)
4590 if (flag_alt_external_templates
)
4592 CLASSTYPE_INTERFACE_ONLY (type
) = interface_only
;
4593 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (type
, interface_unknown
);
4594 CLASSTYPE_VTABLE_NEEDS_WRITING (type
)
4595 = (! CLASSTYPE_INTERFACE_ONLY (type
)
4596 && CLASSTYPE_INTERFACE_KNOWN (type
));
4600 CLASSTYPE_INTERFACE_ONLY (type
) = CLASSTYPE_INTERFACE_ONLY (pattern
);
4601 SET_CLASSTYPE_INTERFACE_UNKNOWN_X
4602 (type
, CLASSTYPE_INTERFACE_UNKNOWN (pattern
));
4603 CLASSTYPE_VTABLE_NEEDS_WRITING (type
)
4604 = (! CLASSTYPE_INTERFACE_ONLY (type
)
4605 && CLASSTYPE_INTERFACE_KNOWN (type
));
4610 SET_CLASSTYPE_INTERFACE_UNKNOWN (type
);
4611 CLASSTYPE_VTABLE_NEEDS_WRITING (type
) = 1;
4614 TYPE_HAS_CONSTRUCTOR (type
) = TYPE_HAS_CONSTRUCTOR (pattern
);
4615 TYPE_HAS_DESTRUCTOR (type
) = TYPE_HAS_DESTRUCTOR (pattern
);
4616 TYPE_HAS_ASSIGNMENT (type
) = TYPE_HAS_ASSIGNMENT (pattern
);
4617 TYPE_OVERLOADS_CALL_EXPR (type
) = TYPE_OVERLOADS_CALL_EXPR (pattern
);
4618 TYPE_OVERLOADS_ARRAY_REF (type
) = TYPE_OVERLOADS_ARRAY_REF (pattern
);
4619 TYPE_OVERLOADS_ARROW (type
) = TYPE_OVERLOADS_ARROW (pattern
);
4620 TYPE_GETS_NEW (type
) = TYPE_GETS_NEW (pattern
);
4621 TYPE_GETS_DELETE (type
) = TYPE_GETS_DELETE (pattern
);
4622 TYPE_VEC_DELETE_TAKES_SIZE (type
) = TYPE_VEC_DELETE_TAKES_SIZE (pattern
);
4623 TYPE_HAS_ASSIGN_REF (type
) = TYPE_HAS_ASSIGN_REF (pattern
);
4624 TYPE_HAS_CONST_ASSIGN_REF (type
) = TYPE_HAS_CONST_ASSIGN_REF (pattern
);
4625 TYPE_HAS_ABSTRACT_ASSIGN_REF (type
) = TYPE_HAS_ABSTRACT_ASSIGN_REF (pattern
);
4626 TYPE_HAS_INIT_REF (type
) = TYPE_HAS_INIT_REF (pattern
);
4627 TYPE_HAS_CONST_INIT_REF (type
) = TYPE_HAS_CONST_INIT_REF (pattern
);
4628 TYPE_HAS_DEFAULT_CONSTRUCTOR (type
) = TYPE_HAS_DEFAULT_CONSTRUCTOR (pattern
);
4629 TYPE_HAS_CONVERSION (type
) = TYPE_HAS_CONVERSION (pattern
);
4630 TYPE_USES_COMPLEX_INHERITANCE (type
)
4631 = TYPE_USES_COMPLEX_INHERITANCE (pattern
);
4632 TYPE_USES_MULTIPLE_INHERITANCE (type
)
4633 = TYPE_USES_MULTIPLE_INHERITANCE (pattern
);
4634 TYPE_USES_VIRTUAL_BASECLASSES (type
)
4635 = TYPE_USES_VIRTUAL_BASECLASSES (pattern
);
4636 TYPE_PACKED (type
) = TYPE_PACKED (pattern
);
4637 TYPE_ALIGN (type
) = TYPE_ALIGN (pattern
);
4638 TYPE_FOR_JAVA (type
) = TYPE_FOR_JAVA (pattern
); /* For libjava's JArray<T> */
4640 /* If this is a partial instantiation, don't tsubst anything. We will
4641 only use this type for implicit typename, so the actual contents don't
4642 matter. All that matters is whether a particular name is a type. */
4643 if (is_partial_instantiation
)
4645 TYPE_BINFO_BASETYPES (type
) = TYPE_BINFO_BASETYPES (pattern
);
4646 TYPE_FIELDS (type
) = TYPE_FIELDS (pattern
);
4647 TYPE_METHODS (type
) = TYPE_METHODS (pattern
);
4648 CLASSTYPE_TAGS (type
) = CLASSTYPE_TAGS (pattern
);
4649 TYPE_SIZE (type
) = integer_zero_node
;
4650 goto done_with_instantiation
;
4654 tree binfo
= TYPE_BINFO (type
);
4655 tree pbases
= TYPE_BINFO_BASETYPES (pattern
);
4661 int len
= TREE_VEC_LENGTH (pbases
);
4662 bases
= make_tree_vec (len
);
4663 for (i
= 0; i
< len
; ++i
)
4667 TREE_VEC_ELT (bases
, i
) = elt
4668 = tsubst (TREE_VEC_ELT (pbases
, i
), args
, NULL_TREE
);
4669 BINFO_INHERITANCE_CHAIN (elt
) = binfo
;
4671 basetype
= TREE_TYPE (elt
);
4673 if (! IS_AGGR_TYPE (basetype
))
4675 ("base type `%T' of `%T' fails to be a struct or class type",
4677 else if (TYPE_SIZE (complete_type (basetype
)) == NULL_TREE
)
4678 cp_error ("base class `%T' of `%T' has incomplete type",
4681 /* These are set up in xref_basetypes for normal classes, so
4682 we have to handle them here for template bases. */
4684 unshare_base_binfos (elt
);
4686 if (TYPE_USES_VIRTUAL_BASECLASSES (basetype
))
4688 TYPE_USES_VIRTUAL_BASECLASSES (type
) = 1;
4689 TYPE_USES_COMPLEX_INHERITANCE (type
) = 1;
4691 TYPE_GETS_NEW (type
) |= TYPE_GETS_NEW (basetype
);
4692 TYPE_GETS_DELETE (type
) |= TYPE_GETS_DELETE (basetype
);
4694 /* Don't initialize this until the vector is filled out, or
4695 lookups will crash. */
4696 BINFO_BASETYPES (binfo
) = bases
;
4700 for (t
= CLASSTYPE_TAGS (pattern
); t
; t
= TREE_CHAIN (t
))
4702 tree tag
= TREE_VALUE (t
);
4703 tree name
= TYPE_IDENTIFIER (tag
);
4706 newtag
= tsubst (tag
, args
, NULL_TREE
);
4707 if (TREE_CODE (newtag
) != ENUMERAL_TYPE
)
4709 if (TYPE_LANG_SPECIFIC (tag
) && CLASSTYPE_IS_TEMPLATE (tag
))
4710 /* Unfortunately, lookup_template_class sets
4711 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
4712 instantiation (i.e., for the type of a member template
4713 class nested within a template class.) This behavior is
4714 required for maybe_process_partial_specialization to work
4715 correctly, but is not accurate in this case; the TAG is not
4716 an instantiation of anything. (The corresponding
4717 TEMPLATE_DECL is an instantiation, but the TYPE is not.) */
4718 CLASSTYPE_USE_TEMPLATE (newtag
) = 0;
4720 /* Now, we call pushtag to put this NEWTAG into the scope of
4721 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
4722 pushtag calling push_template_decl. We don't have to do
4723 this for enums because it will already have been done in
4726 SET_IDENTIFIER_TYPE_VALUE (name
, newtag
);
4727 pushtag (name
, newtag
, /*globalize=*/0);
4731 /* Don't replace enum constants here. */
4732 for (t
= TYPE_FIELDS (pattern
); t
; t
= TREE_CHAIN (t
))
4733 if (TREE_CODE (t
) != CONST_DECL
)
4737 /* The the file and line for this declaration, to assist in
4738 error message reporting. Since we called push_tinst_level
4739 above, we don't need to restore these. */
4740 lineno
= DECL_SOURCE_LINE (t
);
4741 input_filename
= DECL_SOURCE_FILE (t
);
4743 r
= tsubst (t
, args
, NULL_TREE
);
4744 if (TREE_CODE (r
) == VAR_DECL
)
4746 pending_statics
= perm_tree_cons (NULL_TREE
, r
, pending_statics
);
4747 /* Perhaps we should do more of grokfield here. */
4749 DECL_IN_AGGR_P (r
) = 1;
4750 DECL_EXTERNAL (r
) = 1;
4751 cp_finish_decl (r
, DECL_INITIAL (r
), NULL_TREE
, 0, 0);
4752 if (DECL_DEFINED_IN_CLASS_P (r
))
4753 check_static_variable_definition (r
, TREE_TYPE (r
));
4756 /* R will have a TREE_CHAIN if and only if it has already been
4757 processed by finish_member_declaration. This can happen
4758 if, for example, it is a TYPE_DECL for a class-scoped
4759 ENUMERAL_TYPE; such a thing will already have been added to
4760 the field list by tsubst_enum above. */
4761 if (!TREE_CHAIN (r
))
4763 set_current_access_from_decl (r
);
4764 finish_member_declaration (r
);
4768 /* Set up the list (TYPE_METHODS) and vector (CLASSTYPE_METHOD_VEC)
4769 for this instantiation. */
4770 for (t
= TYPE_METHODS (pattern
); t
; t
= TREE_CHAIN (t
))
4772 tree r
= tsubst (t
, args
, NULL_TREE
);
4773 set_current_access_from_decl (r
);
4774 finish_member_declaration (r
);
4777 /* Construct the DECL_FRIENDLIST for the new class type. */
4778 typedecl
= TYPE_MAIN_DECL (type
);
4779 for (t
= DECL_FRIENDLIST (TYPE_MAIN_DECL (pattern
));
4785 DECL_FRIENDLIST (typedecl
)
4786 = tree_cons (TREE_PURPOSE (t
), NULL_TREE
,
4787 DECL_FRIENDLIST (typedecl
));
4789 for (friends
= TREE_VALUE (t
);
4790 friends
!= NULL_TREE
;
4791 friends
= TREE_CHAIN (friends
))
4793 if (TREE_PURPOSE (friends
) == error_mark_node
)
4795 TREE_VALUE (DECL_FRIENDLIST (typedecl
))
4796 = tree_cons (error_mark_node
,
4797 tsubst_friend_function (TREE_VALUE (friends
),
4799 TREE_VALUE (DECL_FRIENDLIST (typedecl
)));
4803 TREE_VALUE (DECL_FRIENDLIST (typedecl
))
4804 = tree_cons (tsubst (TREE_PURPOSE (friends
), args
, NULL_TREE
),
4806 TREE_VALUE (DECL_FRIENDLIST (typedecl
)));
4812 for (t
= CLASSTYPE_FRIEND_CLASSES (pattern
);
4816 tree friend_type
= TREE_VALUE (t
);
4817 tree new_friend_type
;
4819 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
4820 new_friend_type
= tsubst_friend_class (friend_type
, args
);
4821 else if (uses_template_parms (friend_type
))
4822 new_friend_type
= tsubst (friend_type
, args
, NULL_TREE
);
4824 /* The call to xref_tag_from_type does injection for friend
4827 xref_tag_from_type (friend_type
, NULL_TREE
, 1);
4830 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
4831 /* Trick make_friend_class into realizing that the friend
4832 we're adding is a template, not an ordinary class. It's
4833 important that we use make_friend_class since it will
4834 perform some error-checking and output cross-reference
4836 ++processing_template_decl
;
4838 make_friend_class (type
, new_friend_type
);
4840 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
4841 --processing_template_decl
;
4844 /* This does injection for friend functions. */
4845 if (!processing_template_decl
)
4847 t
= tsubst (DECL_TEMPLATE_INJECT (template), args
, NULL_TREE
);
4849 for (; t
; t
= TREE_CHAIN (t
))
4851 tree d
= TREE_VALUE (t
);
4853 if (TREE_CODE (d
) == TYPE_DECL
)
4854 /* Already injected. */;
4860 for (t
= TYPE_FIELDS (type
); t
; t
= TREE_CHAIN (t
))
4861 if (TREE_CODE (t
) == FIELD_DECL
)
4863 TREE_TYPE (t
) = complete_type (TREE_TYPE (t
));
4864 require_complete_type (t
);
4867 /* Set the file and line number information to whatever is given for
4868 the class itself. This puts error messages involving generated
4869 implicit functions at a predictable point, and the same point
4870 that would be used for non-template classes. */
4871 lineno
= DECL_SOURCE_LINE (typedecl
);
4872 input_filename
= DECL_SOURCE_FILE (typedecl
);
4874 unreverse_member_declarations (type
);
4875 type
= finish_struct_1 (type
, 0);
4876 CLASSTYPE_GOT_SEMICOLON (type
) = 1;
4878 /* Clear this now so repo_template_used is happy. */
4879 TYPE_BEING_DEFINED (type
) = 0;
4880 repo_template_used (type
);
4882 done_with_instantiation
:
4883 TYPE_BEING_DEFINED (type
) = 0;
4886 pop_from_top_level ();
4899 if (t1
== NULL_TREE
)
4900 return t2
== NULL_TREE
;
4901 if (t2
== NULL_TREE
)
4903 /* Don't care if one declares its arg const and the other doesn't -- the
4904 main variant of the arg type is all that matters. */
4905 if (TYPE_MAIN_VARIANT (TREE_VALUE (t1
))
4906 != TYPE_MAIN_VARIANT (TREE_VALUE (t2
)))
4908 return list_eq (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
4911 /* If arg is a non-type template parameter that does not depend on template
4912 arguments, fold it like we weren't in the body of a template. */
4915 maybe_fold_nontype_arg (arg
)
4918 if (TREE_CODE_CLASS (TREE_CODE (arg
)) != 't'
4919 && !uses_template_parms (arg
))
4921 /* Sometimes, one of the args was an expression involving a
4922 template constant parameter, like N - 1. Now that we've
4923 tsubst'd, we might have something like 2 - 1. This will
4924 confuse lookup_template_class, so we do constant folding
4925 here. We have to unset processing_template_decl, to
4926 fool build_expr_from_tree() into building an actual
4929 int saved_processing_template_decl
= processing_template_decl
;
4930 processing_template_decl
= 0;
4931 arg
= fold (build_expr_from_tree (arg
));
4932 processing_template_decl
= saved_processing_template_decl
;
4937 /* Return the TREE_VEC with the arguments for the innermost template header,
4938 where ARGS is either that or the VEC of VECs for all the
4942 innermost_args (args
)
4945 return TMPL_ARGS_LEVEL (args
, TMPL_ARGS_DEPTH (args
));
4948 /* Substitute ARGS into the vector of template arguments T. */
4951 tsubst_template_arg_vector (t
, args
)
4955 int len
= TREE_VEC_LENGTH (t
), need_new
= 0, i
;
4956 tree
*elts
= (tree
*) alloca (len
* sizeof (tree
));
4958 bzero ((char *) elts
, len
* sizeof (tree
));
4960 for (i
= 0; i
< len
; i
++)
4962 if (TREE_VEC_ELT (t
, i
) != NULL_TREE
4963 && TREE_CODE (TREE_VEC_ELT (t
, i
)) == TREE_VEC
)
4964 elts
[i
] = tsubst_template_arg_vector (TREE_VEC_ELT (t
, i
), args
);
4966 elts
[i
] = maybe_fold_nontype_arg
4967 (tsubst_expr (TREE_VEC_ELT (t
, i
), args
, NULL_TREE
));
4969 if (elts
[i
] != TREE_VEC_ELT (t
, i
))
4976 t
= make_temp_vec (len
);
4977 for (i
= 0; i
< len
; i
++)
4978 TREE_VEC_ELT (t
, i
) = elts
[i
];
4983 /* Return the result of substituting ARGS into the template parameters
4984 given by PARMS. If there are m levels of ARGS and m + n levels of
4985 PARMS, then the result will contain n levels of PARMS. For
4986 example, if PARMS is `template <class T> template <class U>
4987 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
4988 result will be `template <int*, double, class V>'. */
4991 tsubst_template_parms (parms
, args
)
4996 tree
* new_parms
= &r
;
4998 for (new_parms
= &r
;
4999 TMPL_PARMS_DEPTH (parms
) > TMPL_ARGS_DEPTH (args
);
5000 new_parms
= &(TREE_CHAIN (*new_parms
)),
5001 parms
= TREE_CHAIN (parms
))
5004 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms
)));
5007 for (i
= 0; i
< TREE_VEC_LENGTH (new_vec
); ++i
)
5009 tree default_value
=
5010 TREE_PURPOSE (TREE_VEC_ELT (TREE_VALUE (parms
), i
));
5012 TREE_VALUE (TREE_VEC_ELT (TREE_VALUE (parms
), i
));
5014 TREE_VEC_ELT (new_vec
, i
)
5015 = build_tree_list (tsubst (default_value
, args
, NULL_TREE
),
5016 tsubst (parm_decl
, args
, NULL_TREE
));
5021 tree_cons (build_int_2 (0, (TMPL_PARMS_DEPTH (parms
)
5022 - TMPL_ARGS_DEPTH (args
))),
5023 new_vec
, NULL_TREE
);
5029 /* Substitute the ARGS into the indicated aggregate (or enumeration)
5030 type T. If T is not an aggregate or enumeration type, it is
5031 handled as if by tsubst. IN_DECL is as for tsubst. If
5032 ENTERING_SCOPE is non-zero, T is the context for a template which
5033 we are presently tsubst'ing. Return the subsituted value. */
5036 tsubst_aggr_type (t
, args
, in_decl
, entering_scope
)
5045 switch (TREE_CODE (t
))
5048 if (TYPE_PTRMEMFUNC_P (t
))
5050 tree r
= build_ptrmemfunc_type
5051 (tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t
), args
, in_decl
));
5052 return cp_build_qualified_type (r
, TYPE_QUALS (t
));
5055 /* else fall through */
5058 if (uses_template_parms (t
))
5064 /* First, determine the context for the type we are looking
5066 if (TYPE_CONTEXT (t
) != NULL_TREE
)
5067 context
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
,
5068 in_decl
, /*entering_scope=*/1);
5070 context
= NULL_TREE
;
5072 /* Then, figure out what arguments are appropriate for the
5073 type we are trying to find. For example, given:
5075 template <class T> struct S;
5076 template <class T, class U> void f(T, U) { S<U> su; }
5078 and supposing that we are instantiating f<int, double>,
5079 then our ARGS will be {int, double}, but, when looking up
5080 S we only want {double}. */
5082 argvec
= tsubst_template_arg_vector (TYPE_TI_ARGS (t
), args
);
5084 r
= lookup_template_class (t
, argvec
, in_decl
, context
,
5088 return cp_build_qualified_type (r
, TYPE_QUALS (t
));
5091 /* This is not a template type, so there's nothing to do. */
5095 return tsubst (t
, args
, in_decl
);
5099 /* Substitute the ARGS into the T, which is a _DECL. TYPE is the
5100 (already computed) substitution of ARGS into TREE_TYPE (T), if
5101 appropriate. Return the result of the substitution. IN_DECL is as
5105 tsubst_decl (t
, args
, type
, in_decl
)
5112 char* saved_filename
;
5115 /* Set the filename and linenumber to improve error-reporting. */
5116 saved_lineno
= lineno
;
5117 saved_filename
= input_filename
;
5118 lineno
= DECL_SOURCE_LINE (t
);
5119 input_filename
= DECL_SOURCE_FILE (t
);
5121 switch (TREE_CODE (t
))
5125 /* We can get here when processing a member template function
5126 of a template class. */
5127 tree decl
= DECL_TEMPLATE_RESULT (t
);
5129 int is_template_template_parm
= DECL_TEMPLATE_TEMPLATE_PARM_P (t
);
5131 if (!is_template_template_parm
)
5133 /* We might already have an instance of this template.
5134 The ARGS are for the surrounding class type, so the
5135 full args contain the tsubst'd args for the context,
5136 plus the innermost args from the template decl. */
5137 tree tmpl_args
= DECL_CLASS_TEMPLATE_P (t
)
5138 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t
))
5139 : DECL_TI_ARGS (DECL_RESULT (t
));
5143 full_args
= tsubst_template_arg_vector (tmpl_args
, args
);
5145 /* tsubst_template_arg_vector doesn't copy the vector if
5146 nothing changed. But, *something* should have
5148 my_friendly_assert (full_args
!= tmpl_args
, 0);
5150 spec
= retrieve_specialization (t
, full_args
);
5152 if (spec
!= NULL_TREE
)
5159 /* Make a new template decl. It will be similar to the
5160 original, but will record the current template arguments.
5161 We also create a new function declaration, which is just
5162 like the old one, but points to this new template, rather
5163 than the old one. */
5166 my_friendly_assert (DECL_LANG_SPECIFIC (r
) != 0, 0);
5167 TREE_CHAIN (r
) = NULL_TREE
;
5169 if (is_template_template_parm
)
5171 tree new_decl
= tsubst (decl
, args
, in_decl
);
5172 DECL_RESULT (r
) = new_decl
;
5173 TREE_TYPE (r
) = TREE_TYPE (new_decl
);
5178 = tsubst_aggr_type (DECL_CONTEXT (t
), args
, in_decl
,
5179 /*entering_scope=*/1);
5180 DECL_CLASS_CONTEXT (r
)
5181 = tsubst_aggr_type (DECL_CLASS_CONTEXT (t
), args
, in_decl
,
5182 /*entering_scope=*/1);
5183 DECL_TEMPLATE_INFO (r
) = build_tree_list (t
, args
);
5185 if (TREE_CODE (decl
) == TYPE_DECL
)
5187 tree new_type
= tsubst (TREE_TYPE (t
), args
, in_decl
);
5188 TREE_TYPE (r
) = new_type
;
5189 CLASSTYPE_TI_TEMPLATE (new_type
) = r
;
5190 DECL_RESULT (r
) = TYPE_MAIN_DECL (new_type
);
5191 DECL_TI_ARGS (r
) = CLASSTYPE_TI_ARGS (new_type
);
5195 tree new_decl
= tsubst (decl
, args
, in_decl
);
5196 DECL_RESULT (r
) = new_decl
;
5197 DECL_TI_TEMPLATE (new_decl
) = r
;
5198 TREE_TYPE (r
) = TREE_TYPE (new_decl
);
5199 DECL_TI_ARGS (r
) = DECL_TI_ARGS (new_decl
);
5202 SET_DECL_IMPLICIT_INSTANTIATION (r
);
5203 DECL_TEMPLATE_INSTANTIATIONS (r
) = NULL_TREE
;
5204 DECL_TEMPLATE_SPECIALIZATIONS (r
) = NULL_TREE
;
5206 /* The template parameters for this new template are all the
5207 template parameters for the old template, except the
5208 outermost level of parameters. */
5209 DECL_TEMPLATE_PARMS (r
)
5210 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
);
5212 if (PRIMARY_TEMPLATE_P (t
))
5213 DECL_PRIMARY_TEMPLATE (r
) = r
;
5215 /* We don't partially instantiate partial specializations. */
5216 if (TREE_CODE (decl
) == TYPE_DECL
)
5219 for (spec
= DECL_TEMPLATE_SPECIALIZATIONS (t
);
5221 spec
= TREE_CHAIN (spec
))
5223 /* It helps to consider example here. Consider:
5234 Now, for example, we are instantiating S<int>::f(U u).
5235 We want to make a template:
5240 It will have a specialization, for the case U = int*, of
5244 void S<int>::f<int*>(int*);
5246 This specialization will be an instantiation of
5247 the specialization given in the declaration of S, with
5248 argument list int*. */
5250 tree fn
= TREE_VALUE (spec
);
5254 if (!DECL_TEMPLATE_SPECIALIZATION (fn
))
5255 /* Instantiations are on the same list, but they're of
5256 no concern to us. */
5259 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
5260 /* A full specialization. There's no need to record
5264 spec_args
= tsubst (DECL_TI_ARGS (fn
), args
, in_decl
);
5265 new_fn
= tsubst (DECL_RESULT (most_general_template (fn
)),
5266 spec_args
, in_decl
);
5267 DECL_TI_TEMPLATE (new_fn
) = fn
;
5268 register_specialization (new_fn
, r
,
5269 innermost_args (spec_args
));
5272 /* Record this partial instantiation. */
5273 register_specialization (r
, t
,
5274 DECL_TI_ARGS (DECL_RESULT (r
)));
5282 tree argvec
= NULL_TREE
;
5288 /* Nobody should be tsubst'ing into non-template functions. */
5289 my_friendly_assert (DECL_TEMPLATE_INFO (t
) != NULL_TREE
, 0);
5291 if (TREE_CODE (DECL_TI_TEMPLATE (t
)) == TEMPLATE_DECL
)
5295 /* Allocate template arguments on the momentary obstack,
5296 in case we don't need to keep them. */
5299 /* Calculate the most general template of which R is a
5300 specialization, and the complete set of arguments used to
5302 gen_tmpl
= most_general_template (DECL_TI_TEMPLATE (t
));
5304 = tsubst_template_arg_vector (DECL_TI_ARGS
5305 (DECL_TEMPLATE_RESULT (gen_tmpl
)),
5308 /* Check to see if we already have this specialization. */
5309 spec
= retrieve_specialization (gen_tmpl
, argvec
);
5318 /* We're going to need to keep the ARGVEC, so we copy it
5320 argvec
= copy_to_permanent (argvec
);
5323 /* Here, we deal with the peculiar case:
5325 template <class T> struct S {
5326 template <class U> friend void f();
5328 template <class U> friend void f() {}
5330 template void f<double>();
5332 Here, the ARGS for the instantiation of will be {int,
5333 double}. But, we only need as many ARGS as there are
5334 levels of template parameters in CODE_PATTERN. We are
5335 careful not to get fooled into reducing the ARGS in
5338 template <class T> struct S { template <class U> void f(U); }
5339 template <class T> template <> void S<T>::f(int) {}
5341 which we can spot because the pattern will be a
5342 specialization in this case. */
5343 args_depth
= TMPL_ARGS_DEPTH (args
);
5345 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t
)));
5346 if (args_depth
> parms_depth
5347 && !DECL_TEMPLATE_SPECIALIZATION (t
))
5349 my_friendly_assert (DECL_FRIEND_P (t
), 0);
5351 if (parms_depth
> 1)
5355 args
= make_temp_vec (parms_depth
);
5356 for (i
= 0; i
< parms_depth
; ++i
)
5357 TREE_VEC_ELT (args
, i
) =
5358 TREE_VEC_ELT (args
, i
+ (args_depth
- parms_depth
));
5361 args
= TREE_VEC_ELT (args
, args_depth
- parms_depth
);
5366 /* This special case arises when we have something like this:
5368 template <class T> struct S {
5369 friend void f<int>(int, double);
5372 Here, the DECL_TI_TEMPLATE for the friend declaration
5373 will be a LOOKUP_EXPR or an IDENTIFIER_NODE. We are
5374 being called from tsubst_friend_function, and we want
5375 only to create a new decl (R) with appropriate types so
5376 that we can call determine_specialization. */
5377 my_friendly_assert ((TREE_CODE (DECL_TI_TEMPLATE (t
))
5379 || (TREE_CODE (DECL_TI_TEMPLATE (t
))
5380 == IDENTIFIER_NODE
), 0);
5381 gen_tmpl
= NULL_TREE
;
5384 if (DECL_CLASS_SCOPE_P (t
))
5386 if (DECL_NAME (t
) == constructor_name (DECL_CONTEXT (t
)))
5390 ctx
= tsubst_aggr_type (DECL_CLASS_CONTEXT (t
), args
, t
,
5391 /*entering_scope=*/1);
5398 type
= tsubst (type
, args
, in_decl
);
5400 /* We do NOT check for matching decls pushed separately at this
5401 point, as they may not represent instantiations of this
5402 template, and in any case are considered separate under the
5403 discrete model. Instead, see add_maybe_template. */
5407 DECL_USE_TEMPLATE (r
) = 0;
5408 TREE_TYPE (r
) = type
;
5411 = tsubst_aggr_type (DECL_CONTEXT (t
), args
, t
, /*entering_scope=*/1);
5412 DECL_CLASS_CONTEXT (r
) = ctx
;
5414 if (member
&& !strncmp (OPERATOR_TYPENAME_FORMAT
,
5415 IDENTIFIER_POINTER (DECL_NAME (r
)),
5416 sizeof (OPERATOR_TYPENAME_FORMAT
) - 1))
5417 /* Type-conversion operator. Reconstruct the name, in
5418 case it's the name of one of the template's parameters. */
5419 DECL_NAME (r
) = build_typename_overload (TREE_TYPE (type
));
5421 DECL_ARGUMENTS (r
) = tsubst (DECL_ARGUMENTS (t
), args
, t
);
5422 DECL_MAIN_VARIANT (r
) = r
;
5423 DECL_RESULT (r
) = NULL_TREE
;
5425 TREE_STATIC (r
) = 0;
5426 TREE_PUBLIC (r
) = TREE_PUBLIC (t
);
5427 DECL_EXTERNAL (r
) = 1;
5428 DECL_INTERFACE_KNOWN (r
) = 0;
5429 DECL_DEFER_OUTPUT (r
) = 0;
5430 TREE_CHAIN (r
) = NULL_TREE
;
5431 DECL_PENDING_INLINE_INFO (r
) = 0;
5434 /* Set up the DECL_TEMPLATE_INFO for R and compute its mangled
5435 name. There's no need to do this in the special friend
5436 case mentioned above where GEN_TMPL is NULL. */
5439 /* The ARGVEC was built on the momentary obstack. Make it
5441 argvec
= copy_to_permanent (argvec
);
5442 DECL_TEMPLATE_INFO (r
)
5443 = perm_tree_cons (gen_tmpl
, argvec
, NULL_TREE
);
5444 SET_DECL_IMPLICIT_INSTANTIATION (r
);
5445 register_specialization (r
, gen_tmpl
, argvec
);
5447 /* Set the mangled name for R. */
5448 if (DECL_DESTRUCTOR_P (t
))
5449 DECL_ASSEMBLER_NAME (r
) = build_destructor_name (ctx
);
5452 /* Instantiations of template functions must be mangled
5453 specially, in order to conform to 14.5.5.1
5454 [temp.over.link]. */
5455 tree tmpl
= DECL_TI_TEMPLATE (t
);
5457 /* TMPL will be NULL if this is a specialization of a
5458 member function of a template class. */
5459 if (name_mangling_version
< 1
5460 || tmpl
== NULL_TREE
5461 || (member
&& !is_member_template (tmpl
)
5462 && !DECL_TEMPLATE_INFO (tmpl
)))
5463 set_mangled_name_for_decl (r
);
5465 set_mangled_name_for_template_decl (r
);
5469 make_decl_rtl (r
, NULL_PTR
, 1);
5471 /* Like grokfndecl. If we don't do this, pushdecl will
5472 mess up our TREE_CHAIN because it doesn't find a
5473 previous decl. Sigh. */
5475 && ! uses_template_parms (r
)
5476 && (IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (r
))
5478 SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (r
), r
);
5481 if (DECL_CONSTRUCTOR_P (r
))
5483 maybe_retrofit_in_chrg (r
);
5484 grok_ctor_properties (ctx
, r
);
5486 if (IDENTIFIER_OPNAME_P (DECL_NAME (r
)))
5487 grok_op_properties (r
, DECL_VIRTUAL_P (r
), DECL_FRIEND_P (r
));
5494 TREE_TYPE (r
) = type
;
5495 if (TREE_CODE (DECL_INITIAL (r
)) != TEMPLATE_PARM_INDEX
)
5496 DECL_INITIAL (r
) = TREE_TYPE (r
);
5498 DECL_INITIAL (r
) = tsubst (DECL_INITIAL (r
), args
, in_decl
);
5500 DECL_CONTEXT (r
) = NULL_TREE
;
5501 #ifdef PROMOTE_PROTOTYPES
5502 if ((TREE_CODE (type
) == INTEGER_TYPE
5503 || TREE_CODE (type
) == ENUMERAL_TYPE
)
5504 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
5505 DECL_ARG_TYPE (r
) = integer_type_node
;
5508 TREE_CHAIN (r
) = tsubst (TREE_CHAIN (t
), args
, TREE_CHAIN (t
));
5515 TREE_TYPE (r
) = type
;
5518 DECL_FIELD_CONTEXT (r
) = tsubst (DECL_FIELD_CONTEXT (t
), args
, in_decl
);
5520 DECL_INITIAL (r
) = tsubst_expr (DECL_INITIAL (t
), args
, in_decl
);
5521 TREE_CHAIN (r
) = NULL_TREE
;
5522 if (TREE_CODE (type
) == VOID_TYPE
)
5523 cp_error_at ("instantiation of `%D' as type void", r
);
5531 = tsubst_copy (DECL_INITIAL (t
), args
, in_decl
);
5532 TREE_CHAIN (r
) = NULL_TREE
;
5542 tree ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
, in_decl
,
5543 /*entering_scope=*/1);
5545 /* Nobody should be tsubst'ing into non-template variables. */
5546 my_friendly_assert (DECL_LANG_SPECIFIC (t
)
5547 && DECL_TEMPLATE_INFO (t
) != NULL_TREE
, 0);
5549 /* Check to see if we already have this specialization. */
5550 tmpl
= DECL_TI_TEMPLATE (t
);
5551 gen_tmpl
= most_general_template (tmpl
);
5552 argvec
= tsubst (DECL_TI_ARGS (t
), args
, in_decl
);
5553 spec
= retrieve_specialization (gen_tmpl
, argvec
);
5562 TREE_TYPE (r
) = type
;
5563 DECL_CONTEXT (r
) = ctx
;
5564 if (TREE_STATIC (r
))
5565 DECL_ASSEMBLER_NAME (r
)
5566 = build_static_name (DECL_CONTEXT (r
), DECL_NAME (r
));
5568 /* Don't try to expand the initializer until someone tries to use
5569 this variable; otherwise we run into circular dependencies. */
5570 DECL_INITIAL (r
) = NULL_TREE
;
5574 DECL_CLASS_CONTEXT (r
) = DECL_CONTEXT (r
);
5576 DECL_TEMPLATE_INFO (r
) = perm_tree_cons (tmpl
, argvec
, NULL_TREE
);
5577 SET_DECL_IMPLICIT_INSTANTIATION (r
);
5578 register_specialization (r
, gen_tmpl
, argvec
);
5580 TREE_CHAIN (r
) = NULL_TREE
;
5581 if (TREE_CODE (type
) == VOID_TYPE
)
5582 cp_error_at ("instantiation of `%D' as type void", r
);
5587 if (t
== TYPE_NAME (TREE_TYPE (t
)))
5588 r
= TYPE_NAME (type
);
5592 TREE_TYPE (r
) = type
;
5593 DECL_CONTEXT (r
) = current_class_type
;
5594 TREE_CHAIN (r
) = NULL_TREE
;
5599 my_friendly_abort (0);
5602 /* Restore the file and line information. */
5603 lineno
= saved_lineno
;
5604 input_filename
= saved_filename
;
5609 /* Substitue into the ARG_TYPES of a function type. */
5612 tsubst_arg_types (arg_types
, args
, in_decl
)
5617 tree remaining_arg_types
;
5620 if (!arg_types
|| arg_types
== void_list_node
)
5623 remaining_arg_types
= tsubst_arg_types (TREE_CHAIN (arg_types
),
5626 /* We use TYPE_MAIN_VARIANT is because top-level qualifiers don't
5627 matter on function types. */
5628 type
= TYPE_MAIN_VARIANT (type_decays_to
5629 (tsubst (TREE_VALUE (arg_types
),
5632 /* Note that we do not substitute into default arguments here. The
5633 standard mandates that they be instantiated only when needed,
5634 which is done in build_over_call. */
5635 return hash_tree_cons_simple (TREE_PURPOSE (arg_types
), type
,
5636 remaining_arg_types
);
5640 /* Take the tree structure T and replace template parameters used therein
5641 with the argument vector ARGS. IN_DECL is an associated decl for
5644 tsubst is used for dealing with types, decls and the like; for
5645 expressions, use tsubst_expr or tsubst_copy. */
5648 tsubst (t
, args
, in_decl
)
5654 if (t
== NULL_TREE
|| t
== error_mark_node
5655 || t
== integer_type_node
5656 || t
== void_type_node
5657 || t
== char_type_node
5658 || TREE_CODE (t
) == NAMESPACE_DECL
)
5661 if (TREE_CODE (t
) == IDENTIFIER_NODE
)
5662 type
= IDENTIFIER_TYPE_VALUE (t
);
5664 type
= TREE_TYPE (t
);
5665 if (type
== unknown_type_node
)
5666 my_friendly_abort (42);
5668 if (type
&& TREE_CODE (t
) != FUNCTION_DECL
5669 && TREE_CODE (t
) != TYPENAME_TYPE
5670 && TREE_CODE (t
) != TEMPLATE_DECL
5671 && TREE_CODE (t
) != IDENTIFIER_NODE
)
5672 type
= tsubst (type
, args
, in_decl
);
5674 if (TREE_CODE_CLASS (TREE_CODE (t
)) == 'd')
5675 return tsubst_decl (t
, args
, type
, in_decl
);
5677 switch (TREE_CODE (t
))
5682 return tsubst_aggr_type (t
, args
, in_decl
, /*entering_scope=*/0);
5685 case IDENTIFIER_NODE
:
5697 if (t
== integer_type_node
)
5700 if (TREE_CODE (TYPE_MIN_VALUE (t
)) == INTEGER_CST
5701 && TREE_CODE (TYPE_MAX_VALUE (t
)) == INTEGER_CST
)
5705 tree max
= TREE_OPERAND (TYPE_MAX_VALUE (t
), 0);
5707 max
= tsubst_expr (max
, args
, in_decl
);
5708 if (processing_template_decl
)
5710 tree itype
= make_node (INTEGER_TYPE
);
5711 TYPE_MIN_VALUE (itype
) = size_zero_node
;
5712 TYPE_MAX_VALUE (itype
) = build_min (MINUS_EXPR
, sizetype
, max
,
5717 if (pedantic
&& integer_zerop (max
))
5718 pedwarn ("creating array with size zero");
5719 else if (INT_CST_LT (max
, integer_zero_node
))
5721 cp_error ("creating array with size `%E'", max
);
5722 max
= integer_one_node
;
5725 max
= fold (build_binary_op (MINUS_EXPR
, max
, integer_one_node
, 1));
5726 if (!TREE_PERMANENT (max
) && !allocation_temporary_p ())
5727 max
= copy_to_permanent (max
);
5728 return build_index_type (max
);
5731 case TEMPLATE_TYPE_PARM
:
5732 case TEMPLATE_TEMPLATE_PARM
:
5733 case TEMPLATE_PARM_INDEX
:
5741 if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
5742 || TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
)
5744 idx
= TEMPLATE_TYPE_IDX (t
);
5745 level
= TEMPLATE_TYPE_LEVEL (t
);
5749 idx
= TEMPLATE_PARM_IDX (t
);
5750 level
= TEMPLATE_PARM_LEVEL (t
);
5753 if (TREE_VEC_LENGTH (args
) > 0)
5755 tree arg
= NULL_TREE
;
5757 levels
= TMPL_ARGS_DEPTH (args
);
5758 if (level
<= levels
)
5759 arg
= TMPL_ARG (args
, level
, idx
);
5761 if (arg
== error_mark_node
)
5762 return error_mark_node
;
5763 else if (arg
!= NULL_TREE
)
5765 if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
)
5767 my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (arg
))
5769 return cp_build_qualified_type
5770 (arg
, CP_TYPE_QUALS (arg
) | CP_TYPE_QUALS (t
));
5772 else if (TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
)
5774 if (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t
))
5776 /* We are processing a type constructed from
5777 a template template parameter */
5778 tree argvec
= tsubst (TYPE_TI_ARGS (t
),
5781 /* We can get a TEMPLATE_TEMPLATE_PARM here when
5782 we are resolving nested-types in the signature of
5783 a member function templates.
5784 Otherwise ARG is a TEMPLATE_DECL and is the real
5785 template to be instantiated. */
5786 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
5787 arg
= TYPE_NAME (arg
);
5789 r
= lookup_template_class (DECL_NAME (arg
),
5792 /*entering_scope=*/0);
5793 return cp_build_qualified_type (r
, TYPE_QUALS (t
));
5796 /* We are processing a template argument list. */
5804 my_friendly_abort (981018);
5807 /* This can happen during the attempted tsubst'ing in
5808 unify. This means that we don't yet have any information
5809 about the template parameter in question. */
5812 /* If we get here, we must have been looking at a parm for a
5813 more deeply nested template. Make a new version of this
5814 template parameter, but with a lower level. */
5815 switch (TREE_CODE (t
))
5817 case TEMPLATE_TYPE_PARM
:
5818 case TEMPLATE_TEMPLATE_PARM
:
5820 TEMPLATE_TYPE_PARM_INDEX (r
)
5821 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t
),
5823 TYPE_STUB_DECL (r
) = TYPE_NAME (r
) = TEMPLATE_TYPE_DECL (r
);
5824 TYPE_MAIN_VARIANT (r
) = r
;
5825 TYPE_POINTER_TO (r
) = NULL_TREE
;
5826 TYPE_REFERENCE_TO (r
) = NULL_TREE
;
5828 if (TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
5829 && TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t
))
5831 tree argvec
= tsubst (TYPE_TI_ARGS (t
), args
, in_decl
);
5832 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r
)
5833 = perm_tree_cons (TYPE_NAME (t
), argvec
, NULL_TREE
);
5837 case TEMPLATE_PARM_INDEX
:
5838 r
= reduce_template_parm_level (t
, type
, levels
);
5842 my_friendly_abort (0);
5850 tree purpose
, value
, chain
, result
;
5851 int via_public
, via_virtual
, via_protected
;
5853 if (t
== void_list_node
)
5856 via_public
= TREE_VIA_PUBLIC (t
);
5857 via_protected
= TREE_VIA_PROTECTED (t
);
5858 via_virtual
= TREE_VIA_VIRTUAL (t
);
5860 purpose
= TREE_PURPOSE (t
);
5862 purpose
= tsubst (purpose
, args
, in_decl
);
5863 value
= TREE_VALUE (t
);
5865 value
= tsubst (value
, args
, in_decl
);
5866 chain
= TREE_CHAIN (t
);
5867 if (chain
&& chain
!= void_type_node
)
5868 chain
= tsubst (chain
, args
, in_decl
);
5869 if (purpose
== TREE_PURPOSE (t
)
5870 && value
== TREE_VALUE (t
)
5871 && chain
== TREE_CHAIN (t
))
5873 result
= hash_tree_cons (via_public
, via_virtual
, via_protected
,
5874 purpose
, value
, chain
);
5875 TREE_PARMLIST (result
) = TREE_PARMLIST (t
);
5879 if (type
!= NULL_TREE
)
5881 /* A binfo node. We always need to make a copy, of the node
5882 itself and of its BINFO_BASETYPES. */
5886 /* Make sure type isn't a typedef copy. */
5887 type
= BINFO_TYPE (TYPE_BINFO (type
));
5889 TREE_TYPE (t
) = complete_type (type
);
5890 if (IS_AGGR_TYPE (type
))
5892 BINFO_VTABLE (t
) = TYPE_BINFO_VTABLE (type
);
5893 BINFO_VIRTUALS (t
) = TYPE_BINFO_VIRTUALS (type
);
5894 if (TYPE_BINFO_BASETYPES (type
) != NULL_TREE
)
5895 BINFO_BASETYPES (t
) = copy_node (TYPE_BINFO_BASETYPES (type
));
5900 /* Otherwise, a vector of template arguments. */
5901 return tsubst_template_arg_vector (t
, args
);
5904 case REFERENCE_TYPE
:
5906 enum tree_code code
;
5908 if (type
== TREE_TYPE (t
))
5911 code
= TREE_CODE (t
);
5912 if (TREE_CODE (type
) == REFERENCE_TYPE
5913 || (code
== REFERENCE_TYPE
&& TREE_CODE (type
) == VOID_TYPE
))
5915 static int last_line
= 0;
5916 static char* last_file
= 0;
5918 /* We keep track of the last time we issued this error
5919 message to avoid spewing a ton of messages during a
5920 single bad template instantiation. */
5921 if (last_line
!= lineno
||
5922 last_file
!= input_filename
)
5924 if (TREE_CODE (type
) == VOID_TYPE
)
5925 cp_error ("forming reference to void");
5927 cp_error ("forming %s to reference type `%T'",
5928 (code
== POINTER_TYPE
) ? "pointer" : "reference",
5931 last_file
= input_filename
;
5934 /* Use the underlying type in an attempt at error
5935 recovery; maybe the user meant vector<int> and wrote
5936 vector<int&>, or some such. */
5937 if (code
== REFERENCE_TYPE
)
5940 r
= build_pointer_type (TREE_TYPE (type
));
5942 else if (code
== POINTER_TYPE
)
5943 r
= build_pointer_type (type
);
5945 r
= build_reference_type (type
);
5946 r
= cp_build_qualified_type (r
, TYPE_QUALS (t
));
5948 /* Will this ever be needed for TYPE_..._TO values? */
5954 r
= tsubst (TYPE_OFFSET_BASETYPE (t
), args
, in_decl
);
5955 if (! IS_AGGR_TYPE (r
))
5956 cp_error ("creating pointer to member of non-class type `%T'", r
);
5957 return build_offset_type (r
, type
);
5966 /* The TYPE_CONTEXT is not used for function/method types. */
5967 my_friendly_assert (TYPE_CONTEXT (t
) == NULL_TREE
, 0);
5969 /* Substitue the argument types. */
5970 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, in_decl
);
5972 /* Construct a new type node and return it. */
5973 if (TREE_CODE (t
) == FUNCTION_TYPE
)
5974 fntype
= build_function_type (type
, arg_types
);
5977 r
= TREE_TYPE (TREE_VALUE (arg_types
));
5978 if (! IS_AGGR_TYPE (r
))
5979 cp_error ("creating pointer to member function of non-class type `%T'",
5982 fntype
= build_cplus_method_type (r
, type
, TREE_CHAIN (arg_types
));
5984 fntype
= build_qualified_type (fntype
, TYPE_QUALS (t
));
5986 /* Substitue the exception specification. */
5987 raises
= TYPE_RAISES_EXCEPTIONS (t
);
5990 raises
= tsubst (raises
, args
, in_decl
);
5991 fntype
= build_exception_variant (fntype
, raises
);
5997 tree domain
= tsubst (TYPE_DOMAIN (t
), args
, in_decl
);
5998 if (type
== TREE_TYPE (t
) && domain
== TYPE_DOMAIN (t
))
6001 /* These checks should match the ones in grokdeclarator. */
6002 if (TREE_CODE (type
) == VOID_TYPE
)
6004 cp_error ("creating array of void");
6005 type
= build_pointer_type (type
);
6007 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
6009 cp_error ("creating array of functions `%T'", type
);
6010 type
= build_pointer_type (type
);
6012 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
6014 cp_error ("creating array of references `%T'", type
);
6015 type
= TREE_TYPE (type
);
6018 r
= build_cplus_array_type (type
, domain
);
6024 return fold (build (TREE_CODE (t
), TREE_TYPE (t
),
6025 tsubst (TREE_OPERAND (t
, 0), args
, in_decl
),
6026 tsubst (TREE_OPERAND (t
, 1), args
, in_decl
)));
6030 return fold (build1 (TREE_CODE (t
), TREE_TYPE (t
),
6031 tsubst (TREE_OPERAND (t
, 0), args
, in_decl
)));
6035 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, in_decl
,
6036 /*entering_scope=*/1);
6037 tree f
= tsubst_copy (TYPENAME_TYPE_FULLNAME (t
), args
, in_decl
);
6039 /* Normally, make_typename_type does not require that the CTX
6040 have complete type in order to allow things like:
6042 template <class T> struct S { typename S<T>::X Y; };
6044 But, such constructs have already been resolved by this
6045 point, so here CTX really should have complete type, unless
6046 it's a partial instantiation. */
6047 if (!uses_template_parms (ctx
)
6048 && !complete_type_or_else (ctx
))
6049 return error_mark_node
;
6051 f
= make_typename_type (ctx
, f
);
6052 return cp_build_qualified_type (f
,
6054 | CP_TYPE_QUALS (t
));
6058 return make_pointer_declarator
6059 (type
, tsubst (TREE_OPERAND (t
, 0), args
, in_decl
));
6062 return make_reference_declarator
6063 (type
, tsubst (TREE_OPERAND (t
, 0), args
, in_decl
));
6066 return build_parse_node
6067 (ARRAY_REF
, tsubst (TREE_OPERAND (t
, 0), args
, in_decl
),
6068 tsubst_expr (TREE_OPERAND (t
, 1), args
, in_decl
));
6071 return make_call_declarator
6072 (tsubst (TREE_OPERAND (t
, 0), args
, in_decl
),
6073 tsubst (TREE_OPERAND (t
, 1), args
, in_decl
),
6074 TREE_OPERAND (t
, 2),
6075 tsubst (TREE_TYPE (t
), args
, in_decl
));
6078 return build_parse_node
6079 (TREE_CODE (t
), tsubst (TREE_OPERAND (t
, 0), args
, in_decl
),
6080 tsubst (TREE_OPERAND (t
, 1), args
, in_decl
));
6083 return TREE_TYPE (tsubst_expr (TYPE_FIELDS (t
), args
, in_decl
));
6086 sorry ("use of `%s' in template",
6087 tree_code_name
[(int) TREE_CODE (t
)]);
6088 return error_mark_node
;
6095 emit_line_note (input_filename
, lineno
);
6099 expand_start_bindings (0);
6106 int saved_warn_unused
= 0;
6108 if (processing_template_decl
)
6110 saved_warn_unused
= warn_unused
;
6113 expand_end_bindings (getdecls (), kept_level_p (), 0);
6114 if (processing_template_decl
)
6115 warn_unused
= saved_warn_unused
;
6116 t
= poplevel (kept_level_p (), 1, 0);
6121 /* Like tsubst, but deals with expressions. This function just replaces
6122 template parms; to finish processing the resultant expression, use
6126 tsubst_copy (t
, args
, in_decl
)
6130 enum tree_code code
;
6133 if (t
== NULL_TREE
|| t
== error_mark_node
)
6136 code
= TREE_CODE (t
);
6141 return do_identifier (DECL_NAME (t
), 0, NULL_TREE
);
6148 if (!DECL_CONTEXT (t
))
6149 /* This is a global enumeration constant. */
6152 /* Unfortunately, we cannot just call lookup_name here.
6155 template <int I> int f() {
6157 struct S { void g() { E e = a; } };
6160 When we instantiate f<7>::S::g(), say, lookup_name is not
6161 clever enough to find f<7>::a. */
6163 = tsubst_aggr_type (TREE_TYPE (t
), args
, in_decl
,
6164 /*entering_scope=*/0);
6166 for (v
= TYPE_VALUES (enum_type
);
6169 if (TREE_PURPOSE (v
) == DECL_NAME (t
))
6170 return TREE_VALUE (v
);
6172 /* We didn't find the name. That should never happen; if
6173 name-lookup found it during preliminary parsing, we
6174 should find it again here during instantiation. */
6175 my_friendly_abort (0);
6180 if (DECL_CONTEXT (t
))
6184 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
, in_decl
,
6185 /*entering_scope=*/1);
6186 if (ctx
!= DECL_CONTEXT (t
))
6187 return lookup_field (ctx
, DECL_NAME (t
), 0, 0);
6193 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
6194 t
= tsubst (t
, args
, in_decl
);
6199 if (is_member_template (t
))
6200 return tsubst (t
, args
, in_decl
);
6206 /* We must tsbust into a LOOKUP_EXPR in case the names to
6207 which it refers is a conversion operator; in that case the
6208 name will change. We avoid making unnecessary copies,
6211 tree id
= tsubst_copy (TREE_OPERAND (t
, 0), args
, in_decl
);
6213 if (id
!= TREE_OPERAND (t
, 0))
6215 r
= build_nt (LOOKUP_EXPR
, id
);
6216 LOOKUP_EXPR_GLOBAL (r
) = LOOKUP_EXPR_GLOBAL (t
);
6224 case REINTERPRET_CAST_EXPR
:
6225 case CONST_CAST_EXPR
:
6226 case STATIC_CAST_EXPR
:
6227 case DYNAMIC_CAST_EXPR
:
6230 (code
, tsubst (TREE_TYPE (t
), args
, in_decl
),
6231 tsubst_copy (TREE_OPERAND (t
, 0), args
, in_decl
));
6234 case PREDECREMENT_EXPR
:
6235 case PREINCREMENT_EXPR
:
6236 case POSTDECREMENT_EXPR
:
6237 case POSTINCREMENT_EXPR
:
6239 case TRUTH_NOT_EXPR
:
6242 case CONVERT_EXPR
: /* Unary + */
6250 tsubst_copy (TREE_OPERAND (t
, 0), args
, in_decl
));
6255 case TRUNC_DIV_EXPR
:
6257 case FLOOR_DIV_EXPR
:
6258 case ROUND_DIV_EXPR
:
6259 case EXACT_DIV_EXPR
:
6261 case BIT_ANDTC_EXPR
:
6264 case TRUNC_MOD_EXPR
:
6265 case FLOOR_MOD_EXPR
:
6266 case TRUTH_ANDIF_EXPR
:
6267 case TRUTH_ORIF_EXPR
:
6268 case TRUTH_AND_EXPR
:
6289 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, in_decl
),
6290 tsubst_copy (TREE_OPERAND (t
, 1), args
, in_decl
));
6294 tree fn
= TREE_OPERAND (t
, 0);
6295 if (is_overloaded_fn (fn
))
6296 fn
= tsubst_copy (get_first_fn (fn
), args
, in_decl
);
6298 /* Sometimes FN is a LOOKUP_EXPR. */
6299 fn
= tsubst_copy (fn
, args
, in_decl
);
6301 (code
, fn
, tsubst_copy (TREE_OPERAND (t
, 1), args
, in_decl
),
6305 case METHOD_CALL_EXPR
:
6307 tree name
= TREE_OPERAND (t
, 0);
6308 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
6310 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
, in_decl
);
6311 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
6313 else if (TREE_CODE (name
) == SCOPE_REF
6314 && TREE_CODE (TREE_OPERAND (name
, 1)) == BIT_NOT_EXPR
)
6316 tree base
= tsubst_copy (TREE_OPERAND (name
, 0), args
, in_decl
);
6317 name
= TREE_OPERAND (name
, 1);
6318 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
, in_decl
);
6319 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
6320 name
= build_nt (SCOPE_REF
, base
, name
);
6323 name
= tsubst_copy (TREE_OPERAND (t
, 0), args
, in_decl
);
6325 (code
, name
, tsubst_copy (TREE_OPERAND (t
, 1), args
, in_decl
),
6326 tsubst_copy (TREE_OPERAND (t
, 2), args
, in_decl
),
6335 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, in_decl
),
6336 tsubst_copy (TREE_OPERAND (t
, 1), args
, in_decl
),
6337 tsubst_copy (TREE_OPERAND (t
, 2), args
, in_decl
));
6339 if (code
== BIND_EXPR
&& !processing_template_decl
)
6341 /* This processing should really occur in tsubst_expr,
6342 However, tsubst_expr does not recurse into expressions,
6343 since it assumes that there aren't any statements
6344 inside them. Instead, it simply calls
6345 build_expr_from_tree. So, we need to expand the
6347 tree rtl_expr
= begin_stmt_expr ();
6348 tree block
= tsubst_expr (TREE_OPERAND (r
, 1), args
, in_decl
);
6349 r
= finish_stmt_expr (rtl_expr
, block
);
6358 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, in_decl
),
6359 tsubst_copy (TREE_OPERAND (t
, 1), args
, in_decl
),
6360 tsubst_copy (TREE_OPERAND (t
, 2), args
, in_decl
));
6361 NEW_EXPR_USE_GLOBAL (r
) = NEW_EXPR_USE_GLOBAL (t
);
6368 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, in_decl
),
6369 tsubst_copy (TREE_OPERAND (t
, 1), args
, in_decl
));
6370 DELETE_EXPR_USE_GLOBAL (r
) = DELETE_EXPR_USE_GLOBAL (t
);
6371 DELETE_EXPR_USE_VEC (r
) = DELETE_EXPR_USE_VEC (t
);
6375 case TEMPLATE_ID_EXPR
:
6377 /* Substituted template arguments */
6378 tree targs
= tsubst_copy (TREE_OPERAND (t
, 1), args
, in_decl
);
6380 for (chain
= targs
; chain
; chain
= TREE_CHAIN (chain
))
6381 TREE_VALUE (chain
) = maybe_fold_nontype_arg (TREE_VALUE (chain
));
6383 return lookup_template_function
6384 (tsubst_copy (TREE_OPERAND (t
, 0), args
, in_decl
), targs
);
6389 tree purpose
, value
, chain
;
6391 if (t
== void_list_node
)
6394 purpose
= TREE_PURPOSE (t
);
6396 purpose
= tsubst_copy (purpose
, args
, in_decl
);
6397 value
= TREE_VALUE (t
);
6399 value
= tsubst_copy (value
, args
, in_decl
);
6400 chain
= TREE_CHAIN (t
);
6401 if (chain
&& chain
!= void_type_node
)
6402 chain
= tsubst_copy (chain
, args
, in_decl
);
6403 if (purpose
== TREE_PURPOSE (t
)
6404 && value
== TREE_VALUE (t
)
6405 && chain
== TREE_CHAIN (t
))
6407 return tree_cons (purpose
, value
, chain
);
6414 case TEMPLATE_TYPE_PARM
:
6415 case TEMPLATE_TEMPLATE_PARM
:
6416 case TEMPLATE_PARM_INDEX
:
6418 case REFERENCE_TYPE
:
6425 return tsubst (t
, args
, in_decl
);
6427 case IDENTIFIER_NODE
:
6428 if (IDENTIFIER_TYPENAME_P (t
)
6429 /* Make sure it's not just a variable named `__opr', for instance,
6430 which can occur in some existing code. */
6432 return build_typename_overload
6433 (tsubst (TREE_TYPE (t
), args
, in_decl
));
6440 (CONSTRUCTOR
, tsubst (TREE_TYPE (t
), args
, in_decl
), NULL_TREE
,
6441 tsubst_copy (CONSTRUCTOR_ELTS (t
), args
, in_decl
));
6442 TREE_HAS_CONSTRUCTOR (r
) = TREE_HAS_CONSTRUCTOR (t
);
6451 /* Like tsubst_copy, but also does semantic processing and RTL expansion. */
6454 tsubst_expr (t
, args
, in_decl
)
6458 if (t
== NULL_TREE
|| t
== error_mark_node
)
6461 if (processing_template_decl
)
6462 return tsubst_copy (t
, args
, in_decl
);
6464 switch (TREE_CODE (t
))
6467 lineno
= TREE_COMPLEXITY (t
);
6468 finish_return_stmt (tsubst_expr (RETURN_EXPR (t
),
6473 lineno
= TREE_COMPLEXITY (t
);
6474 finish_expr_stmt (tsubst_expr (EXPR_STMT_EXPR (t
),
6480 int i
= suspend_momentary ();
6483 lineno
= TREE_COMPLEXITY (t
);
6484 emit_line_note (input_filename
, lineno
);
6486 (tsubst (TREE_OPERAND (t
, 0), args
, in_decl
),
6487 tsubst (TREE_OPERAND (t
, 1), args
, in_decl
),
6488 TREE_OPERAND (t
, 2) != 0, NULL_TREE
, NULL_TREE
);
6489 init
= tsubst_expr (TREE_OPERAND (t
, 2), args
, in_decl
);
6491 (dcl
, init
, NULL_TREE
, 1, /*init ? LOOKUP_ONLYCONVERTING :*/ 0);
6492 resume_momentary (i
);
6499 lineno
= TREE_COMPLEXITY (t
);
6502 for (tmp
= FOR_INIT_STMT (t
); tmp
; tmp
= TREE_CHAIN (tmp
))
6503 tsubst_expr (tmp
, args
, in_decl
);
6504 finish_for_init_stmt (NULL_TREE
);
6505 finish_for_cond (tsubst_expr (FOR_COND (t
), args
,
6508 tmp
= tsubst_expr (FOR_EXPR (t
), args
, in_decl
);
6509 finish_for_expr (tmp
, NULL_TREE
);
6510 tsubst_expr (FOR_BODY (t
), args
, in_decl
);
6511 finish_for_stmt (tmp
, NULL_TREE
);
6517 lineno
= TREE_COMPLEXITY (t
);
6518 begin_while_stmt ();
6519 finish_while_stmt_cond (tsubst_expr (WHILE_COND (t
),
6522 tsubst_expr (WHILE_BODY (t
), args
, in_decl
);
6523 finish_while_stmt (NULL_TREE
);
6529 lineno
= TREE_COMPLEXITY (t
);
6531 tsubst_expr (DO_BODY (t
), args
, in_decl
);
6532 finish_do_body (NULL_TREE
);
6533 finish_do_stmt (tsubst_expr (DO_COND (t
), args
,
6543 lineno
= TREE_COMPLEXITY (t
);
6545 finish_if_stmt_cond (tsubst_expr (IF_COND (t
),
6549 if (tmp
= THEN_CLAUSE (t
), tmp
)
6551 tsubst_expr (tmp
, args
, in_decl
);
6552 finish_then_clause (NULL_TREE
);
6555 if (tmp
= ELSE_CLAUSE (t
), tmp
)
6557 begin_else_clause ();
6558 tsubst_expr (tmp
, args
, in_decl
);
6559 finish_else_clause (NULL_TREE
);
6570 lineno
= TREE_COMPLEXITY (t
);
6571 begin_compound_stmt (COMPOUND_STMT_NO_SCOPE (t
));
6572 for (substmt
= COMPOUND_BODY (t
);
6573 substmt
!= NULL_TREE
;
6574 substmt
= TREE_CHAIN (substmt
))
6575 tsubst_expr (substmt
, args
, in_decl
);
6576 return finish_compound_stmt (COMPOUND_STMT_NO_SCOPE (t
),
6582 lineno
= TREE_COMPLEXITY (t
);
6583 finish_break_stmt ();
6587 lineno
= TREE_COMPLEXITY (t
);
6588 finish_continue_stmt ();
6595 lineno
= TREE_COMPLEXITY (t
);
6596 begin_switch_stmt ();
6597 val
= tsubst_expr (SWITCH_COND (t
), args
, in_decl
);
6598 finish_switch_cond (val
);
6600 if (tmp
= TREE_OPERAND (t
, 1), tmp
)
6601 tsubst_expr (tmp
, args
, in_decl
);
6603 finish_switch_stmt (val
, NULL_TREE
);
6608 finish_case_label (tsubst_expr (CASE_LOW (t
), args
, in_decl
),
6609 tsubst_expr (CASE_HIGH (t
), args
, in_decl
));
6613 t
= define_label (DECL_SOURCE_FILE (t
), DECL_SOURCE_LINE (t
),
6620 lineno
= TREE_COMPLEXITY (t
);
6621 t
= GOTO_DESTINATION (t
);
6622 if (TREE_CODE (t
) != IDENTIFIER_NODE
)
6623 /* Computed goto's must be tsubst'd into. On the other hand,
6624 non-computed gotos must not be; the identifier in question
6625 will have no binding. */
6626 t
= tsubst_expr (t
, args
, in_decl
);
6627 finish_goto_stmt (t
);
6631 lineno
= TREE_COMPLEXITY (t
);
6632 finish_asm_stmt (tsubst_expr (ASM_CV_QUAL (t
), args
, in_decl
),
6633 tsubst_expr (ASM_STRING (t
), args
, in_decl
),
6634 tsubst_expr (ASM_OUTPUTS (t
), args
, in_decl
),
6635 tsubst_expr (ASM_INPUTS (t
), args
, in_decl
),
6636 tsubst_expr (ASM_CLOBBERS (t
), args
, in_decl
));
6640 lineno
= TREE_COMPLEXITY (t
);
6642 tsubst_expr (TRY_STMTS (t
), args
, in_decl
);
6643 finish_try_block (NULL_TREE
);
6645 tree handler
= TRY_HANDLERS (t
);
6646 for (; handler
; handler
= TREE_CHAIN (handler
))
6647 tsubst_expr (handler
, args
, in_decl
);
6649 finish_handler_sequence (NULL_TREE
);
6653 lineno
= TREE_COMPLEXITY (t
);
6655 if (HANDLER_PARMS (t
))
6657 tree d
= HANDLER_PARMS (t
);
6658 expand_start_catch_block
6659 (tsubst (TREE_OPERAND (d
, 1), args
, in_decl
),
6660 tsubst (TREE_OPERAND (d
, 0), args
, in_decl
));
6663 expand_start_catch_block (NULL_TREE
, NULL_TREE
);
6664 finish_handler_parms (NULL_TREE
);
6665 tsubst_expr (HANDLER_BODY (t
), args
, in_decl
);
6666 finish_handler (NULL_TREE
);
6670 lineno
= TREE_COMPLEXITY (t
);
6672 if (TREE_CODE (t
) == ENUMERAL_TYPE
)
6673 tsubst (t
, args
, NULL_TREE
);
6677 return build_expr_from_tree (tsubst_copy (t
, args
, in_decl
));
6682 /* Instantiate the indicated variable or function template TMPL with
6683 the template arguments in TARG_PTR. */
6686 instantiate_template (tmpl
, targ_ptr
)
6687 tree tmpl
, targ_ptr
;
6693 struct obstack
*old_fmp_obstack
;
6694 extern struct obstack
*function_maybepermanent_obstack
;
6697 if (tmpl
== error_mark_node
)
6698 return error_mark_node
;
6700 my_friendly_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
, 283);
6702 /* Check to see if we already have this specialization. */
6703 spec
= retrieve_specialization (tmpl
, targ_ptr
);
6704 if (spec
!= NULL_TREE
)
6707 if (DECL_TEMPLATE_INFO (tmpl
))
6709 /* The TMPL is a partial instantiation. To get a full set of
6710 arguments we must add the arguments used to perform the
6711 partial instantiation. */
6712 targ_ptr
= add_outermost_template_args (DECL_TI_ARGS (tmpl
),
6714 gen_tmpl
= most_general_template (tmpl
);
6716 /* Check to see if we already have this specialization. */
6717 spec
= retrieve_specialization (gen_tmpl
, targ_ptr
);
6718 if (spec
!= NULL_TREE
)
6724 push_obstacks (&permanent_obstack
, &permanent_obstack
);
6725 old_fmp_obstack
= function_maybepermanent_obstack
;
6726 function_maybepermanent_obstack
= &permanent_obstack
;
6728 len
= DECL_NTPARMS (gen_tmpl
);
6729 inner_args
= innermost_args (targ_ptr
);
6733 tree t
= TREE_VEC_ELT (inner_args
, i
);
6734 if (TREE_CODE_CLASS (TREE_CODE (t
)) == 't')
6736 tree nt
= target_type (t
);
6737 if (IS_AGGR_TYPE (nt
) && decl_function_context (TYPE_MAIN_DECL (nt
)))
6739 cp_error ("type `%T' composed from a local class is not a valid template-argument", t
);
6740 cp_error (" trying to instantiate `%D'", gen_tmpl
);
6741 fndecl
= error_mark_node
;
6746 targ_ptr
= copy_to_permanent (targ_ptr
);
6748 /* substitute template parameters */
6749 fndecl
= tsubst (DECL_RESULT (gen_tmpl
), targ_ptr
, gen_tmpl
);
6750 /* The DECL_TI_TEMPLATE should always be the immediate parent
6751 template, not the most general template. */
6752 DECL_TI_TEMPLATE (fndecl
) = tmpl
;
6754 if (flag_external_templates
)
6755 add_pending_template (fndecl
);
6758 function_maybepermanent_obstack
= old_fmp_obstack
;
6764 /* Push the name of the class template into the scope of the instantiation. */
6767 overload_template_name (type
)
6770 tree id
= DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
));
6773 if (IDENTIFIER_CLASS_VALUE (id
)
6774 && TREE_TYPE (IDENTIFIER_CLASS_VALUE (id
)) == type
)
6777 decl
= build_decl (TYPE_DECL
, id
, type
);
6778 SET_DECL_ARTIFICIAL (decl
);
6779 pushdecl_class_level (decl
);
6782 /* Like type_unification but designed specially to handle conversion
6785 The FN is a TEMPLATE_DECL for a function. The ARGS are the
6786 arguments that are being used when calling it.
6788 If FN is a conversion operator, RETURN_TYPE is the type desired as
6789 the result of the conversion operator.
6791 The EXTRA_FN_ARG, if any, is the type of an additional
6792 parameter to be added to the beginning of FN's parameter list.
6794 The other arguments are as for type_unification. */
6797 fn_type_unification (fn
, explicit_targs
, targs
, args
, return_type
,
6798 strict
, extra_fn_arg
)
6799 tree fn
, explicit_targs
, targs
, args
, return_type
;
6800 unification_kind_t strict
;
6805 my_friendly_assert (TREE_CODE (fn
) == TEMPLATE_DECL
, 0);
6807 parms
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
6809 if (DECL_CONV_FN_P (fn
))
6811 /* This is a template conversion operator. Use the return types
6812 as well as the argument types. */
6813 parms
= scratch_tree_cons (NULL_TREE
,
6814 TREE_TYPE (TREE_TYPE (fn
)),
6816 args
= scratch_tree_cons (NULL_TREE
, return_type
, args
);
6819 if (extra_fn_arg
!= NULL_TREE
)
6820 parms
= scratch_tree_cons (NULL_TREE
, extra_fn_arg
, parms
);
6822 /* We allow incomplete unification without an error message here
6823 because the standard doesn't seem to explicitly prohibit it. Our
6824 callers must be ready to deal with unification failures in any
6826 return type_unification (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
6835 /* Type unification.
6837 We have a function template signature with one or more references to
6838 template parameters, and a parameter list we wish to fit to this
6839 template. If possible, produce a list of parameters for the template
6840 which will cause it to fit the supplied parameter list.
6842 Return zero for success, 2 for an incomplete match that doesn't resolve
6843 all the types, and 1 for complete failure. An error message will be
6844 printed only for an incomplete match.
6846 TPARMS[NTPARMS] is an array of template parameter types.
6848 TARGS[NTPARMS] is the array into which the deduced template
6849 parameter values are placed. PARMS is the function template's
6850 signature (using TEMPLATE_PARM_IDX nodes), and ARGS is the argument
6851 list we're trying to match against it.
6853 The EXPLICIT_TARGS are explicit template arguments provided via a
6856 The parameter STRICT is one of:
6859 We are deducing arguments for a function call, as in
6863 We are deducing arguments for a conversion function, as in
6867 We are deducing arguments when calculating the partial
6868 ordering between specializations of function or class
6869 templates, as in [temp.func.order] and [temp.class.order],
6870 when doing an explicit instantiation as in [temp.explicit],
6871 when determining an explicit specialization as in
6872 [temp.expl.spec], or when taking the address of a function
6873 template, as in [temp.deduct.funcaddr]. */
6876 type_unification (tparms
, targs
, parms
, args
, explicit_targs
,
6877 strict
, allow_incomplete
)
6878 tree tparms
, targs
, parms
, args
, explicit_targs
;
6879 unification_kind_t strict
;
6880 int allow_incomplete
;
6885 for (i
= 0; i
< TREE_VEC_LENGTH (tparms
); i
++)
6886 TREE_VEC_ELT (targs
, i
) = NULL_TREE
;
6888 if (explicit_targs
!= NULL_TREE
)
6891 arg_vec
= coerce_template_parms (tparms
, explicit_targs
, NULL_TREE
, 0,
6894 if (arg_vec
== error_mark_node
)
6897 explicit_mask
= alloca (sizeof (int) * TREE_VEC_LENGTH (targs
));
6898 bzero ((char *) explicit_mask
, sizeof(int) * TREE_VEC_LENGTH (targs
));
6901 i
< TREE_VEC_LENGTH (arg_vec
)
6902 && TREE_VEC_ELT (arg_vec
, i
) != NULL_TREE
;
6905 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (arg_vec
, i
);
6906 /* Let unify know that this argument was explicit. */
6907 explicit_mask
[i
] = 1;
6914 type_unification_real (tparms
, targs
, parms
, args
, 0,
6915 strict
, allow_incomplete
, explicit_mask
);
6918 /* Adjust types before performing type deduction, as described in
6919 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
6920 sections are symmetric. PARM is the type of a function parameter
6921 or the return type of the conversion function. ARG is the type of
6922 the argument passed to the call, or the type of the value
6923 intialized with the result of the conversion function. */
6926 maybe_adjust_types_for_deduction (strict
, parm
, arg
)
6927 unification_kind_t strict
;
6938 /* Swap PARM and ARG throughout the remainder of this
6939 function; the handling is precisely symmetric since PARM
6940 will initialize ARG rather than vice versa. */
6948 /* There is nothing to do in this case. */
6952 my_friendly_abort (0);
6955 if (TREE_CODE (*parm
) != REFERENCE_TYPE
)
6957 /* [temp.deduct.call]
6959 If P is not a reference type:
6961 --If A is an array type, the pointer type produced by the
6962 array-to-pointer standard conversion (_conv.array_) is
6963 used in place of A for type deduction; otherwise,
6965 --If A is a function type, the pointer type produced by
6966 the function-to-pointer standard conversion
6967 (_conv.func_) is used in place of A for type deduction;
6970 --If A is a cv-qualified type, the top level
6971 cv-qualifiers of A's type are ignored for type
6973 if (TREE_CODE (*arg
) == ARRAY_TYPE
)
6974 *arg
= build_pointer_type (TREE_TYPE (*arg
));
6975 else if (TREE_CODE (*arg
) == FUNCTION_TYPE
6976 || TREE_CODE (*arg
) == METHOD_TYPE
)
6977 *arg
= build_pointer_type (*arg
);
6979 *arg
= TYPE_MAIN_VARIANT (*arg
);
6982 /* [temp.deduct.call]
6984 If P is a cv-qualified type, the top level cv-qualifiers
6985 of P's type are ignored for type deduction. If P is a
6986 reference type, the type referred to by P is used for
6988 *parm
= TYPE_MAIN_VARIANT (*parm
);
6989 if (TREE_CODE (*parm
) == REFERENCE_TYPE
)
6990 *parm
= TREE_TYPE (*parm
);
6993 /* Like type_unfication. EXPLICIT_MASK, if non-NULL, is an array of
6994 integers, with ones in positions corresponding to arguments in
6995 targs that were provided explicitly, and zeros elsewhere.
6997 If SUBR is 1, we're being called recursively (to unify the
6998 arguments of a function or method parameter of a function
7002 type_unification_real (tparms
, targs
, parms
, args
, subr
,
7003 strict
, allow_incomplete
, explicit_mask
)
7004 tree tparms
, targs
, parms
, args
;
7006 unification_kind_t strict
;
7007 int allow_incomplete
;
7012 int ntparms
= TREE_VEC_LENGTH (tparms
);
7015 my_friendly_assert (TREE_CODE (tparms
) == TREE_VEC
, 289);
7016 my_friendly_assert (parms
== NULL_TREE
7017 || TREE_CODE (parms
) == TREE_LIST
, 290);
7018 /* ARGS could be NULL (via a call from parse.y to
7019 build_x_function_call). */
7021 my_friendly_assert (TREE_CODE (args
) == TREE_LIST
, 291);
7022 my_friendly_assert (ntparms
> 0, 292);
7027 sub_strict
= UNIFY_ALLOW_MORE_CV_QUAL
| UNIFY_ALLOW_DERIVED
;
7031 sub_strict
= UNIFY_ALLOW_LESS_CV_QUAL
;
7035 sub_strict
= UNIFY_ALLOW_NONE
;
7039 my_friendly_abort (0);
7043 && parms
!= void_list_node
7045 && args
!= void_list_node
)
7047 parm
= TREE_VALUE (parms
);
7048 parms
= TREE_CHAIN (parms
);
7049 arg
= TREE_VALUE (args
);
7050 args
= TREE_CHAIN (args
);
7052 if (arg
== error_mark_node
)
7054 if (arg
== unknown_type_node
)
7055 /* We can't deduce anything from this, but we might get all the
7056 template args from other function args. */
7059 /* Conversions will be performed on a function argument that
7060 corresponds with a function parameter that contains only
7061 non-deducible template parameters and explicitly specified
7062 template parameters. */
7063 if (! uses_template_parms (parm
))
7067 if (TREE_CODE_CLASS (TREE_CODE (arg
)) != 't')
7068 type
= TREE_TYPE (arg
);
7075 if (strict
== DEDUCE_EXACT
)
7077 if (same_type_p (parm
, type
))
7081 /* It might work; we shouldn't check now, because we might
7082 get into infinite recursion. Overload resolution will
7090 if (TREE_CODE (arg
) == VAR_DECL
)
7091 arg
= TREE_TYPE (arg
);
7092 else if (TREE_CODE_CLASS (TREE_CODE (arg
)) == 'e')
7093 arg
= TREE_TYPE (arg
);
7095 if (TREE_CODE_CLASS (TREE_CODE (arg
)) != 't')
7097 my_friendly_assert (TREE_TYPE (arg
) != NULL_TREE
, 293);
7098 if (type_unknown_p (arg
))
7100 /* [temp.deduct.type] A template-argument can be deduced from
7101 a pointer to function or pointer to member function
7102 argument if the set of overloaded functions does not
7103 contain function templates and at most one of a set of
7104 overloaded functions provides a unique match. */
7106 if (resolve_overloaded_unification
7107 (tparms
, targs
, parm
, arg
, strict
, sub_strict
, explicit_mask
)
7112 arg
= TREE_TYPE (arg
);
7116 maybe_adjust_types_for_deduction (strict
, &parm
, &arg
);
7118 switch (unify (tparms
, targs
, parm
, arg
, sub_strict
,
7127 /* Fail if we've reached the end of the parm list, and more args
7128 are present, and the parm list isn't variadic. */
7129 if (args
&& args
!= void_list_node
&& parms
== void_list_node
)
7131 /* Fail if parms are left and they don't have default values. */
7133 && parms
!= void_list_node
7134 && TREE_PURPOSE (parms
) == NULL_TREE
)
7137 for (i
= 0; i
< ntparms
; i
++)
7138 if (TREE_VEC_ELT (targs
, i
) == NULL_TREE
)
7140 if (!allow_incomplete
)
7141 error ("incomplete type unification");
7147 /* Subroutine of type_unification_real. Args are like the variables at the
7148 call site. ARG is an overloaded function (or template-id); we try
7149 deducing template args from each of the overloads, and if only one
7150 succeeds, we go with that. Modifies TARGS and returns 0 on success. */
7153 resolve_overloaded_unification (tparms
, targs
, parm
, arg
, strict
,
7154 sub_strict
, explicit_mask
)
7155 tree tparms
, targs
, parm
, arg
;
7156 unification_kind_t strict
;
7160 tree tempargs
= copy_node (targs
);
7163 if (TREE_CODE (arg
) == ADDR_EXPR
)
7164 arg
= TREE_OPERAND (arg
, 0);
7166 /* Strip baselink information. */
7167 while (TREE_CODE (arg
) == TREE_LIST
)
7168 arg
= TREE_VALUE (arg
);
7170 if (TREE_CODE (arg
) == TEMPLATE_ID_EXPR
)
7172 /* If we got some explicit template args, we need to plug them into
7173 the affected templates before we try to unify, in case the
7174 explicit args will completely resolve the templates in question. */
7176 tree expl_subargs
= TREE_OPERAND (arg
, 1);
7177 arg
= TREE_OPERAND (arg
, 0);
7179 for (; arg
; arg
= OVL_NEXT (arg
))
7181 tree fn
= OVL_CURRENT (arg
);
7184 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
7187 subargs
= get_bindings_overload (fn
, DECL_RESULT (fn
), expl_subargs
);
7190 elem
= tsubst (TREE_TYPE (fn
), subargs
, NULL_TREE
);
7191 good
+= try_one_overload (tparms
, targs
, tempargs
, parm
, elem
,
7192 strict
, sub_strict
, explicit_mask
);
7196 else if (TREE_CODE (arg
) == OVERLOAD
)
7198 for (; arg
; arg
= OVL_NEXT (arg
))
7199 good
+= try_one_overload (tparms
, targs
, tempargs
, parm
,
7200 TREE_TYPE (OVL_CURRENT (arg
)),
7201 strict
, sub_strict
, explicit_mask
);
7204 my_friendly_abort (981006);
7206 /* [temp.deduct.type] A template-argument can be deduced from a pointer
7207 to function or pointer to member function argument if the set of
7208 overloaded functions does not contain function templates and at most
7209 one of a set of overloaded functions provides a unique match.
7211 So if we found multiple possibilities, we return success but don't
7216 int i
= TREE_VEC_LENGTH (targs
);
7218 if (TREE_VEC_ELT (tempargs
, i
))
7219 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (tempargs
, i
);
7227 /* Subroutine of resolve_overloaded_unification; does deduction for a single
7228 overload. Fills TARGS with any deduced arguments, or error_mark_node if
7229 different overloads deduce different arguments for a given parm.
7230 Returns 1 on success. */
7233 try_one_overload (tparms
, orig_targs
, targs
, parm
, arg
, strict
,
7234 sub_strict
, explicit_mask
)
7235 tree tparms
, orig_targs
, targs
, parm
, arg
;
7236 unification_kind_t strict
;
7244 /* [temp.deduct.type] A template-argument can be deduced from a pointer
7245 to function or pointer to member function argument if the set of
7246 overloaded functions does not contain function templates and at most
7247 one of a set of overloaded functions provides a unique match.
7249 So if this is a template, just return success. */
7251 if (uses_template_parms (arg
))
7254 maybe_adjust_types_for_deduction (strict
, &parm
, &arg
);
7256 /* We don't copy orig_targs for this because if we have already deduced
7257 some template args from previous args, unify would complain when we
7258 try to deduce a template parameter for the same argument, even though
7259 there isn't really a conflict. */
7260 nargs
= TREE_VEC_LENGTH (targs
);
7261 tempargs
= make_scratch_vec (nargs
);
7263 if (unify (tparms
, tempargs
, parm
, arg
, sub_strict
, explicit_mask
) != 0)
7266 /* First make sure we didn't deduce anything that conflicts with
7267 explicitly specified args. */
7268 for (i
= nargs
; i
--; )
7270 tree elt
= TREE_VEC_ELT (tempargs
, i
);
7271 tree oldelt
= TREE_VEC_ELT (orig_targs
, i
);
7273 if (elt
== NULL_TREE
)
7275 else if (uses_template_parms (elt
))
7277 /* Since we're unifying against ourselves, we will fill in template
7278 args used in the function parm list with our own template parms.
7280 TREE_VEC_ELT (tempargs
, i
) = NULL_TREE
;
7283 else if (oldelt
&& ! template_args_equal (oldelt
, elt
))
7287 for (i
= nargs
; i
--; )
7289 tree elt
= TREE_VEC_ELT (tempargs
, i
);
7292 TREE_VEC_ELT (targs
, i
) = elt
;
7298 /* Returns the level of DECL, which declares a template parameter. */
7301 template_decl_level (decl
)
7304 switch (TREE_CODE (decl
))
7308 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl
));
7311 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl
));
7314 my_friendly_abort (0);
7319 /* Decide whether ARG can be unified with PARM, considering only the
7320 cv-qualifiers of each type, given STRICT as documented for unify.
7321 Returns non-zero iff the unification is OK on that basis.*/
7324 check_cv_quals_for_unify (strict
, arg
, parm
)
7329 return !((!(strict
& UNIFY_ALLOW_MORE_CV_QUAL
)
7330 && !at_least_as_qualified_p (arg
, parm
))
7331 || (!(strict
& UNIFY_ALLOW_LESS_CV_QUAL
)
7332 && (!at_least_as_qualified_p (parm
, arg
))));
7335 /* Takes parameters as for type_unification. Returns 0 if the
7336 type deduction suceeds, 1 otherwise. The parameter STRICT is a
7337 bitwise or of the following flags:
7340 Require an exact match between PARM and ARG.
7341 UNIFY_ALLOW_MORE_CV_QUAL:
7342 Allow the deduced ARG to be more cv-qualified than ARG.
7343 UNIFY_ALLOW_LESS_CV_QUAL:
7344 Allow the deduced ARG to be less cv-qualified than ARG.
7345 UNIFY_ALLOW_DERIVED:
7346 Allow the deduced ARG to be a template base class of ARG,
7347 or a pointer to a template base class of the type pointed to by
7349 UNIFY_ALLOW_INTEGER:
7350 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
7351 case for more information. */
7354 unify (tparms
, targs
, parm
, arg
, strict
, explicit_mask
)
7355 tree tparms
, targs
, parm
, arg
;
7363 /* I don't think this will do the right thing with respect to types.
7364 But the only case I've seen it in so far has been array bounds, where
7365 signedness is the only information lost, and I think that will be
7367 while (TREE_CODE (parm
) == NOP_EXPR
)
7368 parm
= TREE_OPERAND (parm
, 0);
7370 if (arg
== error_mark_node
)
7372 if (arg
== unknown_type_node
)
7373 /* We can't deduce anything from this, but we might get all the
7374 template args from other function args. */
7377 /* If PARM uses template parameters, then we can't bail out here,
7378 even if ARG == PARM, since we won't record unifications for the
7379 template parameters. We might need them if we're trying to
7380 figure out which of two things is more specialized. */
7381 if (arg
== parm
&& !uses_template_parms (parm
))
7384 /* Immediately reject some pairs that won't unify because of
7385 cv-qualification mismatches. */
7386 if (TREE_CODE (arg
) == TREE_CODE (parm
)
7387 && TREE_CODE_CLASS (TREE_CODE (arg
)) == 't'
7388 /* We check the cv-qualifiers when unifying with template type
7389 parameters below. We want to allow ARG `const T' to unify with
7390 PARM `T' for example, when computing which of two templates
7391 is more specialized, for example. */
7392 && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
7393 && !check_cv_quals_for_unify (strict
, arg
, parm
))
7396 switch (TREE_CODE (parm
))
7399 /* In a type which contains a nested-name-specifier, template
7400 argument values cannot be deduced for template parameters used
7401 within the nested-name-specifier. */
7404 case TEMPLATE_TYPE_PARM
:
7405 case TEMPLATE_TEMPLATE_PARM
:
7406 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
7408 if (TEMPLATE_TYPE_LEVEL (parm
)
7409 != template_decl_level (tparm
))
7410 /* The PARM is not one we're trying to unify. Just check
7411 to see if it matches ARG. */
7412 return (TREE_CODE (arg
) == TREE_CODE (parm
)
7413 && same_type_p (parm
, arg
)) ? 0 : 1;
7414 idx
= TEMPLATE_TYPE_IDX (parm
);
7415 targ
= TREE_VEC_ELT (targs
, idx
);
7416 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, idx
));
7418 /* Check for mixed types and values. */
7419 if ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
7420 && TREE_CODE (tparm
) != TYPE_DECL
)
7421 || (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
7422 && TREE_CODE (tparm
) != TEMPLATE_DECL
))
7425 if (!strict
&& targ
!= NULL_TREE
7426 && explicit_mask
&& explicit_mask
[idx
])
7427 /* An explicit template argument. Don't even try to match
7428 here; the overload resolution code will manage check to
7429 see whether the call is legal. */
7432 if (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
7434 if (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm
))
7436 /* We arrive here when PARM does not involve template
7439 /* ARG must be constructed from a template class. */
7440 if (TREE_CODE (arg
) != RECORD_TYPE
|| !CLASSTYPE_TEMPLATE_INFO (arg
))
7444 tree parmtmpl
= TYPE_TI_TEMPLATE (parm
);
7445 tree parmvec
= TYPE_TI_ARGS (parm
);
7446 tree argvec
= CLASSTYPE_TI_ARGS (arg
);
7448 = DECL_INNERMOST_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (arg
));
7451 /* The parameter and argument roles have to be switched here
7452 in order to handle default arguments properly. For example,
7453 template<template <class> class TT> void f(TT<int>)
7454 should be able to accept vector<int> which comes from
7455 template <class T, class Allocator = allocator>
7458 if (coerce_template_parms (argtmplvec
, parmvec
, parmtmpl
, 1, 1)
7462 /* Deduce arguments T, i from TT<T> or TT<i>. */
7463 for (i
= 0; i
< TREE_VEC_LENGTH (parmvec
); ++i
)
7465 tree t
= TREE_VEC_ELT (parmvec
, i
);
7466 if (TREE_CODE (t
) != TEMPLATE_TYPE_PARM
7467 && TREE_CODE (t
) != TEMPLATE_TEMPLATE_PARM
7468 && TREE_CODE (t
) != TEMPLATE_PARM_INDEX
)
7471 /* This argument can be deduced. */
7473 if (unify (tparms
, targs
, t
,
7474 TREE_VEC_ELT (argvec
, i
),
7475 UNIFY_ALLOW_NONE
, explicit_mask
))
7479 arg
= CLASSTYPE_TI_TEMPLATE (arg
);
7484 /* If PARM is `const T' and ARG is only `int', we don't have
7485 a match unless we are allowing additional qualification.
7486 If ARG is `const int' and PARM is just `T' that's OK;
7487 that binds `const int' to `T'. */
7488 if (!check_cv_quals_for_unify (strict
| UNIFY_ALLOW_LESS_CV_QUAL
,
7492 /* Consider the case where ARG is `const volatile int' and
7493 PARM is `const T'. Then, T should be `volatile int'. */
7495 cp_build_qualified_type (arg
,
7497 & ~CP_TYPE_QUALS (parm
));
7500 /* Simple cases: Value already set, does match or doesn't. */
7501 if (targ
!= NULL_TREE
7502 && (same_type_p (targ
, arg
)
7503 || (explicit_mask
&& explicit_mask
[idx
])))
7507 TREE_VEC_ELT (targs
, idx
) = arg
;
7510 case TEMPLATE_PARM_INDEX
:
7511 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
7513 if (TEMPLATE_PARM_LEVEL (parm
)
7514 != template_decl_level (tparm
))
7515 /* The PARM is not one we're trying to unify. Just check
7516 to see if it matches ARG. */
7517 return (TREE_CODE (arg
) == TREE_CODE (parm
)
7518 && cp_tree_equal (parm
, arg
) > 0) ? 0 : 1;
7520 idx
= TEMPLATE_PARM_IDX (parm
);
7521 targ
= TREE_VEC_ELT (targs
, idx
);
7525 int i
= (cp_tree_equal (targ
, arg
) > 0);
7531 my_friendly_abort (42);
7534 /* [temp.deduct.type] If, in the declaration of a function template
7535 with a non-type template-parameter, the non-type
7536 template-parameter is used in an expression in the function
7537 parameter-list and, if the corresponding template-argument is
7538 deduced, the template-argument type shall match the type of the
7539 template-parameter exactly, except that a template-argument
7540 deduced from an array bound may be of any integral type. */
7541 if (same_type_p (TREE_TYPE (arg
), TREE_TYPE (parm
)))
7543 else if ((strict
& UNIFY_ALLOW_INTEGER
)
7544 && (TREE_CODE (TREE_TYPE (parm
)) == INTEGER_TYPE
7545 || TREE_CODE (TREE_TYPE (parm
)) == BOOLEAN_TYPE
))
7550 TREE_VEC_ELT (targs
, idx
) = copy_to_permanent (arg
);
7557 if (TREE_CODE (arg
) == RECORD_TYPE
&& TYPE_PTRMEMFUNC_FLAG (arg
))
7558 return (unify (tparms
, targs
, parm
,
7559 TYPE_PTRMEMFUNC_FN_TYPE (arg
), strict
,
7562 if (TREE_CODE (arg
) != POINTER_TYPE
)
7565 /* [temp.deduct.call]
7567 A can be another pointer or pointer to member type that can
7568 be converted to the deduced A via a qualification
7569 conversion (_conv.qual_).
7571 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
7572 This will allow for additional cv-qualification of the
7573 pointed-to types if appropriate. In general, this is a bit
7574 too generous; we are only supposed to allow qualification
7575 conversions and this method will allow an ARG of char** and
7576 a deduced ARG of const char**. However, overload
7577 resolution will subsequently invalidate the candidate, so
7578 this is probably OK. */
7579 sub_strict
= strict
;
7581 if (TREE_CODE (TREE_TYPE (arg
)) != RECORD_TYPE
7582 || TYPE_PTRMEMFUNC_FLAG (TREE_TYPE (arg
)))
7583 /* The derived-to-base conversion only persists through one
7584 level of pointers. */
7585 sub_strict
&= ~UNIFY_ALLOW_DERIVED
;
7587 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE
7588 (arg
), sub_strict
, explicit_mask
);
7591 case REFERENCE_TYPE
:
7592 if (TREE_CODE (arg
) != REFERENCE_TYPE
)
7594 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
7595 UNIFY_ALLOW_NONE
, explicit_mask
);
7598 if (TREE_CODE (arg
) != ARRAY_TYPE
)
7600 if ((TYPE_DOMAIN (parm
) == NULL_TREE
)
7601 != (TYPE_DOMAIN (arg
) == NULL_TREE
))
7603 if (TYPE_DOMAIN (parm
) != NULL_TREE
7604 && unify (tparms
, targs
, TYPE_DOMAIN (parm
),
7605 TYPE_DOMAIN (arg
), UNIFY_ALLOW_NONE
, explicit_mask
) != 0)
7607 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
7608 UNIFY_ALLOW_NONE
, explicit_mask
);
7615 if (TREE_CODE (arg
) != TREE_CODE (parm
))
7618 if (TREE_CODE (parm
) == INTEGER_TYPE
7619 && TREE_CODE (TYPE_MAX_VALUE (parm
)) != INTEGER_CST
)
7621 if (TYPE_MIN_VALUE (parm
) && TYPE_MIN_VALUE (arg
)
7622 && unify (tparms
, targs
, TYPE_MIN_VALUE (parm
),
7623 TYPE_MIN_VALUE (arg
), UNIFY_ALLOW_INTEGER
,
7626 if (TYPE_MAX_VALUE (parm
) && TYPE_MAX_VALUE (arg
)
7627 && unify (tparms
, targs
, TYPE_MAX_VALUE (parm
),
7628 TYPE_MAX_VALUE (arg
), UNIFY_ALLOW_INTEGER
,
7632 /* We use the TYPE_MAIN_VARIANT since we have already
7633 checked cv-qualification at the top of the
7635 else if (!same_type_p (TYPE_MAIN_VARIANT (arg
),
7636 TYPE_MAIN_VARIANT (parm
)))
7639 /* As far as unification is concerned, this wins. Later checks
7640 will invalidate it if necessary. */
7643 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
7644 /* Type INTEGER_CST can come from ordinary constant template args. */
7646 while (TREE_CODE (arg
) == NOP_EXPR
)
7647 arg
= TREE_OPERAND (arg
, 0);
7649 if (TREE_CODE (arg
) != INTEGER_CST
)
7651 return !tree_int_cst_equal (parm
, arg
);
7656 if (TREE_CODE (arg
) != TREE_VEC
)
7658 if (TREE_VEC_LENGTH (parm
) != TREE_VEC_LENGTH (arg
))
7660 for (i
= TREE_VEC_LENGTH (parm
) - 1; i
>= 0; i
--)
7661 if (unify (tparms
, targs
,
7662 TREE_VEC_ELT (parm
, i
), TREE_VEC_ELT (arg
, i
),
7663 UNIFY_ALLOW_NONE
, explicit_mask
))
7670 if (TYPE_PTRMEMFUNC_FLAG (parm
))
7671 return unify (tparms
, targs
, TYPE_PTRMEMFUNC_FN_TYPE (parm
),
7672 arg
, strict
, explicit_mask
);
7674 if (TREE_CODE (arg
) != TREE_CODE (parm
))
7677 if (CLASSTYPE_TEMPLATE_INFO (parm
) && uses_template_parms (parm
))
7680 if (strict
& UNIFY_ALLOW_DERIVED
)
7681 /* [temp.deduct.call]
7683 If P is a class, and P has the form template-id, then A
7684 can be a derived class of the deduced A. Likewise, if
7685 P is a pointer to a class of the form template-id, A
7686 can be a pointer to a derived class pointed to by the
7689 The call to get_template_base also handles the case
7690 where PARM and ARG are the same type, i.e., where no
7691 derivation is involved. */
7692 t
= get_template_base (CLASSTYPE_TI_TEMPLATE (parm
), arg
);
7693 else if (CLASSTYPE_TEMPLATE_INFO (arg
)
7694 && (CLASSTYPE_TI_TEMPLATE (parm
)
7695 == CLASSTYPE_TI_TEMPLATE (arg
)))
7696 /* Perhaps PARM is something like S<U> and ARG is S<int>.
7697 Then, we should unify `int' and `U'. */
7700 if (! t
|| t
== error_mark_node
)
7703 return unify (tparms
, targs
, CLASSTYPE_TI_ARGS (parm
),
7704 CLASSTYPE_TI_ARGS (t
), UNIFY_ALLOW_NONE
,
7707 else if (!same_type_p (TYPE_MAIN_VARIANT (parm
),
7708 TYPE_MAIN_VARIANT (arg
)))
7714 if (TREE_CODE (arg
) != TREE_CODE (parm
))
7717 if (unify (tparms
, targs
, TREE_TYPE (parm
),
7718 TREE_TYPE (arg
), UNIFY_ALLOW_NONE
, explicit_mask
))
7720 return type_unification_real (tparms
, targs
, TYPE_ARG_TYPES (parm
),
7721 TYPE_ARG_TYPES (arg
), 1,
7722 DEDUCE_EXACT
, 0, explicit_mask
);
7725 if (TREE_CODE (arg
) != OFFSET_TYPE
)
7727 if (unify (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
7728 TYPE_OFFSET_BASETYPE (arg
), UNIFY_ALLOW_NONE
, explicit_mask
))
7730 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
7731 strict
, explicit_mask
);
7734 if (arg
!= decl_constant_value (parm
))
7739 /* Matched cases are handled by the ARG == PARM test above. */
7743 if (TREE_CODE (TREE_OPERAND (parm
, 1)) == INTEGER_CST
)
7745 /* We handle this case specially, since it comes up with
7746 arrays. In particular, something like:
7748 template <int N> void f(int (&x)[N]);
7750 Here, we are trying to unify the range type, which
7751 looks like [0 ... (N - 1)]. */
7753 t1
= TREE_OPERAND (parm
, 0);
7754 t2
= TREE_OPERAND (parm
, 1);
7756 /* Should this be a regular fold? */
7757 t
= maybe_fold_nontype_arg (build (PLUS_EXPR
,
7761 return unify (tparms
, targs
, t1
, t
, strict
, explicit_mask
);
7763 /* else fall through */
7766 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (parm
))))
7768 /* We're looking at an expression. This can happen with
7772 void foo(S<I>, S<I + 2>);
7774 If the call looked like:
7776 foo(S<2>(), S<4>());
7778 we would have already matched `I' with `2'. Now, we'd
7779 like to know if `4' matches `I + 2'. So, we substitute
7780 into that expression, and fold constants, in the hope of
7783 maybe_fold_nontype_arg (tsubst_expr (parm
, targs
, NULL_TREE
));
7784 tree a
= maybe_fold_nontype_arg (arg
);
7786 if (!IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (t
))))
7787 /* Good, we mangaged to simplify the exression. */
7788 return unify (tparms
, targs
, t
, a
, UNIFY_ALLOW_NONE
,
7791 /* Bad, we couldn't simplify this. Assume it doesn't
7796 sorry ("use of `%s' in template type unification",
7797 tree_code_name
[(int) TREE_CODE (parm
)]);
7803 /* Called if RESULT is explicitly instantiated, or is a member of an
7804 explicitly instantiated class, or if using -frepo and the
7805 instantiation of RESULT has been assigned to this file. */
7808 mark_decl_instantiated (result
, extern_p
)
7812 if (TREE_CODE (result
) != FUNCTION_DECL
)
7813 /* The TREE_PUBLIC flag for function declarations will have been
7814 set correctly by tsubst. */
7815 TREE_PUBLIC (result
) = 1;
7819 DECL_INTERFACE_KNOWN (result
) = 1;
7820 DECL_NOT_REALLY_EXTERN (result
) = 1;
7822 /* Always make artificials weak. */
7823 if (DECL_ARTIFICIAL (result
) && flag_weak
)
7824 comdat_linkage (result
);
7825 /* For WIN32 we also want to put explicit instantiations in
7826 linkonce sections. */
7827 else if (TREE_PUBLIC (result
))
7828 maybe_make_one_only (result
);
7830 else if (TREE_CODE (result
) == FUNCTION_DECL
)
7831 mark_inline_for_output (result
);
7834 /* Given two function templates PAT1 and PAT2, and explicit template
7835 arguments EXPLICIT_ARGS return:
7837 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
7838 -1 if PAT2 is more specialized than PAT1.
7839 0 if neither is more specialized. */
7842 more_specialized (pat1
, pat2
, explicit_args
)
7843 tree pat1
, pat2
, explicit_args
;
7848 targs
= get_bindings_overload (pat1
, pat2
, explicit_args
);
7852 targs
= get_bindings_overload (pat2
, pat1
, explicit_args
);
7859 /* Given two class template specialization list nodes PAT1 and PAT2, return:
7861 1 if PAT1 is more specialized than PAT2 as described in [temp.class.order].
7862 -1 if PAT2 is more specialized than PAT1.
7863 0 if neither is more specialized. */
7866 more_specialized_class (pat1
, pat2
)
7872 targs
= get_class_bindings (TREE_VALUE (pat1
), TREE_PURPOSE (pat1
),
7873 TREE_PURPOSE (pat2
));
7877 targs
= get_class_bindings (TREE_VALUE (pat2
), TREE_PURPOSE (pat2
),
7878 TREE_PURPOSE (pat1
));
7885 /* Return the template arguments that will produce the function signature
7886 DECL from the function template FN, with the explicit template
7887 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is 1, the return type must
7891 get_bindings_real (fn
, decl
, explicit_args
, check_rettype
)
7892 tree fn
, decl
, explicit_args
;
7895 int ntparms
= DECL_NTPARMS (fn
);
7896 tree targs
= make_scratch_vec (ntparms
);
7897 tree decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
7898 tree extra_fn_arg
= NULL_TREE
;
7901 if (DECL_STATIC_FUNCTION_P (fn
)
7902 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
7904 /* Sometimes we are trying to figure out what's being
7905 specialized by a declaration that looks like a method, and it
7906 turns out to be a static member function. */
7907 if (CLASSTYPE_TEMPLATE_INFO (DECL_REAL_CONTEXT (fn
))
7908 && !is_member_template (fn
))
7909 /* The natural thing to do here seems to be to remove the
7910 spurious `this' parameter from the DECL, but that prevents
7911 unification from making use of the class type. So,
7912 instead, we have fn_type_unification add to the parameters
7914 extra_fn_arg
= build_pointer_type (DECL_REAL_CONTEXT (fn
));
7916 /* In this case, though, adding the extra_fn_arg can confuse
7917 things, so we remove from decl_arg_types instead. */
7918 decl_arg_types
= TREE_CHAIN (decl_arg_types
);
7921 i
= fn_type_unification (fn
, explicit_args
, targs
,
7923 TREE_TYPE (TREE_TYPE (decl
)),
7932 /* Check to see that the resulting return type is also OK. */
7933 tree t
= tsubst (TREE_TYPE (TREE_TYPE (fn
)), targs
,
7936 if (!same_type_p (t
, TREE_TYPE (TREE_TYPE (decl
))))
7943 /* For most uses, we want to check the return type. */
7946 get_bindings (fn
, decl
, explicit_args
)
7947 tree fn
, decl
, explicit_args
;
7949 return get_bindings_real (fn
, decl
, explicit_args
, 1);
7952 /* But for more_specialized, we only care about the parameter types. */
7955 get_bindings_overload (fn
, decl
, explicit_args
)
7956 tree fn
, decl
, explicit_args
;
7958 return get_bindings_real (fn
, decl
, explicit_args
, 0);
7961 /* Return the innermost template arguments that, when applied to a
7962 template specialization whose innermost template parameters are
7963 TPARMS, and whose specialization arguments are ARGS, yield the
7966 For example, suppose we have:
7968 template <class T, class U> struct S {};
7969 template <class T> struct S<T*, int> {};
7971 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
7972 {T}, the PARMS will be {T*, int} and the ARGS will be {double*,
7973 int}. The resulting vector will be {double}, indicating that `T'
7974 is bound to `double'. */
7977 get_class_bindings (tparms
, parms
, args
)
7978 tree tparms
, parms
, args
;
7980 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
7981 tree vec
= make_temp_vec (ntparms
);
7983 args
= innermost_args (args
);
7985 for (i
= 0; i
< TREE_VEC_LENGTH (parms
); ++i
)
7987 switch (unify (tparms
, vec
,
7988 TREE_VEC_ELT (parms
, i
), TREE_VEC_ELT (args
, i
),
7989 UNIFY_ALLOW_NONE
, 0))
7998 for (i
= 0; i
< ntparms
; ++i
)
7999 if (! TREE_VEC_ELT (vec
, i
))
8005 /* In INSTANTIATIONS is a list of <INSTANTIATION, TEMPLATE> pairs.
8006 Pick the most specialized template, and return the corresponding
8007 instantiation, or if there is no corresponding instantiation, the
8008 template itself. EXPLICIT_ARGS is any template arguments explicity
8009 mentioned in a template-id. If there is no most specialized
8010 tempalte, error_mark_node is returned. If there are no templates
8011 at all, NULL_TREE is returned. */
8014 most_specialized_instantiation (instantiations
, explicit_args
)
8015 tree instantiations
;
8021 if (!instantiations
)
8024 champ
= instantiations
;
8025 for (fn
= TREE_CHAIN (instantiations
); fn
; fn
= TREE_CHAIN (fn
))
8027 fate
= more_specialized (TREE_VALUE (champ
),
8028 TREE_VALUE (fn
), explicit_args
);
8035 fn
= TREE_CHAIN (fn
);
8037 return error_mark_node
;
8043 for (fn
= instantiations
; fn
&& fn
!= champ
; fn
= TREE_CHAIN (fn
))
8045 fate
= more_specialized (TREE_VALUE (champ
),
8046 TREE_VALUE (fn
), explicit_args
);
8048 return error_mark_node
;
8051 return TREE_PURPOSE (champ
) ? TREE_PURPOSE (champ
) : TREE_VALUE (champ
);
8054 /* Return the most specialized of the list of templates in FNS that can
8055 produce an instantiation matching DECL, given the explicit template
8056 arguments EXPLICIT_ARGS. */
8059 most_specialized (fns
, decl
, explicit_args
)
8060 tree fns
, decl
, explicit_args
;
8062 tree candidates
= NULL_TREE
;
8065 for (fn
= fns
; fn
; fn
= TREE_CHAIN (fn
))
8067 tree candidate
= TREE_VALUE (fn
);
8069 args
= get_bindings (candidate
, decl
, explicit_args
);
8071 candidates
= scratch_tree_cons (NULL_TREE
, candidate
,
8075 return most_specialized_instantiation (candidates
, explicit_args
);
8078 /* If DECL is a specialization of some template, return the most
8079 general such template. For example, given:
8081 template <class T> struct S { template <class U> void f(U); };
8083 if TMPL is `template <class U> void S<int>::f(U)' this will return
8084 the full template. This function will not trace past partial
8085 specializations, however. For example, given in addition:
8087 template <class T> struct S<T*> { template <class U> void f(U); };
8089 if TMPL is `template <class U> void S<int*>::f(U)' this will return
8090 `template <class T> template <class U> S<T*>::f(U)'. */
8093 most_general_template (decl
)
8096 while (DECL_TEMPLATE_INFO (decl
))
8097 decl
= DECL_TI_TEMPLATE (decl
);
8102 /* Return the most specialized of the class template specializations
8103 of TMPL which can produce an instantiation matching ARGS, or
8104 error_mark_node if the choice is ambiguous. */
8107 most_specialized_class (tmpl
, args
)
8111 tree list
= NULL_TREE
;
8116 tmpl
= most_general_template (tmpl
);
8117 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
); t
; t
= TREE_CHAIN (t
))
8120 = get_class_bindings (TREE_VALUE (t
), TREE_PURPOSE (t
), args
);
8123 list
= decl_tree_cons (TREE_PURPOSE (t
), TREE_VALUE (t
), list
);
8124 TREE_TYPE (list
) = TREE_TYPE (t
);
8134 for (; t
; t
= TREE_CHAIN (t
))
8136 fate
= more_specialized_class (champ
, t
);
8145 return error_mark_node
;
8151 for (t
= list
; t
&& t
!= champ
; t
= TREE_CHAIN (t
))
8153 fate
= more_specialized_class (champ
, t
);
8155 return error_mark_node
;
8161 /* called from the parser. */
8164 do_decl_instantiation (declspecs
, declarator
, storage
)
8165 tree declspecs
, declarator
, storage
;
8167 tree decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, 0, NULL_TREE
);
8168 tree result
= NULL_TREE
;
8171 if (! DECL_LANG_SPECIFIC (decl
))
8173 cp_error ("explicit instantiation of non-template `%#D'", decl
);
8176 else if (TREE_CODE (decl
) == VAR_DECL
)
8178 /* There is an asymmetry here in the way VAR_DECLs and
8179 FUNCTION_DECLs are handled by grokdeclarator. In the case of
8180 the latter, the DECL we get back will be marked as a
8181 template instantiation, and the appropriate
8182 DECL_TEMPLATE_INFO will be set up. This does not happen for
8183 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
8184 should handle VAR_DECLs as it currently handles
8186 result
= lookup_field (DECL_CONTEXT (decl
), DECL_NAME (decl
), 0, 0);
8187 if (result
&& TREE_CODE (result
) != VAR_DECL
)
8189 cp_error ("no matching template for `%D' found", result
);
8193 else if (TREE_CODE (decl
) != FUNCTION_DECL
)
8195 cp_error ("explicit instantiation of `%#D'", decl
);
8201 /* Check for various error cases. Note that if the explicit
8202 instantiation is legal the RESULT will currently be marked as an
8203 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
8204 until we get here. */
8206 if (DECL_TEMPLATE_SPECIALIZATION (result
))
8210 No program shall both explicitly instantiate and explicitly
8211 specialize a template. */
8212 cp_error ("explicit instantiation of `%#D' after", result
);
8213 cp_error_at ("explicit specialization here", result
);
8216 else if (DECL_EXPLICIT_INSTANTIATION (result
))
8220 No program shall explicitly instantiate any template more
8223 We check DECL_INTERFACE_KNOWN so as not to complain when the
8224 first instantiation was `extern' and the second is not, and
8225 EXTERN_P for the opposite case. */
8226 if (DECL_INTERFACE_KNOWN (result
) && !extern_p
)
8227 cp_error ("duplicate explicit instantiation of `%#D'", result
);
8229 /* If we've already instantiated the template, just return now. */
8230 if (DECL_INTERFACE_KNOWN (result
))
8233 else if (!DECL_IMPLICIT_INSTANTIATION (result
))
8235 cp_error ("no matching template for `%D' found", result
);
8238 else if (!DECL_TEMPLATE_INFO (result
))
8240 cp_pedwarn ("explicit instantiation of non-template `%#D'", result
);
8244 if (flag_external_templates
)
8247 if (storage
== NULL_TREE
)
8249 else if (storage
== ridpointers
[(int) RID_EXTERN
])
8252 cp_pedwarn ("ANSI C++ forbids the use of `extern' on explicit instantiations");
8256 cp_error ("storage class `%D' applied to template instantiation",
8259 SET_DECL_EXPLICIT_INSTANTIATION (result
);
8260 mark_decl_instantiated (result
, extern_p
);
8261 repo_template_instantiated (result
, extern_p
);
8263 instantiate_decl (result
);
8267 mark_class_instantiated (t
, extern_p
)
8271 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t
);
8272 SET_CLASSTYPE_INTERFACE_KNOWN (t
);
8273 CLASSTYPE_INTERFACE_ONLY (t
) = extern_p
;
8274 CLASSTYPE_VTABLE_NEEDS_WRITING (t
) = ! extern_p
;
8275 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t
)) = extern_p
;
8278 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
8279 rest_of_type_compilation (t
, 1);
8284 do_type_instantiation (t
, storage
)
8291 if (TREE_CODE (t
) == TYPE_DECL
)
8294 if (! CLASS_TYPE_P (t
) || ! CLASSTYPE_TEMPLATE_INFO (t
))
8296 cp_error ("explicit instantiation of non-template type `%T'", t
);
8302 /* With -fexternal-templates, explicit instantiations are treated the same
8303 as implicit ones. */
8304 if (flag_external_templates
)
8307 if (TYPE_SIZE (t
) == NULL_TREE
)
8309 cp_error ("explicit instantiation of `%#T' before definition of template",
8314 if (storage
!= NULL_TREE
)
8317 cp_pedwarn("ANSI C++ forbids the use of `%s' on explicit instantiations",
8318 IDENTIFIER_POINTER (storage
));
8320 if (storage
== ridpointers
[(int) RID_INLINE
])
8322 else if (storage
== ridpointers
[(int) RID_EXTERN
])
8324 else if (storage
== ridpointers
[(int) RID_STATIC
])
8328 cp_error ("storage class `%D' applied to template instantiation",
8334 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
8338 No program shall both explicitly instantiate and explicitly
8339 specialize a template. */
8340 cp_error ("explicit instantiation of `%#T' after", t
);
8341 cp_error_at ("explicit specialization here", t
);
8344 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t
))
8348 No program shall explicitly instantiate any template more
8351 If CLASSTYPE_INTERFACE_ONLY, then the first explicit
8352 instantiation was `extern', and if EXTERN_P then the second
8353 is. Both cases are OK. */
8354 if (!CLASSTYPE_INTERFACE_ONLY (t
) && !extern_p
)
8355 cp_error ("duplicate explicit instantiation of `%#T'", t
);
8357 /* If we've already instantiated the template, just return now. */
8358 if (!CLASSTYPE_INTERFACE_ONLY (t
))
8362 mark_class_instantiated (t
, extern_p
);
8363 repo_template_instantiated (t
, extern_p
);
8371 /* In contrast to implicit instantiation, where only the
8372 declarations, and not the definitions, of members are
8373 instantiated, we have here:
8377 The explicit instantiation of a class template specialization
8378 implies the instantiation of all of its members not
8379 previously explicitly specialized in the translation unit
8380 containing the explicit instantiation.
8382 Of course, we can't instantiate member template classes, since
8383 we don't have any arguments for them. Note that the standard
8384 is unclear on whether the instatiation of the members are
8385 *explicit* instantiations or not. We choose to be generous,
8386 and not set DECL_EXPLICIT_INSTANTIATION. Therefore, we allow
8387 the explicit instantiation of a class where some of the members
8388 have no definition in the current translation unit. */
8391 for (tmp
= TYPE_METHODS (t
); tmp
; tmp
= TREE_CHAIN (tmp
))
8392 if (TREE_CODE (tmp
) == FUNCTION_DECL
8393 && DECL_TEMPLATE_INSTANTIATION (tmp
))
8395 mark_decl_instantiated (tmp
, extern_p
);
8396 repo_template_instantiated (tmp
, extern_p
);
8398 instantiate_decl (tmp
);
8401 for (tmp
= TYPE_FIELDS (t
); tmp
; tmp
= TREE_CHAIN (tmp
))
8402 if (TREE_CODE (tmp
) == VAR_DECL
&& DECL_TEMPLATE_INSTANTIATION (tmp
))
8404 mark_decl_instantiated (tmp
, extern_p
);
8405 repo_template_instantiated (tmp
, extern_p
);
8407 instantiate_decl (tmp
);
8410 for (tmp
= CLASSTYPE_TAGS (t
); tmp
; tmp
= TREE_CHAIN (tmp
))
8411 if (IS_AGGR_TYPE (TREE_VALUE (tmp
))
8412 && !uses_template_parms (CLASSTYPE_TI_ARGS (TREE_VALUE (tmp
))))
8413 do_type_instantiation (TYPE_MAIN_DECL (TREE_VALUE (tmp
)), storage
);
8417 /* Given a function DECL, which is a specialization of TMPL, modify
8418 DECL to be a re-instantiation of TMPL with the same template
8419 arguments. TMPL should be the template into which tsubst'ing
8420 should occur for DECL, not the most general template.
8422 One reason for doing this is a scenario like this:
8425 void f(const T&, int i);
8427 void g() { f(3, 7); }
8430 void f(const T& t, const int i) { }
8432 Note that when the template is first instantiated, with
8433 instantiate_template, the resulting DECL will have no name for the
8434 first parameter, and the wrong type for the second. So, when we go
8435 to instantiate the DECL, we regenerate it. */
8438 regenerate_decl_from_template (decl
, tmpl
)
8448 args
= DECL_TI_ARGS (decl
);
8449 code_pattern
= DECL_TEMPLATE_RESULT (tmpl
);
8451 /* Unregister the specialization so that when we tsubst we will not
8452 just return DECL. We don't have to unregister DECL from TMPL
8453 because if would only be registered there if it were a partial
8454 instantiation of a specialization, which it isn't: it's a full
8456 gen_tmpl
= most_general_template (tmpl
);
8457 unregistered
= unregister_specialization (decl
, gen_tmpl
);
8459 /* If the DECL was not unregistered then something peculiar is
8460 happening: we created a specialization but did not call
8461 register_specialization for it. */
8462 my_friendly_assert (unregistered
, 0);
8464 if (TREE_CODE (decl
) == VAR_DECL
)
8465 /* Make sure that we can see identifiers, and compute access
8466 correctly, for the class members used in the declaration of
8467 this static variable. */
8468 pushclass (DECL_CONTEXT (decl
), 2);
8470 /* Do the substitution to get the new declaration. */
8471 new_decl
= tsubst (code_pattern
, args
, NULL_TREE
);
8473 if (TREE_CODE (decl
) == VAR_DECL
)
8475 /* Set up DECL_INITIAL, since tsubst doesn't. */
8476 DECL_INITIAL (new_decl
) =
8477 tsubst_expr (DECL_INITIAL (code_pattern
), args
,
8478 DECL_TI_TEMPLATE (decl
));
8479 /* Pop the class context we pushed above. */
8483 if (TREE_CODE (decl
) == FUNCTION_DECL
)
8485 /* Convince duplicate_decls to use the DECL_ARGUMENTS from the
8487 DECL_INITIAL (new_decl
) = error_mark_node
;
8488 /* And don't complain about a duplicate definition. */
8489 DECL_INITIAL (decl
) = NULL_TREE
;
8492 /* The immediate parent of the new template is still whatever it was
8493 before, even though tsubst sets DECL_TI_TEMPLATE up as the most
8494 general template. We also reset the DECL_ASSEMBLER_NAME since
8495 tsubst always calculates the name as if the function in question
8496 were really a template instance, and sometimes, with friend
8497 functions, this is not so. See tsubst_friend_function for
8499 DECL_TI_TEMPLATE (new_decl
) = DECL_TI_TEMPLATE (decl
);
8500 DECL_ASSEMBLER_NAME (new_decl
) = DECL_ASSEMBLER_NAME (decl
);
8501 DECL_RTL (new_decl
) = DECL_RTL (decl
);
8503 /* Call duplicate decls to merge the old and new declarations. */
8504 duplicate_decls (new_decl
, decl
);
8506 /* Now, re-register the specialization. */
8507 register_specialization (decl
, gen_tmpl
, args
);
8510 /* Produce the definition of D, a _DECL generated from a template. */
8513 instantiate_decl (d
)
8516 tree tmpl
= DECL_TI_TEMPLATE (d
);
8517 tree args
= DECL_TI_ARGS (d
);
8522 int nested
= in_function_p ();
8523 int pattern_defined
;
8525 char *file
= input_filename
;
8527 /* This function should only be used to instantiate templates for
8528 functions and static member variables. */
8529 my_friendly_assert (TREE_CODE (d
) == FUNCTION_DECL
8530 || TREE_CODE (d
) == VAR_DECL
, 0);
8532 if (DECL_TEMPLATE_INSTANTIATED (d
))
8533 /* D has already been instantiated. It might seem reasonable to
8534 check whether or not D is an explict instantiation, and, if so,
8535 stop here. But when an explicit instantiation is deferred
8536 until the end of the compilation, DECL_EXPLICIT_INSTANTIATION
8537 is set, even though we still need to do the instantiation. */
8540 /* If we already have a specialization of this declaration, then
8541 there's no reason to instantiate it. Note that
8542 retrieve_specialization gives us both instantiations and
8543 specializations, so we must explicitly check
8544 DECL_TEMPLATE_SPECIALIZATION. */
8545 gen_tmpl
= most_general_template (tmpl
);
8546 spec
= retrieve_specialization (gen_tmpl
, args
);
8547 if (spec
!= NULL_TREE
&& DECL_TEMPLATE_SPECIALIZATION (spec
))
8550 /* This needs to happen before any tsubsting. */
8551 if (! push_tinst_level (d
))
8554 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
8555 for the instantiation. This is not always the most general
8556 template. Consider, for example:
8559 struct S { template <class U> void f();
8560 template <> void f<int>(); };
8562 and an instantiation of S<double>::f<int>. We want TD to be the
8563 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
8566 /* An instantiation cannot have a definition, so we need a
8567 more general template. */
8568 DECL_TEMPLATE_INSTANTIATION (td
)
8569 /* We must also deal with friend templates. Given:
8571 template <class T> struct S {
8572 template <class U> friend void f() {};
8575 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
8576 so far as the language is concerned, but that's still
8577 where we get the pattern for the instantiation from. On
8578 ther hand, if the definition comes outside the class, say:
8580 template <class T> struct S {
8581 template <class U> friend void f();
8583 template <class U> friend void f() {}
8585 we don't need to look any further. That's what the check for
8586 DECL_INITIAL is for. */
8587 || (TREE_CODE (d
) == FUNCTION_DECL
8588 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (td
)
8589 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (td
)));
8592 /* The present template, TD, should not be a definition. If it
8593 were a definition, we should be using it! Note that we
8594 cannot restructure the loop to just keep going until we find
8595 a template with a definition, since that might go too far if
8596 a specialization was declared, but not defined. */
8597 my_friendly_assert (!(TREE_CODE (d
) == VAR_DECL
8598 && !DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (td
))),
8601 /* Fetch the more general template. */
8602 td
= DECL_TI_TEMPLATE (td
);
8605 code_pattern
= DECL_TEMPLATE_RESULT (td
);
8607 if (TREE_CODE (d
) == FUNCTION_DECL
)
8608 pattern_defined
= (DECL_INITIAL (code_pattern
) != NULL_TREE
);
8610 pattern_defined
= ! DECL_IN_AGGR_P (code_pattern
);
8612 push_to_top_level ();
8613 lineno
= DECL_SOURCE_LINE (d
);
8614 input_filename
= DECL_SOURCE_FILE (d
);
8616 if (pattern_defined
)
8618 repo_template_used (d
);
8620 if (flag_external_templates
&& ! DECL_INTERFACE_KNOWN (d
))
8622 if (flag_alt_external_templates
)
8624 if (interface_unknown
)
8625 warn_if_unknown_interface (d
);
8627 else if (DECL_INTERFACE_KNOWN (code_pattern
))
8629 DECL_INTERFACE_KNOWN (d
) = 1;
8630 DECL_NOT_REALLY_EXTERN (d
) = ! DECL_EXTERNAL (code_pattern
);
8633 warn_if_unknown_interface (code_pattern
);
8637 import_export_decl (d
);
8640 /* Reject all external templates except inline functions. */
8641 if (DECL_INTERFACE_KNOWN (d
)
8642 && ! DECL_NOT_REALLY_EXTERN (d
)
8643 && ! (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_INLINE (d
)))
8646 if (TREE_CODE (d
) == VAR_DECL
8647 && TREE_READONLY (d
)
8648 && DECL_INITIAL (d
) == NULL_TREE
8649 && DECL_INITIAL (code_pattern
) != NULL_TREE
)
8650 /* We need to set up DECL_INITIAL regardless of pattern_defined if
8651 the variable is a static const initialized in the class body. */;
8652 else if (! pattern_defined
8653 || (! (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_INLINE (d
) && nested
)
8656 /* Defer all templates except inline functions used in another
8657 function. We restore the source position here because it's used
8658 by add_pending_template. */
8660 input_filename
= file
;
8662 if (at_eof
&& !pattern_defined
8663 && DECL_EXPLICIT_INSTANTIATION (d
))
8666 The definition of a non-exported function template, a
8667 non-exported member function template, or a non-exported
8668 member function or static data member of a class template
8669 shall be present in every translation unit in which it is
8670 explicitly instantiated. */
8671 cp_error ("explicit instantiation of `%D' but no definition available",
8674 add_pending_template (d
);
8678 regenerate_decl_from_template (d
, td
);
8679 DECL_TEMPLATE_INSTANTIATED (d
) = 1;
8681 /* We already set the file and line above. Reset them now in case
8682 they changed as a result of calling regenerate_decl_from_template. */
8683 lineno
= DECL_SOURCE_LINE (d
);
8684 input_filename
= DECL_SOURCE_FILE (d
);
8686 if (TREE_CODE (d
) == VAR_DECL
)
8688 DECL_IN_AGGR_P (d
) = 0;
8689 if (DECL_INTERFACE_KNOWN (d
))
8690 DECL_EXTERNAL (d
) = ! DECL_NOT_REALLY_EXTERN (d
);
8693 DECL_EXTERNAL (d
) = 1;
8694 DECL_NOT_REALLY_EXTERN (d
) = 1;
8696 cp_finish_decl (d
, DECL_INITIAL (d
), NULL_TREE
, 0, 0);
8698 else if (TREE_CODE (d
) == FUNCTION_DECL
)
8700 tree t
= DECL_SAVED_TREE (code_pattern
);
8702 start_function (NULL_TREE
, d
, NULL_TREE
, 1);
8703 store_parm_decls ();
8705 if (t
&& TREE_CODE (t
) == RETURN_INIT
)
8708 (TREE_OPERAND (t
, 0),
8709 tsubst_expr (TREE_OPERAND (t
, 1), args
, tmpl
));
8713 if (t
&& TREE_CODE (t
) == CTOR_INITIALIZER
)
8715 current_member_init_list
8716 = tsubst_expr_values (TREE_OPERAND (t
, 0), args
);
8717 current_base_init_list
8718 = tsubst_expr_values (TREE_OPERAND (t
, 1), args
);
8723 /* Always keep the BLOCK node associated with the outermost
8724 pair of curly braces of a function. These are needed
8725 for correct operation of dwarfout.c. */
8728 my_friendly_assert (TREE_CODE (t
) == COMPOUND_STMT
, 42);
8729 tsubst_expr (t
, args
, tmpl
);
8731 finish_function (lineno
, 0, nested
);
8736 input_filename
= file
;
8738 pop_from_top_level ();
8745 tsubst_expr_values (t
, argvec
)
8748 tree first
= NULL_TREE
;
8751 for (; t
; t
= TREE_CHAIN (t
))
8753 tree pur
= tsubst_copy (TREE_PURPOSE (t
), argvec
, NULL_TREE
);
8754 tree val
= tsubst_expr (TREE_VALUE (t
), argvec
, NULL_TREE
);
8755 *p
= build_tree_list (pur
, val
);
8756 p
= &TREE_CHAIN (*p
);
8767 last_tree
= TREE_CHAIN (last_tree
) = t
;
8774 saved_trees
= tree_cons (NULL_TREE
, last_tree
, saved_trees
);
8775 last_tree
= NULL_TREE
;
8782 my_friendly_assert (saved_trees
!= NULL_TREE
, 0);
8784 last_tree
= TREE_VALUE (saved_trees
);
8785 saved_trees
= TREE_CHAIN (saved_trees
);
8788 /* D is an undefined function declaration in the presence of templates with
8789 the same name, listed in FNS. If one of them can produce D as an
8790 instantiation, remember this so we can instantiate it at EOF if D has
8791 not been defined by that time. */
8794 add_maybe_template (d
, fns
)
8799 if (DECL_MAYBE_TEMPLATE (d
))
8802 t
= most_specialized (fns
, d
, NULL_TREE
);
8805 if (t
== error_mark_node
)
8807 cp_error ("ambiguous template instantiation for `%D'", d
);
8811 *maybe_template_tail
= perm_tree_cons (t
, d
, NULL_TREE
);
8812 maybe_template_tail
= &TREE_CHAIN (*maybe_template_tail
);
8813 DECL_MAYBE_TEMPLATE (d
) = 1;
8816 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
8819 set_current_access_from_decl (decl
)
8822 if (TREE_PRIVATE (decl
))
8823 current_access_specifier
= access_private_node
;
8824 else if (TREE_PROTECTED (decl
))
8825 current_access_specifier
= access_protected_node
;
8827 current_access_specifier
= access_public_node
;
8830 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
8831 is the instantiation (which should have been created with
8832 start_enum) and ARGS are the template arguments to use. */
8835 tsubst_enum (tag
, newtag
, args
)
8842 for (e
= TYPE_VALUES (tag
); e
; e
= TREE_CHAIN (e
))
8847 /* Note that in a template enum, the TREE_VALUE is the
8848 CONST_DECL, not the corresponding INTEGER_CST. */
8849 value
= tsubst_expr (DECL_INITIAL (TREE_VALUE (e
)),
8853 /* Give this enumeration constant the correct access. */
8854 set_current_access_from_decl (TREE_VALUE (e
));
8856 /* Actually build the enumerator itself. */
8857 elt
= build_enumerator (TREE_PURPOSE (e
), value
, newtag
);
8859 /* We save the enumerators we have built so far in the
8860 TYPE_VALUES so that if the enumeration constants for
8861 subsequent enumerators involve those for previous ones,
8862 tsubst_copy will be able to find them. */
8863 TREE_CHAIN (elt
) = TYPE_VALUES (newtag
);
8864 TYPE_VALUES (newtag
) = elt
;
8867 finish_enum (newtag
);
8870 /* Set the DECL_ASSEMBLER_NAME for DECL, which is a FUNCTION_DECL that
8871 is either an instantiation or specialization of a template
8875 set_mangled_name_for_template_decl (decl
)
8878 tree saved_namespace
;
8879 tree context
= NULL_TREE
;
8888 my_friendly_assert (TREE_CODE (decl
) == FUNCTION_DECL
, 0);
8889 my_friendly_assert (DECL_TEMPLATE_INFO (decl
) != NULL_TREE
, 0);
8891 /* The names of template functions must be mangled so as to indicate
8892 what template is being specialized with what template arguments.
8893 For example, each of the following three functions must get
8894 different mangled names:
8897 template <> void f<7>(int);
8898 template <> void f<8>(int); */
8900 targs
= DECL_TI_ARGS (decl
);
8901 if (uses_template_parms (targs
))
8902 /* This DECL is for a partial instantiation. There's no need to
8903 mangle the name of such an entity. */
8906 tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
8907 tparms
= DECL_TEMPLATE_PARMS (tmpl
);
8908 parm_depth
= TMPL_PARMS_DEPTH (tparms
);
8910 /* There should be as many levels of arguments as there are levels
8912 my_friendly_assert (parm_depth
== TMPL_ARGS_DEPTH (targs
), 0);
8914 /* We now compute the PARMS and RET_TYPE to give to
8915 build_decl_overload_real. The PARMS and RET_TYPE are the
8916 parameter and return types of the template, after all but the
8917 innermost template arguments have been substituted, not the
8918 parameter and return types of the function DECL. For example,
8921 template <class T> T f(T);
8923 both PARMS and RET_TYPE should be `T' even if DECL is `int f(int)'.
8924 A more subtle example is:
8926 template <class T> struct S { template <class U> void f(T, U); }
8928 Here, if DECL is `void S<int>::f(int, double)', PARMS should be
8929 {int, U}. Thus, the args that we want to subsitute into the
8930 return and parameter type for the function are those in TARGS,
8931 with the innermost level omitted. */
8932 fn_type
= TREE_TYPE (tmpl
);
8933 if (DECL_STATIC_FUNCTION_P (decl
))
8934 context
= DECL_CLASS_CONTEXT (decl
);
8936 if (parm_depth
== 1)
8937 /* No substitution is necessary. */
8944 /* Replace the innermost level of the TARGS with NULL_TREEs to
8945 let tsubst know not to subsitute for those parameters. */
8946 partial_args
= make_temp_vec (TREE_VEC_LENGTH (targs
));
8947 for (i
= 1; i
< TMPL_ARGS_DEPTH (targs
); ++i
)
8948 SET_TMPL_ARGS_LEVEL (partial_args
, i
,
8949 TMPL_ARGS_LEVEL (targs
, i
));
8950 SET_TMPL_ARGS_LEVEL (partial_args
,
8951 TMPL_ARGS_DEPTH (targs
),
8952 make_temp_vec (DECL_NTPARMS (tmpl
)));
8954 /* Now, do the (partial) substitution to figure out the
8955 appropriate function type. */
8956 fn_type
= tsubst (fn_type
, partial_args
, NULL_TREE
);
8957 if (DECL_STATIC_FUNCTION_P (decl
))
8958 context
= tsubst (context
, partial_args
, NULL_TREE
);
8960 /* Substitute into the template parameters to obtain the real
8961 innermost set of parameters. This step is important if the
8962 innermost set of template parameters contains value
8963 parameters whose types depend on outer template parameters. */
8964 TREE_VEC_LENGTH (partial_args
)--;
8965 tparms
= tsubst_template_parms (tparms
, partial_args
);
8968 /* Now, get the innermost parameters and arguments, and figure out
8969 the parameter and return types. */
8970 tparms
= INNERMOST_TEMPLATE_PARMS (tparms
);
8971 targs
= innermost_args (targs
);
8972 ret_type
= TREE_TYPE (fn_type
);
8973 parm_types
= TYPE_ARG_TYPES (fn_type
);
8975 /* For a static member function, we generate a fake `this' pointer,
8976 for the purposes of mangling. This indicates of which class the
8977 function is a member. Because of:
8981 There shall not be a static and a nonstatic member function
8982 with the same name and the same parameter types
8984 we don't have to worry that this will result in a clash with a
8985 non-static member function. */
8986 if (DECL_STATIC_FUNCTION_P (decl
))
8987 parm_types
= hash_tree_chain (build_pointer_type (context
), parm_types
);
8989 /* There should be the same number of template parameters as
8990 template arguments. */
8991 my_friendly_assert (TREE_VEC_LENGTH (tparms
) == TREE_VEC_LENGTH (targs
),
8994 /* If the template is in a namespace, we need to put that into the
8995 mangled name. Unfortunately, build_decl_overload_real does not
8996 get the decl to mangle, so it relies on the current
8997 namespace. Therefore, we set that here temporarily. */
8998 my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (decl
)) == 'd', 980702);
8999 saved_namespace
= current_namespace
;
9000 current_namespace
= CP_DECL_CONTEXT (decl
);
9002 /* Actually set the DCL_ASSEMBLER_NAME. */
9003 DECL_ASSEMBLER_NAME (decl
)
9004 = build_decl_overload_real (DECL_NAME (decl
), parm_types
, ret_type
,
9006 DECL_FUNCTION_MEMBER_P (decl
)
9007 + DECL_CONSTRUCTOR_P (decl
));
9009 /* Restore the previously active namespace. */
9010 current_namespace
= saved_namespace
;