1 /* Handle parameterized types (templates) for GNU C++.
2 Copyright (C) 1992, 93, 94, 95, 96, 1997 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 void print_candidates
PROTO((tree
));
116 static tree reduce_template_parm_level
PROTO((tree
, tree
, int));
117 static tree build_template_decl
PROTO((tree
, tree
));
118 static int mark_template_parm
PROTO((tree
, void *));
119 static tree tsubst_friend_function
PROTO((tree
, tree
));
120 static tree tsubst_friend_class
PROTO((tree
, tree
));
121 static tree get_bindings_real
PROTO((tree
, tree
, tree
, int));
122 static int template_decl_level
PROTO((tree
));
123 static tree maybe_get_template_decl_from_type_decl
PROTO((tree
));
124 static int check_cv_quals_for_unify
PROTO((int, tree
, tree
));
125 static tree tsubst_template_arg_vector
PROTO((tree
, tree
));
126 static tree tsubst_template_parms
PROTO((tree
, tree
));
127 static void regenerate_decl_from_template
PROTO((tree
, tree
));
128 static tree most_specialized
PROTO((tree
, tree
, tree
));
129 static tree most_specialized_class
PROTO((tree
, tree
));
130 static tree most_general_template
PROTO((tree
));
131 static void set_mangled_name_for_template_decl
PROTO((tree
));
132 static int template_class_depth_real
PROTO((tree
, int));
133 static tree tsubst_aggr_type
PROTO((tree
, tree
, tree
, int));
134 static tree tsubst_decl
PROTO((tree
, tree
, tree
, tree
));
135 static tree tsubst_arg_types
PROTO((tree
, tree
, tree
));
136 static void check_specialization_scope
PROTO((void));
137 static tree process_partial_specialization
PROTO((tree
));
138 static void set_current_access_from_decl
PROTO((tree
));
139 static void check_default_tmpl_args
PROTO((tree
, tree
, int, int));
141 /* We use TREE_VECs to hold template arguments. If there is only one
142 level of template arguments, then the TREE_VEC contains the
143 arguments directly. If there is more than one level of template
144 arguments, then each entry in the TREE_VEC is itself a TREE_VEC,
145 containing the template arguments for a single level. The first
146 entry in the outer TREE_VEC is the outermost level of template
147 parameters; the last is the innermost.
149 It is incorrect to ever form a template argument vector containing
150 only one level of arguments, but which is a TREE_VEC containing as
151 its only entry the TREE_VEC for that level. */
153 /* Non-zero if the template arguments is actually a vector of vectors,
154 rather than just a vector. */
155 #define TMPL_ARGS_HAVE_MULTIPLE_LEVELS(NODE) \
157 && TREE_CODE (NODE) == TREE_VEC \
158 && TREE_VEC_LENGTH (NODE) > 0 \
159 && TREE_VEC_ELT (NODE, 0) != NULL_TREE \
160 && TREE_CODE (TREE_VEC_ELT (NODE, 0)) == TREE_VEC)
162 /* The depth of a template argument vector. When called directly by
163 the parser, we use a TREE_LIST rather than a TREE_VEC to represent
164 template arguments. In fact, we may even see NULL_TREE if there
165 are no template arguments. In both of those cases, there is only
166 one level of template arguments. */
167 #define TMPL_ARGS_DEPTH(NODE) \
168 (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (NODE) ? TREE_VEC_LENGTH (NODE) : 1)
170 /* The LEVELth level of the template ARGS. Note that template
171 parameter levels are indexed from 1, not from 0. */
172 #define TMPL_ARGS_LEVEL(ARGS, LEVEL) \
173 (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (ARGS) \
174 ? TREE_VEC_ELT ((ARGS), (LEVEL) - 1) : ARGS)
176 /* Set the LEVELth level of the template ARGS to VAL. This macro does
177 not work with single-level argument vectors. */
178 #define SET_TMPL_ARGS_LEVEL(ARGS, LEVEL, VAL) \
179 (TREE_VEC_ELT ((ARGS), (LEVEL) - 1) = (VAL))
181 /* Accesses the IDXth parameter in the LEVELth level of the ARGS. */
182 #define TMPL_ARG(ARGS, LEVEL, IDX) \
183 (TREE_VEC_ELT (TMPL_ARGS_LEVEL (ARGS, LEVEL), IDX))
185 /* Set the IDXth element in the LEVELth level of ARGS to VAL. This
186 macro does not work with single-level argument vectors. */
187 #define SET_TMPL_ARG(ARGS, LEVEL, IDX, VAL) \
188 (TREE_VEC_ELT (TREE_VEC_ELT ((ARGS), (LEVEL) - 1), (IDX)) = (VAL))
190 /* Given a single level of template arguments in NODE, return the
191 number of arguments. */
192 #define NUM_TMPL_ARGS(NODE) \
193 ((NODE) == NULL_TREE ? 0 \
194 : (TREE_CODE (NODE) == TREE_VEC \
195 ? TREE_VEC_LENGTH (NODE) : list_length (NODE)))
197 /* The number of levels of template parameters given by NODE. */
198 #define TMPL_PARMS_DEPTH(NODE) \
199 (TREE_INT_CST_HIGH (TREE_PURPOSE (NODE)))
201 /* Do any processing required when DECL (a member template declaration
202 using TEMPLATE_PARAMETERS as its innermost parameter list) is
203 finished. Returns the TEMPLATE_DECL corresponding to DECL, unless
204 it is a specialization, in which case the DECL itself is returned. */
207 finish_member_template_decl (decl
)
210 if (decl
== NULL_TREE
|| decl
== void_type_node
)
212 else if (decl
== error_mark_node
)
213 /* By returning NULL_TREE, the parser will just ignore this
214 declaration. We have already issued the error. */
216 else if (TREE_CODE (decl
) == TREE_LIST
)
218 /* Assume that the class is the only declspec. */
219 decl
= TREE_VALUE (decl
);
220 if (IS_AGGR_TYPE (decl
) && CLASSTYPE_TEMPLATE_INFO (decl
)
221 && ! CLASSTYPE_TEMPLATE_SPECIALIZATION (decl
))
223 tree tmpl
= CLASSTYPE_TI_TEMPLATE (decl
);
224 check_member_template (tmpl
);
229 else if (DECL_TEMPLATE_INFO (decl
))
231 if (!DECL_TEMPLATE_SPECIALIZATION (decl
))
233 check_member_template (DECL_TI_TEMPLATE (decl
));
234 return DECL_TI_TEMPLATE (decl
);
240 cp_error ("invalid member template declaration `%D'", decl
);
242 return error_mark_node
;
245 /* Returns the template nesting level of the indicated class TYPE.
255 A<T>::B<U> has depth two, while A<T> has depth one.
256 Both A<T>::B<int> and A<int>::B<U> have depth one, if
257 COUNT_SPECIALIZATIONS is 0 or if they are instantiations, not
260 This function is guaranteed to return 0 if passed NULL_TREE so
261 that, for example, `template_class_depth (current_class_type)' is
265 template_class_depth_real (type
, count_specializations
)
267 int count_specializations
;
272 type
&& TREE_CODE (type
) != NAMESPACE_DECL
;
273 type
= (TREE_CODE (type
) == FUNCTION_DECL
)
274 ? DECL_REAL_CONTEXT (type
) : TYPE_CONTEXT (type
))
276 if (TREE_CODE (type
) != FUNCTION_DECL
)
278 if (CLASSTYPE_TEMPLATE_INFO (type
)
279 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
))
280 && ((count_specializations
281 && CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
282 || uses_template_parms (CLASSTYPE_TI_ARGS (type
))))
287 if (DECL_TEMPLATE_INFO (type
)
288 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (type
))
289 && ((count_specializations
290 && DECL_TEMPLATE_SPECIALIZATION (type
))
291 || uses_template_parms (DECL_TI_ARGS (type
))))
299 /* Returns the template nesting level of the indicated class TYPE.
300 Like template_class_depth_real, but instantiations do not count in
304 template_class_depth (type
)
307 return template_class_depth_real (type
, /*count_specializations=*/0);
310 /* Returns 1 if processing DECL as part of do_pending_inlines
311 needs us to push template parms. */
314 inline_needs_template_parms (decl
)
317 if (! DECL_TEMPLATE_INFO (decl
))
320 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl
)))
321 > (processing_template_decl
+ DECL_TEMPLATE_SPECIALIZATION (decl
)));
324 /* Subroutine of maybe_begin_member_template_processing.
325 Push the template parms in PARMS, starting from LEVELS steps into the
326 chain, and ending at the beginning, since template parms are listed
330 push_inline_template_parms_recursive (parmlist
, levels
)
334 tree parms
= TREE_VALUE (parmlist
);
338 push_inline_template_parms_recursive (TREE_CHAIN (parmlist
), levels
- 1);
340 ++processing_template_decl
;
341 current_template_parms
342 = tree_cons (build_int_2 (0, processing_template_decl
),
343 parms
, current_template_parms
);
344 TEMPLATE_PARMS_FOR_INLINE (current_template_parms
) = 1;
347 for (i
= 0; i
< TREE_VEC_LENGTH (parms
); ++i
)
349 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
350 my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (parm
)) == 'd', 0);
352 switch (TREE_CODE (parm
))
361 /* Make a CONST_DECL as is done in process_template_parm. */
362 tree decl
= build_decl (CONST_DECL
, DECL_NAME (parm
),
364 DECL_INITIAL (decl
) = DECL_INITIAL (parm
);
370 my_friendly_abort (0);
375 /* Restore the template parameter context for a member template or
376 a friend template defined in a class definition. */
379 maybe_begin_member_template_processing (decl
)
385 if (! inline_needs_template_parms (decl
))
388 parms
= DECL_TEMPLATE_PARMS (most_general_template (decl
));
390 levels
= TMPL_PARMS_DEPTH (parms
) - processing_template_decl
;
392 if (DECL_TEMPLATE_SPECIALIZATION (decl
))
395 parms
= TREE_CHAIN (parms
);
398 push_inline_template_parms_recursive (parms
, levels
);
401 /* Undo the effects of begin_member_template_processing. */
404 maybe_end_member_template_processing ()
406 if (! processing_template_decl
)
409 while (current_template_parms
410 && TEMPLATE_PARMS_FOR_INLINE (current_template_parms
))
412 --processing_template_decl
;
413 current_template_parms
= TREE_CHAIN (current_template_parms
);
418 /* Returns non-zero iff T is a member template function. We must be
421 template <class T> class C { void f(); }
423 Here, f is a template function, and a member, but not a member
424 template. This function does not concern itself with the origin of
425 T, only its present state. So if we have
427 template <class T> class C { template <class U> void f(U); }
429 then neither C<int>::f<char> nor C<T>::f<double> is considered
430 to be a member template. */
433 is_member_template (t
)
436 if (TREE_CODE (t
) != FUNCTION_DECL
437 && !DECL_FUNCTION_TEMPLATE_P (t
))
438 /* Anything that isn't a function or a template function is
439 certainly not a member template. */
442 /* A local class can't have member templates. */
443 if (hack_decl_function_context (t
))
446 if ((DECL_FUNCTION_MEMBER_P (t
)
447 && !DECL_TEMPLATE_SPECIALIZATION (t
))
448 || (TREE_CODE (t
) == TEMPLATE_DECL
449 && DECL_FUNCTION_MEMBER_P (DECL_TEMPLATE_RESULT (t
))))
453 if (DECL_FUNCTION_TEMPLATE_P (t
))
455 else if (DECL_TEMPLATE_INFO (t
)
456 && DECL_FUNCTION_TEMPLATE_P (DECL_TI_TEMPLATE (t
)))
457 tmpl
= DECL_TI_TEMPLATE (t
);
462 /* If there are more levels of template parameters than
463 there are template classes surrounding the declaration,
464 then we have a member template. */
465 && (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
)) >
466 template_class_depth (DECL_CLASS_CONTEXT (t
))))
474 /* Returns non-zero iff T is a member template class. See
475 is_member_template for a description of what precisely constitutes
476 a member template. */
479 is_member_template_class (t
)
482 if (!DECL_CLASS_TEMPLATE_P (t
))
483 /* Anything that isn't a class template, is certainly not a member
487 if (!DECL_CLASS_SCOPE_P (t
))
488 /* Anything whose context isn't a class type is surely not a
492 /* If there are more levels of template parameters than there are
493 template classes surrounding the declaration, then we have a
495 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (t
)) >
496 template_class_depth (DECL_CONTEXT (t
)));
500 /* Return a new template argument vector which contains all of ARGS,
501 but has as its innermost set of arguments the EXTRA_ARGS. The
502 resulting vector will be built on a temporary obstack, and so must
503 be explicitly copied to the permanent obstack, if required. */
506 add_to_template_args (args
, extra_args
)
515 extra_depth
= TMPL_ARGS_DEPTH (extra_args
);
516 new_args
= make_temp_vec (TMPL_ARGS_DEPTH (args
) + extra_depth
);
518 for (i
= 1; i
<= TMPL_ARGS_DEPTH (args
); ++i
)
519 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (args
, i
));
521 for (j
= 1; j
<= extra_depth
; ++j
, ++i
)
522 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (extra_args
, j
));
527 /* Like add_to_template_args, but only the outermost ARGS are added to
528 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
529 (EXTRA_ARGS) levels are added. This function is used to combine
530 the template arguments from a partial instantiation with the
531 template arguments used to attain the full instantiation from the
532 partial instantiation. */
535 add_outermost_template_args (args
, extra_args
)
541 /* If there are more levels of EXTRA_ARGS than there are ARGS,
542 something very fishy is going on. */
543 my_friendly_assert (TMPL_ARGS_DEPTH (args
) >= TMPL_ARGS_DEPTH (extra_args
),
546 /* If *all* the new arguments will be the EXTRA_ARGS, just return
548 if (TMPL_ARGS_DEPTH (args
) == TMPL_ARGS_DEPTH (extra_args
))
551 /* For the moment, we make ARGS look like it contains fewer levels. */
552 TREE_VEC_LENGTH (args
) -= TMPL_ARGS_DEPTH (extra_args
);
554 new_args
= add_to_template_args (args
, extra_args
);
556 /* Now, we restore ARGS to its full dimensions. */
557 TREE_VEC_LENGTH (args
) += TMPL_ARGS_DEPTH (extra_args
);
562 /* We've got a template header coming up; push to a new level for storing
566 begin_template_parm_list ()
568 /* We use a non-tag-transparent scope here, which causes pushtag to
569 put tags in this scope, rather than in the enclosing class or
570 namespace scope. This is the right thing, since we want
571 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
572 global template class, push_template_decl handles putting the
573 TEMPLATE_DECL into top-level scope. For a nested template class,
576 template <class T> struct S1 {
577 template <class T> struct S2 {};
580 pushtag contains special code to call pushdecl_with_scope on the
581 TEMPLATE_DECL for S2. */
583 declare_pseudo_global_level ();
584 ++processing_template_decl
;
585 ++processing_template_parmlist
;
586 note_template_header (0);
589 /* This routine is called when a specialization is declared. If it is
590 illegal to declare a specialization here, an error is reported. */
593 check_specialization_scope ()
595 tree scope
= current_scope ();
599 An explicit specialization shall be declared in the namespace of
600 which the template is a member, or, for member templates, in the
601 namespace of which the enclosing class or enclosing class
602 template is a member. An explicit specialization of a member
603 function, member class or static data member of a class template
604 shall be declared in the namespace of which the class template
606 if (scope
&& TREE_CODE (scope
) != NAMESPACE_DECL
)
607 cp_error ("explicit specialization in non-namespace scope `%D'",
612 In an explicit specialization declaration for a member of a class
613 template or a member template that appears in namespace scope,
614 the member template and some of its enclosing class templates may
615 remain unspecialized, except that the declaration shall not
616 explicitly specialize a class member template if its enclosing
617 class templates are not explicitly specialized as well. */
618 if (current_template_parms
)
619 cp_error ("enclosing class templates are not explicitly specialized");
622 /* We've just seen template <>. */
625 begin_specialization ()
627 note_template_header (1);
628 check_specialization_scope ();
631 /* Called at then end of processing a declaration preceeded by
635 end_specialization ()
637 reset_specialization ();
640 /* Any template <>'s that we have seen thus far are not referring to a
641 function specialization. */
644 reset_specialization ()
646 processing_specialization
= 0;
647 template_header_count
= 0;
650 /* We've just seen a template header. If SPECIALIZATION is non-zero,
651 it was of the form template <>. */
654 note_template_header (specialization
)
657 processing_specialization
= specialization
;
658 template_header_count
++;
661 /* We're beginning an explicit instantiation. */
664 begin_explicit_instantiation ()
666 ++processing_explicit_instantiation
;
671 end_explicit_instantiation ()
673 my_friendly_assert(processing_explicit_instantiation
> 0, 0);
674 --processing_explicit_instantiation
;
677 /* The TYPE is being declared. If it is a template type, that means it
678 is a partial specialization. Do appropriate error-checking. */
681 maybe_process_partial_specialization (type
)
684 if (IS_AGGR_TYPE (type
) && CLASSTYPE_USE_TEMPLATE (type
))
686 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type
)
687 && TYPE_SIZE (type
) == NULL_TREE
)
689 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type
);
690 if (processing_template_decl
)
691 push_template_decl (TYPE_MAIN_DECL (type
));
693 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type
))
694 cp_error ("specialization of `%T' after instantiation", type
);
698 /* Retrieve the specialization (in the sense of [temp.spec] - a
699 specialization is either an instantiation or an explicit
700 specialization) of TMPL for the given template ARGS. If there is
701 no such specialization, return NULL_TREE. The ARGS are a vector of
702 arguments, or a vector of vectors of arguments, in the case of
703 templates with more than one level of parameters. */
706 retrieve_specialization (tmpl
, args
)
712 my_friendly_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
, 0);
714 /* There should be as many levels of arguments as there are
715 levels of parameters. */
716 my_friendly_assert (TMPL_ARGS_DEPTH (args
)
717 == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
)),
720 for (s
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
723 if (comp_template_args (TREE_PURPOSE (s
), args
))
724 return TREE_VALUE (s
);
729 /* Returns non-zero iff DECL is a specialization of TMPL. */
732 is_specialization_of (decl
, tmpl
)
738 if (TREE_CODE (decl
) == FUNCTION_DECL
)
742 t
= DECL_TEMPLATE_INFO (t
) ? DECL_TI_TEMPLATE (t
) : NULL_TREE
)
748 my_friendly_assert (TREE_CODE (decl
) == TYPE_DECL
, 0);
750 for (t
= TREE_TYPE (decl
);
752 t
= CLASSTYPE_USE_TEMPLATE (t
)
753 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t
)) : NULL_TREE
)
754 if (same_type_p (TYPE_MAIN_VARIANT (t
),
755 TYPE_MAIN_VARIANT (TREE_TYPE (tmpl
))))
762 /* Register the specialization SPEC as a specialization of TMPL with
763 the indicated ARGS. Returns SPEC, or an equivalent prior
764 declaration, if available. */
767 register_specialization (spec
, tmpl
, args
)
774 my_friendly_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
, 0);
776 if (TREE_CODE (spec
) == FUNCTION_DECL
777 && uses_template_parms (DECL_TI_ARGS (spec
)))
778 /* This is the FUNCTION_DECL for a partial instantiation. Don't
779 register it; we want the corresponding TEMPLATE_DECL instead.
780 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
781 the more obvious `uses_template_parms (spec)' to avoid problems
782 with default function arguments. In particular, given
785 template <class T> void f(T t1, T t = T())
787 the default argument expression is not substituted for in an
788 instantiation unless and until it is actually needed. */
791 /* There should be as many levels of arguments as there are
792 levels of parameters. */
793 my_friendly_assert (TMPL_ARGS_DEPTH (args
)
794 == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
)),
797 for (s
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
800 if (comp_template_args (TREE_PURPOSE (s
), args
))
802 tree fn
= TREE_VALUE (s
);
804 if (DECL_TEMPLATE_SPECIALIZATION (spec
))
806 if (DECL_TEMPLATE_INSTANTIATION (fn
))
809 || DECL_EXPLICIT_INSTANTIATION (fn
))
811 cp_error ("specialization of %D after instantiation",
817 /* This situation should occur only if the first
818 specialization is an implicit instantiation,
819 the second is an explicit specialization, and
820 the implicit instantiation has not yet been
821 used. That situation can occur if we have
822 implicitly instantiated a member function and
823 then specialized it later.
825 We can also wind up here if a friend
826 declaration that looked like an instantiation
827 turns out to be a specialization:
829 template <class T> void foo(T);
830 class S { friend void foo<>(int) };
831 template <> void foo(int);
833 We transform the existing DECL in place so that
834 any pointers to it become pointers to the
837 If there was a definition for the template, but
838 not for the specialization, we want this to
839 look as if there is no definition, and vice
841 DECL_INITIAL (fn
) = NULL_TREE
;
842 duplicate_decls (spec
, fn
);
847 else if (DECL_TEMPLATE_SPECIALIZATION (fn
))
849 duplicate_decls (spec
, fn
);
855 DECL_TEMPLATE_SPECIALIZATIONS (tmpl
)
856 = perm_tree_cons (args
, spec
, DECL_TEMPLATE_SPECIALIZATIONS (tmpl
));
861 /* Unregister the specialization SPEC as a specialization of TMPL.
862 Returns nonzero if the SPEC was listed as a specialization of
866 unregister_specialization (spec
, tmpl
)
872 for (s
= &DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
874 s
= &TREE_CHAIN (*s
))
875 if (TREE_VALUE (*s
) == spec
)
877 *s
= TREE_CHAIN (*s
);
884 /* Print the list of candidate FNS in an error message. */
887 print_candidates (fns
)
892 char* str
= "candidates are:";
894 for (fn
= fns
; fn
!= NULL_TREE
; fn
= TREE_CHAIN (fn
))
896 cp_error_at ("%s %+#D", str
, TREE_VALUE (fn
));
901 /* Returns the template (one of the functions given by TEMPLATE_ID)
902 which can be specialized to match the indicated DECL with the
903 explicit template args given in TEMPLATE_ID. If
904 NEED_MEMBER_TEMPLATE is true the function is a specialization of a
905 member template. The template args (those explicitly specified and
906 those deduced) are output in a newly created vector *TARGS_OUT. If
907 it is impossible to determine the result, an error message is
908 issued, unless COMPLAIN is 0. The DECL may be NULL_TREE if none is
912 determine_specialization (template_id
, decl
, targs_out
,
913 need_member_template
,
918 int need_member_template
;
922 tree templates
= NULL_TREE
;
925 *targs_out
= NULL_TREE
;
927 if (template_id
== error_mark_node
)
928 return error_mark_node
;
930 fns
= TREE_OPERAND (template_id
, 0);
931 targs_in
= TREE_OPERAND (template_id
, 1);
933 if (fns
== error_mark_node
)
934 return error_mark_node
;
936 /* Check for baselinks. */
937 if (TREE_CODE (fns
) == TREE_LIST
)
938 fns
= TREE_VALUE (fns
);
940 for (; fns
; fns
= OVL_NEXT (fns
))
944 fn
= OVL_CURRENT (fns
);
945 if (!need_member_template
946 && TREE_CODE (fn
) == FUNCTION_DECL
947 && DECL_FUNCTION_MEMBER_P (fn
)
948 && DECL_USE_TEMPLATE (fn
)
949 && DECL_TI_TEMPLATE (fn
))
950 /* We can get here when processing something like:
951 template <class T> class X { void f(); }
952 template <> void X<int>::f() {}
953 We're specializing a member function, but not a member
955 tmpl
= DECL_TI_TEMPLATE (fn
);
956 else if (TREE_CODE (fn
) != TEMPLATE_DECL
957 || (need_member_template
&& !is_member_template (fn
)))
962 if (list_length (targs_in
) > DECL_NTPARMS (tmpl
))
965 if (decl
== NULL_TREE
)
967 /* Unify against ourselves to make sure that the args we have
968 make sense and there aren't any undeducible parms. It's OK if
969 not all the parms are specified; they might be deduced
971 tree targs
= get_bindings_overload (tmpl
, DECL_RESULT (tmpl
),
975 /* Unification was successful. */
976 templates
= scratch_tree_cons (targs
, tmpl
, templates
);
979 templates
= scratch_tree_cons (NULL_TREE
, tmpl
, templates
);
982 if (decl
!= NULL_TREE
)
984 tree tmpl
= most_specialized (templates
, decl
, targs_in
);
988 if (tmpl
== error_mark_node
)
990 else if (tmpl
== NULL_TREE
)
993 inner_args
= get_bindings (tmpl
, decl
, targs_in
);
994 tmpl_args
= DECL_TI_ARGS (DECL_RESULT (tmpl
));
995 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (tmpl_args
))
997 *targs_out
= copy_node (tmpl_args
);
998 SET_TMPL_ARGS_LEVEL (*targs_out
,
999 TMPL_ARGS_DEPTH (*targs_out
),
1003 *targs_out
= inner_args
;
1008 if (templates
== NULL_TREE
)
1013 cp_error_at ("template-id `%D' for `%+D' does not match any template declaration",
1015 return error_mark_node
;
1019 else if (TREE_CHAIN (templates
) != NULL_TREE
1020 || uses_template_parms (TREE_PURPOSE (templates
)))
1025 cp_error_at ("ambiguous template specialization `%D' for `%+D'",
1027 print_candidates (templates
);
1028 return error_mark_node
;
1033 /* We have one, and exactly one, match. */
1034 *targs_out
= TREE_PURPOSE (templates
);
1035 return TREE_VALUE (templates
);
1038 /* Check to see if the function just declared, as indicated in
1039 DECLARATOR, and in DECL, is a specialization of a function
1040 template. We may also discover that the declaration is an explicit
1041 instantiation at this point.
1043 Returns DECL, or an equivalent declaration that should be used
1046 FLAGS is a bitmask consisting of the following flags:
1048 2: The function has a definition.
1049 4: The function is a friend.
1051 The TEMPLATE_COUNT is the number of references to qualifying
1052 template classes that appeared in the name of the function. For
1055 template <class T> struct S { void f(); };
1058 the TEMPLATE_COUNT would be 1. However, explicitly specialized
1059 classes are not counted in the TEMPLATE_COUNT, so that in
1061 template <class T> struct S {};
1062 template <> struct S<int> { void f(); }
1063 template <> void S<int>::f();
1065 the TEMPLATE_COUNT would be 0. (Note that this declaration is
1066 illegal; there should be no template <>.)
1068 If the function is a specialization, it is marked as such via
1069 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
1070 is set up correctly, and it is added to the list of specializations
1071 for that template. */
1074 check_explicit_specialization (declarator
, decl
, template_count
, flags
)
1080 int have_def
= flags
& 2;
1081 int is_friend
= flags
& 4;
1082 int specialization
= 0;
1083 int explicit_instantiation
= 0;
1084 int member_specialization
= 0;
1086 tree ctype
= DECL_CLASS_CONTEXT (decl
);
1087 tree dname
= DECL_NAME (decl
);
1089 if (processing_specialization
)
1091 /* The last template header was of the form template <>. */
1093 if (template_header_count
> template_count
)
1095 /* There were more template headers than qualifying template
1097 if (template_header_count
- template_count
> 1)
1098 /* There shouldn't be that many template parameter
1099 lists. There can be at most one parameter list for
1100 every qualifying class, plus one for the function
1102 cp_error ("too many template parameter lists in declaration of `%D'", decl
);
1104 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
1106 member_specialization
= 1;
1110 else if (template_header_count
== template_count
)
1112 /* The counts are equal. So, this might be a
1113 specialization, but it is not a specialization of a
1114 member template. It might be something like
1116 template <class T> struct S {
1120 void S<int>::f(int i) {} */
1122 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
1126 /* This cannot be an explicit specialization. There are not
1127 enough headers for all of the qualifying classes. For
1128 example, we might have:
1131 void S<int>::T<char>::f();
1133 But, we're missing another template <>. */
1134 cp_error("too few template parameter lists in declaration of `%D'", decl
);
1138 else if (processing_explicit_instantiation
)
1140 if (template_header_count
)
1141 cp_error ("template parameter list used in explicit instantiation");
1144 cp_error ("definition provided for explicit instantiation");
1146 explicit_instantiation
= 1;
1148 else if (ctype
!= NULL_TREE
1149 && !TYPE_BEING_DEFINED (ctype
)
1150 && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype
)
1153 /* This case catches outdated code that looks like this:
1155 template <class T> struct S { void f(); };
1156 void S<int>::f() {} // Missing template <>
1158 We disable this check when the type is being defined to
1159 avoid complaining about default compiler-generated
1160 constructors, destructors, and assignment operators.
1161 Since the type is an instantiation, not a specialization,
1162 these are the only functions that can be defined before
1163 the class is complete. */
1166 template <class T> void S<int>::f() {}
1168 if (template_header_count
)
1170 cp_error ("template parameters specified in specialization");
1176 ("explicit specialization not preceded by `template <>'");
1178 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
1180 else if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
1183 /* This could be something like:
1185 template <class T> void f(T);
1186 class S { friend void f<>(int); } */
1190 /* This case handles bogus declarations like template <>
1191 template <class T> void f<int>(); */
1193 cp_error ("template-id `%D' in declaration of primary template",
1199 if (specialization
|| member_specialization
)
1201 tree t
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
1202 for (; t
; t
= TREE_CHAIN (t
))
1203 if (TREE_PURPOSE (t
))
1206 ("default argument specified in explicit specialization");
1211 if (specialization
|| member_specialization
|| explicit_instantiation
)
1214 tree tmpl
= NULL_TREE
;
1215 tree targs
= NULL_TREE
;
1217 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
1218 if (TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
1222 my_friendly_assert (TREE_CODE (declarator
) == IDENTIFIER_NODE
,
1225 fns
= IDENTIFIER_NAMESPACE_VALUE (dname
);
1230 lookup_template_function (fns
, NULL_TREE
);
1233 if (declarator
== error_mark_node
)
1234 return error_mark_node
;
1236 if (TREE_CODE (TREE_OPERAND (declarator
, 0)) == LOOKUP_EXPR
)
1238 /* A friend declaration. We can't do much, because we don't
1239 know what this resolves to, yet. */
1240 my_friendly_assert (is_friend
!= 0, 0);
1241 my_friendly_assert (!explicit_instantiation
, 0);
1242 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
1246 if (ctype
!= NULL_TREE
&& TYPE_BEING_DEFINED (ctype
))
1248 if (!explicit_instantiation
)
1249 /* A specialization in class scope. This is illegal,
1250 but the error will already have been flagged by
1251 check_specialization_scope. */
1252 return error_mark_node
;
1255 /* It's not legal to write an explicit instantiation in
1258 class C { template void f(); }
1260 This case is caught by the parser. However, on
1263 template class C { void f(); };
1265 (which is illegal) we can get here. The error will be
1272 else if (ctype
!= NULL_TREE
1273 && (TREE_CODE (TREE_OPERAND (declarator
, 0)) ==
1276 /* Find the list of functions in ctype that have the same
1277 name as the declared function. */
1278 tree name
= TREE_OPERAND (declarator
, 0);
1281 if (name
== constructor_name (ctype
)
1282 || name
== constructor_name_full (ctype
))
1284 int is_constructor
= DECL_CONSTRUCTOR_P (decl
);
1286 if (is_constructor
? !TYPE_HAS_CONSTRUCTOR (ctype
)
1287 : !TYPE_HAS_DESTRUCTOR (ctype
))
1289 /* From [temp.expl.spec]:
1291 If such an explicit specialization for the member
1292 of a class template names an implicitly-declared
1293 special member function (clause _special_), the
1294 program is ill-formed.
1296 Similar language is found in [temp.explicit]. */
1297 cp_error ("specialization of implicitly-declared special member function");
1302 name
= is_constructor
? ctor_identifier
: dtor_identifier
;
1305 fns
= lookup_fnfields (TYPE_BINFO (ctype
), name
, 1);
1307 if (fns
== NULL_TREE
)
1309 cp_error ("no member function `%s' declared in `%T'",
1310 IDENTIFIER_POINTER (name
),
1315 TREE_OPERAND (declarator
, 0) = fns
;
1318 /* Figure out what exactly is being specialized at this point.
1319 Note that for an explicit instantiation, even one for a
1320 member function, we cannot tell apriori whether the
1321 instantiation is for a member template, or just a member
1322 function of a template class. Even if a member template is
1323 being instantiated, the member template arguments may be
1324 elided if they can be deduced from the rest of the
1326 tmpl
= determine_specialization (declarator
, decl
,
1328 member_specialization
,
1331 if (tmpl
&& tmpl
!= error_mark_node
)
1333 gen_tmpl
= most_general_template (tmpl
);
1335 if (explicit_instantiation
)
1337 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
1338 is done by do_decl_instantiation later. */
1339 decl
= instantiate_template (tmpl
, innermost_args (targs
));
1343 /* If we though that the DECL was a member function, but it
1344 turns out to be specializing a static member function,
1345 make DECL a static member function as well. */
1346 if (DECL_STATIC_FUNCTION_P (tmpl
)
1347 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
1349 revert_static_member_fn (&decl
, 0, 0);
1350 last_function_parms
= TREE_CHAIN (last_function_parms
);
1353 /* Set up the DECL_TEMPLATE_INFO for DECL. */
1354 DECL_TEMPLATE_INFO (decl
)
1355 = perm_tree_cons (tmpl
, targs
, NULL_TREE
);
1357 /* Mangle the function name appropriately. Note that we do
1358 not mangle specializations of non-template member
1359 functions of template classes, e.g. with
1361 template <class T> struct S { void f(); }
1363 and given the specialization
1365 template <> void S<int>::f() {}
1367 we do not mangle S<int>::f() here. That's because it's
1368 just an ordinary member function and doesn't need special
1369 treatment. We do this here so that the ordinary,
1370 non-template, name-mangling algorith will not be used
1372 if ((is_member_template (tmpl
) || ctype
== NULL_TREE
)
1373 && name_mangling_version
>= 1)
1374 set_mangled_name_for_template_decl (decl
);
1376 if (is_friend
&& !have_def
)
1377 /* This is not really a declaration of a specialization.
1378 It's just the name of an instantiation. But, it's not
1379 a request for an instantiation, either. */
1380 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
1382 /* Register this specialization so that we can find it
1384 decl
= register_specialization (decl
, gen_tmpl
, targs
);
1393 /* TYPE is being declared. Verify that the use of template headers
1394 and such is reasonable. Issue error messages if not. */
1397 maybe_check_template_type (type
)
1400 if (template_header_count
)
1402 /* We are in the scope of some `template <...>' header. */
1405 = template_class_depth_real (TYPE_CONTEXT (type
),
1406 /*count_specializations=*/1);
1408 if (template_header_count
<= context_depth
)
1409 /* This is OK; the template headers are for the context. We
1410 are actually too lenient here; like
1411 check_explicit_specialization we should consider the number
1412 of template types included in the actual declaration. For
1415 template <class T> struct S {
1416 template <class U> template <class V>
1422 template <class T> struct S {
1423 template <class U> struct I;
1426 template <class T> template <class U.
1431 else if (template_header_count
> context_depth
+ 1)
1432 /* There are two many template parameter lists. */
1433 cp_error ("too many template parameter lists in declaration of `%T'", type
);
1437 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
1438 parameters. These are represented in the same format used for
1439 DECL_TEMPLATE_PARMS. */
1441 int comp_template_parms (parms1
, parms2
)
1448 if (parms1
== parms2
)
1451 for (p1
= parms1
, p2
= parms2
;
1452 p1
!= NULL_TREE
&& p2
!= NULL_TREE
;
1453 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
))
1455 tree t1
= TREE_VALUE (p1
);
1456 tree t2
= TREE_VALUE (p2
);
1459 my_friendly_assert (TREE_CODE (t1
) == TREE_VEC
, 0);
1460 my_friendly_assert (TREE_CODE (t2
) == TREE_VEC
, 0);
1462 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
1465 for (i
= 0; i
< TREE_VEC_LENGTH (t2
); ++i
)
1467 tree parm1
= TREE_VALUE (TREE_VEC_ELT (t1
, i
));
1468 tree parm2
= TREE_VALUE (TREE_VEC_ELT (t2
, i
));
1470 if (TREE_CODE (parm1
) != TREE_CODE (parm2
))
1473 if (TREE_CODE (parm1
) == TEMPLATE_TYPE_PARM
)
1475 else if (!same_type_p (TREE_TYPE (parm1
), TREE_TYPE (parm2
)))
1480 if ((p1
!= NULL_TREE
) != (p2
!= NULL_TREE
))
1481 /* One set of parameters has more parameters lists than the
1489 /* Returns 1 iff old_id is a template parameter. OLD_DECL is the decl
1490 from IDENTIFIER_LOCAL_VALUE (new identifier). */
1492 int decl_template_parm_p (old_decl
)
1495 /* For template template parms. */
1496 if (TREE_CODE (old_decl
) == TEMPLATE_DECL
1497 && TREE_TYPE (old_decl
)
1498 && TREE_CODE (TREE_TYPE (old_decl
)) == TEMPLATE_TEMPLATE_PARM
)
1501 /* For template type parms. */
1502 if (TREE_CODE (old_decl
) == TYPE_DECL
1503 && TREE_TYPE (old_decl
)
1504 && TREE_CODE (TREE_TYPE (old_decl
)) == TEMPLATE_TYPE_PARM
)
1507 /* For template non-type parms. */
1508 if (TREE_CODE (old_decl
) == CONST_DECL
1509 && DECL_INITIAL (old_decl
)
1510 && TREE_CODE (DECL_INITIAL (old_decl
)) == TEMPLATE_PARM_INDEX
)
1517 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
1518 ORIG_LEVEL, DECL, and TYPE. */
1521 build_template_parm_index (index
, level
, orig_level
, decl
, type
)
1528 tree t
= make_node (TEMPLATE_PARM_INDEX
);
1529 TEMPLATE_PARM_IDX (t
) = index
;
1530 TEMPLATE_PARM_LEVEL (t
) = level
;
1531 TEMPLATE_PARM_ORIG_LEVEL (t
) = orig_level
;
1532 TEMPLATE_PARM_DECL (t
) = decl
;
1533 TREE_TYPE (t
) = type
;
1538 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
1539 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
1540 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
1541 new one is created. */
1544 reduce_template_parm_level (index
, type
, levels
)
1549 if (TEMPLATE_PARM_DESCENDANTS (index
) == NULL_TREE
1550 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index
))
1551 != TEMPLATE_PARM_LEVEL (index
) - levels
))
1554 = build_decl (TREE_CODE (TEMPLATE_PARM_DECL (index
)),
1555 DECL_NAME (TEMPLATE_PARM_DECL (index
)),
1558 = build_template_parm_index (TEMPLATE_PARM_IDX (index
),
1559 TEMPLATE_PARM_LEVEL (index
) - levels
,
1560 TEMPLATE_PARM_ORIG_LEVEL (index
),
1562 TEMPLATE_PARM_DESCENDANTS (index
) = t
;
1564 /* Template template parameters need this. */
1565 DECL_TEMPLATE_PARMS (decl
)
1566 = DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index
));
1569 return TEMPLATE_PARM_DESCENDANTS (index
);
1572 /* Process information from new template parameter NEXT and append it to the
1573 LIST being built. */
1576 process_template_parm (list
, next
)
1585 my_friendly_assert (TREE_CODE (parm
) == TREE_LIST
, 259);
1586 defval
= TREE_PURPOSE (parm
);
1587 parm
= TREE_VALUE (parm
);
1588 is_type
= TREE_PURPOSE (parm
) == class_type_node
;
1592 tree p
= TREE_VALUE (tree_last (list
));
1594 if (TREE_CODE (p
) == TYPE_DECL
)
1595 idx
= TEMPLATE_TYPE_IDX (TREE_TYPE (p
));
1596 else if (TREE_CODE (p
) == TEMPLATE_DECL
)
1597 idx
= TEMPLATE_TYPE_IDX (TREE_TYPE (DECL_TEMPLATE_RESULT (p
)));
1599 idx
= TEMPLATE_PARM_IDX (DECL_INITIAL (p
));
1607 my_friendly_assert (TREE_CODE (TREE_PURPOSE (parm
)) == TREE_LIST
, 260);
1608 /* is a const-param */
1609 parm
= grokdeclarator (TREE_VALUE (parm
), TREE_PURPOSE (parm
),
1610 PARM
, 0, NULL_TREE
);
1611 /* A template parameter is not modifiable. */
1612 TREE_READONLY (parm
) = 1;
1613 if (IS_AGGR_TYPE (TREE_TYPE (parm
))
1614 && TREE_CODE (TREE_TYPE (parm
)) != TEMPLATE_TYPE_PARM
1615 && TREE_CODE (TREE_TYPE (parm
)) != TYPENAME_TYPE
)
1617 cp_error ("`%#T' is not a valid type for a template constant parameter",
1619 if (DECL_NAME (parm
) == NULL_TREE
)
1620 error (" a template type parameter must begin with `class' or `typename'");
1621 TREE_TYPE (parm
) = void_type_node
;
1624 && (TREE_CODE (TREE_TYPE (parm
)) == REAL_TYPE
1625 || TREE_CODE (TREE_TYPE (parm
)) == COMPLEX_TYPE
))
1626 cp_pedwarn ("`%T' is not a valid type for a template constant parameter",
1628 if (TREE_PERMANENT (parm
) == 0)
1630 parm
= copy_node (parm
);
1631 TREE_PERMANENT (parm
) = 1;
1633 decl
= build_decl (CONST_DECL
, DECL_NAME (parm
), TREE_TYPE (parm
));
1634 DECL_INITIAL (parm
) = DECL_INITIAL (decl
)
1635 = build_template_parm_index (idx
, processing_template_decl
,
1636 processing_template_decl
,
1637 decl
, TREE_TYPE (parm
));
1642 parm
= TREE_VALUE (parm
);
1644 if (parm
&& TREE_CODE (parm
) == TEMPLATE_DECL
)
1646 t
= make_lang_type (TEMPLATE_TEMPLATE_PARM
);
1647 /* This is for distinguishing between real templates and template
1648 template parameters */
1649 TREE_TYPE (parm
) = t
;
1650 TREE_TYPE (DECL_TEMPLATE_RESULT (parm
)) = t
;
1655 t
= make_lang_type (TEMPLATE_TYPE_PARM
);
1656 /* parm is either IDENTIFIER_NODE or NULL_TREE */
1657 decl
= build_decl (TYPE_DECL
, parm
, t
);
1660 TYPE_NAME (t
) = decl
;
1661 TYPE_STUB_DECL (t
) = decl
;
1663 TEMPLATE_TYPE_PARM_INDEX (t
)
1664 = build_template_parm_index (idx
, processing_template_decl
,
1665 processing_template_decl
,
1666 decl
, TREE_TYPE (parm
));
1668 SET_DECL_ARTIFICIAL (decl
);
1670 parm
= build_tree_list (defval
, parm
);
1671 return chainon (list
, parm
);
1674 /* The end of a template parameter list has been reached. Process the
1675 tree list into a parameter vector, converting each parameter into a more
1676 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
1680 end_template_parm_list (parms
)
1685 tree saved_parmlist
= make_tree_vec (list_length (parms
));
1687 current_template_parms
1688 = tree_cons (build_int_2 (0, processing_template_decl
),
1689 saved_parmlist
, current_template_parms
);
1691 for (parm
= parms
, nparms
= 0; parm
; parm
= TREE_CHAIN (parm
), nparms
++)
1692 TREE_VEC_ELT (saved_parmlist
, nparms
) = parm
;
1694 --processing_template_parmlist
;
1696 return saved_parmlist
;
1699 /* end_template_decl is called after a template declaration is seen. */
1702 end_template_decl ()
1704 reset_specialization ();
1706 if (! processing_template_decl
)
1709 /* This matches the pushlevel in begin_template_parm_list. */
1712 --processing_template_decl
;
1713 current_template_parms
= TREE_CHAIN (current_template_parms
);
1714 (void) get_pending_sizes (); /* Why? */
1717 /* Given a template argument vector containing the template PARMS.
1718 The innermost PARMS are given first. */
1721 current_template_args ()
1724 tree args
= NULL_TREE
;
1725 int length
= TMPL_PARMS_DEPTH (current_template_parms
);
1728 /* If there is only one level of template parameters, we do not
1729 create a TREE_VEC of TREE_VECs. Instead, we return a single
1730 TREE_VEC containing the arguments. */
1732 args
= make_tree_vec (length
);
1734 for (header
= current_template_parms
; header
; header
= TREE_CHAIN (header
))
1736 tree a
= copy_node (TREE_VALUE (header
));
1739 TREE_TYPE (a
) = NULL_TREE
;
1740 for (i
= TREE_VEC_LENGTH (a
) - 1; i
>= 0; --i
)
1742 tree t
= TREE_VEC_ELT (a
, i
);
1744 /* T will be a list if we are called from within a
1745 begin/end_template_parm_list pair, but a vector directly
1746 if within a begin/end_member_template_processing pair. */
1747 if (TREE_CODE (t
) == TREE_LIST
)
1751 if (TREE_CODE (t
) == TYPE_DECL
1752 || TREE_CODE (t
) == TEMPLATE_DECL
)
1755 t
= DECL_INITIAL (t
);
1756 TREE_VEC_ELT (a
, i
) = t
;
1761 TREE_VEC_ELT (args
, --l
) = a
;
1769 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
1770 template PARMS. Used by push_template_decl below. */
1773 build_template_decl (decl
, parms
)
1777 tree tmpl
= build_lang_decl (TEMPLATE_DECL
, DECL_NAME (decl
), NULL_TREE
);
1778 DECL_TEMPLATE_PARMS (tmpl
) = parms
;
1779 DECL_CONTEXT (tmpl
) = DECL_CONTEXT (decl
);
1780 if (DECL_LANG_SPECIFIC (decl
))
1782 DECL_CLASS_CONTEXT (tmpl
) = DECL_CLASS_CONTEXT (decl
);
1783 DECL_STATIC_FUNCTION_P (tmpl
) =
1784 DECL_STATIC_FUNCTION_P (decl
);
1790 struct template_parm_data
1792 /* The level of the template parameters we are currently
1796 /* The index of the specialization argument we are currently
1800 /* An array whose size is the number of template parameters. The
1801 elements are non-zero if the parameter has been used in any one
1802 of the arguments processed so far. */
1805 /* An array whose size is the number of template arguments. The
1806 elements are non-zero if the argument makes use of template
1807 parameters of this level. */
1808 int* arg_uses_template_parms
;
1811 /* Subroutine of push_template_decl used to see if each template
1812 parameter in a partial specialization is used in the explicit
1813 argument list. If T is of the LEVEL given in DATA (which is
1814 treated as a template_parm_data*), then DATA->PARMS is marked
1818 mark_template_parm (t
, data
)
1824 struct template_parm_data
* tpd
= (struct template_parm_data
*) data
;
1826 if (TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
1828 level
= TEMPLATE_PARM_LEVEL (t
);
1829 idx
= TEMPLATE_PARM_IDX (t
);
1833 level
= TEMPLATE_TYPE_LEVEL (t
);
1834 idx
= TEMPLATE_TYPE_IDX (t
);
1837 if (level
== tpd
->level
)
1839 tpd
->parms
[idx
] = 1;
1840 tpd
->arg_uses_template_parms
[tpd
->current_arg
] = 1;
1843 /* Return zero so that for_each_template_parm will continue the
1844 traversal of the tree; we want to mark *every* template parm. */
1848 /* Process the partial specialization DECL. */
1851 process_partial_specialization (decl
)
1854 tree type
= TREE_TYPE (decl
);
1855 tree maintmpl
= CLASSTYPE_TI_TEMPLATE (type
);
1856 tree specargs
= CLASSTYPE_TI_ARGS (type
);
1857 tree inner_args
= innermost_args (specargs
);
1858 tree inner_parms
= INNERMOST_TEMPLATE_PARMS (current_template_parms
);
1859 tree main_inner_parms
= DECL_INNERMOST_TEMPLATE_PARMS (maintmpl
);
1860 int nargs
= TREE_VEC_LENGTH (inner_args
);
1861 int ntparms
= TREE_VEC_LENGTH (inner_parms
);
1863 int did_error_intro
= 0;
1864 struct template_parm_data tpd
;
1865 struct template_parm_data tpd2
;
1867 /* We check that each of the template parameters given in the
1868 partial specialization is used in the argument list to the
1869 specialization. For example:
1871 template <class T> struct S;
1872 template <class T> struct S<T*>;
1874 The second declaration is OK because `T*' uses the template
1875 parameter T, whereas
1877 template <class T> struct S<int>;
1879 is no good. Even trickier is:
1890 The S2<T> declaration is actually illegal; it is a
1891 full-specialization. Of course,
1894 struct S2<T (*)(U)>;
1896 or some such would have been OK. */
1897 tpd
.level
= TMPL_PARMS_DEPTH (current_template_parms
);
1898 tpd
.parms
= alloca (sizeof (int) * ntparms
);
1899 bzero ((PTR
) tpd
.parms
, sizeof (int) * ntparms
);
1901 tpd
.arg_uses_template_parms
= alloca (sizeof (int) * nargs
);
1902 bzero ((PTR
) tpd
.arg_uses_template_parms
, sizeof (int) * nargs
);
1903 for (i
= 0; i
< nargs
; ++i
)
1905 tpd
.current_arg
= i
;
1906 for_each_template_parm (TREE_VEC_ELT (inner_args
, i
),
1907 &mark_template_parm
,
1910 for (i
= 0; i
< ntparms
; ++i
)
1911 if (tpd
.parms
[i
] == 0)
1913 /* One of the template parms was not used in the
1915 if (!did_error_intro
)
1917 cp_error ("template parameters not used in partial specialization:");
1918 did_error_intro
= 1;
1922 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
)));
1925 /* [temp.class.spec]
1927 The argument list of the specialization shall not be identical to
1928 the implicit argument list of the primary template. */
1929 if (comp_template_args (inner_args
,
1930 innermost_args (CLASSTYPE_TI_ARGS (TREE_TYPE
1932 cp_error ("partial specialization `%T' does not specialize any template arguments", type
);
1934 /* [temp.class.spec]
1936 A partially specialized non-type argument expression shall not
1937 involve template parameters of the partial specialization except
1938 when the argument expression is a simple identifier.
1940 The type of a template parameter corresponding to a specialized
1941 non-type argument shall not be dependent on a parameter of the
1943 my_friendly_assert (nargs
== DECL_NTPARMS (maintmpl
), 0);
1945 for (i
= 0; i
< nargs
; ++i
)
1947 tree arg
= TREE_VEC_ELT (inner_args
, i
);
1948 if (/* These first two lines are the `non-type' bit. */
1949 TREE_CODE_CLASS (TREE_CODE (arg
)) != 't'
1950 && TREE_CODE (arg
) != TEMPLATE_DECL
1951 /* This next line is the `argument expression is not just a
1952 simple identifier' condition and also the `specialized
1953 non-type argument' bit. */
1954 && TREE_CODE (arg
) != TEMPLATE_PARM_INDEX
)
1956 if (tpd
.arg_uses_template_parms
[i
])
1957 cp_error ("template argument `%E' involves template parameter(s)", arg
);
1960 /* Look at the corresponding template parameter,
1961 marking which template parameters its type depends
1964 TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (main_inner_parms
,
1969 /* We haven't yet initialized TPD2. Do so now. */
1970 tpd2
.arg_uses_template_parms
1971 = (int*) alloca (sizeof (int) * nargs
);
1972 /* The number of paramters here is the number in the
1973 main template, which, as checked in the assertion
1975 tpd2
.parms
= (int*) alloca (sizeof (int) * nargs
);
1977 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl
));
1980 /* Mark the template paramters. But this time, we're
1981 looking for the template parameters of the main
1982 template, not in the specialization. */
1983 tpd2
.current_arg
= i
;
1984 tpd2
.arg_uses_template_parms
[i
] = 0;
1985 bzero ((PTR
) tpd2
.parms
, sizeof (int) * nargs
);
1986 for_each_template_parm (type
,
1987 &mark_template_parm
,
1990 if (tpd2
.arg_uses_template_parms
[i
])
1992 /* The type depended on some template parameters.
1993 If they are fully specialized in the
1994 specialization, that's OK. */
1996 for (j
= 0; j
< nargs
; ++j
)
1997 if (tpd2
.parms
[j
] != 0
1998 && tpd
.arg_uses_template_parms
[j
])
2000 cp_error ("type `%T' of template argument `%E' depends on template paramter(s)",
2010 if (retrieve_specialization (maintmpl
, specargs
))
2011 /* We've already got this specialization. */
2014 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
) = CLASSTYPE_TI_SPEC_INFO (type
)
2015 = perm_tree_cons (inner_args
, inner_parms
,
2016 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
));
2017 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)) = type
;
2021 /* Check that a template declaration's use of default arguments is not
2022 invalid. Here, PARMS are the template parameters. IS_PRIMARY is
2023 non-zero if DECL is the thing declared by a primary template.
2024 IS_PARTIAL is non-zero if DECL is a partial specialization. */
2027 check_default_tmpl_args (decl
, parms
, is_primary
, is_partial
)
2034 int last_level_to_check
;
2038 A default template-argument shall not be specified in a
2039 function template declaration or a function template definition, nor
2040 in the template-parameter-list of the definition of a member of a
2043 if (current_class_type
2044 && !TYPE_BEING_DEFINED (current_class_type
)
2045 && DECL_REAL_CONTEXT (decl
) == current_class_type
2046 && DECL_DEFINED_IN_CLASS_P (decl
))
2047 /* We already checked these parameters when the template was
2048 declared, so there's no need to do it again now. This is an
2049 inline member function definition. */
2052 if (TREE_CODE (decl
) != TYPE_DECL
|| is_partial
|| !is_primary
)
2053 /* For an ordinary class template, default template arguments are
2054 allowed at the innermost level, e.g.:
2055 template <class T = int>
2057 but, in a partial specialization, they're not allowed even
2058 there, as we have in [temp.class.spec]:
2060 The template parameter list of a specialization shall not
2061 contain default template argument values.
2063 So, for a partial specialization, or for a function template,
2064 we look at all of them. */
2067 /* But, for a primary class template that is not a partial
2068 specialization we look at all template parameters except the
2070 parms
= TREE_CHAIN (parms
);
2072 /* Figure out what error message to issue. */
2073 if (TREE_CODE (decl
) == FUNCTION_DECL
)
2074 msg
= "default argument for template parameter in function template `%D'";
2075 else if (is_partial
)
2076 msg
= "default argument in partial specialization `%D'";
2078 msg
= "default argument for template parameter for class enclosing `%D'";
2080 if (current_class_type
&& TYPE_BEING_DEFINED (current_class_type
))
2081 /* If we're inside a class definition, there's no need to
2082 examine the paramters to the class itself. On the one
2083 hand, they will be checked when the class is defined, and,
2084 on the other, default arguments are legal in things like:
2085 template <class T = double>
2086 struct S { template <class U> void f(U); };
2087 Here the default argument for `S' has no bearing on the
2088 declaration of `f'. */
2089 last_level_to_check
= template_class_depth (current_class_type
) + 1;
2091 /* Check everything. */
2092 last_level_to_check
= 0;
2094 for (; parms
&& TMPL_PARMS_DEPTH (parms
) >= last_level_to_check
;
2095 parms
= TREE_CHAIN (parms
))
2097 tree inner_parms
= TREE_VALUE (parms
);
2100 ntparms
= TREE_VEC_LENGTH (inner_parms
);
2101 for (i
= 0; i
< ntparms
; ++i
)
2102 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)))
2106 cp_error (msg
, decl
);
2110 /* Clear out the default argument so that we are not
2112 TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)) = NULL_TREE
;
2115 /* At this point, if we're still interested in issuing messages,
2116 they must apply to classes surrounding the object declared. */
2118 msg
= "default argument for template parameter for class enclosing `%D'";
2122 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
2123 parameters given by current_template_args, or reuses a
2124 previously existing one, if appropriate. Returns the DECL, or an
2125 equivalent one, if it is replaced via a call to duplicate_decls.
2127 If IS_FRIEND is non-zero, DECL is a friend declaration. */
2130 push_template_decl_real (decl
, is_friend
)
2141 /* See if this is a partial specialization. */
2142 is_partial
= (TREE_CODE (decl
) == TYPE_DECL
&& DECL_ARTIFICIAL (decl
)
2143 && TREE_CODE (TREE_TYPE (decl
)) != ENUMERAL_TYPE
2144 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)));
2146 is_friend
|= (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_FRIEND_P (decl
));
2149 /* For a friend, we want the context of the friend function, not
2150 the type of which it is a friend. */
2151 ctx
= DECL_CONTEXT (decl
);
2152 else if (DECL_REAL_CONTEXT (decl
)
2153 && TREE_CODE (DECL_REAL_CONTEXT (decl
)) != NAMESPACE_DECL
)
2154 /* In the case of a virtual function, we want the class in which
2156 ctx
= DECL_REAL_CONTEXT (decl
);
2158 /* Otherwise, if we're currently definining some class, the DECL
2159 is assumed to be a member of the class. */
2160 ctx
= current_class_type
;
2162 if (ctx
&& TREE_CODE (ctx
) == NAMESPACE_DECL
)
2165 if (!DECL_CONTEXT (decl
))
2166 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
2168 /* For determining whether this is a primary template or not, we're really
2169 interested in the lexical context, not the true context. */
2171 info
= current_class_type
;
2175 /* See if this is a primary template. */
2176 if (info
&& TREE_CODE (info
) == FUNCTION_DECL
)
2178 /* Note that template_class_depth returns 0 if given NULL_TREE, so
2179 this next line works even when we are at global scope. */
2180 else if (processing_template_decl
> template_class_depth (info
))
2187 if (current_lang_name
== lang_name_c
)
2188 cp_error ("template with C linkage");
2189 if (TREE_CODE (decl
) == TYPE_DECL
&& ANON_AGGRNAME_P (DECL_NAME (decl
)))
2190 cp_error ("template class without a name");
2191 if (TREE_CODE (decl
) == TYPE_DECL
2192 && TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
2193 cp_error ("template declaration of `%#T'", TREE_TYPE (decl
));
2196 /* Check to see that the rules regarding the use of default
2197 arguments are not being violated. */
2198 check_default_tmpl_args (decl
, current_template_parms
,
2199 primary
, is_partial
);
2202 return process_partial_specialization (decl
);
2204 args
= current_template_args ();
2207 || TREE_CODE (ctx
) == FUNCTION_DECL
2208 || TYPE_BEING_DEFINED (ctx
)
2209 || (is_friend
&& !DECL_TEMPLATE_INFO (decl
)))
2211 if (DECL_LANG_SPECIFIC (decl
)
2212 && DECL_TEMPLATE_INFO (decl
)
2213 && DECL_TI_TEMPLATE (decl
))
2214 tmpl
= DECL_TI_TEMPLATE (decl
);
2217 tmpl
= build_template_decl (decl
, current_template_parms
);
2219 if (DECL_LANG_SPECIFIC (decl
)
2220 && DECL_TEMPLATE_SPECIALIZATION (decl
))
2222 /* A specialization of a member template of a template
2224 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
2225 DECL_TEMPLATE_INFO (tmpl
) = DECL_TEMPLATE_INFO (decl
);
2226 DECL_TEMPLATE_INFO (decl
) = NULL_TREE
;
2232 tree a
, t
, current
, parms
;
2235 if (CLASSTYPE_TEMPLATE_INSTANTIATION (ctx
))
2236 cp_error ("must specialize `%#T' before defining member `%#D'",
2238 if (TREE_CODE (decl
) == TYPE_DECL
)
2240 if ((IS_AGGR_TYPE_CODE (TREE_CODE (TREE_TYPE (decl
)))
2241 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
2242 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl
))
2243 && TYPE_TI_TEMPLATE (TREE_TYPE (decl
)))
2244 tmpl
= TYPE_TI_TEMPLATE (TREE_TYPE (decl
));
2247 cp_error ("`%D' does not declare a template type", decl
);
2251 else if (! DECL_TEMPLATE_INFO (decl
))
2253 cp_error ("template definition of non-template `%#D'", decl
);
2257 tmpl
= DECL_TI_TEMPLATE (decl
);
2259 if (is_member_template (tmpl
)
2260 && DECL_FUNCTION_TEMPLATE_P (tmpl
)
2261 && DECL_TEMPLATE_INFO (decl
) && DECL_TI_ARGS (decl
)
2262 && DECL_TEMPLATE_SPECIALIZATION (decl
))
2266 /* The declaration is a specialization of a member
2267 template, declared outside the class. Therefore, the
2268 innermost template arguments will be NULL, so we
2269 replace them with the arguments determined by the
2270 earlier call to check_explicit_specialization. */
2271 args
= DECL_TI_ARGS (decl
);
2274 = build_template_decl (decl
, current_template_parms
);
2275 DECL_TEMPLATE_RESULT (new_tmpl
) = decl
;
2276 TREE_TYPE (new_tmpl
) = TREE_TYPE (decl
);
2277 DECL_TI_TEMPLATE (decl
) = new_tmpl
;
2278 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl
);
2279 DECL_TEMPLATE_INFO (new_tmpl
) =
2280 perm_tree_cons (tmpl
, args
, NULL_TREE
);
2282 register_specialization (new_tmpl
, tmpl
, args
);
2286 /* Make sure the template headers we got make sense. */
2288 parms
= DECL_TEMPLATE_PARMS (tmpl
);
2289 i
= TMPL_PARMS_DEPTH (parms
);
2290 if (TMPL_ARGS_DEPTH (args
) != i
)
2292 cp_error ("expected %d levels of template parms for `%#D', got %d",
2293 i
, decl
, TMPL_ARGS_DEPTH (args
));
2296 for (current
= decl
; i
> 0; --i
, parms
= TREE_CHAIN (parms
))
2298 a
= TMPL_ARGS_LEVEL (args
, i
);
2299 t
= INNERMOST_TEMPLATE_PARMS (parms
);
2301 if (TREE_VEC_LENGTH (t
) != TREE_VEC_LENGTH (a
))
2303 if (current
== decl
)
2304 cp_error ("got %d template parameters for `%#D'",
2305 TREE_VEC_LENGTH (a
), decl
);
2307 cp_error ("got %d template parameters for `%#T'",
2308 TREE_VEC_LENGTH (a
), current
);
2309 cp_error (" but %d required", TREE_VEC_LENGTH (t
));
2312 /* Perhaps we should also check that the parms are used in the
2313 appropriate qualifying scopes in the declarator? */
2315 if (current
== decl
)
2318 current
= TYPE_CONTEXT (current
);
2322 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
2323 TREE_TYPE (tmpl
) = TREE_TYPE (decl
);
2325 /* Push template declarations for global functions and types. Note
2326 that we do not try to push a global template friend declared in a
2327 template class; such a thing may well depend on the template
2328 parameters of the class. */
2330 && !(is_friend
&& template_class_depth (current_class_type
) > 0))
2331 tmpl
= pushdecl_namespace_level (tmpl
);
2334 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
2336 info
= perm_tree_cons (tmpl
, args
, NULL_TREE
);
2338 if (TREE_CODE (decl
) == TYPE_DECL
&& DECL_ARTIFICIAL (decl
))
2340 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl
), info
);
2341 if ((!ctx
|| TREE_CODE (ctx
) != FUNCTION_DECL
)
2342 && TREE_CODE (TREE_TYPE (decl
)) != ENUMERAL_TYPE
)
2343 DECL_NAME (decl
) = classtype_mangled_name (TREE_TYPE (decl
));
2345 else if (! DECL_LANG_SPECIFIC (decl
))
2346 cp_error ("template declaration of `%#D'", decl
);
2348 DECL_TEMPLATE_INFO (decl
) = info
;
2350 return DECL_TEMPLATE_RESULT (tmpl
);
2354 push_template_decl (decl
)
2357 return push_template_decl_real (decl
, 0);
2360 /* Called when a class template TYPE is redeclared with the indicated
2361 template PARMS, e.g.:
2363 template <class T> struct S;
2364 template <class T> struct S {}; */
2367 redeclare_class_template (type
, parms
)
2371 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
2375 if (!PRIMARY_TEMPLATE_P (tmpl
))
2376 /* The type is nested in some template class. Nothing to worry
2377 about here; there are no new template parameters for the nested
2381 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
2382 tmpl_parms
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl
);
2384 if (TREE_VEC_LENGTH (parms
) != TREE_VEC_LENGTH (tmpl_parms
))
2386 cp_error_at ("previous declaration `%D'", tmpl
);
2387 cp_error ("used %d template parameter%s instead of %d",
2388 TREE_VEC_LENGTH (tmpl_parms
),
2389 TREE_VEC_LENGTH (tmpl_parms
) == 1 ? "" : "s",
2390 TREE_VEC_LENGTH (parms
));
2394 for (i
= 0; i
< TREE_VEC_LENGTH (tmpl_parms
); ++i
)
2396 tree tmpl_parm
= TREE_VALUE (TREE_VEC_ELT (tmpl_parms
, i
));
2397 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
2398 tree tmpl_default
= TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
));
2399 tree parm_default
= TREE_PURPOSE (TREE_VEC_ELT (parms
, i
));
2401 if (TREE_CODE (tmpl_parm
) != TREE_CODE (parm
))
2403 cp_error_at ("template parameter `%#D'", tmpl_parm
);
2404 cp_error ("redeclared here as `%#D'", parm
);
2408 if (tmpl_default
!= NULL_TREE
&& parm_default
!= NULL_TREE
)
2410 /* We have in [temp.param]:
2412 A template-parameter may not be given default arguments
2413 by two different declarations in the same scope. */
2414 cp_error ("redefinition of default argument for `%#D'", parm
);
2415 cp_error_at (" original definition appeared here", tmpl_parm
);
2419 if (parm_default
!= NULL_TREE
)
2420 /* Update the previous template parameters (which are the ones
2421 that will really count) with the new default value. */
2422 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
)) = parm_default
;
2426 /* Attempt to convert the non-type template parameter EXPR to the
2427 indicated TYPE. If the conversion is successful, return the
2428 converted value. If the conversion is unsuccesful, return
2429 NULL_TREE if we issued an error message, or error_mark_node if we
2430 did not. We issue error messages for out-and-out bad template
2431 parameters, but not simply because the conversion failed, since we
2432 might be just trying to do argument deduction. By the time this
2433 function is called, neither TYPE nor EXPR may make use of template
2437 convert_nontype_argument (type
, expr
)
2441 tree expr_type
= TREE_TYPE (expr
);
2443 /* A template-argument for a non-type, non-template
2444 template-parameter shall be one of:
2446 --an integral constant-expression of integral or enumeration
2449 --the name of a non-type template-parameter; or
2451 --the name of an object or function with external linkage,
2452 including function templates and function template-ids but
2453 excluding non-static class members, expressed as id-expression;
2456 --the address 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
2459 where the & is optional if the name refers to a function or
2462 --a pointer to member expressed as described in _expr.unary.op_. */
2464 /* An integral constant-expression can include const variables
2466 if (INTEGRAL_TYPE_P (expr_type
) && TREE_READONLY_DECL_P (expr
))
2467 expr
= decl_constant_value (expr
);
2469 if (is_overloaded_fn (expr
))
2470 /* OK for now. We'll check that it has external linkage later.
2471 Check this first since if expr_type is the unknown_type_node
2472 we would otherwise complain below. */
2474 else if (INTEGRAL_TYPE_P (expr_type
)
2475 || TYPE_PTRMEM_P (expr_type
)
2476 || TYPE_PTRMEMFUNC_P (expr_type
)
2477 /* The next two are g++ extensions. */
2478 || TREE_CODE (expr_type
) == REAL_TYPE
2479 || TREE_CODE (expr_type
) == COMPLEX_TYPE
)
2481 if (! TREE_CONSTANT (expr
))
2484 cp_error ("non-constant `%E' cannot be used as template argument",
2489 else if (TYPE_PTR_P (expr_type
)
2490 /* If expr is the address of an overloaded function, we
2491 will get the unknown_type_node at this point. */
2492 || expr_type
== unknown_type_node
)
2498 if (TREE_CODE (e
) != ADDR_EXPR
)
2501 cp_error ("`%E' is not a valid template argument", expr
);
2502 error ("it must be %s%s with external linkage",
2503 TREE_CODE (TREE_TYPE (expr
)) == POINTER_TYPE
2504 ? "a pointer to " : "",
2505 TREE_CODE (TREE_TYPE (TREE_TYPE (expr
))) == FUNCTION_TYPE
2506 ? "a function" : "an object");
2510 referent
= TREE_OPERAND (e
, 0);
2511 STRIP_NOPS (referent
);
2513 if (TREE_CODE (referent
) == STRING_CST
)
2515 cp_error ("string literal %E is not a valid template argument",
2517 error ("because it is the address of an object with static linkage");
2521 if (is_overloaded_fn (referent
))
2522 /* We'll check that it has external linkage later. */
2524 else if (TREE_CODE (referent
) != VAR_DECL
)
2526 else if (!TREE_PUBLIC (referent
))
2528 cp_error ("address of non-extern `%E' cannot be used as template argument", referent
);
2529 return error_mark_node
;
2532 else if (TREE_CODE (expr
) == VAR_DECL
)
2534 if (!TREE_PUBLIC (expr
))
2539 cp_error ("object `%E' cannot be used as template argument", expr
);
2543 switch (TREE_CODE (type
))
2548 /* For a non-type template-parameter of integral or enumeration
2549 type, integral promotions (_conv.prom_) and integral
2550 conversions (_conv.integral_) are applied. */
2551 if (!INTEGRAL_TYPE_P (expr_type
))
2552 return error_mark_node
;
2554 /* It's safe to call digest_init in this case; we know we're
2555 just converting one integral constant expression to another. */
2556 expr
= digest_init (type
, expr
, (tree
*) 0);
2558 if (TREE_CODE (expr
) != INTEGER_CST
)
2559 /* Curiously, some TREE_CONSTNAT integral expressions do not
2560 simplify to integer constants. For example, `3 % 0',
2561 remains a TRUNC_MOD_EXPR. */
2568 /* These are g++ extensions. */
2569 if (TREE_CODE (expr_type
) != TREE_CODE (type
))
2570 return error_mark_node
;
2572 expr
= digest_init (type
, expr
, (tree
*) 0);
2574 if (TREE_CODE (expr
) != REAL_CST
)
2581 tree type_pointed_to
= TREE_TYPE (type
);
2583 if (TYPE_PTRMEM_P (type
))
2584 /* For a non-type template-parameter of type pointer to data
2585 member, qualification conversions (_conv.qual_) are
2587 return perform_qualification_conversions (type
, expr
);
2588 else if (TREE_CODE (type_pointed_to
) == FUNCTION_TYPE
)
2590 /* For a non-type template-parameter of type pointer to
2591 function, only the function-to-pointer conversion
2592 (_conv.func_) is applied. If the template-argument
2593 represents a set of overloaded functions (or a pointer to
2594 such), the matching function is selected from the set
2599 if (TREE_CODE (expr
) == ADDR_EXPR
)
2600 fns
= TREE_OPERAND (expr
, 0);
2604 fn
= instantiate_type (type_pointed_to
, fns
, 0);
2606 if (fn
== error_mark_node
)
2607 return error_mark_node
;
2609 if (!TREE_PUBLIC (fn
))
2611 if (really_overloaded_fn (fns
))
2612 return error_mark_node
;
2617 expr
= build_unary_op (ADDR_EXPR
, fn
, 0);
2619 my_friendly_assert (same_type_p (type
, TREE_TYPE (expr
)),
2625 /* For a non-type template-parameter of type pointer to
2626 object, qualification conversions (_conv.qual_) and the
2627 array-to-pointer conversion (_conv.array_) are applied.
2628 [Note: In particular, neither the null pointer conversion
2629 (_conv.ptr_) nor the derived-to-base conversion
2630 (_conv.ptr_) are applied. Although 0 is a valid
2631 template-argument for a non-type template-parameter of
2632 integral type, it is not a valid template-argument for a
2633 non-type template-parameter of pointer type.]
2635 The call to decay_conversion performs the
2636 array-to-pointer conversion, if appropriate. */
2637 expr
= decay_conversion (expr
);
2639 if (expr
== error_mark_node
)
2640 return error_mark_node
;
2642 return perform_qualification_conversions (type
, expr
);
2647 case REFERENCE_TYPE
:
2649 tree type_referred_to
= TREE_TYPE (type
);
2651 if (TREE_CODE (type_referred_to
) == FUNCTION_TYPE
)
2653 /* For a non-type template-parameter of type reference to
2654 function, no conversions apply. If the
2655 template-argument represents a set of overloaded
2656 functions, the matching function is selected from the
2657 set (_over.over_). */
2661 fn
= instantiate_type (type_referred_to
, fns
, 0);
2663 if (fn
== error_mark_node
)
2664 return error_mark_node
;
2666 if (!TREE_PUBLIC (fn
))
2668 if (really_overloaded_fn (fns
))
2669 /* Don't issue an error here; we might get a different
2670 function if the overloading had worked out
2672 return error_mark_node
;
2677 my_friendly_assert (same_type_p (type_referred_to
,
2685 /* For a non-type template-parameter of type reference to
2686 object, no conversions apply. The type referred to by the
2687 reference may be more cv-qualified than the (otherwise
2688 identical) type of the template-argument. The
2689 template-parameter is bound directly to the
2690 template-argument, which must be an lvalue. */
2691 if ((TYPE_MAIN_VARIANT (expr_type
)
2692 != TYPE_MAIN_VARIANT (type_referred_to
))
2693 || !at_least_as_qualified_p (type_referred_to
,
2695 || !real_lvalue_p (expr
))
2696 return error_mark_node
;
2708 if (!TYPE_PTRMEMFUNC_P (type
))
2709 /* This handles templates like
2710 template<class T, T t> void f();
2711 when T is substituted with any class. The second template
2712 parameter becomes invalid and the template candidate is
2714 return error_mark_node
;
2716 /* For a non-type template-parameter of type pointer to member
2717 function, no conversions apply. If the template-argument
2718 represents a set of overloaded member functions, the
2719 matching member function is selected from the set
2722 if (!TYPE_PTRMEMFUNC_P (expr_type
) &&
2723 expr_type
!= unknown_type_node
)
2724 return error_mark_node
;
2726 if (TREE_CODE (expr
) == CONSTRUCTOR
)
2728 /* A ptr-to-member constant. */
2729 if (!same_type_p (type
, expr_type
))
2730 return error_mark_node
;
2735 if (TREE_CODE (expr
) != ADDR_EXPR
)
2736 return error_mark_node
;
2738 fns
= TREE_OPERAND (expr
, 0);
2740 fn
= instantiate_type (TREE_TYPE (TREE_TYPE (type
)),
2743 if (fn
== error_mark_node
)
2744 return error_mark_node
;
2746 expr
= build_unary_op (ADDR_EXPR
, fn
, 0);
2748 my_friendly_assert (same_type_p (type
, TREE_TYPE (expr
)),
2755 /* All non-type parameters must have one of these types. */
2756 my_friendly_abort (0);
2760 return error_mark_node
;
2763 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
2764 template template parameters. Both PARM_PARMS and ARG_PARMS are
2765 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
2768 ARG_PARMS may contain more parameters than PARM_PARMS. If this is
2769 the case, then extra parameters must have default arguments.
2771 Consider the example:
2772 template <class T, class Allocator = allocator> class vector;
2773 template<template <class U> class TT> class C;
2775 C<vector> is a valid instantiation. PARM_PARMS for the above code
2776 contains a TYPE_DECL (for U), ARG_PARMS contains two TYPE_DECLs (for
2777 T and Allocator) and OUTER_ARGS contains the argument that is used to
2778 substitute the TT parameter. */
2781 coerce_template_template_parms (parm_parms
, arg_parms
, in_decl
, outer_args
)
2782 tree parm_parms
, arg_parms
, in_decl
, outer_args
;
2784 int nparms
, nargs
, i
;
2787 my_friendly_assert (TREE_CODE (parm_parms
) == TREE_VEC
, 0);
2788 my_friendly_assert (TREE_CODE (arg_parms
) == TREE_VEC
, 0);
2790 nparms
= TREE_VEC_LENGTH (parm_parms
);
2791 nargs
= TREE_VEC_LENGTH (arg_parms
);
2793 /* The rule here is opposite of coerce_template_parms. */
2796 && TREE_PURPOSE (TREE_VEC_ELT (arg_parms
, nparms
)) == NULL_TREE
))
2799 for (i
= 0; i
< nparms
; ++i
)
2801 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
2802 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
2804 if (arg
== NULL_TREE
|| arg
== error_mark_node
2805 || parm
== NULL_TREE
|| parm
== error_mark_node
)
2808 if (TREE_CODE (arg
) != TREE_CODE (parm
))
2811 switch (TREE_CODE (parm
))
2817 /* We encounter instantiations of templates like
2818 template <template <template <class> class> class TT>
2820 sorry ("nested template template parameter");
2824 /* The tsubst call is used to handle cases such as
2825 template <class T, template <T> class TT> class D;
2826 i.e. the parameter list of TT depends on earlier parameters. */
2827 if (!same_type_p (tsubst (TREE_TYPE (parm
), outer_args
, in_decl
),
2833 my_friendly_abort (0);
2839 /* Convert the indicated template ARG as necessary to match the
2840 indicated template PARM. Returns the converted ARG, or
2841 error_mark_node if the conversion was unsuccessful. Error messages
2842 are issued if COMPLAIN is non-zero. This conversion is for the Ith
2843 parameter in the parameter list. ARGS is the full set of template
2844 arguments deduced so far. */
2847 convert_template_argument (parm
, arg
, args
, complain
, i
, in_decl
)
2857 int is_type
, requires_type
, is_tmpl_type
, requires_tmpl_type
;
2859 inner_args
= innermost_args (args
);
2861 if (TREE_CODE (arg
) == TREE_LIST
2862 && TREE_TYPE (arg
) != NULL_TREE
2863 && TREE_CODE (TREE_TYPE (arg
)) == OFFSET_TYPE
)
2865 /* The template argument was the name of some
2866 member function. That's usually
2867 illegal, but static members are OK. In any
2868 case, grab the underlying fields/functions
2869 and issue an error later if required. */
2870 arg
= TREE_VALUE (arg
);
2871 TREE_TYPE (arg
) = unknown_type_node
;
2874 requires_tmpl_type
= TREE_CODE (parm
) == TEMPLATE_DECL
;
2875 requires_type
= (TREE_CODE (parm
) == TYPE_DECL
2876 || requires_tmpl_type
);
2878 /* Check if it is a class template. If REQUIRES_TMPL_TYPE is true,
2879 we also accept implicitly created TYPE_DECL as a valid argument.
2880 This is necessary to handle the case where we pass a template name
2881 to a template template parameter in a scope where we've derived from
2882 in instantiation of that template, so the template name refers to that
2883 instantiation. We really ought to handle this better. */
2885 = ((TREE_CODE (arg
) == TEMPLATE_DECL
2886 && TREE_CODE (DECL_TEMPLATE_RESULT (arg
)) == TYPE_DECL
)
2887 || (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
2888 && !TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (arg
))
2889 || (TREE_CODE (arg
) == RECORD_TYPE
2890 && CLASSTYPE_TEMPLATE_INFO (arg
)
2891 && TREE_CODE (TYPE_NAME (arg
)) == TYPE_DECL
2892 && DECL_ARTIFICIAL (TYPE_NAME (arg
))
2893 && requires_tmpl_type
2894 && is_base_of_enclosing_class (arg
, current_class_type
)));
2895 if (is_tmpl_type
&& TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
2896 arg
= TYPE_STUB_DECL (arg
);
2897 else if (is_tmpl_type
&& TREE_CODE (arg
) == RECORD_TYPE
)
2898 arg
= CLASSTYPE_TI_TEMPLATE (arg
);
2900 is_type
= TREE_CODE_CLASS (TREE_CODE (arg
)) == 't' || is_tmpl_type
;
2902 if (requires_type
&& ! is_type
&& TREE_CODE (arg
) == SCOPE_REF
2903 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_TYPE_PARM
)
2905 cp_pedwarn ("to refer to a type member of a template parameter,");
2906 cp_pedwarn (" use `typename %E'", arg
);
2908 arg
= make_typename_type (TREE_OPERAND (arg
, 0),
2909 TREE_OPERAND (arg
, 1));
2912 if (is_type
!= requires_type
)
2918 cp_error ("type/value mismatch at argument %d in template parameter list for `%D'",
2921 cp_error (" expected a constant of type `%T', got `%T'",
2923 (is_tmpl_type
? DECL_NAME (arg
) : arg
));
2925 cp_error (" expected a type, got `%E'", arg
);
2928 return error_mark_node
;
2930 if (is_tmpl_type
^ requires_tmpl_type
)
2932 if (in_decl
&& complain
)
2934 cp_error ("type/value mismatch at argument %d in template parameter list for `%D'",
2937 cp_error (" expected a type, got `%T'", DECL_NAME (arg
));
2939 cp_error (" expected a class template, got `%T'", arg
);
2941 return error_mark_node
;
2946 if (requires_tmpl_type
)
2948 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
2949 tree argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
2951 if (coerce_template_template_parms (parmparm
, argparm
,
2952 in_decl
, inner_args
))
2956 /* TEMPLATE_TEMPLATE_PARM node is preferred over
2958 if (val
!= error_mark_node
2959 && DECL_TEMPLATE_TEMPLATE_PARM_P (val
))
2960 val
= TREE_TYPE (val
);
2964 if (in_decl
&& complain
)
2966 cp_error ("type/value mismatch at argument %d in template parameter list for `%D'",
2968 cp_error (" expected a template of type `%D', got `%D'", parm
, arg
);
2971 val
= error_mark_node
;
2976 val
= groktypename (arg
);
2977 if (! processing_template_decl
)
2979 /* [basic.link]: A name with no linkage (notably, the
2980 name of a class or enumeration declared in a local
2981 scope) shall not be used to declare an entity with
2982 linkage. This implies that names with no linkage
2983 cannot be used as template arguments. */
2984 tree t
= no_linkage_check (val
);
2987 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
2989 ("template-argument `%T' uses anonymous type", val
);
2992 ("template-argument `%T' uses local type `%T'",
2994 return error_mark_node
;
3001 tree t
= tsubst (TREE_TYPE (parm
), args
, in_decl
);
3003 if (processing_template_decl
)
3004 arg
= maybe_fold_nontype_arg (arg
);
3006 if (!uses_template_parms (arg
) && !uses_template_parms (t
))
3007 /* We used to call digest_init here. However, digest_init
3008 will report errors, which we don't want when complain
3009 is zero. More importantly, digest_init will try too
3010 hard to convert things: for example, `0' should not be
3011 converted to pointer type at this point according to
3012 the standard. Accepting this is not merely an
3013 extension, since deciding whether or not these
3014 conversions can occur is part of determining which
3015 function template to call, or whether a given epxlicit
3016 argument specification is legal. */
3017 val
= convert_nontype_argument (t
, arg
);
3021 if (val
== NULL_TREE
)
3022 val
= error_mark_node
;
3023 else if (val
== error_mark_node
&& complain
)
3024 cp_error ("could not convert template argument `%E' to `%T'",
3031 /* Convert all template arguments to their appropriate types, and
3032 return a vector containing the innermost resulting template
3033 arguments. If any error occurs, return error_mark_node, and, if
3034 COMPLAIN is non-zero, issue an error message. Some error messages
3035 are issued even if COMPLAIN is zero; for instance, if a template
3036 argument is composed from a local class.
3038 If REQUIRE_ALL_ARGUMENTS is non-zero, all arguments must be
3039 provided in ARGLIST, or else trailing parameters must have default
3040 values. If REQUIRE_ALL_ARGUMENTS is zero, we will attempt argument
3041 deduction for any unspecified trailing arguments.
3043 The resulting TREE_VEC is allocated on a temporary obstack, and
3044 must be explicitly copied if it will be permanent. */
3047 coerce_template_parms (parms
, args
, in_decl
,
3049 require_all_arguments
)
3053 int require_all_arguments
;
3055 int nparms
, nargs
, i
, lost
= 0;
3058 tree new_inner_args
;
3060 inner_args
= innermost_args (args
);
3061 nargs
= NUM_TMPL_ARGS (inner_args
);
3062 nparms
= TREE_VEC_LENGTH (parms
);
3066 && require_all_arguments
3067 && TREE_PURPOSE (TREE_VEC_ELT (parms
, nargs
)) == NULL_TREE
))
3071 cp_error ("wrong number of template arguments (%d, should be %d)",
3075 cp_error_at ("provided for `%D'", in_decl
);
3078 return error_mark_node
;
3081 new_inner_args
= make_temp_vec (nparms
);
3082 new_args
= add_outermost_template_args (args
, new_inner_args
);
3083 for (i
= 0; i
< nparms
; i
++)
3088 /* Get the Ith template parameter. */
3089 parm
= TREE_VEC_ELT (parms
, i
);
3091 /* Calculate the Ith argument. */
3092 if (inner_args
&& TREE_CODE (inner_args
) == TREE_LIST
)
3094 arg
= TREE_VALUE (inner_args
);
3095 inner_args
= TREE_CHAIN (inner_args
);
3098 arg
= TREE_VEC_ELT (inner_args
, i
);
3099 /* If no template argument was supplied, look for a default
3101 else if (TREE_PURPOSE (parm
) == NULL_TREE
)
3103 /* There was no default value. */
3104 my_friendly_assert (!require_all_arguments
, 0);
3107 else if (TREE_CODE (TREE_VALUE (parm
)) == TYPE_DECL
)
3108 arg
= tsubst (TREE_PURPOSE (parm
), new_args
, in_decl
);
3110 arg
= tsubst_expr (TREE_PURPOSE (parm
), new_args
, in_decl
);
3112 /* Now, convert the Ith argument, as necessary. */
3113 if (arg
== NULL_TREE
)
3114 /* We're out of arguments. */
3116 my_friendly_assert (!require_all_arguments
, 0);
3119 else if (arg
== error_mark_node
)
3121 cp_error ("template argument %d is invalid", i
+ 1);
3122 arg
= error_mark_node
;
3125 arg
= convert_template_argument (TREE_VALUE (parm
),
3126 arg
, new_args
, complain
, i
,
3129 if (arg
== error_mark_node
)
3131 TREE_VEC_ELT (new_inner_args
, i
) = arg
;
3135 return error_mark_node
;
3137 return new_inner_args
;
3140 /* Returns 1 if template args OT and NT are equivalent. */
3143 template_args_equal (ot
, nt
)
3148 if (TREE_CODE (nt
) != TREE_CODE (ot
))
3150 if (TREE_CODE (nt
) == TREE_VEC
)
3151 /* For member templates */
3152 return comp_template_args (ot
, nt
);
3153 else if (TREE_CODE_CLASS (TREE_CODE (ot
)) == 't')
3154 return same_type_p (ot
, nt
);
3156 return (cp_tree_equal (ot
, nt
) > 0);
3159 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
3160 of template arguments. Returns 0 otherwise. */
3163 comp_template_args (oldargs
, newargs
)
3164 tree oldargs
, newargs
;
3168 if (TREE_VEC_LENGTH (oldargs
) != TREE_VEC_LENGTH (newargs
))
3171 for (i
= 0; i
< TREE_VEC_LENGTH (oldargs
); ++i
)
3173 tree nt
= TREE_VEC_ELT (newargs
, i
);
3174 tree ot
= TREE_VEC_ELT (oldargs
, i
);
3176 if (! template_args_equal (ot
, nt
))
3182 /* Given class template name and parameter list, produce a user-friendly name
3183 for the instantiation. */
3186 mangle_class_name_for_template (name
, parms
, arglist
)
3188 tree parms
, arglist
;
3190 static struct obstack scratch_obstack
;
3191 static char *scratch_firstobj
;
3194 if (!scratch_firstobj
)
3195 gcc_obstack_init (&scratch_obstack
);
3197 obstack_free (&scratch_obstack
, scratch_firstobj
);
3198 scratch_firstobj
= obstack_alloc (&scratch_obstack
, 1);
3200 #define ccat(c) obstack_1grow (&scratch_obstack, (c));
3201 #define cat(s) obstack_grow (&scratch_obstack, (s), strlen (s))
3205 nparms
= TREE_VEC_LENGTH (parms
);
3206 arglist
= innermost_args (arglist
);
3207 my_friendly_assert (nparms
== TREE_VEC_LENGTH (arglist
), 268);
3208 for (i
= 0; i
< nparms
; i
++)
3210 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
3211 tree arg
= TREE_VEC_ELT (arglist
, i
);
3216 if (TREE_CODE (parm
) == TYPE_DECL
)
3218 cat (type_as_string_real (arg
, 0, 1));
3221 else if (TREE_CODE (parm
) == TEMPLATE_DECL
)
3223 if (TREE_CODE (arg
) == TEMPLATE_DECL
)
3225 /* Already substituted with real template. Just output
3226 the template name here */
3227 tree context
= DECL_CONTEXT (arg
);
3230 my_friendly_assert (TREE_CODE (context
) == NAMESPACE_DECL
, 980422);
3231 cat(decl_as_string (DECL_CONTEXT (arg
), 0));
3234 cat (IDENTIFIER_POINTER (DECL_NAME (arg
)));
3237 /* Output the parameter declaration */
3238 cat (type_as_string_real (arg
, 0, 1));
3242 my_friendly_assert (TREE_CODE (parm
) == PARM_DECL
, 269);
3244 if (TREE_CODE (arg
) == TREE_LIST
)
3246 /* New list cell was built because old chain link was in
3248 my_friendly_assert (TREE_PURPOSE (arg
) == NULL_TREE
, 270);
3249 arg
= TREE_VALUE (arg
);
3251 /* No need to check arglist against parmlist here; we did that
3252 in coerce_template_parms, called from lookup_template_class. */
3253 cat (expr_as_string (arg
, 0));
3256 char *bufp
= obstack_next_free (&scratch_obstack
);
3258 while (bufp
[offset
- 1] == ' ')
3260 obstack_blank_fast (&scratch_obstack
, offset
);
3262 /* B<C<char> >, not B<C<char>> */
3263 if (bufp
[offset
- 1] == '>')
3268 return (char *) obstack_base (&scratch_obstack
);
3272 classtype_mangled_name (t
)
3275 if (CLASSTYPE_TEMPLATE_INFO (t
)
3276 /* Specializations have already had their names set up in
3277 lookup_template_class. */
3278 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
3280 tree tmpl
= most_general_template (CLASSTYPE_TI_TEMPLATE (t
));
3282 /* For non-primary templates, the template parameters are
3283 implicit from their surrounding context. */
3284 if (PRIMARY_TEMPLATE_P (tmpl
))
3286 tree name
= DECL_NAME (tmpl
);
3287 char *mangled_name
= mangle_class_name_for_template
3288 (IDENTIFIER_POINTER (name
),
3289 DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
3290 CLASSTYPE_TI_ARGS (t
));
3291 tree id
= get_identifier (mangled_name
);
3292 IDENTIFIER_TEMPLATE (id
) = name
;
3297 return TYPE_IDENTIFIER (t
);
3301 add_pending_template (d
)
3306 if (TREE_CODE_CLASS (TREE_CODE (d
)) == 't')
3307 ti
= CLASSTYPE_TEMPLATE_INFO (d
);
3309 ti
= DECL_TEMPLATE_INFO (d
);
3311 if (TI_PENDING_TEMPLATE_FLAG (ti
))
3314 *template_tail
= perm_tree_cons
3315 (build_srcloc_here (), d
, NULL_TREE
);
3316 template_tail
= &TREE_CHAIN (*template_tail
);
3317 TI_PENDING_TEMPLATE_FLAG (ti
) = 1;
3321 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS (which
3322 may be either a _DECL or an overloaded function or an
3323 IDENTIFIER_NODE), and ARGLIST. */
3326 lookup_template_function (fns
, arglist
)
3331 if (fns
== NULL_TREE
)
3333 cp_error ("non-template used as template");
3334 return error_mark_node
;
3337 type
= TREE_TYPE (fns
);
3338 if (TREE_CODE (fns
) == OVERLOAD
|| !type
)
3339 type
= unknown_type_node
;
3341 if (processing_template_decl
)
3342 return build_min (TEMPLATE_ID_EXPR
, type
, fns
, arglist
);
3344 return build (TEMPLATE_ID_EXPR
, type
, fns
, arglist
);
3347 /* Within the scope of a template class S<T>, the name S gets bound
3348 (in build_self_reference) to a TYPE_DECL for the class, not a
3349 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
3350 or one of its enclosing classes, and that type is a template,
3351 return the associated TEMPLATE_DECL. Otherwise, the original
3352 DECL is returned. */
3355 maybe_get_template_decl_from_type_decl (decl
)
3358 return (decl
!= NULL_TREE
3359 && TREE_CODE (decl
) == TYPE_DECL
3360 && DECL_ARTIFICIAL (decl
)
3361 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl
)))
3362 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl
)) : decl
;
3365 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
3366 parameters, find the desired type.
3368 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
3369 (Actually ARGLIST may be either a TREE_LIST or a TREE_VEC. It will
3370 be a TREE_LIST if called directly from the parser, and a TREE_VEC
3371 otherwise.) Since ARGLIST is build on the decl_obstack, we must
3372 copy it here to keep it from being reclaimed when the decl storage
3375 IN_DECL, if non-NULL, is the template declaration we are trying to
3378 If ENTERING_SCOPE is non-zero, we are about to enter the scope of
3379 the class we are looking up.
3381 If the template class is really a local class in a template
3382 function, then the FUNCTION_CONTEXT is the function in which it is
3383 being instantiated. */
3386 lookup_template_class (d1
, arglist
, in_decl
, context
, entering_scope
)
3392 tree
template = NULL_TREE
, parmlist
;
3395 if (TREE_CODE (d1
) == IDENTIFIER_NODE
)
3397 if (IDENTIFIER_LOCAL_VALUE (d1
)
3398 && DECL_TEMPLATE_TEMPLATE_PARM_P (IDENTIFIER_LOCAL_VALUE (d1
)))
3399 template = IDENTIFIER_LOCAL_VALUE (d1
);
3403 push_decl_namespace (context
);
3404 if (current_class_type
!= NULL_TREE
)
3406 maybe_get_template_decl_from_type_decl
3407 (IDENTIFIER_CLASS_VALUE (d1
));
3408 if (template == NULL_TREE
)
3409 template = lookup_name_nonclass (d1
);
3411 pop_decl_namespace ();
3414 context
= DECL_CONTEXT (template);
3416 else if (TREE_CODE (d1
) == TYPE_DECL
&& IS_AGGR_TYPE (TREE_TYPE (d1
)))
3418 if (CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (d1
)) == NULL_TREE
)
3419 return error_mark_node
;
3420 template = CLASSTYPE_TI_TEMPLATE (TREE_TYPE (d1
));
3421 d1
= DECL_NAME (template);
3423 else if (TREE_CODE (d1
) == ENUMERAL_TYPE
3424 || (TREE_CODE_CLASS (TREE_CODE (d1
)) == 't'
3425 && IS_AGGR_TYPE (d1
)))
3427 template = TYPE_TI_TEMPLATE (d1
);
3428 d1
= DECL_NAME (template);
3430 else if (TREE_CODE (d1
) == TEMPLATE_DECL
3431 && TREE_CODE (DECL_RESULT (d1
)) == TYPE_DECL
)
3434 d1
= DECL_NAME (template);
3435 context
= DECL_CONTEXT (template);
3438 my_friendly_abort (272);
3440 /* With something like `template <class T> class X class X { ... };'
3441 we could end up with D1 having nothing but an IDENTIFIER_LOCAL_VALUE.
3442 We don't want to do that, but we have to deal with the situation, so
3443 let's give them some syntax errors to chew on instead of a crash. */
3445 return error_mark_node
;
3447 if (context
== NULL_TREE
)
3448 context
= global_namespace
;
3450 if (TREE_CODE (template) != TEMPLATE_DECL
)
3452 cp_error ("non-template type `%T' used as a template", d1
);
3454 cp_error_at ("for template declaration `%D'", in_decl
);
3455 return error_mark_node
;
3458 if (DECL_TEMPLATE_TEMPLATE_PARM_P (template))
3460 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
3461 template arguments */
3463 tree parm
= copy_template_template_parm (TREE_TYPE (template));
3464 tree template2
= TYPE_STUB_DECL (parm
);
3467 parmlist
= DECL_INNERMOST_TEMPLATE_PARMS (template);
3469 arglist2
= coerce_template_parms (parmlist
, arglist
, template, 1, 1);
3470 if (arglist2
== error_mark_node
)
3471 return error_mark_node
;
3473 arglist2
= copy_to_permanent (arglist2
);
3474 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm
)
3475 = perm_tree_cons (template2
, arglist2
, NULL_TREE
);
3476 TYPE_SIZE (parm
) = 0;
3481 tree template_type
= TREE_TYPE (template);
3483 tree found
= NULL_TREE
;
3486 int is_partial_instantiation
;
3488 template = most_general_template (template);
3489 parmlist
= DECL_TEMPLATE_PARMS (template);
3490 parm_depth
= TMPL_PARMS_DEPTH (parmlist
);
3491 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
3493 /* We build up the coerced arguments and such on the
3494 momentary_obstack. */
3497 if (arg_depth
== 1 && parm_depth
> 1)
3499 /* We've been given an incomplete set of template arguments.
3502 template <class T> struct S1 {
3503 template <class U> struct S2 {};
3504 template <class U> struct S2<U*> {};
3507 we will be called with an ARGLIST of `U*', but the
3508 TEMPLATE will be `template <class T> template
3509 <class U> struct S1<T>::S2'. We must fill in the missing
3511 my_friendly_assert (context
!= NULL_TREE
, 0);
3512 while (!IS_AGGR_TYPE_CODE (TREE_CODE (context
))
3513 && context
!= global_namespace
)
3514 context
= DECL_REAL_CONTEXT (context
);
3516 if (context
== global_namespace
)
3517 /* This is bad. We cannot get enough arguments, even from
3518 the surrounding context, to resolve this class. One
3519 case where this might happen is (illegal) code like:
3527 We should catch this error sooner (at the opening curly
3528 for `S', but it is better to be safe than sorry here. */
3530 cp_error ("invalid use of `%D'", template);
3531 return error_mark_node
;
3534 arglist
= add_to_template_args (TYPE_TI_ARGS (context
),
3536 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
3539 my_friendly_assert (parm_depth
== arg_depth
, 0);
3541 /* Calculate the BOUND_ARGS. These will be the args that are
3542 actually tsubst'd into the definition to create the
3546 /* We have multiple levels of arguments to coerce, at once. */
3548 int saved_depth
= TMPL_ARGS_DEPTH (arglist
);
3550 tree bound_args
= make_temp_vec (parm_depth
);
3552 for (i
= saved_depth
,
3553 t
= DECL_TEMPLATE_PARMS (template);
3554 i
> 0 && t
!= NULL_TREE
;
3555 --i
, t
= TREE_CHAIN (t
))
3557 tree a
= coerce_template_parms (TREE_VALUE (t
),
3558 arglist
, template, 1, 1);
3559 SET_TMPL_ARGS_LEVEL (bound_args
, i
, a
);
3561 /* We temporarily reduce the length of the ARGLIST so
3562 that coerce_template_parms will see only the arguments
3563 corresponding to the template parameters it is
3565 TREE_VEC_LENGTH (arglist
)--;
3568 /* Restore the ARGLIST to its full size. */
3569 TREE_VEC_LENGTH (arglist
) = saved_depth
;
3571 arglist
= bound_args
;
3575 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist
),
3576 innermost_args (arglist
),
3579 if (arglist
== error_mark_node
)
3580 /* We were unable to bind the arguments. */
3581 return error_mark_node
;
3583 /* In the scope of a template class, explicit references to the
3584 template class refer to the type of the template, not any
3585 instantiation of it. For example, in:
3587 template <class T> class C { void f(C<T>); }
3589 the `C<T>' is just the same as `C'. Outside of the
3590 class, however, such a reference is an instantiation. */
3591 if (comp_template_args (TYPE_TI_ARGS (template_type
),
3594 found
= template_type
;
3596 if (!entering_scope
&& PRIMARY_TEMPLATE_P (template))
3600 /* Note that we use DECL_CONTEXT, rather than
3601 CP_DECL_CONTEXT, so that the termination test is
3602 always just `ctx'. We're not interested in namepace
3604 for (ctx
= current_class_type
;
3606 ctx
= (TREE_CODE_CLASS (TREE_CODE (ctx
)) == 't')
3607 ? TYPE_CONTEXT (ctx
) : DECL_CONTEXT (ctx
))
3608 if (same_type_p (ctx
, template_type
))
3612 /* We're not in the scope of the class, so the
3613 TEMPLATE_TYPE is not the type we want after
3621 for (found
= DECL_TEMPLATE_INSTANTIATIONS (template);
3622 found
; found
= TREE_CHAIN (found
))
3623 if (comp_template_args (TREE_PURPOSE (found
), arglist
))
3627 found
= TREE_VALUE (found
);
3636 /* Since we didn't find the type, we'll have to create it.
3637 Since we'll be saving this type on the
3638 DECL_TEMPLATE_INSTANTIATIONS list, it must be permanent. */
3639 push_obstacks (&permanent_obstack
, &permanent_obstack
);
3641 /* This type is a "partial instantiation" if any of the template
3642 arguments still inolve template parameters. Note that we set
3643 IS_PARTIAL_INSTANTIATION for partial specializations as
3645 is_partial_instantiation
= uses_template_parms (arglist
);
3647 /* Create the type. */
3648 if (TREE_CODE (template_type
) == ENUMERAL_TYPE
)
3650 if (!is_partial_instantiation
)
3651 t
= start_enum (TYPE_IDENTIFIER (template_type
));
3653 /* We don't want to call start_enum for this type, since
3654 the values for the enumeration constants may involve
3655 template parameters. And, no one should be interested
3656 in the enumeration constants for such a type. */
3657 t
= make_node (ENUMERAL_TYPE
);
3661 t
= make_lang_type (TREE_CODE (template_type
));
3662 CLASSTYPE_DECLARED_CLASS (t
)
3663 = CLASSTYPE_DECLARED_CLASS (template_type
);
3664 CLASSTYPE_GOT_SEMICOLON (t
) = 1;
3665 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t
);
3666 TYPE_FOR_JAVA (t
) = TYPE_FOR_JAVA (template_type
);
3669 /* If we called start_enum above, this information will already
3673 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
3675 /* Create a stub TYPE_DECL for it. */
3676 type_decl
= build_decl (TYPE_DECL
, DECL_NAME (template), t
);
3677 SET_DECL_ARTIFICIAL (type_decl
);
3678 DECL_CONTEXT (type_decl
) = TYPE_CONTEXT (t
);
3679 DECL_SOURCE_FILE (type_decl
)
3680 = DECL_SOURCE_FILE (TYPE_STUB_DECL (template_type
));
3681 DECL_SOURCE_LINE (type_decl
)
3682 = DECL_SOURCE_LINE (TYPE_STUB_DECL (template_type
));
3683 TYPE_STUB_DECL (t
) = TYPE_NAME (t
) = type_decl
;
3686 type_decl
= TYPE_NAME (t
);
3688 /* Set up the template information. We have to figure out which
3689 template is the immediate parent if this is a full
3691 if (parm_depth
== 1 || is_partial_instantiation
3692 || !PRIMARY_TEMPLATE_P (template))
3693 /* This case is easy; there are no member templates involved. */
3697 /* This is a full instantiation of a member template. There
3698 should be some partial instantiation of which this is an
3701 for (found
= DECL_TEMPLATE_INSTANTIATIONS (template);
3702 found
; found
= TREE_CHAIN (found
))
3705 tree tmpl
= CLASSTYPE_TI_TEMPLATE (TREE_VALUE (found
));
3707 /* We only want partial instantiations, here, not
3708 specializations or full instantiations. */
3709 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_VALUE (found
))
3710 || !uses_template_parms (TREE_VALUE (found
)))
3713 /* Temporarily reduce by one the number of levels in the
3714 ARGLIST and in FOUND so as to avoid comparing the
3715 last set of arguments. */
3716 TREE_VEC_LENGTH (arglist
)--;
3717 TREE_VEC_LENGTH (TREE_PURPOSE (found
)) --;
3719 /* See if the arguments match. If they do, then TMPL is
3720 the partial instantiation we want. */
3721 success
= comp_template_args (TREE_PURPOSE (found
), arglist
);
3723 /* Restore the argument vectors to their full size. */
3724 TREE_VEC_LENGTH (arglist
)++;
3725 TREE_VEC_LENGTH (TREE_PURPOSE (found
))++;
3735 my_friendly_abort (0);
3738 arglist
= copy_to_permanent (arglist
);
3739 SET_TYPE_TEMPLATE_INFO (t
,
3740 tree_cons (found
, arglist
, NULL_TREE
));
3741 DECL_TEMPLATE_INSTANTIATIONS (template)
3742 = tree_cons (arglist
, t
,
3743 DECL_TEMPLATE_INSTANTIATIONS (template));
3745 if (TREE_CODE (t
) == ENUMERAL_TYPE
3746 && !is_partial_instantiation
)
3747 /* Now that the type has been registered on the instantiations
3748 list, we set up the enumerators. Because the enumeration
3749 constants may involve the enumeration type itself, we make
3750 sure to register the type first, and then create the
3751 constants. That way, doing tsubst_expr for the enumeration
3752 constants won't result in recursive calls here; we'll find
3753 the instantiation and exit above. */
3754 tsubst_enum (template_type
, t
, arglist
);
3756 /* We're done with the permanent obstack, now. */
3758 /* We're also done with the momentary allocation we started
3762 /* Reset the name of the type, now that CLASSTYPE_TEMPLATE_INFO
3764 if (TREE_CODE (t
) != ENUMERAL_TYPE
)
3765 DECL_NAME (type_decl
) = classtype_mangled_name (t
);
3766 DECL_ASSEMBLER_NAME (type_decl
) = DECL_NAME (type_decl
);
3767 if (!is_partial_instantiation
)
3769 DECL_ASSEMBLER_NAME (type_decl
)
3770 = get_identifier (build_overload_name (t
, 1, 1));
3772 /* For backwards compatibility; code that uses
3773 -fexternal-templates expects looking up a template to
3774 instantiate it. I think DDD still relies on this.
3775 (jason 8/20/1998) */
3776 if (TREE_CODE (t
) != ENUMERAL_TYPE
3777 && flag_external_templates
3778 && CLASSTYPE_INTERFACE_KNOWN (TREE_TYPE (template))
3779 && ! CLASSTYPE_INTERFACE_ONLY (TREE_TYPE (template)))
3780 add_pending_template (t
);
3783 /* If the type makes use of template parameters, the
3784 code that generates debugging information will crash. */
3785 DECL_IGNORED_P (TYPE_STUB_DECL (t
)) = 1;
3791 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM, or
3792 TEMPLATE_PARM_INDEX in T, call FN with the parameter and the DATA.
3793 If FN returns non-zero, the iteration is terminated, and
3794 for_each_template_parm returns 1. Otherwise, the iteration
3795 continues. If FN never returns a non-zero value, the value
3796 returned by for_each_template_parm is 0. If FN is NULL, it is
3797 considered to be the function which always returns 1. */
3800 for_each_template_parm (t
, fn
, data
)
3808 if (TREE_CODE_CLASS (TREE_CODE (t
)) == 't'
3809 && for_each_template_parm (TYPE_CONTEXT (t
), fn
, data
))
3812 switch (TREE_CODE (t
))
3816 /* We assume that the object must be instantiated in order to build
3817 the COMPONENT_REF, so we test only whether the type of the
3818 COMPONENT_REF uses template parms. */
3819 return for_each_template_parm (TREE_TYPE (t
), fn
, data
);
3821 case IDENTIFIER_NODE
:
3822 if (!IDENTIFIER_TEMPLATE (t
))
3824 my_friendly_abort (42);
3826 /* aggregates of tree nodes */
3829 int i
= TREE_VEC_LENGTH (t
);
3831 if (for_each_template_parm (TREE_VEC_ELT (t
, i
), fn
, data
))
3836 if (for_each_template_parm (TREE_PURPOSE (t
), fn
, data
)
3837 || for_each_template_parm (TREE_VALUE (t
), fn
, data
))
3839 return for_each_template_parm (TREE_CHAIN (t
), fn
, data
);
3842 if (for_each_template_parm (OVL_FUNCTION (t
), fn
, data
))
3844 return for_each_template_parm (OVL_CHAIN (t
), fn
, data
);
3846 /* constructed type nodes */
3848 case REFERENCE_TYPE
:
3849 return for_each_template_parm (TREE_TYPE (t
), fn
, data
);
3852 if (TYPE_PTRMEMFUNC_FLAG (t
))
3853 return for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE (t
),
3859 if (! TYPE_TEMPLATE_INFO (t
))
3861 return for_each_template_parm (TREE_VALUE
3862 (TYPE_TEMPLATE_INFO (t
)),
3865 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t
), fn
, data
))
3870 /* Check the parameter types. Since default arguments are not
3871 instantiated until they are needed, the TYPE_ARG_TYPES may
3872 contain expressions that involve template parameters. But,
3873 no-one should be looking at them yet. And, once they're
3874 instantiated, they don't contain template parameters, so
3875 there's no point in looking at them then, either. */
3879 for (parm
= TYPE_ARG_TYPES (t
); parm
; parm
= TREE_CHAIN (parm
))
3880 if (for_each_template_parm (TREE_VALUE (parm
), fn
, data
))
3884 /* Check the return type, too. */
3885 return for_each_template_parm (TREE_TYPE (t
), fn
, data
);
3888 if (for_each_template_parm (TYPE_DOMAIN (t
), fn
, data
))
3890 return for_each_template_parm (TREE_TYPE (t
), fn
, data
);
3892 if (for_each_template_parm (TYPE_OFFSET_BASETYPE (t
), fn
, data
))
3894 return for_each_template_parm (TREE_TYPE (t
), fn
, data
);
3898 return for_each_template_parm (TREE_TYPE (t
), fn
, data
);
3901 /* A template template parameter is encountered */
3902 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
3903 return for_each_template_parm (TREE_TYPE (t
), fn
, data
);
3904 /* Already substituted template template parameter */
3908 if (for_each_template_parm (DECL_INITIAL (t
), fn
, data
))
3910 goto check_type_and_context
;
3914 /* ??? What about FIELD_DECLs? */
3915 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
)
3916 && for_each_template_parm (DECL_TI_ARGS (t
), fn
, data
))
3920 check_type_and_context
:
3921 if (for_each_template_parm (TREE_TYPE (t
), fn
, data
))
3923 if (DECL_CONTEXT (t
)
3924 && for_each_template_parm (DECL_CONTEXT (t
), fn
, data
))
3929 return for_each_template_parm (TREE_TYPE (t
), fn
, data
);
3931 return for_each_template_parm (TREE_OPERAND (t
, 0), fn
, data
);
3933 /* template parm nodes */
3934 case TEMPLATE_TEMPLATE_PARM
:
3935 /* Record template parameters such as `T' inside `TT<T>'. */
3936 if (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t
)
3937 && for_each_template_parm (TYPE_TI_ARGS (t
), fn
, data
))
3939 case TEMPLATE_TYPE_PARM
:
3940 case TEMPLATE_PARM_INDEX
:
3942 return (*fn
)(t
, data
);
3946 /* simple type nodes */
3948 if (for_each_template_parm (TYPE_MIN_VALUE (t
), fn
, data
))
3950 return for_each_template_parm (TYPE_MAX_VALUE (t
), fn
, data
);
3956 case NAMESPACE_DECL
:
3966 /* Non-error_mark_node ERROR_MARKs are bad things. */
3967 my_friendly_assert (t
== error_mark_node
, 274);
3976 return for_each_template_parm (TREE_TYPE (t
), fn
, data
);
3979 return for_each_template_parm (TREE_OPERAND (t
, 0), fn
, data
);
3982 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
)))
3983 return for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
3984 (TREE_TYPE (t
)), fn
, data
);
3985 return for_each_template_parm (TREE_OPERAND (t
, 1), fn
, data
);
3989 case REINTERPRET_CAST_EXPR
:
3990 case CONST_CAST_EXPR
:
3991 case STATIC_CAST_EXPR
:
3992 case DYNAMIC_CAST_EXPR
:
4000 return for_each_template_parm (TREE_OPERAND (t
, 0), fn
, data
);
4003 switch (TREE_CODE_CLASS (TREE_CODE (t
)))
4011 for (i
= first_rtl_op (TREE_CODE (t
)); --i
>= 0;)
4012 if (for_each_template_parm (TREE_OPERAND (t
, i
), fn
, data
))
4019 sorry ("testing %s for template parms",
4020 tree_code_name
[(int) TREE_CODE (t
)]);
4021 my_friendly_abort (82);
4028 uses_template_parms (t
)
4031 return for_each_template_parm (t
, 0, 0);
4034 static struct tinst_level
*current_tinst_level
;
4035 static struct tinst_level
*free_tinst_level
;
4036 static int tinst_depth
;
4037 extern int max_tinst_depth
;
4038 #ifdef GATHER_STATISTICS
4041 int tinst_level_tick
;
4042 int last_template_error_tick
;
4044 /* Print out all the template instantiations that we are currently
4045 working on. If ERR, we are being called from cp_thing, so do
4046 the right thing for an error message. */
4049 print_template_context (err
)
4052 struct tinst_level
*p
= current_tinst_level
;
4054 char *file
= input_filename
;
4058 if (current_function_decl
!= p
->decl
4059 && current_function_decl
!= NULL_TREE
)
4060 /* We can get here during the processing of some synthesized
4061 method. Then, p->decl will be the function that's causing
4066 if (current_function_decl
== p
->decl
)
4067 /* Avoid redundancy with the the "In function" line. */;
4069 fprintf (stderr
, "%s: In instantiation of `%s':\n",
4070 file
, decl_as_string (p
->decl
, 0));
4078 for (; p
; p
= p
->next
)
4080 fprintf (stderr
, "%s:%d: instantiated from `%s'\n", file
, line
,
4081 decl_as_string (p
->decl
, 0));
4085 fprintf (stderr
, "%s:%d: instantiated from here\n", file
, line
);
4088 /* Called from cp_thing to print the template context for an error. */
4091 maybe_print_template_context ()
4093 if (last_template_error_tick
== tinst_level_tick
4094 || current_tinst_level
== 0)
4097 last_template_error_tick
= tinst_level_tick
;
4098 print_template_context (1);
4102 push_tinst_level (d
)
4105 struct tinst_level
*new;
4107 if (tinst_depth
>= max_tinst_depth
)
4109 /* If the instantiation in question still has unbound template parms,
4110 we don't really care if we can't instantiate it, so just return.
4111 This happens with base instantiation for implicit `typename'. */
4112 if (uses_template_parms (d
))
4115 last_template_error_tick
= tinst_level_tick
;
4116 error ("template instantiation depth exceeds maximum of %d",
4118 error (" (use -ftemplate-depth-NN to increase the maximum)");
4119 cp_error (" instantiating `%D'", d
);
4121 print_template_context (0);
4126 if (free_tinst_level
)
4128 new = free_tinst_level
;
4129 free_tinst_level
= new->next
;
4132 new = (struct tinst_level
*) xmalloc (sizeof (struct tinst_level
));
4136 new->file
= input_filename
;
4137 new->next
= current_tinst_level
;
4138 current_tinst_level
= new;
4141 #ifdef GATHER_STATISTICS
4142 if (tinst_depth
> depth_reached
)
4143 depth_reached
= tinst_depth
;
4153 struct tinst_level
*old
= current_tinst_level
;
4155 /* Restore the filename and line number stashed away when we started
4156 this instantiation. */
4158 input_filename
= old
->file
;
4159 extract_interface_info ();
4161 current_tinst_level
= old
->next
;
4162 old
->next
= free_tinst_level
;
4163 free_tinst_level
= old
;
4168 struct tinst_level
*
4171 struct tinst_level
*p
= current_tinst_level
;
4174 for (; p
->next
; p
= p
->next
)
4179 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
4180 vector of template arguments, as for tsubst.
4182 Returns an appropriate tsbust'd friend declaration. */
4185 tsubst_friend_function (decl
, args
)
4191 char *file
= input_filename
;
4193 lineno
= DECL_SOURCE_LINE (decl
);
4194 input_filename
= DECL_SOURCE_FILE (decl
);
4196 if (TREE_CODE (decl
) == FUNCTION_DECL
4197 && DECL_TEMPLATE_INSTANTIATION (decl
)
4198 && TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
4199 /* This was a friend declared with an explicit template
4200 argument list, e.g.:
4204 to indicate that f was a template instantiation, not a new
4205 function declaration. Now, we have to figure out what
4206 instantiation of what template. */
4213 = lookup_template_function (tsubst_expr (DECL_TI_TEMPLATE (decl
),
4215 tsubst (DECL_TI_ARGS (decl
),
4217 /* FIXME: The decl we create via the next tsubst could be
4218 created on a temporary obstack. */
4219 new_friend
= tsubst (decl
, args
, NULL_TREE
);
4220 tmpl
= determine_specialization (template_id
, new_friend
,
4222 /*need_member_template=*/0,
4224 new_friend
= instantiate_template (tmpl
, new_args
);
4228 new_friend
= tsubst (decl
, args
, NULL_TREE
);
4230 /* The NEW_FRIEND will look like an instantiation, to the
4231 compiler, but is not an instantiation from the point of view of
4232 the language. For example, we might have had:
4234 template <class T> struct S {
4235 template <class U> friend void f(T, U);
4238 Then, in S<int>, template <class U> void f(int, U) is not an
4239 instantiation of anything. */
4240 DECL_USE_TEMPLATE (new_friend
) = 0;
4241 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
4242 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend
)) = 0;
4244 /* The mangled name for the NEW_FRIEND is incorrect. The call to
4245 tsubst will have resulted in a call to
4246 set_mangled_name_for_template_decl. But, the function is not a
4247 template instantiation and should not be mangled like one.
4248 Therefore, we remangle the function name. We don't have to do
4249 this if the NEW_FRIEND is a template since
4250 set_mangled_name_for_template_decl doesn't do anything if the
4251 function declaration still uses template arguments. */
4252 if (TREE_CODE (new_friend
) != TEMPLATE_DECL
)
4254 set_mangled_name_for_decl (new_friend
);
4255 DECL_RTL (new_friend
) = 0;
4256 make_decl_rtl (new_friend
, NULL_PTR
, 1);
4259 if (DECL_NAMESPACE_SCOPE_P (new_friend
))
4262 tree new_friend_template_info
;
4263 tree new_friend_result_template_info
;
4264 int new_friend_is_defn
;
4266 /* We must save some information from NEW_FRIEND before calling
4267 duplicate decls since that function will free NEW_FRIEND if
4269 new_friend_template_info
= DECL_TEMPLATE_INFO (new_friend
);
4270 if (TREE_CODE (new_friend
) == TEMPLATE_DECL
)
4272 /* This declaration is a `primary' template. */
4273 DECL_PRIMARY_TEMPLATE (new_friend
) = new_friend
;
4276 = DECL_INITIAL (DECL_RESULT (new_friend
)) != NULL_TREE
;
4277 new_friend_result_template_info
4278 = DECL_TEMPLATE_INFO (DECL_RESULT (new_friend
));
4282 new_friend_is_defn
= DECL_INITIAL (new_friend
) != NULL_TREE
;
4283 new_friend_result_template_info
= NULL_TREE
;
4286 old_decl
= pushdecl_namespace_level (new_friend
);
4288 if (old_decl
!= new_friend
)
4290 /* This new friend declaration matched an existing
4291 declaration. For example, given:
4293 template <class T> void f(T);
4294 template <class U> class C {
4295 template <class T> friend void f(T) {}
4298 the friend declaration actually provides the definition
4299 of `f', once C has been instantiated for some type. So,
4300 old_decl will be the out-of-class template declaration,
4301 while new_friend is the in-class definition.
4303 But, if `f' was called before this point, the
4304 instantiation of `f' will have DECL_TI_ARGS corresponding
4305 to `T' but not to `U', references to which might appear
4306 in the definition of `f'. Previously, the most general
4307 template for an instantiation of `f' was the out-of-class
4308 version; now it is the in-class version. Therefore, we
4309 run through all specialization of `f', adding to their
4310 DECL_TI_ARGS appropriately. In particular, they need a
4311 new set of outer arguments, corresponding to the
4312 arguments for this class instantiation.
4314 The same situation can arise with something like this:
4317 template <class T> class C {
4321 when `C<int>' is instantiated. Now, `f(int)' is defined
4324 if (!new_friend_is_defn
)
4325 /* On the other hand, if the in-class declaration does
4326 *not* provide a definition, then we don't want to alter
4327 existing definitions. We can just leave everything
4332 /* Overwrite whatever template info was there before, if
4333 any, with the new template information pertaining to
4335 DECL_TEMPLATE_INFO (old_decl
) = new_friend_template_info
;
4337 if (TREE_CODE (old_decl
) != TEMPLATE_DECL
)
4338 /* duplicate_decls will take care of this case. */
4343 tree new_friend_args
;
4345 DECL_TEMPLATE_INFO (DECL_RESULT (old_decl
))
4346 = new_friend_result_template_info
;
4348 new_friend_args
= TI_ARGS (new_friend_template_info
);
4349 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (old_decl
);
4353 tree spec
= TREE_VALUE (t
);
4356 = add_outermost_template_args (new_friend_args
,
4357 DECL_TI_ARGS (spec
));
4359 = copy_to_permanent (DECL_TI_ARGS (spec
));
4362 /* Now, since specializations are always supposed to
4363 hang off of the most general template, we must move
4365 t
= most_general_template (old_decl
);
4368 DECL_TEMPLATE_SPECIALIZATIONS (t
)
4369 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (t
),
4370 DECL_TEMPLATE_SPECIALIZATIONS (old_decl
));
4371 DECL_TEMPLATE_SPECIALIZATIONS (old_decl
) = NULL_TREE
;
4376 /* The information from NEW_FRIEND has been merged into OLD_DECL
4377 by duplicate_decls. */
4378 new_friend
= old_decl
;
4381 else if (TYPE_SIZE (DECL_CONTEXT (new_friend
)))
4383 /* Check to see that the declaration is really present, and,
4384 possibly obtain an improved declaration. */
4385 tree fn
= check_classfn (DECL_CONTEXT (new_friend
),
4394 input_filename
= file
;
4398 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
4399 template arguments, as for tsubst.
4401 Returns an appropriate tsbust'd friend type. */
4404 tsubst_friend_class (friend_tmpl
, args
)
4409 tree tmpl
= lookup_name (DECL_NAME (friend_tmpl
), 1);
4411 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
4413 if (tmpl
!= NULL_TREE
&& DECL_CLASS_TEMPLATE_P (tmpl
))
4415 /* The friend template has already been declared. Just
4416 check to see that the declarations match, and install any new
4417 default parameters. We must tsubst the default parameters,
4418 of course. We only need the innermost template parameters
4419 because that is all that redeclare_class_template will look
4422 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl
),
4424 redeclare_class_template (TREE_TYPE (tmpl
), parms
);
4425 friend_type
= TREE_TYPE (tmpl
);
4429 /* The friend template has not already been declared. In this
4430 case, the instantiation of the template class will cause the
4431 injection of this template into the global scope. */
4432 tmpl
= tsubst (friend_tmpl
, args
, NULL_TREE
);
4434 /* The new TMPL is not an instantiation of anything, so we
4435 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
4436 the new type because that is supposed to be the corresponding
4437 template decl, i.e., TMPL. */
4438 DECL_USE_TEMPLATE (tmpl
) = 0;
4439 DECL_TEMPLATE_INFO (tmpl
) = NULL_TREE
;
4440 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl
)) = 0;
4442 /* Inject this template into the global scope. */
4443 friend_type
= TREE_TYPE (pushdecl_top_level (tmpl
));
4450 instantiate_class_template (type
)
4453 tree
template, args
, pattern
, t
;
4456 if (type
== error_mark_node
)
4457 return error_mark_node
;
4459 if (TYPE_BEING_DEFINED (type
) || TYPE_SIZE (type
))
4462 /* We want to allocate temporary vectors of template arguments and
4463 template argument expressions on the momentary obstack, not on
4464 the expression obstack. Otherwise, all the space allocated in
4465 argument coercion and such is simply lost. */
4468 template = most_general_template (CLASSTYPE_TI_TEMPLATE (type
));
4469 args
= CLASSTYPE_TI_ARGS (type
);
4470 my_friendly_assert (TREE_CODE (template) == TEMPLATE_DECL
, 279);
4471 t
= most_specialized_class (template, args
);
4473 if (t
== error_mark_node
)
4475 char *str
= "candidates are:";
4476 cp_error ("ambiguous class template instantiation for `%#T'", type
);
4477 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (template); t
; t
= TREE_CHAIN (t
))
4479 if (get_class_bindings (TREE_VALUE (t
), TREE_PURPOSE (t
),
4482 cp_error_at ("%s %+#T", str
, TREE_TYPE (t
));
4486 TYPE_BEING_DEFINED (type
) = 1;
4487 type
= error_mark_node
;
4491 pattern
= TREE_TYPE (t
);
4493 pattern
= TREE_TYPE (template);
4495 if (TYPE_SIZE (pattern
) == NULL_TREE
)
4500 /* This TYPE is actually a instantiation of of a partial
4501 specialization. We replace the innermost set of ARGS with
4502 the arguments appropriate for substitution. For example,
4505 template <class T> struct S {};
4506 template <class T> struct S<T*> {};
4508 and supposing that we are instantiating S<int*>, ARGS will
4509 present be {int*} but we need {int}. */
4511 = get_class_bindings (TREE_VALUE (t
), TREE_PURPOSE (t
),
4514 /* If there were multiple levels in ARGS, replacing the
4515 innermost level would alter CLASSTYPE_TI_ARGS, which we don't
4516 want, so we make a copy first. */
4517 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
4519 args
= copy_node (args
);
4520 SET_TMPL_ARGS_LEVEL (args
, TMPL_ARGS_DEPTH (args
), inner_args
);
4526 if (pedantic
&& uses_template_parms (args
))
4528 /* If there are still template parameters amongst the args, then
4529 we can't instantiate the type; there's no telling whether or not one
4530 of the template parameters might eventually be instantiated to some
4531 value that results in a specialization being used. We do the
4532 type as complete so that, for example, declaring one of its
4533 members to be a friend will not be rejected. */
4534 TYPE_SIZE (type
) = integer_zero_node
;
4538 TYPE_BEING_DEFINED (type
) = 1;
4540 if (! push_tinst_level (type
))
4543 maybe_push_to_top_level (uses_template_parms (type
));
4544 pushclass (type
, 0);
4546 /* We must copy the arguments to the permanent obstack since
4547 during the tsubst'ing below they may wind up in the
4548 DECL_TI_ARGS of some instantiated member template. */
4549 args
= copy_to_permanent (args
);
4551 if (flag_external_templates
)
4553 if (flag_alt_external_templates
)
4555 CLASSTYPE_INTERFACE_ONLY (type
) = interface_only
;
4556 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (type
, interface_unknown
);
4557 CLASSTYPE_VTABLE_NEEDS_WRITING (type
)
4558 = (! CLASSTYPE_INTERFACE_ONLY (type
)
4559 && CLASSTYPE_INTERFACE_KNOWN (type
));
4563 CLASSTYPE_INTERFACE_ONLY (type
) = CLASSTYPE_INTERFACE_ONLY (pattern
);
4564 SET_CLASSTYPE_INTERFACE_UNKNOWN_X
4565 (type
, CLASSTYPE_INTERFACE_UNKNOWN (pattern
));
4566 CLASSTYPE_VTABLE_NEEDS_WRITING (type
)
4567 = (! CLASSTYPE_INTERFACE_ONLY (type
)
4568 && CLASSTYPE_INTERFACE_KNOWN (type
));
4573 SET_CLASSTYPE_INTERFACE_UNKNOWN (type
);
4574 CLASSTYPE_VTABLE_NEEDS_WRITING (type
) = 1;
4577 TYPE_HAS_CONSTRUCTOR (type
) = TYPE_HAS_CONSTRUCTOR (pattern
);
4578 TYPE_HAS_DESTRUCTOR (type
) = TYPE_HAS_DESTRUCTOR (pattern
);
4579 TYPE_HAS_ASSIGNMENT (type
) = TYPE_HAS_ASSIGNMENT (pattern
);
4580 TYPE_OVERLOADS_CALL_EXPR (type
) = TYPE_OVERLOADS_CALL_EXPR (pattern
);
4581 TYPE_OVERLOADS_ARRAY_REF (type
) = TYPE_OVERLOADS_ARRAY_REF (pattern
);
4582 TYPE_OVERLOADS_ARROW (type
) = TYPE_OVERLOADS_ARROW (pattern
);
4583 TYPE_GETS_NEW (type
) = TYPE_GETS_NEW (pattern
);
4584 TYPE_GETS_DELETE (type
) = TYPE_GETS_DELETE (pattern
);
4585 TYPE_VEC_DELETE_TAKES_SIZE (type
) = TYPE_VEC_DELETE_TAKES_SIZE (pattern
);
4586 TYPE_HAS_ASSIGN_REF (type
) = TYPE_HAS_ASSIGN_REF (pattern
);
4587 TYPE_HAS_CONST_ASSIGN_REF (type
) = TYPE_HAS_CONST_ASSIGN_REF (pattern
);
4588 TYPE_HAS_ABSTRACT_ASSIGN_REF (type
) = TYPE_HAS_ABSTRACT_ASSIGN_REF (pattern
);
4589 TYPE_HAS_INIT_REF (type
) = TYPE_HAS_INIT_REF (pattern
);
4590 TYPE_HAS_CONST_INIT_REF (type
) = TYPE_HAS_CONST_INIT_REF (pattern
);
4591 TYPE_HAS_DEFAULT_CONSTRUCTOR (type
) = TYPE_HAS_DEFAULT_CONSTRUCTOR (pattern
);
4592 TYPE_HAS_CONVERSION (type
) = TYPE_HAS_CONVERSION (pattern
);
4593 TYPE_USES_COMPLEX_INHERITANCE (type
)
4594 = TYPE_USES_COMPLEX_INHERITANCE (pattern
);
4595 TYPE_USES_MULTIPLE_INHERITANCE (type
)
4596 = TYPE_USES_MULTIPLE_INHERITANCE (pattern
);
4597 TYPE_USES_VIRTUAL_BASECLASSES (type
)
4598 = TYPE_USES_VIRTUAL_BASECLASSES (pattern
);
4599 TYPE_PACKED (type
) = TYPE_PACKED (pattern
);
4600 TYPE_ALIGN (type
) = TYPE_ALIGN (pattern
);
4601 TYPE_FOR_JAVA (type
) = TYPE_FOR_JAVA (pattern
); /* For libjava's JArray<T> */
4603 /* If this is a partial instantiation, don't tsubst anything. We will
4604 only use this type for implicit typename, so the actual contents don't
4605 matter. All that matters is whether a particular name is a type. */
4606 if (uses_template_parms (type
))
4608 TYPE_BINFO_BASETYPES (type
) = TYPE_BINFO_BASETYPES (pattern
);
4609 TYPE_FIELDS (type
) = TYPE_FIELDS (pattern
);
4610 TYPE_METHODS (type
) = TYPE_METHODS (pattern
);
4611 CLASSTYPE_TAGS (type
) = CLASSTYPE_TAGS (pattern
);
4612 TYPE_SIZE (type
) = integer_zero_node
;
4613 goto done_with_instantiation
;
4617 tree binfo
= TYPE_BINFO (type
);
4618 tree pbases
= TYPE_BINFO_BASETYPES (pattern
);
4624 int len
= TREE_VEC_LENGTH (pbases
);
4625 bases
= make_tree_vec (len
);
4626 for (i
= 0; i
< len
; ++i
)
4630 TREE_VEC_ELT (bases
, i
) = elt
4631 = tsubst (TREE_VEC_ELT (pbases
, i
), args
, NULL_TREE
);
4632 BINFO_INHERITANCE_CHAIN (elt
) = binfo
;
4634 basetype
= TREE_TYPE (elt
);
4636 if (! IS_AGGR_TYPE (basetype
))
4638 ("base type `%T' of `%T' fails to be a struct or class type",
4640 else if (TYPE_SIZE (complete_type (basetype
)) == NULL_TREE
)
4641 cp_error ("base class `%T' of `%T' has incomplete type",
4644 /* These are set up in xref_basetypes for normal classes, so
4645 we have to handle them here for template bases. */
4647 unshare_base_binfos (elt
);
4649 if (TYPE_USES_VIRTUAL_BASECLASSES (basetype
))
4651 TYPE_USES_VIRTUAL_BASECLASSES (type
) = 1;
4652 TYPE_USES_COMPLEX_INHERITANCE (type
) = 1;
4654 TYPE_GETS_NEW (type
) |= TYPE_GETS_NEW (basetype
);
4655 TYPE_GETS_DELETE (type
) |= TYPE_GETS_DELETE (basetype
);
4657 /* Don't initialize this until the vector is filled out, or
4658 lookups will crash. */
4659 BINFO_BASETYPES (binfo
) = bases
;
4663 for (t
= CLASSTYPE_TAGS (pattern
); t
; t
= TREE_CHAIN (t
))
4665 tree tag
= TREE_VALUE (t
);
4666 tree name
= TYPE_IDENTIFIER (tag
);
4669 newtag
= tsubst (tag
, args
, NULL_TREE
);
4670 if (TREE_CODE (newtag
) != ENUMERAL_TYPE
)
4672 if (TYPE_LANG_SPECIFIC (tag
) && CLASSTYPE_IS_TEMPLATE (tag
))
4673 /* Unfortunately, lookup_template_class sets
4674 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
4675 instantiation (i.e., for the type of a member template
4676 class nested within a template class.) This behavior is
4677 required for maybe_process_partial_specialization to work
4678 correctly, but is not accurate in this case; the TAG is not
4679 an instantiation of anything. (The corresponding
4680 TEMPLATE_DECL is an instantiation, but the TYPE is not.) */
4681 CLASSTYPE_USE_TEMPLATE (newtag
) = 0;
4683 /* Now, we call pushtag to put this NEWTAG into the scope of
4684 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
4685 pushtag calling push_template_decl. We don't have to do
4686 this for enums because it will already have been done in
4689 SET_IDENTIFIER_TYPE_VALUE (name
, newtag
);
4690 pushtag (name
, newtag
, /*globalize=*/0);
4694 /* Don't replace enum constants here. */
4695 for (t
= TYPE_FIELDS (pattern
); t
; t
= TREE_CHAIN (t
))
4696 if (TREE_CODE (t
) != CONST_DECL
)
4700 /* The the file and line for this declaration, to assist in
4701 error message reporting. Since we called push_tinst_level
4702 above, we don't need to restore these. */
4703 lineno
= DECL_SOURCE_LINE (t
);
4704 input_filename
= DECL_SOURCE_FILE (t
);
4706 r
= tsubst (t
, args
, NULL_TREE
);
4707 if (TREE_CODE (r
) == VAR_DECL
)
4709 pending_statics
= perm_tree_cons (NULL_TREE
, r
, pending_statics
);
4710 /* Perhaps we should do more of grokfield here. */
4712 DECL_IN_AGGR_P (r
) = 1;
4713 DECL_EXTERNAL (r
) = 1;
4714 cp_finish_decl (r
, DECL_INITIAL (r
), NULL_TREE
, 0, 0);
4715 if (DECL_DEFINED_IN_CLASS_P (r
))
4716 check_static_variable_definition (r
, TREE_TYPE (r
));
4719 /* R will have a TREE_CHAIN if and only if it has already been
4720 processed by finish_member_declaration. This can happen
4721 if, for example, it is a TYPE_DECL for a class-scoped
4722 ENUMERAL_TYPE; such a thing will already have been added to
4723 the field list by tsubst_enum above. */
4724 if (!TREE_CHAIN (r
))
4726 set_current_access_from_decl (r
);
4727 finish_member_declaration (r
);
4731 /* Set up the list (TYPE_METHODS) and vector (CLASSTYPE_METHOD_VEC)
4732 for this instantiation. */
4733 for (t
= TYPE_METHODS (pattern
); t
; t
= TREE_CHAIN (t
))
4735 tree r
= tsubst (t
, args
, NULL_TREE
);
4736 set_current_access_from_decl (r
);
4737 finish_member_declaration (r
);
4740 /* Construct the DECL_FRIENDLIST for the new class type. */
4741 typedecl
= TYPE_MAIN_DECL (type
);
4742 for (t
= DECL_FRIENDLIST (TYPE_MAIN_DECL (pattern
));
4748 DECL_FRIENDLIST (typedecl
)
4749 = tree_cons (TREE_PURPOSE (t
), NULL_TREE
,
4750 DECL_FRIENDLIST (typedecl
));
4752 for (friends
= TREE_VALUE (t
);
4753 friends
!= NULL_TREE
;
4754 friends
= TREE_CHAIN (friends
))
4756 if (TREE_PURPOSE (friends
) == error_mark_node
)
4758 TREE_VALUE (DECL_FRIENDLIST (typedecl
))
4759 = tree_cons (error_mark_node
,
4760 tsubst_friend_function (TREE_VALUE (friends
),
4762 TREE_VALUE (DECL_FRIENDLIST (typedecl
)));
4766 TREE_VALUE (DECL_FRIENDLIST (typedecl
))
4767 = tree_cons (tsubst (TREE_PURPOSE (friends
), args
, NULL_TREE
),
4769 TREE_VALUE (DECL_FRIENDLIST (typedecl
)));
4775 for (t
= CLASSTYPE_FRIEND_CLASSES (pattern
);
4779 tree friend_type
= TREE_VALUE (t
);
4780 tree new_friend_type
;
4782 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
4783 new_friend_type
= tsubst_friend_class (friend_type
, args
);
4784 else if (uses_template_parms (friend_type
))
4785 new_friend_type
= tsubst (friend_type
, args
, NULL_TREE
);
4787 /* The call to xref_tag_from_type does injection for friend
4790 xref_tag_from_type (friend_type
, NULL_TREE
, 1);
4793 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
4794 /* Trick make_friend_class into realizing that the friend
4795 we're adding is a template, not an ordinary class. It's
4796 important that we use make_friend_class since it will
4797 perform some error-checking and output cross-reference
4799 ++processing_template_decl
;
4801 make_friend_class (type
, new_friend_type
);
4803 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
4804 --processing_template_decl
;
4807 /* This does injection for friend functions. */
4808 if (!processing_template_decl
)
4810 t
= tsubst (DECL_TEMPLATE_INJECT (template), args
, NULL_TREE
);
4812 for (; t
; t
= TREE_CHAIN (t
))
4814 tree d
= TREE_VALUE (t
);
4816 if (TREE_CODE (d
) == TYPE_DECL
)
4817 /* Already injected. */;
4823 for (t
= TYPE_FIELDS (type
); t
; t
= TREE_CHAIN (t
))
4824 if (TREE_CODE (t
) == FIELD_DECL
)
4826 TREE_TYPE (t
) = complete_type (TREE_TYPE (t
));
4827 require_complete_type (t
);
4830 /* Set the file and line number information to whatever is given for
4831 the class itself. This puts error messages involving generated
4832 implicit functions at a predictable point, and the same point
4833 that would be used for non-template classes. */
4834 lineno
= DECL_SOURCE_LINE (typedecl
);
4835 input_filename
= DECL_SOURCE_FILE (typedecl
);
4837 unreverse_member_declarations (type
);
4838 type
= finish_struct_1 (type
, 0);
4839 CLASSTYPE_GOT_SEMICOLON (type
) = 1;
4841 /* Clear this now so repo_template_used is happy. */
4842 TYPE_BEING_DEFINED (type
) = 0;
4843 repo_template_used (type
);
4845 done_with_instantiation
:
4846 TYPE_BEING_DEFINED (type
) = 0;
4849 pop_from_top_level ();
4862 if (t1
== NULL_TREE
)
4863 return t2
== NULL_TREE
;
4864 if (t2
== NULL_TREE
)
4866 /* Don't care if one declares its arg const and the other doesn't -- the
4867 main variant of the arg type is all that matters. */
4868 if (TYPE_MAIN_VARIANT (TREE_VALUE (t1
))
4869 != TYPE_MAIN_VARIANT (TREE_VALUE (t2
)))
4871 return list_eq (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
4874 /* If arg is a non-type template parameter that does not depend on template
4875 arguments, fold it like we weren't in the body of a template. */
4878 maybe_fold_nontype_arg (arg
)
4881 if (TREE_CODE_CLASS (TREE_CODE (arg
)) != 't'
4882 && !uses_template_parms (arg
))
4884 /* Sometimes, one of the args was an expression involving a
4885 template constant parameter, like N - 1. Now that we've
4886 tsubst'd, we might have something like 2 - 1. This will
4887 confuse lookup_template_class, so we do constant folding
4888 here. We have to unset processing_template_decl, to
4889 fool build_expr_from_tree() into building an actual
4892 int saved_processing_template_decl
= processing_template_decl
;
4893 processing_template_decl
= 0;
4894 arg
= fold (build_expr_from_tree (arg
));
4895 processing_template_decl
= saved_processing_template_decl
;
4900 /* Return the TREE_VEC with the arguments for the innermost template header,
4901 where ARGS is either that or the VEC of VECs for all the
4905 innermost_args (args
)
4908 return TMPL_ARGS_LEVEL (args
, TMPL_ARGS_DEPTH (args
));
4911 /* Substitute ARGS into the vector of template arguments T. */
4914 tsubst_template_arg_vector (t
, args
)
4918 int len
= TREE_VEC_LENGTH (t
), need_new
= 0, i
;
4919 tree
*elts
= (tree
*) alloca (len
* sizeof (tree
));
4921 bzero ((char *) elts
, len
* sizeof (tree
));
4923 for (i
= 0; i
< len
; i
++)
4925 if (TREE_VEC_ELT (t
, i
) != NULL_TREE
4926 && TREE_CODE (TREE_VEC_ELT (t
, i
)) == TREE_VEC
)
4927 elts
[i
] = tsubst_template_arg_vector (TREE_VEC_ELT (t
, i
), args
);
4929 elts
[i
] = maybe_fold_nontype_arg
4930 (tsubst_expr (TREE_VEC_ELT (t
, i
), args
, NULL_TREE
));
4932 if (elts
[i
] != TREE_VEC_ELT (t
, i
))
4939 t
= make_temp_vec (len
);
4940 for (i
= 0; i
< len
; i
++)
4941 TREE_VEC_ELT (t
, i
) = elts
[i
];
4946 /* Return the result of substituting ARGS into the template parameters
4947 given by PARMS. If there are m levels of ARGS and m + n levels of
4948 PARMS, then the result will contain n levels of PARMS. For
4949 example, if PARMS is `template <class T> template <class U>
4950 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
4951 result will be `template <int*, double, class V>'. */
4954 tsubst_template_parms (parms
, args
)
4959 tree
* new_parms
= &r
;
4961 for (new_parms
= &r
;
4962 TMPL_PARMS_DEPTH (parms
) > TMPL_ARGS_DEPTH (args
);
4963 new_parms
= &(TREE_CHAIN (*new_parms
)),
4964 parms
= TREE_CHAIN (parms
))
4967 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms
)));
4970 for (i
= 0; i
< TREE_VEC_LENGTH (new_vec
); ++i
)
4972 tree default_value
=
4973 TREE_PURPOSE (TREE_VEC_ELT (TREE_VALUE (parms
), i
));
4975 TREE_VALUE (TREE_VEC_ELT (TREE_VALUE (parms
), i
));
4977 TREE_VEC_ELT (new_vec
, i
)
4978 = build_tree_list (tsubst (default_value
, args
, NULL_TREE
),
4979 tsubst (parm_decl
, args
, NULL_TREE
));
4984 tree_cons (build_int_2 (0, (TMPL_PARMS_DEPTH (parms
)
4985 - TMPL_ARGS_DEPTH (args
))),
4986 new_vec
, NULL_TREE
);
4992 /* Substitute the ARGS into the indicated aggregate (or enumeration)
4993 type T. If T is not an aggregate or enumeration type, it is
4994 handled as if by tsubst. IN_DECL is as for tsubst. If
4995 ENTERING_SCOPE is non-zero, T is the context for a template which
4996 we are presently tsubst'ing. Return the subsituted value. */
4999 tsubst_aggr_type (t
, args
, in_decl
, entering_scope
)
5008 switch (TREE_CODE (t
))
5011 if (TYPE_PTRMEMFUNC_P (t
))
5013 tree r
= build_ptrmemfunc_type
5014 (tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t
), args
, in_decl
));
5015 return cp_build_qualified_type (r
, TYPE_QUALS (t
));
5018 /* else fall through */
5021 if (uses_template_parms (t
))
5027 /* First, determine the context for the type we are looking
5029 if (TYPE_CONTEXT (t
) != NULL_TREE
)
5030 context
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
,
5031 in_decl
, /*entering_scope=*/1);
5033 context
= NULL_TREE
;
5035 /* Then, figure out what arguments are appropriate for the
5036 type we are trying to find. For example, given:
5038 template <class T> struct S;
5039 template <class T, class U> void f(T, U) { S<U> su; }
5041 and supposing that we are instantiating f<int, double>,
5042 then our ARGS will be {int, double}, but, when looking up
5043 S we only want {double}. */
5045 argvec
= tsubst_template_arg_vector (TYPE_TI_ARGS (t
), args
);
5047 r
= lookup_template_class (t
, argvec
, in_decl
, context
,
5051 return cp_build_qualified_type (r
, TYPE_QUALS (t
));
5054 /* This is not a template type, so there's nothing to do. */
5058 return tsubst (t
, args
, in_decl
);
5062 /* Substitute the ARGS into the T, which is a _DECL. TYPE is the
5063 (already computed) substitution of ARGS into TREE_TYPE (T), if
5064 appropriate. Return the result of the substitution. IN_DECL is as
5068 tsubst_decl (t
, args
, type
, in_decl
)
5075 char* saved_filename
;
5078 /* Set the filename and linenumber to improve error-reporting. */
5079 saved_lineno
= lineno
;
5080 saved_filename
= input_filename
;
5081 lineno
= DECL_SOURCE_LINE (t
);
5082 input_filename
= DECL_SOURCE_FILE (t
);
5084 switch (TREE_CODE (t
))
5088 /* We can get here when processing a member template function
5089 of a template class. */
5090 tree decl
= DECL_TEMPLATE_RESULT (t
);
5092 int is_template_template_parm
= DECL_TEMPLATE_TEMPLATE_PARM_P (t
);
5094 if (!is_template_template_parm
)
5096 /* We might already have an instance of this template.
5097 The ARGS are for the surrounding class type, so the
5098 full args contain the tsubst'd args for the context,
5099 plus the innermost args from the template decl. */
5100 tree tmpl_args
= DECL_CLASS_TEMPLATE_P (t
)
5101 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t
))
5102 : DECL_TI_ARGS (DECL_RESULT (t
));
5106 full_args
= tsubst_template_arg_vector (tmpl_args
, args
);
5108 /* tsubst_template_arg_vector doesn't copy the vector if
5109 nothing changed. But, *something* should have
5111 my_friendly_assert (full_args
!= tmpl_args
, 0);
5113 spec
= retrieve_specialization (t
, full_args
);
5115 if (spec
!= NULL_TREE
)
5122 /* Make a new template decl. It will be similar to the
5123 original, but will record the current template arguments.
5124 We also create a new function declaration, which is just
5125 like the old one, but points to this new template, rather
5126 than the old one. */
5129 my_friendly_assert (DECL_LANG_SPECIFIC (r
) != 0, 0);
5130 TREE_CHAIN (r
) = NULL_TREE
;
5132 if (is_template_template_parm
)
5134 tree new_decl
= tsubst (decl
, args
, in_decl
);
5135 DECL_RESULT (r
) = new_decl
;
5136 TREE_TYPE (r
) = TREE_TYPE (new_decl
);
5141 = tsubst_aggr_type (DECL_CONTEXT (t
), args
, in_decl
,
5142 /*entering_scope=*/1);
5143 DECL_CLASS_CONTEXT (r
)
5144 = tsubst_aggr_type (DECL_CLASS_CONTEXT (t
), args
, in_decl
,
5145 /*entering_scope=*/1);
5146 DECL_TEMPLATE_INFO (r
) = build_tree_list (t
, args
);
5148 if (TREE_CODE (decl
) == TYPE_DECL
)
5150 tree new_type
= tsubst (TREE_TYPE (t
), args
, in_decl
);
5151 TREE_TYPE (r
) = new_type
;
5152 CLASSTYPE_TI_TEMPLATE (new_type
) = r
;
5153 DECL_RESULT (r
) = TYPE_MAIN_DECL (new_type
);
5154 DECL_TI_ARGS (r
) = CLASSTYPE_TI_ARGS (new_type
);
5158 tree new_decl
= tsubst (decl
, args
, in_decl
);
5159 DECL_RESULT (r
) = new_decl
;
5160 DECL_TI_TEMPLATE (new_decl
) = r
;
5161 TREE_TYPE (r
) = TREE_TYPE (new_decl
);
5162 DECL_TI_ARGS (r
) = DECL_TI_ARGS (new_decl
);
5165 SET_DECL_IMPLICIT_INSTANTIATION (r
);
5166 DECL_TEMPLATE_INSTANTIATIONS (r
) = NULL_TREE
;
5167 DECL_TEMPLATE_SPECIALIZATIONS (r
) = NULL_TREE
;
5169 /* The template parameters for this new template are all the
5170 template parameters for the old template, except the
5171 outermost level of parameters. */
5172 DECL_TEMPLATE_PARMS (r
)
5173 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
);
5175 if (PRIMARY_TEMPLATE_P (t
))
5176 DECL_PRIMARY_TEMPLATE (r
) = r
;
5178 /* We don't partially instantiate partial specializations. */
5179 if (TREE_CODE (decl
) == TYPE_DECL
)
5182 for (spec
= DECL_TEMPLATE_SPECIALIZATIONS (t
);
5184 spec
= TREE_CHAIN (spec
))
5186 /* It helps to consider example here. Consider:
5197 Now, for example, we are instantiating S<int>::f(U u).
5198 We want to make a template:
5203 It will have a specialization, for the case U = int*, of
5207 void S<int>::f<int*>(int*);
5209 This specialization will be an instantiation of
5210 the specialization given in the declaration of S, with
5211 argument list int*. */
5213 tree fn
= TREE_VALUE (spec
);
5217 if (!DECL_TEMPLATE_SPECIALIZATION (fn
))
5218 /* Instantiations are on the same list, but they're of
5219 no concern to us. */
5222 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
5223 /* A full specialization. There's no need to record
5227 spec_args
= tsubst (DECL_TI_ARGS (fn
), args
, in_decl
);
5228 new_fn
= tsubst (DECL_RESULT (most_general_template (fn
)),
5229 spec_args
, in_decl
);
5230 DECL_TI_TEMPLATE (new_fn
) = fn
;
5231 register_specialization (new_fn
, r
,
5232 innermost_args (spec_args
));
5235 /* Record this partial instantiation. */
5236 register_specialization (r
, t
,
5237 DECL_TI_ARGS (DECL_RESULT (r
)));
5245 tree argvec
= NULL_TREE
;
5251 /* Nobody should be tsubst'ing into non-template functions. */
5252 my_friendly_assert (DECL_TEMPLATE_INFO (t
) != NULL_TREE
, 0);
5254 if (TREE_CODE (DECL_TI_TEMPLATE (t
)) == TEMPLATE_DECL
)
5258 /* Allocate template arguments on the momentary obstack,
5259 in case we don't need to keep them. */
5262 /* Calculate the most general template of which R is a
5263 specialization, and the complete set of arguments used to
5265 gen_tmpl
= most_general_template (DECL_TI_TEMPLATE (t
));
5267 = tsubst_template_arg_vector (DECL_TI_ARGS
5268 (DECL_TEMPLATE_RESULT (gen_tmpl
)),
5271 /* Check to see if we already have this specialization. */
5272 spec
= retrieve_specialization (gen_tmpl
, argvec
);
5281 /* We're going to need to keep the ARGVEC, so we copy it
5283 argvec
= copy_to_permanent (argvec
);
5286 /* Here, we deal with the peculiar case:
5288 template <class T> struct S {
5289 template <class U> friend void f();
5291 template <class U> friend void f() {}
5293 template void f<double>();
5295 Here, the ARGS for the instantiation of will be {int,
5296 double}. But, we only need as many ARGS as there are
5297 levels of template parameters in CODE_PATTERN. We are
5298 careful not to get fooled into reducing the ARGS in
5301 template <class T> struct S { template <class U> void f(U); }
5302 template <class T> template <> void S<T>::f(int) {}
5304 which we can spot because the pattern will be a
5305 specialization in this case. */
5306 args_depth
= TMPL_ARGS_DEPTH (args
);
5308 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t
)));
5309 if (args_depth
> parms_depth
5310 && !DECL_TEMPLATE_SPECIALIZATION (t
))
5312 my_friendly_assert (DECL_FRIEND_P (t
), 0);
5314 if (parms_depth
> 1)
5318 args
= make_temp_vec (parms_depth
);
5319 for (i
= 0; i
< parms_depth
; ++i
)
5320 TREE_VEC_ELT (args
, i
) =
5321 TREE_VEC_ELT (args
, i
+ (args_depth
- parms_depth
));
5324 args
= TREE_VEC_ELT (args
, args_depth
- parms_depth
);
5329 /* This special case arises when we have something like this:
5331 template <class T> struct S {
5332 friend void f<int>(int, double);
5335 Here, the DECL_TI_TEMPLATE for the friend declaration
5336 will be a LOOKUP_EXPR or an IDENTIFIER_NODE. We are
5337 being called from tsubst_friend_function, and we want
5338 only to create a new decl (R) with appropriate types so
5339 that we can call determine_specialization. */
5340 my_friendly_assert ((TREE_CODE (DECL_TI_TEMPLATE (t
))
5342 || (TREE_CODE (DECL_TI_TEMPLATE (t
))
5343 == IDENTIFIER_NODE
), 0);
5344 gen_tmpl
= NULL_TREE
;
5347 if (DECL_CLASS_SCOPE_P (t
))
5349 if (DECL_NAME (t
) == constructor_name (DECL_CONTEXT (t
)))
5353 ctx
= tsubst_aggr_type (DECL_CLASS_CONTEXT (t
), args
, t
,
5354 /*entering_scope=*/1);
5361 type
= tsubst (type
, args
, in_decl
);
5363 /* We do NOT check for matching decls pushed separately at this
5364 point, as they may not represent instantiations of this
5365 template, and in any case are considered separate under the
5366 discrete model. Instead, see add_maybe_template. */
5370 DECL_USE_TEMPLATE (r
) = 0;
5371 TREE_TYPE (r
) = type
;
5374 = tsubst_aggr_type (DECL_CONTEXT (t
), args
, t
, /*entering_scope=*/1);
5375 DECL_CLASS_CONTEXT (r
) = ctx
;
5377 if (member
&& !strncmp (OPERATOR_TYPENAME_FORMAT
,
5378 IDENTIFIER_POINTER (DECL_NAME (r
)),
5379 sizeof (OPERATOR_TYPENAME_FORMAT
) - 1))
5381 /* Type-conversion operator. Reconstruct the name, in
5382 case it's the name of one of the template's parameters. */
5383 DECL_NAME (r
) = build_typename_overload (TREE_TYPE (type
));
5386 DECL_ARGUMENTS (r
) = tsubst (DECL_ARGUMENTS (t
), args
, t
);
5387 DECL_MAIN_VARIANT (r
) = r
;
5388 DECL_RESULT (r
) = NULL_TREE
;
5390 TREE_STATIC (r
) = 0;
5391 TREE_PUBLIC (r
) = TREE_PUBLIC (t
);
5392 DECL_EXTERNAL (r
) = 1;
5393 DECL_INTERFACE_KNOWN (r
) = 0;
5394 DECL_DEFER_OUTPUT (r
) = 0;
5395 TREE_CHAIN (r
) = NULL_TREE
;
5396 DECL_PENDING_INLINE_INFO (r
) = 0;
5399 if (DECL_CONSTRUCTOR_P (r
))
5401 maybe_retrofit_in_chrg (r
);
5402 grok_ctor_properties (ctx
, r
);
5404 if (IDENTIFIER_OPNAME_P (DECL_NAME (r
)))
5405 grok_op_properties (r
, DECL_VIRTUAL_P (r
), DECL_FRIEND_P (r
));
5407 /* Set up the DECL_TEMPLATE_INFO for R and compute its mangled
5408 name. There's no need to do this in the special friend
5409 case mentioned above where GEN_TMPL is NULL. */
5412 /* The ARGVEC was built on the momentary obstack. Make it
5414 argvec
= copy_to_permanent (argvec
);
5415 DECL_TEMPLATE_INFO (r
)
5416 = perm_tree_cons (gen_tmpl
, argvec
, NULL_TREE
);
5417 SET_DECL_IMPLICIT_INSTANTIATION (r
);
5418 register_specialization (r
, gen_tmpl
, argvec
);
5420 /* Set the mangled name for R. */
5421 if (DECL_DESTRUCTOR_P (t
))
5422 DECL_ASSEMBLER_NAME (r
) = build_destructor_name (ctx
);
5425 /* Instantiations of template functions must be mangled
5426 specially, in order to conform to 14.5.5.1
5427 [temp.over.link]. */
5428 tree tmpl
= DECL_TI_TEMPLATE (t
);
5430 /* TMPL will be NULL if this is a specialization of a
5431 member function of a template class. */
5432 if (name_mangling_version
< 1
5433 || tmpl
== NULL_TREE
5434 || (member
&& !is_member_template (tmpl
)
5435 && !DECL_TEMPLATE_INFO (tmpl
)))
5436 set_mangled_name_for_decl (r
);
5438 set_mangled_name_for_template_decl (r
);
5442 make_decl_rtl (r
, NULL_PTR
, 1);
5444 /* Like grokfndecl. If we don't do this, pushdecl will
5445 mess up our TREE_CHAIN because it doesn't find a
5446 previous decl. Sigh. */
5448 && ! uses_template_parms (r
)
5449 && (IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (r
))
5451 SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (r
), r
);
5459 TREE_TYPE (r
) = type
;
5460 if (TREE_CODE (DECL_INITIAL (r
)) != TEMPLATE_PARM_INDEX
)
5461 DECL_INITIAL (r
) = TREE_TYPE (r
);
5463 DECL_INITIAL (r
) = tsubst (DECL_INITIAL (r
), args
, in_decl
);
5465 DECL_CONTEXT (r
) = NULL_TREE
;
5466 #ifdef PROMOTE_PROTOTYPES
5467 if ((TREE_CODE (type
) == INTEGER_TYPE
5468 || TREE_CODE (type
) == ENUMERAL_TYPE
)
5469 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
5470 DECL_ARG_TYPE (r
) = integer_type_node
;
5473 TREE_CHAIN (r
) = tsubst (TREE_CHAIN (t
), args
, TREE_CHAIN (t
));
5480 TREE_TYPE (r
) = type
;
5483 DECL_FIELD_CONTEXT (r
) = tsubst (DECL_FIELD_CONTEXT (t
), args
, in_decl
);
5485 DECL_INITIAL (r
) = tsubst_expr (DECL_INITIAL (t
), args
, in_decl
);
5486 TREE_CHAIN (r
) = NULL_TREE
;
5487 if (TREE_CODE (type
) == VOID_TYPE
)
5488 cp_error_at ("instantiation of `%D' as type void", r
);
5496 = tsubst_copy (DECL_INITIAL (t
), args
, in_decl
);
5497 TREE_CHAIN (r
) = NULL_TREE
;
5507 tree ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
, in_decl
,
5508 /*entering_scope=*/1);
5510 /* Nobody should be tsubst'ing into non-template variables. */
5511 my_friendly_assert (DECL_LANG_SPECIFIC (t
)
5512 && DECL_TEMPLATE_INFO (t
) != NULL_TREE
, 0);
5514 /* Check to see if we already have this specialization. */
5515 tmpl
= DECL_TI_TEMPLATE (t
);
5516 gen_tmpl
= most_general_template (tmpl
);
5517 argvec
= tsubst (DECL_TI_ARGS (t
), args
, in_decl
);
5518 spec
= retrieve_specialization (gen_tmpl
, argvec
);
5527 TREE_TYPE (r
) = type
;
5528 DECL_CONTEXT (r
) = ctx
;
5529 if (TREE_STATIC (r
))
5530 DECL_ASSEMBLER_NAME (r
)
5531 = build_static_name (DECL_CONTEXT (r
), DECL_NAME (r
));
5533 /* Don't try to expand the initializer until someone tries to use
5534 this variable; otherwise we run into circular dependencies. */
5535 DECL_INITIAL (r
) = NULL_TREE
;
5539 DECL_CLASS_CONTEXT (r
) = DECL_CONTEXT (r
);
5541 DECL_TEMPLATE_INFO (r
) = perm_tree_cons (tmpl
, argvec
, NULL_TREE
);
5542 SET_DECL_IMPLICIT_INSTANTIATION (r
);
5543 register_specialization (r
, gen_tmpl
, argvec
);
5545 TREE_CHAIN (r
) = NULL_TREE
;
5546 if (TREE_CODE (type
) == VOID_TYPE
)
5547 cp_error_at ("instantiation of `%D' as type void", r
);
5552 if (t
== TYPE_NAME (TREE_TYPE (t
)))
5553 r
= TYPE_NAME (type
);
5557 TREE_TYPE (r
) = type
;
5558 DECL_CONTEXT (r
) = current_class_type
;
5559 TREE_CHAIN (r
) = NULL_TREE
;
5564 my_friendly_abort (0);
5567 /* Restore the file and line information. */
5568 lineno
= saved_lineno
;
5569 input_filename
= saved_filename
;
5574 /* Substitue into the ARG_TYPES of a function type. */
5577 tsubst_arg_types (arg_types
, args
, in_decl
)
5582 tree remaining_arg_types
;
5585 if (!arg_types
|| arg_types
== void_list_node
)
5588 remaining_arg_types
= tsubst_arg_types (TREE_CHAIN (arg_types
),
5591 /* We use TYPE_MAIN_VARIANT is because top-level qualifiers don't
5592 matter on function types. */
5593 type
= TYPE_MAIN_VARIANT (type_decays_to
5594 (tsubst (TREE_VALUE (arg_types
),
5597 /* Note that we do not substitute into default arguments here. The
5598 standard mandates that they be instantiated only when needed,
5599 which is done in build_over_call. */
5600 return hash_tree_cons_simple (TREE_PURPOSE (arg_types
), type
,
5601 remaining_arg_types
);
5605 /* Take the tree structure T and replace template parameters used therein
5606 with the argument vector ARGS. IN_DECL is an associated decl for
5609 tsubst is used for dealing with types, decls and the like; for
5610 expressions, use tsubst_expr or tsubst_copy. */
5613 tsubst (t
, args
, in_decl
)
5619 if (t
== NULL_TREE
|| t
== error_mark_node
5620 || t
== integer_type_node
5621 || t
== void_type_node
5622 || t
== char_type_node
5623 || TREE_CODE (t
) == NAMESPACE_DECL
)
5626 if (TREE_CODE (t
) == IDENTIFIER_NODE
)
5627 type
= IDENTIFIER_TYPE_VALUE (t
);
5629 type
= TREE_TYPE (t
);
5630 if (type
== unknown_type_node
)
5631 my_friendly_abort (42);
5633 if (type
&& TREE_CODE (t
) != FUNCTION_DECL
5634 && TREE_CODE (t
) != TYPENAME_TYPE
5635 && TREE_CODE (t
) != TEMPLATE_DECL
5636 && TREE_CODE (t
) != IDENTIFIER_NODE
)
5637 type
= tsubst (type
, args
, in_decl
);
5639 if (TREE_CODE_CLASS (TREE_CODE (t
)) == 'd')
5640 return tsubst_decl (t
, args
, type
, in_decl
);
5642 switch (TREE_CODE (t
))
5647 return tsubst_aggr_type (t
, args
, in_decl
, /*entering_scope=*/0);
5650 case IDENTIFIER_NODE
:
5662 if (t
== integer_type_node
)
5665 if (TREE_CODE (TYPE_MIN_VALUE (t
)) == INTEGER_CST
5666 && TREE_CODE (TYPE_MAX_VALUE (t
)) == INTEGER_CST
)
5670 tree max
= TREE_OPERAND (TYPE_MAX_VALUE (t
), 0);
5672 max
= tsubst_expr (max
, args
, in_decl
);
5673 if (processing_template_decl
)
5675 tree itype
= make_node (INTEGER_TYPE
);
5676 TYPE_MIN_VALUE (itype
) = size_zero_node
;
5677 TYPE_MAX_VALUE (itype
) = build_min (MINUS_EXPR
, sizetype
, max
,
5682 if (pedantic
&& integer_zerop (max
))
5683 pedwarn ("creating array with size zero");
5684 else if (INT_CST_LT (max
, integer_zero_node
))
5686 cp_error ("creating array with size `%E'", max
);
5687 max
= integer_one_node
;
5690 max
= fold (build_binary_op (MINUS_EXPR
, max
, integer_one_node
, 1));
5691 if (!TREE_PERMANENT (max
) && !allocation_temporary_p ())
5692 max
= copy_to_permanent (max
);
5693 return build_index_type (max
);
5696 case TEMPLATE_TYPE_PARM
:
5697 case TEMPLATE_TEMPLATE_PARM
:
5698 case TEMPLATE_PARM_INDEX
:
5706 if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
5707 || TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
)
5709 idx
= TEMPLATE_TYPE_IDX (t
);
5710 level
= TEMPLATE_TYPE_LEVEL (t
);
5714 idx
= TEMPLATE_PARM_IDX (t
);
5715 level
= TEMPLATE_PARM_LEVEL (t
);
5718 if (TREE_VEC_LENGTH (args
) > 0)
5720 tree arg
= NULL_TREE
;
5722 levels
= TMPL_ARGS_DEPTH (args
);
5723 if (level
<= levels
)
5724 arg
= TMPL_ARG (args
, level
, idx
);
5726 if (arg
== error_mark_node
)
5727 return error_mark_node
;
5728 else if (arg
!= NULL_TREE
)
5730 if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
)
5732 my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (arg
))
5734 return cp_build_qualified_type
5735 (arg
, CP_TYPE_QUALS (arg
) | CP_TYPE_QUALS (t
));
5737 else if (TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
)
5739 if (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t
))
5741 /* We are processing a type constructed from
5742 a template template parameter */
5743 tree argvec
= tsubst (TYPE_TI_ARGS (t
),
5746 /* We can get a TEMPLATE_TEMPLATE_PARM here when
5747 we are resolving nested-types in the signature of
5748 a member function templates.
5749 Otherwise ARG is a TEMPLATE_DECL and is the real
5750 template to be instantiated. */
5751 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
5752 arg
= TYPE_NAME (arg
);
5754 r
= lookup_template_class (DECL_NAME (arg
),
5757 /*entering_scope=*/0);
5758 return cp_build_qualified_type (r
, TYPE_QUALS (t
));
5761 /* We are processing a template argument list. */
5769 my_friendly_abort (981018);
5772 /* This can happen during the attempted tsubst'ing in
5773 unify. This means that we don't yet have any information
5774 about the template parameter in question. */
5777 /* If we get here, we must have been looking at a parm for a
5778 more deeply nested template. Make a new version of this
5779 template parameter, but with a lower level. */
5780 switch (TREE_CODE (t
))
5782 case TEMPLATE_TYPE_PARM
:
5783 case TEMPLATE_TEMPLATE_PARM
:
5785 TEMPLATE_TYPE_PARM_INDEX (r
)
5786 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t
),
5788 TYPE_STUB_DECL (r
) = TYPE_NAME (r
) = TEMPLATE_TYPE_DECL (r
);
5789 TYPE_MAIN_VARIANT (r
) = r
;
5790 TYPE_POINTER_TO (r
) = NULL_TREE
;
5791 TYPE_REFERENCE_TO (r
) = NULL_TREE
;
5793 if (TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
5794 && TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t
))
5796 tree argvec
= tsubst (TYPE_TI_ARGS (t
), args
, in_decl
);
5797 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r
)
5798 = perm_tree_cons (TYPE_NAME (t
), argvec
, NULL_TREE
);
5802 case TEMPLATE_PARM_INDEX
:
5803 r
= reduce_template_parm_level (t
, type
, levels
);
5807 my_friendly_abort (0);
5815 tree purpose
, value
, chain
, result
;
5816 int via_public
, via_virtual
, via_protected
;
5818 if (t
== void_list_node
)
5821 via_public
= TREE_VIA_PUBLIC (t
);
5822 via_protected
= TREE_VIA_PROTECTED (t
);
5823 via_virtual
= TREE_VIA_VIRTUAL (t
);
5825 purpose
= TREE_PURPOSE (t
);
5827 purpose
= tsubst (purpose
, args
, in_decl
);
5828 value
= TREE_VALUE (t
);
5830 value
= tsubst (value
, args
, in_decl
);
5831 chain
= TREE_CHAIN (t
);
5832 if (chain
&& chain
!= void_type_node
)
5833 chain
= tsubst (chain
, args
, in_decl
);
5834 if (purpose
== TREE_PURPOSE (t
)
5835 && value
== TREE_VALUE (t
)
5836 && chain
== TREE_CHAIN (t
))
5838 result
= hash_tree_cons (via_public
, via_virtual
, via_protected
,
5839 purpose
, value
, chain
);
5840 TREE_PARMLIST (result
) = TREE_PARMLIST (t
);
5844 if (type
!= NULL_TREE
)
5846 /* A binfo node. We always need to make a copy, of the node
5847 itself and of its BINFO_BASETYPES. */
5851 /* Make sure type isn't a typedef copy. */
5852 type
= BINFO_TYPE (TYPE_BINFO (type
));
5854 TREE_TYPE (t
) = complete_type (type
);
5855 if (IS_AGGR_TYPE (type
))
5857 BINFO_VTABLE (t
) = TYPE_BINFO_VTABLE (type
);
5858 BINFO_VIRTUALS (t
) = TYPE_BINFO_VIRTUALS (type
);
5859 if (TYPE_BINFO_BASETYPES (type
) != NULL_TREE
)
5860 BINFO_BASETYPES (t
) = copy_node (TYPE_BINFO_BASETYPES (type
));
5865 /* Otherwise, a vector of template arguments. */
5866 return tsubst_template_arg_vector (t
, args
);
5869 case REFERENCE_TYPE
:
5871 enum tree_code code
;
5873 if (type
== TREE_TYPE (t
))
5876 code
= TREE_CODE (t
);
5877 if (TREE_CODE (type
) == REFERENCE_TYPE
5878 || (code
== REFERENCE_TYPE
&& TREE_CODE (type
) == VOID_TYPE
))
5880 static int last_line
= 0;
5881 static char* last_file
= 0;
5883 /* We keep track of the last time we issued this error
5884 message to avoid spewing a ton of messages during a
5885 single bad template instantiation. */
5886 if (last_line
!= lineno
||
5887 last_file
!= input_filename
)
5889 if (TREE_CODE (type
) == VOID_TYPE
)
5890 cp_error ("forming reference to void");
5892 cp_error ("forming %s to reference type `%T'",
5893 (code
== POINTER_TYPE
) ? "pointer" : "reference",
5896 last_file
= input_filename
;
5899 /* Use the underlying type in an attempt at error
5900 recovery; maybe the user meant vector<int> and wrote
5901 vector<int&>, or some such. */
5902 if (code
== REFERENCE_TYPE
)
5905 r
= build_pointer_type (TREE_TYPE (type
));
5907 else if (code
== POINTER_TYPE
)
5908 r
= build_pointer_type (type
);
5910 r
= build_reference_type (type
);
5911 r
= cp_build_qualified_type (r
, TYPE_QUALS (t
));
5913 /* Will this ever be needed for TYPE_..._TO values? */
5919 r
= tsubst (TYPE_OFFSET_BASETYPE (t
), args
, in_decl
);
5920 if (! IS_AGGR_TYPE (r
))
5921 cp_error ("creating pointer to member of non-class type `%T'", r
);
5922 return build_offset_type (r
, type
);
5931 /* The TYPE_CONTEXT is not used for function/method types. */
5932 my_friendly_assert (TYPE_CONTEXT (t
) == NULL_TREE
, 0);
5934 /* Substitue the argument types. */
5935 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, in_decl
);
5937 /* Construct a new type node and return it. */
5938 if (TREE_CODE (t
) == FUNCTION_TYPE
)
5939 fntype
= build_function_type (type
, arg_types
);
5942 r
= TREE_TYPE (TREE_VALUE (arg_types
));
5943 if (! IS_AGGR_TYPE (r
))
5944 cp_error ("creating pointer to member function of non-class type `%T'",
5947 fntype
= build_cplus_method_type (r
, type
, TREE_CHAIN (arg_types
));
5949 fntype
= build_qualified_type (fntype
, TYPE_QUALS (t
));
5951 /* Substitue the exception specification. */
5952 raises
= TYPE_RAISES_EXCEPTIONS (t
);
5955 raises
= tsubst (raises
, args
, in_decl
);
5956 fntype
= build_exception_variant (fntype
, raises
);
5962 tree domain
= tsubst (TYPE_DOMAIN (t
), args
, in_decl
);
5963 if (type
== TREE_TYPE (t
) && domain
== TYPE_DOMAIN (t
))
5966 /* These checks should match the ones in grokdeclarator. */
5967 if (TREE_CODE (type
) == VOID_TYPE
)
5969 cp_error ("creating array of void");
5970 type
= build_pointer_type (type
);
5972 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
5974 cp_error ("creating array of functions `%T'", type
);
5975 type
= build_pointer_type (type
);
5977 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
5979 cp_error ("creating array of references `%T'", type
);
5980 type
= TREE_TYPE (type
);
5983 r
= build_cplus_array_type (type
, domain
);
5989 return fold (build (TREE_CODE (t
), TREE_TYPE (t
),
5990 tsubst (TREE_OPERAND (t
, 0), args
, in_decl
),
5991 tsubst (TREE_OPERAND (t
, 1), args
, in_decl
)));
5995 return fold (build1 (TREE_CODE (t
), TREE_TYPE (t
),
5996 tsubst (TREE_OPERAND (t
, 0), args
, in_decl
)));
6000 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, in_decl
,
6001 /*entering_scope=*/1);
6002 tree f
= tsubst_copy (TYPENAME_TYPE_FULLNAME (t
), args
, in_decl
);
6004 /* Normally, make_typename_type does not require that the CTX
6005 have complete type in order to allow things like:
6007 template <class T> struct S { typename S<T>::X Y; };
6009 But, such constructs have already been resolved by this
6010 point, so here CTX really should have complete type, unless
6011 it's a partial instantiation. */
6012 if (!uses_template_parms (ctx
)
6013 && !complete_type_or_else (ctx
))
6014 return error_mark_node
;
6016 f
= make_typename_type (ctx
, f
);
6017 return cp_build_qualified_type (f
,
6019 | CP_TYPE_QUALS (t
));
6023 return make_pointer_declarator
6024 (type
, tsubst (TREE_OPERAND (t
, 0), args
, in_decl
));
6027 return make_reference_declarator
6028 (type
, tsubst (TREE_OPERAND (t
, 0), args
, in_decl
));
6031 return build_parse_node
6032 (ARRAY_REF
, tsubst (TREE_OPERAND (t
, 0), args
, in_decl
),
6033 tsubst_expr (TREE_OPERAND (t
, 1), args
, in_decl
));
6036 return make_call_declarator
6037 (tsubst (TREE_OPERAND (t
, 0), args
, in_decl
),
6038 tsubst (TREE_OPERAND (t
, 1), args
, in_decl
),
6039 TREE_OPERAND (t
, 2),
6040 tsubst (TREE_TYPE (t
), args
, in_decl
));
6043 return build_parse_node
6044 (TREE_CODE (t
), tsubst (TREE_OPERAND (t
, 0), args
, in_decl
),
6045 tsubst (TREE_OPERAND (t
, 1), args
, in_decl
));
6048 return TREE_TYPE (tsubst_expr (TYPE_FIELDS (t
), args
, in_decl
));
6051 sorry ("use of `%s' in template",
6052 tree_code_name
[(int) TREE_CODE (t
)]);
6053 return error_mark_node
;
6060 emit_line_note (input_filename
, lineno
);
6064 expand_start_bindings (0);
6071 int saved_warn_unused
= 0;
6073 if (processing_template_decl
)
6075 saved_warn_unused
= warn_unused
;
6078 expand_end_bindings (getdecls (), kept_level_p (), 0);
6079 if (processing_template_decl
)
6080 warn_unused
= saved_warn_unused
;
6081 t
= poplevel (kept_level_p (), 1, 0);
6086 /* Like tsubst, but deals with expressions. This function just replaces
6087 template parms; to finish processing the resultant expression, use
6091 tsubst_copy (t
, args
, in_decl
)
6095 enum tree_code code
;
6098 if (t
== NULL_TREE
|| t
== error_mark_node
)
6101 code
= TREE_CODE (t
);
6106 return do_identifier (DECL_NAME (t
), 0, NULL_TREE
);
6113 if (!DECL_CONTEXT (t
))
6114 /* This is a global enumeration constant. */
6117 /* Unfortunately, we cannot just call lookup_name here.
6120 template <int I> int f() {
6122 struct S { void g() { E e = a; } };
6125 When we instantiate f<7>::S::g(), say, lookup_name is not
6126 clever enough to find f<7>::a. */
6128 = tsubst_aggr_type (TREE_TYPE (t
), args
, in_decl
,
6129 /*entering_scope=*/0);
6131 for (v
= TYPE_VALUES (enum_type
);
6134 if (TREE_PURPOSE (v
) == DECL_NAME (t
))
6135 return TREE_VALUE (v
);
6137 /* We didn't find the name. That should never happen; if
6138 name-lookup found it during preliminary parsing, we
6139 should find it again here during instantiation. */
6140 my_friendly_abort (0);
6145 if (DECL_CONTEXT (t
))
6149 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
, in_decl
,
6150 /*entering_scope=*/1);
6151 if (ctx
!= DECL_CONTEXT (t
))
6152 return lookup_field (ctx
, DECL_NAME (t
), 0, 0);
6158 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
6159 t
= tsubst (t
, args
, in_decl
);
6164 if (is_member_template (t
))
6165 return tsubst (t
, args
, in_decl
);
6171 /* We must tsbust into a LOOKUP_EXPR in case the names to
6172 which it refers is a conversion operator; in that case the
6173 name will change. We avoid making unnecessary copies,
6176 tree id
= tsubst_copy (TREE_OPERAND (t
, 0), args
, in_decl
);
6178 if (id
!= TREE_OPERAND (t
, 0))
6180 r
= build_nt (LOOKUP_EXPR
, id
);
6181 LOOKUP_EXPR_GLOBAL (r
) = LOOKUP_EXPR_GLOBAL (t
);
6189 case REINTERPRET_CAST_EXPR
:
6190 case CONST_CAST_EXPR
:
6191 case STATIC_CAST_EXPR
:
6192 case DYNAMIC_CAST_EXPR
:
6195 (code
, tsubst (TREE_TYPE (t
), args
, in_decl
),
6196 tsubst_copy (TREE_OPERAND (t
, 0), args
, in_decl
));
6199 case PREDECREMENT_EXPR
:
6200 case PREINCREMENT_EXPR
:
6201 case POSTDECREMENT_EXPR
:
6202 case POSTINCREMENT_EXPR
:
6204 case TRUTH_NOT_EXPR
:
6207 case CONVERT_EXPR
: /* Unary + */
6215 tsubst_copy (TREE_OPERAND (t
, 0), args
, in_decl
));
6220 case TRUNC_DIV_EXPR
:
6222 case FLOOR_DIV_EXPR
:
6223 case ROUND_DIV_EXPR
:
6224 case EXACT_DIV_EXPR
:
6226 case BIT_ANDTC_EXPR
:
6229 case TRUNC_MOD_EXPR
:
6230 case FLOOR_MOD_EXPR
:
6231 case TRUTH_ANDIF_EXPR
:
6232 case TRUTH_ORIF_EXPR
:
6233 case TRUTH_AND_EXPR
:
6254 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, in_decl
),
6255 tsubst_copy (TREE_OPERAND (t
, 1), args
, in_decl
));
6259 tree fn
= TREE_OPERAND (t
, 0);
6260 if (is_overloaded_fn (fn
))
6261 fn
= tsubst_copy (get_first_fn (fn
), args
, in_decl
);
6263 /* Sometimes FN is a LOOKUP_EXPR. */
6264 fn
= tsubst_copy (fn
, args
, in_decl
);
6266 (code
, fn
, tsubst_copy (TREE_OPERAND (t
, 1), args
, in_decl
),
6270 case METHOD_CALL_EXPR
:
6272 tree name
= TREE_OPERAND (t
, 0);
6273 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
6275 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
, in_decl
);
6276 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
6278 else if (TREE_CODE (name
) == SCOPE_REF
6279 && TREE_CODE (TREE_OPERAND (name
, 1)) == BIT_NOT_EXPR
)
6281 tree base
= tsubst_copy (TREE_OPERAND (name
, 0), args
, in_decl
);
6282 name
= TREE_OPERAND (name
, 1);
6283 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
, in_decl
);
6284 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
6285 name
= build_nt (SCOPE_REF
, base
, name
);
6288 name
= tsubst_copy (TREE_OPERAND (t
, 0), args
, in_decl
);
6290 (code
, name
, tsubst_copy (TREE_OPERAND (t
, 1), args
, in_decl
),
6291 tsubst_copy (TREE_OPERAND (t
, 2), args
, in_decl
),
6300 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, in_decl
),
6301 tsubst_copy (TREE_OPERAND (t
, 1), args
, in_decl
),
6302 tsubst_copy (TREE_OPERAND (t
, 2), args
, in_decl
));
6304 if (code
== BIND_EXPR
&& !processing_template_decl
)
6306 /* This processing should really occur in tsubst_expr,
6307 However, tsubst_expr does not recurse into expressions,
6308 since it assumes that there aren't any statements
6309 inside them. Instead, it simply calls
6310 build_expr_from_tree. So, we need to expand the
6312 tree rtl_expr
= begin_stmt_expr ();
6313 tree block
= tsubst_expr (TREE_OPERAND (r
, 1), args
, in_decl
);
6314 r
= finish_stmt_expr (rtl_expr
, block
);
6323 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, in_decl
),
6324 tsubst_copy (TREE_OPERAND (t
, 1), args
, in_decl
),
6325 tsubst_copy (TREE_OPERAND (t
, 2), args
, in_decl
));
6326 NEW_EXPR_USE_GLOBAL (r
) = NEW_EXPR_USE_GLOBAL (t
);
6333 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, in_decl
),
6334 tsubst_copy (TREE_OPERAND (t
, 1), args
, in_decl
));
6335 DELETE_EXPR_USE_GLOBAL (r
) = DELETE_EXPR_USE_GLOBAL (t
);
6336 DELETE_EXPR_USE_VEC (r
) = DELETE_EXPR_USE_VEC (t
);
6340 case TEMPLATE_ID_EXPR
:
6342 /* Substituted template arguments */
6343 tree targs
= tsubst_copy (TREE_OPERAND (t
, 1), args
, in_decl
);
6345 for (chain
= targs
; chain
; chain
= TREE_CHAIN (chain
))
6346 TREE_VALUE (chain
) = maybe_fold_nontype_arg (TREE_VALUE (chain
));
6348 return lookup_template_function
6349 (tsubst_copy (TREE_OPERAND (t
, 0), args
, in_decl
), targs
);
6354 tree purpose
, value
, chain
;
6356 if (t
== void_list_node
)
6359 purpose
= TREE_PURPOSE (t
);
6361 purpose
= tsubst_copy (purpose
, args
, in_decl
);
6362 value
= TREE_VALUE (t
);
6364 value
= tsubst_copy (value
, args
, in_decl
);
6365 chain
= TREE_CHAIN (t
);
6366 if (chain
&& chain
!= void_type_node
)
6367 chain
= tsubst_copy (chain
, args
, in_decl
);
6368 if (purpose
== TREE_PURPOSE (t
)
6369 && value
== TREE_VALUE (t
)
6370 && chain
== TREE_CHAIN (t
))
6372 return tree_cons (purpose
, value
, chain
);
6379 case TEMPLATE_TYPE_PARM
:
6380 case TEMPLATE_TEMPLATE_PARM
:
6381 case TEMPLATE_PARM_INDEX
:
6383 case REFERENCE_TYPE
:
6390 return tsubst (t
, args
, in_decl
);
6392 case IDENTIFIER_NODE
:
6393 if (IDENTIFIER_TYPENAME_P (t
)
6394 /* Make sure it's not just a variable named `__opr', for instance,
6395 which can occur in some existing code. */
6397 return build_typename_overload
6398 (tsubst (TREE_TYPE (t
), args
, in_decl
));
6405 (CONSTRUCTOR
, tsubst (TREE_TYPE (t
), args
, in_decl
), NULL_TREE
,
6406 tsubst_copy (CONSTRUCTOR_ELTS (t
), args
, in_decl
));
6407 TREE_HAS_CONSTRUCTOR (r
) = TREE_HAS_CONSTRUCTOR (t
);
6416 /* Like tsubst_copy, but also does semantic processing and RTL expansion. */
6419 tsubst_expr (t
, args
, in_decl
)
6423 if (t
== NULL_TREE
|| t
== error_mark_node
)
6426 if (processing_template_decl
)
6427 return tsubst_copy (t
, args
, in_decl
);
6429 switch (TREE_CODE (t
))
6432 lineno
= TREE_COMPLEXITY (t
);
6433 finish_return_stmt (tsubst_expr (RETURN_EXPR (t
),
6438 lineno
= TREE_COMPLEXITY (t
);
6439 finish_expr_stmt (tsubst_expr (EXPR_STMT_EXPR (t
),
6445 int i
= suspend_momentary ();
6448 lineno
= TREE_COMPLEXITY (t
);
6449 emit_line_note (input_filename
, lineno
);
6451 (tsubst (TREE_OPERAND (t
, 0), args
, in_decl
),
6452 tsubst (TREE_OPERAND (t
, 1), args
, in_decl
),
6453 TREE_OPERAND (t
, 2) != 0, NULL_TREE
, NULL_TREE
);
6454 init
= tsubst_expr (TREE_OPERAND (t
, 2), args
, in_decl
);
6456 (dcl
, init
, NULL_TREE
, 1, /*init ? LOOKUP_ONLYCONVERTING :*/ 0);
6457 resume_momentary (i
);
6464 lineno
= TREE_COMPLEXITY (t
);
6467 for (tmp
= FOR_INIT_STMT (t
); tmp
; tmp
= TREE_CHAIN (tmp
))
6468 tsubst_expr (tmp
, args
, in_decl
);
6469 finish_for_init_stmt (NULL_TREE
);
6470 finish_for_cond (tsubst_expr (FOR_COND (t
), args
,
6473 tmp
= tsubst_expr (FOR_EXPR (t
), args
, in_decl
);
6474 finish_for_expr (tmp
, NULL_TREE
);
6475 tsubst_expr (FOR_BODY (t
), args
, in_decl
);
6476 finish_for_stmt (tmp
, NULL_TREE
);
6482 lineno
= TREE_COMPLEXITY (t
);
6483 begin_while_stmt ();
6484 finish_while_stmt_cond (tsubst_expr (WHILE_COND (t
),
6487 tsubst_expr (WHILE_BODY (t
), args
, in_decl
);
6488 finish_while_stmt (NULL_TREE
);
6494 lineno
= TREE_COMPLEXITY (t
);
6496 tsubst_expr (DO_BODY (t
), args
, in_decl
);
6497 finish_do_body (NULL_TREE
);
6498 finish_do_stmt (tsubst_expr (DO_COND (t
), args
,
6508 lineno
= TREE_COMPLEXITY (t
);
6510 finish_if_stmt_cond (tsubst_expr (IF_COND (t
),
6514 if (tmp
= THEN_CLAUSE (t
), tmp
)
6516 tsubst_expr (tmp
, args
, in_decl
);
6517 finish_then_clause (NULL_TREE
);
6520 if (tmp
= ELSE_CLAUSE (t
), tmp
)
6522 begin_else_clause ();
6523 tsubst_expr (tmp
, args
, in_decl
);
6524 finish_else_clause (NULL_TREE
);
6535 lineno
= TREE_COMPLEXITY (t
);
6536 begin_compound_stmt (COMPOUND_STMT_NO_SCOPE (t
));
6537 for (substmt
= COMPOUND_BODY (t
);
6538 substmt
!= NULL_TREE
;
6539 substmt
= TREE_CHAIN (substmt
))
6540 tsubst_expr (substmt
, args
, in_decl
);
6541 return finish_compound_stmt (COMPOUND_STMT_NO_SCOPE (t
),
6547 lineno
= TREE_COMPLEXITY (t
);
6548 finish_break_stmt ();
6552 lineno
= TREE_COMPLEXITY (t
);
6553 finish_continue_stmt ();
6560 lineno
= TREE_COMPLEXITY (t
);
6561 begin_switch_stmt ();
6562 val
= tsubst_expr (SWITCH_COND (t
), args
, in_decl
);
6563 finish_switch_cond (val
);
6565 if (tmp
= TREE_OPERAND (t
, 1), tmp
)
6566 tsubst_expr (tmp
, args
, in_decl
);
6568 finish_switch_stmt (val
, NULL_TREE
);
6573 finish_case_label (tsubst_expr (CASE_LOW (t
), args
, in_decl
),
6574 tsubst_expr (CASE_HIGH (t
), args
, in_decl
));
6578 t
= define_label (DECL_SOURCE_FILE (t
), DECL_SOURCE_LINE (t
),
6585 lineno
= TREE_COMPLEXITY (t
);
6586 t
= GOTO_DESTINATION (t
);
6587 if (TREE_CODE (t
) != IDENTIFIER_NODE
)
6588 /* Computed goto's must be tsubst'd into. On the other hand,
6589 non-computed gotos must not be; the identifier in question
6590 will have no binding. */
6591 t
= tsubst_expr (t
, args
, in_decl
);
6592 finish_goto_stmt (t
);
6596 lineno
= TREE_COMPLEXITY (t
);
6597 finish_asm_stmt (tsubst_expr (ASM_CV_QUAL (t
), args
, in_decl
),
6598 tsubst_expr (ASM_STRING (t
), args
, in_decl
),
6599 tsubst_expr (ASM_OUTPUTS (t
), args
, in_decl
),
6600 tsubst_expr (ASM_INPUTS (t
), args
, in_decl
),
6601 tsubst_expr (ASM_CLOBBERS (t
), args
, in_decl
));
6605 lineno
= TREE_COMPLEXITY (t
);
6607 tsubst_expr (TRY_STMTS (t
), args
, in_decl
);
6608 finish_try_block (NULL_TREE
);
6610 tree handler
= TRY_HANDLERS (t
);
6611 for (; handler
; handler
= TREE_CHAIN (handler
))
6612 tsubst_expr (handler
, args
, in_decl
);
6614 finish_handler_sequence (NULL_TREE
);
6618 lineno
= TREE_COMPLEXITY (t
);
6620 if (HANDLER_PARMS (t
))
6622 tree d
= HANDLER_PARMS (t
);
6623 expand_start_catch_block
6624 (tsubst (TREE_OPERAND (d
, 1), args
, in_decl
),
6625 tsubst (TREE_OPERAND (d
, 0), args
, in_decl
));
6628 expand_start_catch_block (NULL_TREE
, NULL_TREE
);
6629 finish_handler_parms (NULL_TREE
);
6630 tsubst_expr (HANDLER_BODY (t
), args
, in_decl
);
6631 finish_handler (NULL_TREE
);
6635 lineno
= TREE_COMPLEXITY (t
);
6637 if (TREE_CODE (t
) == ENUMERAL_TYPE
)
6638 tsubst (t
, args
, NULL_TREE
);
6642 return build_expr_from_tree (tsubst_copy (t
, args
, in_decl
));
6647 /* Instantiate the indicated variable or function template TMPL with
6648 the template arguments in TARG_PTR. */
6651 instantiate_template (tmpl
, targ_ptr
)
6652 tree tmpl
, targ_ptr
;
6658 struct obstack
*old_fmp_obstack
;
6659 extern struct obstack
*function_maybepermanent_obstack
;
6662 if (tmpl
== error_mark_node
)
6663 return error_mark_node
;
6665 my_friendly_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
, 283);
6667 /* Check to see if we already have this specialization. */
6668 spec
= retrieve_specialization (tmpl
, targ_ptr
);
6669 if (spec
!= NULL_TREE
)
6672 if (DECL_TEMPLATE_INFO (tmpl
))
6674 /* The TMPL is a partial instantiation. To get a full set of
6675 arguments we must add the arguments used to perform the
6676 partial instantiation. */
6677 targ_ptr
= add_outermost_template_args (DECL_TI_ARGS (tmpl
),
6679 gen_tmpl
= most_general_template (tmpl
);
6681 /* Check to see if we already have this specialization. */
6682 spec
= retrieve_specialization (gen_tmpl
, targ_ptr
);
6683 if (spec
!= NULL_TREE
)
6689 push_obstacks (&permanent_obstack
, &permanent_obstack
);
6690 old_fmp_obstack
= function_maybepermanent_obstack
;
6691 function_maybepermanent_obstack
= &permanent_obstack
;
6693 len
= DECL_NTPARMS (gen_tmpl
);
6694 inner_args
= innermost_args (targ_ptr
);
6698 tree t
= TREE_VEC_ELT (inner_args
, i
);
6699 if (TREE_CODE_CLASS (TREE_CODE (t
)) == 't')
6701 tree nt
= target_type (t
);
6702 if (IS_AGGR_TYPE (nt
) && decl_function_context (TYPE_MAIN_DECL (nt
)))
6704 cp_error ("type `%T' composed from a local class is not a valid template-argument", t
);
6705 cp_error (" trying to instantiate `%D'", gen_tmpl
);
6706 fndecl
= error_mark_node
;
6711 targ_ptr
= copy_to_permanent (targ_ptr
);
6713 /* substitute template parameters */
6714 fndecl
= tsubst (DECL_RESULT (gen_tmpl
), targ_ptr
, gen_tmpl
);
6715 /* The DECL_TI_TEMPLATE should always be the immediate parent
6716 template, not the most general template. */
6717 DECL_TI_TEMPLATE (fndecl
) = tmpl
;
6719 if (flag_external_templates
)
6720 add_pending_template (fndecl
);
6723 function_maybepermanent_obstack
= old_fmp_obstack
;
6729 /* Push the name of the class template into the scope of the instantiation. */
6732 overload_template_name (type
)
6735 tree id
= DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
));
6738 if (IDENTIFIER_CLASS_VALUE (id
)
6739 && TREE_TYPE (IDENTIFIER_CLASS_VALUE (id
)) == type
)
6742 decl
= build_decl (TYPE_DECL
, id
, type
);
6743 SET_DECL_ARTIFICIAL (decl
);
6744 pushdecl_class_level (decl
);
6747 /* Like type_unification but designed specially to handle conversion
6750 The FN is a TEMPLATE_DECL for a function. The ARGS are the
6751 arguments that are being used when calling it.
6753 If FN is a conversion operator, RETURN_TYPE is the type desired as
6754 the result of the conversion operator.
6756 The EXTRA_FN_ARG, if any, is the type of an additional
6757 parameter to be added to the beginning of FN's parameter list.
6759 The other arguments are as for type_unification. */
6762 fn_type_unification (fn
, explicit_targs
, targs
, args
, return_type
,
6763 strict
, extra_fn_arg
)
6764 tree fn
, explicit_targs
, targs
, args
, return_type
;
6765 unification_kind_t strict
;
6770 my_friendly_assert (TREE_CODE (fn
) == TEMPLATE_DECL
, 0);
6772 parms
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
6774 if (DECL_CONV_FN_P (fn
))
6776 /* This is a template conversion operator. Use the return types
6777 as well as the argument types. */
6778 parms
= scratch_tree_cons (NULL_TREE
,
6779 TREE_TYPE (TREE_TYPE (fn
)),
6781 args
= scratch_tree_cons (NULL_TREE
, return_type
, args
);
6784 if (extra_fn_arg
!= NULL_TREE
)
6785 parms
= scratch_tree_cons (NULL_TREE
, extra_fn_arg
, parms
);
6787 /* We allow incomplete unification without an error message here
6788 because the standard doesn't seem to explicitly prohibit it. Our
6789 callers must be ready to deal with unification failures in any
6791 return type_unification (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
6800 /* Type unification.
6802 We have a function template signature with one or more references to
6803 template parameters, and a parameter list we wish to fit to this
6804 template. If possible, produce a list of parameters for the template
6805 which will cause it to fit the supplied parameter list.
6807 Return zero for success, 2 for an incomplete match that doesn't resolve
6808 all the types, and 1 for complete failure. An error message will be
6809 printed only for an incomplete match.
6811 TPARMS[NTPARMS] is an array of template parameter types.
6813 TARGS[NTPARMS] is the array into which the deduced template
6814 parameter values are placed. PARMS is the function template's
6815 signature (using TEMPLATE_PARM_IDX nodes), and ARGS is the argument
6816 list we're trying to match against it.
6818 The EXPLICIT_TARGS are explicit template arguments provided via a
6821 The parameter STRICT is one of:
6824 We are deducing arguments for a function call, as in
6828 We are deducing arguments for a conversion function, as in
6832 We are deducing arguments when calculating the partial
6833 ordering between specializations of function or class
6834 templates, as in [temp.func.order] and [temp.class.order],
6835 when doing an explicit instantiation as in [temp.explicit],
6836 when determining an explicit specialization as in
6837 [temp.expl.spec], or when taking the address of a function
6838 template, as in [temp.deduct.funcaddr]. */
6841 type_unification (tparms
, targs
, parms
, args
, explicit_targs
,
6842 strict
, allow_incomplete
)
6843 tree tparms
, targs
, parms
, args
, explicit_targs
;
6844 unification_kind_t strict
;
6845 int allow_incomplete
;
6850 for (i
= 0; i
< TREE_VEC_LENGTH (tparms
); i
++)
6851 TREE_VEC_ELT (targs
, i
) = NULL_TREE
;
6853 if (explicit_targs
!= NULL_TREE
)
6856 arg_vec
= coerce_template_parms (tparms
, explicit_targs
, NULL_TREE
, 0,
6859 if (arg_vec
== error_mark_node
)
6862 explicit_mask
= alloca (sizeof (int) * TREE_VEC_LENGTH (targs
));
6863 bzero ((char *) explicit_mask
, sizeof(int) * TREE_VEC_LENGTH (targs
));
6866 i
< TREE_VEC_LENGTH (arg_vec
)
6867 && TREE_VEC_ELT (arg_vec
, i
) != NULL_TREE
;
6870 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (arg_vec
, i
);
6871 /* Let unify know that this argument was explicit. */
6872 explicit_mask
[i
] = 1;
6879 type_unification_real (tparms
, targs
, parms
, args
, 0,
6880 strict
, allow_incomplete
, explicit_mask
);
6883 /* Adjust types before performing type deduction, as described in
6884 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
6885 sections are symmetric. PARM is the type of a function parameter
6886 or the return type of the conversion function. ARG is the type of
6887 the argument passed to the call, or the type of the value
6888 intialized with the result of the conversion function. */
6891 maybe_adjust_types_for_deduction (strict
, parm
, arg
)
6892 unification_kind_t strict
;
6903 /* Swap PARM and ARG throughout the remainder of this
6904 function; the handling is precisely symmetric since PARM
6905 will initialize ARG rather than vice versa. */
6913 /* There is nothing to do in this case. */
6917 my_friendly_abort (0);
6920 if (TREE_CODE (*parm
) != REFERENCE_TYPE
)
6922 /* [temp.deduct.call]
6924 If P is not a reference type:
6926 --If A is an array type, the pointer type produced by the
6927 array-to-pointer standard conversion (_conv.array_) is
6928 used in place of A for type deduction; otherwise,
6930 --If A is a function type, the pointer type produced by
6931 the function-to-pointer standard conversion
6932 (_conv.func_) is used in place of A for type deduction;
6935 --If A is a cv-qualified type, the top level
6936 cv-qualifiers of A's type are ignored for type
6938 if (TREE_CODE (*arg
) == ARRAY_TYPE
)
6939 *arg
= build_pointer_type (TREE_TYPE (*arg
));
6940 else if (TREE_CODE (*arg
) == FUNCTION_TYPE
6941 || TREE_CODE (*arg
) == METHOD_TYPE
)
6942 *arg
= build_pointer_type (*arg
);
6944 *arg
= TYPE_MAIN_VARIANT (*arg
);
6947 /* [temp.deduct.call]
6949 If P is a cv-qualified type, the top level cv-qualifiers
6950 of P's type are ignored for type deduction. If P is a
6951 reference type, the type referred to by P is used for
6953 *parm
= TYPE_MAIN_VARIANT (*parm
);
6954 if (TREE_CODE (*parm
) == REFERENCE_TYPE
)
6955 *parm
= TREE_TYPE (*parm
);
6958 /* Like type_unfication. EXPLICIT_MASK, if non-NULL, is an array of
6959 integers, with ones in positions corresponding to arguments in
6960 targs that were provided explicitly, and zeros elsewhere.
6962 If SUBR is 1, we're being called recursively (to unify the
6963 arguments of a function or method parameter of a function
6967 type_unification_real (tparms
, targs
, parms
, args
, subr
,
6968 strict
, allow_incomplete
, explicit_mask
)
6969 tree tparms
, targs
, parms
, args
;
6971 unification_kind_t strict
;
6972 int allow_incomplete
;
6977 int ntparms
= TREE_VEC_LENGTH (tparms
);
6980 my_friendly_assert (TREE_CODE (tparms
) == TREE_VEC
, 289);
6981 my_friendly_assert (parms
== NULL_TREE
6982 || TREE_CODE (parms
) == TREE_LIST
, 290);
6983 /* ARGS could be NULL (via a call from parse.y to
6984 build_x_function_call). */
6986 my_friendly_assert (TREE_CODE (args
) == TREE_LIST
, 291);
6987 my_friendly_assert (ntparms
> 0, 292);
6992 sub_strict
= UNIFY_ALLOW_MORE_CV_QUAL
| UNIFY_ALLOW_DERIVED
;
6996 sub_strict
= UNIFY_ALLOW_LESS_CV_QUAL
;
7000 sub_strict
= UNIFY_ALLOW_NONE
;
7004 my_friendly_abort (0);
7008 && parms
!= void_list_node
7010 && args
!= void_list_node
)
7012 parm
= TREE_VALUE (parms
);
7013 parms
= TREE_CHAIN (parms
);
7014 arg
= TREE_VALUE (args
);
7015 args
= TREE_CHAIN (args
);
7017 if (arg
== error_mark_node
)
7019 if (arg
== unknown_type_node
)
7020 /* We can't deduce anything from this, but we might get all the
7021 template args from other function args. */
7024 /* Conversions will be performed on a function argument that
7025 corresponds with a function parameter that contains only
7026 non-deducible template parameters and explicitly specified
7027 template parameters. */
7028 if (! uses_template_parms (parm
))
7032 if (TREE_CODE_CLASS (TREE_CODE (arg
)) != 't')
7033 type
= TREE_TYPE (arg
);
7040 if (strict
== DEDUCE_EXACT
)
7042 if (same_type_p (parm
, type
))
7046 /* It might work; we shouldn't check now, because we might
7047 get into infinite recursion. Overload resolution will
7055 if (TREE_CODE (arg
) == VAR_DECL
)
7056 arg
= TREE_TYPE (arg
);
7057 else if (TREE_CODE_CLASS (TREE_CODE (arg
)) == 'e')
7058 arg
= TREE_TYPE (arg
);
7060 if (TREE_CODE_CLASS (TREE_CODE (arg
)) != 't')
7062 my_friendly_assert (TREE_TYPE (arg
) != NULL_TREE
, 293);
7063 if (type_unknown_p (arg
))
7065 /* [temp.deduct.type] A template-argument can be deduced from
7066 a pointer to function or pointer to member function
7067 argument if the set of overloaded functions does not
7068 contain function templates and at most one of a set of
7069 overloaded functions provides a unique match. */
7071 if (resolve_overloaded_unification
7072 (tparms
, targs
, parm
, arg
, strict
, sub_strict
, explicit_mask
)
7077 arg
= TREE_TYPE (arg
);
7081 maybe_adjust_types_for_deduction (strict
, &parm
, &arg
);
7083 switch (unify (tparms
, targs
, parm
, arg
, sub_strict
,
7092 /* Fail if we've reached the end of the parm list, and more args
7093 are present, and the parm list isn't variadic. */
7094 if (args
&& args
!= void_list_node
&& parms
== void_list_node
)
7096 /* Fail if parms are left and they don't have default values. */
7098 && parms
!= void_list_node
7099 && TREE_PURPOSE (parms
) == NULL_TREE
)
7102 for (i
= 0; i
< ntparms
; i
++)
7103 if (TREE_VEC_ELT (targs
, i
) == NULL_TREE
)
7105 if (!allow_incomplete
)
7106 error ("incomplete type unification");
7112 /* Subroutine of type_unification_real. Args are like the variables at the
7113 call site. ARG is an overloaded function (or template-id); we try
7114 deducing template args from each of the overloads, and if only one
7115 succeeds, we go with that. Modifies TARGS and returns 0 on success. */
7118 resolve_overloaded_unification (tparms
, targs
, parm
, arg
, strict
,
7119 sub_strict
, explicit_mask
)
7120 tree tparms
, targs
, parm
, arg
;
7121 unification_kind_t strict
;
7125 tree tempargs
= copy_node (targs
);
7128 if (TREE_CODE (arg
) == ADDR_EXPR
)
7129 arg
= TREE_OPERAND (arg
, 0);
7130 if (TREE_CODE (arg
) == TEMPLATE_ID_EXPR
)
7132 /* If we got some explicit template args, we need to plug them into
7133 the affected templates before we try to unify, in case the
7134 explicit args will completely resolve the templates in question. */
7136 tree expl_subargs
= TREE_OPERAND (arg
, 1);
7137 arg
= TREE_OPERAND (arg
, 0);
7139 for (; arg
; arg
= OVL_NEXT (arg
))
7141 tree fn
= OVL_CURRENT (arg
);
7144 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
7147 subargs
= get_bindings_overload (fn
, DECL_RESULT (fn
), expl_subargs
);
7150 elem
= tsubst (TREE_TYPE (fn
), subargs
, NULL_TREE
);
7151 good
+= try_one_overload (tparms
, targs
, tempargs
, parm
, elem
,
7152 strict
, sub_strict
, explicit_mask
);
7156 else if (TREE_CODE (arg
) == OVERLOAD
)
7158 for (; arg
; arg
= OVL_NEXT (arg
))
7159 good
+= try_one_overload (tparms
, targs
, tempargs
, parm
,
7160 TREE_TYPE (OVL_CURRENT (arg
)),
7161 strict
, sub_strict
, explicit_mask
);
7164 my_friendly_abort (981006);
7166 /* [temp.deduct.type] A template-argument can be deduced from a pointer
7167 to function or pointer to member function argument if the set of
7168 overloaded functions does not contain function templates and at most
7169 one of a set of overloaded functions provides a unique match.
7171 So if we found multiple possibilities, we return success but don't
7176 int i
= TREE_VEC_LENGTH (targs
);
7178 if (TREE_VEC_ELT (tempargs
, i
))
7179 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (tempargs
, i
);
7187 /* Subroutine of resolve_overloaded_unification; does deduction for a single
7188 overload. Fills TARGS with any deduced arguments, or error_mark_node if
7189 different overloads deduce different arguments for a given parm.
7190 Returns 1 on success. */
7193 try_one_overload (tparms
, orig_targs
, targs
, parm
, arg
, strict
,
7194 sub_strict
, explicit_mask
)
7195 tree tparms
, orig_targs
, targs
, parm
, arg
;
7196 unification_kind_t strict
;
7204 /* [temp.deduct.type] A template-argument can be deduced from a pointer
7205 to function or pointer to member function argument if the set of
7206 overloaded functions does not contain function templates and at most
7207 one of a set of overloaded functions provides a unique match.
7209 So if this is a template, just return success. */
7211 if (uses_template_parms (arg
))
7214 maybe_adjust_types_for_deduction (strict
, &parm
, &arg
);
7216 /* We don't copy orig_targs for this because if we have already deduced
7217 some template args from previous args, unify would complain when we
7218 try to deduce a template parameter for the same argument, even though
7219 there isn't really a conflict. */
7220 nargs
= TREE_VEC_LENGTH (targs
);
7221 tempargs
= make_scratch_vec (nargs
);
7223 if (unify (tparms
, tempargs
, parm
, arg
, sub_strict
, explicit_mask
) != 0)
7226 /* First make sure we didn't deduce anything that conflicts with
7227 explicitly specified args. */
7228 for (i
= nargs
; i
--; )
7230 tree elt
= TREE_VEC_ELT (tempargs
, i
);
7231 tree oldelt
= TREE_VEC_ELT (orig_targs
, i
);
7233 if (elt
== NULL_TREE
)
7235 else if (uses_template_parms (elt
))
7237 /* Since we're unifying against ourselves, we will fill in template
7238 args used in the function parm list with our own template parms.
7240 TREE_VEC_ELT (tempargs
, i
) = NULL_TREE
;
7243 else if (oldelt
&& ! template_args_equal (oldelt
, elt
))
7247 for (i
= nargs
; i
--; )
7249 tree elt
= TREE_VEC_ELT (tempargs
, i
);
7252 TREE_VEC_ELT (targs
, i
) = elt
;
7258 /* Returns the level of DECL, which declares a template parameter. */
7261 template_decl_level (decl
)
7264 switch (TREE_CODE (decl
))
7268 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl
));
7271 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl
));
7274 my_friendly_abort (0);
7279 /* Decide whether ARG can be unified with PARM, considering only the
7280 cv-qualifiers of each type, given STRICT as documented for unify.
7281 Returns non-zero iff the unification is OK on that basis.*/
7284 check_cv_quals_for_unify (strict
, arg
, parm
)
7289 return !((!(strict
& UNIFY_ALLOW_MORE_CV_QUAL
)
7290 && !at_least_as_qualified_p (arg
, parm
))
7291 || (!(strict
& UNIFY_ALLOW_LESS_CV_QUAL
)
7292 && (!at_least_as_qualified_p (parm
, arg
))));
7295 /* Takes parameters as for type_unification. Returns 0 if the
7296 type deduction suceeds, 1 otherwise. The parameter STRICT is a
7297 bitwise or of the following flags:
7300 Require an exact match between PARM and ARG.
7301 UNIFY_ALLOW_MORE_CV_QUAL:
7302 Allow the deduced ARG to be more cv-qualified than ARG.
7303 UNIFY_ALLOW_LESS_CV_QUAL:
7304 Allow the deduced ARG to be less cv-qualified than ARG.
7305 UNIFY_ALLOW_DERIVED:
7306 Allow the deduced ARG to be a template base class of ARG,
7307 or a pointer to a template base class of the type pointed to by
7309 UNIFY_ALLOW_INTEGER:
7310 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
7311 case for more information. */
7314 unify (tparms
, targs
, parm
, arg
, strict
, explicit_mask
)
7315 tree tparms
, targs
, parm
, arg
;
7323 /* I don't think this will do the right thing with respect to types.
7324 But the only case I've seen it in so far has been array bounds, where
7325 signedness is the only information lost, and I think that will be
7327 while (TREE_CODE (parm
) == NOP_EXPR
)
7328 parm
= TREE_OPERAND (parm
, 0);
7330 if (arg
== error_mark_node
)
7332 if (arg
== unknown_type_node
)
7333 /* We can't deduce anything from this, but we might get all the
7334 template args from other function args. */
7337 /* If PARM uses template parameters, then we can't bail out here,
7338 even in ARG == PARM, since we won't record unifications for the
7339 template parameters. We might need them if we're trying to
7340 figure out which of two things is more specialized. */
7341 if (arg
== parm
&& !uses_template_parms (parm
))
7344 /* Immediately reject some pairs that won't unify because of
7345 cv-qualification mismatches. */
7346 if (TREE_CODE (arg
) == TREE_CODE (parm
)
7347 && TREE_CODE_CLASS (TREE_CODE (arg
)) == 't'
7348 /* We check the cv-qualifiers when unifying with template type
7349 parameters below. We want to allow ARG `const T' to unify with
7350 PARM `T' for example, when computing which of two templates
7351 is more specialized, for example. */
7352 && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
7353 && !check_cv_quals_for_unify (strict
, arg
, parm
))
7356 switch (TREE_CODE (parm
))
7359 /* In a type which contains a nested-name-specifier, template
7360 argument values cannot be deduced for template parameters used
7361 within the nested-name-specifier. */
7364 case TEMPLATE_TYPE_PARM
:
7365 case TEMPLATE_TEMPLATE_PARM
:
7366 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
7368 if (TEMPLATE_TYPE_LEVEL (parm
)
7369 != template_decl_level (tparm
))
7370 /* The PARM is not one we're trying to unify. Just check
7371 to see if it matches ARG. */
7372 return (TREE_CODE (arg
) == TREE_CODE (parm
)
7373 && same_type_p (parm
, arg
)) ? 0 : 1;
7374 idx
= TEMPLATE_TYPE_IDX (parm
);
7375 targ
= TREE_VEC_ELT (targs
, idx
);
7376 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, idx
));
7378 /* Check for mixed types and values. */
7379 if ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
7380 && TREE_CODE (tparm
) != TYPE_DECL
)
7381 || (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
7382 && TREE_CODE (tparm
) != TEMPLATE_DECL
))
7385 if (!strict
&& targ
!= NULL_TREE
7386 && explicit_mask
&& explicit_mask
[idx
])
7387 /* An explicit template argument. Don't even try to match
7388 here; the overload resolution code will manage check to
7389 see whether the call is legal. */
7392 if (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
7394 if (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm
))
7396 /* We arrive here when PARM does not involve template
7399 /* ARG must be constructed from a template class. */
7400 if (TREE_CODE (arg
) != RECORD_TYPE
|| !CLASSTYPE_TEMPLATE_INFO (arg
))
7404 tree parmtmpl
= TYPE_TI_TEMPLATE (parm
);
7405 tree parmvec
= TYPE_TI_ARGS (parm
);
7406 tree argvec
= CLASSTYPE_TI_ARGS (arg
);
7408 = DECL_INNERMOST_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (arg
));
7411 /* The parameter and argument roles have to be switched here
7412 in order to handle default arguments properly. For example,
7413 template<template <class> class TT> void f(TT<int>)
7414 should be able to accept vector<int> which comes from
7415 template <class T, class Allocator = allocator>
7418 if (coerce_template_parms (argtmplvec
, parmvec
, parmtmpl
, 1, 1)
7422 /* Deduce arguments T, i from TT<T> or TT<i>. */
7423 for (i
= 0; i
< TREE_VEC_LENGTH (parmvec
); ++i
)
7425 tree t
= TREE_VEC_ELT (parmvec
, i
);
7426 if (TREE_CODE (t
) != TEMPLATE_TYPE_PARM
7427 && TREE_CODE (t
) != TEMPLATE_TEMPLATE_PARM
7428 && TREE_CODE (t
) != TEMPLATE_PARM_INDEX
)
7431 /* This argument can be deduced. */
7433 if (unify (tparms
, targs
, t
,
7434 TREE_VEC_ELT (argvec
, i
),
7435 UNIFY_ALLOW_NONE
, explicit_mask
))
7439 arg
= CLASSTYPE_TI_TEMPLATE (arg
);
7444 /* If PARM is `const T' and ARG is only `int', we don't have
7445 a match unless we are allowing additional qualification.
7446 If ARG is `const int' and PARM is just `T' that's OK;
7447 that binds `const int' to `T'. */
7448 if (!check_cv_quals_for_unify (strict
| UNIFY_ALLOW_LESS_CV_QUAL
,
7452 /* Consider the case where ARG is `const volatile int' and
7453 PARM is `const T'. Then, T should be `volatile int'. */
7455 cp_build_qualified_type (arg
,
7457 & ~CP_TYPE_QUALS (parm
));
7460 /* Simple cases: Value already set, does match or doesn't. */
7461 if (targ
!= NULL_TREE
7462 && (same_type_p (targ
, arg
)
7463 || (explicit_mask
&& explicit_mask
[idx
])))
7467 TREE_VEC_ELT (targs
, idx
) = arg
;
7470 case TEMPLATE_PARM_INDEX
:
7471 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
7473 if (TEMPLATE_PARM_LEVEL (parm
)
7474 != template_decl_level (tparm
))
7475 /* The PARM is not one we're trying to unify. Just check
7476 to see if it matches ARG. */
7477 return (TREE_CODE (arg
) == TREE_CODE (parm
)
7478 && cp_tree_equal (parm
, arg
) > 0) ? 0 : 1;
7480 idx
= TEMPLATE_PARM_IDX (parm
);
7481 targ
= TREE_VEC_ELT (targs
, idx
);
7485 int i
= (cp_tree_equal (targ
, arg
) > 0);
7491 my_friendly_abort (42);
7494 /* [temp.deduct.type] If, in the declaration of a function template
7495 with a non-type template-parameter, the non-type
7496 template-parameter is used in an expression in the function
7497 parameter-list and, if the corresponding template-argument is
7498 deduced, the template-argument type shall match the type of the
7499 template-parameter exactly, except that a template-argument
7500 deduced from an array bound may be of any integral type. */
7501 if (same_type_p (TREE_TYPE (arg
), TREE_TYPE (parm
)))
7503 else if ((strict
& UNIFY_ALLOW_INTEGER
)
7504 && (TREE_CODE (TREE_TYPE (parm
)) == INTEGER_TYPE
7505 || TREE_CODE (TREE_TYPE (parm
)) == BOOLEAN_TYPE
))
7510 TREE_VEC_ELT (targs
, idx
) = copy_to_permanent (arg
);
7517 if (TREE_CODE (arg
) == RECORD_TYPE
&& TYPE_PTRMEMFUNC_FLAG (arg
))
7518 return (unify (tparms
, targs
, parm
,
7519 TYPE_PTRMEMFUNC_FN_TYPE (arg
), strict
,
7522 if (TREE_CODE (arg
) != POINTER_TYPE
)
7525 /* [temp.deduct.call]
7527 A can be another pointer or pointer to member type that can
7528 be converted to the deduced A via a qualification
7529 conversion (_conv.qual_).
7531 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
7532 This will allow for additional cv-qualification of the
7533 pointed-to types if appropriate. In general, this is a bit
7534 too generous; we are only supposed to allow qualification
7535 conversions and this method will allow an ARG of char** and
7536 a deduced ARG of const char**. However, overload
7537 resolution will subsequently invalidate the candidate, so
7538 this is probably OK. */
7539 sub_strict
= strict
;
7541 if (TREE_CODE (TREE_TYPE (arg
)) != RECORD_TYPE
7542 || TYPE_PTRMEMFUNC_FLAG (TREE_TYPE (arg
)))
7543 /* The derived-to-base conversion only persists through one
7544 level of pointers. */
7545 sub_strict
&= ~UNIFY_ALLOW_DERIVED
;
7547 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE
7548 (arg
), sub_strict
, explicit_mask
);
7551 case REFERENCE_TYPE
:
7552 if (TREE_CODE (arg
) != REFERENCE_TYPE
)
7554 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
7555 UNIFY_ALLOW_NONE
, explicit_mask
);
7558 if (TREE_CODE (arg
) != ARRAY_TYPE
)
7560 if ((TYPE_DOMAIN (parm
) == NULL_TREE
)
7561 != (TYPE_DOMAIN (arg
) == NULL_TREE
))
7563 if (TYPE_DOMAIN (parm
) != NULL_TREE
7564 && unify (tparms
, targs
, TYPE_DOMAIN (parm
),
7565 TYPE_DOMAIN (arg
), UNIFY_ALLOW_NONE
, explicit_mask
) != 0)
7567 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
7568 UNIFY_ALLOW_NONE
, explicit_mask
);
7575 if (TREE_CODE (arg
) != TREE_CODE (parm
))
7578 if (TREE_CODE (parm
) == INTEGER_TYPE
7579 && TREE_CODE (TYPE_MAX_VALUE (parm
)) != INTEGER_CST
)
7581 if (TYPE_MIN_VALUE (parm
) && TYPE_MIN_VALUE (arg
)
7582 && unify (tparms
, targs
, TYPE_MIN_VALUE (parm
),
7583 TYPE_MIN_VALUE (arg
), UNIFY_ALLOW_INTEGER
,
7586 if (TYPE_MAX_VALUE (parm
) && TYPE_MAX_VALUE (arg
)
7587 && unify (tparms
, targs
, TYPE_MAX_VALUE (parm
),
7588 TYPE_MAX_VALUE (arg
), UNIFY_ALLOW_INTEGER
,
7592 /* We use the TYPE_MAIN_VARIANT since we have already
7593 checked cv-qualification at the top of the
7595 else if (!same_type_p (TYPE_MAIN_VARIANT (arg
),
7596 TYPE_MAIN_VARIANT (parm
)))
7599 /* As far as unification is concerned, this wins. Later checks
7600 will invalidate it if necessary. */
7603 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
7604 /* Type INTEGER_CST can come from ordinary constant template args. */
7606 while (TREE_CODE (arg
) == NOP_EXPR
)
7607 arg
= TREE_OPERAND (arg
, 0);
7609 if (TREE_CODE (arg
) != INTEGER_CST
)
7611 return !tree_int_cst_equal (parm
, arg
);
7616 if (TREE_CODE (arg
) != TREE_VEC
)
7618 if (TREE_VEC_LENGTH (parm
) != TREE_VEC_LENGTH (arg
))
7620 for (i
= TREE_VEC_LENGTH (parm
) - 1; i
>= 0; i
--)
7621 if (unify (tparms
, targs
,
7622 TREE_VEC_ELT (parm
, i
), TREE_VEC_ELT (arg
, i
),
7623 UNIFY_ALLOW_NONE
, explicit_mask
))
7629 if (TYPE_PTRMEMFUNC_FLAG (parm
))
7630 return unify (tparms
, targs
, TYPE_PTRMEMFUNC_FN_TYPE (parm
),
7631 arg
, strict
, explicit_mask
);
7633 if (TREE_CODE (arg
) != RECORD_TYPE
)
7636 if (CLASSTYPE_TEMPLATE_INFO (parm
) && uses_template_parms (parm
))
7639 if (strict
& UNIFY_ALLOW_DERIVED
)
7640 /* [temp.deduct.call]
7642 If P is a class, and P has the form template-id, then A
7643 can be a derived class of the deduced A. Likewise, if
7644 P is a pointer to a class of the form template-id, A
7645 can be a pointer to a derived class pointed to by the
7648 The call to get_template_base also handles the case
7649 where PARM and ARG are the same type, i.e., where no
7650 derivation is involved. */
7651 t
= get_template_base (CLASSTYPE_TI_TEMPLATE (parm
), arg
);
7652 else if (CLASSTYPE_TEMPLATE_INFO (arg
)
7653 && (CLASSTYPE_TI_TEMPLATE (parm
)
7654 == CLASSTYPE_TI_TEMPLATE (arg
)))
7655 /* Perhaps PARM is something like S<U> and ARG is S<int>.
7656 Then, we should unify `int' and `U'. */
7659 if (! t
|| t
== error_mark_node
)
7662 return unify (tparms
, targs
, CLASSTYPE_TI_ARGS (parm
),
7663 CLASSTYPE_TI_ARGS (t
), UNIFY_ALLOW_NONE
,
7666 else if (!same_type_p (TYPE_MAIN_VARIANT (parm
),
7667 TYPE_MAIN_VARIANT (arg
)))
7673 if (TREE_CODE (arg
) != TREE_CODE (parm
))
7676 if (unify (tparms
, targs
, TREE_TYPE (parm
),
7677 TREE_TYPE (arg
), UNIFY_ALLOW_NONE
, explicit_mask
))
7679 return type_unification_real (tparms
, targs
, TYPE_ARG_TYPES (parm
),
7680 TYPE_ARG_TYPES (arg
), 1,
7681 DEDUCE_EXACT
, 0, explicit_mask
);
7684 if (TREE_CODE (arg
) != OFFSET_TYPE
)
7686 if (unify (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
7687 TYPE_OFFSET_BASETYPE (arg
), UNIFY_ALLOW_NONE
, explicit_mask
))
7689 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
7690 UNIFY_ALLOW_NONE
, explicit_mask
);
7693 if (arg
!= decl_constant_value (parm
))
7698 /* Matched cases are handled by the ARG == PARM test above. */
7702 if (TREE_CODE (TREE_OPERAND (parm
, 1)) == INTEGER_CST
)
7704 /* We handle this case specially, since it comes up with
7705 arrays. In particular, something like:
7707 template <int N> void f(int (&x)[N]);
7709 Here, we are trying to unify the range type, which
7710 looks like [0 ... (N - 1)]. */
7712 t1
= TREE_OPERAND (parm
, 0);
7713 t2
= TREE_OPERAND (parm
, 1);
7715 /* Should this be a regular fold? */
7716 t
= maybe_fold_nontype_arg (build (PLUS_EXPR
,
7720 return unify (tparms
, targs
, t1
, t
, strict
, explicit_mask
);
7722 /* else fall through */
7725 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (parm
))))
7727 /* We're looking at an expression. This can happen with
7731 void foo(S<I>, S<I + 2>);
7733 If the call looked like:
7735 foo(S<2>(), S<4>());
7737 we would have already matched `I' with `2'. Now, we'd
7738 like to know if `4' matches `I + 2'. So, we substitute
7739 into that expression, and fold constants, in the hope of
7742 maybe_fold_nontype_arg (tsubst_expr (parm
, targs
, NULL_TREE
));
7743 tree a
= maybe_fold_nontype_arg (arg
);
7745 if (!IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (t
))))
7746 /* Good, we mangaged to simplify the exression. */
7747 return unify (tparms
, targs
, t
, a
, UNIFY_ALLOW_NONE
,
7750 /* Bad, we couldn't simplify this. Assume it doesn't
7755 sorry ("use of `%s' in template type unification",
7756 tree_code_name
[(int) TREE_CODE (parm
)]);
7762 /* Called if RESULT is explicitly instantiated, or is a member of an
7763 explicitly instantiated class, or if using -frepo and the
7764 instantiation of RESULT has been assigned to this file. */
7767 mark_decl_instantiated (result
, extern_p
)
7771 if (TREE_CODE (result
) != FUNCTION_DECL
)
7772 /* The TREE_PUBLIC flag for function declarations will have been
7773 set correctly by tsubst. */
7774 TREE_PUBLIC (result
) = 1;
7778 DECL_INTERFACE_KNOWN (result
) = 1;
7779 DECL_NOT_REALLY_EXTERN (result
) = 1;
7781 /* Always make artificials weak. */
7782 if (DECL_ARTIFICIAL (result
) && flag_weak
)
7783 comdat_linkage (result
);
7784 /* For WIN32 we also want to put explicit instantiations in
7785 linkonce sections. */
7786 else if (TREE_PUBLIC (result
))
7787 maybe_make_one_only (result
);
7789 else if (TREE_CODE (result
) == FUNCTION_DECL
)
7790 mark_inline_for_output (result
);
7793 /* Given two function templates PAT1 and PAT2, and explicit template
7794 arguments EXPLICIT_ARGS return:
7796 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
7797 -1 if PAT2 is more specialized than PAT1.
7798 0 if neither is more specialized. */
7801 more_specialized (pat1
, pat2
, explicit_args
)
7802 tree pat1
, pat2
, explicit_args
;
7807 targs
= get_bindings_overload (pat1
, pat2
, explicit_args
);
7811 targs
= get_bindings_overload (pat2
, pat1
, explicit_args
);
7818 /* Given two class template specialization list nodes PAT1 and PAT2, return:
7820 1 if PAT1 is more specialized than PAT2 as described in [temp.class.order].
7821 -1 if PAT2 is more specialized than PAT1.
7822 0 if neither is more specialized. */
7825 more_specialized_class (pat1
, pat2
)
7831 targs
= get_class_bindings (TREE_VALUE (pat1
), TREE_PURPOSE (pat1
),
7832 TREE_PURPOSE (pat2
));
7836 targs
= get_class_bindings (TREE_VALUE (pat2
), TREE_PURPOSE (pat2
),
7837 TREE_PURPOSE (pat1
));
7844 /* Return the template arguments that will produce the function signature
7845 DECL from the function template FN, with the explicit template
7846 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is 1, the return type must
7850 get_bindings_real (fn
, decl
, explicit_args
, check_rettype
)
7851 tree fn
, decl
, explicit_args
;
7854 int ntparms
= DECL_NTPARMS (fn
);
7855 tree targs
= make_scratch_vec (ntparms
);
7856 tree decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
7857 tree extra_fn_arg
= NULL_TREE
;
7860 if (DECL_STATIC_FUNCTION_P (fn
)
7861 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
7863 /* Sometimes we are trying to figure out what's being
7864 specialized by a declaration that looks like a method, and it
7865 turns out to be a static member function. */
7866 if (CLASSTYPE_TEMPLATE_INFO (DECL_REAL_CONTEXT (fn
))
7867 && !is_member_template (fn
))
7868 /* The natural thing to do here seems to be to remove the
7869 spurious `this' parameter from the DECL, but that prevents
7870 unification from making use of the class type. So,
7871 instead, we have fn_type_unification add to the parameters
7873 extra_fn_arg
= build_pointer_type (DECL_REAL_CONTEXT (fn
));
7875 /* In this case, though, adding the extra_fn_arg can confuse
7876 things, so we remove from decl_arg_types instead. */
7877 decl_arg_types
= TREE_CHAIN (decl_arg_types
);
7880 i
= fn_type_unification (fn
, explicit_args
, targs
,
7882 TREE_TYPE (TREE_TYPE (decl
)),
7891 /* Check to see that the resulting return type is also OK. */
7892 tree t
= tsubst (TREE_TYPE (TREE_TYPE (fn
)), targs
,
7895 if (!same_type_p (t
, TREE_TYPE (TREE_TYPE (decl
))))
7902 /* For most uses, we want to check the return type. */
7905 get_bindings (fn
, decl
, explicit_args
)
7906 tree fn
, decl
, explicit_args
;
7908 return get_bindings_real (fn
, decl
, explicit_args
, 1);
7911 /* But for more_specialized, we only care about the parameter types. */
7914 get_bindings_overload (fn
, decl
, explicit_args
)
7915 tree fn
, decl
, explicit_args
;
7917 return get_bindings_real (fn
, decl
, explicit_args
, 0);
7920 /* Return the innermost template arguments that, when applied to a
7921 template specialization whose innermost template parameters are
7922 TPARMS, and whose specialization arguments are ARGS, yield the
7925 For example, suppose we have:
7927 template <class T, class U> struct S {};
7928 template <class T> struct S<T*, int> {};
7930 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
7931 {T}, the PARMS will be {T*, int} and the ARGS will be {double*,
7932 int}. The resulting vector will be {double}, indicating that `T'
7933 is bound to `double'. */
7936 get_class_bindings (tparms
, parms
, args
)
7937 tree tparms
, parms
, args
;
7939 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
7940 tree vec
= make_temp_vec (ntparms
);
7942 args
= innermost_args (args
);
7944 for (i
= 0; i
< TREE_VEC_LENGTH (parms
); ++i
)
7946 switch (unify (tparms
, vec
,
7947 TREE_VEC_ELT (parms
, i
), TREE_VEC_ELT (args
, i
),
7948 UNIFY_ALLOW_NONE
, 0))
7957 for (i
= 0; i
< ntparms
; ++i
)
7958 if (! TREE_VEC_ELT (vec
, i
))
7964 /* Return the most specialized of the list of templates in FNS that can
7965 produce an instantiation matching DECL, given the explicit template
7966 arguments EXPLICIT_ARGS. */
7969 most_specialized (fns
, decl
, explicit_args
)
7970 tree fns
, decl
, explicit_args
;
7972 tree candidates
= NULL_TREE
;
7973 tree fn
, champ
, args
;
7976 for (fn
= fns
; fn
; fn
= TREE_CHAIN (fn
))
7978 tree candidate
= TREE_VALUE (fn
);
7980 args
= get_bindings (candidate
, decl
, explicit_args
);
7982 candidates
= scratch_tree_cons (NULL_TREE
, candidate
,
7989 champ
= TREE_VALUE (candidates
);
7990 for (fn
= TREE_CHAIN (candidates
); fn
; fn
= TREE_CHAIN (fn
))
7992 fate
= more_specialized (champ
, TREE_VALUE (fn
), explicit_args
);
7999 fn
= TREE_CHAIN (fn
);
8001 return error_mark_node
;
8003 champ
= TREE_VALUE (fn
);
8007 for (fn
= candidates
; fn
&& TREE_VALUE (fn
) != champ
; fn
= TREE_CHAIN (fn
))
8009 fate
= more_specialized (champ
, TREE_VALUE (fn
), explicit_args
);
8011 return error_mark_node
;
8017 /* If DECL is a specialization of some template, return the most
8018 general such template. For example, given:
8020 template <class T> struct S { template <class U> void f(U); };
8022 if TMPL is `template <class U> void S<int>::f(U)' this will return
8023 the full template. This function will not trace past partial
8024 specializations, however. For example, given in addition:
8026 template <class T> struct S<T*> { template <class U> void f(U); };
8028 if TMPL is `template <class U> void S<int*>::f(U)' this will return
8029 `template <class T> template <class U> S<T*>::f(U)'. */
8032 most_general_template (decl
)
8035 while (DECL_TEMPLATE_INFO (decl
))
8036 decl
= DECL_TI_TEMPLATE (decl
);
8041 /* Return the most specialized of the class template specializations
8042 of TMPL which can produce an instantiation matching ARGS, or
8043 error_mark_node if the choice is ambiguous. */
8046 most_specialized_class (tmpl
, args
)
8050 tree list
= NULL_TREE
;
8055 tmpl
= most_general_template (tmpl
);
8056 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
); t
; t
= TREE_CHAIN (t
))
8059 = get_class_bindings (TREE_VALUE (t
), TREE_PURPOSE (t
), args
);
8062 list
= decl_tree_cons (TREE_PURPOSE (t
), TREE_VALUE (t
), list
);
8063 TREE_TYPE (list
) = TREE_TYPE (t
);
8073 for (; t
; t
= TREE_CHAIN (t
))
8075 fate
= more_specialized_class (champ
, t
);
8084 return error_mark_node
;
8090 for (t
= list
; t
&& t
!= champ
; t
= TREE_CHAIN (t
))
8092 fate
= more_specialized_class (champ
, t
);
8094 return error_mark_node
;
8100 /* called from the parser. */
8103 do_decl_instantiation (declspecs
, declarator
, storage
)
8104 tree declspecs
, declarator
, storage
;
8106 tree decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, 0, NULL_TREE
);
8107 tree result
= NULL_TREE
;
8110 if (! DECL_LANG_SPECIFIC (decl
))
8112 cp_error ("explicit instantiation of non-template `%#D'", decl
);
8115 else if (TREE_CODE (decl
) == VAR_DECL
)
8117 /* There is an asymmetry here in the way VAR_DECLs and
8118 FUNCTION_DECLs are handled by grokdeclarator. In the case of
8119 the latter, the DECL we get back will be marked as a
8120 template instantiation, and the appropriate
8121 DECL_TEMPLATE_INFO will be set up. This does not happen for
8122 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
8123 should handle VAR_DECLs as it currently handles
8125 result
= lookup_field (DECL_CONTEXT (decl
), DECL_NAME (decl
), 0, 0);
8126 if (result
&& TREE_CODE (result
) != VAR_DECL
)
8128 cp_error ("no matching template for `%D' found", result
);
8132 else if (TREE_CODE (decl
) != FUNCTION_DECL
)
8134 cp_error ("explicit instantiation of `%#D'", decl
);
8140 /* Check for various error cases. Note that if the explicit
8141 instantiation is legal the RESULT will currently be marked as an
8142 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
8143 until we get here. */
8145 if (DECL_TEMPLATE_SPECIALIZATION (result
))
8149 No program shall both explicitly instantiate and explicitly
8150 specialize a template. */
8151 cp_error ("explicit instantiation of `%#D' after", result
);
8152 cp_error_at ("explicit specialization here", result
);
8155 else if (DECL_EXPLICIT_INSTANTIATION (result
))
8159 No program shall explicitly instantiate any template more
8162 We check DECL_INTERFACE_KNOWN so as not to complain when the
8163 first instantiation was `extern' and the second is not, and
8164 EXTERN_P for the opposite case. */
8165 if (DECL_INTERFACE_KNOWN (result
) && !extern_p
)
8166 cp_error ("duplicate explicit instantiation of `%#D'", result
);
8168 /* If we've already instantiated the template, just return now. */
8169 if (DECL_INTERFACE_KNOWN (result
))
8172 else if (!DECL_IMPLICIT_INSTANTIATION (result
))
8174 cp_error ("no matching template for `%D' found", result
);
8177 else if (!DECL_TEMPLATE_INFO (result
))
8179 cp_pedwarn ("explicit instantiation of non-template `%#D'", result
);
8183 if (flag_external_templates
)
8186 if (storage
== NULL_TREE
)
8188 else if (storage
== ridpointers
[(int) RID_EXTERN
])
8191 cp_pedwarn ("ANSI C++ forbids the use of `extern' on explicit instantiations");
8195 cp_error ("storage class `%D' applied to template instantiation",
8198 SET_DECL_EXPLICIT_INSTANTIATION (result
);
8199 mark_decl_instantiated (result
, extern_p
);
8200 repo_template_instantiated (result
, extern_p
);
8202 instantiate_decl (result
);
8206 mark_class_instantiated (t
, extern_p
)
8210 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t
);
8211 SET_CLASSTYPE_INTERFACE_KNOWN (t
);
8212 CLASSTYPE_INTERFACE_ONLY (t
) = extern_p
;
8213 CLASSTYPE_VTABLE_NEEDS_WRITING (t
) = ! extern_p
;
8214 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t
)) = extern_p
;
8217 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
8218 rest_of_type_compilation (t
, 1);
8223 do_type_instantiation (t
, storage
)
8230 if (TREE_CODE (t
) == TYPE_DECL
)
8233 if (! CLASS_TYPE_P (t
) || ! CLASSTYPE_TEMPLATE_INFO (t
))
8235 cp_error ("explicit instantiation of non-template type `%T'", t
);
8241 /* With -fexternal-templates, explicit instantiations are treated the same
8242 as implicit ones. */
8243 if (flag_external_templates
)
8246 if (TYPE_SIZE (t
) == NULL_TREE
)
8248 cp_error ("explicit instantiation of `%#T' before definition of template",
8253 if (storage
!= NULL_TREE
)
8256 cp_pedwarn("ANSI C++ forbids the use of `%s' on explicit instantiations",
8257 IDENTIFIER_POINTER (storage
));
8259 if (storage
== ridpointers
[(int) RID_INLINE
])
8261 else if (storage
== ridpointers
[(int) RID_EXTERN
])
8263 else if (storage
== ridpointers
[(int) RID_STATIC
])
8267 cp_error ("storage class `%D' applied to template instantiation",
8273 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
8277 No program shall both explicitly instantiate and explicitly
8278 specialize a template. */
8279 cp_error ("explicit instantiation of `%#T' after", t
);
8280 cp_error_at ("explicit specialization here", t
);
8283 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t
))
8287 No program shall explicitly instantiate any template more
8290 If CLASSTYPE_INTERFACE_ONLY, then the first explicit
8291 instantiation was `extern', and if EXTERN_P then the second
8292 is. Both cases are OK. */
8293 if (!CLASSTYPE_INTERFACE_ONLY (t
) && !extern_p
)
8294 cp_error ("duplicate explicit instantiation of `%#T'", t
);
8296 /* If we've already instantiated the template, just return now. */
8297 if (!CLASSTYPE_INTERFACE_ONLY (t
))
8301 mark_class_instantiated (t
, extern_p
);
8302 repo_template_instantiated (t
, extern_p
);
8310 /* In contrast to implicit instantiation, where only the
8311 declarations, and not the definitions, of members are
8312 instantiated, we have here:
8316 The explicit instantiation of a class template specialization
8317 implies the instantiation of all of its members not
8318 previously explicitly specialized in the translation unit
8319 containing the explicit instantiation.
8321 Of course, we can't instantiate member template classes, since
8322 we don't have any arguments for them. Note that the standard
8323 is unclear on whether the instatiation of the members are
8324 *explicit* instantiations or not. We choose to be generous,
8325 and not set DECL_EXPLICIT_INSTANTIATION. Therefore, we allow
8326 the explicit instantiation of a class where some of the members
8327 have no definition in the current translation unit. */
8330 for (tmp
= TYPE_METHODS (t
); tmp
; tmp
= TREE_CHAIN (tmp
))
8331 if (TREE_CODE (tmp
) == FUNCTION_DECL
8332 && DECL_TEMPLATE_INSTANTIATION (tmp
))
8334 mark_decl_instantiated (tmp
, extern_p
);
8335 repo_template_instantiated (tmp
, extern_p
);
8337 instantiate_decl (tmp
);
8340 for (tmp
= TYPE_FIELDS (t
); tmp
; tmp
= TREE_CHAIN (tmp
))
8341 if (TREE_CODE (tmp
) == VAR_DECL
&& DECL_TEMPLATE_INSTANTIATION (tmp
))
8343 mark_decl_instantiated (tmp
, extern_p
);
8344 repo_template_instantiated (tmp
, extern_p
);
8346 instantiate_decl (tmp
);
8349 for (tmp
= CLASSTYPE_TAGS (t
); tmp
; tmp
= TREE_CHAIN (tmp
))
8350 if (IS_AGGR_TYPE (TREE_VALUE (tmp
))
8351 && !uses_template_parms (CLASSTYPE_TI_ARGS (TREE_VALUE (tmp
))))
8352 do_type_instantiation (TYPE_MAIN_DECL (TREE_VALUE (tmp
)), storage
);
8356 /* Given a function DECL, which is a specialization of TMPL, modify
8357 DECL to be a re-instantiation of TMPL with the same template
8358 arguments. TMPL should be the template into which tsubst'ing
8359 should occur for DECL, not the most general template.
8361 One reason for doing this is a scenario like this:
8364 void f(const T&, int i);
8366 void g() { f(3, 7); }
8369 void f(const T& t, const int i) { }
8371 Note that when the template is first instantiated, with
8372 instantiate_template, the resulting DECL will have no name for the
8373 first parameter, and the wrong type for the second. So, when we go
8374 to instantiate the DECL, we regenerate it. */
8377 regenerate_decl_from_template (decl
, tmpl
)
8387 args
= DECL_TI_ARGS (decl
);
8388 code_pattern
= DECL_TEMPLATE_RESULT (tmpl
);
8390 /* Unregister the specialization so that when we tsubst we will not
8391 just return DECL. We don't have to unregister DECL from TMPL
8392 because if would only be registered there if it were a partial
8393 instantiation of a specialization, which it isn't: it's a full
8395 gen_tmpl
= most_general_template (tmpl
);
8396 unregistered
= unregister_specialization (decl
, gen_tmpl
);
8398 /* If the DECL was not unregistered then something peculiar is
8399 happening: we created a specialization but did not call
8400 register_specialization for it. */
8401 my_friendly_assert (unregistered
, 0);
8403 if (TREE_CODE (decl
) == VAR_DECL
)
8404 /* Make sure that we can see identifiers, and compute access
8405 correctly, for the class members used in the declaration of
8406 this static variable. */
8407 pushclass (DECL_CONTEXT (decl
), 2);
8409 /* Do the substitution to get the new declaration. */
8410 new_decl
= tsubst (code_pattern
, args
, NULL_TREE
);
8412 if (TREE_CODE (decl
) == VAR_DECL
)
8414 /* Set up DECL_INITIAL, since tsubst doesn't. */
8415 DECL_INITIAL (new_decl
) =
8416 tsubst_expr (DECL_INITIAL (code_pattern
), args
,
8417 DECL_TI_TEMPLATE (decl
));
8418 /* Pop the class context we pushed above. */
8422 if (TREE_CODE (decl
) == FUNCTION_DECL
)
8424 /* Convince duplicate_decls to use the DECL_ARGUMENTS from the
8426 DECL_INITIAL (new_decl
) = error_mark_node
;
8427 /* And don't complain about a duplicate definition. */
8428 DECL_INITIAL (decl
) = NULL_TREE
;
8431 /* The immediate parent of the new template is still whatever it was
8432 before, even though tsubst sets DECL_TI_TEMPLATE up as the most
8433 general template. We also reset the DECL_ASSEMBLER_NAME since
8434 tsubst always calculates the name as if the function in question
8435 were really a template instance, and sometimes, with friend
8436 functions, this is not so. See tsubst_friend_function for
8438 DECL_TI_TEMPLATE (new_decl
) = DECL_TI_TEMPLATE (decl
);
8439 DECL_ASSEMBLER_NAME (new_decl
) = DECL_ASSEMBLER_NAME (decl
);
8440 DECL_RTL (new_decl
) = DECL_RTL (decl
);
8442 /* Call duplicate decls to merge the old and new declarations. */
8443 duplicate_decls (new_decl
, decl
);
8445 /* Now, re-register the specialization. */
8446 register_specialization (decl
, gen_tmpl
, args
);
8449 /* Produce the definition of D, a _DECL generated from a template. */
8452 instantiate_decl (d
)
8455 tree tmpl
= DECL_TI_TEMPLATE (d
);
8456 tree args
= DECL_TI_ARGS (d
);
8461 int nested
= in_function_p ();
8462 int pattern_defined
;
8464 char *file
= input_filename
;
8466 /* This function should only be used to instantiate templates for
8467 functions and static member variables. */
8468 my_friendly_assert (TREE_CODE (d
) == FUNCTION_DECL
8469 || TREE_CODE (d
) == VAR_DECL
, 0);
8471 if (DECL_TEMPLATE_INSTANTIATED (d
))
8472 /* D has already been instantiated. It might seem reasonable to
8473 check whether or not D is an explict instantiation, and, if so,
8474 stop here. But when an explicit instantiation is deferred
8475 until the end of the compilation, DECL_EXPLICIT_INSTANTIATION
8476 is set, even though we still need to do the instantiation. */
8479 /* If we already have a specialization of this declaration, then
8480 there's no reason to instantiate it. Note that
8481 retrieve_specialization gives us both instantiations and
8482 specializations, so we must explicitly check
8483 DECL_TEMPLATE_SPECIALIZATION. */
8484 gen_tmpl
= most_general_template (tmpl
);
8485 spec
= retrieve_specialization (gen_tmpl
, args
);
8486 if (spec
!= NULL_TREE
&& DECL_TEMPLATE_SPECIALIZATION (spec
))
8489 /* This needs to happen before any tsubsting. */
8490 if (! push_tinst_level (d
))
8493 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
8494 for the instantiation. This is not always the most general
8495 template. Consider, for example:
8498 struct S { template <class U> void f();
8499 template <> void f<int>(); };
8501 and an instantiation of S<double>::f<int>. We want TD to be the
8502 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
8505 /* An instantiation cannot have a definition, so we need a
8506 more general template. */
8507 DECL_TEMPLATE_INSTANTIATION (td
)
8508 /* We must also deal with friend templates. Given:
8510 template <class T> struct S {
8511 template <class U> friend void f() {};
8514 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
8515 so far as the language is concerned, but that's still
8516 where we get the pattern for the instantiation from. On
8517 ther hand, if the definition comes outside the class, say:
8519 template <class T> struct S {
8520 template <class U> friend void f();
8522 template <class U> friend void f() {}
8524 we don't need to look any further. That's what the check for
8525 DECL_INITIAL is for. */
8526 || (TREE_CODE (d
) == FUNCTION_DECL
8527 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (td
)
8528 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (td
)));
8531 /* The present template, TD, should not be a definition. If it
8532 were a definition, we should be using it! Note that we
8533 cannot restructure the loop to just keep going until we find
8534 a template with a definition, since that might go too far if
8535 a specialization was declared, but not defined. */
8536 my_friendly_assert (!(TREE_CODE (d
) == VAR_DECL
8537 && !DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (td
))),
8540 /* Fetch the more general template. */
8541 td
= DECL_TI_TEMPLATE (td
);
8544 code_pattern
= DECL_TEMPLATE_RESULT (td
);
8546 if (TREE_CODE (d
) == FUNCTION_DECL
)
8547 pattern_defined
= (DECL_INITIAL (code_pattern
) != NULL_TREE
);
8549 pattern_defined
= ! DECL_IN_AGGR_P (code_pattern
);
8551 push_to_top_level ();
8552 lineno
= DECL_SOURCE_LINE (d
);
8553 input_filename
= DECL_SOURCE_FILE (d
);
8555 if (pattern_defined
)
8557 repo_template_used (d
);
8559 if (flag_external_templates
&& ! DECL_INTERFACE_KNOWN (d
))
8561 if (flag_alt_external_templates
)
8563 if (interface_unknown
)
8564 warn_if_unknown_interface (d
);
8566 else if (DECL_INTERFACE_KNOWN (code_pattern
))
8568 DECL_INTERFACE_KNOWN (d
) = 1;
8569 DECL_NOT_REALLY_EXTERN (d
) = ! DECL_EXTERNAL (code_pattern
);
8572 warn_if_unknown_interface (code_pattern
);
8576 import_export_decl (d
);
8579 /* Reject all external templates except inline functions. */
8580 if (DECL_INTERFACE_KNOWN (d
)
8581 && ! DECL_NOT_REALLY_EXTERN (d
)
8582 && ! (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_INLINE (d
)))
8585 if (TREE_CODE (d
) == VAR_DECL
8586 && TREE_READONLY (d
)
8587 && DECL_INITIAL (d
) == NULL_TREE
8588 && DECL_INITIAL (code_pattern
) != NULL_TREE
)
8589 /* We need to set up DECL_INITIAL regardless of pattern_defined if
8590 the variable is a static const initialized in the class body. */;
8591 else if (! pattern_defined
8592 || (! (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_INLINE (d
) && nested
)
8595 /* Defer all templates except inline functions used in another
8596 function. We restore the source position here because it's used
8597 by add_pending_template. */
8599 input_filename
= file
;
8601 if (at_eof
&& !pattern_defined
8602 && DECL_EXPLICIT_INSTANTIATION (d
))
8605 The definition of a non-exported function template, a
8606 non-exported member function template, or a non-exported
8607 member function or static data member of a class template
8608 shall be present in every translation unit in which it is
8609 explicitly instantiated. */
8610 cp_error ("explicit instantiation of `%D' but no definition available",
8613 add_pending_template (d
);
8617 regenerate_decl_from_template (d
, td
);
8618 DECL_TEMPLATE_INSTANTIATED (d
) = 1;
8620 /* We already set the file and line above. Reset them now in case
8621 they changed as a result of calling regenerate_decl_from_template. */
8622 lineno
= DECL_SOURCE_LINE (d
);
8623 input_filename
= DECL_SOURCE_FILE (d
);
8625 if (TREE_CODE (d
) == VAR_DECL
)
8627 DECL_IN_AGGR_P (d
) = 0;
8628 if (DECL_INTERFACE_KNOWN (d
))
8629 DECL_EXTERNAL (d
) = ! DECL_NOT_REALLY_EXTERN (d
);
8632 DECL_EXTERNAL (d
) = 1;
8633 DECL_NOT_REALLY_EXTERN (d
) = 1;
8635 cp_finish_decl (d
, DECL_INITIAL (d
), NULL_TREE
, 0, 0);
8637 else if (TREE_CODE (d
) == FUNCTION_DECL
)
8639 tree t
= DECL_SAVED_TREE (code_pattern
);
8641 start_function (NULL_TREE
, d
, NULL_TREE
, 1);
8642 store_parm_decls ();
8644 if (t
&& TREE_CODE (t
) == RETURN_INIT
)
8647 (TREE_OPERAND (t
, 0),
8648 tsubst_expr (TREE_OPERAND (t
, 1), args
, tmpl
));
8652 if (t
&& TREE_CODE (t
) == CTOR_INITIALIZER
)
8654 current_member_init_list
8655 = tsubst_expr_values (TREE_OPERAND (t
, 0), args
);
8656 current_base_init_list
8657 = tsubst_expr_values (TREE_OPERAND (t
, 1), args
);
8662 /* Always keep the BLOCK node associated with the outermost
8663 pair of curly braces of a function. These are needed
8664 for correct operation of dwarfout.c. */
8667 my_friendly_assert (TREE_CODE (t
) == COMPOUND_STMT
, 42);
8668 tsubst_expr (t
, args
, tmpl
);
8670 finish_function (lineno
, 0, nested
);
8675 input_filename
= file
;
8677 pop_from_top_level ();
8684 tsubst_expr_values (t
, argvec
)
8687 tree first
= NULL_TREE
;
8690 for (; t
; t
= TREE_CHAIN (t
))
8692 tree pur
= tsubst_copy (TREE_PURPOSE (t
), argvec
, NULL_TREE
);
8693 tree val
= tsubst_expr (TREE_VALUE (t
), argvec
, NULL_TREE
);
8694 *p
= build_tree_list (pur
, val
);
8695 p
= &TREE_CHAIN (*p
);
8706 last_tree
= TREE_CHAIN (last_tree
) = t
;
8713 saved_trees
= tree_cons (NULL_TREE
, last_tree
, saved_trees
);
8714 last_tree
= NULL_TREE
;
8721 my_friendly_assert (saved_trees
!= NULL_TREE
, 0);
8723 last_tree
= TREE_VALUE (saved_trees
);
8724 saved_trees
= TREE_CHAIN (saved_trees
);
8727 /* D is an undefined function declaration in the presence of templates with
8728 the same name, listed in FNS. If one of them can produce D as an
8729 instantiation, remember this so we can instantiate it at EOF if D has
8730 not been defined by that time. */
8733 add_maybe_template (d
, fns
)
8738 if (DECL_MAYBE_TEMPLATE (d
))
8741 t
= most_specialized (fns
, d
, NULL_TREE
);
8744 if (t
== error_mark_node
)
8746 cp_error ("ambiguous template instantiation for `%D'", d
);
8750 *maybe_template_tail
= perm_tree_cons (t
, d
, NULL_TREE
);
8751 maybe_template_tail
= &TREE_CHAIN (*maybe_template_tail
);
8752 DECL_MAYBE_TEMPLATE (d
) = 1;
8755 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
8758 set_current_access_from_decl (decl
)
8761 if (TREE_PRIVATE (decl
))
8762 current_access_specifier
= access_private_node
;
8763 else if (TREE_PROTECTED (decl
))
8764 current_access_specifier
= access_protected_node
;
8766 current_access_specifier
= access_public_node
;
8769 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
8770 is the instantiation (which should have been created with
8771 start_enum) and ARGS are the template arguments to use. */
8774 tsubst_enum (tag
, newtag
, args
)
8781 for (e
= TYPE_VALUES (tag
); e
; e
= TREE_CHAIN (e
))
8786 /* Note that in a template enum, the TREE_VALUE is the
8787 CONST_DECL, not the corresponding INTEGER_CST. */
8788 value
= tsubst_expr (DECL_INITIAL (TREE_VALUE (e
)),
8792 /* Give this enumeration constant the correct access. */
8793 set_current_access_from_decl (TREE_VALUE (e
));
8795 /* Actually build the enumerator itself. */
8796 elt
= build_enumerator (TREE_PURPOSE (e
), value
, newtag
);
8798 /* We save the enumerators we have built so far in the
8799 TYPE_VALUES so that if the enumeration constants for
8800 subsequent enumerators involve those for previous ones,
8801 tsubst_copy will be able to find them. */
8802 TREE_CHAIN (elt
) = TYPE_VALUES (newtag
);
8803 TYPE_VALUES (newtag
) = elt
;
8806 finish_enum (newtag
);
8809 /* Set the DECL_ASSEMBLER_NAME for DECL, which is a FUNCTION_DECL that
8810 is either an instantiation or specialization of a template
8814 set_mangled_name_for_template_decl (decl
)
8817 tree saved_namespace
;
8818 tree context
= NULL_TREE
;
8827 my_friendly_assert (TREE_CODE (decl
) == FUNCTION_DECL
, 0);
8828 my_friendly_assert (DECL_TEMPLATE_INFO (decl
) != NULL_TREE
, 0);
8830 /* The names of template functions must be mangled so as to indicate
8831 what template is being specialized with what template arguments.
8832 For example, each of the following three functions must get
8833 different mangled names:
8836 template <> void f<7>(int);
8837 template <> void f<8>(int); */
8839 targs
= DECL_TI_ARGS (decl
);
8840 if (uses_template_parms (targs
))
8841 /* This DECL is for a partial instantiation. There's no need to
8842 mangle the name of such an entity. */
8845 tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
8846 tparms
= DECL_TEMPLATE_PARMS (tmpl
);
8847 parm_depth
= TMPL_PARMS_DEPTH (tparms
);
8849 /* There should be as many levels of arguments as there are levels
8851 my_friendly_assert (parm_depth
== TMPL_ARGS_DEPTH (targs
), 0);
8853 /* We now compute the PARMS and RET_TYPE to give to
8854 build_decl_overload_real. The PARMS and RET_TYPE are the
8855 parameter and return types of the template, after all but the
8856 innermost template arguments have been substituted, not the
8857 parameter and return types of the function DECL. For example,
8860 template <class T> T f(T);
8862 both PARMS and RET_TYPE should be `T' even if DECL is `int f(int)'.
8863 A more subtle example is:
8865 template <class T> struct S { template <class U> void f(T, U); }
8867 Here, if DECL is `void S<int>::f(int, double)', PARMS should be
8868 {int, U}. Thus, the args that we want to subsitute into the
8869 return and parameter type for the function are those in TARGS,
8870 with the innermost level omitted. */
8871 fn_type
= TREE_TYPE (tmpl
);
8872 if (DECL_STATIC_FUNCTION_P (decl
))
8873 context
= DECL_CLASS_CONTEXT (decl
);
8875 if (parm_depth
== 1)
8876 /* No substitution is necessary. */
8883 /* Replace the innermost level of the TARGS with NULL_TREEs to
8884 let tsubst know not to subsitute for those parameters. */
8885 partial_args
= make_temp_vec (TREE_VEC_LENGTH (targs
));
8886 for (i
= 1; i
< TMPL_ARGS_DEPTH (targs
); ++i
)
8887 SET_TMPL_ARGS_LEVEL (partial_args
, i
,
8888 TMPL_ARGS_LEVEL (targs
, i
));
8889 SET_TMPL_ARGS_LEVEL (partial_args
,
8890 TMPL_ARGS_DEPTH (targs
),
8891 make_temp_vec (DECL_NTPARMS (tmpl
)));
8893 /* Now, do the (partial) substitution to figure out the
8894 appropriate function type. */
8895 fn_type
= tsubst (fn_type
, partial_args
, NULL_TREE
);
8896 if (DECL_STATIC_FUNCTION_P (decl
))
8897 context
= tsubst (context
, partial_args
, NULL_TREE
);
8899 /* Substitute into the template parameters to obtain the real
8900 innermost set of parameters. This step is important if the
8901 innermost set of template parameters contains value
8902 parameters whose types depend on outer template parameters. */
8903 TREE_VEC_LENGTH (partial_args
)--;
8904 tparms
= tsubst_template_parms (tparms
, partial_args
);
8907 /* Now, get the innermost parameters and arguments, and figure out
8908 the parameter and return types. */
8909 tparms
= INNERMOST_TEMPLATE_PARMS (tparms
);
8910 targs
= innermost_args (targs
);
8911 ret_type
= TREE_TYPE (fn_type
);
8912 parm_types
= TYPE_ARG_TYPES (fn_type
);
8914 /* For a static member function, we generate a fake `this' pointer,
8915 for the purposes of mangling. This indicates of which class the
8916 function is a member. Because of:
8920 There shall not be a static and a nonstatic member function
8921 with the same name and the same parameter types
8923 we don't have to worry that this will result in a clash with a
8924 non-static member function. */
8925 if (DECL_STATIC_FUNCTION_P (decl
))
8926 parm_types
= hash_tree_chain (build_pointer_type (context
), parm_types
);
8928 /* There should be the same number of template parameters as
8929 template arguments. */
8930 my_friendly_assert (TREE_VEC_LENGTH (tparms
) == TREE_VEC_LENGTH (targs
),
8933 /* If the template is in a namespace, we need to put that into the
8934 mangled name. Unfortunately, build_decl_overload_real does not
8935 get the decl to mangle, so it relies on the current
8936 namespace. Therefore, we set that here temporarily. */
8937 my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (decl
)) == 'd', 980702);
8938 saved_namespace
= current_namespace
;
8939 current_namespace
= CP_DECL_CONTEXT (decl
);
8941 /* Actually set the DCL_ASSEMBLER_NAME. */
8942 DECL_ASSEMBLER_NAME (decl
)
8943 = build_decl_overload_real (DECL_NAME (decl
), parm_types
, ret_type
,
8945 DECL_FUNCTION_MEMBER_P (decl
)
8946 + DECL_CONSTRUCTOR_P (decl
));
8948 /* Restore the previously active namespace. */
8949 current_namespace
= saved_namespace
;