diff options
Diffstat (limited to 'gcc-4.2.1-5666.3/gcc/cp/pt.c')
| -rw-r--r-- | gcc-4.2.1-5666.3/gcc/cp/pt.c | 13459 |
1 files changed, 0 insertions, 13459 deletions
diff --git a/gcc-4.2.1-5666.3/gcc/cp/pt.c b/gcc-4.2.1-5666.3/gcc/cp/pt.c deleted file mode 100644 index 5b041a851..000000000 --- a/gcc-4.2.1-5666.3/gcc/cp/pt.c +++ /dev/null @@ -1,13459 +0,0 @@ -/* Handle parameterized types (templates) for GNU C++. - Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, - 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. - Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing. - Rewritten by Jason Merrill (jason@cygnus.com). - -This file is part of GCC. - -GCC is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2, or (at your option) -any later version. - -GCC is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with GCC; see the file COPYING. If not, write to -the Free Software Foundation, 51 Franklin Street, Fifth Floor, -Boston, MA 02110-1301, USA. */ - -/* Known bugs or deficiencies include: - - all methods must be provided in header files; can't use a source - file that contains only the method templates and "just win". */ - -#include "config.h" -#include "system.h" -#include "coretypes.h" -#include "tm.h" -#include "obstack.h" -#include "tree.h" -#include "pointer-set.h" -#include "flags.h" -#include "c-common.h" -#include "cp-tree.h" -#include "cp-objcp-common.h" -#include "tree-inline.h" -#include "decl.h" -#include "output.h" -#include "except.h" -#include "toplev.h" -#include "rtl.h" -#include "timevar.h" -#include "tree-iterator.h" -#include "vecprim.h" - -/* The type of functions taking a tree, and some additional data, and - returning an int. */ -typedef int (*tree_fn_t) (tree, void*); - -/* The PENDING_TEMPLATES is a TREE_LIST of templates whose - instantiations have been deferred, either because their definitions - were not yet available, or because we were putting off doing the work. - The TREE_PURPOSE of each entry is either a DECL (for a function or - static data member), or a TYPE (for a class) indicating what we are - hoping to instantiate. The TREE_VALUE is not used. */ -static GTY(()) tree pending_templates; -static GTY(()) tree last_pending_template; - -int processing_template_parmlist; -static int template_header_count; - -static GTY(()) tree saved_trees; -static VEC(int,heap) *inline_parm_levels; - -static GTY(()) tree current_tinst_level; - -static GTY(()) tree saved_access_scope; - -/* Live only within one (recursive) call to tsubst_expr. We use - this to pass the statement expression node from the STMT_EXPR - to the EXPR_STMT that is its result. */ -static tree cur_stmt_expr; - -/* A map from local variable declarations in the body of the template - presently being instantiated to the corresponding instantiated - local variables. */ -static htab_t local_specializations; - -#define UNIFY_ALLOW_NONE 0 -#define UNIFY_ALLOW_MORE_CV_QUAL 1 -#define UNIFY_ALLOW_LESS_CV_QUAL 2 -#define UNIFY_ALLOW_DERIVED 4 -#define UNIFY_ALLOW_INTEGER 8 -#define UNIFY_ALLOW_OUTER_LEVEL 16 -#define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32 -#define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64 - -static void push_access_scope (tree); -static void pop_access_scope (tree); -static bool resolve_overloaded_unification (tree, tree, tree, tree, - unification_kind_t, int); -static int try_one_overload (tree, tree, tree, tree, tree, - unification_kind_t, int, bool); -static int unify (tree, tree, tree, tree, int); -static void add_pending_template (tree); -static int push_tinst_level (tree); -static void pop_tinst_level (void); -static void reopen_tinst_level (tree); -static tree classtype_mangled_name (tree); -static char* mangle_class_name_for_template (const char *, tree, tree); -static tree tsubst_initializer_list (tree, tree); -static tree get_class_bindings (tree, tree, tree); -static tree coerce_template_parms (tree, tree, tree, tsubst_flags_t, - bool, bool); -static void tsubst_enum (tree, tree, tree); -static tree add_to_template_args (tree, tree); -static tree add_outermost_template_args (tree, tree); -static bool check_instantiated_args (tree, tree, tsubst_flags_t); -static int maybe_adjust_types_for_deduction (unification_kind_t, tree*, tree*); -static int type_unification_real (tree, tree, tree, tree, - int, unification_kind_t, int); -static void note_template_header (int); -static tree convert_nontype_argument_function (tree, tree); -static tree convert_nontype_argument (tree, tree); -static tree convert_template_argument (tree, tree, tree, - tsubst_flags_t, int, tree); -static int for_each_template_parm (tree, tree_fn_t, void*, - struct pointer_set_t*); -static tree build_template_parm_index (int, int, int, tree, tree); -static int inline_needs_template_parms (tree); -static void push_inline_template_parms_recursive (tree, int); -static tree retrieve_local_specialization (tree); -static void register_local_specialization (tree, tree); -static tree reduce_template_parm_level (tree, tree, int); -static int mark_template_parm (tree, void *); -static int template_parm_this_level_p (tree, void *); -static tree tsubst_friend_function (tree, tree); -static tree tsubst_friend_class (tree, tree); -static int can_complete_type_without_circularity (tree); -static tree get_bindings (tree, tree, tree, bool); -static int template_decl_level (tree); -static int check_cv_quals_for_unify (int, tree, tree); -static tree tsubst_template_arg (tree, tree, tsubst_flags_t, tree); -static tree tsubst_template_args (tree, tree, tsubst_flags_t, tree); -static tree tsubst_template_parms (tree, tree, tsubst_flags_t); -static void regenerate_decl_from_template (tree, tree); -static tree most_specialized_class (tree, tree); -static tree tsubst_aggr_type (tree, tree, tsubst_flags_t, tree, int); -static tree tsubst_arg_types (tree, tree, tsubst_flags_t, tree); -static tree tsubst_function_type (tree, tree, tsubst_flags_t, tree); -static bool check_specialization_scope (void); -static tree process_partial_specialization (tree); -static void set_current_access_from_decl (tree); -static void check_default_tmpl_args (tree, tree, int, int); -static tree get_template_base (tree, tree, tree, tree); -static tree try_class_unification (tree, tree, tree, tree); -static int coerce_template_template_parms (tree, tree, tsubst_flags_t, - tree, tree); -static int template_args_equal (tree, tree); -static void tsubst_default_arguments (tree); -static tree for_each_template_parm_r (tree *, int *, void *); -static tree copy_default_args_to_explicit_spec_1 (tree, tree); -static void copy_default_args_to_explicit_spec (tree); -static int invalid_nontype_parm_type_p (tree, tsubst_flags_t); -static int eq_local_specializations (const void *, const void *); -static bool dependent_type_p_r (tree); -static tree tsubst (tree, tree, tsubst_flags_t, tree); -static tree tsubst_expr (tree, tree, tsubst_flags_t, tree, bool); -static tree tsubst_copy (tree, tree, tsubst_flags_t, tree); - -/* Make the current scope suitable for access checking when we are - processing T. T can be FUNCTION_DECL for instantiated function - template, or VAR_DECL for static member variable (need by - instantiate_decl). */ - -static void -push_access_scope (tree t) -{ - gcc_assert (TREE_CODE (t) == FUNCTION_DECL - || TREE_CODE (t) == VAR_DECL); - - if (DECL_FRIEND_CONTEXT (t)) - push_nested_class (DECL_FRIEND_CONTEXT (t)); - else if (DECL_CLASS_SCOPE_P (t)) - push_nested_class (DECL_CONTEXT (t)); - else - push_to_top_level (); - - if (TREE_CODE (t) == FUNCTION_DECL) - { - saved_access_scope = tree_cons - (NULL_TREE, current_function_decl, saved_access_scope); - current_function_decl = t; - } -} - -/* Restore the scope set up by push_access_scope. T is the node we - are processing. */ - -static void -pop_access_scope (tree t) -{ - if (TREE_CODE (t) == FUNCTION_DECL) - { - current_function_decl = TREE_VALUE (saved_access_scope); - saved_access_scope = TREE_CHAIN (saved_access_scope); - } - - if (DECL_FRIEND_CONTEXT (t) || DECL_CLASS_SCOPE_P (t)) - pop_nested_class (); - else - pop_from_top_level (); -} - -/* Do any processing required when DECL (a member template - declaration) is finished. Returns the TEMPLATE_DECL corresponding - to DECL, unless it is a specialization, in which case the DECL - itself is returned. */ - -tree -finish_member_template_decl (tree decl) -{ - if (decl == error_mark_node) - return error_mark_node; - - gcc_assert (DECL_P (decl)); - - if (TREE_CODE (decl) == TYPE_DECL) - { - tree type; - - type = TREE_TYPE (decl); - if (IS_AGGR_TYPE (type) - && CLASSTYPE_TEMPLATE_INFO (type) - && !CLASSTYPE_TEMPLATE_SPECIALIZATION (type)) - { - tree tmpl = CLASSTYPE_TI_TEMPLATE (type); - check_member_template (tmpl); - return tmpl; - } - return NULL_TREE; - } - else if (TREE_CODE (decl) == FIELD_DECL) - error ("data member %qD cannot be a member template", decl); - else if (DECL_TEMPLATE_INFO (decl)) - { - if (!DECL_TEMPLATE_SPECIALIZATION (decl)) - { - check_member_template (DECL_TI_TEMPLATE (decl)); - return DECL_TI_TEMPLATE (decl); - } - else - return decl; - } - else - error ("invalid member template declaration %qD", decl); - - return error_mark_node; -} - -/* Returns the template nesting level of the indicated class TYPE. - - For example, in: - template <class T> - struct A - { - template <class U> - struct B {}; - }; - - A<T>::B<U> has depth two, while A<T> has depth one. - Both A<T>::B<int> and A<int>::B<U> have depth one, if - they are instantiations, not specializations. - - This function is guaranteed to return 0 if passed NULL_TREE so - that, for example, `template_class_depth (current_class_type)' is - always safe. */ - -int -template_class_depth (tree type) -{ - int depth; - - for (depth = 0; - type && TREE_CODE (type) != NAMESPACE_DECL; - type = (TREE_CODE (type) == FUNCTION_DECL) - ? CP_DECL_CONTEXT (type) : TYPE_CONTEXT (type)) - { - if (TREE_CODE (type) != FUNCTION_DECL) - { - if (CLASSTYPE_TEMPLATE_INFO (type) - && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)) - && uses_template_parms (CLASSTYPE_TI_ARGS (type))) - ++depth; - } - else - { - if (DECL_TEMPLATE_INFO (type) - && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (type)) - && uses_template_parms (DECL_TI_ARGS (type))) - ++depth; - } - } - - return depth; -} - -/* Returns 1 if processing DECL as part of do_pending_inlines - needs us to push template parms. */ - -static int -inline_needs_template_parms (tree decl) -{ - if (! DECL_TEMPLATE_INFO (decl)) - return 0; - - return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl))) - > (processing_template_decl + DECL_TEMPLATE_SPECIALIZATION (decl))); -} - -/* Subroutine of maybe_begin_member_template_processing. - Push the template parms in PARMS, starting from LEVELS steps into the - chain, and ending at the beginning, since template parms are listed - innermost first. */ - -static void -push_inline_template_parms_recursive (tree parmlist, int levels) -{ - tree parms = TREE_VALUE (parmlist); - int i; - - if (levels > 1) - push_inline_template_parms_recursive (TREE_CHAIN (parmlist), levels - 1); - - ++processing_template_decl; - current_template_parms - = tree_cons (size_int (processing_template_decl), - parms, current_template_parms); - TEMPLATE_PARMS_FOR_INLINE (current_template_parms) = 1; - - begin_scope (TREE_VEC_LENGTH (parms) ? sk_template_parms : sk_template_spec, - NULL); - for (i = 0; i < TREE_VEC_LENGTH (parms); ++i) - { - tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i)); - - if (parm == error_mark_node) - continue; - - gcc_assert (DECL_P (parm)); - - switch (TREE_CODE (parm)) - { - case TYPE_DECL: - case TEMPLATE_DECL: - pushdecl (parm); - break; - - case PARM_DECL: - { - /* Make a CONST_DECL as is done in process_template_parm. - It is ugly that we recreate this here; the original - version built in process_template_parm is no longer - available. */ - tree decl = build_decl (CONST_DECL, DECL_NAME (parm), - TREE_TYPE (parm)); - DECL_ARTIFICIAL (decl) = 1; - TREE_CONSTANT (decl) = 1; - TREE_INVARIANT (decl) = 1; - TREE_READONLY (decl) = 1; - DECL_INITIAL (decl) = DECL_INITIAL (parm); - SET_DECL_TEMPLATE_PARM_P (decl); - pushdecl (decl); - } - break; - - default: - gcc_unreachable (); - } - } -} - -/* Restore the template parameter context for a member template or - a friend template defined in a class definition. */ - -void -maybe_begin_member_template_processing (tree decl) -{ - tree parms; - int levels = 0; - - if (inline_needs_template_parms (decl)) - { - parms = DECL_TEMPLATE_PARMS (most_general_template (decl)); - levels = TMPL_PARMS_DEPTH (parms) - processing_template_decl; - - if (DECL_TEMPLATE_SPECIALIZATION (decl)) - { - --levels; - parms = TREE_CHAIN (parms); - } - - push_inline_template_parms_recursive (parms, levels); - } - - /* Remember how many levels of template parameters we pushed so that - we can pop them later. */ - VEC_safe_push (int, heap, inline_parm_levels, levels); -} - -/* Undo the effects of maybe_begin_member_template_processing. */ - -void -maybe_end_member_template_processing (void) -{ - int i; - int last; - - if (VEC_length (int, inline_parm_levels) == 0) - return; - - last = VEC_pop (int, inline_parm_levels); - for (i = 0; i < last; ++i) - { - --processing_template_decl; - current_template_parms = TREE_CHAIN (current_template_parms); - poplevel (0, 0, 0); - } -} - -/* Return a new template argument vector which contains all of ARGS, - but has as its innermost set of arguments the EXTRA_ARGS. */ - -static tree -add_to_template_args (tree args, tree extra_args) -{ - tree new_args; - int extra_depth; - int i; - int j; - - extra_depth = TMPL_ARGS_DEPTH (extra_args); - new_args = make_tree_vec (TMPL_ARGS_DEPTH (args) + extra_depth); - - for (i = 1; i <= TMPL_ARGS_DEPTH (args); ++i) - SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (args, i)); - - for (j = 1; j <= extra_depth; ++j, ++i) - SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (extra_args, j)); - - return new_args; -} - -/* Like add_to_template_args, but only the outermost ARGS are added to - the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH - (EXTRA_ARGS) levels are added. This function is used to combine - the template arguments from a partial instantiation with the - template arguments used to attain the full instantiation from the - partial instantiation. */ - -static tree -add_outermost_template_args (tree args, tree extra_args) -{ - tree new_args; - - /* If there are more levels of EXTRA_ARGS than there are ARGS, - something very fishy is going on. */ - gcc_assert (TMPL_ARGS_DEPTH (args) >= TMPL_ARGS_DEPTH (extra_args)); - - /* If *all* the new arguments will be the EXTRA_ARGS, just return - them. */ - if (TMPL_ARGS_DEPTH (args) == TMPL_ARGS_DEPTH (extra_args)) - return extra_args; - - /* For the moment, we make ARGS look like it contains fewer levels. */ - TREE_VEC_LENGTH (args) -= TMPL_ARGS_DEPTH (extra_args); - - new_args = add_to_template_args (args, extra_args); - - /* Now, we restore ARGS to its full dimensions. */ - TREE_VEC_LENGTH (args) += TMPL_ARGS_DEPTH (extra_args); - - return new_args; -} - -/* Return the N levels of innermost template arguments from the ARGS. */ - -tree -get_innermost_template_args (tree args, int n) -{ - tree new_args; - int extra_levels; - int i; - - gcc_assert (n >= 0); - - /* If N is 1, just return the innermost set of template arguments. */ - if (n == 1) - return TMPL_ARGS_LEVEL (args, TMPL_ARGS_DEPTH (args)); - - /* If we're not removing anything, just return the arguments we were - given. */ - extra_levels = TMPL_ARGS_DEPTH (args) - n; - gcc_assert (extra_levels >= 0); - if (extra_levels == 0) - return args; - - /* Make a new set of arguments, not containing the outer arguments. */ - new_args = make_tree_vec (n); - for (i = 1; i <= n; ++i) - SET_TMPL_ARGS_LEVEL (new_args, i, - TMPL_ARGS_LEVEL (args, i + extra_levels)); - - return new_args; -} - -/* We've got a template header coming up; push to a new level for storing - the parms. */ - -void -begin_template_parm_list (void) -{ - /* We use a non-tag-transparent scope here, which causes pushtag to - put tags in this scope, rather than in the enclosing class or - namespace scope. This is the right thing, since we want - TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a - global template class, push_template_decl handles putting the - TEMPLATE_DECL into top-level scope. For a nested template class, - e.g.: - - template <class T> struct S1 { - template <class T> struct S2 {}; - }; - - pushtag contains special code to call pushdecl_with_scope on the - TEMPLATE_DECL for S2. */ - begin_scope (sk_template_parms, NULL); - ++processing_template_decl; - ++processing_template_parmlist; - note_template_header (0); -} - -/* This routine is called when a specialization is declared. If it is - invalid to declare a specialization here, an error is reported and - false is returned, otherwise this routine will return true. */ - -static bool -check_specialization_scope (void) -{ - tree scope = current_scope (); - - /* [temp.expl.spec] - - An explicit specialization shall be declared in the namespace of - which the template is a member, or, for member templates, in the - namespace of which the enclosing class or enclosing class - template is a member. An explicit specialization of a member - function, member class or static data member of a class template - shall be declared in the namespace of which the class template - is a member. */ - if (scope && TREE_CODE (scope) != NAMESPACE_DECL) - { - error ("explicit specialization in non-namespace scope %qD", scope); - return false; - } - - /* [temp.expl.spec] - - In an explicit specialization declaration for a member of a class - template or a member template that appears in namespace scope, - the member template and some of its enclosing class templates may - remain unspecialized, except that the declaration shall not - explicitly specialize a class member template if its enclosing - class templates are not explicitly specialized as well. */ - if (current_template_parms) - { - error ("enclosing class templates are not explicitly specialized"); - return false; - } - - return true; -} - -/* We've just seen template <>. */ - -bool -begin_specialization (void) -{ - begin_scope (sk_template_spec, NULL); - note_template_header (1); - return check_specialization_scope (); -} - -/* Called at then end of processing a declaration preceded by - template<>. */ - -void -end_specialization (void) -{ - finish_scope (); - reset_specialization (); -} - -/* Any template <>'s that we have seen thus far are not referring to a - function specialization. */ - -void -reset_specialization (void) -{ - processing_specialization = 0; - template_header_count = 0; -} - -/* We've just seen a template header. If SPECIALIZATION is nonzero, - it was of the form template <>. */ - -static void -note_template_header (int specialization) -{ - processing_specialization = specialization; - template_header_count++; -} - -/* We're beginning an explicit instantiation. */ - -void -begin_explicit_instantiation (void) -{ - gcc_assert (!processing_explicit_instantiation); - processing_explicit_instantiation = true; -} - - -void -end_explicit_instantiation (void) -{ - gcc_assert (processing_explicit_instantiation); - processing_explicit_instantiation = false; -} - -/* An explicit specialization or partial specialization TMPL is being - declared. Check that the namespace in which the specialization is - occurring is permissible. Returns false iff it is invalid to - specialize TMPL in the current namespace. */ - -static bool -check_specialization_namespace (tree tmpl) -{ - tree tpl_ns = decl_namespace_context (tmpl); - - /* [tmpl.expl.spec] - - An explicit specialization shall be declared in the namespace of - which the template is a member, or, for member templates, in the - namespace of which the enclosing class or enclosing class - template is a member. An explicit specialization of a member - function, member class or static data member of a class template - shall be declared in the namespace of which the class template is - a member. */ - if (is_associated_namespace (current_namespace, tpl_ns)) - /* Same or super-using namespace. */ - return true; - else - { - pedwarn ("specialization of %qD in different namespace", tmpl); - pedwarn (" from definition of %q+#D", tmpl); - return false; - } -} - -/* SPEC is an explicit instantiation. Check that it is valid to - perform this explicit instantiation in the current namespace. */ - -static void -check_explicit_instantiation_namespace (tree spec) -{ - tree ns; - - /* DR 275: An explicit instantiation shall appear in an enclosing - namespace of its template. */ - ns = decl_namespace_context (spec); - if (!is_ancestor (current_namespace, ns)) - pedwarn ("explicit instantiation of %qD in namespace %qD " - "(which does not enclose namespace %qD)", - spec, current_namespace, ns); -} - -/* The TYPE is being declared. If it is a template type, that means it - is a partial specialization. Do appropriate error-checking. */ - -tree -maybe_process_partial_specialization (tree type) -{ - tree context; - - if (type == error_mark_node) - return error_mark_node; - - if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM) - { - error ("name of class shadows template template parameter %qD", - TYPE_NAME (type)); - return error_mark_node; - } - - context = TYPE_CONTEXT (type); - - if (CLASS_TYPE_P (type) && CLASSTYPE_USE_TEMPLATE (type)) - { - /* This is for ordinary explicit specialization and partial - specialization of a template class such as: - - template <> class C<int>; - - or: - - template <class T> class C<T*>; - - Make sure that `C<int>' and `C<T*>' are implicit instantiations. */ - - if (CLASSTYPE_IMPLICIT_INSTANTIATION (type) - && !COMPLETE_TYPE_P (type)) - { - check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (type)); - SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type); - if (processing_template_decl) - push_template_decl (TYPE_MAIN_DECL (type)); - } - else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type)) - error ("specialization of %qT after instantiation", type); - } - else if (CLASS_TYPE_P (type) - && !CLASSTYPE_USE_TEMPLATE (type) - && CLASSTYPE_TEMPLATE_INFO (type) - && context && CLASS_TYPE_P (context) - && CLASSTYPE_TEMPLATE_INFO (context)) - { - /* This is for an explicit specialization of member class - template according to [temp.expl.spec/18]: - - template <> template <class U> class C<int>::D; - - The context `C<int>' must be an implicit instantiation. - Otherwise this is just a member class template declared - earlier like: - - template <> class C<int> { template <class U> class D; }; - template <> template <class U> class C<int>::D; - - In the first case, `C<int>::D' is a specialization of `C<T>::D' - while in the second case, `C<int>::D' is a primary template - and `C<T>::D' may not exist. */ - - if (CLASSTYPE_IMPLICIT_INSTANTIATION (context) - && !COMPLETE_TYPE_P (type)) - { - tree t; - - if (current_namespace - != decl_namespace_context (CLASSTYPE_TI_TEMPLATE (type))) - { - pedwarn ("specializing %q#T in different namespace", type); - pedwarn (" from definition of %q+#D", - CLASSTYPE_TI_TEMPLATE (type)); - } - - /* Check for invalid specialization after instantiation: - - template <> template <> class C<int>::D<int>; - template <> template <class U> class C<int>::D; */ - - for (t = DECL_TEMPLATE_INSTANTIATIONS - (most_general_template (CLASSTYPE_TI_TEMPLATE (type))); - t; t = TREE_CHAIN (t)) - if (TREE_VALUE (t) != type - && TYPE_CONTEXT (TREE_VALUE (t)) == context) - error ("specialization %qT after instantiation %qT", - type, TREE_VALUE (t)); - - /* Mark TYPE as a specialization. And as a result, we only - have one level of template argument for the innermost - class template. */ - SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type); - CLASSTYPE_TI_ARGS (type) - = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type)); - } - } - else if (processing_specialization) - { - error ("explicit specialization of non-template %qT", type); - return error_mark_node; - } - - return type; -} - -/* Returns nonzero if we can optimize the retrieval of specializations - for TMPL, a TEMPLATE_DECL. In particular, for such a template, we - do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */ - -static inline bool -optimize_specialization_lookup_p (tree tmpl) -{ - return (DECL_FUNCTION_TEMPLATE_P (tmpl) - && DECL_CLASS_SCOPE_P (tmpl) - /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template - parameter. */ - && CLASS_TYPE_P (DECL_CONTEXT (tmpl)) - /* The optimized lookup depends on the fact that the - template arguments for the member function template apply - purely to the containing class, which is not true if the - containing class is an explicit or partial - specialization. */ - && !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl)) - && !DECL_MEMBER_TEMPLATE_P (tmpl) - && !DECL_CONV_FN_P (tmpl) - /* It is possible to have a template that is not a member - template and is not a member of a template class: - - template <typename T> - struct S { friend A::f(); }; - - Here, the friend function is a template, but the context does - not have template information. The optimized lookup relies - on having ARGS be the template arguments for both the class - and the function template. */ - && !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl))); -} - -/* Retrieve the specialization (in the sense of [temp.spec] - a - specialization is either an instantiation or an explicit - specialization) of TMPL for the given template ARGS. If there is - no such specialization, return NULL_TREE. The ARGS are a vector of - arguments, or a vector of vectors of arguments, in the case of - templates with more than one level of parameters. - - If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true, - then we search for a partial specialization matching ARGS. This - parameter is ignored if TMPL is not a class template. */ - -static tree -retrieve_specialization (tree tmpl, tree args, - bool class_specializations_p) -{ - if (args == error_mark_node) - return NULL_TREE; - - gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL); - - /* There should be as many levels of arguments as there are - levels of parameters. */ - gcc_assert (TMPL_ARGS_DEPTH (args) - == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl))); - - if (optimize_specialization_lookup_p (tmpl)) - { - tree class_template; - tree class_specialization; - VEC(tree,gc) *methods; - tree fns; - int idx; - - /* The template arguments actually apply to the containing - class. Find the class specialization with those - arguments. */ - class_template = CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl)); - class_specialization - = retrieve_specialization (class_template, args, - /*class_specializations_p=*/false); - if (!class_specialization) - return NULL_TREE; - /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC - for the specialization. */ - idx = class_method_index_for_fn (class_specialization, tmpl); - if (idx == -1) - return NULL_TREE; - /* Iterate through the methods with the indicated name, looking - for the one that has an instance of TMPL. */ - methods = CLASSTYPE_METHOD_VEC (class_specialization); - for (fns = VEC_index (tree, methods, idx); fns; fns = OVL_NEXT (fns)) - { - tree fn = OVL_CURRENT (fns); - if (DECL_TEMPLATE_INFO (fn) && DECL_TI_TEMPLATE (fn) == tmpl) - return fn; - } - return NULL_TREE; - } - else - { - tree *sp; - tree *head; - - /* Class templates store their instantiations on the - DECL_TEMPLATE_INSTANTIATIONS list; other templates use the - DECL_TEMPLATE_SPECIALIZATIONS list. */ - if (!class_specializations_p - && TREE_CODE (DECL_TEMPLATE_RESULT (tmpl)) == TYPE_DECL) - sp = &DECL_TEMPLATE_INSTANTIATIONS (tmpl); - else - sp = &DECL_TEMPLATE_SPECIALIZATIONS (tmpl); - head = sp; - /* Iterate through the list until we find a matching template. */ - while (*sp != NULL_TREE) - { - tree spec = *sp; - - if (comp_template_args (TREE_PURPOSE (spec), args)) - { - /* Use the move-to-front heuristic to speed up future - searches. */ - if (spec != *head) - { - *sp = TREE_CHAIN (*sp); - TREE_CHAIN (spec) = *head; - *head = spec; - } - return TREE_VALUE (spec); - } - sp = &TREE_CHAIN (spec); - } - } - - return NULL_TREE; -} - -/* Like retrieve_specialization, but for local declarations. */ - -static tree -retrieve_local_specialization (tree tmpl) -{ - tree spec = (tree) htab_find_with_hash (local_specializations, tmpl, - htab_hash_pointer (tmpl)); - return spec ? TREE_PURPOSE (spec) : NULL_TREE; -} - -/* Returns nonzero iff DECL is a specialization of TMPL. */ - -int -is_specialization_of (tree decl, tree tmpl) -{ - tree t; - - if (TREE_CODE (decl) == FUNCTION_DECL) - { - for (t = decl; - t != NULL_TREE; - t = DECL_TEMPLATE_INFO (t) ? DECL_TI_TEMPLATE (t) : NULL_TREE) - if (t == tmpl) - return 1; - } - else - { - gcc_assert (TREE_CODE (decl) == TYPE_DECL); - - for (t = TREE_TYPE (decl); - t != NULL_TREE; - t = CLASSTYPE_USE_TEMPLATE (t) - ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t)) : NULL_TREE) - if (same_type_ignoring_top_level_qualifiers_p (t, TREE_TYPE (tmpl))) - return 1; - } - - return 0; -} - -/* Returns nonzero iff DECL is a specialization of friend declaration - FRIEND according to [temp.friend]. */ - -bool -is_specialization_of_friend (tree decl, tree friend) -{ - bool need_template = true; - int template_depth; - - gcc_assert (TREE_CODE (decl) == FUNCTION_DECL - || TREE_CODE (decl) == TYPE_DECL); - - /* For [temp.friend/6] when FRIEND is an ordinary member function - of a template class, we want to check if DECL is a specialization - if this. */ - if (TREE_CODE (friend) == FUNCTION_DECL - && DECL_TEMPLATE_INFO (friend) - && !DECL_USE_TEMPLATE (friend)) - { - /* We want a TEMPLATE_DECL for `is_specialization_of'. */ - friend = DECL_TI_TEMPLATE (friend); - need_template = false; - } - else if (TREE_CODE (friend) == TEMPLATE_DECL - && !PRIMARY_TEMPLATE_P (friend)) - need_template = false; - - /* There is nothing to do if this is not a template friend. */ - if (TREE_CODE (friend) != TEMPLATE_DECL) - return false; - - if (is_specialization_of (decl, friend)) - return true; - - /* [temp.friend/6] - A member of a class template may be declared to be a friend of a - non-template class. In this case, the corresponding member of - every specialization of the class template is a friend of the - class granting friendship. - - For example, given a template friend declaration - - template <class T> friend void A<T>::f(); - - the member function below is considered a friend - - template <> struct A<int> { - void f(); - }; - - For this type of template friend, TEMPLATE_DEPTH below will be - nonzero. To determine if DECL is a friend of FRIEND, we first - check if the enclosing class is a specialization of another. */ - - template_depth = template_class_depth (DECL_CONTEXT (friend)); - if (template_depth - && DECL_CLASS_SCOPE_P (decl) - && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl)), - CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend)))) - { - /* Next, we check the members themselves. In order to handle - a few tricky cases, such as when FRIEND's are - - template <class T> friend void A<T>::g(T t); - template <class T> template <T t> friend void A<T>::h(); - - and DECL's are - - void A<int>::g(int); - template <int> void A<int>::h(); - - we need to figure out ARGS, the template arguments from - the context of DECL. This is required for template substitution - of `T' in the function parameter of `g' and template parameter - of `h' in the above examples. Here ARGS corresponds to `int'. */ - - tree context = DECL_CONTEXT (decl); - tree args = NULL_TREE; - int current_depth = 0; - - while (current_depth < template_depth) - { - if (CLASSTYPE_TEMPLATE_INFO (context)) - { - if (current_depth == 0) - args = TYPE_TI_ARGS (context); - else - args = add_to_template_args (TYPE_TI_ARGS (context), args); - current_depth++; - } - context = TYPE_CONTEXT (context); - } - - if (TREE_CODE (decl) == FUNCTION_DECL) - { - bool is_template; - tree friend_type; - tree decl_type; - tree friend_args_type; - tree decl_args_type; - - /* Make sure that both DECL and FRIEND are templates or - non-templates. */ - is_template = DECL_TEMPLATE_INFO (decl) - && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl)); - if (need_template ^ is_template) - return false; - else if (is_template) - { - /* If both are templates, check template parameter list. */ - tree friend_parms - = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend), - args, tf_none); - if (!comp_template_parms - (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl)), - friend_parms)) - return false; - - decl_type = TREE_TYPE (DECL_TI_TEMPLATE (decl)); - } - else - decl_type = TREE_TYPE (decl); - - friend_type = tsubst_function_type (TREE_TYPE (friend), args, - tf_none, NULL_TREE); - if (friend_type == error_mark_node) - return false; - - /* Check if return types match. */ - if (!same_type_p (TREE_TYPE (decl_type), TREE_TYPE (friend_type))) - return false; - - /* Check if function parameter types match, ignoring the - `this' parameter. */ - friend_args_type = TYPE_ARG_TYPES (friend_type); - decl_args_type = TYPE_ARG_TYPES (decl_type); - if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend)) - friend_args_type = TREE_CHAIN (friend_args_type); - if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)) - decl_args_type = TREE_CHAIN (decl_args_type); - - return compparms (decl_args_type, friend_args_type); - } - else - { - /* DECL is a TYPE_DECL */ - bool is_template; - tree decl_type = TREE_TYPE (decl); - - /* Make sure that both DECL and FRIEND are templates or - non-templates. */ - is_template - = CLASSTYPE_TEMPLATE_INFO (decl_type) - && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type)); - - if (need_template ^ is_template) - return false; - else if (is_template) - { - tree friend_parms; - /* If both are templates, check the name of the two - TEMPLATE_DECL's first because is_friend didn't. */ - if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type)) - != DECL_NAME (friend)) - return false; - - /* Now check template parameter list. */ - friend_parms - = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend), - args, tf_none); - return comp_template_parms - (DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type)), - friend_parms); - } - else - return (DECL_NAME (decl) - == DECL_NAME (friend)); - } - } - return false; -} - -/* Register the specialization SPEC as a specialization of TMPL with - the indicated ARGS. IS_FRIEND indicates whether the specialization - is actually just a friend declaration. Returns SPEC, or an - equivalent prior declaration, if available. */ - -static tree -register_specialization (tree spec, tree tmpl, tree args, bool is_friend) -{ - tree fn; - - gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL); - - if (TREE_CODE (spec) == FUNCTION_DECL - && uses_template_parms (DECL_TI_ARGS (spec))) - /* This is the FUNCTION_DECL for a partial instantiation. Don't - register it; we want the corresponding TEMPLATE_DECL instead. - We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than - the more obvious `uses_template_parms (spec)' to avoid problems - with default function arguments. In particular, given - something like this: - - template <class T> void f(T t1, T t = T()) - - the default argument expression is not substituted for in an - instantiation unless and until it is actually needed. */ - return spec; - - fn = retrieve_specialization (tmpl, args, - /*class_specializations_p=*/false); - /* We can sometimes try to re-register a specialization that we've - already got. In particular, regenerate_decl_from_template calls - duplicate_decls which will update the specialization list. But, - we'll still get called again here anyhow. It's more convenient - to simply allow this than to try to prevent it. */ - if (fn == spec) - return spec; - else if (fn && DECL_TEMPLATE_SPECIALIZATION (spec)) - { - if (DECL_TEMPLATE_INSTANTIATION (fn)) - { - if (TREE_USED (fn) - || DECL_EXPLICIT_INSTANTIATION (fn)) - { - error ("specialization of %qD after instantiation", - fn); - return error_mark_node; - } - else - { - tree clone; - /* This situation should occur only if the first - specialization is an implicit instantiation, the - second is an explicit specialization, and the - implicit instantiation has not yet been used. That - situation can occur if we have implicitly - instantiated a member function and then specialized - it later. - - We can also wind up here if a friend declaration that - looked like an instantiation turns out to be a - specialization: - - template <class T> void foo(T); - class S { friend void foo<>(int) }; - template <> void foo(int); - - We transform the existing DECL in place so that any - pointers to it become pointers to the updated - declaration. - - If there was a definition for the template, but not - for the specialization, we want this to look as if - there were no definition, and vice versa. */ - DECL_INITIAL (fn) = NULL_TREE; - duplicate_decls (spec, fn, is_friend); - /* The call to duplicate_decls will have applied - [temp.expl.spec]: - - An explicit specialization of a function template - is inline only if it is explicitly declared to be, - and independently of whether its function template - is. - - to the primary function; now copy the inline bits to - the various clones. */ - FOR_EACH_CLONE (clone, fn) - { - DECL_DECLARED_INLINE_P (clone) - = DECL_DECLARED_INLINE_P (fn); - DECL_INLINE (clone) - = DECL_INLINE (fn); - } - check_specialization_namespace (fn); - - return fn; - } - } - else if (DECL_TEMPLATE_SPECIALIZATION (fn)) - { - if (!duplicate_decls (spec, fn, is_friend) && DECL_INITIAL (spec)) - /* Dup decl failed, but this is a new definition. Set the - line number so any errors match this new - definition. */ - DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (spec); - - return fn; - } - } - - /* A specialization must be declared in the same namespace as the - template it is specializing. */ - if (DECL_TEMPLATE_SPECIALIZATION (spec) - && !check_specialization_namespace (tmpl)) - DECL_CONTEXT (spec) = FROB_CONTEXT (decl_namespace_context (tmpl)); - - if (!optimize_specialization_lookup_p (tmpl)) - DECL_TEMPLATE_SPECIALIZATIONS (tmpl) - = tree_cons (args, spec, DECL_TEMPLATE_SPECIALIZATIONS (tmpl)); - - return spec; -} - -/* Unregister the specialization SPEC as a specialization of TMPL. - Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true - if the SPEC was listed as a specialization of TMPL. */ - -bool -reregister_specialization (tree spec, tree tmpl, tree new_spec) -{ - tree* s; - - for (s = &DECL_TEMPLATE_SPECIALIZATIONS (tmpl); - *s != NULL_TREE; - s = &TREE_CHAIN (*s)) - if (TREE_VALUE (*s) == spec) - { - if (!new_spec) - *s = TREE_CHAIN (*s); - else - TREE_VALUE (*s) = new_spec; - return 1; - } - - return 0; -} - -/* Compare an entry in the local specializations hash table P1 (which - is really a pointer to a TREE_LIST) with P2 (which is really a - DECL). */ - -static int -eq_local_specializations (const void *p1, const void *p2) -{ - return TREE_VALUE ((tree) p1) == (tree) p2; -} - -/* Hash P1, an entry in the local specializations table. */ - -static hashval_t -hash_local_specialization (const void* p1) -{ - return htab_hash_pointer (TREE_VALUE ((tree) p1)); -} - -/* Like register_specialization, but for local declarations. We are - registering SPEC, an instantiation of TMPL. */ - -static void -register_local_specialization (tree spec, tree tmpl) -{ - void **slot; - - slot = htab_find_slot_with_hash (local_specializations, tmpl, - htab_hash_pointer (tmpl), INSERT); - *slot = build_tree_list (spec, tmpl); -} - -/* TYPE is a class type. Returns true if TYPE is an explicitly - specialized class. */ - -bool -explicit_class_specialization_p (tree type) -{ - if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type)) - return false; - return !uses_template_parms (CLASSTYPE_TI_ARGS (type)); -} - -/* Print the list of candidate FNS in an error message. */ - -void -print_candidates (tree fns) -{ - tree fn; - - const char *str = "candidates are:"; - - for (fn = fns; fn != NULL_TREE; fn = TREE_CHAIN (fn)) - { - tree f; - - for (f = TREE_VALUE (fn); f; f = OVL_NEXT (f)) - error ("%s %+#D", str, OVL_CURRENT (f)); - str = " "; - } -} - -/* Returns the template (one of the functions given by TEMPLATE_ID) - which can be specialized to match the indicated DECL with the - explicit template args given in TEMPLATE_ID. The DECL may be - NULL_TREE if none is available. In that case, the functions in - TEMPLATE_ID are non-members. - - If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a - specialization of a member template. - - The TEMPLATE_COUNT is the number of references to qualifying - template classes that appeared in the name of the function. See - check_explicit_specialization for a more accurate description. - - TSK indicates what kind of template declaration (if any) is being - declared. TSK_TEMPLATE indicates that the declaration given by - DECL, though a FUNCTION_DECL, has template parameters, and is - therefore a template function. - - The template args (those explicitly specified and those deduced) - are output in a newly created vector *TARGS_OUT. - - If it is impossible to determine the result, an error message is - issued. The error_mark_node is returned to indicate failure. */ - -static tree -determine_specialization (tree template_id, - tree decl, - tree* targs_out, - int need_member_template, - int template_count, - tmpl_spec_kind tsk) -{ - tree fns; - tree targs; - tree explicit_targs; - tree candidates = NULL_TREE; - /* A TREE_LIST of templates of which DECL may be a specialization. - The TREE_VALUE of each node is a TEMPLATE_DECL. The - corresponding TREE_PURPOSE is the set of template arguments that, - when used to instantiate the template, would produce a function - with the signature of DECL. */ - tree templates = NULL_TREE; - int header_count; - struct cp_binding_level *b; - - *targs_out = NULL_TREE; - - if (template_id == error_mark_node || decl == error_mark_node) - return error_mark_node; - - fns = TREE_OPERAND (template_id, 0); - explicit_targs = TREE_OPERAND (template_id, 1); - - if (fns == error_mark_node) - return error_mark_node; - - /* Check for baselinks. */ - if (BASELINK_P (fns)) - fns = BASELINK_FUNCTIONS (fns); - - if (!is_overloaded_fn (fns)) - { - error ("%qD is not a function template", fns); - return error_mark_node; - } - - /* Count the number of template headers specified for this - specialization. */ - header_count = 0; - for (b = current_binding_level; - b->kind == sk_template_parms; - b = b->level_chain) - ++header_count; - - for (; fns; fns = OVL_NEXT (fns)) - { - tree fn = OVL_CURRENT (fns); - - if (TREE_CODE (fn) == TEMPLATE_DECL) - { - tree decl_arg_types; - tree fn_arg_types; - - /* In case of explicit specialization, we need to check if - the number of template headers appearing in the specialization - is correct. This is usually done in check_explicit_specialization, - but the check done there cannot be exhaustive when specializing - member functions. Consider the following code: - - template <> void A<int>::f(int); - template <> template <> void A<int>::f(int); - - Assuming that A<int> is not itself an explicit specialization - already, the first line specializes "f" which is a non-template - member function, whilst the second line specializes "f" which - is a template member function. So both lines are syntactically - correct, and check_explicit_specialization does not reject - them. - - Here, we can do better, as we are matching the specialization - against the declarations. We count the number of template - headers, and we check if they match TEMPLATE_COUNT + 1 - (TEMPLATE_COUNT is the number of qualifying template classes, - plus there must be another header for the member template - itself). - - Notice that if header_count is zero, this is not a - specialization but rather a template instantiation, so there - is no check we can perform here. */ - if (header_count && header_count != template_count + 1) - continue; - - /* Check that the number of template arguments at the - innermost level for DECL is the same as for FN. */ - if (current_binding_level->kind == sk_template_parms - && !current_binding_level->explicit_spec_p - && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn)) - != TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS - (current_template_parms)))) - continue; - - /* DECL might be a specialization of FN. */ - decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl)); - fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn)); - - /* For a non-static member function, we need to make sure - that the const qualification is the same. Since - get_bindings does not try to merge the "this" parameter, - we must do the comparison explicitly. */ - if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn) - && !same_type_p (TREE_VALUE (fn_arg_types), - TREE_VALUE (decl_arg_types))) - continue; - - /* Skip the "this" parameter and, for constructors of - classes with virtual bases, the VTT parameter. A - full specialization of a constructor will have a VTT - parameter, but a template never will. */ - decl_arg_types - = skip_artificial_parms_for (decl, decl_arg_types); - fn_arg_types - = skip_artificial_parms_for (fn, fn_arg_types); - - /* Check that the number of function parameters matches. - For example, - template <class T> void f(int i = 0); - template <> void f<int>(); - The specialization f<int> is invalid but is not caught - by get_bindings below. */ - if (list_length (fn_arg_types) != list_length (decl_arg_types)) - continue; - - /* Function templates cannot be specializations; there are - no partial specializations of functions. Therefore, if - the type of DECL does not match FN, there is no - match. */ - if (tsk == tsk_template) - { - if (compparms (fn_arg_types, decl_arg_types)) - candidates = tree_cons (NULL_TREE, fn, candidates); - continue; - } - - /* See whether this function might be a specialization of this - template. */ - targs = get_bindings (fn, decl, explicit_targs, /*check_ret=*/true); - - if (!targs) - /* We cannot deduce template arguments that when used to - specialize TMPL will produce DECL. */ - continue; - - /* Save this template, and the arguments deduced. */ - templates = tree_cons (targs, fn, templates); - } - else if (need_member_template) - /* FN is an ordinary member function, and we need a - specialization of a member template. */ - ; - else if (TREE_CODE (fn) != FUNCTION_DECL) - /* We can get IDENTIFIER_NODEs here in certain erroneous - cases. */ - ; - else if (!DECL_FUNCTION_MEMBER_P (fn)) - /* This is just an ordinary non-member function. Nothing can - be a specialization of that. */ - ; - else if (DECL_ARTIFICIAL (fn)) - /* Cannot specialize functions that are created implicitly. */ - ; - else - { - tree decl_arg_types; - - /* This is an ordinary member function. However, since - we're here, we can assume it's enclosing class is a - template class. For example, - - template <typename T> struct S { void f(); }; - template <> void S<int>::f() {} - - Here, S<int>::f is a non-template, but S<int> is a - template class. If FN has the same type as DECL, we - might be in business. */ - - if (!DECL_TEMPLATE_INFO (fn)) - /* Its enclosing class is an explicit specialization - of a template class. This is not a candidate. */ - continue; - - if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)), - TREE_TYPE (TREE_TYPE (fn)))) - /* The return types differ. */ - continue; - - /* Adjust the type of DECL in case FN is a static member. */ - decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl)); - if (DECL_STATIC_FUNCTION_P (fn) - && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)) - decl_arg_types = TREE_CHAIN (decl_arg_types); - - if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)), - decl_arg_types)) - /* They match! */ - candidates = tree_cons (NULL_TREE, fn, candidates); - } - } - - if (templates && TREE_CHAIN (templates)) - { - /* We have: - - [temp.expl.spec] - - It is possible for a specialization with a given function - signature to be instantiated from more than one function - template. In such cases, explicit specification of the - template arguments must be used to uniquely identify the - function template specialization being specialized. - - Note that here, there's no suggestion that we're supposed to - determine which of the candidate templates is most - specialized. However, we, also have: - - [temp.func.order] - - Partial ordering of overloaded function template - declarations is used in the following contexts to select - the function template to which a function template - specialization refers: - - -- when an explicit specialization refers to a function - template. - - So, we do use the partial ordering rules, at least for now. - This extension can only serve to make invalid programs valid, - so it's safe. And, there is strong anecdotal evidence that - the committee intended the partial ordering rules to apply; - the EDG front-end has that behavior, and John Spicer claims - that the committee simply forgot to delete the wording in - [temp.expl.spec]. */ - tree tmpl = most_specialized_instantiation (templates); - if (tmpl != error_mark_node) - { - templates = tmpl; - TREE_CHAIN (templates) = NULL_TREE; - } - } - - if (templates == NULL_TREE && candidates == NULL_TREE) - { - error ("template-id %qD for %q+D does not match any template " - "declaration", template_id, decl); - return error_mark_node; - } - else if ((templates && TREE_CHAIN (templates)) - || (candidates && TREE_CHAIN (candidates)) - || (templates && candidates)) - { - error ("ambiguous template specialization %qD for %q+D", - template_id, decl); - chainon (candidates, templates); - print_candidates (candidates); - return error_mark_node; - } - - /* We have one, and exactly one, match. */ - if (candidates) - { - tree fn = TREE_VALUE (candidates); - /* DECL is a re-declaration of a template function. */ - if (TREE_CODE (fn) == TEMPLATE_DECL) - return fn; - /* It was a specialization of an ordinary member function in a - template class. */ - *targs_out = copy_node (DECL_TI_ARGS (fn)); - return DECL_TI_TEMPLATE (fn); - } - - /* It was a specialization of a template. */ - targs = DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates))); - if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs)) - { - *targs_out = copy_node (targs); - SET_TMPL_ARGS_LEVEL (*targs_out, - TMPL_ARGS_DEPTH (*targs_out), - TREE_PURPOSE (templates)); - } - else - *targs_out = TREE_PURPOSE (templates); - return TREE_VALUE (templates); -} - -/* Returns a chain of parameter types, exactly like the SPEC_TYPES, - but with the default argument values filled in from those in the - TMPL_TYPES. */ - -static tree -copy_default_args_to_explicit_spec_1 (tree spec_types, - tree tmpl_types) -{ - tree new_spec_types; - - if (!spec_types) - return NULL_TREE; - - if (spec_types == void_list_node) - return void_list_node; - - /* Substitute into the rest of the list. */ - new_spec_types = - copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types), - TREE_CHAIN (tmpl_types)); - - /* Add the default argument for this parameter. */ - return hash_tree_cons (TREE_PURPOSE (tmpl_types), - TREE_VALUE (spec_types), - new_spec_types); -} - -/* DECL is an explicit specialization. Replicate default arguments - from the template it specializes. (That way, code like: - - template <class T> void f(T = 3); - template <> void f(double); - void g () { f (); } - - works, as required.) An alternative approach would be to look up - the correct default arguments at the call-site, but this approach - is consistent with how implicit instantiations are handled. */ - -static void -copy_default_args_to_explicit_spec (tree decl) -{ - tree tmpl; - tree spec_types; - tree tmpl_types; - tree new_spec_types; - tree old_type; - tree new_type; - tree t; - tree object_type = NULL_TREE; - tree in_charge = NULL_TREE; - tree vtt = NULL_TREE; - - /* See if there's anything we need to do. */ - tmpl = DECL_TI_TEMPLATE (decl); - tmpl_types = TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl))); - for (t = tmpl_types; t; t = TREE_CHAIN (t)) - if (TREE_PURPOSE (t)) - break; - if (!t) - return; - - old_type = TREE_TYPE (decl); - spec_types = TYPE_ARG_TYPES (old_type); - - if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)) - { - /* Remove the this pointer, but remember the object's type for - CV quals. */ - object_type = TREE_TYPE (TREE_VALUE (spec_types)); - spec_types = TREE_CHAIN (spec_types); - tmpl_types = TREE_CHAIN (tmpl_types); - - if (DECL_HAS_IN_CHARGE_PARM_P (decl)) - { - /* DECL may contain more parameters than TMPL due to the extra - in-charge parameter in constructors and destructors. */ - in_charge = spec_types; - spec_types = TREE_CHAIN (spec_types); - } - if (DECL_HAS_VTT_PARM_P (decl)) - { - vtt = spec_types; - spec_types = TREE_CHAIN (spec_types); - } - } - - /* Compute the merged default arguments. */ - new_spec_types = - copy_default_args_to_explicit_spec_1 (spec_types, tmpl_types); - - /* Compute the new FUNCTION_TYPE. */ - if (object_type) - { - if (vtt) - new_spec_types = hash_tree_cons (TREE_PURPOSE (vtt), - TREE_VALUE (vtt), - new_spec_types); - - if (in_charge) - /* Put the in-charge parameter back. */ - new_spec_types = hash_tree_cons (TREE_PURPOSE (in_charge), - TREE_VALUE (in_charge), - new_spec_types); - - new_type = build_method_type_directly (object_type, - TREE_TYPE (old_type), - new_spec_types); - } - else - new_type = build_function_type (TREE_TYPE (old_type), - new_spec_types); - new_type = cp_build_type_attribute_variant (new_type, - TYPE_ATTRIBUTES (old_type)); - new_type = build_exception_variant (new_type, - TYPE_RAISES_EXCEPTIONS (old_type)); - TREE_TYPE (decl) = new_type; -} - -/* Check to see if the function just declared, as indicated in - DECLARATOR, and in DECL, is a specialization of a function - template. We may also discover that the declaration is an explicit - instantiation at this point. - - Returns DECL, or an equivalent declaration that should be used - instead if all goes well. Issues an error message if something is - amiss. Returns error_mark_node if the error is not easily - recoverable. - - FLAGS is a bitmask consisting of the following flags: - - 2: The function has a definition. - 4: The function is a friend. - - The TEMPLATE_COUNT is the number of references to qualifying - template classes that appeared in the name of the function. For - example, in - - template <class T> struct S { void f(); }; - void S<int>::f(); - - the TEMPLATE_COUNT would be 1. However, explicitly specialized - classes are not counted in the TEMPLATE_COUNT, so that in - - template <class T> struct S {}; - template <> struct S<int> { void f(); } - template <> void S<int>::f(); - - the TEMPLATE_COUNT would be 0. (Note that this declaration is - invalid; there should be no template <>.) - - If the function is a specialization, it is marked as such via - DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO - is set up correctly, and it is added to the list of specializations - for that template. */ - -tree -check_explicit_specialization (tree declarator, - tree decl, - int template_count, - int flags) -{ - int have_def = flags & 2; - int is_friend = flags & 4; - int specialization = 0; - int explicit_instantiation = 0; - int member_specialization = 0; - tree ctype = DECL_CLASS_CONTEXT (decl); - tree dname = DECL_NAME (decl); - tmpl_spec_kind tsk; - - if (is_friend) - { - if (!processing_specialization) - tsk = tsk_none; - else - tsk = tsk_excessive_parms; - } - else - tsk = current_tmpl_spec_kind (template_count); - - switch (tsk) - { - case tsk_none: - if (processing_specialization) - { - specialization = 1; - SET_DECL_TEMPLATE_SPECIALIZATION (decl); - } - else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR) - { - if (is_friend) - /* This could be something like: - - template <class T> void f(T); - class S { friend void f<>(int); } */ - specialization = 1; - else - { - /* This case handles bogus declarations like template <> - template <class T> void f<int>(); */ - - error ("template-id %qD in declaration of primary template", - declarator); - return decl; - } - } - break; - - case tsk_invalid_member_spec: - /* The error has already been reported in - check_specialization_scope. */ - return error_mark_node; - - case tsk_invalid_expl_inst: - error ("template parameter list used in explicit instantiation"); - - /* Fall through. */ - - case tsk_expl_inst: - if (have_def) - error ("definition provided for explicit instantiation"); - - explicit_instantiation = 1; - break; - - case tsk_excessive_parms: - case tsk_insufficient_parms: - if (tsk == tsk_excessive_parms) - error ("too many template parameter lists in declaration of %qD", - decl); - else if (template_header_count) - error("too few template parameter lists in declaration of %qD", decl); - else - error("explicit specialization of %qD must be introduced by " - "%<template <>%>", decl); - - /* Fall through. */ - case tsk_expl_spec: - SET_DECL_TEMPLATE_SPECIALIZATION (decl); - if (ctype) - member_specialization = 1; - else - specialization = 1; - break; - - case tsk_template: - if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR) - { - /* This case handles bogus declarations like template <> - template <class T> void f<int>(); */ - - if (uses_template_parms (declarator)) - error ("function template partial specialization %qD " - "is not allowed", declarator); - else - error ("template-id %qD in declaration of primary template", - declarator); - return decl; - } - - if (ctype && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype)) - /* This is a specialization of a member template, without - specialization the containing class. Something like: - - template <class T> struct S { - template <class U> void f (U); - }; - template <> template <class U> void S<int>::f(U) {} - - That's a specialization -- but of the entire template. */ - specialization = 1; - break; - - default: - gcc_unreachable (); - } - - if (specialization || member_specialization) - { - tree t = TYPE_ARG_TYPES (TREE_TYPE (decl)); - for (; t; t = TREE_CHAIN (t)) - if (TREE_PURPOSE (t)) - { - pedwarn - ("default argument specified in explicit specialization"); - break; - } - } - - if (specialization || member_specialization || explicit_instantiation) - { - tree tmpl = NULL_TREE; - tree targs = NULL_TREE; - - /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */ - if (TREE_CODE (declarator) != TEMPLATE_ID_EXPR) - { - tree fns; - - gcc_assert (TREE_CODE (declarator) == IDENTIFIER_NODE); - if (ctype) - fns = dname; - else - { - /* If there is no class context, the explicit instantiation - must be at namespace scope. */ - gcc_assert (DECL_NAMESPACE_SCOPE_P (decl)); - - /* Find the namespace binding, using the declaration - context. */ - fns = lookup_qualified_name (CP_DECL_CONTEXT (decl), dname, - false, true); - if (!fns || !is_overloaded_fn (fns)) - { - error ("%qD is not a template function", dname); - fns = error_mark_node; - } - else - { - tree fn = OVL_CURRENT (fns); - if (!is_associated_namespace (CP_DECL_CONTEXT (decl), - CP_DECL_CONTEXT (fn))) - error ("%qD is not declared in %qD", - decl, current_namespace); - } - } - - declarator = lookup_template_function (fns, NULL_TREE); - } - - if (declarator == error_mark_node) - return error_mark_node; - - if (ctype != NULL_TREE && TYPE_BEING_DEFINED (ctype)) - { - if (!explicit_instantiation) - /* A specialization in class scope. This is invalid, - but the error will already have been flagged by - check_specialization_scope. */ - return error_mark_node; - else - { - /* It's not valid to write an explicit instantiation in - class scope, e.g.: - - class C { template void f(); } - - This case is caught by the parser. However, on - something like: - - template class C { void f(); }; - - (which is invalid) we can get here. The error will be - issued later. */ - ; - } - - return decl; - } - else if (ctype != NULL_TREE - && (TREE_CODE (TREE_OPERAND (declarator, 0)) == - IDENTIFIER_NODE)) - { - /* Find the list of functions in ctype that have the same - name as the declared function. */ - tree name = TREE_OPERAND (declarator, 0); - tree fns = NULL_TREE; - int idx; - - if (constructor_name_p (name, ctype)) - { - int is_constructor = DECL_CONSTRUCTOR_P (decl); - - if (is_constructor ? !TYPE_HAS_CONSTRUCTOR (ctype) - : !CLASSTYPE_DESTRUCTORS (ctype)) - { - /* From [temp.expl.spec]: - - If such an explicit specialization for the member - of a class template names an implicitly-declared - special member function (clause _special_), the - program is ill-formed. - - Similar language is found in [temp.explicit]. */ - error ("specialization of implicitly-declared special member function"); - return error_mark_node; - } - - name = is_constructor ? ctor_identifier : dtor_identifier; - } - - if (!DECL_CONV_FN_P (decl)) - { - idx = lookup_fnfields_1 (ctype, name); - if (idx >= 0) - fns = VEC_index (tree, CLASSTYPE_METHOD_VEC (ctype), idx); - } - else - { - VEC(tree,gc) *methods; - tree ovl; - - /* For a type-conversion operator, we cannot do a - name-based lookup. We might be looking for `operator - int' which will be a specialization of `operator T'. - So, we find *all* the conversion operators, and then - select from them. */ - fns = NULL_TREE; - - methods = CLASSTYPE_METHOD_VEC (ctype); - if (methods) - for (idx = CLASSTYPE_FIRST_CONVERSION_SLOT; - VEC_iterate (tree, methods, idx, ovl); - ++idx) - { - if (!DECL_CONV_FN_P (OVL_CURRENT (ovl))) - /* There are no more conversion functions. */ - break; - - /* Glue all these conversion functions together - with those we already have. */ - for (; ovl; ovl = OVL_NEXT (ovl)) - fns = ovl_cons (OVL_CURRENT (ovl), fns); - } - } - - if (fns == NULL_TREE) - { - error ("no member function %qD declared in %qT", name, ctype); - return error_mark_node; - } - else - TREE_OPERAND (declarator, 0) = fns; - } - - /* Figure out what exactly is being specialized at this point. - Note that for an explicit instantiation, even one for a - member function, we cannot tell apriori whether the - instantiation is for a member template, or just a member - function of a template class. Even if a member template is - being instantiated, the member template arguments may be - elided if they can be deduced from the rest of the - declaration. */ - tmpl = determine_specialization (declarator, decl, - &targs, - member_specialization, - template_count, - tsk); - - if (!tmpl || tmpl == error_mark_node) - /* We couldn't figure out what this declaration was - specializing. */ - return error_mark_node; - else - { - tree gen_tmpl = most_general_template (tmpl); - - if (explicit_instantiation) - { - /* We don't set DECL_EXPLICIT_INSTANTIATION here; that - is done by do_decl_instantiation later. */ - - int arg_depth = TMPL_ARGS_DEPTH (targs); - int parm_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)); - - if (arg_depth > parm_depth) - { - /* If TMPL is not the most general template (for - example, if TMPL is a friend template that is - injected into namespace scope), then there will - be too many levels of TARGS. Remove some of them - here. */ - int i; - tree new_targs; - - new_targs = make_tree_vec (parm_depth); - for (i = arg_depth - parm_depth; i < arg_depth; ++i) - TREE_VEC_ELT (new_targs, i - (arg_depth - parm_depth)) - = TREE_VEC_ELT (targs, i); - targs = new_targs; - } - - return instantiate_template (tmpl, targs, tf_error); - } - - /* If we thought that the DECL was a member function, but it - turns out to be specializing a static member function, - make DECL a static member function as well. */ - if (DECL_STATIC_FUNCTION_P (tmpl) - && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)) - revert_static_member_fn (decl); - - /* If this is a specialization of a member template of a - template class, we want to return the TEMPLATE_DECL, not - the specialization of it. */ - if (tsk == tsk_template) - { - SET_DECL_TEMPLATE_SPECIALIZATION (tmpl); - DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl)) = NULL_TREE; - if (have_def) - { - DECL_SOURCE_LOCATION (tmpl) = DECL_SOURCE_LOCATION (decl); - DECL_SOURCE_LOCATION (DECL_TEMPLATE_RESULT (tmpl)) - = DECL_SOURCE_LOCATION (decl); - /* We want to use the argument list specified in the - definition, not in the original declaration. */ - DECL_ARGUMENTS (DECL_TEMPLATE_RESULT (tmpl)) - = DECL_ARGUMENTS (decl); - } - return tmpl; - } - - /* Set up the DECL_TEMPLATE_INFO for DECL. */ - DECL_TEMPLATE_INFO (decl) = tree_cons (tmpl, targs, NULL_TREE); - - /* Inherit default function arguments from the template - DECL is specializing. */ - copy_default_args_to_explicit_spec (decl); - - /* This specialization has the same protection as the - template it specializes. */ - TREE_PRIVATE (decl) = TREE_PRIVATE (gen_tmpl); - TREE_PROTECTED (decl) = TREE_PROTECTED (gen_tmpl); - - /* If DECL is a friend declaration, declared using an - unqualified name, the namespace associated with DECL may - have been set incorrectly. For example, in: - - template <typename T> void f(T); - namespace N { - struct S { friend void f<int>(int); } - } - - we will have set the DECL_CONTEXT for the friend - declaration to N, rather than to the global namespace. */ - if (DECL_NAMESPACE_SCOPE_P (decl)) - DECL_CONTEXT (decl) = DECL_CONTEXT (tmpl); - - if (is_friend && !have_def) - /* This is not really a declaration of a specialization. - It's just the name of an instantiation. But, it's not - a request for an instantiation, either. */ - SET_DECL_IMPLICIT_INSTANTIATION (decl); - else if (DECL_CONSTRUCTOR_P (decl) || DECL_DESTRUCTOR_P (decl)) - /* This is indeed a specialization. In case of constructors - and destructors, we need in-charge and not-in-charge - versions in V3 ABI. */ - clone_function_decl (decl, /*update_method_vec_p=*/0); - - /* Register this specialization so that we can find it - again. */ - decl = register_specialization (decl, gen_tmpl, targs, is_friend); - } - } - - return decl; -} - -/* Returns 1 iff PARMS1 and PARMS2 are identical sets of template - parameters. These are represented in the same format used for - DECL_TEMPLATE_PARMS. */ - -int -comp_template_parms (tree parms1, tree parms2) -{ - tree p1; - tree p2; - - if (parms1 == parms2) - return 1; - - for (p1 = parms1, p2 = parms2; - p1 != NULL_TREE && p2 != NULL_TREE; - p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2)) - { - tree t1 = TREE_VALUE (p1); - tree t2 = TREE_VALUE (p2); - int i; - - gcc_assert (TREE_CODE (t1) == TREE_VEC); - gcc_assert (TREE_CODE (t2) == TREE_VEC); - - if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2)) - return 0; - - for (i = 0; i < TREE_VEC_LENGTH (t2); ++i) - { - tree parm1 = TREE_VALUE (TREE_VEC_ELT (t1, i)); - tree parm2 = TREE_VALUE (TREE_VEC_ELT (t2, i)); - - /* If either of the template parameters are invalid, assume - they match for the sake of error recovery. */ - if (parm1 == error_mark_node || parm2 == error_mark_node) - return 1; - - if (TREE_CODE (parm1) != TREE_CODE (parm2)) - return 0; - - if (TREE_CODE (parm1) == TEMPLATE_TYPE_PARM) - continue; - else if (!same_type_p (TREE_TYPE (parm1), TREE_TYPE (parm2))) - return 0; - } - } - - if ((p1 != NULL_TREE) != (p2 != NULL_TREE)) - /* One set of parameters has more parameters lists than the - other. */ - return 0; - - return 1; -} - -/* Complain if DECL shadows a template parameter. - - [temp.local]: A template-parameter shall not be redeclared within its - scope (including nested scopes). */ - -void -check_template_shadow (tree decl) -{ - tree olddecl; - - /* If we're not in a template, we can't possibly shadow a template - parameter. */ - if (!current_template_parms) - return; - - /* Figure out what we're shadowing. */ - if (TREE_CODE (decl) == OVERLOAD) - decl = OVL_CURRENT (decl); - olddecl = innermost_non_namespace_value (DECL_NAME (decl)); - - /* If there's no previous binding for this name, we're not shadowing - anything, let alone a template parameter. */ - if (!olddecl) - return; - - /* If we're not shadowing a template parameter, we're done. Note - that OLDDECL might be an OVERLOAD (or perhaps even an - ERROR_MARK), so we can't just blithely assume it to be a _DECL - node. */ - if (!DECL_P (olddecl) || !DECL_TEMPLATE_PARM_P (olddecl)) - return; - - /* We check for decl != olddecl to avoid bogus errors for using a - name inside a class. We check TPFI to avoid duplicate errors for - inline member templates. */ - if (decl == olddecl - || TEMPLATE_PARMS_FOR_INLINE (current_template_parms)) - return; - - error ("declaration of %q+#D", decl); - error (" shadows template parm %q+#D", olddecl); -} - -/* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL, - ORIG_LEVEL, DECL, and TYPE. */ - -static tree -build_template_parm_index (int index, - int level, - int orig_level, - tree decl, - tree type) -{ - tree t = make_node (TEMPLATE_PARM_INDEX); - TEMPLATE_PARM_IDX (t) = index; - TEMPLATE_PARM_LEVEL (t) = level; - TEMPLATE_PARM_ORIG_LEVEL (t) = orig_level; - TEMPLATE_PARM_DECL (t) = decl; - TREE_TYPE (t) = type; - TREE_CONSTANT (t) = TREE_CONSTANT (decl); - TREE_INVARIANT (t) = TREE_INVARIANT (decl); - TREE_READONLY (t) = TREE_READONLY (decl); - - return t; -} - -/* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose - TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a - TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a - new one is created. */ - -static tree -reduce_template_parm_level (tree index, tree type, int levels) -{ - if (TEMPLATE_PARM_DESCENDANTS (index) == NULL_TREE - || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index)) - != TEMPLATE_PARM_LEVEL (index) - levels)) - { - tree orig_decl = TEMPLATE_PARM_DECL (index); - tree decl, t; - - decl = build_decl (TREE_CODE (orig_decl), DECL_NAME (orig_decl), type); - TREE_CONSTANT (decl) = TREE_CONSTANT (orig_decl); - TREE_INVARIANT (decl) = TREE_INVARIANT (orig_decl); - TREE_READONLY (decl) = TREE_READONLY (orig_decl); - DECL_ARTIFICIAL (decl) = 1; - SET_DECL_TEMPLATE_PARM_P (decl); - - t = build_template_parm_index (TEMPLATE_PARM_IDX (index), - TEMPLATE_PARM_LEVEL (index) - levels, - TEMPLATE_PARM_ORIG_LEVEL (index), - decl, type); - TEMPLATE_PARM_DESCENDANTS (index) = t; - - /* Template template parameters need this. */ - if (TREE_CODE (decl) != CONST_DECL) - DECL_TEMPLATE_PARMS (decl) - = DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index)); - } - - return TEMPLATE_PARM_DESCENDANTS (index); -} - -/* Process information from new template parameter PARM and append it to the - LIST being built. This new parameter is a non-type parameter iff - IS_NON_TYPE is true. */ - -tree -process_template_parm (tree list, tree parm, bool is_non_type) -{ - tree decl = 0; - tree defval; - tree err_parm_list; - int idx = 0; - - gcc_assert (TREE_CODE (parm) == TREE_LIST); - defval = TREE_PURPOSE (parm); - - if (list) - { - tree p = tree_last (list); - - if (p && TREE_VALUE (p) != error_mark_node) - { - p = TREE_VALUE (p); - if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL) - idx = TEMPLATE_TYPE_IDX (TREE_TYPE (p)); - else - idx = TEMPLATE_PARM_IDX (DECL_INITIAL (p)); - } - - ++idx; - } - else - idx = 0; - - if (is_non_type) - { - parm = TREE_VALUE (parm); - - SET_DECL_TEMPLATE_PARM_P (parm); - - if (TREE_TYPE (parm) == error_mark_node) - { - err_parm_list = build_tree_list (defval, parm); - TREE_VALUE (err_parm_list) = error_mark_node; - return chainon (list, err_parm_list); - } - else - { - /* [temp.param] - - The top-level cv-qualifiers on the template-parameter are - ignored when determining its type. */ - TREE_TYPE (parm) = TYPE_MAIN_VARIANT (TREE_TYPE (parm)); - if (invalid_nontype_parm_type_p (TREE_TYPE (parm), 1)) - { - err_parm_list = build_tree_list (defval, parm); - TREE_VALUE (err_parm_list) = error_mark_node; - return chainon (list, err_parm_list); - } - } - - /* A template parameter is not modifiable. */ - TREE_CONSTANT (parm) = 1; - TREE_INVARIANT (parm) = 1; - TREE_READONLY (parm) = 1; - decl = build_decl (CONST_DECL, DECL_NAME (parm), TREE_TYPE (parm)); - TREE_CONSTANT (decl) = 1; - TREE_INVARIANT (decl) = 1; - TREE_READONLY (decl) = 1; - DECL_INITIAL (parm) = DECL_INITIAL (decl) - = build_template_parm_index (idx, processing_template_decl, - processing_template_decl, - decl, TREE_TYPE (parm)); - } - else - { - tree t; - parm = TREE_VALUE (TREE_VALUE (parm)); - - if (parm && TREE_CODE (parm) == TEMPLATE_DECL) - { - t = make_aggr_type (TEMPLATE_TEMPLATE_PARM); - /* This is for distinguishing between real templates and template - template parameters */ - TREE_TYPE (parm) = t; - TREE_TYPE (DECL_TEMPLATE_RESULT (parm)) = t; - decl = parm; - } - else - { - t = make_aggr_type (TEMPLATE_TYPE_PARM); - /* parm is either IDENTIFIER_NODE or NULL_TREE. */ - decl = build_decl (TYPE_DECL, parm, t); - } - - TYPE_NAME (t) = decl; - TYPE_STUB_DECL (t) = decl; - parm = decl; - TEMPLATE_TYPE_PARM_INDEX (t) - = build_template_parm_index (idx, processing_template_decl, - processing_template_decl, - decl, TREE_TYPE (parm)); - } - DECL_ARTIFICIAL (decl) = 1; - SET_DECL_TEMPLATE_PARM_P (decl); - pushdecl (decl); - parm = build_tree_list (defval, parm); - return chainon (list, parm); -} - -/* The end of a template parameter list has been reached. Process the - tree list into a parameter vector, converting each parameter into a more - useful form. Type parameters are saved as IDENTIFIER_NODEs, and others - as PARM_DECLs. */ - -tree -end_template_parm_list (tree parms) -{ - int nparms; - tree parm, next; - tree saved_parmlist = make_tree_vec (list_length (parms)); - - current_template_parms - = tree_cons (size_int (processing_template_decl), - saved_parmlist, current_template_parms); - - for (parm = parms, nparms = 0; parm; parm = next, nparms++) - { - next = TREE_CHAIN (parm); - TREE_VEC_ELT (saved_parmlist, nparms) = parm; - TREE_CHAIN (parm) = NULL_TREE; - } - - --processing_template_parmlist; - - return saved_parmlist; -} - -/* end_template_decl is called after a template declaration is seen. */ - -void -end_template_decl (void) -{ - reset_specialization (); - - if (! processing_template_decl) - return; - - /* This matches the pushlevel in begin_template_parm_list. */ - finish_scope (); - - --processing_template_decl; - current_template_parms = TREE_CHAIN (current_template_parms); -} - -/* Given a template argument vector containing the template PARMS. - The innermost PARMS are given first. */ - -static tree -current_template_args (void) -{ - tree header; - tree args = NULL_TREE; - int length = TMPL_PARMS_DEPTH (current_template_parms); - int l = length; - - /* If there is only one level of template parameters, we do not - create a TREE_VEC of TREE_VECs. Instead, we return a single - TREE_VEC containing the arguments. */ - if (length > 1) - args = make_tree_vec (length); - - for (header = current_template_parms; header; header = TREE_CHAIN (header)) - { - tree a = copy_node (TREE_VALUE (header)); - int i; - - TREE_TYPE (a) = NULL_TREE; - for (i = TREE_VEC_LENGTH (a) - 1; i >= 0; --i) - { - tree t = TREE_VEC_ELT (a, i); - - /* T will be a list if we are called from within a - begin/end_template_parm_list pair, but a vector directly - if within a begin/end_member_template_processing pair. */ - if (TREE_CODE (t) == TREE_LIST) - { - t = TREE_VALUE (t); - - if (t != error_mark_node) - { - if (TREE_CODE (t) == TYPE_DECL - || TREE_CODE (t) == TEMPLATE_DECL) - t = TREE_TYPE (t); - else - t = DECL_INITIAL (t); - } - - TREE_VEC_ELT (a, i) = t; - } - } - - if (length > 1) - TREE_VEC_ELT (args, --l) = a; - else - args = a; - } - - return args; -} - -/* Return a TEMPLATE_DECL corresponding to DECL, using the indicated - template PARMS. If MEMBER_TEMPLATE_P is true, the new template is - a member template. Used by push_template_decl below. */ - -static tree -build_template_decl (tree decl, tree parms, bool member_template_p) -{ - tree tmpl = build_lang_decl (TEMPLATE_DECL, DECL_NAME (decl), NULL_TREE); - DECL_TEMPLATE_PARMS (tmpl) = parms; - DECL_CONTEXT (tmpl) = DECL_CONTEXT (decl); - DECL_MEMBER_TEMPLATE_P (tmpl) = member_template_p; - if (DECL_LANG_SPECIFIC (decl)) - { - DECL_STATIC_FUNCTION_P (tmpl) = DECL_STATIC_FUNCTION_P (decl); - DECL_CONSTRUCTOR_P (tmpl) = DECL_CONSTRUCTOR_P (decl); - DECL_DESTRUCTOR_P (tmpl) = DECL_DESTRUCTOR_P (decl); - DECL_NONCONVERTING_P (tmpl) = DECL_NONCONVERTING_P (decl); - DECL_ASSIGNMENT_OPERATOR_P (tmpl) = DECL_ASSIGNMENT_OPERATOR_P (decl); - if (DECL_OVERLOADED_OPERATOR_P (decl)) - SET_OVERLOADED_OPERATOR_CODE (tmpl, - DECL_OVERLOADED_OPERATOR_P (decl)); - } - - return tmpl; -} - -struct template_parm_data -{ - /* The level of the template parameters we are currently - processing. */ - int level; - - /* The index of the specialization argument we are currently - processing. */ - int current_arg; - - /* An array whose size is the number of template parameters. The - elements are nonzero if the parameter has been used in any one - of the arguments processed so far. */ - int* parms; - - /* An array whose size is the number of template arguments. The - elements are nonzero if the argument makes use of template - parameters of this level. */ - int* arg_uses_template_parms; -}; - -/* Subroutine of push_template_decl used to see if each template - parameter in a partial specialization is used in the explicit - argument list. If T is of the LEVEL given in DATA (which is - treated as a template_parm_data*), then DATA->PARMS is marked - appropriately. */ - -static int -mark_template_parm (tree t, void* data) -{ - int level; - int idx; - struct template_parm_data* tpd = (struct template_parm_data*) data; - - if (TREE_CODE (t) == TEMPLATE_PARM_INDEX) - { - level = TEMPLATE_PARM_LEVEL (t); - idx = TEMPLATE_PARM_IDX (t); - } - else - { - level = TEMPLATE_TYPE_LEVEL (t); - idx = TEMPLATE_TYPE_IDX (t); - } - - if (level == tpd->level) - { - tpd->parms[idx] = 1; - tpd->arg_uses_template_parms[tpd->current_arg] = 1; - } - - /* Return zero so that for_each_template_parm will continue the - traversal of the tree; we want to mark *every* template parm. */ - return 0; -} - -/* Process the partial specialization DECL. */ - -static tree -process_partial_specialization (tree decl) -{ - tree type = TREE_TYPE (decl); - tree maintmpl = CLASSTYPE_TI_TEMPLATE (type); - tree specargs = CLASSTYPE_TI_ARGS (type); - tree inner_args = INNERMOST_TEMPLATE_ARGS (specargs); - tree inner_parms = INNERMOST_TEMPLATE_PARMS (current_template_parms); - tree main_inner_parms = DECL_INNERMOST_TEMPLATE_PARMS (maintmpl); - int nargs = TREE_VEC_LENGTH (inner_args); - int ntparms = TREE_VEC_LENGTH (inner_parms); - int i; - int did_error_intro = 0; - struct template_parm_data tpd; - struct template_parm_data tpd2; - - /* We check that each of the template parameters given in the - partial specialization is used in the argument list to the - specialization. For example: - - template <class T> struct S; - template <class T> struct S<T*>; - - The second declaration is OK because `T*' uses the template - parameter T, whereas - - template <class T> struct S<int>; - - is no good. Even trickier is: - - template <class T> - struct S1 - { - template <class U> - struct S2; - template <class U> - struct S2<T>; - }; - - The S2<T> declaration is actually invalid; it is a - full-specialization. Of course, - - template <class U> - struct S2<T (*)(U)>; - - or some such would have been OK. */ - tpd.level = TMPL_PARMS_DEPTH (current_template_parms); - tpd.parms = (int *) alloca (sizeof (int) * ntparms); - memset (tpd.parms, 0, sizeof (int) * ntparms); - - tpd.arg_uses_template_parms = (int *) alloca (sizeof (int) * nargs); - memset (tpd.arg_uses_template_parms, 0, sizeof (int) * nargs); - for (i = 0; i < nargs; ++i) - { - tpd.current_arg = i; - for_each_template_parm (TREE_VEC_ELT (inner_args, i), - &mark_template_parm, - &tpd, - NULL); - } - for (i = 0; i < ntparms; ++i) - if (tpd.parms[i] == 0) - { - /* One of the template parms was not used in the - specialization. */ - if (!did_error_intro) - { - error ("template parameters not used in partial specialization:"); - did_error_intro = 1; - } - - error (" %qD", TREE_VALUE (TREE_VEC_ELT (inner_parms, i))); - } - - /* [temp.class.spec] - - The argument list of the specialization shall not be identical to - the implicit argument list of the primary template. */ - if (comp_template_args - (inner_args, - INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE - (maintmpl))))) - error ("partial specialization %qT does not specialize any template arguments", type); - - /* [temp.class.spec] - - A partially specialized non-type argument expression shall not - involve template parameters of the partial specialization except - when the argument expression is a simple identifier. - - The type of a template parameter corresponding to a specialized - non-type argument shall not be dependent on a parameter of the - specialization. */ - gcc_assert (nargs == DECL_NTPARMS (maintmpl)); - tpd2.parms = 0; - for (i = 0; i < nargs; ++i) - { - tree arg = TREE_VEC_ELT (inner_args, i); - if (/* These first two lines are the `non-type' bit. */ - !TYPE_P (arg) - && TREE_CODE (arg) != TEMPLATE_DECL - /* This next line is the `argument expression is not just a - simple identifier' condition and also the `specialized - non-type argument' bit. */ - && TREE_CODE (arg) != TEMPLATE_PARM_INDEX) - { - if (tpd.arg_uses_template_parms[i]) - error ("template argument %qE involves template parameter(s)", arg); - else - { - /* Look at the corresponding template parameter, - marking which template parameters its type depends - upon. */ - tree type = - TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (main_inner_parms, - i))); - - if (!tpd2.parms) - { - /* We haven't yet initialized TPD2. Do so now. */ - tpd2.arg_uses_template_parms - = (int *) alloca (sizeof (int) * nargs); - /* The number of parameters here is the number in the - main template, which, as checked in the assertion - above, is NARGS. */ - tpd2.parms = (int *) alloca (sizeof (int) * nargs); - tpd2.level = - TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl)); - } - - /* Mark the template parameters. But this time, we're - looking for the template parameters of the main - template, not in the specialization. */ - tpd2.current_arg = i; - tpd2.arg_uses_template_parms[i] = 0; - memset (tpd2.parms, 0, sizeof (int) * nargs); - for_each_template_parm (type, - &mark_template_parm, - &tpd2, - NULL); - - if (tpd2.arg_uses_template_parms [i]) - { - /* The type depended on some template parameters. - If they are fully specialized in the - specialization, that's OK. */ - int j; - for (j = 0; j < nargs; ++j) - if (tpd2.parms[j] != 0 - && tpd.arg_uses_template_parms [j]) - { - error ("type %qT of template argument %qE depends " - "on template parameter(s)", - type, - arg); - break; - } - } - } - } - } - - if (retrieve_specialization (maintmpl, specargs, - /*class_specializations_p=*/true)) - /* We've already got this specialization. */ - return decl; - - DECL_TEMPLATE_SPECIALIZATIONS (maintmpl) - = tree_cons (specargs, inner_parms, - DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)); - TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)) = type; - return decl; -} - -/* Check that a template declaration's use of default arguments is not - invalid. Here, PARMS are the template parameters. IS_PRIMARY is - nonzero if DECL is the thing declared by a primary template. - IS_PARTIAL is nonzero if DECL is a partial specialization. */ - -static void -check_default_tmpl_args (tree decl, tree parms, int is_primary, int is_partial) -{ - const char *msg; - int last_level_to_check; - tree parm_level; - - /* [temp.param] - - A default template-argument shall not be specified in a - function template declaration or a function template definition, nor - in the template-parameter-list of the definition of a member of a - class template. */ - - if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL) - /* You can't have a function template declaration in a local - scope, nor you can you define a member of a class template in a - local scope. */ - return; - - if (current_class_type - && !TYPE_BEING_DEFINED (current_class_type) - && DECL_LANG_SPECIFIC (decl) - /* If this is either a friend defined in the scope of the class - or a member function. */ - && (DECL_FUNCTION_MEMBER_P (decl) - ? same_type_p (DECL_CONTEXT (decl), current_class_type) - : DECL_FRIEND_CONTEXT (decl) - ? same_type_p (DECL_FRIEND_CONTEXT (decl), current_class_type) - : false) - /* And, if it was a member function, it really was defined in - the scope of the class. */ - && (!DECL_FUNCTION_MEMBER_P (decl) - || DECL_INITIALIZED_IN_CLASS_P (decl))) - /* We already checked these parameters when the template was - declared, so there's no need to do it again now. This function - was defined in class scope, but we're processing it's body now - that the class is complete. */ - return; - - /* [temp.param] - - If a template-parameter has a default template-argument, all - subsequent template-parameters shall have a default - template-argument supplied. */ - for (parm_level = parms; parm_level; parm_level = TREE_CHAIN (parm_level)) - { - tree inner_parms = TREE_VALUE (parm_level); - int ntparms = TREE_VEC_LENGTH (inner_parms); - int seen_def_arg_p = 0; - int i; - - for (i = 0; i < ntparms; ++i) - { - tree parm = TREE_VEC_ELT (inner_parms, i); - - if (parm == error_mark_node) - continue; - - if (TREE_PURPOSE (parm)) - seen_def_arg_p = 1; - else if (seen_def_arg_p) - { - error ("no default argument for %qD", TREE_VALUE (parm)); - /* For better subsequent error-recovery, we indicate that - there should have been a default argument. */ - TREE_PURPOSE (parm) = error_mark_node; - } - } - } - - if (TREE_CODE (decl) != TYPE_DECL || is_partial || !is_primary) - /* For an ordinary class template, default template arguments are - allowed at the innermost level, e.g.: - template <class T = int> - struct S {}; - but, in a partial specialization, they're not allowed even - there, as we have in [temp.class.spec]: - - The template parameter list of a specialization shall not - contain default template argument values. - - So, for a partial specialization, or for a function template, - we look at all of them. */ - ; - else - /* But, for a primary class template that is not a partial - specialization we look at all template parameters except the - innermost ones. */ - parms = TREE_CHAIN (parms); - - /* Figure out what error message to issue. */ - if (TREE_CODE (decl) == FUNCTION_DECL) - msg = "default template arguments may not be used in function templates"; - else if (is_partial) - msg = "default template arguments may not be used in partial specializations"; - else - msg = "default argument for template parameter for class enclosing %qD"; - - if (current_class_type && TYPE_BEING_DEFINED (current_class_type)) - /* If we're inside a class definition, there's no need to - examine the parameters to the class itself. On the one - hand, they will be checked when the class is defined, and, - on the other, default arguments are valid in things like: - template <class T = double> - struct S { template <class U> void f(U); }; - Here the default argument for `S' has no bearing on the - declaration of `f'. */ - last_level_to_check = template_class_depth (current_class_type) + 1; - else - /* Check everything. */ - last_level_to_check = 0; - - for (parm_level = parms; - parm_level && TMPL_PARMS_DEPTH (parm_level) >= last_level_to_check; - parm_level = TREE_CHAIN (parm_level)) - { - tree inner_parms = TREE_VALUE (parm_level); - int i; - int ntparms; - - ntparms = TREE_VEC_LENGTH (inner_parms); - for (i = 0; i < ntparms; ++i) - { - if (TREE_VEC_ELT (inner_parms, i) == error_mark_node) - continue; - - if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i))) - { - if (msg) - { - error (msg, decl); - msg = 0; - } - - /* Clear out the default argument so that we are not - confused later. */ - TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)) = NULL_TREE; - } - } - - /* At this point, if we're still interested in issuing messages, - they must apply to classes surrounding the object declared. */ - if (msg) - msg = "default argument for template parameter for class enclosing %qD"; - } -} - -/* Worker for push_template_decl_real, called via - for_each_template_parm. DATA is really an int, indicating the - level of the parameters we are interested in. If T is a template - parameter of that level, return nonzero. */ - -static int -template_parm_this_level_p (tree t, void* data) -{ - int this_level = *(int *)data; - int level; - - if (TREE_CODE (t) == TEMPLATE_PARM_INDEX) - level = TEMPLATE_PARM_LEVEL (t); - else - level = TEMPLATE_TYPE_LEVEL (t); - return level == this_level; -} - -/* Creates a TEMPLATE_DECL for the indicated DECL using the template - parameters given by current_template_args, or reuses a - previously existing one, if appropriate. Returns the DECL, or an - equivalent one, if it is replaced via a call to duplicate_decls. - - If IS_FRIEND is true, DECL is a friend declaration. */ - -tree -push_template_decl_real (tree decl, bool is_friend) -{ - tree tmpl; - tree args; - tree info; - tree ctx; - int primary; - int is_partial; - int new_template_p = 0; - /* True if the template is a member template, in the sense of - [temp.mem]. */ - bool member_template_p = false; - - if (decl == error_mark_node) - return decl; - - /* See if this is a partial specialization. */ - is_partial = (DECL_IMPLICIT_TYPEDEF_P (decl) - && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE - && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl))); - - if (TREE_CODE (decl) == FUNCTION_DECL && DECL_FRIEND_P (decl)) - is_friend = true; - - if (is_friend) - /* For a friend, we want the context of the friend function, not - the type of which it is a friend. */ - ctx = DECL_CONTEXT (decl); - else if (CP_DECL_CONTEXT (decl) - && TREE_CODE (CP_DECL_CONTEXT (decl)) != NAMESPACE_DECL) - /* In the case of a virtual function, we want the class in which - it is defined. */ - ctx = CP_DECL_CONTEXT (decl); - else - /* Otherwise, if we're currently defining some class, the DECL - is assumed to be a member of the class. */ - ctx = current_scope (); - - if (ctx && TREE_CODE (ctx) == NAMESPACE_DECL) - ctx = NULL_TREE; - - if (!DECL_CONTEXT (decl)) - DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace); - - /* See if this is a primary template. */ - if (is_friend && ctx) - /* A friend template that specifies a class context, i.e. - template <typename T> friend void A<T>::f(); - is not primary. */ - primary = 0; - else - primary = template_parm_scope_p (); - - if (primary) - { - if (DECL_CLASS_SCOPE_P (decl)) - member_template_p = true; - if (TREE_CODE (decl) == TYPE_DECL - && ANON_AGGRNAME_P (DECL_NAME (decl))) - error ("template class without a name"); - else if (TREE_CODE (decl) == FUNCTION_DECL) - { - if (DECL_DESTRUCTOR_P (decl)) - { - /* [temp.mem] - - A destructor shall not be a member template. */ - error ("destructor %qD declared as member template", decl); - return error_mark_node; - } - if (NEW_DELETE_OPNAME_P (DECL_NAME (decl)) - && (!TYPE_ARG_TYPES (TREE_TYPE (decl)) - || TYPE_ARG_TYPES (TREE_TYPE (decl)) == void_list_node - || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl))) - || (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl)))) - == void_list_node))) - { - /* [basic.stc.dynamic.allocation] - - An allocation function can be a function - template. ... Template allocation functions shall - have two or more parameters. */ - error ("invalid template declaration of %qD", decl); - return error_mark_node; - } - } - else if (DECL_IMPLICIT_TYPEDEF_P (decl) - && CLASS_TYPE_P (TREE_TYPE (decl))) - /* OK */; - else - { - error ("template declaration of %q#D", decl); - return error_mark_node; - } - } - - /* Check to see that the rules regarding the use of default - arguments are not being violated. */ - check_default_tmpl_args (decl, current_template_parms, - primary, is_partial); - - if (is_partial) - return process_partial_specialization (decl); - - args = current_template_args (); - - if (!ctx - || TREE_CODE (ctx) == FUNCTION_DECL - || (CLASS_TYPE_P (ctx) && TYPE_BEING_DEFINED (ctx)) - || (is_friend && !DECL_TEMPLATE_INFO (decl))) - { - if (DECL_LANG_SPECIFIC (decl) - && DECL_TEMPLATE_INFO (decl) - && DECL_TI_TEMPLATE (decl)) - tmpl = DECL_TI_TEMPLATE (decl); - /* If DECL is a TYPE_DECL for a class-template, then there won't - be DECL_LANG_SPECIFIC. The information equivalent to - DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */ - else if (DECL_IMPLICIT_TYPEDEF_P (decl) - && TYPE_TEMPLATE_INFO (TREE_TYPE (decl)) - && TYPE_TI_TEMPLATE (TREE_TYPE (decl))) - { - /* Since a template declaration already existed for this - class-type, we must be redeclaring it here. Make sure - that the redeclaration is valid. */ - redeclare_class_template (TREE_TYPE (decl), - current_template_parms); - /* We don't need to create a new TEMPLATE_DECL; just use the - one we already had. */ - tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl)); - } - else - { - tmpl = build_template_decl (decl, current_template_parms, - member_template_p); - new_template_p = 1; - - if (DECL_LANG_SPECIFIC (decl) - && DECL_TEMPLATE_SPECIALIZATION (decl)) - { - /* A specialization of a member template of a template - class. */ - SET_DECL_TEMPLATE_SPECIALIZATION (tmpl); - DECL_TEMPLATE_INFO (tmpl) = DECL_TEMPLATE_INFO (decl); - DECL_TEMPLATE_INFO (decl) = NULL_TREE; - } - } - } - else - { - tree a, t, current, parms; - int i; - - if (TREE_CODE (decl) == TYPE_DECL) - { - if ((IS_AGGR_TYPE_CODE (TREE_CODE (TREE_TYPE (decl))) - || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE) - && TYPE_TEMPLATE_INFO (TREE_TYPE (decl)) - && TYPE_TI_TEMPLATE (TREE_TYPE (decl))) - tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl)); - else - { - error ("%qD does not declare a template type", decl); - return decl; - } - } - else if (!DECL_LANG_SPECIFIC (decl) || !DECL_TEMPLATE_INFO (decl)) - { - error ("template definition of non-template %q#D", decl); - return decl; - } - else - tmpl = DECL_TI_TEMPLATE (decl); - - if (DECL_FUNCTION_TEMPLATE_P (tmpl) - && DECL_TEMPLATE_INFO (decl) && DECL_TI_ARGS (decl) - && DECL_TEMPLATE_SPECIALIZATION (decl) - && DECL_MEMBER_TEMPLATE_P (tmpl)) - { - tree new_tmpl; - - /* The declaration is a specialization of a member - template, declared outside the class. Therefore, the - innermost template arguments will be NULL, so we - replace them with the arguments determined by the - earlier call to check_explicit_specialization. */ - args = DECL_TI_ARGS (decl); - - new_tmpl - = build_template_decl (decl, current_template_parms, - member_template_p); - DECL_TEMPLATE_RESULT (new_tmpl) = decl; - TREE_TYPE (new_tmpl) = TREE_TYPE (decl); - DECL_TI_TEMPLATE (decl) = new_tmpl; - SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl); - DECL_TEMPLATE_INFO (new_tmpl) - = tree_cons (tmpl, args, NULL_TREE); - - register_specialization (new_tmpl, - most_general_template (tmpl), - args, - is_friend); - return decl; - } - - /* Make sure the template headers we got make sense. */ - - parms = DECL_TEMPLATE_PARMS (tmpl); - i = TMPL_PARMS_DEPTH (parms); - if (TMPL_ARGS_DEPTH (args) != i) - { - error ("expected %d levels of template parms for %q#D, got %d", - i, decl, TMPL_ARGS_DEPTH (args)); - } - else - for (current = decl; i > 0; --i, parms = TREE_CHAIN (parms)) - { - a = TMPL_ARGS_LEVEL (args, i); - t = INNERMOST_TEMPLATE_PARMS (parms); - - if (TREE_VEC_LENGTH (t) != TREE_VEC_LENGTH (a)) - { - if (current == decl) - error ("got %d template parameters for %q#D", - TREE_VEC_LENGTH (a), decl); - else - error ("got %d template parameters for %q#T", - TREE_VEC_LENGTH (a), current); - error (" but %d required", TREE_VEC_LENGTH (t)); - return error_mark_node; - } - - /* Perhaps we should also check that the parms are used in the - appropriate qualifying scopes in the declarator? */ - - if (current == decl) - current = ctx; - else - current = TYPE_CONTEXT (current); - } - } - - DECL_TEMPLATE_RESULT (tmpl) = decl; - TREE_TYPE (tmpl) = TREE_TYPE (decl); - - /* Push template declarations for global functions and types. Note - that we do not try to push a global template friend declared in a - template class; such a thing may well depend on the template - parameters of the class. */ - if (new_template_p && !ctx - && !(is_friend && template_class_depth (current_class_type) > 0)) - { - tmpl = pushdecl_namespace_level (tmpl, is_friend); - if (tmpl == error_mark_node) - return error_mark_node; - - /* Hide template friend classes that haven't been declared yet. */ - if (is_friend && TREE_CODE (decl) == TYPE_DECL) - { - DECL_ANTICIPATED (tmpl) = 1; - DECL_FRIEND_P (tmpl) = 1; - } - } - - if (primary) - { - DECL_PRIMARY_TEMPLATE (tmpl) = tmpl; - if (DECL_CONV_FN_P (tmpl)) - { - int depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)); - - /* It is a conversion operator. See if the type converted to - depends on innermost template operands. */ - - if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl)), - depth)) - DECL_TEMPLATE_CONV_FN_P (tmpl) = 1; - } - } - - /* The DECL_TI_ARGS of DECL contains full set of arguments referring - back to its most general template. If TMPL is a specialization, - ARGS may only have the innermost set of arguments. Add the missing - argument levels if necessary. */ - if (DECL_TEMPLATE_INFO (tmpl)) - args = add_outermost_template_args (DECL_TI_ARGS (tmpl), args); - - info = tree_cons (tmpl, args, NULL_TREE); - - if (DECL_IMPLICIT_TYPEDEF_P (decl)) - { - SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl), info); - if ((!ctx || TREE_CODE (ctx) != FUNCTION_DECL) - && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE - /* Don't change the name if we've already set it up. */ - && !IDENTIFIER_TEMPLATE (DECL_NAME (decl))) - DECL_NAME (decl) = classtype_mangled_name (TREE_TYPE (decl)); - } - else if (DECL_LANG_SPECIFIC (decl)) - DECL_TEMPLATE_INFO (decl) = info; - - return DECL_TEMPLATE_RESULT (tmpl); -} - -tree -push_template_decl (tree decl) -{ - return push_template_decl_real (decl, false); -} - -/* Called when a class template TYPE is redeclared with the indicated - template PARMS, e.g.: - - template <class T> struct S; - template <class T> struct S {}; */ - -bool -redeclare_class_template (tree type, tree parms) -{ - tree tmpl; - tree tmpl_parms; - int i; - - if (!TYPE_TEMPLATE_INFO (type)) - { - error ("%qT is not a template type", type); - return false; - } - - tmpl = TYPE_TI_TEMPLATE (type); - if (!PRIMARY_TEMPLATE_P (tmpl)) - /* The type is nested in some template class. Nothing to worry - about here; there are no new template parameters for the nested - type. */ - return true; - - if (!parms) - { - error ("template specifiers not specified in declaration of %qD", - tmpl); - return false; - } - - parms = INNERMOST_TEMPLATE_PARMS (parms); - tmpl_parms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl); - - if (TREE_VEC_LENGTH (parms) != TREE_VEC_LENGTH (tmpl_parms)) - { - error ("previous declaration %q+D", tmpl); - error ("used %d template parameter(s) instead of %d", - TREE_VEC_LENGTH (tmpl_parms), - TREE_VEC_LENGTH (parms)); - return false; - } - - for (i = 0; i < TREE_VEC_LENGTH (tmpl_parms); ++i) - { - tree tmpl_parm; - tree parm; - tree tmpl_default; - tree parm_default; - - if (TREE_VEC_ELT (tmpl_parms, i) == error_mark_node - || TREE_VEC_ELT (parms, i) == error_mark_node) - continue; - - tmpl_parm = TREE_VALUE (TREE_VEC_ELT (tmpl_parms, i)); - parm = TREE_VALUE (TREE_VEC_ELT (parms, i)); - tmpl_default = TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i)); - parm_default = TREE_PURPOSE (TREE_VEC_ELT (parms, i)); - - /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or - TEMPLATE_DECL. */ - if (tmpl_parm != error_mark_node - && (TREE_CODE (tmpl_parm) != TREE_CODE (parm) - || (TREE_CODE (tmpl_parm) != TYPE_DECL - && !same_type_p (TREE_TYPE (tmpl_parm), TREE_TYPE (parm))))) - { - error ("template parameter %q+#D", tmpl_parm); - error ("redeclared here as %q#D", parm); - return false; - } - - if (tmpl_default != NULL_TREE && parm_default != NULL_TREE) - { - /* We have in [temp.param]: - - A template-parameter may not be given default arguments - by two different declarations in the same scope. */ - error ("redefinition of default argument for %q#D", parm); - error ("%J original definition appeared here", tmpl_parm); - return false; - } - - if (parm_default != NULL_TREE) - /* Update the previous template parameters (which are the ones - that will really count) with the new default value. */ - TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i)) = parm_default; - else if (tmpl_default != NULL_TREE) - /* Update the new parameters, too; they'll be used as the - parameters for any members. */ - TREE_PURPOSE (TREE_VEC_ELT (parms, i)) = tmpl_default; - } - - return true; -} - -/* Simplify EXPR if it is a non-dependent expression. Returns the - (possibly simplified) expression. */ - -tree -fold_non_dependent_expr (tree expr) -{ - if (expr == NULL_TREE) - return NULL_TREE; - - /* If we're in a template, but EXPR isn't value dependent, simplify - it. We're supposed to treat: - - template <typename T> void f(T[1 + 1]); - template <typename T> void f(T[2]); - - as two declarations of the same function, for example. */ - if (processing_template_decl - && !type_dependent_expression_p (expr) - && !value_dependent_expression_p (expr)) - { - HOST_WIDE_INT saved_processing_template_decl; - - saved_processing_template_decl = processing_template_decl; - processing_template_decl = 0; - expr = tsubst_copy_and_build (expr, - /*args=*/NULL_TREE, - tf_error, - /*in_decl=*/NULL_TREE, - /*function_p=*/false, - /*integral_constant_expression_p=*/true); - processing_template_decl = saved_processing_template_decl; - } - return expr; -} - -/* EXPR is an expression which is used in a constant-expression context. - For instance, it could be a VAR_DECL with a constant initializer. - Extract the innest constant expression. - - This is basically a more powerful version of - integral_constant_value, which can be used also in templates where - initializers can maintain a syntactic rather than semantic form - (even if they are non-dependent, for access-checking purposes). */ - -static tree -fold_decl_constant_value (tree expr) -{ - tree const_expr = expr; - do - { - expr = fold_non_dependent_expr (const_expr); - const_expr = integral_constant_value (expr); - } - while (expr != const_expr); - - return expr; -} - -/* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which - must be a function or a pointer-to-function type, as specified - in [temp.arg.nontype]: disambiguate EXPR if it is an overload set, - and check that the resulting function has external linkage. */ - -static tree -convert_nontype_argument_function (tree type, tree expr) -{ - tree fns = expr; - tree fn, fn_no_ptr; - - fn = instantiate_type (type, fns, tf_none); - if (fn == error_mark_node) - return error_mark_node; - - fn_no_ptr = fn; - if (TREE_CODE (fn_no_ptr) == ADDR_EXPR) - fn_no_ptr = TREE_OPERAND (fn_no_ptr, 0); - if (TREE_CODE (fn_no_ptr) == BASELINK) - fn_no_ptr = BASELINK_FUNCTIONS (fn_no_ptr); - - /* [temp.arg.nontype]/1 - - A template-argument for a non-type, non-template template-parameter - shall be one of: - [...] - -- the address of an object or function with external linkage. */ - if (!DECL_EXTERNAL_LINKAGE_P (fn_no_ptr)) - { - error ("%qE is not a valid template argument for type %qT " - "because function %qD has not external linkage", - expr, type, fn_no_ptr); - return NULL_TREE; - } - - return fn; -} - -/* Attempt to convert the non-type template parameter EXPR to the - indicated TYPE. If the conversion is successful, return the - converted value. If the conversion is unsuccessful, return - NULL_TREE if we issued an error message, or error_mark_node if we - did not. We issue error messages for out-and-out bad template - parameters, but not simply because the conversion failed, since we - might be just trying to do argument deduction. Both TYPE and EXPR - must be non-dependent. - - The conversion follows the special rules described in - [temp.arg.nontype], and it is much more strict than an implicit - conversion. - - This function is called twice for each template argument (see - lookup_template_class for a more accurate description of this - problem). This means that we need to handle expressions which - are not valid in a C++ source, but can be created from the - first call (for instance, casts to perform conversions). These - hacks can go away after we fix the double coercion problem. */ - -static tree -convert_nontype_argument (tree type, tree expr) -{ - tree expr_type; - - /* Detect immediately string literals as invalid non-type argument. - This special-case is not needed for correctness (we would easily - catch this later), but only to provide better diagnostic for this - common user mistake. As suggested by DR 100, we do not mention - linkage issues in the diagnostic as this is not the point. */ - if (TREE_CODE (expr) == STRING_CST) - { - error ("%qE is not a valid template argument for type %qT " - "because string literals can never be used in this context", - expr, type); - return NULL_TREE; - } - - /* If we are in a template, EXPR may be non-dependent, but still - have a syntactic, rather than semantic, form. For example, EXPR - might be a SCOPE_REF, rather than the VAR_DECL to which the - SCOPE_REF refers. Preserving the qualifying scope is necessary - so that access checking can be performed when the template is - instantiated -- but here we need the resolved form so that we can - convert the argument. */ - expr = fold_non_dependent_expr (expr); - if (error_operand_p (expr)) - return error_mark_node; - expr_type = TREE_TYPE (expr); - - /* HACK: Due to double coercion, we can get a - NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here, - which is the tree that we built on the first call (see - below when coercing to reference to object or to reference to - function). We just strip everything and get to the arg. - See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C - for examples. */ - if (TREE_CODE (expr) == NOP_EXPR) - { - if (TYPE_REF_OBJ_P (type) || TYPE_REFFN_P (type)) - { - /* ??? Maybe we could use convert_from_reference here, but we - would need to relax its constraints because the NOP_EXPR - could actually change the type to something more cv-qualified, - and this is not folded by convert_from_reference. */ - tree addr = TREE_OPERAND (expr, 0); - gcc_assert (TREE_CODE (expr_type) == REFERENCE_TYPE); - gcc_assert (TREE_CODE (addr) == ADDR_EXPR); - gcc_assert (TREE_CODE (TREE_TYPE (addr)) == POINTER_TYPE); - gcc_assert (same_type_ignoring_top_level_qualifiers_p - (TREE_TYPE (expr_type), - TREE_TYPE (TREE_TYPE (addr)))); - - expr = TREE_OPERAND (addr, 0); - expr_type = TREE_TYPE (expr); - } - - /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the - parameter is a pointer to object, through decay and - qualification conversion. Let's strip everything. */ - else if (TYPE_PTROBV_P (type)) - { - STRIP_NOPS (expr); - gcc_assert (TREE_CODE (expr) == ADDR_EXPR); - gcc_assert (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE); - /* Skip the ADDR_EXPR only if it is part of the decay for - an array. Otherwise, it is part of the original argument - in the source code. */ - if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == ARRAY_TYPE) - expr = TREE_OPERAND (expr, 0); - expr_type = TREE_TYPE (expr); - } - } - - /* [temp.arg.nontype]/5, bullet 1 - - For a non-type template-parameter of integral or enumeration type, - integral promotions (_conv.prom_) and integral conversions - (_conv.integral_) are applied. */ - if (INTEGRAL_TYPE_P (type)) - { - if (!INTEGRAL_TYPE_P (expr_type)) - return error_mark_node; - - expr = fold_decl_constant_value (expr); - /* Notice that there are constant expressions like '4 % 0' which - do not fold into integer constants. */ - if (TREE_CODE (expr) != INTEGER_CST) - { - error ("%qE is not a valid template argument for type %qT " - "because it is a non-constant expression", expr, type); - return NULL_TREE; - } - - /* At this point, an implicit conversion does what we want, - because we already know that the expression is of integral - type. */ - expr = ocp_convert (type, expr, CONV_IMPLICIT, LOOKUP_PROTECT); - if (expr == error_mark_node) - return error_mark_node; - - /* Conversion was allowed: fold it to a bare integer constant. */ - expr = fold (expr); - } - /* [temp.arg.nontype]/5, bullet 2 - - For a non-type template-parameter of type pointer to object, - qualification conversions (_conv.qual_) and the array-to-pointer - conversion (_conv.array_) are applied. */ - else if (TYPE_PTROBV_P (type)) - { - /* [temp.arg.nontype]/1 (TC1 version, DR 49): - - A template-argument for a non-type, non-template template-parameter - shall be one of: [...] - - -- the name of a non-type template-parameter; - -- the address of an object or function with external linkage, [...] - expressed as "& id-expression" where the & is optional if the name - refers to a function or array, or if the corresponding - template-parameter is a reference. - - Here, we do not care about functions, as they are invalid anyway - for a parameter of type pointer-to-object. */ - - if (DECL_P (expr) && DECL_TEMPLATE_PARM_P (expr)) - /* Non-type template parameters are OK. */ - ; - else if (TREE_CODE (expr) != ADDR_EXPR - && TREE_CODE (expr_type) != ARRAY_TYPE) - { - if (TREE_CODE (expr) == VAR_DECL) - { - error ("%qD is not a valid template argument " - "because %qD is a variable, not the address of " - "a variable", - expr, expr); - return NULL_TREE; - } - /* Other values, like integer constants, might be valid - non-type arguments of some other type. */ - return error_mark_node; - } - else - { - tree decl; - - decl = ((TREE_CODE (expr) == ADDR_EXPR) - ? TREE_OPERAND (expr, 0) : expr); - if (TREE_CODE (decl) != VAR_DECL) - { - error ("%qE is not a valid template argument of type %qT " - "because %qE is not a variable", - expr, type, decl); - return NULL_TREE; - } - else if (!DECL_EXTERNAL_LINKAGE_P (decl)) - { - error ("%qE is not a valid template argument of type %qT " - "because %qD does not have external linkage", - expr, type, decl); - return NULL_TREE; - } - } - - expr = decay_conversion (expr); - if (expr == error_mark_node) - return error_mark_node; - - expr = perform_qualification_conversions (type, expr); - if (expr == error_mark_node) - return error_mark_node; - } - /* [temp.arg.nontype]/5, bullet 3 - - For a non-type template-parameter of type reference to object, no - conversions apply. The type referred to by the reference may be more - cv-qualified than the (otherwise identical) type of the - template-argument. The template-parameter is bound directly to the - template-argument, which must be an lvalue. */ - else if (TYPE_REF_OBJ_P (type)) - { - if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type), - expr_type)) - return error_mark_node; - - if (!at_least_as_qualified_p (TREE_TYPE (type), expr_type)) - { - error ("%qE is not a valid template argument for type %qT " - "because of conflicts in cv-qualification", expr, type); - return NULL_TREE; - } - - if (!real_lvalue_p (expr)) - { - error ("%qE is not a valid template argument for type %qT " - "because it is not an lvalue", expr, type); - return NULL_TREE; - } - - /* [temp.arg.nontype]/1 - - A template-argument for a non-type, non-template template-parameter - shall be one of: [...] - - -- the address of an object or function with external linkage. */ - if (!DECL_EXTERNAL_LINKAGE_P (expr)) - { - error ("%qE is not a valid template argument for type %qT " - "because object %qD has not external linkage", - expr, type, expr); - return NULL_TREE; - } - - expr = build_nop (type, build_address (expr)); - } - /* [temp.arg.nontype]/5, bullet 4 - - For a non-type template-parameter of type pointer to function, only - the function-to-pointer conversion (_conv.func_) is applied. If the - template-argument represents a set of overloaded functions (or a - pointer to such), the matching function is selected from the set - (_over.over_). */ - else if (TYPE_PTRFN_P (type)) - { - /* If the argument is a template-id, we might not have enough - context information to decay the pointer. */ - if (!type_unknown_p (expr_type)) - { - expr = decay_conversion (expr); - if (expr == error_mark_node) - return error_mark_node; - } - - expr = convert_nontype_argument_function (type, expr); - if (!expr || expr == error_mark_node) - return expr; - } - /* [temp.arg.nontype]/5, bullet 5 - - For a non-type template-parameter of type reference to function, no - conversions apply. If the template-argument represents a set of - overloaded functions, the matching function is selected from the set - (_over.over_). */ - else if (TYPE_REFFN_P (type)) - { - if (TREE_CODE (expr) == ADDR_EXPR) - { - error ("%qE is not a valid template argument for type %qT " - "because it is a pointer", expr, type); - inform ("try using %qE instead", TREE_OPERAND (expr, 0)); - return NULL_TREE; - } - - expr = convert_nontype_argument_function (TREE_TYPE (type), expr); - if (!expr || expr == error_mark_node) - return expr; - - expr = build_nop (type, build_address (expr)); - } - /* [temp.arg.nontype]/5, bullet 6 - - For a non-type template-parameter of type pointer to member function, - no conversions apply. If the template-argument represents a set of - overloaded member functions, the matching member function is selected - from the set (_over.over_). */ - else if (TYPE_PTRMEMFUNC_P (type)) - { - expr = instantiate_type (type, expr, tf_none); - if (expr == error_mark_node) - return error_mark_node; - - /* There is no way to disable standard conversions in - resolve_address_of_overloaded_function (called by - instantiate_type). It is possible that the call succeeded by - converting &B::I to &D::I (where B is a base of D), so we need - to reject this conversion here. - - Actually, even if there was a way to disable standard conversions, - it would still be better to reject them here so that we can - provide a superior diagnostic. */ - if (!same_type_p (TREE_TYPE (expr), type)) - { - /* Make sure we are just one standard conversion off. */ - gcc_assert (can_convert (type, TREE_TYPE (expr))); - error ("%qE is not a valid template argument for type %qT " - "because it is of type %qT", expr, type, - TREE_TYPE (expr)); - inform ("standard conversions are not allowed in this context"); - return NULL_TREE; - } - } - /* [temp.arg.nontype]/5, bullet 7 - - For a non-type template-parameter of type pointer to data member, - qualification conversions (_conv.qual_) are applied. */ - else if (TYPE_PTRMEM_P (type)) - { - expr = perform_qualification_conversions (type, expr); - if (expr == error_mark_node) - return expr; - } - /* A template non-type parameter must be one of the above. */ - else - gcc_unreachable (); - - /* Sanity check: did we actually convert the argument to the - right type? */ - gcc_assert (same_type_p (type, TREE_TYPE (expr))); - return expr; -} - - -/* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for - template template parameters. Both PARM_PARMS and ARG_PARMS are - vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL - or PARM_DECL. - - Consider the example: - template <class T> class A; - template<template <class U> class TT> class B; - - For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are - the parameters to A, and OUTER_ARGS contains A. */ - -static int -coerce_template_template_parms (tree parm_parms, - tree arg_parms, - tsubst_flags_t complain, - tree in_decl, - tree outer_args) -{ - int nparms, nargs, i; - tree parm, arg; - - gcc_assert (TREE_CODE (parm_parms) == TREE_VEC); - gcc_assert (TREE_CODE (arg_parms) == TREE_VEC); - - nparms = TREE_VEC_LENGTH (parm_parms); - nargs = TREE_VEC_LENGTH (arg_parms); - - if (nargs != nparms) - return 0; - - for (i = 0; i < nparms; ++i) - { - if (TREE_VEC_ELT (parm_parms, i) == error_mark_node - || TREE_VEC_ELT (arg_parms, i) == error_mark_node) - continue; - - parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, i)); - arg = TREE_VALUE (TREE_VEC_ELT (arg_parms, i)); - - if (arg == NULL_TREE || arg == error_mark_node - || parm == NULL_TREE || parm == error_mark_node) - return 0; - - if (TREE_CODE (arg) != TREE_CODE (parm)) - return 0; - - switch (TREE_CODE (parm)) - { - case TYPE_DECL: - break; - - case TEMPLATE_DECL: - /* We encounter instantiations of templates like - template <template <template <class> class> class TT> - class C; */ - { - tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm); - tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg); - - if (!coerce_template_template_parms - (parmparm, argparm, complain, in_decl, outer_args)) - return 0; - } - break; - - case PARM_DECL: - /* The tsubst call is used to handle cases such as - - template <int> class C {}; - template <class T, template <T> class TT> class D {}; - D<int, C> d; - - i.e. the parameter list of TT depends on earlier parameters. */ - if (!dependent_type_p (TREE_TYPE (arg)) - && !same_type_p - (tsubst (TREE_TYPE (parm), outer_args, complain, in_decl), - TREE_TYPE (arg))) - return 0; - break; - - default: - gcc_unreachable (); - } - } - return 1; -} - -/* Convert the indicated template ARG as necessary to match the - indicated template PARM. Returns the converted ARG, or - error_mark_node if the conversion was unsuccessful. Error and - warning messages are issued under control of COMPLAIN. This - conversion is for the Ith parameter in the parameter list. ARGS is - the full set of template arguments deduced so far. */ - -static tree -convert_template_argument (tree parm, - tree arg, - tree args, - tsubst_flags_t complain, - int i, - tree in_decl) -{ - tree val; - int is_type, requires_type, is_tmpl_type, requires_tmpl_type; - - if (TREE_CODE (arg) == TREE_LIST - && TREE_CODE (TREE_VALUE (arg)) == OFFSET_REF) - { - /* The template argument was the name of some - member function. That's usually - invalid, but static members are OK. In any - case, grab the underlying fields/functions - and issue an error later if required. */ - arg = TREE_VALUE (arg); - TREE_TYPE (arg) = unknown_type_node; - } - - requires_tmpl_type = TREE_CODE (parm) == TEMPLATE_DECL; - requires_type = (TREE_CODE (parm) == TYPE_DECL - || requires_tmpl_type); - - is_tmpl_type = ((TREE_CODE (arg) == TEMPLATE_DECL - && TREE_CODE (DECL_TEMPLATE_RESULT (arg)) == TYPE_DECL) - || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM - || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE); - - if (is_tmpl_type - && (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM - || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)) - arg = TYPE_STUB_DECL (arg); - - is_type = TYPE_P (arg) || is_tmpl_type; - - if (requires_type && ! is_type && TREE_CODE (arg) == SCOPE_REF - && TREE_CODE (TREE_OPERAND (arg, 0)) == TEMPLATE_TYPE_PARM) - { - pedwarn ("to refer to a type member of a template parameter, " - "use %<typename %E%>", arg); - - arg = make_typename_type (TREE_OPERAND (arg, 0), - TREE_OPERAND (arg, 1), - typename_type, - complain & tf_error); - is_type = 1; - } - if (is_type != requires_type) - { - if (in_decl) - { - if (complain & tf_error) - { - error ("type/value mismatch at argument %d in template " - "parameter list for %qD", - i + 1, in_decl); - if (is_type) - error (" expected a constant of type %qT, got %qT", - TREE_TYPE (parm), - (is_tmpl_type ? DECL_NAME (arg) : arg)); - else if (requires_tmpl_type) - error (" expected a class template, got %qE", arg); - else - error (" expected a type, got %qE", arg); - } - } - return error_mark_node; - } - if (is_tmpl_type ^ requires_tmpl_type) - { - if (in_decl && (complain & tf_error)) - { - error ("type/value mismatch at argument %d in template " - "parameter list for %qD", - i + 1, in_decl); - if (is_tmpl_type) - error (" expected a type, got %qT", DECL_NAME (arg)); - else - error (" expected a class template, got %qT", arg); - } - return error_mark_node; - } - - if (is_type) - { - if (requires_tmpl_type) - { - if (TREE_CODE (TREE_TYPE (arg)) == UNBOUND_CLASS_TEMPLATE) - /* The number of argument required is not known yet. - Just accept it for now. */ - val = TREE_TYPE (arg); - else - { - tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm); - tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg); - - if (coerce_template_template_parms (parmparm, argparm, - complain, in_decl, - args)) - { - val = arg; - - /* TEMPLATE_TEMPLATE_PARM node is preferred over - TEMPLATE_DECL. */ - if (val != error_mark_node - && DECL_TEMPLATE_TEMPLATE_PARM_P (val)) - val = TREE_TYPE (val); - } - else - { - if (in_decl && (complain & tf_error)) - { - error ("type/value mismatch at argument %d in " - "template parameter list for %qD", - i + 1, in_decl); - error (" expected a template of type %qD, got %qD", - parm, arg); - } - - val = error_mark_node; - } - } - } - else - val = arg; - /* We only form one instance of each template specialization. - Therefore, if we use a non-canonical variant (i.e., a - typedef), any future messages referring to the type will use - the typedef, which is confusing if those future uses do not - themselves also use the typedef. */ - if (TYPE_P (val)) - val = canonical_type_variant (val); - } - else - { - tree t = tsubst (TREE_TYPE (parm), args, complain, in_decl); - - if (invalid_nontype_parm_type_p (t, complain)) - return error_mark_node; - - if (!uses_template_parms (arg) && !uses_template_parms (t)) - /* We used to call digest_init here. However, digest_init - will report errors, which we don't want when complain - is zero. More importantly, digest_init will try too - hard to convert things: for example, `0' should not be - converted to pointer type at this point according to - the standard. Accepting this is not merely an - extension, since deciding whether or not these - conversions can occur is part of determining which - function template to call, or whether a given explicit - argument specification is valid. */ - val = convert_nontype_argument (t, arg); - else - val = arg; - - if (val == NULL_TREE) - val = error_mark_node; - else if (val == error_mark_node && (complain & tf_error)) - error ("could not convert template argument %qE to %qT", arg, t); - } - - return val; -} - -/* Convert all template arguments to their appropriate types, and - return a vector containing the innermost resulting template - arguments. If any error occurs, return error_mark_node. Error and - warning messages are issued under control of COMPLAIN. - - If REQUIRE_ALL_ARGS is false, argument deduction will be performed - for arguments not specified in ARGS. Otherwise, if - USE_DEFAULT_ARGS is true, default arguments will be used to fill in - unspecified arguments. If REQUIRE_ALL_ARGS is true, but - USE_DEFAULT_ARGS is false, then all arguments must be specified in - ARGS. */ - -static tree -coerce_template_parms (tree parms, - tree args, - tree in_decl, - tsubst_flags_t complain, - bool require_all_args, - bool use_default_args) -{ - int nparms, nargs, i, lost = 0; - tree inner_args; - tree new_args; - tree new_inner_args; - bool saved_skip_evaluation; - - inner_args = INNERMOST_TEMPLATE_ARGS (args); - nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0; - nparms = TREE_VEC_LENGTH (parms); - - if (nargs > nparms - || (nargs < nparms - && require_all_args - && (!use_default_args - || (TREE_VEC_ELT (parms, nargs) != error_mark_node - && !TREE_PURPOSE (TREE_VEC_ELT (parms, nargs)))))) - { - if (complain & tf_error) - { - error ("wrong number of template arguments (%d, should be %d)", - nargs, nparms); - - if (in_decl) - error ("provided for %q+D", in_decl); - } - - return error_mark_node; - } - - /* We need to evaluate the template arguments, even though this - template-id may be nested within a "sizeof". */ - saved_skip_evaluation = skip_evaluation; - skip_evaluation = false; - new_inner_args = make_tree_vec (nparms); - new_args = add_outermost_template_args (args, new_inner_args); - for (i = 0; i < nparms; i++) - { - tree arg; - tree parm; - - /* Get the Ith template parameter. */ - parm = TREE_VEC_ELT (parms, i); - - if (parm == error_mark_node) - { - TREE_VEC_ELT (new_inner_args, i) = error_mark_node; - continue; - } - - /* Calculate the Ith argument. */ - if (i < nargs) - arg = TREE_VEC_ELT (inner_args, i); - else if (require_all_args) - /* There must be a default arg in this case. */ - arg = tsubst_template_arg (TREE_PURPOSE (parm), new_args, - complain, in_decl); - else - break; - - gcc_assert (arg); - if (arg == error_mark_node) - { - if (complain & tf_error) - error ("template argument %d is invalid", i + 1); - } - else - arg = convert_template_argument (TREE_VALUE (parm), - arg, new_args, complain, i, - in_decl); - - if (arg == error_mark_node) - lost++; - TREE_VEC_ELT (new_inner_args, i) = arg; - } - skip_evaluation = saved_skip_evaluation; - - if (lost) - return error_mark_node; - - return new_inner_args; -} - -/* Returns 1 if template args OT and NT are equivalent. */ - -static int -template_args_equal (tree ot, tree nt) -{ - if (nt == ot) - return 1; - - if (TREE_CODE (nt) == TREE_VEC) - /* For member templates */ - return TREE_CODE (ot) == TREE_VEC && comp_template_args (ot, nt); - else if (TYPE_P (nt)) - return TYPE_P (ot) && same_type_p (ot, nt); - else if (TREE_CODE (ot) == TREE_VEC || TYPE_P (ot)) - return 0; - else - return cp_tree_equal (ot, nt); -} - -/* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets - of template arguments. Returns 0 otherwise. */ - -int -comp_template_args (tree oldargs, tree newargs) -{ - int i; - - if (TREE_VEC_LENGTH (oldargs) != TREE_VEC_LENGTH (newargs)) - return 0; - - for (i = 0; i < TREE_VEC_LENGTH (oldargs); ++i) - { - tree nt = TREE_VEC_ELT (newargs, i); - tree ot = TREE_VEC_ELT (oldargs, i); - - if (! template_args_equal (ot, nt)) - return 0; - } - return 1; -} - -/* Given class template name and parameter list, produce a user-friendly name - for the instantiation. */ - -static char * -mangle_class_name_for_template (const char* name, tree parms, tree arglist) -{ - static struct obstack scratch_obstack; - static char *scratch_firstobj; - int i, nparms; - - if (!scratch_firstobj) - gcc_obstack_init (&scratch_obstack); - else - obstack_free (&scratch_obstack, scratch_firstobj); - scratch_firstobj = (char *) obstack_alloc (&scratch_obstack, 1); - -#define ccat(C) obstack_1grow (&scratch_obstack, (C)); -#define cat(S) obstack_grow (&scratch_obstack, (S), strlen (S)) - - cat (name); - ccat ('<'); - nparms = TREE_VEC_LENGTH (parms); - arglist = INNERMOST_TEMPLATE_ARGS (arglist); - gcc_assert (nparms == TREE_VEC_LENGTH (arglist)); - for (i = 0; i < nparms; i++) - { - tree parm; - tree arg; - - parm = TREE_VALUE (TREE_VEC_ELT (parms, i)); - arg = TREE_VEC_ELT (arglist, i); - - if (parm == error_mark_node) - continue; - - if (i) - ccat (','); - - if (TREE_CODE (parm) == TYPE_DECL) - { - cat (type_as_string (arg, TFF_CHASE_TYPEDEF)); - continue; - } - else if (TREE_CODE (parm) == TEMPLATE_DECL) - { - if (TREE_CODE (arg) == TEMPLATE_DECL) - { - /* Already substituted with real template. Just output - the template name here */ - tree context = DECL_CONTEXT (arg); - if (context) - { - /* The template may be defined in a namespace, or - may be a member template. */ - gcc_assert (TREE_CODE (context) == NAMESPACE_DECL - || CLASS_TYPE_P (context)); - cat (decl_as_string (DECL_CONTEXT (arg), - TFF_PLAIN_IDENTIFIER)); - cat ("::"); - } - cat (IDENTIFIER_POINTER (DECL_NAME (arg))); - } - else - /* Output the parameter declaration. */ - cat (type_as_string (arg, TFF_CHASE_TYPEDEF)); - continue; - } - else - gcc_assert (TREE_CODE (parm) == PARM_DECL); - - /* No need to check arglist against parmlist here; we did that - in coerce_template_parms, called from lookup_template_class. */ - cat (expr_as_string (arg, TFF_PLAIN_IDENTIFIER)); - } - { - char *bufp = obstack_next_free (&scratch_obstack); - int offset = 0; - while (bufp[offset - 1] == ' ') - offset--; - obstack_blank_fast (&scratch_obstack, offset); - - /* B<C<char> >, not B<C<char>> */ - if (bufp[offset - 1] == '>') - ccat (' '); - } - ccat ('>'); - ccat ('\0'); - return (char *) obstack_base (&scratch_obstack); -} - -static tree -classtype_mangled_name (tree t) -{ - if (CLASSTYPE_TEMPLATE_INFO (t) - /* Specializations have already had their names set up in - lookup_template_class. */ - && !CLASSTYPE_TEMPLATE_SPECIALIZATION (t)) - { - tree tmpl = most_general_template (CLASSTYPE_TI_TEMPLATE (t)); - - /* For non-primary templates, the template parameters are - implicit from their surrounding context. */ - if (PRIMARY_TEMPLATE_P (tmpl)) - { - tree name = DECL_NAME (tmpl); - char *mangled_name = mangle_class_name_for_template - (IDENTIFIER_POINTER (name), - DECL_INNERMOST_TEMPLATE_PARMS (tmpl), - CLASSTYPE_TI_ARGS (t)); - tree id = get_identifier (mangled_name); - IDENTIFIER_TEMPLATE (id) = name; - return id; - } - } - - return TYPE_IDENTIFIER (t); -} - -static void -add_pending_template (tree d) -{ - tree ti = (TYPE_P (d) - ? CLASSTYPE_TEMPLATE_INFO (d) - : DECL_TEMPLATE_INFO (d)); - tree pt; - int level; - - if (TI_PENDING_TEMPLATE_FLAG (ti)) - return; - - /* We are called both from instantiate_decl, where we've already had a - tinst_level pushed, and instantiate_template, where we haven't. - Compensate. */ - level = !(current_tinst_level && TINST_DECL (current_tinst_level) == d); - - if (level) - push_tinst_level (d); - - pt = tree_cons (current_tinst_level, d, NULL_TREE); - if (last_pending_template) - TREE_CHAIN (last_pending_template) = pt; - else - pending_templates = pt; - - last_pending_template = pt; - - TI_PENDING_TEMPLATE_FLAG (ti) = 1; - - if (level) - pop_tinst_level (); -} - - -/* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and - ARGLIST. Valid choices for FNS are given in the cp-tree.def - documentation for TEMPLATE_ID_EXPR. */ - -tree -lookup_template_function (tree fns, tree arglist) -{ - tree type; - - if (fns == error_mark_node || arglist == error_mark_node) - return error_mark_node; - - gcc_assert (!arglist || TREE_CODE (arglist) == TREE_VEC); - gcc_assert (fns && (is_overloaded_fn (fns) - || TREE_CODE (fns) == IDENTIFIER_NODE)); - - if (BASELINK_P (fns)) - { - BASELINK_FUNCTIONS (fns) = build2 (TEMPLATE_ID_EXPR, - unknown_type_node, - BASELINK_FUNCTIONS (fns), - arglist); - return fns; - } - - type = TREE_TYPE (fns); - if (TREE_CODE (fns) == OVERLOAD || !type) - type = unknown_type_node; - - return build2 (TEMPLATE_ID_EXPR, type, fns, arglist); -} - -/* Within the scope of a template class S<T>, the name S gets bound - (in build_self_reference) to a TYPE_DECL for the class, not a - TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type, - or one of its enclosing classes, and that type is a template, - return the associated TEMPLATE_DECL. Otherwise, the original - DECL is returned. */ - -tree -maybe_get_template_decl_from_type_decl (tree decl) -{ - return (decl != NULL_TREE - && TREE_CODE (decl) == TYPE_DECL - && DECL_ARTIFICIAL (decl) - && CLASS_TYPE_P (TREE_TYPE (decl)) - && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl))) - ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl)) : decl; -} - -/* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of - parameters, find the desired type. - - D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments. - - IN_DECL, if non-NULL, is the template declaration we are trying to - instantiate. - - If ENTERING_SCOPE is nonzero, we are about to enter the scope of - the class we are looking up. - - Issue error and warning messages under control of COMPLAIN. - - If the template class is really a local class in a template - function, then the FUNCTION_CONTEXT is the function in which it is - being instantiated. - - ??? Note that this function is currently called *twice* for each - template-id: the first time from the parser, while creating the - incomplete type (finish_template_type), and the second type during the - real instantiation (instantiate_template_class). This is surely something - that we want to avoid. It also causes some problems with argument - coercion (see convert_nontype_argument for more information on this). */ - -tree -lookup_template_class (tree d1, - tree arglist, - tree in_decl, - tree context, - int entering_scope, - tsubst_flags_t complain) -{ - tree template = NULL_TREE, parmlist; - tree t; - - timevar_push (TV_NAME_LOOKUP); - - if (TREE_CODE (d1) == IDENTIFIER_NODE) - { - tree value = innermost_non_namespace_value (d1); - if (value && DECL_TEMPLATE_TEMPLATE_PARM_P (value)) - template = value; - else - { - if (context) - push_decl_namespace (context); - template = lookup_name (d1); - template = maybe_get_template_decl_from_type_decl (template); - if (context) - pop_decl_namespace (); - } - if (template) - context = DECL_CONTEXT (template); - } - else if (TREE_CODE (d1) == TYPE_DECL && IS_AGGR_TYPE (TREE_TYPE (d1))) - { - tree type = TREE_TYPE (d1); - - /* If we are declaring a constructor, say A<T>::A<T>, we will get - an implicit typename for the second A. Deal with it. */ - if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type)) - type = TREE_TYPE (type); - - if (CLASSTYPE_TEMPLATE_INFO (type)) - { - template = CLASSTYPE_TI_TEMPLATE (type); - d1 = DECL_NAME (template); - } - } - else if (TREE_CODE (d1) == ENUMERAL_TYPE - || (TYPE_P (d1) && IS_AGGR_TYPE (d1))) - { - template = TYPE_TI_TEMPLATE (d1); - d1 = DECL_NAME (template); - } - else if (TREE_CODE (d1) == TEMPLATE_DECL - && TREE_CODE (DECL_TEMPLATE_RESULT (d1)) == TYPE_DECL) - { - template = d1; - d1 = DECL_NAME (template); - context = DECL_CONTEXT (template); - } - - /* Issue an error message if we didn't find a template. */ - if (! template) - { - if (complain & tf_error) - error ("%qT is not a template", d1); - POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node); - } - - if (TREE_CODE (template) != TEMPLATE_DECL - /* Make sure it's a user visible template, if it was named by - the user. */ - || ((complain & tf_user) && !DECL_TEMPLATE_PARM_P (template) - && !PRIMARY_TEMPLATE_P (template))) - { - if (complain & tf_error) - { - error ("non-template type %qT used as a template", d1); - if (in_decl) - error ("for template declaration %q+D", in_decl); - } - POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node); - } - - complain &= ~tf_user; - - if (DECL_TEMPLATE_TEMPLATE_PARM_P (template)) - { - /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store - template arguments */ - - tree parm; - tree arglist2; - - parmlist = DECL_INNERMOST_TEMPLATE_PARMS (template); - - /* Consider an example where a template template parameter declared as - - template <class T, class U = std::allocator<T> > class TT - - The template parameter level of T and U are one level larger than - of TT. To proper process the default argument of U, say when an - instantiation `TT<int>' is seen, we need to build the full - arguments containing {int} as the innermost level. Outer levels, - available when not appearing as default template argument, can be - obtained from `current_template_args ()'. - - Suppose that TT is later substituted with std::vector. The above - instantiation is `TT<int, std::allocator<T> >' with TT at - level 1, and T at level 2, while the template arguments at level 1 - becomes {std::vector} and the inner level 2 is {int}. */ - - if (current_template_parms) - arglist = add_to_template_args (current_template_args (), arglist); - - arglist2 = coerce_template_parms (parmlist, arglist, template, - complain, - /*require_all_args=*/true, - /*use_default_args=*/true); - if (arglist2 == error_mark_node - || (!uses_template_parms (arglist2) - && check_instantiated_args (template, arglist2, complain))) - POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node); - - parm = bind_template_template_parm (TREE_TYPE (template), arglist2); - POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, parm); - } - else - { - tree template_type = TREE_TYPE (template); - tree gen_tmpl; - tree type_decl; - tree found = NULL_TREE; - int arg_depth; - int parm_depth; - int is_partial_instantiation; - - gen_tmpl = most_general_template (template); - parmlist = DECL_TEMPLATE_PARMS (gen_tmpl); - parm_depth = TMPL_PARMS_DEPTH (parmlist); - arg_depth = TMPL_ARGS_DEPTH (arglist); - - if (arg_depth == 1 && parm_depth > 1) - { - /* We've been given an incomplete set of template arguments. - For example, given: - - template <class T> struct S1 { - template <class U> struct S2 {}; - template <class U> struct S2<U*> {}; - }; - - we will be called with an ARGLIST of `U*', but the - TEMPLATE will be `template <class T> template - <class U> struct S1<T>::S2'. We must fill in the missing - arguments. */ - arglist - = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (template)), - arglist); - arg_depth = TMPL_ARGS_DEPTH (arglist); - } - - /* Now we should have enough arguments. */ - gcc_assert (parm_depth == arg_depth); - - /* From here on, we're only interested in the most general - template. */ - template = gen_tmpl; - - /* Calculate the BOUND_ARGS. These will be the args that are - actually tsubst'd into the definition to create the - instantiation. */ - if (parm_depth > 1) - { - /* We have multiple levels of arguments to coerce, at once. */ - int i; - int saved_depth = TMPL_ARGS_DEPTH (arglist); - - tree bound_args = make_tree_vec (parm_depth); - - for (i = saved_depth, - t = DECL_TEMPLATE_PARMS (template); - i > 0 && t != NULL_TREE; - --i, t = TREE_CHAIN (t)) - { - tree a = coerce_template_parms (TREE_VALUE (t), - arglist, template, - complain, - /*require_all_args=*/true, - /*use_default_args=*/true); - - /* Don't process further if one of the levels fails. */ - if (a == error_mark_node) - { - /* Restore the ARGLIST to its full size. */ - TREE_VEC_LENGTH (arglist) = saved_depth; - POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node); - } - - SET_TMPL_ARGS_LEVEL (bound_args, i, a); - - /* We temporarily reduce the length of the ARGLIST so - that coerce_template_parms will see only the arguments - corresponding to the template parameters it is - examining. */ - TREE_VEC_LENGTH (arglist)--; - } - - /* Restore the ARGLIST to its full size. */ - TREE_VEC_LENGTH (arglist) = saved_depth; - - arglist = bound_args; - } - else - arglist - = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist), - INNERMOST_TEMPLATE_ARGS (arglist), - template, - complain, - /*require_all_args=*/true, - /*use_default_args=*/true); - - if (arglist == error_mark_node) - /* We were unable to bind the arguments. */ - POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node); - - /* In the scope of a template class, explicit references to the - template class refer to the type of the template, not any - instantiation of it. For example, in: - - template <class T> class C { void f(C<T>); } - - the `C<T>' is just the same as `C'. Outside of the - class, however, such a reference is an instantiation. */ - if (comp_template_args (TYPE_TI_ARGS (template_type), - arglist)) - { - found = template_type; - - if (!entering_scope && PRIMARY_TEMPLATE_P (template)) - { - tree ctx; - - for (ctx = current_class_type; - ctx && TREE_CODE (ctx) != NAMESPACE_DECL; - ctx = (TYPE_P (ctx) - ? TYPE_CONTEXT (ctx) - : DECL_CONTEXT (ctx))) - if (TYPE_P (ctx) && same_type_p (ctx, template_type)) - goto found_ctx; - - /* We're not in the scope of the class, so the - TEMPLATE_TYPE is not the type we want after all. */ - found = NULL_TREE; - found_ctx:; - } - } - if (found) - POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found); - - /* If we already have this specialization, return it. */ - found = retrieve_specialization (template, arglist, - /*class_specializations_p=*/false); - if (found) - POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found); - - /* This type is a "partial instantiation" if any of the template - arguments still involve template parameters. Note that we set - IS_PARTIAL_INSTANTIATION for partial specializations as - well. */ - is_partial_instantiation = uses_template_parms (arglist); - - /* If the deduced arguments are invalid, then the binding - failed. */ - if (!is_partial_instantiation - && check_instantiated_args (template, - INNERMOST_TEMPLATE_ARGS (arglist), - complain)) - POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node); - - if (!is_partial_instantiation - && !PRIMARY_TEMPLATE_P (template) - && TREE_CODE (CP_DECL_CONTEXT (template)) == NAMESPACE_DECL) - { - found = xref_tag_from_type (TREE_TYPE (template), - DECL_NAME (template), - /*tag_scope=*/ts_global); - POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found); - } - - context = tsubst (DECL_CONTEXT (template), arglist, - complain, in_decl); - if (!context) - context = global_namespace; - - /* Create the type. */ - if (TREE_CODE (template_type) == ENUMERAL_TYPE) - { - if (!is_partial_instantiation) - { - set_current_access_from_decl (TYPE_NAME (template_type)); - t = start_enum (TYPE_IDENTIFIER (template_type)); - } - else - /* We don't want to call start_enum for this type, since - the values for the enumeration constants may involve - template parameters. And, no one should be interested - in the enumeration constants for such a type. */ - t = make_node (ENUMERAL_TYPE); - } - else - { - t = make_aggr_type (TREE_CODE (template_type)); - CLASSTYPE_DECLARED_CLASS (t) - = CLASSTYPE_DECLARED_CLASS (template_type); - SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t); - TYPE_FOR_JAVA (t) = TYPE_FOR_JAVA (template_type); - - /* A local class. Make sure the decl gets registered properly. */ - if (context == current_function_decl) - pushtag (DECL_NAME (template), t, /*tag_scope=*/ts_current); - } - - /* If we called start_enum or pushtag above, this information - will already be set up. */ - if (!TYPE_NAME (t)) - { - TYPE_CONTEXT (t) = FROB_CONTEXT (context); - - type_decl = create_implicit_typedef (DECL_NAME (template), t); - DECL_CONTEXT (type_decl) = TYPE_CONTEXT (t); - TYPE_STUB_DECL (t) = type_decl; - DECL_SOURCE_LOCATION (type_decl) - = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type)); - } - else - type_decl = TYPE_NAME (t); - - TREE_PRIVATE (type_decl) - = TREE_PRIVATE (TYPE_STUB_DECL (template_type)); - TREE_PROTECTED (type_decl) - = TREE_PROTECTED (TYPE_STUB_DECL (template_type)); - DECL_IN_SYSTEM_HEADER (type_decl) - = DECL_IN_SYSTEM_HEADER (template); - if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type)) - { - DECL_VISIBILITY_SPECIFIED (type_decl) = 1; - DECL_VISIBILITY (type_decl) = CLASSTYPE_VISIBILITY (template_type); - } - - /* Set up the template information. We have to figure out which - template is the immediate parent if this is a full - instantiation. */ - if (parm_depth == 1 || is_partial_instantiation - || !PRIMARY_TEMPLATE_P (template)) - /* This case is easy; there are no member templates involved. */ - found = template; - else - { - /* This is a full instantiation of a member template. Look - for a partial instantiation of which this is an instance. */ - - for (found = DECL_TEMPLATE_INSTANTIATIONS (template); - found; found = TREE_CHAIN (found)) - { - int success; - tree tmpl = CLASSTYPE_TI_TEMPLATE (TREE_VALUE (found)); - - /* We only want partial instantiations, here, not - specializations or full instantiations. */ - if (CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_VALUE (found)) - || !uses_template_parms (TREE_VALUE (found))) - continue; - - /* Temporarily reduce by one the number of levels in the - ARGLIST and in FOUND so as to avoid comparing the - last set of arguments. */ - TREE_VEC_LENGTH (arglist)--; - TREE_VEC_LENGTH (TREE_PURPOSE (found)) --; - - /* See if the arguments match. If they do, then TMPL is - the partial instantiation we want. */ - success = comp_template_args (TREE_PURPOSE (found), arglist); - - /* Restore the argument vectors to their full size. */ - TREE_VEC_LENGTH (arglist)++; - TREE_VEC_LENGTH (TREE_PURPOSE (found))++; - - if (success) - { - found = tmpl; - break; - } - } - - if (!found) - { - /* There was no partial instantiation. This happens - where C<T> is a member template of A<T> and it's used - in something like - - template <typename T> struct B { A<T>::C<int> m; }; - B<float>; - - Create the partial instantiation. - */ - TREE_VEC_LENGTH (arglist)--; - found = tsubst (template, arglist, complain, NULL_TREE); - TREE_VEC_LENGTH (arglist)++; - } - } - - SET_TYPE_TEMPLATE_INFO (t, tree_cons (found, arglist, NULL_TREE)); - DECL_TEMPLATE_INSTANTIATIONS (template) - = tree_cons (arglist, t, - DECL_TEMPLATE_INSTANTIATIONS (template)); - - if (TREE_CODE (t) == ENUMERAL_TYPE - && !is_partial_instantiation) - /* Now that the type has been registered on the instantiations - list, we set up the enumerators. Because the enumeration - constants may involve the enumeration type itself, we make - sure to register the type first, and then create the - constants. That way, doing tsubst_expr for the enumeration - constants won't result in recursive calls here; we'll find - the instantiation and exit above. */ - tsubst_enum (template_type, t, arglist); - - /* Reset the name of the type, now that CLASSTYPE_TEMPLATE_INFO - is set up. */ - if (TREE_CODE (t) != ENUMERAL_TYPE) - DECL_NAME (type_decl) = classtype_mangled_name (t); - if (is_partial_instantiation) - /* If the type makes use of template parameters, the - code that generates debugging information will crash. */ - DECL_IGNORED_P (TYPE_STUB_DECL (t)) = 1; - - /* Possibly limit visibility based on template args. */ - TREE_PUBLIC (type_decl) = 1; - determine_visibility (type_decl); - - POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t); - } - timevar_pop (TV_NAME_LOOKUP); -} - -struct pair_fn_data -{ - tree_fn_t fn; - void *data; - struct pointer_set_t *visited; -}; - -/* Called from for_each_template_parm via walk_tree. */ - -static tree -for_each_template_parm_r (tree *tp, int *walk_subtrees, void *d) -{ - tree t = *tp; - struct pair_fn_data *pfd = (struct pair_fn_data *) d; - tree_fn_t fn = pfd->fn; - void *data = pfd->data; - - if (TYPE_P (t) - && for_each_template_parm (TYPE_CONTEXT (t), fn, data, pfd->visited)) - return error_mark_node; - - switch (TREE_CODE (t)) - { - case RECORD_TYPE: - if (TYPE_PTRMEMFUNC_P (t)) - break; - /* Fall through. */ - - case UNION_TYPE: - case ENUMERAL_TYPE: - if (!TYPE_TEMPLATE_INFO (t)) - *walk_subtrees = 0; - else if (for_each_template_parm (TREE_VALUE (TYPE_TEMPLATE_INFO (t)), - fn, data, pfd->visited)) - return error_mark_node; - break; - - case METHOD_TYPE: - /* Since we're not going to walk subtrees, we have to do this - explicitly here. */ - if (for_each_template_parm (TYPE_METHOD_BASETYPE (t), fn, data, - pfd->visited)) - return error_mark_node; - /* Fall through. */ - - case FUNCTION_TYPE: - /* Check the return type. */ - if (for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited)) - return error_mark_node; - - /* Check the parameter types. Since default arguments are not - instantiated until they are needed, the TYPE_ARG_TYPES may - contain expressions that involve template parameters. But, - no-one should be looking at them yet. And, once they're - instantiated, they don't contain template parameters, so - there's no point in looking at them then, either. */ - { - tree parm; - - for (parm = TYPE_ARG_TYPES (t); parm; parm = TREE_CHAIN (parm)) - if (for_each_template_parm (TREE_VALUE (parm), fn, data, - pfd->visited)) - return error_mark_node; - - /* Since we've already handled the TYPE_ARG_TYPES, we don't - want walk_tree walking into them itself. */ - *walk_subtrees = 0; - } - break; - - case TYPEOF_TYPE: - if (for_each_template_parm (TYPE_FIELDS (t), fn, data, - pfd->visited)) - return error_mark_node; - break; - - case FUNCTION_DECL: - case VAR_DECL: - if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t) - && for_each_template_parm (DECL_TI_ARGS (t), fn, data, - pfd->visited)) - return error_mark_node; - /* Fall through. */ - - case PARM_DECL: - case CONST_DECL: - if (TREE_CODE (t) == CONST_DECL && DECL_TEMPLATE_PARM_P (t) - && for_each_template_parm (DECL_INITIAL (t), fn, data, - pfd->visited)) - return error_mark_node; - if (DECL_CONTEXT (t) - && for_each_template_parm (DECL_CONTEXT (t), fn, data, - pfd->visited)) - return error_mark_node; - break; - - case BOUND_TEMPLATE_TEMPLATE_PARM: - /* Record template parameters such as `T' inside `TT<T>'. */ - if (for_each_template_parm (TYPE_TI_ARGS (t), fn, data, pfd->visited)) - return error_mark_node; - /* Fall through. */ - - case TEMPLATE_TEMPLATE_PARM: - case TEMPLATE_TYPE_PARM: - case TEMPLATE_PARM_INDEX: - if (fn && (*fn)(t, data)) - return error_mark_node; - else if (!fn) - return error_mark_node; - break; - - case TEMPLATE_DECL: - /* A template template parameter is encountered. */ - if (DECL_TEMPLATE_TEMPLATE_PARM_P (t) - && for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited)) - return error_mark_node; - - /* Already substituted template template parameter */ - *walk_subtrees = 0; - break; - - case TYPENAME_TYPE: - if (!fn - || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t), fn, - data, pfd->visited)) - return error_mark_node; - break; - - case CONSTRUCTOR: - if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)) - && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE - (TREE_TYPE (t)), fn, data, - pfd->visited)) - return error_mark_node; - break; - - case INDIRECT_REF: - case COMPONENT_REF: - /* If there's no type, then this thing must be some expression - involving template parameters. */ - if (!fn && !TREE_TYPE (t)) - return error_mark_node; - break; - - case MODOP_EXPR: - case CAST_EXPR: - case REINTERPRET_CAST_EXPR: - case CONST_CAST_EXPR: - case STATIC_CAST_EXPR: - case DYNAMIC_CAST_EXPR: - case ARROW_EXPR: - case DOTSTAR_EXPR: - case TYPEID_EXPR: - case PSEUDO_DTOR_EXPR: - if (!fn) - return error_mark_node; - break; - - case BASELINK: - /* If we do not handle this case specially, we end up walking - the BINFO hierarchy, which is circular, and therefore - confuses walk_tree. */ - *walk_subtrees = 0; - if (for_each_template_parm (BASELINK_FUNCTIONS (*tp), fn, data, - pfd->visited)) - return error_mark_node; - break; - - default: - break; - } - - /* We didn't find any template parameters we liked. */ - return NULL_TREE; -} - -/* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM, - BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T, - call FN with the parameter and the DATA. - If FN returns nonzero, the iteration is terminated, and - for_each_template_parm returns 1. Otherwise, the iteration - continues. If FN never returns a nonzero value, the value - returned by for_each_template_parm is 0. If FN is NULL, it is - considered to be the function which always returns 1. */ - -static int -for_each_template_parm (tree t, tree_fn_t fn, void* data, - struct pointer_set_t *visited) -{ - struct pair_fn_data pfd; - int result; - - /* Set up. */ - pfd.fn = fn; - pfd.data = data; - - /* Walk the tree. (Conceptually, we would like to walk without - duplicates, but for_each_template_parm_r recursively calls - for_each_template_parm, so we would need to reorganize a fair - bit to use walk_tree_without_duplicates, so we keep our own - visited list.) */ - if (visited) - pfd.visited = visited; - else - pfd.visited = pointer_set_create (); - result = walk_tree (&t, - for_each_template_parm_r, - &pfd, - pfd.visited) != NULL_TREE; - - /* Clean up. */ - if (!visited) - { - pointer_set_destroy (pfd.visited); - pfd.visited = 0; - } - - return result; -} - -/* Returns true if T depends on any template parameter. */ - -int -uses_template_parms (tree t) -{ - bool dependent_p; - int saved_processing_template_decl; - - saved_processing_template_decl = processing_template_decl; - if (!saved_processing_template_decl) - processing_template_decl = 1; - if (TYPE_P (t)) - dependent_p = dependent_type_p (t); - else if (TREE_CODE (t) == TREE_VEC) - dependent_p = any_dependent_template_arguments_p (t); - else if (TREE_CODE (t) == TREE_LIST) - dependent_p = (uses_template_parms (TREE_VALUE (t)) - || uses_template_parms (TREE_CHAIN (t))); - else if (TREE_CODE (t) == TYPE_DECL) - dependent_p = dependent_type_p (TREE_TYPE (t)); - else if (DECL_P (t) - || EXPR_P (t) - || TREE_CODE (t) == TEMPLATE_PARM_INDEX - || TREE_CODE (t) == OVERLOAD - || TREE_CODE (t) == BASELINK - || TREE_CODE (t) == IDENTIFIER_NODE - || CONSTANT_CLASS_P (t)) - dependent_p = (type_dependent_expression_p (t) - || value_dependent_expression_p (t)); - else - { - gcc_assert (t == error_mark_node); - dependent_p = false; - } - - processing_template_decl = saved_processing_template_decl; - - return dependent_p; -} - -/* Returns true if T depends on any template parameter with level LEVEL. */ - -int -uses_template_parms_level (tree t, int level) -{ - return for_each_template_parm (t, template_parm_this_level_p, &level, NULL); -} - -static int tinst_depth; -extern int max_tinst_depth; -#ifdef GATHER_STATISTICS -int depth_reached; -#endif -static int tinst_level_tick; -static int last_template_error_tick; - -/* We're starting to instantiate D; record the template instantiation context - for diagnostics and to restore it later. */ - -static int -push_tinst_level (tree d) -{ - tree new; - - if (tinst_depth >= max_tinst_depth) - { - /* If the instantiation in question still has unbound template parms, - we don't really care if we can't instantiate it, so just return. - This happens with base instantiation for implicit `typename'. */ - if (uses_template_parms (d)) - return 0; - - last_template_error_tick = tinst_level_tick; - error ("template instantiation depth exceeds maximum of %d (use " - "-ftemplate-depth-NN to increase the maximum) instantiating %qD", - max_tinst_depth, d); - - print_instantiation_context (); - - return 0; - } - - new = make_node (TINST_LEVEL); - TINST_DECL (new) = d; - TINST_LOCATION (new) = input_location; - TINST_IN_SYSTEM_HEADER_P (new) = in_system_header; - TREE_CHAIN (new) = current_tinst_level; - current_tinst_level = new; - - ++tinst_depth; -#ifdef GATHER_STATISTICS - if (tinst_depth > depth_reached) - depth_reached = tinst_depth; -#endif - - ++tinst_level_tick; - return 1; -} - -/* We're done instantiating this template; return to the instantiation - context. */ - -static void -pop_tinst_level (void) -{ - tree old = current_tinst_level; - - /* Restore the filename and line number stashed away when we started - this instantiation. */ - input_location = TINST_LOCATION (old); - in_system_header = TINST_IN_SYSTEM_HEADER_P (old); - current_tinst_level = TREE_CHAIN (old); - --tinst_depth; - ++tinst_level_tick; -} - -/* We're instantiating a deferred template; restore the template - instantiation context in which the instantiation was requested, which - is one step out from LEVEL. */ - -static void -reopen_tinst_level (tree level) -{ - tree t; - - tinst_depth = 0; - for (t = level; t; t = TREE_CHAIN (t)) - ++tinst_depth; - - current_tinst_level = level; - pop_tinst_level (); -} - -/* APPLE LOCAL begin mainline radar 6194879 */ -/* Returns the TINST_LEVEL which gives the original instantiation - context. */ - -tree -outermost_tinst_level (void) -{ - return tree_last (current_tinst_level); -} - -/* APPLE LOCAL end mainline radar 6194879 */ -/* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the - vector of template arguments, as for tsubst. - - Returns an appropriate tsubst'd friend declaration. */ - -static tree -tsubst_friend_function (tree decl, tree args) -{ - tree new_friend; - - if (TREE_CODE (decl) == FUNCTION_DECL - && DECL_TEMPLATE_INSTANTIATION (decl) - && TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL) - /* This was a friend declared with an explicit template - argument list, e.g.: - - friend void f<>(T); - - to indicate that f was a template instantiation, not a new - function declaration. Now, we have to figure out what - instantiation of what template. */ - { - tree template_id, arglist, fns; - tree new_args; - tree tmpl; - tree ns = decl_namespace_context (TYPE_MAIN_DECL (current_class_type)); - - /* Friend functions are looked up in the containing namespace scope. - We must enter that scope, to avoid finding member functions of the - current cless with same name. */ - push_nested_namespace (ns); - fns = tsubst_expr (DECL_TI_TEMPLATE (decl), args, - tf_warning_or_error, NULL_TREE, - /*integral_constant_expression_p=*/false); - pop_nested_namespace (ns); - arglist = tsubst (DECL_TI_ARGS (decl), args, - tf_warning_or_error, NULL_TREE); - template_id = lookup_template_function (fns, arglist); - - new_friend = tsubst (decl, args, tf_warning_or_error, NULL_TREE); - tmpl = determine_specialization (template_id, new_friend, - &new_args, - /*need_member_template=*/0, - TREE_VEC_LENGTH (args), - tsk_none); - return instantiate_template (tmpl, new_args, tf_error); - } - - new_friend = tsubst (decl, args, tf_warning_or_error, NULL_TREE); - - /* The NEW_FRIEND will look like an instantiation, to the - compiler, but is not an instantiation from the point of view of - the language. For example, we might have had: - - template <class T> struct S { - template <class U> friend void f(T, U); - }; - - Then, in S<int>, template <class U> void f(int, U) is not an - instantiation of anything. */ - if (new_friend == error_mark_node) - return error_mark_node; - - DECL_USE_TEMPLATE (new_friend) = 0; - if (TREE_CODE (decl) == TEMPLATE_DECL) - { - DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend)) = 0; - DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend)) - = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl)); - } - - /* The mangled name for the NEW_FRIEND is incorrect. The function - is not a template instantiation and should not be mangled like - one. Therefore, we forget the mangling here; we'll recompute it - later if we need it. */ - if (TREE_CODE (new_friend) != TEMPLATE_DECL) - { - SET_DECL_RTL (new_friend, NULL_RTX); - SET_DECL_ASSEMBLER_NAME (new_friend, NULL_TREE); - } - - if (DECL_NAMESPACE_SCOPE_P (new_friend)) - { - tree old_decl; - tree new_friend_template_info; - tree new_friend_result_template_info; - tree ns; - int new_friend_is_defn; - - /* We must save some information from NEW_FRIEND before calling - duplicate decls since that function will free NEW_FRIEND if - possible. */ - new_friend_template_info = DECL_TEMPLATE_INFO (new_friend); - new_friend_is_defn = - (DECL_INITIAL (DECL_TEMPLATE_RESULT - (template_for_substitution (new_friend))) - != NULL_TREE); - if (TREE_CODE (new_friend) == TEMPLATE_DECL) - { - /* This declaration is a `primary' template. */ - DECL_PRIMARY_TEMPLATE (new_friend) = new_friend; - - new_friend_result_template_info - = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend)); - } - else - new_friend_result_template_info = NULL_TREE; - - /* Make the init_value nonzero so pushdecl knows this is a defn. */ - if (new_friend_is_defn) - DECL_INITIAL (new_friend) = error_mark_node; - - /* Inside pushdecl_namespace_level, we will push into the - current namespace. However, the friend function should go - into the namespace of the template. */ - ns = decl_namespace_context (new_friend); - push_nested_namespace (ns); - old_decl = pushdecl_namespace_level (new_friend, /*is_friend=*/true); - pop_nested_namespace (ns); - - if (old_decl == error_mark_node) - return error_mark_node; - - if (old_decl != new_friend) - { - /* This new friend declaration matched an existing - declaration. For example, given: - - template <class T> void f(T); - template <class U> class C { - template <class T> friend void f(T) {} - }; - - the friend declaration actually provides the definition - of `f', once C has been instantiated for some type. So, - old_decl will be the out-of-class template declaration, - while new_friend is the in-class definition. - - But, if `f' was called before this point, the - instantiation of `f' will have DECL_TI_ARGS corresponding - to `T' but not to `U', references to which might appear - in the definition of `f'. Previously, the most general - template for an instantiation of `f' was the out-of-class - version; now it is the in-class version. Therefore, we - run through all specialization of `f', adding to their - DECL_TI_ARGS appropriately. In particular, they need a - new set of outer arguments, corresponding to the - arguments for this class instantiation. - - The same situation can arise with something like this: - - friend void f(int); - template <class T> class C { - friend void f(T) {} - }; - - when `C<int>' is instantiated. Now, `f(int)' is defined - in the class. */ - - if (!new_friend_is_defn) - /* On the other hand, if the in-class declaration does - *not* provide a definition, then we don't want to alter - existing definitions. We can just leave everything - alone. */ - ; - else - { - /* Overwrite whatever template info was there before, if - any, with the new template information pertaining to - the declaration. */ - DECL_TEMPLATE_INFO (old_decl) = new_friend_template_info; - - if (TREE_CODE (old_decl) != TEMPLATE_DECL) - reregister_specialization (new_friend, - most_general_template (old_decl), - old_decl); - else - { - tree t; - tree new_friend_args; - - DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl)) - = new_friend_result_template_info; - - new_friend_args = TI_ARGS (new_friend_template_info); - for (t = DECL_TEMPLATE_SPECIALIZATIONS (old_decl); - t != NULL_TREE; - t = TREE_CHAIN (t)) - { - tree spec = TREE_VALUE (t); - - DECL_TI_ARGS (spec) - = add_outermost_template_args (new_friend_args, - DECL_TI_ARGS (spec)); - } - - /* Now, since specializations are always supposed to - hang off of the most general template, we must move - them. */ - t = most_general_template (old_decl); - if (t != old_decl) - { - DECL_TEMPLATE_SPECIALIZATIONS (t) - = chainon (DECL_TEMPLATE_SPECIALIZATIONS (t), - DECL_TEMPLATE_SPECIALIZATIONS (old_decl)); - DECL_TEMPLATE_SPECIALIZATIONS (old_decl) = NULL_TREE; - } - } - } - - /* The information from NEW_FRIEND has been merged into OLD_DECL - by duplicate_decls. */ - new_friend = old_decl; - } - } - else - { - tree context = DECL_CONTEXT (new_friend); - bool dependent_p; - - /* In the code - template <class T> class C { - template <class U> friend void C1<U>::f (); // case 1 - friend void C2<T>::f (); // case 2 - }; - we only need to make sure CONTEXT is a complete type for - case 2. To distinguish between the two cases, we note that - CONTEXT of case 1 remains dependent type after tsubst while - this isn't true for case 2. */ - ++processing_template_decl; - dependent_p = dependent_type_p (context); - --processing_template_decl; - - if (!dependent_p - && !complete_type_or_else (context, NULL_TREE)) - return error_mark_node; - - if (COMPLETE_TYPE_P (context)) - { - /* Check to see that the declaration is really present, and, - possibly obtain an improved declaration. */ - tree fn = check_classfn (context, - new_friend, NULL_TREE); - - if (fn) - new_friend = fn; - } - } - - return new_friend; -} - -/* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of - template arguments, as for tsubst. - - Returns an appropriate tsubst'd friend type or error_mark_node on - failure. */ - -static tree -tsubst_friend_class (tree friend_tmpl, tree args) -{ - tree friend_type; - tree tmpl; - tree context; - - context = DECL_CONTEXT (friend_tmpl); - - if (context) - { - if (TREE_CODE (context) == NAMESPACE_DECL) - push_nested_namespace (context); - else - push_nested_class (tsubst (context, args, tf_none, NULL_TREE)); - } - - /* Look for a class template declaration. We look for hidden names - because two friend declarations of the same template are the - same. For example, in: - - struct A { - template <typename> friend class F; - }; - template <typename> struct B { - template <typename> friend class F; - }; - - both F templates are the same. */ - tmpl = lookup_name_real (DECL_NAME (friend_tmpl), 0, 0, - /*block_p=*/true, 0, - LOOKUP_COMPLAIN | LOOKUP_HIDDEN); - - /* But, if we don't find one, it might be because we're in a - situation like this: - - template <class T> - struct S { - template <class U> - friend struct S; - }; - - Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL - for `S<int>', not the TEMPLATE_DECL. */ - if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl)) - { - tmpl = lookup_name_prefer_type (DECL_NAME (friend_tmpl), 1); - tmpl = maybe_get_template_decl_from_type_decl (tmpl); - } - - if (tmpl && DECL_CLASS_TEMPLATE_P (tmpl)) - { - /* The friend template has already been declared. Just - check to see that the declarations match, and install any new - default parameters. We must tsubst the default parameters, - of course. We only need the innermost template parameters - because that is all that redeclare_class_template will look - at. */ - if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl)) - > TMPL_ARGS_DEPTH (args)) - { - tree parms; - parms = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl), - args, tf_warning_or_error); - redeclare_class_template (TREE_TYPE (tmpl), parms); - } - - friend_type = TREE_TYPE (tmpl); - } - else - { - /* The friend template has not already been declared. In this - case, the instantiation of the template class will cause the - injection of this template into the global scope. */ - tmpl = tsubst (friend_tmpl, args, tf_warning_or_error, NULL_TREE); - if (tmpl == error_mark_node) - return error_mark_node; - - /* The new TMPL is not an instantiation of anything, so we - forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for - the new type because that is supposed to be the corresponding - template decl, i.e., TMPL. */ - DECL_USE_TEMPLATE (tmpl) = 0; - DECL_TEMPLATE_INFO (tmpl) = NULL_TREE; - CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl)) = 0; - CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl)) - = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl))); - - /* Inject this template into the global scope. */ - friend_type = TREE_TYPE (pushdecl_top_level_maybe_friend (tmpl, true)); - } - - if (context) - { - if (TREE_CODE (context) == NAMESPACE_DECL) - pop_nested_namespace (context); - else - pop_nested_class (); - } - - return friend_type; -} - -/* Returns zero if TYPE cannot be completed later due to circularity. - Otherwise returns one. */ - -static int -can_complete_type_without_circularity (tree type) -{ - if (type == NULL_TREE || type == error_mark_node) - return 0; - else if (COMPLETE_TYPE_P (type)) - return 1; - else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type)) - return can_complete_type_without_circularity (TREE_TYPE (type)); - else if (CLASS_TYPE_P (type) - && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type))) - return 0; - else - return 1; -} - -tree -instantiate_class_template (tree type) -{ - tree template, args, pattern, t, member; - tree typedecl; - tree pbinfo; - tree base_list; - - if (type == error_mark_node) - return error_mark_node; - - if (TYPE_BEING_DEFINED (type) - || COMPLETE_TYPE_P (type) - || dependent_type_p (type)) - return type; - - /* Figure out which template is being instantiated. */ - template = most_general_template (CLASSTYPE_TI_TEMPLATE (type)); - gcc_assert (TREE_CODE (template) == TEMPLATE_DECL); - - /* Determine what specialization of the original template to - instantiate. */ - t = most_specialized_class (type, template); - if (t == error_mark_node) - { - TYPE_BEING_DEFINED (type) = 1; - return error_mark_node; - } - else if (t) - { - /* This TYPE is actually an instantiation of a partial - specialization. We replace the innermost set of ARGS with - the arguments appropriate for substitution. For example, - given: - - template <class T> struct S {}; - template <class T> struct S<T*> {}; - - and supposing that we are instantiating S<int*>, ARGS will - presently be {int*} -- but we need {int}. */ - pattern = TREE_TYPE (t); - args = TREE_PURPOSE (t); - } - else - { - pattern = TREE_TYPE (template); - args = CLASSTYPE_TI_ARGS (type); - } - - /* If the template we're instantiating is incomplete, then clearly - there's nothing we can do. */ - if (!COMPLETE_TYPE_P (pattern)) - return type; - - /* If we've recursively instantiated too many templates, stop. */ - if (! push_tinst_level (type)) - return type; - - /* Now we're really doing the instantiation. Mark the type as in - the process of being defined. */ - TYPE_BEING_DEFINED (type) = 1; - - /* We may be in the middle of deferred access check. Disable - it now. */ - push_deferring_access_checks (dk_no_deferred); - - push_to_top_level (); - - SET_CLASSTYPE_INTERFACE_UNKNOWN (type); - - /* Set the input location to the template definition. This is needed - if tsubsting causes an error. */ - typedecl = TYPE_MAIN_DECL (type); - input_location = DECL_SOURCE_LOCATION (typedecl); - in_system_header = DECL_IN_SYSTEM_HEADER (typedecl); - - TYPE_HAS_CONSTRUCTOR (type) = TYPE_HAS_CONSTRUCTOR (pattern); - TYPE_HAS_NEW_OPERATOR (type) = TYPE_HAS_NEW_OPERATOR (pattern); - TYPE_HAS_ARRAY_NEW_OPERATOR (type) = TYPE_HAS_ARRAY_NEW_OPERATOR (pattern); - TYPE_GETS_DELETE (type) = TYPE_GETS_DELETE (pattern); - TYPE_HAS_ASSIGN_REF (type) = TYPE_HAS_ASSIGN_REF (pattern); - TYPE_HAS_CONST_ASSIGN_REF (type) = TYPE_HAS_CONST_ASSIGN_REF (pattern); - TYPE_HAS_INIT_REF (type) = TYPE_HAS_INIT_REF (pattern); - TYPE_HAS_CONST_INIT_REF (type) = TYPE_HAS_CONST_INIT_REF (pattern); - TYPE_HAS_DEFAULT_CONSTRUCTOR (type) = TYPE_HAS_DEFAULT_CONSTRUCTOR (pattern); - TYPE_HAS_CONVERSION (type) = TYPE_HAS_CONVERSION (pattern); - TYPE_PACKED (type) = TYPE_PACKED (pattern); - TYPE_ALIGN (type) = TYPE_ALIGN (pattern); - TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (pattern); - TYPE_FOR_JAVA (type) = TYPE_FOR_JAVA (pattern); /* For libjava's JArray<T> */ - if (ANON_AGGR_TYPE_P (pattern)) - SET_ANON_AGGR_TYPE_P (type); - if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern)) - { - CLASSTYPE_VISIBILITY_SPECIFIED (type) = 1; - /* APPLE LOCAL begin 5812195 */ - /* CLASSTYPE_VISIBILITY (type) should already be set by the time - we get here, in particular, we should just constrain the - visibility, as we don't reconstrain on template arguments - post this whereas we've already done that by the time we get - here. */ - if (CLASSTYPE_VISIBILITY (type) < CLASSTYPE_VISIBILITY (pattern)) - CLASSTYPE_VISIBILITY (type) = CLASSTYPE_VISIBILITY (pattern); - /* APPLE LOCAL end 5812195 */ - } - - pbinfo = TYPE_BINFO (pattern); - - /* We should never instantiate a nested class before its enclosing - class; we need to look up the nested class by name before we can - instantiate it, and that lookup should instantiate the enclosing - class. */ - gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern)) - || COMPLETE_TYPE_P (TYPE_CONTEXT (type)) - || TYPE_BEING_DEFINED (TYPE_CONTEXT (type))); - - base_list = NULL_TREE; - if (BINFO_N_BASE_BINFOS (pbinfo)) - { - tree pbase_binfo; - tree context = TYPE_CONTEXT (type); - tree pushed_scope; - int i; - - /* We must enter the scope containing the type, as that is where - the accessibility of types named in dependent bases are - looked up from. */ - pushed_scope = push_scope (context ? context : global_namespace); - - /* Substitute into each of the bases to determine the actual - basetypes. */ - for (i = 0; BINFO_BASE_ITERATE (pbinfo, i, pbase_binfo); i++) - { - tree base; - tree access = BINFO_BASE_ACCESS (pbinfo, i); - - /* Substitute to figure out the base class. */ - base = tsubst (BINFO_TYPE (pbase_binfo), args, tf_error, NULL_TREE); - if (base == error_mark_node) - continue; - - base_list = tree_cons (access, base, base_list); - if (BINFO_VIRTUAL_P (pbase_binfo)) - TREE_TYPE (base_list) = integer_type_node; - } - - /* The list is now in reverse order; correct that. */ - base_list = nreverse (base_list); - - if (pushed_scope) - pop_scope (pushed_scope); - } - /* Now call xref_basetypes to set up all the base-class - information. */ - xref_basetypes (type, base_list); - - - /* Now that our base classes are set up, enter the scope of the - class, so that name lookups into base classes, etc. will work - correctly. This is precisely analogous to what we do in - begin_class_definition when defining an ordinary non-template - class. */ - pushclass (type); - - /* Now members are processed in the order of declaration. */ - for (member = CLASSTYPE_DECL_LIST (pattern); - member; member = TREE_CHAIN (member)) - { - tree t = TREE_VALUE (member); - - if (TREE_PURPOSE (member)) - { - if (TYPE_P (t)) - { - /* Build new CLASSTYPE_NESTED_UTDS. */ - - tree newtag; - bool class_template_p; - - class_template_p = (TREE_CODE (t) != ENUMERAL_TYPE - && TYPE_LANG_SPECIFIC (t) - && CLASSTYPE_IS_TEMPLATE (t)); - /* If the member is a class template, then -- even after - substitution -- there may be dependent types in the - template argument list for the class. We increment - PROCESSING_TEMPLATE_DECL so that dependent_type_p, as - that function will assume that no types are dependent - when outside of a template. */ - if (class_template_p) - ++processing_template_decl; - newtag = tsubst (t, args, tf_error, NULL_TREE); - if (class_template_p) - --processing_template_decl; - if (newtag == error_mark_node) - continue; - - if (TREE_CODE (newtag) != ENUMERAL_TYPE) - { - tree name = TYPE_IDENTIFIER (t); - - if (class_template_p) - /* Unfortunately, lookup_template_class sets - CLASSTYPE_IMPLICIT_INSTANTIATION for a partial - instantiation (i.e., for the type of a member - template class nested within a template class.) - This behavior is required for - maybe_process_partial_specialization to work - correctly, but is not accurate in this case; - the TAG is not an instantiation of anything. - (The corresponding TEMPLATE_DECL is an - instantiation, but the TYPE is not.) */ - CLASSTYPE_USE_TEMPLATE (newtag) = 0; - - /* Now, we call pushtag to put this NEWTAG into the scope of - TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid - pushtag calling push_template_decl. We don't have to do - this for enums because it will already have been done in - tsubst_enum. */ - if (name) - SET_IDENTIFIER_TYPE_VALUE (name, newtag); - pushtag (name, newtag, /*tag_scope=*/ts_current); - } - } - else if (TREE_CODE (t) == FUNCTION_DECL - || DECL_FUNCTION_TEMPLATE_P (t)) - { - /* Build new TYPE_METHODS. */ - tree r; - - if (TREE_CODE (t) == TEMPLATE_DECL) - ++processing_template_decl; - r = tsubst (t, args, tf_error, NULL_TREE); - if (TREE_CODE (t) == TEMPLATE_DECL) - --processing_template_decl; - set_current_access_from_decl (r); - finish_member_declaration (r); - } - else - { - /* Build new TYPE_FIELDS. */ - - if (TREE_CODE (t) != CONST_DECL) - { - tree r; - - /* The the file and line for this declaration, to - assist in error message reporting. Since we - called push_tinst_level above, we don't need to - restore these. */ - input_location = DECL_SOURCE_LOCATION (t); - - if (TREE_CODE (t) == TEMPLATE_DECL) - ++processing_template_decl; - r = tsubst (t, args, tf_warning_or_error, NULL_TREE); - if (TREE_CODE (t) == TEMPLATE_DECL) - --processing_template_decl; - if (TREE_CODE (r) == VAR_DECL) - { - /* In [temp.inst]: - - [t]he initialization (and any associated - side-effects) of a static data member does - not occur unless the static data member is - itself used in a way that requires the - definition of the static data member to - exist. - - Therefore, we do not substitute into the - initialized for the static data member here. */ - finish_static_data_member_decl - (r, - /*init=*/NULL_TREE, - /*init_const_expr_p=*/false, - /*asmspec_tree=*/NULL_TREE, - /*flags=*/0); - if (DECL_INITIALIZED_IN_CLASS_P (r)) - check_static_variable_definition (r, TREE_TYPE (r)); - } - else if (TREE_CODE (r) == FIELD_DECL) - { - /* Determine whether R has a valid type and can be - completed later. If R is invalid, then it is - replaced by error_mark_node so that it will not be - added to TYPE_FIELDS. */ - tree rtype = TREE_TYPE (r); - if (can_complete_type_without_circularity (rtype)) - complete_type (rtype); - - if (!COMPLETE_TYPE_P (rtype)) - { - cxx_incomplete_type_error (r, rtype); - r = error_mark_node; - } - } - - /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE, - such a thing will already have been added to the field - list by tsubst_enum in finish_member_declaration in the - CLASSTYPE_NESTED_UTDS case above. */ - if (!(TREE_CODE (r) == TYPE_DECL - && TREE_CODE (TREE_TYPE (r)) == ENUMERAL_TYPE - && DECL_ARTIFICIAL (r))) - { - set_current_access_from_decl (r); - finish_member_declaration (r); - } - } - } - } - else - { - if (TYPE_P (t) || DECL_CLASS_TEMPLATE_P (t)) - { - /* Build new CLASSTYPE_FRIEND_CLASSES. */ - - tree friend_type = t; - bool adjust_processing_template_decl = false; - - if (TREE_CODE (friend_type) == TEMPLATE_DECL) - { - /* template <class T> friend class C; */ - friend_type = tsubst_friend_class (friend_type, args); - adjust_processing_template_decl = true; - } - else if (TREE_CODE (friend_type) == UNBOUND_CLASS_TEMPLATE) - { - /* template <class T> friend class C::D; */ - friend_type = tsubst (friend_type, args, - tf_warning_or_error, NULL_TREE); - if (TREE_CODE (friend_type) == TEMPLATE_DECL) - friend_type = TREE_TYPE (friend_type); - adjust_processing_template_decl = true; - } - else if (TREE_CODE (friend_type) == TYPENAME_TYPE) - { - /* This could be either - - friend class T::C; - - when dependent_type_p is false or - - template <class U> friend class T::C; - - otherwise. */ - friend_type = tsubst (friend_type, args, - tf_warning_or_error, NULL_TREE); - /* Bump processing_template_decl for correct - dependent_type_p calculation. */ - ++processing_template_decl; - if (dependent_type_p (friend_type)) - adjust_processing_template_decl = true; - --processing_template_decl; - } - else if (!CLASSTYPE_USE_TEMPLATE (friend_type) - && hidden_name_p (TYPE_NAME (friend_type))) - { - /* friend class C; - - where C hasn't been declared yet. Let's lookup name - from namespace scope directly, bypassing any name that - come from dependent base class. */ - tree ns = decl_namespace_context (TYPE_MAIN_DECL (friend_type)); - - /* The call to xref_tag_from_type does injection for friend - classes. */ - push_nested_namespace (ns); - friend_type = - xref_tag_from_type (friend_type, NULL_TREE, - /*tag_scope=*/ts_current); - pop_nested_namespace (ns); - } - else if (uses_template_parms (friend_type)) - /* friend class C<T>; */ - friend_type = tsubst (friend_type, args, - tf_warning_or_error, NULL_TREE); - /* Otherwise it's - - friend class C; - - where C is already declared or - - friend class C<int>; - - We don't have to do anything in these cases. */ - - if (adjust_processing_template_decl) - /* Trick make_friend_class into realizing that the friend - we're adding is a template, not an ordinary class. It's - important that we use make_friend_class since it will - perform some error-checking and output cross-reference - information. */ - ++processing_template_decl; - - if (friend_type != error_mark_node) - make_friend_class (type, friend_type, /*complain=*/false); - - if (adjust_processing_template_decl) - --processing_template_decl; - } - else - { - /* Build new DECL_FRIENDLIST. */ - tree r; - - /* The the file and line for this declaration, to - assist in error message reporting. Since we - called push_tinst_level above, we don't need to - restore these. */ - input_location = DECL_SOURCE_LOCATION (t); - - if (TREE_CODE (t) == TEMPLATE_DECL) - { - ++processing_template_decl; - push_deferring_access_checks (dk_no_check); - } - - r = tsubst_friend_function (t, args); - add_friend (type, r, /*complain=*/false); - if (TREE_CODE (t) == TEMPLATE_DECL) - { - pop_deferring_access_checks (); - --processing_template_decl; - } - } - } - } - - /* Set the file and line number information to whatever is given for - the class itself. This puts error messages involving generated - implicit functions at a predictable point, and the same point - that would be used for non-template classes. */ - input_location = DECL_SOURCE_LOCATION (typedecl); - - unreverse_member_declarations (type); - finish_struct_1 (type); - TYPE_BEING_DEFINED (type) = 0; - - /* Now that the class is complete, instantiate default arguments for - any member functions. We don't do this earlier because the - default arguments may reference members of the class. */ - if (!PRIMARY_TEMPLATE_P (template)) - for (t = TYPE_METHODS (type); t; t = TREE_CHAIN (t)) - if (TREE_CODE (t) == FUNCTION_DECL - /* Implicitly generated member functions will not have template - information; they are not instantiations, but instead are - created "fresh" for each instantiation. */ - && DECL_TEMPLATE_INFO (t)) - tsubst_default_arguments (t); - - popclass (); - pop_from_top_level (); - pop_deferring_access_checks (); - pop_tinst_level (); - - /* The vtable for a template class can be emitted in any translation - unit in which the class is instantiated. When there is no key - method, however, finish_struct_1 will already have added TYPE to - the keyed_classes list. */ - if (TYPE_CONTAINS_VPTR_P (type) && CLASSTYPE_KEY_METHOD (type)) - keyed_classes = tree_cons (NULL_TREE, type, keyed_classes); - - return type; -} - -static tree -tsubst_template_arg (tree t, tree args, tsubst_flags_t complain, tree in_decl) -{ - tree r; - - if (!t) - r = t; - else if (TYPE_P (t)) - r = tsubst (t, args, complain, in_decl); - else - { - r = tsubst_expr (t, args, complain, in_decl, - /*integral_constant_expression_p=*/true); - r = fold_non_dependent_expr (r); - } - return r; -} - -/* Substitute ARGS into the vector or list of template arguments T. */ - -static tree -tsubst_template_args (tree t, tree args, tsubst_flags_t complain, tree in_decl) -{ - int len = TREE_VEC_LENGTH (t); - int need_new = 0, i; - tree *elts = (tree *) alloca (len * sizeof (tree)); - - for (i = 0; i < len; i++) - { - tree orig_arg = TREE_VEC_ELT (t, i); - tree new_arg; - - if (TREE_CODE (orig_arg) == TREE_VEC) - new_arg = tsubst_template_args (orig_arg, args, complain, in_decl); - else - new_arg = tsubst_template_arg (orig_arg, args, complain, in_decl); - - if (new_arg == error_mark_node) - return error_mark_node; - - elts[i] = new_arg; - if (new_arg != orig_arg) - need_new = 1; - } - - if (!need_new) - return t; - - t = make_tree_vec (len); - for (i = 0; i < len; i++) - TREE_VEC_ELT (t, i) = elts[i]; - - return t; -} - -/* Return the result of substituting ARGS into the template parameters - given by PARMS. If there are m levels of ARGS and m + n levels of - PARMS, then the result will contain n levels of PARMS. For - example, if PARMS is `template <class T> template <class U> - template <T*, U, class V>' and ARGS is {{int}, {double}} then the - result will be `template <int*, double, class V>'. */ - -static tree -tsubst_template_parms (tree parms, tree args, tsubst_flags_t complain) -{ - tree r = NULL_TREE; - tree* new_parms; - - /* When substituting into a template, we must set - PROCESSING_TEMPLATE_DECL as the template parameters may be - dependent if they are based on one-another, and the dependency - predicates are short-circuit outside of templates. */ - ++processing_template_decl; - - for (new_parms = &r; - TMPL_PARMS_DEPTH (parms) > TMPL_ARGS_DEPTH (args); - new_parms = &(TREE_CHAIN (*new_parms)), - parms = TREE_CHAIN (parms)) - { - tree new_vec = - make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms))); - int i; - - for (i = 0; i < TREE_VEC_LENGTH (new_vec); ++i) - { - tree tuple; - tree default_value; - tree parm_decl; - - if (parms == error_mark_node) - continue; - - tuple = TREE_VEC_ELT (TREE_VALUE (parms), i); - - if (tuple == error_mark_node) - continue; - - default_value = TREE_PURPOSE (tuple); - parm_decl = TREE_VALUE (tuple); - - parm_decl = tsubst (parm_decl, args, complain, NULL_TREE); - if (TREE_CODE (parm_decl) == PARM_DECL - && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl), complain)) - parm_decl = error_mark_node; - default_value = tsubst_template_arg (default_value, args, - complain, NULL_TREE); - - tuple = build_tree_list (default_value, parm_decl); - TREE_VEC_ELT (new_vec, i) = tuple; - } - - *new_parms = - tree_cons (size_int (TMPL_PARMS_DEPTH (parms) - - TMPL_ARGS_DEPTH (args)), - new_vec, NULL_TREE); - } - - --processing_template_decl; - - return r; -} - -/* Substitute the ARGS into the indicated aggregate (or enumeration) - type T. If T is not an aggregate or enumeration type, it is - handled as if by tsubst. IN_DECL is as for tsubst. If - ENTERING_SCOPE is nonzero, T is the context for a template which - we are presently tsubst'ing. Return the substituted value. */ - -static tree -tsubst_aggr_type (tree t, - tree args, - tsubst_flags_t complain, - tree in_decl, - int entering_scope) -{ - if (t == NULL_TREE) - return NULL_TREE; - - switch (TREE_CODE (t)) - { - case RECORD_TYPE: - if (TYPE_PTRMEMFUNC_P (t)) - return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t), args, complain, in_decl); - - /* Else fall through. */ - case ENUMERAL_TYPE: - case UNION_TYPE: - if (TYPE_TEMPLATE_INFO (t)) - { - tree argvec; - tree context; - tree r; - bool saved_skip_evaluation; - - /* In "sizeof(X<I>)" we need to evaluate "I". */ - saved_skip_evaluation = skip_evaluation; - skip_evaluation = false; - - /* First, determine the context for the type we are looking - up. */ - context = TYPE_CONTEXT (t); - if (context) - context = tsubst_aggr_type (context, args, complain, - in_decl, /*entering_scope=*/1); - - /* Then, figure out what arguments are appropriate for the - type we are trying to find. For example, given: - - template <class T> struct S; - template <class T, class U> void f(T, U) { S<U> su; } - - and supposing that we are instantiating f<int, double>, - then our ARGS will be {int, double}, but, when looking up - S we only want {double}. */ - argvec = tsubst_template_args (TYPE_TI_ARGS (t), args, - complain, in_decl); - if (argvec == error_mark_node) - r = error_mark_node; - else - { - r = lookup_template_class (t, argvec, in_decl, context, - entering_scope, complain); - r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain); - } - - skip_evaluation = saved_skip_evaluation; - - return r; - } - else - /* This is not a template type, so there's nothing to do. */ - return t; - - default: - return tsubst (t, args, complain, in_decl); - } -} - -/* Substitute into the default argument ARG (a default argument for - FN), which has the indicated TYPE. */ - -tree -tsubst_default_argument (tree fn, tree type, tree arg) -{ - tree saved_class_ptr = NULL_TREE; - tree saved_class_ref = NULL_TREE; - - /* This default argument came from a template. Instantiate the - default argument here, not in tsubst. In the case of - something like: - - template <class T> - struct S { - static T t(); - void f(T = t()); - }; - - we must be careful to do name lookup in the scope of S<T>, - rather than in the current class. */ - push_access_scope (fn); - /* The "this" pointer is not valid in a default argument. */ - if (cfun) - { - saved_class_ptr = current_class_ptr; - cp_function_chain->x_current_class_ptr = NULL_TREE; - saved_class_ref = current_class_ref; - cp_function_chain->x_current_class_ref = NULL_TREE; - } - - push_deferring_access_checks(dk_no_deferred); - /* The default argument expression may cause implicitly defined - member functions to be synthesized, which will result in garbage - collection. We must treat this situation as if we were within - the body of function so as to avoid collecting live data on the - stack. */ - ++function_depth; - arg = tsubst_expr (arg, DECL_TI_ARGS (fn), - tf_warning_or_error, NULL_TREE, - /*integral_constant_expression_p=*/false); - --function_depth; - pop_deferring_access_checks(); - - /* Restore the "this" pointer. */ - if (cfun) - { - cp_function_chain->x_current_class_ptr = saved_class_ptr; - cp_function_chain->x_current_class_ref = saved_class_ref; - } - - pop_access_scope (fn); - - /* Make sure the default argument is reasonable. */ - arg = check_default_argument (type, arg); - - return arg; -} - -/* Substitute into all the default arguments for FN. */ - -static void -tsubst_default_arguments (tree fn) -{ - tree arg; - tree tmpl_args; - - tmpl_args = DECL_TI_ARGS (fn); - - /* If this function is not yet instantiated, we certainly don't need - its default arguments. */ - if (uses_template_parms (tmpl_args)) - return; - - for (arg = TYPE_ARG_TYPES (TREE_TYPE (fn)); - arg; - arg = TREE_CHAIN (arg)) - if (TREE_PURPOSE (arg)) - TREE_PURPOSE (arg) = tsubst_default_argument (fn, - TREE_VALUE (arg), - TREE_PURPOSE (arg)); -} - -/* Substitute the ARGS into the T, which is a _DECL. Return the - result of the substitution. Issue error and warning messages under - control of COMPLAIN. */ - -static tree -tsubst_decl (tree t, tree args, tsubst_flags_t complain) -{ - location_t saved_loc; - tree r = NULL_TREE; - tree in_decl = t; - - /* Set the filename and linenumber to improve error-reporting. */ - saved_loc = input_location; - input_location = DECL_SOURCE_LOCATION (t); - - switch (TREE_CODE (t)) - { - case TEMPLATE_DECL: - { - /* We can get here when processing a member function template, - member class template, and template template parameter of - a template class. */ - tree decl = DECL_TEMPLATE_RESULT (t); - tree spec; - tree tmpl_args; - tree full_args; - - if (DECL_TEMPLATE_TEMPLATE_PARM_P (t)) - { - /* Template template parameter is treated here. */ - tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl); - if (new_type == error_mark_node) - return error_mark_node; - - r = copy_decl (t); - TREE_CHAIN (r) = NULL_TREE; - TREE_TYPE (r) = new_type; - DECL_TEMPLATE_RESULT (r) - = build_decl (TYPE_DECL, DECL_NAME (decl), new_type); - DECL_TEMPLATE_PARMS (r) - = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args, - complain); - TYPE_NAME (new_type) = r; - break; - } - - /* We might already have an instance of this template. - The ARGS are for the surrounding class type, so the - full args contain the tsubst'd args for the context, - plus the innermost args from the template decl. */ - tmpl_args = DECL_CLASS_TEMPLATE_P (t) - ? CLASSTYPE_TI_ARGS (TREE_TYPE (t)) - : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t)); - /* Because this is a template, the arguments will still be - dependent, even after substitution. If - PROCESSING_TEMPLATE_DECL is not set, the dependency - predicates will short-circuit. */ - ++processing_template_decl; - full_args = tsubst_template_args (tmpl_args, args, - complain, in_decl); - --processing_template_decl; - if (full_args == error_mark_node) - return error_mark_node; - - /* tsubst_template_args doesn't copy the vector if - nothing changed. But, *something* should have - changed. */ - gcc_assert (full_args != tmpl_args); - - spec = retrieve_specialization (t, full_args, - /*class_specializations_p=*/true); - if (spec != NULL_TREE) - { - r = spec; - break; - } - - /* Make a new template decl. It will be similar to the - original, but will record the current template arguments. - We also create a new function declaration, which is just - like the old one, but points to this new template, rather - than the old one. */ - r = copy_decl (t); - gcc_assert (DECL_LANG_SPECIFIC (r) != 0); - TREE_CHAIN (r) = NULL_TREE; - - DECL_TEMPLATE_INFO (r) = build_tree_list (t, args); - - if (TREE_CODE (decl) == TYPE_DECL) - { - tree new_type; - ++processing_template_decl; - new_type = tsubst (TREE_TYPE (t), args, complain, in_decl); - --processing_template_decl; - if (new_type == error_mark_node) - return error_mark_node; - - TREE_TYPE (r) = new_type; - CLASSTYPE_TI_TEMPLATE (new_type) = r; - DECL_TEMPLATE_RESULT (r) = TYPE_MAIN_DECL (new_type); - DECL_TI_ARGS (r) = CLASSTYPE_TI_ARGS (new_type); - DECL_CONTEXT (r) = TYPE_CONTEXT (new_type); - } - else - { - tree new_decl; - ++processing_template_decl; - new_decl = tsubst (decl, args, complain, in_decl); - --processing_template_decl; - if (new_decl == error_mark_node) - return error_mark_node; - - DECL_TEMPLATE_RESULT (r) = new_decl; - DECL_TI_TEMPLATE (new_decl) = r; - TREE_TYPE (r) = TREE_TYPE (new_decl); - DECL_TI_ARGS (r) = DECL_TI_ARGS (new_decl); - DECL_CONTEXT (r) = DECL_CONTEXT (new_decl); - } - - SET_DECL_IMPLICIT_INSTANTIATION (r); - DECL_TEMPLATE_INSTANTIATIONS (r) = NULL_TREE; - DECL_TEMPLATE_SPECIALIZATIONS (r) = NULL_TREE; - - /* The template parameters for this new template are all the - template parameters for the old template, except the - outermost level of parameters. */ - DECL_TEMPLATE_PARMS (r) - = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args, - complain); - - if (PRIMARY_TEMPLATE_P (t)) - DECL_PRIMARY_TEMPLATE (r) = r; - - if (TREE_CODE (decl) != TYPE_DECL) - /* Record this non-type partial instantiation. */ - register_specialization (r, t, - DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r)), - false); - } - break; - - case FUNCTION_DECL: - { - tree ctx; - tree argvec = NULL_TREE; - tree *friends; - tree gen_tmpl; - tree type; - int member; - int args_depth; - int parms_depth; - - /* Nobody should be tsubst'ing into non-template functions. */ - gcc_assert (DECL_TEMPLATE_INFO (t) != NULL_TREE); - - if (TREE_CODE (DECL_TI_TEMPLATE (t)) == TEMPLATE_DECL) - { - tree spec; - bool dependent_p; - - /* If T is not dependent, just return it. We have to - increment PROCESSING_TEMPLATE_DECL because - value_dependent_expression_p assumes that nothing is - dependent when PROCESSING_TEMPLATE_DECL is zero. */ - ++processing_template_decl; - dependent_p = value_dependent_expression_p (t); - --processing_template_decl; - if (!dependent_p) - return t; - - /* Calculate the most general template of which R is a - specialization, and the complete set of arguments used to - specialize R. */ - gen_tmpl = most_general_template (DECL_TI_TEMPLATE (t)); - argvec = tsubst_template_args (DECL_TI_ARGS - (DECL_TEMPLATE_RESULT (gen_tmpl)), - args, complain, in_decl); - - /* Check to see if we already have this specialization. */ - spec = retrieve_specialization (gen_tmpl, argvec, - /*class_specializations_p=*/false); - - if (spec) - { - r = spec; - break; - } - - /* We can see more levels of arguments than parameters if - there was a specialization of a member template, like - this: - - template <class T> struct S { template <class U> void f(); } - template <> template <class U> void S<int>::f(U); - - Here, we'll be substituting into the specialization, - because that's where we can find the code we actually - want to generate, but we'll have enough arguments for - the most general template. - - We also deal with the peculiar case: - - template <class T> struct S { - template <class U> friend void f(); - }; - template <class U> void f() {} - template S<int>; - template void f<double>(); - - Here, the ARGS for the instantiation of will be {int, - double}. But, we only need as many ARGS as there are - levels of template parameters in CODE_PATTERN. We are - careful not to get fooled into reducing the ARGS in - situations like: - - template <class T> struct S { template <class U> void f(U); } - template <class T> template <> void S<T>::f(int) {} - - which we can spot because the pattern will be a - specialization in this case. */ - args_depth = TMPL_ARGS_DEPTH (args); - parms_depth = - TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t))); - if (args_depth > parms_depth - && !DECL_TEMPLATE_SPECIALIZATION (t)) - args = get_innermost_template_args (args, parms_depth); - } - else - { - /* This special case arises when we have something like this: - - template <class T> struct S { - friend void f<int>(int, double); - }; - - Here, the DECL_TI_TEMPLATE for the friend declaration - will be an IDENTIFIER_NODE. We are being called from - tsubst_friend_function, and we want only to create a - new decl (R) with appropriate types so that we can call - determine_specialization. */ - gen_tmpl = NULL_TREE; - } - - if (DECL_CLASS_SCOPE_P (t)) - { - if (DECL_NAME (t) == constructor_name (DECL_CONTEXT (t))) - member = 2; - else - member = 1; - ctx = tsubst_aggr_type (DECL_CONTEXT (t), args, - complain, t, /*entering_scope=*/1); - } - else - { - member = 0; - ctx = DECL_CONTEXT (t); - } - type = tsubst (TREE_TYPE (t), args, complain, in_decl); - if (type == error_mark_node) - return error_mark_node; - - /* We do NOT check for matching decls pushed separately at this - point, as they may not represent instantiations of this - template, and in any case are considered separate under the - discrete model. */ - r = copy_decl (t); - DECL_USE_TEMPLATE (r) = 0; - TREE_TYPE (r) = type; - /* Clear out the mangled name and RTL for the instantiation. */ - SET_DECL_ASSEMBLER_NAME (r, NULL_TREE); - SET_DECL_RTL (r, NULL_RTX); - DECL_INITIAL (r) = NULL_TREE; - DECL_CONTEXT (r) = ctx; - - if (member && DECL_CONV_FN_P (r)) - /* Type-conversion operator. Reconstruct the name, in - case it's the name of one of the template's parameters. */ - DECL_NAME (r) = mangle_conv_op_name_for_type (TREE_TYPE (type)); - - DECL_ARGUMENTS (r) = tsubst (DECL_ARGUMENTS (t), args, - complain, t); - DECL_RESULT (r) = NULL_TREE; - - TREE_STATIC (r) = 0; - TREE_PUBLIC (r) = TREE_PUBLIC (t); - DECL_EXTERNAL (r) = 1; - /* If this is an instantiation of a function with internal - linkage, we already know what object file linkage will be - assigned to the instantiation. */ - DECL_INTERFACE_KNOWN (r) = !TREE_PUBLIC (r); - DECL_DEFER_OUTPUT (r) = 0; - TREE_CHAIN (r) = NULL_TREE; - DECL_PENDING_INLINE_INFO (r) = 0; - DECL_PENDING_INLINE_P (r) = 0; - DECL_SAVED_TREE (r) = NULL_TREE; - TREE_USED (r) = 0; - if (DECL_CLONED_FUNCTION (r)) - { - DECL_CLONED_FUNCTION (r) = tsubst (DECL_CLONED_FUNCTION (t), - args, complain, t); - TREE_CHAIN (r) = TREE_CHAIN (DECL_CLONED_FUNCTION (r)); - TREE_CHAIN (DECL_CLONED_FUNCTION (r)) = r; - } - - /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do - this in the special friend case mentioned above where - GEN_TMPL is NULL. */ - if (gen_tmpl) - { - DECL_TEMPLATE_INFO (r) - = tree_cons (gen_tmpl, argvec, NULL_TREE); - SET_DECL_IMPLICIT_INSTANTIATION (r); - register_specialization (r, gen_tmpl, argvec, false); - - /* We're not supposed to instantiate default arguments - until they are called, for a template. But, for a - declaration like: - - template <class T> void f () - { extern void g(int i = T()); } - - we should do the substitution when the template is - instantiated. We handle the member function case in - instantiate_class_template since the default arguments - might refer to other members of the class. */ - if (!member - && !PRIMARY_TEMPLATE_P (gen_tmpl) - && !uses_template_parms (argvec)) - tsubst_default_arguments (r); - } - else - DECL_TEMPLATE_INFO (r) = NULL_TREE; - - /* Copy the list of befriending classes. */ - for (friends = &DECL_BEFRIENDING_CLASSES (r); - *friends; - friends = &TREE_CHAIN (*friends)) - { - *friends = copy_node (*friends); - TREE_VALUE (*friends) = tsubst (TREE_VALUE (*friends), - args, complain, - in_decl); - } - - if (DECL_CONSTRUCTOR_P (r) || DECL_DESTRUCTOR_P (r)) - { - maybe_retrofit_in_chrg (r); - if (DECL_CONSTRUCTOR_P (r)) - grok_ctor_properties (ctx, r); - /* If this is an instantiation of a member template, clone it. - If it isn't, that'll be handled by - clone_constructors_and_destructors. */ - if (PRIMARY_TEMPLATE_P (gen_tmpl)) - clone_function_decl (r, /*update_method_vec_p=*/0); - } - else if (IDENTIFIER_OPNAME_P (DECL_NAME (r)) - && !grok_op_properties (r, (complain & tf_error) != 0)) - return error_mark_node; - - if (DECL_FRIEND_P (t) && DECL_FRIEND_CONTEXT (t)) - SET_DECL_FRIEND_CONTEXT (r, - tsubst (DECL_FRIEND_CONTEXT (t), - args, complain, in_decl)); - - /* Possibly limit visibility based on template args. */ - DECL_VISIBILITY (r) = VISIBILITY_DEFAULT; - if (DECL_VISIBILITY_SPECIFIED (t)) - { - DECL_VISIBILITY_SPECIFIED (r) = 0; - DECL_ATTRIBUTES (r) - = remove_attribute ("visibility", DECL_ATTRIBUTES (r)); - } - determine_visibility (r); - } - break; - - case PARM_DECL: - { - tree type; - - r = copy_node (t); - if (DECL_TEMPLATE_PARM_P (t)) - SET_DECL_TEMPLATE_PARM_P (r); - - type = tsubst (TREE_TYPE (t), args, complain, in_decl); - type = type_decays_to (type); - TREE_TYPE (r) = type; - cp_apply_type_quals_to_decl (cp_type_quals (type), r); - - if (DECL_INITIAL (r)) - { - if (TREE_CODE (DECL_INITIAL (r)) != TEMPLATE_PARM_INDEX) - DECL_INITIAL (r) = TREE_TYPE (r); - else - DECL_INITIAL (r) = tsubst (DECL_INITIAL (r), args, - complain, in_decl); - } - - DECL_CONTEXT (r) = NULL_TREE; - - if (!DECL_TEMPLATE_PARM_P (r)) - DECL_ARG_TYPE (r) = type_passed_as (type); - if (TREE_CHAIN (t)) - TREE_CHAIN (r) = tsubst (TREE_CHAIN (t), args, - complain, TREE_CHAIN (t)); - } - break; - - case FIELD_DECL: - { - tree type; - - r = copy_decl (t); - type = tsubst (TREE_TYPE (t), args, complain, in_decl); - if (type == error_mark_node) - return error_mark_node; - TREE_TYPE (r) = type; - cp_apply_type_quals_to_decl (cp_type_quals (type), r); - - /* DECL_INITIAL gives the number of bits in a bit-field. */ - DECL_INITIAL (r) - = tsubst_expr (DECL_INITIAL (t), args, - complain, in_decl, - /*integral_constant_expression_p=*/true); - /* We don't have to set DECL_CONTEXT here; it is set by - finish_member_declaration. */ - TREE_CHAIN (r) = NULL_TREE; - if (VOID_TYPE_P (type)) - error ("instantiation of %q+D as type %qT", r, type); - } - break; - - case USING_DECL: - /* We reach here only for member using decls. */ - if (DECL_DEPENDENT_P (t)) - { - r = do_class_using_decl - (tsubst_copy (USING_DECL_SCOPE (t), args, complain, in_decl), - tsubst_copy (DECL_NAME (t), args, complain, in_decl)); - if (!r) - r = error_mark_node; - } - else - { - r = copy_node (t); - TREE_CHAIN (r) = NULL_TREE; - } - break; - - case TYPE_DECL: - case VAR_DECL: - { - tree argvec = NULL_TREE; - tree gen_tmpl = NULL_TREE; - tree spec; - tree tmpl = NULL_TREE; - tree ctx; - tree type = NULL_TREE; - bool local_p; - - if (TREE_CODE (t) == TYPE_DECL) - { - type = tsubst (TREE_TYPE (t), args, complain, in_decl); - if (TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM - || t == TYPE_MAIN_DECL (TREE_TYPE (t))) - { - /* If this is the canonical decl, we don't have to - mess with instantiations, and often we can't (for - typename, template type parms and such). Note that - TYPE_NAME is not correct for the above test if - we've copied the type for a typedef. */ - r = TYPE_NAME (type); - break; - } - } - - /* Check to see if we already have the specialization we - need. */ - spec = NULL_TREE; - if (DECL_CLASS_SCOPE_P (t) || DECL_NAMESPACE_SCOPE_P (t)) - { - /* T is a static data member or namespace-scope entity. - We have to substitute into namespace-scope variables - (even though such entities are never templates) because - of cases like: - - template <class T> void f() { extern T t; } - - where the entity referenced is not known until - instantiation time. */ - local_p = false; - ctx = DECL_CONTEXT (t); - if (DECL_CLASS_SCOPE_P (t)) - { - ctx = tsubst_aggr_type (ctx, args, - complain, - in_decl, /*entering_scope=*/1); - /* If CTX is unchanged, then T is in fact the - specialization we want. That situation occurs when - referencing a static data member within in its own - class. We can use pointer equality, rather than - same_type_p, because DECL_CONTEXT is always - canonical. */ - if (ctx == DECL_CONTEXT (t)) - spec = t; - } - - if (!spec) - { - tmpl = DECL_TI_TEMPLATE (t); - gen_tmpl = most_general_template (tmpl); - argvec = tsubst (DECL_TI_ARGS (t), args, complain, in_decl); - spec = (retrieve_specialization - (gen_tmpl, argvec, - /*class_specializations_p=*/false)); - } - } - else - { - /* A local variable. */ - local_p = true; - /* Subsequent calls to pushdecl will fill this in. */ - ctx = NULL_TREE; - spec = retrieve_local_specialization (t); - } - /* If we already have the specialization we need, there is - nothing more to do. */ - if (spec) - { - r = spec; - break; - } - - /* Create a new node for the specialization we need. */ - r = copy_decl (t); - if (TREE_CODE (r) == VAR_DECL) - { - /* Even if the original location is out of scope, the - newly substituted one is not. */ - DECL_DEAD_FOR_LOCAL (r) = 0; - DECL_INITIALIZED_P (r) = 0; - DECL_TEMPLATE_INSTANTIATED (r) = 0; - type = tsubst (TREE_TYPE (t), args, complain, in_decl); - if (type == error_mark_node) - return error_mark_node; - if (TREE_CODE (type) == FUNCTION_TYPE) - { - /* It may seem that this case cannot occur, since: - - typedef void f(); - void g() { f x; } - - declares a function, not a variable. However: - - typedef void f(); - template <typename T> void g() { T t; } - template void g<f>(); - - is an attempt to declare a variable with function - type. */ - error ("variable %qD has function type", - /* R is not yet sufficiently initialized, so we - just use its name. */ - DECL_NAME (r)); - return error_mark_node; - } - type = complete_type (type); - DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r) - = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t); - type = check_var_type (DECL_NAME (r), type); - - if (DECL_HAS_VALUE_EXPR_P (t)) - { - tree ve = DECL_VALUE_EXPR (t); - ve = tsubst_expr (ve, args, complain, in_decl, - /*constant_expression_p=*/false); - SET_DECL_VALUE_EXPR (r, ve); - } - } - else if (DECL_SELF_REFERENCE_P (t)) - SET_DECL_SELF_REFERENCE_P (r); - TREE_TYPE (r) = type; - cp_apply_type_quals_to_decl (cp_type_quals (type), r); - DECL_CONTEXT (r) = ctx; - /* Clear out the mangled name and RTL for the instantiation. */ - SET_DECL_ASSEMBLER_NAME (r, NULL_TREE); - if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL)) - SET_DECL_RTL (r, NULL_RTX); - /* The initializer must not be expanded until it is required; - see [temp.inst]. */ - DECL_INITIAL (r) = NULL_TREE; - if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL)) - SET_DECL_RTL (r, NULL_RTX); - DECL_SIZE (r) = DECL_SIZE_UNIT (r) = 0; - if (TREE_CODE (r) == VAR_DECL) - { - /* Possibly limit visibility based on template args. */ - DECL_VISIBILITY (r) = VISIBILITY_DEFAULT; - if (DECL_VISIBILITY_SPECIFIED (t)) - { - DECL_VISIBILITY_SPECIFIED (r) = 0; - DECL_ATTRIBUTES (r) - = remove_attribute ("visibility", DECL_ATTRIBUTES (r)); - } - determine_visibility (r); - } - - if (!local_p) - { - /* A static data member declaration is always marked - external when it is declared in-class, even if an - initializer is present. We mimic the non-template - processing here. */ - DECL_EXTERNAL (r) = 1; - - register_specialization (r, gen_tmpl, argvec, false); - DECL_TEMPLATE_INFO (r) = tree_cons (tmpl, argvec, NULL_TREE); - SET_DECL_IMPLICIT_INSTANTIATION (r); - } - else - register_local_specialization (r, t); - - TREE_CHAIN (r) = NULL_TREE; - layout_decl (r, 0); - } - break; - - default: - gcc_unreachable (); - } - - /* Restore the file and line information. */ - input_location = saved_loc; - - return r; -} - -/* Substitute into the ARG_TYPES of a function type. */ - -static tree -tsubst_arg_types (tree arg_types, - tree args, - tsubst_flags_t complain, - tree in_decl) -{ - tree remaining_arg_types; - tree type; - tree default_arg; - tree result = NULL_TREE; - - if (!arg_types || arg_types == void_list_node) - return arg_types; - - remaining_arg_types = tsubst_arg_types (TREE_CHAIN (arg_types), - args, complain, in_decl); - if (remaining_arg_types == error_mark_node) - return error_mark_node; - - type = tsubst (TREE_VALUE (arg_types), args, complain, in_decl); - if (type == error_mark_node) - return error_mark_node; - if (VOID_TYPE_P (type)) - { - if (complain & tf_error) - { - error ("invalid parameter type %qT", type); - if (in_decl) - error ("in declaration %q+D", in_decl); - } - return error_mark_node; - } - - /* Do array-to-pointer, function-to-pointer conversion, and ignore - top-level qualifiers as required. */ - type = TYPE_MAIN_VARIANT (type_decays_to (type)); - - /* We do not substitute into default arguments here. The standard - mandates that they be instantiated only when needed, which is - done in build_over_call. */ - default_arg = TREE_PURPOSE (arg_types); - - if (default_arg && TREE_CODE (default_arg) == DEFAULT_ARG) - { - /* We've instantiated a template before its default arguments - have been parsed. This can happen for a nested template - class, and is not an error unless we require the default - argument in a call of this function. */ - result = tree_cons (default_arg, type, remaining_arg_types); - VEC_safe_push (tree, gc, DEFARG_INSTANTIATIONS (default_arg), result); - } - else - result = hash_tree_cons (default_arg, type, remaining_arg_types); - - return result; -} - -/* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does - *not* handle the exception-specification for FNTYPE, because the - initial substitution of explicitly provided template parameters - during argument deduction forbids substitution into the - exception-specification: - - [temp.deduct] - - All references in the function type of the function template to the - corresponding template parameters are replaced by the specified tem- - plate argument values. If a substitution in a template parameter or - in the function type of the function template results in an invalid - type, type deduction fails. [Note: The equivalent substitution in - exception specifications is done only when the function is instanti- - ated, at which point a program is ill-formed if the substitution - results in an invalid type.] */ - -static tree -tsubst_function_type (tree t, - tree args, - tsubst_flags_t complain, - tree in_decl) -{ - tree return_type; - tree arg_types; - tree fntype; - - /* The TYPE_CONTEXT is not used for function/method types. */ - gcc_assert (TYPE_CONTEXT (t) == NULL_TREE); - - /* Substitute the return type. */ - return_type = tsubst (TREE_TYPE (t), args, complain, in_decl); - if (return_type == error_mark_node) - return error_mark_node; - /* The standard does not presently indicate that creation of a - function type with an invalid return type is a deduction failure. - However, that is clearly analogous to creating an array of "void" - or a reference to a reference. This is core issue #486. */ - if (TREE_CODE (return_type) == ARRAY_TYPE - || TREE_CODE (return_type) == FUNCTION_TYPE) - { - if (complain & tf_error) - { - if (TREE_CODE (return_type) == ARRAY_TYPE) - error ("function returning an array"); - else - error ("function returning a function"); - } - return error_mark_node; - } - - /* Substitute the argument types. */ - arg_types = tsubst_arg_types (TYPE_ARG_TYPES (t), args, - complain, in_decl); - if (arg_types == error_mark_node) - return error_mark_node; - - /* Construct a new type node and return it. */ - if (TREE_CODE (t) == FUNCTION_TYPE) - fntype = build_function_type (return_type, arg_types); - else - { - tree r = TREE_TYPE (TREE_VALUE (arg_types)); - if (! IS_AGGR_TYPE (r)) - { - /* [temp.deduct] - - Type deduction may fail for any of the following - reasons: - - -- Attempting to create "pointer to member of T" when T - is not a class type. */ - if (complain & tf_error) - error ("creating pointer to member function of non-class type %qT", - r); - return error_mark_node; - } - - fntype = build_method_type_directly (r, return_type, - TREE_CHAIN (arg_types)); - } - fntype = cp_build_qualified_type_real (fntype, TYPE_QUALS (t), complain); - fntype = cp_build_type_attribute_variant (fntype, TYPE_ATTRIBUTES (t)); - - return fntype; -} - -/* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template - ARGS into that specification, and return the substituted - specification. If there is no specification, return NULL_TREE. */ - -static tree -tsubst_exception_specification (tree fntype, - tree args, - tsubst_flags_t complain, - tree in_decl) -{ - tree specs; - tree new_specs; - - specs = TYPE_RAISES_EXCEPTIONS (fntype); - new_specs = NULL_TREE; - if (specs) - { - if (! TREE_VALUE (specs)) - new_specs = specs; - else - while (specs) - { - tree spec; - spec = tsubst (TREE_VALUE (specs), args, complain, in_decl); - if (spec == error_mark_node) - return spec; - new_specs = add_exception_specifier (new_specs, spec, complain); - specs = TREE_CHAIN (specs); - } - } - return new_specs; -} - -/* Take the tree structure T and replace template parameters used - therein with the argument vector ARGS. IN_DECL is an associated - decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE. - Issue error and warning messages under control of COMPLAIN. Note - that we must be relatively non-tolerant of extensions here, in - order to preserve conformance; if we allow substitutions that - should not be allowed, we may allow argument deductions that should - not succeed, and therefore report ambiguous overload situations - where there are none. In theory, we could allow the substitution, - but indicate that it should have failed, and allow our caller to - make sure that the right thing happens, but we don't try to do this - yet. - - This function is used for dealing with types, decls and the like; - for expressions, use tsubst_expr or tsubst_copy. */ - -static tree -tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl) -{ - tree type, r; - - if (t == NULL_TREE || t == error_mark_node - || t == integer_type_node - || t == void_type_node - || t == char_type_node - || t == unknown_type_node - || TREE_CODE (t) == NAMESPACE_DECL) - return t; - - if (DECL_P (t)) - return tsubst_decl (t, args, complain); - - if (TREE_CODE (t) == IDENTIFIER_NODE) - type = IDENTIFIER_TYPE_VALUE (t); - else - type = TREE_TYPE (t); - - gcc_assert (type != unknown_type_node); - - if (type - && TREE_CODE (t) != TYPENAME_TYPE - && TREE_CODE (t) != IDENTIFIER_NODE - && TREE_CODE (t) != FUNCTION_TYPE - && TREE_CODE (t) != METHOD_TYPE) - type = tsubst (type, args, complain, in_decl); - if (type == error_mark_node) - return error_mark_node; - - switch (TREE_CODE (t)) - { - case RECORD_TYPE: - case UNION_TYPE: - case ENUMERAL_TYPE: - return tsubst_aggr_type (t, args, complain, in_decl, - /*entering_scope=*/0); - - case ERROR_MARK: - case IDENTIFIER_NODE: - case VOID_TYPE: - case REAL_TYPE: - case COMPLEX_TYPE: - case VECTOR_TYPE: - case BOOLEAN_TYPE: - case INTEGER_CST: - case REAL_CST: - case STRING_CST: - return t; - - case INTEGER_TYPE: - if (t == integer_type_node) - return t; - - if (TREE_CODE (TYPE_MIN_VALUE (t)) == INTEGER_CST - && TREE_CODE (TYPE_MAX_VALUE (t)) == INTEGER_CST) - return t; - - { - tree max, omax = TREE_OPERAND (TYPE_MAX_VALUE (t), 0); - - max = tsubst_expr (omax, args, complain, in_decl, - /*integral_constant_expression_p=*/false); - max = fold_decl_constant_value (max); - - if (TREE_CODE (max) != INTEGER_CST - && TREE_CODE (max) != TEMPLATE_PARM_INDEX - && !at_function_scope_p ()) - { - if (complain & tf_error) - error ("array bound is not an integer constant"); - return error_mark_node; - } - - /* [temp.deduct] - - Type deduction may fail for any of the following - reasons: - - Attempting to create an array with a size that is - zero or negative. */ - if (integer_zerop (max) && !(complain & tf_error)) - /* We must fail if performing argument deduction (as - indicated by the state of complain), so that - another substitution can be found. */ - return error_mark_node; - else if (TREE_CODE (max) == INTEGER_CST - && INT_CST_LT (max, integer_zero_node)) - { - if (complain & tf_error) - error ("creating array with negative size (%qE)", max); - - return error_mark_node; - } - - return compute_array_index_type (NULL_TREE, max); - } - - case TEMPLATE_TYPE_PARM: - case TEMPLATE_TEMPLATE_PARM: - case BOUND_TEMPLATE_TEMPLATE_PARM: - case TEMPLATE_PARM_INDEX: - { - int idx; - int level; - int levels; - tree arg = NULL_TREE; - - r = NULL_TREE; - - gcc_assert (TREE_VEC_LENGTH (args) > 0); - if (TREE_CODE (t) == TEMPLATE_TYPE_PARM - || TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM - || TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM) - { - idx = TEMPLATE_TYPE_IDX (t); - level = TEMPLATE_TYPE_LEVEL (t); - } - else - { - idx = TEMPLATE_PARM_IDX (t); - level = TEMPLATE_PARM_LEVEL (t); - } - - levels = TMPL_ARGS_DEPTH (args); - if (level <= levels) - arg = TMPL_ARG (args, level, idx); - - if (arg == error_mark_node) - return error_mark_node; - else if (arg != NULL_TREE) - { - if (TREE_CODE (t) == TEMPLATE_TYPE_PARM) - { - int quals; - gcc_assert (TYPE_P (arg)); - - /* cv-quals from the template are discarded when - substituting in a function or reference type. */ - if (TREE_CODE (arg) == FUNCTION_TYPE - || TREE_CODE (arg) == METHOD_TYPE - || TREE_CODE (arg) == REFERENCE_TYPE) - quals = cp_type_quals (arg); - else - quals = cp_type_quals (arg) | cp_type_quals (t); - - return cp_build_qualified_type_real - (arg, quals, complain | tf_ignore_bad_quals); - } - else if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM) - { - /* We are processing a type constructed from a - template template parameter. */ - tree argvec = tsubst (TYPE_TI_ARGS (t), - args, complain, in_decl); - if (argvec == error_mark_node) - return error_mark_node; - - /* We can get a TEMPLATE_TEMPLATE_PARM here when we - are resolving nested-types in the signature of a - member function templates. Otherwise ARG is a - TEMPLATE_DECL and is the real template to be - instantiated. */ - if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM) - arg = TYPE_NAME (arg); - - r = lookup_template_class (arg, - argvec, in_decl, - DECL_CONTEXT (arg), - /*entering_scope=*/0, - complain); - return cp_build_qualified_type_real - (r, TYPE_QUALS (t), complain); - } - else - /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */ - return arg; - } - - if (level == 1) - /* This can happen during the attempted tsubst'ing in - unify. This means that we don't yet have any information - about the template parameter in question. */ - return t; - - /* If we get here, we must have been looking at a parm for a - more deeply nested template. Make a new version of this - template parameter, but with a lower level. */ - switch (TREE_CODE (t)) - { - case TEMPLATE_TYPE_PARM: - case TEMPLATE_TEMPLATE_PARM: - case BOUND_TEMPLATE_TEMPLATE_PARM: - if (cp_type_quals (t)) - { - r = tsubst (TYPE_MAIN_VARIANT (t), args, complain, in_decl); - r = cp_build_qualified_type_real - (r, cp_type_quals (t), - complain | (TREE_CODE (t) == TEMPLATE_TYPE_PARM - ? tf_ignore_bad_quals : 0)); - } - else - { - r = copy_type (t); - TEMPLATE_TYPE_PARM_INDEX (r) - = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t), - r, levels); - TYPE_STUB_DECL (r) = TYPE_NAME (r) = TEMPLATE_TYPE_DECL (r); - TYPE_MAIN_VARIANT (r) = r; - TYPE_POINTER_TO (r) = NULL_TREE; - TYPE_REFERENCE_TO (r) = NULL_TREE; - - if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM) - { - tree argvec = tsubst (TYPE_TI_ARGS (t), args, - complain, in_decl); - if (argvec == error_mark_node) - return error_mark_node; - - TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r) - = tree_cons (TYPE_TI_TEMPLATE (t), argvec, NULL_TREE); - } - } - break; - - case TEMPLATE_PARM_INDEX: - r = reduce_template_parm_level (t, type, levels); - break; - - default: - gcc_unreachable (); - } - - return r; - } - - case TREE_LIST: - { - tree purpose, value, chain; - - if (t == void_list_node) - return t; - - purpose = TREE_PURPOSE (t); - if (purpose) - { - purpose = tsubst (purpose, args, complain, in_decl); - if (purpose == error_mark_node) - return error_mark_node; - } - value = TREE_VALUE (t); - if (value) - { - value = tsubst (value, args, complain, in_decl); - if (value == error_mark_node) - return error_mark_node; - } - chain = TREE_CHAIN (t); - if (chain && chain != void_type_node) - { - chain = tsubst (chain, args, complain, in_decl); - if (chain == error_mark_node) - return error_mark_node; - } - if (purpose == TREE_PURPOSE (t) - && value == TREE_VALUE (t) - && chain == TREE_CHAIN (t)) - return t; - return hash_tree_cons (purpose, value, chain); - } - - case TREE_BINFO: - /* We should never be tsubsting a binfo. */ - gcc_unreachable (); - - case TREE_VEC: - /* A vector of template arguments. */ - gcc_assert (!type); - return tsubst_template_args (t, args, complain, in_decl); - - case POINTER_TYPE: - case REFERENCE_TYPE: - { - enum tree_code code; - - if (type == TREE_TYPE (t) && TREE_CODE (type) != METHOD_TYPE) - return t; - - code = TREE_CODE (t); - - - /* [temp.deduct] - - Type deduction may fail for any of the following - reasons: - - -- Attempting to create a pointer to reference type. - -- Attempting to create a reference to a reference type or - a reference to void. */ - if (TREE_CODE (type) == REFERENCE_TYPE - || (code == REFERENCE_TYPE && TREE_CODE (type) == VOID_TYPE)) - { - static location_t last_loc; - - /* We keep track of the last time we issued this error - message to avoid spewing a ton of messages during a - single bad template instantiation. */ - if (complain & tf_error -#ifdef USE_MAPPED_LOCATION - && last_loc != input_location -#else - && (last_loc.line != input_line - || last_loc.file != input_filename) -#endif - ) - { - if (TREE_CODE (type) == VOID_TYPE) - error ("forming reference to void"); - else - error ("forming %s to reference type %qT", - (code == POINTER_TYPE) ? "pointer" : "reference", - type); - last_loc = input_location; - } - - return error_mark_node; - } - else if (code == POINTER_TYPE) - { - r = build_pointer_type (type); - if (TREE_CODE (type) == METHOD_TYPE) - r = build_ptrmemfunc_type (r); - } - else - r = build_reference_type (type); - r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain); - - if (r != error_mark_node) - /* Will this ever be needed for TYPE_..._TO values? */ - layout_type (r); - - return r; - } - case OFFSET_TYPE: - { - r = tsubst (TYPE_OFFSET_BASETYPE (t), args, complain, in_decl); - if (r == error_mark_node || !IS_AGGR_TYPE (r)) - { - /* [temp.deduct] - - Type deduction may fail for any of the following - reasons: - - -- Attempting to create "pointer to member of T" when T - is not a class type. */ - if (complain & tf_error) - error ("creating pointer to member of non-class type %qT", r); - return error_mark_node; - } - if (TREE_CODE (type) == REFERENCE_TYPE) - { - if (complain & tf_error) - error ("creating pointer to member reference type %qT", type); - return error_mark_node; - } - if (TREE_CODE (type) == VOID_TYPE) - { - if (complain & tf_error) - error ("creating pointer to member of type void"); - return error_mark_node; - } - gcc_assert (TREE_CODE (type) != METHOD_TYPE); - if (TREE_CODE (type) == FUNCTION_TYPE) - { - /* The type of the implicit object parameter gets its - cv-qualifiers from the FUNCTION_TYPE. */ - tree method_type; - tree this_type = cp_build_qualified_type (TYPE_MAIN_VARIANT (r), - cp_type_quals (type)); - tree memptr; - method_type = build_method_type_directly (this_type, - TREE_TYPE (type), - TYPE_ARG_TYPES (type)); - memptr = build_ptrmemfunc_type (build_pointer_type (method_type)); - return cp_build_qualified_type_real (memptr, cp_type_quals (t), - complain); - } - else - return cp_build_qualified_type_real (build_ptrmem_type (r, type), - TYPE_QUALS (t), - complain); - } - case FUNCTION_TYPE: - case METHOD_TYPE: - { - tree fntype; - tree specs; - fntype = tsubst_function_type (t, args, complain, in_decl); - if (fntype == error_mark_node) - return error_mark_node; - - /* Substitute the exception specification. */ - specs = tsubst_exception_specification (t, args, complain, - in_decl); - if (specs == error_mark_node) - return error_mark_node; - if (specs) - fntype = build_exception_variant (fntype, specs); - return fntype; - } - case ARRAY_TYPE: - { - tree domain = tsubst (TYPE_DOMAIN (t), args, complain, in_decl); - if (domain == error_mark_node) - return error_mark_node; - - /* As an optimization, we avoid regenerating the array type if - it will obviously be the same as T. */ - if (type == TREE_TYPE (t) && domain == TYPE_DOMAIN (t)) - return t; - - /* These checks should match the ones in grokdeclarator. - - [temp.deduct] - - The deduction may fail for any of the following reasons: - - -- Attempting to create an array with an element type that - is void, a function type, or a reference type, or [DR337] - an abstract class type. */ - if (TREE_CODE (type) == VOID_TYPE - || TREE_CODE (type) == FUNCTION_TYPE - || TREE_CODE (type) == REFERENCE_TYPE) - { - if (complain & tf_error) - error ("creating array of %qT", type); - return error_mark_node; - } - if (CLASS_TYPE_P (type) && CLASSTYPE_PURE_VIRTUALS (type)) - { - if (complain & tf_error) - error ("creating array of %qT, which is an abstract class type", - type); - return error_mark_node; - } - - r = build_cplus_array_type (type, domain); - return r; - } - - case PLUS_EXPR: - case MINUS_EXPR: - { - tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl); - tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl); - - if (e1 == error_mark_node || e2 == error_mark_node) - return error_mark_node; - - return fold_build2 (TREE_CODE (t), TREE_TYPE (t), e1, e2); - } - - case NEGATE_EXPR: - case NOP_EXPR: - { - tree e = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl); - if (e == error_mark_node) - return error_mark_node; - - return fold_build1 (TREE_CODE (t), TREE_TYPE (t), e); - } - - case TYPENAME_TYPE: - { - tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain, - in_decl, /*entering_scope=*/1); - tree f = tsubst_copy (TYPENAME_TYPE_FULLNAME (t), args, - complain, in_decl); - - if (ctx == error_mark_node || f == error_mark_node) - return error_mark_node; - - if (!IS_AGGR_TYPE (ctx)) - { - if (complain & tf_error) - error ("%qT is not a class, struct, or union type", ctx); - return error_mark_node; - } - else if (!uses_template_parms (ctx) && !TYPE_BEING_DEFINED (ctx)) - { - /* Normally, make_typename_type does not require that the CTX - have complete type in order to allow things like: - - template <class T> struct S { typename S<T>::X Y; }; - - But, such constructs have already been resolved by this - point, so here CTX really should have complete type, unless - it's a partial instantiation. */ - ctx = complete_type (ctx); - if (!COMPLETE_TYPE_P (ctx)) - { - if (complain & tf_error) - cxx_incomplete_type_error (NULL_TREE, ctx); - return error_mark_node; - } - } - - f = make_typename_type (ctx, f, typename_type, - (complain & tf_error) | tf_keep_type_decl); - if (f == error_mark_node) - return f; - if (TREE_CODE (f) == TYPE_DECL) - { - complain |= tf_ignore_bad_quals; - f = TREE_TYPE (f); - } - - if (TREE_CODE (f) != TYPENAME_TYPE) - { - if (TYPENAME_IS_ENUM_P (t) && TREE_CODE (f) != ENUMERAL_TYPE) - error ("%qT resolves to %qT, which is not an enumeration type", - t, f); - else if (TYPENAME_IS_CLASS_P (t) && !CLASS_TYPE_P (f)) - error ("%qT resolves to %qT, which is is not a class type", - t, f); - } - - return cp_build_qualified_type_real - (f, cp_type_quals (f) | cp_type_quals (t), complain); - } - - case UNBOUND_CLASS_TEMPLATE: - { - tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain, - in_decl, /*entering_scope=*/1); - tree name = TYPE_IDENTIFIER (t); - tree parm_list = DECL_TEMPLATE_PARMS (TYPE_NAME (t)); - - if (ctx == error_mark_node || name == error_mark_node) - return error_mark_node; - - if (parm_list) - parm_list = tsubst_template_parms (parm_list, args, complain); - return make_unbound_class_template (ctx, name, parm_list, complain); - } - - case INDIRECT_REF: - case ADDR_EXPR: - case CALL_EXPR: - gcc_unreachable (); - - case ARRAY_REF: - { - tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl); - tree e2 = tsubst_expr (TREE_OPERAND (t, 1), args, complain, in_decl, - /*integral_constant_expression_p=*/false); - if (e1 == error_mark_node || e2 == error_mark_node) - return error_mark_node; - - return build_nt (ARRAY_REF, e1, e2, NULL_TREE, NULL_TREE); - } - - case SCOPE_REF: - { - tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl); - tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl); - if (e1 == error_mark_node || e2 == error_mark_node) - return error_mark_node; - - return build_qualified_name (/*type=*/NULL_TREE, - e1, e2, QUALIFIED_NAME_IS_TEMPLATE (t)); - } - - case TYPEOF_TYPE: - { - tree type; - - type = finish_typeof (tsubst_expr - (TYPEOF_TYPE_EXPR (t), args, - complain, in_decl, - /*integral_constant_expression_p=*/false)); - return cp_build_qualified_type_real (type, - cp_type_quals (t) - | cp_type_quals (type), - complain); - } - - /* APPLE LOCAL begin blocks 6204446 */ - case BLOCK_POINTER_TYPE: - return t; - /* APPLE LOCAL end blocks 6204446 */ - - default: - sorry ("use of %qs in template", - tree_code_name [(int) TREE_CODE (t)]); - return error_mark_node; - } -} - -/* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the - type of the expression on the left-hand side of the "." or "->" - operator. */ - -static tree -tsubst_baselink (tree baselink, tree object_type, - tree args, tsubst_flags_t complain, tree in_decl) -{ - tree name; - tree qualifying_scope; - tree fns; - tree optype; - tree template_args = 0; - bool template_id_p = false; - - /* A baselink indicates a function from a base class. Both the - BASELINK_ACCESS_BINFO and the base class referenced may - indicate bases of the template class, rather than the - instantiated class. In addition, lookups that were not - ambiguous before may be ambiguous now. Therefore, we perform - the lookup again. */ - qualifying_scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink)); - qualifying_scope = tsubst (qualifying_scope, args, - complain, in_decl); - fns = BASELINK_FUNCTIONS (baselink); - optype = BASELINK_OPTYPE (baselink); - if (TREE_CODE (fns) == TEMPLATE_ID_EXPR) - { - template_id_p = true; - template_args = TREE_OPERAND (fns, 1); - fns = TREE_OPERAND (fns, 0); - if (template_args) - template_args = tsubst_template_args (template_args, args, - complain, in_decl); - } - name = DECL_NAME (get_first_fn (fns)); - baselink = lookup_fnfields (qualifying_scope, name, /*protect=*/1); - - /* If lookup found a single function, mark it as used at this - point. (If it lookup found multiple functions the one selected - later by overload resolution will be marked as used at that - point.) */ - if (BASELINK_P (baselink)) - fns = BASELINK_FUNCTIONS (baselink); - if (!template_id_p && !really_overloaded_fn (fns)) - mark_used (OVL_CURRENT (fns)); - - /* Add back the template arguments, if present. */ - if (BASELINK_P (baselink) && template_id_p) - BASELINK_FUNCTIONS (baselink) - = build_nt (TEMPLATE_ID_EXPR, - BASELINK_FUNCTIONS (baselink), - template_args); - /* Update the conversion operator type. */ - BASELINK_OPTYPE (baselink) - = tsubst (optype, args, complain, in_decl); - - if (!object_type) - object_type = current_class_type; - return adjust_result_of_qualified_name_lookup (baselink, - qualifying_scope, - object_type); -} - -/* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is - true if the qualified-id will be a postfix-expression in-and-of - itself; false if more of the postfix-expression follows the - QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand - of "&". */ - -static tree -tsubst_qualified_id (tree qualified_id, tree args, - tsubst_flags_t complain, tree in_decl, - bool done, bool address_p) -{ - tree expr; - tree scope; - tree name; - bool is_template; - tree template_args; - - gcc_assert (TREE_CODE (qualified_id) == SCOPE_REF); - - /* Figure out what name to look up. */ - name = TREE_OPERAND (qualified_id, 1); - if (TREE_CODE (name) == TEMPLATE_ID_EXPR) - { - is_template = true; - template_args = TREE_OPERAND (name, 1); - if (template_args) - template_args = tsubst_template_args (template_args, args, - complain, in_decl); - name = TREE_OPERAND (name, 0); - } - else - { - is_template = false; - template_args = NULL_TREE; - } - - /* Substitute into the qualifying scope. When there are no ARGS, we - are just trying to simplify a non-dependent expression. In that - case the qualifying scope may be dependent, and, in any case, - substituting will not help. */ - scope = TREE_OPERAND (qualified_id, 0); - if (args) - { - scope = tsubst (scope, args, complain, in_decl); - expr = tsubst_copy (name, args, complain, in_decl); - } - else - expr = name; - - if (dependent_type_p (scope)) - return build_qualified_name (/*type=*/NULL_TREE, - scope, expr, - QUALIFIED_NAME_IS_TEMPLATE (qualified_id)); - - if (!BASELINK_P (name) && !DECL_P (expr)) - { - if (TREE_CODE (expr) == BIT_NOT_EXPR) - /* If this were actually a destructor call, it would have been - parsed as such by the parser. */ - expr = error_mark_node; - else - expr = lookup_qualified_name (scope, expr, /*is_type_p=*/0, false); - if (TREE_CODE (TREE_CODE (expr) == TEMPLATE_DECL - ? DECL_TEMPLATE_RESULT (expr) : expr) == TYPE_DECL) - { - if (complain & tf_error) - { - error ("dependent-name %qE is parsed as a non-type, but " - "instantiation yields a type", qualified_id); - inform ("say %<typename %E%> if a type is meant", qualified_id); - } - return error_mark_node; - } - } - - if (DECL_P (expr)) - { - check_accessibility_of_qualified_id (expr, /*object_type=*/NULL_TREE, - scope); - /* Remember that there was a reference to this entity. */ - mark_used (expr); - } - - if (expr == error_mark_node || TREE_CODE (expr) == TREE_LIST) - { - if (complain & tf_error) - qualified_name_lookup_error (scope, - TREE_OPERAND (qualified_id, 1), - expr); - return error_mark_node; - } - - if (is_template) - expr = lookup_template_function (expr, template_args); - - if (expr == error_mark_node && complain & tf_error) - qualified_name_lookup_error (scope, TREE_OPERAND (qualified_id, 1), - expr); - else if (TYPE_P (scope)) - { - expr = (adjust_result_of_qualified_name_lookup - (expr, scope, current_class_type)); - expr = (finish_qualified_id_expr - (scope, expr, done, address_p, - QUALIFIED_NAME_IS_TEMPLATE (qualified_id), - /*template_arg_p=*/false)); - } - - /* Expressions do not generally have reference type. */ - if (TREE_CODE (expr) != SCOPE_REF - /* However, if we're about to form a pointer-to-member, we just - want the referenced member referenced. */ - && TREE_CODE (expr) != OFFSET_REF) - expr = convert_from_reference (expr); - - return expr; -} - -/* Like tsubst, but deals with expressions. This function just replaces - template parms; to finish processing the resultant expression, use - tsubst_expr. */ - -static tree -tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl) -{ - enum tree_code code; - tree r; - - if (t == NULL_TREE || t == error_mark_node) - return t; - - code = TREE_CODE (t); - - switch (code) - { - case PARM_DECL: - r = retrieve_local_specialization (t); - gcc_assert (r != NULL); - mark_used (r); - return r; - - case CONST_DECL: - { - tree enum_type; - tree v; - - if (DECL_TEMPLATE_PARM_P (t)) - return tsubst_copy (DECL_INITIAL (t), args, complain, in_decl); - /* There is no need to substitute into namespace-scope - enumerators. */ - if (DECL_NAMESPACE_SCOPE_P (t)) - return t; - /* If ARGS is NULL, then T is known to be non-dependent. */ - if (args == NULL_TREE) - return integral_constant_value (t); - - /* Unfortunately, we cannot just call lookup_name here. - Consider: - - template <int I> int f() { - enum E { a = I }; - struct S { void g() { E e = a; } }; - }; - - When we instantiate f<7>::S::g(), say, lookup_name is not - clever enough to find f<7>::a. */ - enum_type - = tsubst_aggr_type (TREE_TYPE (t), args, complain, in_decl, - /*entering_scope=*/0); - - for (v = TYPE_VALUES (enum_type); - v != NULL_TREE; - v = TREE_CHAIN (v)) - if (TREE_PURPOSE (v) == DECL_NAME (t)) - return TREE_VALUE (v); - - /* We didn't find the name. That should never happen; if - name-lookup found it during preliminary parsing, we - should find it again here during instantiation. */ - gcc_unreachable (); - } - return t; - - case FIELD_DECL: - if (DECL_CONTEXT (t)) - { - tree ctx; - - ctx = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, in_decl, - /*entering_scope=*/1); - if (ctx != DECL_CONTEXT (t)) - { - tree r = lookup_field (ctx, DECL_NAME (t), 0, false); - if (!r) - { - if (complain & tf_error) - error ("using invalid field %qD", t); - return error_mark_node; - } - return r; - } - } - - return t; - - case VAR_DECL: - case FUNCTION_DECL: - if ((DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t)) - || local_variable_p (t)) - t = tsubst (t, args, complain, in_decl); - mark_used (t); - return t; - - case BASELINK: - return tsubst_baselink (t, current_class_type, args, complain, in_decl); - - case TEMPLATE_DECL: - if (DECL_TEMPLATE_TEMPLATE_PARM_P (t)) - return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t)), - args, complain, in_decl); - else if (DECL_FUNCTION_TEMPLATE_P (t) && DECL_MEMBER_TEMPLATE_P (t)) - return tsubst (t, args, complain, in_decl); - else if (DECL_CLASS_SCOPE_P (t) - && uses_template_parms (DECL_CONTEXT (t))) - { - /* Template template argument like the following example need - special treatment: - - template <template <class> class TT> struct C {}; - template <class T> struct D { - template <class U> struct E {}; - C<E> c; // #1 - }; - D<int> d; // #2 - - We are processing the template argument `E' in #1 for - the template instantiation #2. Originally, `E' is a - TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we - have to substitute this with one having context `D<int>'. */ - - tree context = tsubst (DECL_CONTEXT (t), args, complain, in_decl); - return lookup_field (context, DECL_NAME(t), 0, false); - } - else - /* Ordinary template template argument. */ - return t; - - case CAST_EXPR: - case REINTERPRET_CAST_EXPR: - case CONST_CAST_EXPR: - case STATIC_CAST_EXPR: - case DYNAMIC_CAST_EXPR: - case NOP_EXPR: - return build1 - (code, tsubst (TREE_TYPE (t), args, complain, in_decl), - tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl)); - - case INDIRECT_REF: - case NEGATE_EXPR: - case TRUTH_NOT_EXPR: - case BIT_NOT_EXPR: - case ADDR_EXPR: - case UNARY_PLUS_EXPR: /* Unary + */ - case SIZEOF_EXPR: - case ALIGNOF_EXPR: - case ARROW_EXPR: - case THROW_EXPR: - case TYPEID_EXPR: - case REALPART_EXPR: - case IMAGPART_EXPR: - return build1 - (code, tsubst (TREE_TYPE (t), args, complain, in_decl), - tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl)); - - case COMPONENT_REF: - { - tree object; - tree name; - - object = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl); - name = TREE_OPERAND (t, 1); - if (TREE_CODE (name) == BIT_NOT_EXPR) - { - name = tsubst_copy (TREE_OPERAND (name, 0), args, - complain, in_decl); - name = build1 (BIT_NOT_EXPR, NULL_TREE, name); - } - else if (TREE_CODE (name) == SCOPE_REF - && TREE_CODE (TREE_OPERAND (name, 1)) == BIT_NOT_EXPR) - { - tree base = tsubst_copy (TREE_OPERAND (name, 0), args, - complain, in_decl); - name = TREE_OPERAND (name, 1); - name = tsubst_copy (TREE_OPERAND (name, 0), args, - complain, in_decl); - name = build1 (BIT_NOT_EXPR, NULL_TREE, name); - name = build_qualified_name (/*type=*/NULL_TREE, - base, name, - /*template_p=*/false); - } - else if (TREE_CODE (name) == BASELINK) - name = tsubst_baselink (name, - non_reference (TREE_TYPE (object)), - args, complain, - in_decl); - else - name = tsubst_copy (name, args, complain, in_decl); - return build_nt (COMPONENT_REF, object, name, NULL_TREE); - } - - case PLUS_EXPR: - case MINUS_EXPR: - case MULT_EXPR: - case TRUNC_DIV_EXPR: - case CEIL_DIV_EXPR: - case FLOOR_DIV_EXPR: - case ROUND_DIV_EXPR: - case EXACT_DIV_EXPR: - case BIT_AND_EXPR: - case BIT_IOR_EXPR: - case BIT_XOR_EXPR: - case TRUNC_MOD_EXPR: - case FLOOR_MOD_EXPR: - case TRUTH_ANDIF_EXPR: - case TRUTH_ORIF_EXPR: - case TRUTH_AND_EXPR: - case TRUTH_OR_EXPR: - case RSHIFT_EXPR: - case LSHIFT_EXPR: - case RROTATE_EXPR: - case LROTATE_EXPR: - case EQ_EXPR: - case NE_EXPR: - case MAX_EXPR: - case MIN_EXPR: - case LE_EXPR: - case GE_EXPR: - case LT_EXPR: - case GT_EXPR: - case COMPOUND_EXPR: - case DOTSTAR_EXPR: - case MEMBER_REF: - case PREDECREMENT_EXPR: - case PREINCREMENT_EXPR: - case POSTDECREMENT_EXPR: - case POSTINCREMENT_EXPR: - return build_nt - (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl), - tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl)); - - case SCOPE_REF: - return build_qualified_name (/*type=*/NULL_TREE, - tsubst_copy (TREE_OPERAND (t, 0), - args, complain, in_decl), - tsubst_copy (TREE_OPERAND (t, 1), - args, complain, in_decl), - QUALIFIED_NAME_IS_TEMPLATE (t)); - - case ARRAY_REF: - return build_nt - (ARRAY_REF, - tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl), - tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl), - NULL_TREE, NULL_TREE); - - case CALL_EXPR: - return build_nt (code, - tsubst_copy (TREE_OPERAND (t, 0), args, - complain, in_decl), - tsubst_copy (TREE_OPERAND (t, 1), args, complain, - in_decl), - NULL_TREE); - - case COND_EXPR: - case MODOP_EXPR: - case PSEUDO_DTOR_EXPR: - { - r = build_nt - (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl), - tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl), - tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl)); - TREE_NO_WARNING (r) = TREE_NO_WARNING (t); - return r; - } - - case NEW_EXPR: - { - r = build_nt - (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl), - tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl), - tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl)); - NEW_EXPR_USE_GLOBAL (r) = NEW_EXPR_USE_GLOBAL (t); - return r; - } - - case DELETE_EXPR: - { - r = build_nt - (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl), - tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl)); - DELETE_EXPR_USE_GLOBAL (r) = DELETE_EXPR_USE_GLOBAL (t); - DELETE_EXPR_USE_VEC (r) = DELETE_EXPR_USE_VEC (t); - return r; - } - - case TEMPLATE_ID_EXPR: - { - /* Substituted template arguments */ - tree fn = TREE_OPERAND (t, 0); - tree targs = TREE_OPERAND (t, 1); - - fn = tsubst_copy (fn, args, complain, in_decl); - if (targs) - targs = tsubst_template_args (targs, args, complain, in_decl); - - return lookup_template_function (fn, targs); - } - - case TREE_LIST: - { - tree purpose, value, chain; - - if (t == void_list_node) - return t; - - purpose = TREE_PURPOSE (t); - if (purpose) - purpose = tsubst_copy (purpose, args, complain, in_decl); - value = TREE_VALUE (t); - if (value) - value = tsubst_copy (value, args, complain, in_decl); - chain = TREE_CHAIN (t); - if (chain && chain != void_type_node) - chain = tsubst_copy (chain, args, complain, in_decl); - if (purpose == TREE_PURPOSE (t) - && value == TREE_VALUE (t) - && chain == TREE_CHAIN (t)) - return t; - return tree_cons (purpose, value, chain); - } - - case RECORD_TYPE: - case UNION_TYPE: - case ENUMERAL_TYPE: - case INTEGER_TYPE: - case TEMPLATE_TYPE_PARM: - case TEMPLATE_TEMPLATE_PARM: - case BOUND_TEMPLATE_TEMPLATE_PARM: - case TEMPLATE_PARM_INDEX: - case POINTER_TYPE: - case REFERENCE_TYPE: - case OFFSET_TYPE: - case FUNCTION_TYPE: - case METHOD_TYPE: - case ARRAY_TYPE: - case TYPENAME_TYPE: - case UNBOUND_CLASS_TEMPLATE: - case TYPEOF_TYPE: - case TYPE_DECL: - return tsubst (t, args, complain, in_decl); - - case IDENTIFIER_NODE: - if (IDENTIFIER_TYPENAME_P (t)) - { - tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl); - return mangle_conv_op_name_for_type (new_type); - } - else - return t; - - case CONSTRUCTOR: - /* This is handled by tsubst_copy_and_build. */ - gcc_unreachable (); - - case VA_ARG_EXPR: - return build_x_va_arg (tsubst_copy (TREE_OPERAND (t, 0), args, complain, - in_decl), - tsubst (TREE_TYPE (t), args, complain, in_decl)); - - case CLEANUP_POINT_EXPR: - /* We shouldn't have built any of these during initial template - generation. Instead, they should be built during instantiation - in response to the saved STMT_IS_FULL_EXPR_P setting. */ - gcc_unreachable (); - - case OFFSET_REF: - mark_used (TREE_OPERAND (t, 1)); - return t; - - default: - return t; - } -} - -/* Like tsubst_copy, but specifically for OpenMP clauses. */ - -static tree -tsubst_omp_clauses (tree clauses, tree args, tsubst_flags_t complain, - tree in_decl) -{ - tree new_clauses = NULL, nc, oc; - - for (oc = clauses; oc ; oc = OMP_CLAUSE_CHAIN (oc)) - { - nc = copy_node (oc); - OMP_CLAUSE_CHAIN (nc) = new_clauses; - new_clauses = nc; - - switch (OMP_CLAUSE_CODE (nc)) - { - case OMP_CLAUSE_PRIVATE: - case OMP_CLAUSE_SHARED: - case OMP_CLAUSE_FIRSTPRIVATE: - case OMP_CLAUSE_LASTPRIVATE: - case OMP_CLAUSE_REDUCTION: - case OMP_CLAUSE_COPYIN: - case OMP_CLAUSE_COPYPRIVATE: - case OMP_CLAUSE_IF: - case OMP_CLAUSE_NUM_THREADS: - case OMP_CLAUSE_SCHEDULE: - OMP_CLAUSE_OPERAND (nc, 0) - = tsubst_expr (OMP_CLAUSE_OPERAND (oc, 0), args, complain, - in_decl, /*integral_constant_expression_p=*/false); - break; - case OMP_CLAUSE_NOWAIT: - case OMP_CLAUSE_ORDERED: - case OMP_CLAUSE_DEFAULT: - break; - default: - gcc_unreachable (); - } - } - - return finish_omp_clauses (nreverse (new_clauses)); -} - -/* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */ - -static tree -tsubst_copy_asm_operands (tree t, tree args, tsubst_flags_t complain, - tree in_decl) -{ -#define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl) - - tree purpose, value, chain; - - if (t == NULL) - return t; - - if (TREE_CODE (t) != TREE_LIST) - return tsubst_copy_and_build (t, args, complain, in_decl, - /*function_p=*/false, - /*integral_constant_expression_p=*/false); - - if (t == void_list_node) - return t; - - purpose = TREE_PURPOSE (t); - if (purpose) - purpose = RECUR (purpose); - value = TREE_VALUE (t); - if (value) - value = RECUR (value); - chain = TREE_CHAIN (t); - if (chain && chain != void_type_node) - chain = RECUR (chain); - return tree_cons (purpose, value, chain); -#undef RECUR -} - -/* Like tsubst_copy for expressions, etc. but also does semantic - processing. */ - -static tree -tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl, - bool integral_constant_expression_p) -{ -#define RECUR(NODE) \ - tsubst_expr ((NODE), args, complain, in_decl, \ - integral_constant_expression_p) - - tree stmt, tmp; - - if (t == NULL_TREE || t == error_mark_node) - return t; - - if (EXPR_HAS_LOCATION (t)) - input_location = EXPR_LOCATION (t); - if (STATEMENT_CODE_P (TREE_CODE (t))) - current_stmt_tree ()->stmts_are_full_exprs_p = STMT_IS_FULL_EXPR_P (t); - - switch (TREE_CODE (t)) - { - case STATEMENT_LIST: - { - tree_stmt_iterator i; - for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i)) - RECUR (tsi_stmt (i)); - break; - } - - case CTOR_INITIALIZER: - finish_mem_initializers (tsubst_initializer_list - (TREE_OPERAND (t, 0), args)); - break; - - case RETURN_EXPR: - finish_return_stmt (RECUR (TREE_OPERAND (t, 0))); - break; - - case EXPR_STMT: - tmp = RECUR (EXPR_STMT_EXPR (t)); - if (EXPR_STMT_STMT_EXPR_RESULT (t)) - finish_stmt_expr_expr (tmp, cur_stmt_expr); - else - finish_expr_stmt (tmp); - break; - - case USING_STMT: - do_using_directive (RECUR (USING_STMT_NAMESPACE (t))); - break; - - case DECL_EXPR: - { - tree decl; - tree init; - - decl = DECL_EXPR_DECL (t); - if (TREE_CODE (decl) == LABEL_DECL) - finish_label_decl (DECL_NAME (decl)); - else if (TREE_CODE (decl) == USING_DECL) - { - tree scope = USING_DECL_SCOPE (decl); - tree name = DECL_NAME (decl); - tree decl; - - scope = RECUR (scope); - decl = lookup_qualified_name (scope, name, - /*is_type_p=*/false, - /*complain=*/false); - if (decl == error_mark_node || TREE_CODE (decl) == TREE_LIST) - qualified_name_lookup_error (scope, name, decl); - else - do_local_using_decl (decl, scope, name); - } - else - { - init = DECL_INITIAL (decl); - decl = tsubst (decl, args, complain, in_decl); - if (decl != error_mark_node) - { - /* By marking the declaration as instantiated, we avoid - trying to instantiate it. Since instantiate_decl can't - handle local variables, and since we've already done - all that needs to be done, that's the right thing to - do. */ - if (TREE_CODE (decl) == VAR_DECL) - DECL_TEMPLATE_INSTANTIATED (decl) = 1; - if (TREE_CODE (decl) == VAR_DECL - && ANON_AGGR_TYPE_P (TREE_TYPE (decl))) - /* Anonymous aggregates are a special case. */ - finish_anon_union (decl); - else - { - maybe_push_decl (decl); - if (TREE_CODE (decl) == VAR_DECL - && DECL_PRETTY_FUNCTION_P (decl)) - { - /* For __PRETTY_FUNCTION__ we have to adjust the - initializer. */ - const char *const name - = cxx_printable_name (current_function_decl, 2); - init = cp_fname_init (name, &TREE_TYPE (decl)); - } - else - init = RECUR (init); - finish_decl (decl, init, NULL_TREE); - } - } - } - - /* A DECL_EXPR can also be used as an expression, in the condition - clause of an if/for/while construct. */ - return decl; - } - - case FOR_STMT: -/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \ - tmp = RECUR (FOR_ATTRIBUTES (t)); - stmt = begin_for_stmt (tmp); - RECUR (FOR_INIT_STMT (t)); -/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \ - finish_for_init_stmt (stmt); - tmp = RECUR (FOR_COND (t)); - finish_for_cond (tmp, stmt); - tmp = RECUR (FOR_EXPR (t)); - finish_for_expr (tmp, stmt); - RECUR (FOR_BODY (t)); - finish_for_stmt (stmt); - break; - - case WHILE_STMT: -/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \ - tmp = RECUR (WHILE_ATTRIBUTES (t)); - stmt = begin_while_stmt (tmp); -/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \ - tmp = RECUR (WHILE_COND (t)); - finish_while_stmt_cond (tmp, stmt); - RECUR (WHILE_BODY (t)); - finish_while_stmt (stmt); - break; - - case DO_STMT: -/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \ - tmp = RECUR (DO_ATTRIBUTES (t)); - stmt = begin_do_stmt (tmp); -/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \ - RECUR (DO_BODY (t)); - finish_do_body (stmt); - tmp = RECUR (DO_COND (t)); - finish_do_stmt (tmp, stmt); - break; - - case IF_STMT: - stmt = begin_if_stmt (); - tmp = RECUR (IF_COND (t)); - finish_if_stmt_cond (tmp, stmt); - RECUR (THEN_CLAUSE (t)); - finish_then_clause (stmt); - - if (ELSE_CLAUSE (t)) - { - begin_else_clause (stmt); - RECUR (ELSE_CLAUSE (t)); - finish_else_clause (stmt); - } - - finish_if_stmt (stmt); - break; - - case BIND_EXPR: - if (BIND_EXPR_BODY_BLOCK (t)) - stmt = begin_function_body (); - else - stmt = begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t) - ? BCS_TRY_BLOCK : 0); - - RECUR (BIND_EXPR_BODY (t)); - - if (BIND_EXPR_BODY_BLOCK (t)) - finish_function_body (stmt); - else - finish_compound_stmt (stmt); - break; - - case BREAK_STMT: - finish_break_stmt (); - break; - - case CONTINUE_STMT: - finish_continue_stmt (); - break; - - case SWITCH_STMT: - stmt = begin_switch_stmt (); - tmp = RECUR (SWITCH_STMT_COND (t)); - finish_switch_cond (tmp, stmt); - RECUR (SWITCH_STMT_BODY (t)); - finish_switch_stmt (stmt); - break; - - case CASE_LABEL_EXPR: - finish_case_label (RECUR (CASE_LOW (t)), - RECUR (CASE_HIGH (t))); - break; - - case LABEL_EXPR: - finish_label_stmt (DECL_NAME (LABEL_EXPR_LABEL (t))); - break; - - case GOTO_EXPR: - tmp = GOTO_DESTINATION (t); - if (TREE_CODE (tmp) != LABEL_DECL) - /* Computed goto's must be tsubst'd into. On the other hand, - non-computed gotos must not be; the identifier in question - will have no binding. */ - tmp = RECUR (tmp); - else - tmp = DECL_NAME (tmp); - finish_goto_stmt (tmp); - break; - - case ASM_EXPR: - tmp = finish_asm_stmt - (ASM_VOLATILE_P (t), - RECUR (ASM_STRING (t)), - tsubst_copy_asm_operands (ASM_OUTPUTS (t), args, complain, in_decl), - tsubst_copy_asm_operands (ASM_INPUTS (t), args, complain, in_decl), - /* APPLE LOCAL begin CW asm blocks */ - tsubst_copy_asm_operands (ASM_CLOBBERS (t), args, complain, in_decl), - tsubst_copy_asm_operands (ASM_USES (t), args, complain, in_decl)); - /* APPLE LOCAL end CW asm blocks */ - { - tree asm_expr = tmp; - if (TREE_CODE (asm_expr) == CLEANUP_POINT_EXPR) - asm_expr = TREE_OPERAND (asm_expr, 0); - ASM_INPUT_P (asm_expr) = ASM_INPUT_P (t); - /* APPLE LOCAL begin inline asm labels in templates 6606502 */ - /* We have to check to see if we have a CW style inline assembly - label, and mark it as defined, if this asm defines it. */ - if (TREE_CODE (TREE_OPERAND (asm_expr, 0)) == STRING_CST - && TREE_STRING_LENGTH (TREE_OPERAND (asm_expr, 0)) >= 5 - && strncmp (TREE_STRING_POINTER (TREE_OPERAND (asm_expr, 0)), - "%l0:", 4)) - { - tree inner = TREE_OPERAND (asm_expr, 2); - if (inner && TREE_CODE (inner) == TREE_LIST) - { - inner = TREE_VALUE (inner); - if (inner && TREE_CODE (inner) == ADDR_EXPR) { - inner = TREE_OPERAND (inner, 0); - if (TREE_CODE (inner) == LABEL_DECL) - DECL_INITIAL (inner) = error_mark_node; - } - } - } - /* APPLE LOCAL end inline asm labels in templates 6606502 */ - } - break; - - case TRY_BLOCK: - if (CLEANUP_P (t)) - { - stmt = begin_try_block (); - RECUR (TRY_STMTS (t)); - finish_cleanup_try_block (stmt); - finish_cleanup (RECUR (TRY_HANDLERS (t)), stmt); - } - else - { - tree compound_stmt = NULL_TREE; - - if (FN_TRY_BLOCK_P (t)) - stmt = begin_function_try_block (&compound_stmt); - else - stmt = begin_try_block (); - - RECUR (TRY_STMTS (t)); - - if (FN_TRY_BLOCK_P (t)) - finish_function_try_block (stmt); - else - finish_try_block (stmt); - - RECUR (TRY_HANDLERS (t)); - if (FN_TRY_BLOCK_P (t)) - finish_function_handler_sequence (stmt, compound_stmt); - else - finish_handler_sequence (stmt); - } - break; - - case HANDLER: - { - tree decl = HANDLER_PARMS (t); - - if (decl) - { - decl = tsubst (decl, args, complain, in_decl); - /* Prevent instantiate_decl from trying to instantiate - this variable. We've already done all that needs to be - done. */ - if (decl != error_mark_node) - DECL_TEMPLATE_INSTANTIATED (decl) = 1; - } - stmt = begin_handler (); - finish_handler_parms (decl, stmt); - RECUR (HANDLER_BODY (t)); - finish_handler (stmt); - } - break; - - case TAG_DEFN: - tsubst (TREE_TYPE (t), args, complain, NULL_TREE); - break; - - case OMP_PARALLEL: - tmp = tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t), - args, complain, in_decl); - stmt = begin_omp_parallel (); - RECUR (OMP_PARALLEL_BODY (t)); - OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp, stmt)) - = OMP_PARALLEL_COMBINED (t); - break; - - case OMP_FOR: - { - tree clauses, decl, init, cond, incr, body, pre_body; - - clauses = tsubst_omp_clauses (OMP_FOR_CLAUSES (t), - args, complain, in_decl); - init = OMP_FOR_INIT (t); - gcc_assert (TREE_CODE (init) == MODIFY_EXPR); - decl = RECUR (TREE_OPERAND (init, 0)); - init = RECUR (TREE_OPERAND (init, 1)); - cond = RECUR (OMP_FOR_COND (t)); - incr = RECUR (OMP_FOR_INCR (t)); - - stmt = begin_omp_structured_block (); - - pre_body = push_stmt_list (); - RECUR (OMP_FOR_PRE_BODY (t)); - pre_body = pop_stmt_list (pre_body); - - body = push_stmt_list (); - RECUR (OMP_FOR_BODY (t)); - body = pop_stmt_list (body); - - t = finish_omp_for (EXPR_LOCATION (t), decl, init, cond, incr, body, - pre_body); - if (t) - OMP_FOR_CLAUSES (t) = clauses; - - add_stmt (finish_omp_structured_block (stmt)); - } - break; - - case OMP_SECTIONS: - case OMP_SINGLE: - tmp = tsubst_omp_clauses (OMP_CLAUSES (t), args, complain, in_decl); - stmt = push_stmt_list (); - RECUR (OMP_BODY (t)); - stmt = pop_stmt_list (stmt); - - t = copy_node (t); - OMP_BODY (t) = stmt; - OMP_CLAUSES (t) = tmp; - add_stmt (t); - break; - - case OMP_SECTION: - case OMP_CRITICAL: - case OMP_MASTER: - case OMP_ORDERED: - stmt = push_stmt_list (); - RECUR (OMP_BODY (t)); - stmt = pop_stmt_list (stmt); - - t = copy_node (t); - OMP_BODY (t) = stmt; - add_stmt (t); - break; - - case OMP_ATOMIC: - { - tree op0, op1; - op0 = RECUR (TREE_OPERAND (t, 0)); - op1 = RECUR (TREE_OPERAND (t, 1)); - finish_omp_atomic (OMP_ATOMIC_CODE (t), op0, op1); - } - break; - - default: - gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t))); - - return tsubst_copy_and_build (t, args, complain, in_decl, - /*function_p=*/false, - integral_constant_expression_p); - } - - return NULL_TREE; -#undef RECUR -} - -/* T is a postfix-expression that is not being used in a function - call. Return the substituted version of T. */ - -static tree -tsubst_non_call_postfix_expression (tree t, tree args, - tsubst_flags_t complain, - tree in_decl) -{ - if (TREE_CODE (t) == SCOPE_REF) - t = tsubst_qualified_id (t, args, complain, in_decl, - /*done=*/false, /*address_p=*/false); - else - t = tsubst_copy_and_build (t, args, complain, in_decl, - /*function_p=*/false, - /*integral_constant_expression_p=*/false); - - return t; -} - -/* Like tsubst but deals with expressions and performs semantic - analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */ - -tree -tsubst_copy_and_build (tree t, - tree args, - tsubst_flags_t complain, - tree in_decl, - bool function_p, - bool integral_constant_expression_p) -{ -#define RECUR(NODE) \ - tsubst_copy_and_build (NODE, args, complain, in_decl, \ - /*function_p=*/false, \ - integral_constant_expression_p) - - tree op1; - - if (t == NULL_TREE || t == error_mark_node) - return t; - - switch (TREE_CODE (t)) - { - case USING_DECL: - t = DECL_NAME (t); - /* Fall through. */ - case IDENTIFIER_NODE: - { - tree decl; - cp_id_kind idk; - bool non_integral_constant_expression_p; - const char *error_msg; - - if (IDENTIFIER_TYPENAME_P (t)) - { - tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl); - t = mangle_conv_op_name_for_type (new_type); - } - - /* Look up the name. */ - decl = lookup_name (t); - - /* By convention, expressions use ERROR_MARK_NODE to indicate - failure, not NULL_TREE. */ - if (decl == NULL_TREE) - decl = error_mark_node; - - decl = finish_id_expression (t, decl, NULL_TREE, - &idk, - integral_constant_expression_p, - /*allow_non_integral_constant_expression_p=*/false, - &non_integral_constant_expression_p, - /*template_p=*/false, - /*done=*/true, - /*address_p=*/false, - /*template_arg_p=*/false, - &error_msg); - if (error_msg) - /* APPLE LOCAL default to Wformat-security 5764921 */ - error ("%s", error_msg); - if (!function_p && TREE_CODE (decl) == IDENTIFIER_NODE) - decl = unqualified_name_lookup_error (decl); - return decl; - } - - case TEMPLATE_ID_EXPR: - { - tree object; - tree template = RECUR (TREE_OPERAND (t, 0)); - tree targs = TREE_OPERAND (t, 1); - - if (targs) - targs = tsubst_template_args (targs, args, complain, in_decl); - - if (TREE_CODE (template) == COMPONENT_REF) - { - object = TREE_OPERAND (template, 0); - template = TREE_OPERAND (template, 1); - } - else - object = NULL_TREE; - template = lookup_template_function (template, targs); - - if (object) - return build3 (COMPONENT_REF, TREE_TYPE (template), - object, template, NULL_TREE); - else - return baselink_for_fns (template); - } - - case INDIRECT_REF: - { - tree r = RECUR (TREE_OPERAND (t, 0)); - - if (REFERENCE_REF_P (t)) - { - /* A type conversion to reference type will be enclosed in - such an indirect ref, but the substitution of the cast - will have also added such an indirect ref. */ - if (TREE_CODE (TREE_TYPE (r)) == REFERENCE_TYPE) - r = convert_from_reference (r); - } - else - r = build_x_indirect_ref (r, "unary *"); - return r; - } - - case NOP_EXPR: - return build_nop - (tsubst (TREE_TYPE (t), args, complain, in_decl), - RECUR (TREE_OPERAND (t, 0))); - - case CAST_EXPR: - case REINTERPRET_CAST_EXPR: - case CONST_CAST_EXPR: - case DYNAMIC_CAST_EXPR: - case STATIC_CAST_EXPR: - { - tree type; - tree op; - - type = tsubst (TREE_TYPE (t), args, complain, in_decl); - if (integral_constant_expression_p - && !cast_valid_in_integral_constant_expression_p (type)) - { - error ("a cast to a type other than an integral or " - "enumeration type cannot appear in a constant-expression"); - return error_mark_node; - } - - op = RECUR (TREE_OPERAND (t, 0)); - - switch (TREE_CODE (t)) - { - case CAST_EXPR: - return build_functional_cast (type, op); - case REINTERPRET_CAST_EXPR: - return build_reinterpret_cast (type, op); - case CONST_CAST_EXPR: - return build_const_cast (type, op); - case DYNAMIC_CAST_EXPR: - return build_dynamic_cast (type, op); - case STATIC_CAST_EXPR: - return build_static_cast (type, op); - default: - gcc_unreachable (); - } - } - - case POSTDECREMENT_EXPR: - case POSTINCREMENT_EXPR: - op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0), - args, complain, in_decl); - return build_x_unary_op (TREE_CODE (t), op1); - - case PREDECREMENT_EXPR: - case PREINCREMENT_EXPR: - case NEGATE_EXPR: - case BIT_NOT_EXPR: - case ABS_EXPR: - case TRUTH_NOT_EXPR: - case UNARY_PLUS_EXPR: /* Unary + */ - case REALPART_EXPR: - case IMAGPART_EXPR: - return build_x_unary_op (TREE_CODE (t), RECUR (TREE_OPERAND (t, 0))); - - case ADDR_EXPR: - op1 = TREE_OPERAND (t, 0); - if (TREE_CODE (op1) == SCOPE_REF) - op1 = tsubst_qualified_id (op1, args, complain, in_decl, - /*done=*/true, /*address_p=*/true); - /* APPLE LOCAL begin constant cfstrings - radar 4557092 */ - /* CFSTRING is represented as an ADDR_EXPR of a CONST_DECL node whose - DECL_INITIAL field holds the CONSTRUCTOR initializer. We cannot - fold away CONST_DECL part since this results in ADDR_EXPR of - CONSTRUCTOR node which is wrong and causes gimplifier to assign - CONSTRUCTOR to a local temporary and function returning address - of this temporary. */ - else if (TREE_CODE (op1) == CONST_DECL - && TREE_CODE (DECL_INITIAL (op1)) == CONSTRUCTOR) - ; - /* APPLE LOCAL end constant cfstrings - radar 4557092 */ - else - op1 = tsubst_non_call_postfix_expression (op1, args, complain, - in_decl); - if (TREE_CODE (op1) == LABEL_DECL) - return finish_label_address_expr (DECL_NAME (op1)); - return build_x_unary_op (ADDR_EXPR, op1); - - case PLUS_EXPR: - case MINUS_EXPR: - case MULT_EXPR: - case TRUNC_DIV_EXPR: - case CEIL_DIV_EXPR: - case FLOOR_DIV_EXPR: - case ROUND_DIV_EXPR: - case EXACT_DIV_EXPR: - case BIT_AND_EXPR: - case BIT_IOR_EXPR: - case BIT_XOR_EXPR: - case TRUNC_MOD_EXPR: - case FLOOR_MOD_EXPR: - case TRUTH_ANDIF_EXPR: - case TRUTH_ORIF_EXPR: - case TRUTH_AND_EXPR: - case TRUTH_OR_EXPR: - case RSHIFT_EXPR: - case LSHIFT_EXPR: - case RROTATE_EXPR: - case LROTATE_EXPR: - case EQ_EXPR: - case NE_EXPR: - case MAX_EXPR: - case MIN_EXPR: - case LE_EXPR: - case GE_EXPR: - case LT_EXPR: - case GT_EXPR: - case MEMBER_REF: - case DOTSTAR_EXPR: - return build_x_binary_op - (TREE_CODE (t), - RECUR (TREE_OPERAND (t, 0)), - RECUR (TREE_OPERAND (t, 1)), - /*overloaded_p=*/NULL); - - case SCOPE_REF: - return tsubst_qualified_id (t, args, complain, in_decl, /*done=*/true, - /*address_p=*/false); - case ARRAY_REF: - op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0), - args, complain, in_decl); - return build_x_binary_op (ARRAY_REF, op1, RECUR (TREE_OPERAND (t, 1)), - /*overloaded_p=*/NULL); - - case SIZEOF_EXPR: - case ALIGNOF_EXPR: - op1 = TREE_OPERAND (t, 0); - if (!args) - { - /* When there are no ARGS, we are trying to evaluate a - non-dependent expression from the parser. Trying to do - the substitutions may not work. */ - if (!TYPE_P (op1)) - op1 = TREE_TYPE (op1); - } - else - { - ++skip_evaluation; - op1 = tsubst_copy_and_build (op1, args, complain, in_decl, - /*function_p=*/false, - /*integral_constant_expression_p=*/false); - --skip_evaluation; - } - if (TYPE_P (op1)) - return cxx_sizeof_or_alignof_type (op1, TREE_CODE (t), true); - else - return cxx_sizeof_or_alignof_expr (op1, TREE_CODE (t)); - - /* APPLE LOCAL begin radar 4278774 */ - case AT_ENCODE_EXPR: - { - op1 = TREE_OPERAND (t, 0); - ++skip_evaluation; - op1 = RECUR (op1); - --skip_evaluation; - return objc_build_encode_expr (op1); - } - /* APPLE LOCAL end radar 4278774 */ - - case MODOP_EXPR: - { - tree r = build_x_modify_expr - (RECUR (TREE_OPERAND (t, 0)), - TREE_CODE (TREE_OPERAND (t, 1)), - RECUR (TREE_OPERAND (t, 2))); - /* TREE_NO_WARNING must be set if either the expression was - parenthesized or it uses an operator such as >>= rather - than plain assignment. In the former case, it was already - set and must be copied. In the latter case, - build_x_modify_expr sets it and it must not be reset - here. */ - if (TREE_NO_WARNING (t)) - TREE_NO_WARNING (r) = TREE_NO_WARNING (t); - return r; - } - - case ARROW_EXPR: - op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0), - args, complain, in_decl); - /* Remember that there was a reference to this entity. */ - if (DECL_P (op1)) - mark_used (op1); - return build_x_arrow (op1); - - case NEW_EXPR: - return build_new - (RECUR (TREE_OPERAND (t, 0)), - RECUR (TREE_OPERAND (t, 1)), - RECUR (TREE_OPERAND (t, 2)), - RECUR (TREE_OPERAND (t, 3)), - NEW_EXPR_USE_GLOBAL (t)); - - case DELETE_EXPR: - return delete_sanity - (RECUR (TREE_OPERAND (t, 0)), - RECUR (TREE_OPERAND (t, 1)), - DELETE_EXPR_USE_VEC (t), - DELETE_EXPR_USE_GLOBAL (t)); - - case COMPOUND_EXPR: - return build_x_compound_expr (RECUR (TREE_OPERAND (t, 0)), - RECUR (TREE_OPERAND (t, 1))); - - case CALL_EXPR: - { - tree function; - tree call_args; - bool qualified_p; - bool koenig_p; - - function = TREE_OPERAND (t, 0); - /* When we parsed the expression, we determined whether or - not Koenig lookup should be performed. */ - koenig_p = KOENIG_LOOKUP_P (t); - if (TREE_CODE (function) == SCOPE_REF) - { - qualified_p = true; - function = tsubst_qualified_id (function, args, complain, in_decl, - /*done=*/false, - /*address_p=*/false); - } - else - { - if (TREE_CODE (function) == COMPONENT_REF) - { - tree op = TREE_OPERAND (function, 1); - - qualified_p = (TREE_CODE (op) == SCOPE_REF - || (BASELINK_P (op) - && BASELINK_QUALIFIED_P (op))); - } - else - qualified_p = false; - - function = tsubst_copy_and_build (function, args, complain, - in_decl, - !qualified_p, - integral_constant_expression_p); - - if (BASELINK_P (function)) - qualified_p = true; - } - - call_args = RECUR (TREE_OPERAND (t, 1)); - - /* We do not perform argument-dependent lookup if normal - lookup finds a non-function, in accordance with the - expected resolution of DR 218. */ - if (koenig_p - && ((is_overloaded_fn (function) - /* If lookup found a member function, the Koenig lookup is - not appropriate, even if an unqualified-name was used - to denote the function. */ - && !DECL_FUNCTION_MEMBER_P (get_first_fn (function))) - || TREE_CODE (function) == IDENTIFIER_NODE)) - function = perform_koenig_lookup (function, call_args); - - if (TREE_CODE (function) == IDENTIFIER_NODE) - { - unqualified_name_lookup_error (function); - return error_mark_node; - } - - /* Remember that there was a reference to this entity. */ - if (DECL_P (function)) - mark_used (function); - - if (TREE_CODE (function) == OFFSET_REF) - return build_offset_ref_call_from_tree (function, call_args); - if (TREE_CODE (function) == COMPONENT_REF) - { - if (!BASELINK_P (TREE_OPERAND (function, 1))) - return finish_call_expr (function, call_args, - /*disallow_virtual=*/false, - /*koenig_p=*/false); - else - return (build_new_method_call - (TREE_OPERAND (function, 0), - TREE_OPERAND (function, 1), - call_args, NULL_TREE, - qualified_p ? LOOKUP_NONVIRTUAL : LOOKUP_NORMAL, - /*fn_p=*/NULL)); - } - return finish_call_expr (function, call_args, - /*disallow_virtual=*/qualified_p, - koenig_p); - } - - case COND_EXPR: - return build_x_conditional_expr - (RECUR (TREE_OPERAND (t, 0)), - RECUR (TREE_OPERAND (t, 1)), - RECUR (TREE_OPERAND (t, 2))); - - case PSEUDO_DTOR_EXPR: - return finish_pseudo_destructor_expr - (RECUR (TREE_OPERAND (t, 0)), - RECUR (TREE_OPERAND (t, 1)), - RECUR (TREE_OPERAND (t, 2))); - - case TREE_LIST: - { - tree purpose, value, chain; - - if (t == void_list_node) - return t; - - purpose = TREE_PURPOSE (t); - if (purpose) - purpose = RECUR (purpose); - value = TREE_VALUE (t); - if (value) - value = RECUR (value); - chain = TREE_CHAIN (t); - if (chain && chain != void_type_node) - chain = RECUR (chain); - if (purpose == TREE_PURPOSE (t) - && value == TREE_VALUE (t) - && chain == TREE_CHAIN (t)) - return t; - return tree_cons (purpose, value, chain); - } - - case COMPONENT_REF: - { - tree object; - tree object_type; - tree member; - - object = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0), - args, complain, in_decl); - /* Remember that there was a reference to this entity. */ - if (DECL_P (object)) - mark_used (object); - object_type = TREE_TYPE (object); - - member = TREE_OPERAND (t, 1); - if (BASELINK_P (member)) - member = tsubst_baselink (member, - non_reference (TREE_TYPE (object)), - args, complain, in_decl); - else - member = tsubst_copy (member, args, complain, in_decl); - if (member == error_mark_node) - return error_mark_node; - - if (object_type && !CLASS_TYPE_P (object_type)) - { - if (TREE_CODE (member) == BIT_NOT_EXPR) - return finish_pseudo_destructor_expr (object, - NULL_TREE, - object_type); - else if (TREE_CODE (member) == SCOPE_REF - && (TREE_CODE (TREE_OPERAND (member, 1)) == BIT_NOT_EXPR)) - return finish_pseudo_destructor_expr (object, - object, - object_type); - } - else if (TREE_CODE (member) == SCOPE_REF - && TREE_CODE (TREE_OPERAND (member, 1)) == TEMPLATE_ID_EXPR) - { - tree tmpl; - tree args; - - /* Lookup the template functions now that we know what the - scope is. */ - tmpl = TREE_OPERAND (TREE_OPERAND (member, 1), 0); - args = TREE_OPERAND (TREE_OPERAND (member, 1), 1); - member = lookup_qualified_name (TREE_OPERAND (member, 0), tmpl, - /*is_type_p=*/false, - /*complain=*/false); - if (BASELINK_P (member)) - { - BASELINK_FUNCTIONS (member) - = build_nt (TEMPLATE_ID_EXPR, BASELINK_FUNCTIONS (member), - args); - member = (adjust_result_of_qualified_name_lookup - (member, BINFO_TYPE (BASELINK_BINFO (member)), - object_type)); - } - else - { - qualified_name_lookup_error (object_type, tmpl, member); - return error_mark_node; - } - } - else if (TREE_CODE (member) == SCOPE_REF - && !CLASS_TYPE_P (TREE_OPERAND (member, 0)) - && TREE_CODE (TREE_OPERAND (member, 0)) != NAMESPACE_DECL) - { - if (complain & tf_error) - { - if (TYPE_P (TREE_OPERAND (member, 0))) - error ("%qT is not a class or namespace", - TREE_OPERAND (member, 0)); - else - error ("%qD is not a class or namespace", - TREE_OPERAND (member, 0)); - } - return error_mark_node; - } - else if (TREE_CODE (member) == FIELD_DECL) - return finish_non_static_data_member (member, object, NULL_TREE); - - return finish_class_member_access_expr (object, member, - /*template_p=*/false); - } - - case THROW_EXPR: - return build_throw - (RECUR (TREE_OPERAND (t, 0))); - - case CONSTRUCTOR: - { - VEC(constructor_elt,gc) *n; - constructor_elt *ce; - unsigned HOST_WIDE_INT idx; - tree type = tsubst (TREE_TYPE (t), args, complain, in_decl); - bool process_index_p; - - if (type == error_mark_node) - return error_mark_node; - - /* digest_init will do the wrong thing if we let it. */ - if (type && TYPE_PTRMEMFUNC_P (type)) - return t; - - /* We do not want to process the index of aggregate - initializers as they are identifier nodes which will be - looked up by digest_init. */ - process_index_p = !(type && IS_AGGR_TYPE (type)); - - n = VEC_copy (constructor_elt, gc, CONSTRUCTOR_ELTS (t)); - for (idx = 0; VEC_iterate (constructor_elt, n, idx, ce); idx++) - { - if (ce->index && process_index_p) - ce->index = RECUR (ce->index); - ce->value = RECUR (ce->value); - } - - if (TREE_HAS_CONSTRUCTOR (t)) - return finish_compound_literal (type, n); - - return build_constructor (NULL_TREE, n); - } - - case TYPEID_EXPR: - { - tree operand_0 = RECUR (TREE_OPERAND (t, 0)); - if (TYPE_P (operand_0)) - return get_typeid (operand_0); - return build_typeid (operand_0); - } - - case VAR_DECL: - if (!args) - return t; - /* Fall through */ - - case PARM_DECL: - { - tree r = tsubst_copy (t, args, complain, in_decl); - - if (TREE_CODE (TREE_TYPE (t)) != REFERENCE_TYPE) - /* If the original type was a reference, we'll be wrapped in - the appropriate INDIRECT_REF. */ - r = convert_from_reference (r); - return r; - } - - case VA_ARG_EXPR: - return build_x_va_arg (RECUR (TREE_OPERAND (t, 0)), - tsubst_copy (TREE_TYPE (t), args, complain, - in_decl)); - - case OFFSETOF_EXPR: - return finish_offsetof (RECUR (TREE_OPERAND (t, 0))); - - case STMT_EXPR: - { - tree old_stmt_expr = cur_stmt_expr; - tree stmt_expr = begin_stmt_expr (); - - cur_stmt_expr = stmt_expr; - tsubst_expr (STMT_EXPR_STMT (t), args, complain, in_decl, - integral_constant_expression_p); - stmt_expr = finish_stmt_expr (stmt_expr, false); - cur_stmt_expr = old_stmt_expr; - - return stmt_expr; - } - - case CONST_DECL: - t = tsubst_copy (t, args, complain, in_decl); - /* As in finish_id_expression, we resolve enumeration constants - to their underlying values. */ - if (TREE_CODE (t) == CONST_DECL) - { - used_types_insert (TREE_TYPE (t)); - return DECL_INITIAL (t); - } - return t; - - default: - /* Handle Objective-C++ constructs, if appropriate. */ - { - tree subst - = objcp_tsubst_copy_and_build (t, args, complain, - in_decl, /*function_p=*/false); - if (subst) - return subst; - } - return tsubst_copy (t, args, complain, in_decl); - } - -#undef RECUR -} - -/* Verify that the instantiated ARGS are valid. For type arguments, - make sure that the type's linkage is ok. For non-type arguments, - make sure they are constants if they are integral or enumerations. - Emit an error under control of COMPLAIN, and return TRUE on error. */ - -static bool -check_instantiated_args (tree tmpl, tree args, tsubst_flags_t complain) -{ - int ix, len = DECL_NTPARMS (tmpl); - bool result = false; - - for (ix = 0; ix != len; ix++) - { - tree t = TREE_VEC_ELT (args, ix); - - if (TYPE_P (t)) - { - /* [basic.link]: A name with no linkage (notably, the name - of a class or enumeration declared in a local scope) - shall not be used to declare an entity with linkage. - This implies that names with no linkage cannot be used as - template arguments. */ - tree nt = no_linkage_check (t, /*relaxed_p=*/false); - - if (nt) - { - /* DR 488 makes use of a type with no linkage cause - type deduction to fail. */ - if (complain & tf_error) - { - if (TYPE_ANONYMOUS_P (nt)) - error ("%qT is/uses anonymous type", t); - else - error ("template argument for %qD uses local type %qT", - tmpl, t); - } - result = true; - } - /* In order to avoid all sorts of complications, we do not - allow variably-modified types as template arguments. */ - else if (variably_modified_type_p (t, NULL_TREE)) - { - if (complain & tf_error) - error ("%qT is a variably modified type", t); - result = true; - } - } - /* A non-type argument of integral or enumerated type must be a - constant. */ - else if (TREE_TYPE (t) - && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t)) - && !TREE_CONSTANT (t)) - { - if (complain & tf_error) - error ("integral expression %qE is not constant", t); - result = true; - } - } - if (result && (complain & tf_error)) - error (" trying to instantiate %qD", tmpl); - return result; -} - -/* Instantiate the indicated variable or function template TMPL with - the template arguments in TARG_PTR. */ - -tree -instantiate_template (tree tmpl, tree targ_ptr, tsubst_flags_t complain) -{ - tree fndecl; - tree gen_tmpl; - tree spec; - HOST_WIDE_INT saved_processing_template_decl; - - if (tmpl == error_mark_node) - return error_mark_node; - - gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL); - - /* If this function is a clone, handle it specially. */ - if (DECL_CLONED_FUNCTION_P (tmpl)) - { - tree spec; - tree clone; - - spec = instantiate_template (DECL_CLONED_FUNCTION (tmpl), targ_ptr, - complain); - if (spec == error_mark_node) - return error_mark_node; - - /* Look for the clone. */ - FOR_EACH_CLONE (clone, spec) - if (DECL_NAME (clone) == DECL_NAME (tmpl)) - return clone; - /* We should always have found the clone by now. */ - gcc_unreachable (); - return NULL_TREE; - } - - /* Check to see if we already have this specialization. */ - spec = retrieve_specialization (tmpl, targ_ptr, - /*class_specializations_p=*/false); - if (spec != NULL_TREE) - return spec; - - gen_tmpl = most_general_template (tmpl); - if (tmpl != gen_tmpl) - { - /* The TMPL is a partial instantiation. To get a full set of - arguments we must add the arguments used to perform the - partial instantiation. */ - targ_ptr = add_outermost_template_args (DECL_TI_ARGS (tmpl), - targ_ptr); - - /* Check to see if we already have this specialization. */ - spec = retrieve_specialization (gen_tmpl, targ_ptr, - /*class_specializations_p=*/false); - if (spec != NULL_TREE) - return spec; - } - - if (check_instantiated_args (gen_tmpl, INNERMOST_TEMPLATE_ARGS (targ_ptr), - complain)) - return error_mark_node; - - /* We are building a FUNCTION_DECL, during which the access of its - parameters and return types have to be checked. However this - FUNCTION_DECL which is the desired context for access checking - is not built yet. We solve this chicken-and-egg problem by - deferring all checks until we have the FUNCTION_DECL. */ - push_deferring_access_checks (dk_deferred); - - /* Although PROCESSING_TEMPLATE_DECL may be true at this point - (because, for example, we have encountered a non-dependent - function call in the body of a template function and must now - determine which of several overloaded functions will be called), - within the instantiation itself we are not processing a - template. */ - saved_processing_template_decl = processing_template_decl; - processing_template_decl = 0; - /* Substitute template parameters to obtain the specialization. */ - fndecl = tsubst (DECL_TEMPLATE_RESULT (gen_tmpl), - targ_ptr, complain, gen_tmpl); - processing_template_decl = saved_processing_template_decl; - if (fndecl == error_mark_node) - return error_mark_node; - - /* Now we know the specialization, compute access previously - deferred. */ - push_access_scope (fndecl); - perform_deferred_access_checks (); - pop_access_scope (fndecl); - pop_deferring_access_checks (); - - /* The DECL_TI_TEMPLATE should always be the immediate parent - template, not the most general template. */ - DECL_TI_TEMPLATE (fndecl) = tmpl; - - /* If we've just instantiated the main entry point for a function, - instantiate all the alternate entry points as well. We do this - by cloning the instantiation of the main entry point, not by - instantiating the template clones. */ - if (TREE_CHAIN (gen_tmpl) && DECL_CLONED_FUNCTION_P (TREE_CHAIN (gen_tmpl))) - clone_function_decl (fndecl, /*update_method_vec_p=*/0); - - return fndecl; -} - -/* The FN is a TEMPLATE_DECL for a function. The ARGS are the - arguments that are being used when calling it. TARGS is a vector - into which the deduced template arguments are placed. - - Return zero for success, 2 for an incomplete match that doesn't resolve - all the types, and 1 for complete failure. An error message will be - printed only for an incomplete match. - - If FN is a conversion operator, or we are trying to produce a specific - specialization, RETURN_TYPE is the return type desired. - - The EXPLICIT_TARGS are explicit template arguments provided via a - template-id. - - The parameter STRICT is one of: - - DEDUCE_CALL: - We are deducing arguments for a function call, as in - [temp.deduct.call]. - - DEDUCE_CONV: - We are deducing arguments for a conversion function, as in - [temp.deduct.conv]. - - DEDUCE_EXACT: - We are deducing arguments when doing an explicit instantiation - as in [temp.explicit], when determining an explicit specialization - as in [temp.expl.spec], or when taking the address of a function - template, as in [temp.deduct.funcaddr]. */ - -int -fn_type_unification (tree fn, - tree explicit_targs, - tree targs, - tree args, - tree return_type, - unification_kind_t strict, - int flags) -{ - tree parms; - tree fntype; - int result; - - gcc_assert (TREE_CODE (fn) == TEMPLATE_DECL); - - fntype = TREE_TYPE (fn); - if (explicit_targs) - { - /* [temp.deduct] - - The specified template arguments must match the template - parameters in kind (i.e., type, nontype, template), and there - must not be more arguments than there are parameters; - otherwise type deduction fails. - - Nontype arguments must match the types of the corresponding - nontype template parameters, or must be convertible to the - types of the corresponding nontype parameters as specified in - _temp.arg.nontype_, otherwise type deduction fails. - - All references in the function type of the function template - to the corresponding template parameters are replaced by the - specified template argument values. If a substitution in a - template parameter or in the function type of the function - template results in an invalid type, type deduction fails. */ - int i; - tree converted_args; - bool incomplete; - - if (explicit_targs == error_mark_node) - return 1; - - converted_args - = (coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn), - explicit_targs, NULL_TREE, tf_none, - /*require_all_args=*/false, - /*use_default_args=*/false)); - if (converted_args == error_mark_node) - return 1; - - /* Substitute the explicit args into the function type. This is - necessary so that, for instance, explicitly declared function - arguments can match null pointed constants. If we were given - an incomplete set of explicit args, we must not do semantic - processing during substitution as we could create partial - instantiations. */ - incomplete = NUM_TMPL_ARGS (explicit_targs) != NUM_TMPL_ARGS (targs); - processing_template_decl += incomplete; - fntype = tsubst (fntype, converted_args, tf_none, NULL_TREE); - processing_template_decl -= incomplete; - - if (fntype == error_mark_node) - return 1; - - /* Place the explicitly specified arguments in TARGS. */ - for (i = NUM_TMPL_ARGS (converted_args); i--;) - TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (converted_args, i); - } - - /* Never do unification on the 'this' parameter. */ - parms = skip_artificial_parms_for (fn, TYPE_ARG_TYPES (fntype)); - - if (return_type) - { - parms = tree_cons (NULL_TREE, TREE_TYPE (fntype), parms); - args = tree_cons (NULL_TREE, return_type, args); - } - - /* We allow incomplete unification without an error message here - because the standard doesn't seem to explicitly prohibit it. Our - callers must be ready to deal with unification failures in any - event. */ - result = type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn), - targs, parms, args, /*subr=*/0, - strict, flags); - - if (result == 0) - /* All is well so far. Now, check: - - [temp.deduct] - - When all template arguments have been deduced, all uses of - template parameters in nondeduced contexts are replaced with - the corresponding deduced argument values. If the - substitution results in an invalid type, as described above, - type deduction fails. */ - if (tsubst (TREE_TYPE (fn), targs, tf_none, NULL_TREE) - == error_mark_node) - return 1; - - return result; -} - -/* Adjust types before performing type deduction, as described in - [temp.deduct.call] and [temp.deduct.conv]. The rules in these two - sections are symmetric. PARM is the type of a function parameter - or the return type of the conversion function. ARG is the type of - the argument passed to the call, or the type of the value - initialized with the result of the conversion function. */ - -static int -maybe_adjust_types_for_deduction (unification_kind_t strict, - tree* parm, - tree* arg) -{ - int result = 0; - - switch (strict) - { - case DEDUCE_CALL: - break; - - case DEDUCE_CONV: - { - /* Swap PARM and ARG throughout the remainder of this - function; the handling is precisely symmetric since PARM - will initialize ARG rather than vice versa. */ - tree* temp = parm; - parm = arg; - arg = temp; - break; - } - - case DEDUCE_EXACT: - /* There is nothing to do in this case. */ - return 0; - - default: - gcc_unreachable (); - } - - if (TREE_CODE (*parm) != REFERENCE_TYPE) - { - /* [temp.deduct.call] - - If P is not a reference type: - - --If A is an array type, the pointer type produced by the - array-to-pointer standard conversion (_conv.array_) is - used in place of A for type deduction; otherwise, - - --If A is a function type, the pointer type produced by - the function-to-pointer standard conversion - (_conv.func_) is used in place of A for type deduction; - otherwise, - - --If A is a cv-qualified type, the top level - cv-qualifiers of A's type are ignored for type - deduction. */ - if (TREE_CODE (*arg) == ARRAY_TYPE) - *arg = build_pointer_type (TREE_TYPE (*arg)); - else if (TREE_CODE (*arg) == FUNCTION_TYPE) - *arg = build_pointer_type (*arg); - else - *arg = TYPE_MAIN_VARIANT (*arg); - } - - /* [temp.deduct.call] - - If P is a cv-qualified type, the top level cv-qualifiers - of P's type are ignored for type deduction. If P is a - reference type, the type referred to by P is used for - type deduction. */ - *parm = TYPE_MAIN_VARIANT (*parm); - if (TREE_CODE (*parm) == REFERENCE_TYPE) - { - *parm = TREE_TYPE (*parm); - result |= UNIFY_ALLOW_OUTER_MORE_CV_QUAL; - } - - /* DR 322. For conversion deduction, remove a reference type on parm - too (which has been swapped into ARG). */ - if (strict == DEDUCE_CONV && TREE_CODE (*arg) == REFERENCE_TYPE) - *arg = TREE_TYPE (*arg); - - return result; -} - -/* Most parms like fn_type_unification. - - If SUBR is 1, we're being called recursively (to unify the - arguments of a function or method parameter of a function - template). */ - -static int -type_unification_real (tree tparms, - tree targs, - tree xparms, - tree xargs, - int subr, - unification_kind_t strict, - int flags) -{ - tree parm, arg; - int i; - int ntparms = TREE_VEC_LENGTH (tparms); - int sub_strict; - int saw_undeduced = 0; - tree parms, args; - - gcc_assert (TREE_CODE (tparms) == TREE_VEC); - gcc_assert (xparms == NULL_TREE || TREE_CODE (xparms) == TREE_LIST); - gcc_assert (!xargs || TREE_CODE (xargs) == TREE_LIST); - gcc_assert (ntparms > 0); - - switch (strict) - { - case DEDUCE_CALL: - sub_strict = (UNIFY_ALLOW_OUTER_LEVEL | UNIFY_ALLOW_MORE_CV_QUAL - | UNIFY_ALLOW_DERIVED); - break; - - case DEDUCE_CONV: - sub_strict = UNIFY_ALLOW_LESS_CV_QUAL; - break; - - case DEDUCE_EXACT: - sub_strict = UNIFY_ALLOW_NONE; - break; - - default: - gcc_unreachable (); - } - - again: - parms = xparms; - args = xargs; - - while (parms && parms != void_list_node - && args && args != void_list_node) - { - parm = TREE_VALUE (parms); - parms = TREE_CHAIN (parms); - arg = TREE_VALUE (args); - args = TREE_CHAIN (args); - - if (arg == error_mark_node) - return 1; - if (arg == unknown_type_node) - /* We can't deduce anything from this, but we might get all the - template args from other function args. */ - continue; - - /* Conversions will be performed on a function argument that - corresponds with a function parameter that contains only - non-deducible template parameters and explicitly specified - template parameters. */ - if (!uses_template_parms (parm)) - { - tree type; - - if (!TYPE_P (arg)) - type = TREE_TYPE (arg); - else - type = arg; - - if (same_type_p (parm, type)) - continue; - if (strict != DEDUCE_EXACT - && can_convert_arg (parm, type, TYPE_P (arg) ? NULL_TREE : arg, - flags)) - continue; - - return 1; - } - - if (!TYPE_P (arg)) - { - gcc_assert (TREE_TYPE (arg) != NULL_TREE); - if (type_unknown_p (arg)) - { - /* [temp.deduct.type] - - A template-argument can be deduced from a pointer to - function or pointer to member function argument if - the set of overloaded functions does not contain - function templates and at most one of a set of - overloaded functions provides a unique match. */ - if (resolve_overloaded_unification - (tparms, targs, parm, arg, strict, sub_strict)) - continue; - - return 1; - } - arg = unlowered_expr_type (arg); - if (arg == error_mark_node) - return 1; - } - - { - int arg_strict = sub_strict; - - if (!subr) - arg_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg); - - if (unify (tparms, targs, parm, arg, arg_strict)) - return 1; - } - } - - /* Fail if we've reached the end of the parm list, and more args - are present, and the parm list isn't variadic. */ - if (args && args != void_list_node && parms == void_list_node) - return 1; - /* Fail if parms are left and they don't have default values. */ - if (parms && parms != void_list_node - && TREE_PURPOSE (parms) == NULL_TREE) - return 1; - - if (!subr) - for (i = 0; i < ntparms; i++) - if (!TREE_VEC_ELT (targs, i)) - { - tree tparm; - - if (TREE_VEC_ELT (tparms, i) == error_mark_node) - continue; - - tparm = TREE_VALUE (TREE_VEC_ELT (tparms, i)); - - /* If this is an undeduced nontype parameter that depends on - a type parameter, try another pass; its type may have been - deduced from a later argument than the one from which - this parameter can be deduced. */ - if (TREE_CODE (tparm) == PARM_DECL - && uses_template_parms (TREE_TYPE (tparm)) - && !saw_undeduced++) - goto again; - - return 2; - } - - return 0; -} - -/* Subroutine of type_unification_real. Args are like the variables - at the call site. ARG is an overloaded function (or template-id); - we try deducing template args from each of the overloads, and if - only one succeeds, we go with that. Modifies TARGS and returns - true on success. */ - -static bool -resolve_overloaded_unification (tree tparms, - tree targs, - tree parm, - tree arg, - unification_kind_t strict, - int sub_strict) -{ - tree tempargs = copy_node (targs); - int good = 0; - bool addr_p; - - if (TREE_CODE (arg) == ADDR_EXPR) - { - arg = TREE_OPERAND (arg, 0); - addr_p = true; - } - else - addr_p = false; - - if (TREE_CODE (arg) == COMPONENT_REF) - /* Handle `&x' where `x' is some static or non-static member - function name. */ - arg = TREE_OPERAND (arg, 1); - - if (TREE_CODE (arg) == OFFSET_REF) - arg = TREE_OPERAND (arg, 1); - - /* Strip baselink information. */ - if (BASELINK_P (arg)) - arg = BASELINK_FUNCTIONS (arg); - - if (TREE_CODE (arg) == TEMPLATE_ID_EXPR) - { - /* If we got some explicit template args, we need to plug them into - the affected templates before we try to unify, in case the - explicit args will completely resolve the templates in question. */ - - tree expl_subargs = TREE_OPERAND (arg, 1); - arg = TREE_OPERAND (arg, 0); - - for (; arg; arg = OVL_NEXT (arg)) - { - tree fn = OVL_CURRENT (arg); - tree subargs, elem; - - if (TREE_CODE (fn) != TEMPLATE_DECL) - continue; - - subargs = get_bindings (fn, DECL_TEMPLATE_RESULT (fn), - expl_subargs, /*check_ret=*/false); - if (subargs) - { - elem = tsubst (TREE_TYPE (fn), subargs, tf_none, NULL_TREE); - good += try_one_overload (tparms, targs, tempargs, parm, - elem, strict, sub_strict, addr_p); - } - } - } - else if (TREE_CODE (arg) != OVERLOAD - && TREE_CODE (arg) != FUNCTION_DECL) - /* If ARG is, for example, "(0, &f)" then its type will be unknown - -- but the deduction does not succeed because the expression is - not just the function on its own. */ - return false; - else - for (; arg; arg = OVL_NEXT (arg)) - good += try_one_overload (tparms, targs, tempargs, parm, - TREE_TYPE (OVL_CURRENT (arg)), - strict, sub_strict, addr_p); - - /* [temp.deduct.type] A template-argument can be deduced from a pointer - to function or pointer to member function argument if the set of - overloaded functions does not contain function templates and at most - one of a set of overloaded functions provides a unique match. - - So if we found multiple possibilities, we return success but don't - deduce anything. */ - - if (good == 1) - { - int i = TREE_VEC_LENGTH (targs); - for (; i--; ) - if (TREE_VEC_ELT (tempargs, i)) - TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (tempargs, i); - } - if (good) - return true; - - return false; -} - -/* Subroutine of resolve_overloaded_unification; does deduction for a single - overload. Fills TARGS with any deduced arguments, or error_mark_node if - different overloads deduce different arguments for a given parm. - ADDR_P is true if the expression for which deduction is being - performed was of the form "& fn" rather than simply "fn". - - Returns 1 on success. */ - -static int -try_one_overload (tree tparms, - tree orig_targs, - tree targs, - tree parm, - tree arg, - unification_kind_t strict, - int sub_strict, - bool addr_p) -{ - int nargs; - tree tempargs; - int i; - - /* [temp.deduct.type] A template-argument can be deduced from a pointer - to function or pointer to member function argument if the set of - overloaded functions does not contain function templates and at most - one of a set of overloaded functions provides a unique match. - - So if this is a template, just return success. */ - - if (uses_template_parms (arg)) - return 1; - - if (TREE_CODE (arg) == METHOD_TYPE) - arg = build_ptrmemfunc_type (build_pointer_type (arg)); - else if (addr_p) - arg = build_pointer_type (arg); - - sub_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg); - - /* We don't copy orig_targs for this because if we have already deduced - some template args from previous args, unify would complain when we - try to deduce a template parameter for the same argument, even though - there isn't really a conflict. */ - nargs = TREE_VEC_LENGTH (targs); - tempargs = make_tree_vec (nargs); - - if (unify (tparms, tempargs, parm, arg, sub_strict) != 0) - return 0; - - /* First make sure we didn't deduce anything that conflicts with - explicitly specified args. */ - for (i = nargs; i--; ) - { - tree elt = TREE_VEC_ELT (tempargs, i); - tree oldelt = TREE_VEC_ELT (orig_targs, i); - - if (!elt) - /*NOP*/; - else if (uses_template_parms (elt)) - /* Since we're unifying against ourselves, we will fill in - template args used in the function parm list with our own - template parms. Discard them. */ - TREE_VEC_ELT (tempargs, i) = NULL_TREE; - else if (oldelt && !template_args_equal (oldelt, elt)) - return 0; - } - - for (i = nargs; i--; ) - { - tree elt = TREE_VEC_ELT (tempargs, i); - - if (elt) - TREE_VEC_ELT (targs, i) = elt; - } - - return 1; -} - -/* PARM is a template class (perhaps with unbound template - parameters). ARG is a fully instantiated type. If ARG can be - bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and - TARGS are as for unify. */ - -static tree -try_class_unification (tree tparms, tree targs, tree parm, tree arg) -{ - tree copy_of_targs; - - if (!CLASSTYPE_TEMPLATE_INFO (arg) - || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg)) - != most_general_template (CLASSTYPE_TI_TEMPLATE (parm)))) - return NULL_TREE; - - /* We need to make a new template argument vector for the call to - unify. If we used TARGS, we'd clutter it up with the result of - the attempted unification, even if this class didn't work out. - We also don't want to commit ourselves to all the unifications - we've already done, since unification is supposed to be done on - an argument-by-argument basis. In other words, consider the - following pathological case: - - template <int I, int J, int K> - struct S {}; - - template <int I, int J> - struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {}; - - template <int I, int J, int K> - void f(S<I, J, K>, S<I, I, I>); - - void g() { - S<0, 0, 0> s0; - S<0, 1, 2> s2; - - f(s0, s2); - } - - Now, by the time we consider the unification involving `s2', we - already know that we must have `f<0, 0, 0>'. But, even though - `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid - because there are two ways to unify base classes of S<0, 1, 2> - with S<I, I, I>. If we kept the already deduced knowledge, we - would reject the possibility I=1. */ - copy_of_targs = make_tree_vec (TREE_VEC_LENGTH (targs)); - - /* If unification failed, we're done. */ - if (unify (tparms, copy_of_targs, CLASSTYPE_TI_ARGS (parm), - CLASSTYPE_TI_ARGS (arg), UNIFY_ALLOW_NONE)) - return NULL_TREE; - - return arg; -} - -/* Given a template type PARM and a class type ARG, find the unique - base type in ARG that is an instance of PARM. We do not examine - ARG itself; only its base-classes. If there is not exactly one - appropriate base class, return NULL_TREE. PARM may be the type of - a partial specialization, as well as a plain template type. Used - by unify. */ - -static tree -get_template_base (tree tparms, tree targs, tree parm, tree arg) -{ - tree rval = NULL_TREE; - tree binfo; - - gcc_assert (IS_AGGR_TYPE_CODE (TREE_CODE (arg))); - - binfo = TYPE_BINFO (complete_type (arg)); - if (!binfo) - /* The type could not be completed. */ - return NULL_TREE; - - /* Walk in inheritance graph order. The search order is not - important, and this avoids multiple walks of virtual bases. */ - for (binfo = TREE_CHAIN (binfo); binfo; binfo = TREE_CHAIN (binfo)) - { - tree r = try_class_unification (tparms, targs, parm, BINFO_TYPE (binfo)); - - if (r) - { - /* If there is more than one satisfactory baseclass, then: - - [temp.deduct.call] - - If they yield more than one possible deduced A, the type - deduction fails. - - applies. */ - if (rval && !same_type_p (r, rval)) - return NULL_TREE; - - rval = r; - } - } - - return rval; -} - -/* Returns the level of DECL, which declares a template parameter. */ - -static int -template_decl_level (tree decl) -{ - switch (TREE_CODE (decl)) - { - case TYPE_DECL: - case TEMPLATE_DECL: - return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl)); - - case PARM_DECL: - return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl)); - - default: - gcc_unreachable (); - } - return 0; -} - -/* Decide whether ARG can be unified with PARM, considering only the - cv-qualifiers of each type, given STRICT as documented for unify. - Returns nonzero iff the unification is OK on that basis. */ - -static int -check_cv_quals_for_unify (int strict, tree arg, tree parm) -{ - int arg_quals = cp_type_quals (arg); - int parm_quals = cp_type_quals (parm); - - if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM - && !(strict & UNIFY_ALLOW_OUTER_MORE_CV_QUAL)) - { - /* Although a CVR qualifier is ignored when being applied to a - substituted template parameter ([8.3.2]/1 for example), that - does not apply during deduction [14.8.2.4]/1, (even though - that is not explicitly mentioned, [14.8.2.4]/9 indicates - this). Except when we're allowing additional CV qualifiers - at the outer level [14.8.2.1]/3,1st bullet. */ - if ((TREE_CODE (arg) == REFERENCE_TYPE - || TREE_CODE (arg) == FUNCTION_TYPE - || TREE_CODE (arg) == METHOD_TYPE) - && (parm_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE))) - return 0; - - if ((!POINTER_TYPE_P (arg) && TREE_CODE (arg) != TEMPLATE_TYPE_PARM) - && (parm_quals & TYPE_QUAL_RESTRICT)) - return 0; - } - - if (!(strict & (UNIFY_ALLOW_MORE_CV_QUAL | UNIFY_ALLOW_OUTER_MORE_CV_QUAL)) - && (arg_quals & parm_quals) != parm_quals) - return 0; - - if (!(strict & (UNIFY_ALLOW_LESS_CV_QUAL | UNIFY_ALLOW_OUTER_LESS_CV_QUAL)) - && (parm_quals & arg_quals) != arg_quals) - return 0; - - return 1; -} - -/* Deduce the value of template parameters. TPARMS is the (innermost) - set of template parameters to a template. TARGS is the bindings - for those template parameters, as determined thus far; TARGS may - include template arguments for outer levels of template parameters - as well. PARM is a parameter to a template function, or a - subcomponent of that parameter; ARG is the corresponding argument. - This function attempts to match PARM with ARG in a manner - consistent with the existing assignments in TARGS. If more values - are deduced, then TARGS is updated. - - Returns 0 if the type deduction succeeds, 1 otherwise. The - parameter STRICT is a bitwise or of the following flags: - - UNIFY_ALLOW_NONE: - Require an exact match between PARM and ARG. - UNIFY_ALLOW_MORE_CV_QUAL: - Allow the deduced ARG to be more cv-qualified (by qualification - conversion) than ARG. - UNIFY_ALLOW_LESS_CV_QUAL: - Allow the deduced ARG to be less cv-qualified than ARG. - UNIFY_ALLOW_DERIVED: - Allow the deduced ARG to be a template base class of ARG, - or a pointer to a template base class of the type pointed to by - ARG. - UNIFY_ALLOW_INTEGER: - Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX - case for more information. - UNIFY_ALLOW_OUTER_LEVEL: - This is the outermost level of a deduction. Used to determine validity - of qualification conversions. A valid qualification conversion must - have const qualified pointers leading up to the inner type which - requires additional CV quals, except at the outer level, where const - is not required [conv.qual]. It would be normal to set this flag in - addition to setting UNIFY_ALLOW_MORE_CV_QUAL. - UNIFY_ALLOW_OUTER_MORE_CV_QUAL: - This is the outermost level of a deduction, and PARM can be more CV - qualified at this point. - UNIFY_ALLOW_OUTER_LESS_CV_QUAL: - This is the outermost level of a deduction, and PARM can be less CV - qualified at this point. */ - -static int -unify (tree tparms, tree targs, tree parm, tree arg, int strict) -{ - int idx; - tree targ; - tree tparm; - int strict_in = strict; - - /* I don't think this will do the right thing with respect to types. - But the only case I've seen it in so far has been array bounds, where - signedness is the only information lost, and I think that will be - okay. */ - while (TREE_CODE (parm) == NOP_EXPR) - parm = TREE_OPERAND (parm, 0); - - if (arg == error_mark_node) - return 1; - if (arg == unknown_type_node) - /* We can't deduce anything from this, but we might get all the - template args from other function args. */ - return 0; - - /* If PARM uses template parameters, then we can't bail out here, - even if ARG == PARM, since we won't record unifications for the - template parameters. We might need them if we're trying to - figure out which of two things is more specialized. */ - if (arg == parm && !uses_template_parms (parm)) - return 0; - - /* Immediately reject some pairs that won't unify because of - cv-qualification mismatches. */ - if (TREE_CODE (arg) == TREE_CODE (parm) - && TYPE_P (arg) - /* It is the elements of the array which hold the cv quals of an array - type, and the elements might be template type parms. We'll check - when we recurse. */ - && TREE_CODE (arg) != ARRAY_TYPE - /* We check the cv-qualifiers when unifying with template type - parameters below. We want to allow ARG `const T' to unify with - PARM `T' for example, when computing which of two templates - is more specialized, for example. */ - && TREE_CODE (arg) != TEMPLATE_TYPE_PARM - && !check_cv_quals_for_unify (strict_in, arg, parm)) - return 1; - - if (!(strict & UNIFY_ALLOW_OUTER_LEVEL) - && TYPE_P (parm) && !CP_TYPE_CONST_P (parm)) - strict &= ~UNIFY_ALLOW_MORE_CV_QUAL; - strict &= ~UNIFY_ALLOW_OUTER_LEVEL; - strict &= ~UNIFY_ALLOW_DERIVED; - strict &= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL; - strict &= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL; - - switch (TREE_CODE (parm)) - { - case TYPENAME_TYPE: - case SCOPE_REF: - case UNBOUND_CLASS_TEMPLATE: - /* In a type which contains a nested-name-specifier, template - argument values cannot be deduced for template parameters used - within the nested-name-specifier. */ - return 0; - - case TEMPLATE_TYPE_PARM: - case TEMPLATE_TEMPLATE_PARM: - case BOUND_TEMPLATE_TEMPLATE_PARM: - tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0)); - - if (TEMPLATE_TYPE_LEVEL (parm) - != template_decl_level (tparm)) - /* The PARM is not one we're trying to unify. Just check - to see if it matches ARG. */ - return (TREE_CODE (arg) == TREE_CODE (parm) - && same_type_p (parm, arg)) ? 0 : 1; - idx = TEMPLATE_TYPE_IDX (parm); - targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx); - tparm = TREE_VALUE (TREE_VEC_ELT (tparms, idx)); - - /* Check for mixed types and values. */ - if ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM - && TREE_CODE (tparm) != TYPE_DECL) - || (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM - && TREE_CODE (tparm) != TEMPLATE_DECL)) - return 1; - - if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM) - { - /* ARG must be constructed from a template class or a template - template parameter. */ - if (TREE_CODE (arg) != BOUND_TEMPLATE_TEMPLATE_PARM - && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg)) - return 1; - - { - tree parmvec = TYPE_TI_ARGS (parm); - tree argvec = INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg)); - tree argtmplvec - = DECL_INNERMOST_TEMPLATE_PARMS (TYPE_TI_TEMPLATE (arg)); - int i; - - /* The resolution to DR150 makes clear that default - arguments for an N-argument may not be used to bind T - to a template template parameter with fewer than N - parameters. It is not safe to permit the binding of - default arguments as an extension, as that may change - the meaning of a conforming program. Consider: - - struct Dense { static const unsigned int dim = 1; }; - - template <template <typename> class View, - typename Block> - void operator+(float, View<Block> const&); - - template <typename Block, - unsigned int Dim = Block::dim> - struct Lvalue_proxy { operator float() const; }; - - void - test_1d (void) { - Lvalue_proxy<Dense> p; - float b; - b + p; - } - - Here, if Lvalue_proxy is permitted to bind to View, then - the global operator+ will be used; if they are not, the - Lvalue_proxy will be converted to float. */ - if (coerce_template_parms (argtmplvec, parmvec, - TYPE_TI_TEMPLATE (parm), - tf_none, - /*require_all_args=*/true, - /*use_default_args=*/false) - == error_mark_node) - return 1; - - /* Deduce arguments T, i from TT<T> or TT<i>. - We check each element of PARMVEC and ARGVEC individually - rather than the whole TREE_VEC since they can have - different number of elements. */ - - for (i = 0; i < TREE_VEC_LENGTH (parmvec); ++i) - { - if (unify (tparms, targs, - TREE_VEC_ELT (parmvec, i), - TREE_VEC_ELT (argvec, i), - UNIFY_ALLOW_NONE)) - return 1; - } - } - arg = TYPE_TI_TEMPLATE (arg); - - /* Fall through to deduce template name. */ - } - - if (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM - || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM) - { - /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */ - - /* Simple cases: Value already set, does match or doesn't. */ - if (targ != NULL_TREE && template_args_equal (targ, arg)) - return 0; - else if (targ) - return 1; - } - else - { - /* If PARM is `const T' and ARG is only `int', we don't have - a match unless we are allowing additional qualification. - If ARG is `const int' and PARM is just `T' that's OK; - that binds `const int' to `T'. */ - if (!check_cv_quals_for_unify (strict_in | UNIFY_ALLOW_LESS_CV_QUAL, - arg, parm)) - return 1; - - /* Consider the case where ARG is `const volatile int' and - PARM is `const T'. Then, T should be `volatile int'. */ - arg = cp_build_qualified_type_real - (arg, cp_type_quals (arg) & ~cp_type_quals (parm), tf_none); - if (arg == error_mark_node) - return 1; - - /* Simple cases: Value already set, does match or doesn't. */ - if (targ != NULL_TREE && same_type_p (targ, arg)) - return 0; - else if (targ) - return 1; - - /* Make sure that ARG is not a variable-sized array. (Note - that were talking about variable-sized arrays (like - `int[n]'), rather than arrays of unknown size (like - `int[]').) We'll get very confused by such a type since - the bound of the array will not be computable in an - instantiation. Besides, such types are not allowed in - ISO C++, so we can do as we please here. */ - if (variably_modified_type_p (arg, NULL_TREE)) - return 1; - } - - TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg; - return 0; - - case TEMPLATE_PARM_INDEX: - tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0)); - if (tparm == error_mark_node) - return 1; - - if (TEMPLATE_PARM_LEVEL (parm) - != template_decl_level (tparm)) - /* The PARM is not one we're trying to unify. Just check - to see if it matches ARG. */ - return !(TREE_CODE (arg) == TREE_CODE (parm) - && cp_tree_equal (parm, arg)); - - idx = TEMPLATE_PARM_IDX (parm); - targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx); - - if (targ) - return !cp_tree_equal (targ, arg); - - /* [temp.deduct.type] If, in the declaration of a function template - with a non-type template-parameter, the non-type - template-parameter is used in an expression in the function - parameter-list and, if the corresponding template-argument is - deduced, the template-argument type shall match the type of the - template-parameter exactly, except that a template-argument - deduced from an array bound may be of any integral type. - The non-type parameter might use already deduced type parameters. */ - tparm = tsubst (TREE_TYPE (parm), targs, 0, NULL_TREE); - if (!TREE_TYPE (arg)) - /* Template-parameter dependent expression. Just accept it for now. - It will later be processed in convert_template_argument. */ - ; - else if (same_type_p (TREE_TYPE (arg), tparm)) - /* OK */; - else if ((strict & UNIFY_ALLOW_INTEGER) - && (TREE_CODE (tparm) == INTEGER_TYPE - || TREE_CODE (tparm) == BOOLEAN_TYPE)) - /* Convert the ARG to the type of PARM; the deduced non-type - template argument must exactly match the types of the - corresponding parameter. */ - arg = fold (build_nop (TREE_TYPE (parm), arg)); - else if (uses_template_parms (tparm)) - /* We haven't deduced the type of this parameter yet. Try again - later. */ - return 0; - else - return 1; - - TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg; - return 0; - - case PTRMEM_CST: - { - /* A pointer-to-member constant can be unified only with - another constant. */ - if (TREE_CODE (arg) != PTRMEM_CST) - return 1; - - /* Just unify the class member. It would be useless (and possibly - wrong, depending on the strict flags) to unify also - PTRMEM_CST_CLASS, because we want to be sure that both parm and - arg refer to the same variable, even if through different - classes. For instance: - - struct A { int x; }; - struct B : A { }; - - Unification of &A::x and &B::x must succeed. */ - return unify (tparms, targs, PTRMEM_CST_MEMBER (parm), - PTRMEM_CST_MEMBER (arg), strict); - } - - case POINTER_TYPE: - { - if (TREE_CODE (arg) != POINTER_TYPE) - return 1; - - /* [temp.deduct.call] - - A can be another pointer or pointer to member type that can - be converted to the deduced A via a qualification - conversion (_conv.qual_). - - We pass down STRICT here rather than UNIFY_ALLOW_NONE. - This will allow for additional cv-qualification of the - pointed-to types if appropriate. */ - - if (TREE_CODE (TREE_TYPE (arg)) == RECORD_TYPE) - /* The derived-to-base conversion only persists through one - level of pointers. */ - strict |= (strict_in & UNIFY_ALLOW_DERIVED); - - return unify (tparms, targs, TREE_TYPE (parm), - TREE_TYPE (arg), strict); - } - - case REFERENCE_TYPE: - if (TREE_CODE (arg) != REFERENCE_TYPE) - return 1; - return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg), - strict & UNIFY_ALLOW_MORE_CV_QUAL); - - case ARRAY_TYPE: - if (TREE_CODE (arg) != ARRAY_TYPE) - return 1; - if ((TYPE_DOMAIN (parm) == NULL_TREE) - != (TYPE_DOMAIN (arg) == NULL_TREE)) - return 1; - if (TYPE_DOMAIN (parm) != NULL_TREE) - { - tree parm_max; - tree arg_max; - bool parm_cst; - bool arg_cst; - - /* Our representation of array types uses "N - 1" as the - TYPE_MAX_VALUE for an array with "N" elements, if "N" is - not an integer constant. We cannot unify arbitrarily - complex expressions, so we eliminate the MINUS_EXPRs - here. */ - parm_max = TYPE_MAX_VALUE (TYPE_DOMAIN (parm)); - parm_cst = TREE_CODE (parm_max) == INTEGER_CST; - if (!parm_cst) - { - gcc_assert (TREE_CODE (parm_max) == MINUS_EXPR); - parm_max = TREE_OPERAND (parm_max, 0); - } - arg_max = TYPE_MAX_VALUE (TYPE_DOMAIN (arg)); - arg_cst = TREE_CODE (arg_max) == INTEGER_CST; - if (!arg_cst) - { - /* The ARG_MAX may not be a simple MINUS_EXPR, if we are - trying to unify the type of a variable with the type - of a template parameter. For example: - - template <unsigned int N> - void f (char (&) [N]); - int g(); - void h(int i) { - char a[g(i)]; - f(a); - } - - Here, the type of the ARG will be "int [g(i)]", and - may be a SAVE_EXPR, etc. */ - if (TREE_CODE (arg_max) != MINUS_EXPR) - return 1; - arg_max = TREE_OPERAND (arg_max, 0); - } - - /* If only one of the bounds used a MINUS_EXPR, compensate - by adding one to the other bound. */ - if (parm_cst && !arg_cst) - parm_max = fold_build2 (PLUS_EXPR, - integer_type_node, - parm_max, - integer_one_node); - else if (arg_cst && !parm_cst) - arg_max = fold_build2 (PLUS_EXPR, - integer_type_node, - arg_max, - integer_one_node); - - if (unify (tparms, targs, parm_max, arg_max, UNIFY_ALLOW_INTEGER)) - return 1; - } - return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg), - strict & UNIFY_ALLOW_MORE_CV_QUAL); - - case REAL_TYPE: - case COMPLEX_TYPE: - case VECTOR_TYPE: - case INTEGER_TYPE: - case BOOLEAN_TYPE: - case ENUMERAL_TYPE: - case VOID_TYPE: - if (TREE_CODE (arg) != TREE_CODE (parm)) - return 1; - - /* We have already checked cv-qualification at the top of the - function. */ - if (!same_type_ignoring_top_level_qualifiers_p (arg, parm)) - return 1; - - /* As far as unification is concerned, this wins. Later checks - will invalidate it if necessary. */ - return 0; - - /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */ - /* Type INTEGER_CST can come from ordinary constant template args. */ - case INTEGER_CST: - while (TREE_CODE (arg) == NOP_EXPR) - arg = TREE_OPERAND (arg, 0); - - if (TREE_CODE (arg) != INTEGER_CST) - return 1; - return !tree_int_cst_equal (parm, arg); - - case TREE_VEC: - { - int i; - if (TREE_CODE (arg) != TREE_VEC) - return 1; - if (TREE_VEC_LENGTH (parm) != TREE_VEC_LENGTH (arg)) - return 1; - for (i = 0; i < TREE_VEC_LENGTH (parm); ++i) - if (unify (tparms, targs, - TREE_VEC_ELT (parm, i), TREE_VEC_ELT (arg, i), - UNIFY_ALLOW_NONE)) - return 1; - return 0; - } - - case RECORD_TYPE: - case UNION_TYPE: - if (TREE_CODE (arg) != TREE_CODE (parm)) - return 1; - - if (TYPE_PTRMEMFUNC_P (parm)) - { - if (!TYPE_PTRMEMFUNC_P (arg)) - return 1; - - return unify (tparms, targs, - TYPE_PTRMEMFUNC_FN_TYPE (parm), - TYPE_PTRMEMFUNC_FN_TYPE (arg), - strict); - } - - if (CLASSTYPE_TEMPLATE_INFO (parm)) - { - tree t = NULL_TREE; - - if (strict_in & UNIFY_ALLOW_DERIVED) - { - /* First, we try to unify the PARM and ARG directly. */ - t = try_class_unification (tparms, targs, - parm, arg); - - if (!t) - { - /* Fallback to the special case allowed in - [temp.deduct.call]: - - If P is a class, and P has the form - template-id, then A can be a derived class of - the deduced A. Likewise, if P is a pointer to - a class of the form template-id, A can be a - pointer to a derived class pointed to by the - deduced A. */ - t = get_template_base (tparms, targs, parm, arg); - - if (!t) - return 1; - } - } - else if (CLASSTYPE_TEMPLATE_INFO (arg) - && (CLASSTYPE_TI_TEMPLATE (parm) - == CLASSTYPE_TI_TEMPLATE (arg))) - /* Perhaps PARM is something like S<U> and ARG is S<int>. - Then, we should unify `int' and `U'. */ - t = arg; - else - /* There's no chance of unification succeeding. */ - return 1; - - return unify (tparms, targs, CLASSTYPE_TI_ARGS (parm), - CLASSTYPE_TI_ARGS (t), UNIFY_ALLOW_NONE); - } - else if (!same_type_ignoring_top_level_qualifiers_p (parm, arg)) - return 1; - return 0; - - case METHOD_TYPE: - case FUNCTION_TYPE: - if (TREE_CODE (arg) != TREE_CODE (parm)) - return 1; - - /* CV qualifications for methods can never be deduced, they must - match exactly. We need to check them explicitly here, - because type_unification_real treats them as any other - cvqualified parameter. */ - if (TREE_CODE (parm) == METHOD_TYPE - && (!check_cv_quals_for_unify - (UNIFY_ALLOW_NONE, - TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (arg))), - TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (parm)))))) - return 1; - - if (unify (tparms, targs, TREE_TYPE (parm), - TREE_TYPE (arg), UNIFY_ALLOW_NONE)) - return 1; - return type_unification_real (tparms, targs, TYPE_ARG_TYPES (parm), - TYPE_ARG_TYPES (arg), 1, DEDUCE_EXACT, - LOOKUP_NORMAL); - - case OFFSET_TYPE: - /* Unify a pointer to member with a pointer to member function, which - deduces the type of the member as a function type. */ - if (TYPE_PTRMEMFUNC_P (arg)) - { - tree method_type; - tree fntype; - cp_cv_quals cv_quals; - - /* Check top-level cv qualifiers */ - if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE, arg, parm)) - return 1; - - if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm), - TYPE_PTRMEMFUNC_OBJECT_TYPE (arg), UNIFY_ALLOW_NONE)) - return 1; - - /* Determine the type of the function we are unifying against. */ - method_type = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (arg)); - fntype = - build_function_type (TREE_TYPE (method_type), - TREE_CHAIN (TYPE_ARG_TYPES (method_type))); - - /* Extract the cv-qualifiers of the member function from the - implicit object parameter and place them on the function - type to be restored later. */ - cv_quals = - cp_type_quals(TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (method_type)))); - fntype = build_qualified_type (fntype, cv_quals); - return unify (tparms, targs, TREE_TYPE (parm), fntype, strict); - } - - if (TREE_CODE (arg) != OFFSET_TYPE) - return 1; - if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm), - TYPE_OFFSET_BASETYPE (arg), UNIFY_ALLOW_NONE)) - return 1; - return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg), - strict); - - case CONST_DECL: - if (DECL_TEMPLATE_PARM_P (parm)) - return unify (tparms, targs, DECL_INITIAL (parm), arg, strict); - if (arg != integral_constant_value (parm)) - return 1; - return 0; - - case FIELD_DECL: - case TEMPLATE_DECL: - /* Matched cases are handled by the ARG == PARM test above. */ - return 1; - - default: - gcc_assert (EXPR_P (parm)); - - /* We must be looking at an expression. This can happen with - something like: - - template <int I> - void foo(S<I>, S<I + 2>); - - This is a "nondeduced context": - - [deduct.type] - - The nondeduced contexts are: - - --A type that is a template-id in which one or more of - the template-arguments is an expression that references - a template-parameter. - - In these cases, we assume deduction succeeded, but don't - actually infer any unifications. */ - - if (!uses_template_parms (parm) - && !template_args_equal (parm, arg)) - return 1; - else - return 0; - } -} - -/* Note that DECL can be defined in this translation unit, if - required. */ - -static void -mark_definable (tree decl) -{ - tree clone; - DECL_NOT_REALLY_EXTERN (decl) = 1; - FOR_EACH_CLONE (clone, decl) - DECL_NOT_REALLY_EXTERN (clone) = 1; -} - -/* Called if RESULT is explicitly instantiated, or is a member of an - explicitly instantiated class. */ - -void -mark_decl_instantiated (tree result, int extern_p) -{ - SET_DECL_EXPLICIT_INSTANTIATION (result); - - /* If this entity has already been written out, it's too late to - make any modifications. */ - if (TREE_ASM_WRITTEN (result)) - return; - - if (TREE_CODE (result) != FUNCTION_DECL) - /* The TREE_PUBLIC flag for function declarations will have been - set correctly by tsubst. */ - TREE_PUBLIC (result) = 1; - - /* This might have been set by an earlier implicit instantiation. */ - DECL_COMDAT (result) = 0; - - if (extern_p) - DECL_NOT_REALLY_EXTERN (result) = 0; - else - { - mark_definable (result); - /* Always make artificials weak. */ - if (DECL_ARTIFICIAL (result) && flag_weak) - comdat_linkage (result); - /* For WIN32 we also want to put explicit instantiations in - linkonce sections. */ - else if (TREE_PUBLIC (result)) - maybe_make_one_only (result); - } - - /* If EXTERN_P, then this function will not be emitted -- unless - followed by an explicit instantiation, at which point its linkage - will be adjusted. If !EXTERN_P, then this function will be - emitted here. In neither circumstance do we want - import_export_decl to adjust the linkage. */ - DECL_INTERFACE_KNOWN (result) = 1; -} - -/* Given two function templates PAT1 and PAT2, return: - - 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order]. - -1 if PAT2 is more specialized than PAT1. - 0 if neither is more specialized. - - LEN indicates the number of parameters we should consider - (defaulted parameters should not be considered). - - The 1998 std underspecified function template partial ordering, and - DR214 addresses the issue. We take pairs of arguments, one from - each of the templates, and deduce them against each other. One of - the templates will be more specialized if all the *other* - template's arguments deduce against its arguments and at least one - of its arguments *does* *not* deduce against the other template's - corresponding argument. Deduction is done as for class templates. - The arguments used in deduction have reference and top level cv - qualifiers removed. Iff both arguments were originally reference - types *and* deduction succeeds in both directions, the template - with the more cv-qualified argument wins for that pairing (if - neither is more cv-qualified, they both are equal). Unlike regular - deduction, after all the arguments have been deduced in this way, - we do *not* verify the deduced template argument values can be - substituted into non-deduced contexts, nor do we have to verify - that all template arguments have been deduced. */ - -int -more_specialized_fn (tree pat1, tree pat2, int len) -{ - tree decl1 = DECL_TEMPLATE_RESULT (pat1); - tree decl2 = DECL_TEMPLATE_RESULT (pat2); - tree targs1 = make_tree_vec (DECL_NTPARMS (pat1)); - tree targs2 = make_tree_vec (DECL_NTPARMS (pat2)); - tree tparms1 = DECL_INNERMOST_TEMPLATE_PARMS (pat1); - tree tparms2 = DECL_INNERMOST_TEMPLATE_PARMS (pat2); - tree args1 = TYPE_ARG_TYPES (TREE_TYPE (decl1)); - tree args2 = TYPE_ARG_TYPES (TREE_TYPE (decl2)); - int better1 = 0; - int better2 = 0; - - /* Remove the this parameter from non-static member functions. If - one is a non-static member function and the other is not a static - member function, remove the first parameter from that function - also. This situation occurs for operator functions where we - locate both a member function (with this pointer) and non-member - operator (with explicit first operand). */ - if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1)) - { - len--; /* LEN is the number of significant arguments for DECL1 */ - args1 = TREE_CHAIN (args1); - if (!DECL_STATIC_FUNCTION_P (decl2)) - args2 = TREE_CHAIN (args2); - } - else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2)) - { - args2 = TREE_CHAIN (args2); - if (!DECL_STATIC_FUNCTION_P (decl1)) - { - len--; - args1 = TREE_CHAIN (args1); - } - } - - /* If only one is a conversion operator, they are unordered. */ - if (DECL_CONV_FN_P (decl1) != DECL_CONV_FN_P (decl2)) - return 0; - - /* Consider the return type for a conversion function */ - if (DECL_CONV_FN_P (decl1)) - { - args1 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl1)), args1); - args2 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl2)), args2); - len++; - } - - processing_template_decl++; - - while (len--) - { - tree arg1 = TREE_VALUE (args1); - tree arg2 = TREE_VALUE (args2); - int deduce1, deduce2; - int quals1 = -1; - int quals2 = -1; - - if (TREE_CODE (arg1) == REFERENCE_TYPE) - { - arg1 = TREE_TYPE (arg1); - quals1 = cp_type_quals (arg1); - } - - if (TREE_CODE (arg2) == REFERENCE_TYPE) - { - arg2 = TREE_TYPE (arg2); - quals2 = cp_type_quals (arg2); - } - - if ((quals1 < 0) != (quals2 < 0)) - { - /* Only of the args is a reference, see if we should apply - array/function pointer decay to it. This is not part of - DR214, but is, IMHO, consistent with the deduction rules - for the function call itself, and with our earlier - implementation of the underspecified partial ordering - rules. (nathan). */ - if (quals1 >= 0) - { - switch (TREE_CODE (arg1)) - { - case ARRAY_TYPE: - arg1 = TREE_TYPE (arg1); - /* FALLTHROUGH. */ - case FUNCTION_TYPE: - arg1 = build_pointer_type (arg1); - break; - - default: - break; - } - } - else - { - switch (TREE_CODE (arg2)) - { - case ARRAY_TYPE: - arg2 = TREE_TYPE (arg2); - /* FALLTHROUGH. */ - case FUNCTION_TYPE: - arg2 = build_pointer_type (arg2); - break; - - default: - break; - } - } - } - - arg1 = TYPE_MAIN_VARIANT (arg1); - arg2 = TYPE_MAIN_VARIANT (arg2); - - deduce1 = !unify (tparms1, targs1, arg1, arg2, UNIFY_ALLOW_NONE); - deduce2 = !unify (tparms2, targs2, arg2, arg1, UNIFY_ALLOW_NONE); - - if (!deduce1) - better2 = -1; - if (!deduce2) - better1 = -1; - if (better1 < 0 && better2 < 0) - /* We've failed to deduce something in either direction. - These must be unordered. */ - break; - - if (deduce1 && deduce2 && quals1 >= 0 && quals2 >= 0) - { - /* Deduces in both directions, see if quals can - disambiguate. Pretend the worse one failed to deduce. */ - if ((quals1 & quals2) == quals2) - deduce1 = 0; - if ((quals1 & quals2) == quals1) - deduce2 = 0; - } - if (deduce1 && !deduce2 && !better2) - better2 = 1; - if (deduce2 && !deduce1 && !better1) - better1 = 1; - - args1 = TREE_CHAIN (args1); - args2 = TREE_CHAIN (args2); - } - - processing_template_decl--; - - return (better1 > 0) - (better2 > 0); -} - -/* Determine which of two partial specializations is more specialized. - - PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding - to the first partial specialization. The TREE_VALUE is the - innermost set of template parameters for the partial - specialization. PAT2 is similar, but for the second template. - - Return 1 if the first partial specialization is more specialized; - -1 if the second is more specialized; 0 if neither is more - specialized. - - See [temp.class.order] for information about determining which of - two templates is more specialized. */ - -static int -more_specialized_class (tree pat1, tree pat2) -{ - tree targs; - tree tmpl1, tmpl2; - int winner = 0; - - tmpl1 = TREE_TYPE (pat1); - tmpl2 = TREE_TYPE (pat2); - - /* Just like what happens for functions, if we are ordering between - different class template specializations, we may encounter dependent - types in the arguments, and we need our dependency check functions - to behave correctly. */ - ++processing_template_decl; - targs = get_class_bindings (TREE_VALUE (pat1), - CLASSTYPE_TI_ARGS (tmpl1), - CLASSTYPE_TI_ARGS (tmpl2)); - if (targs) - --winner; - - targs = get_class_bindings (TREE_VALUE (pat2), - CLASSTYPE_TI_ARGS (tmpl2), - CLASSTYPE_TI_ARGS (tmpl1)); - if (targs) - ++winner; - --processing_template_decl; - - return winner; -} - -/* Return the template arguments that will produce the function signature - DECL from the function template FN, with the explicit template - arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must - also match. Return NULL_TREE if no satisfactory arguments could be - found. */ - -static tree -get_bindings (tree fn, tree decl, tree explicit_args, bool check_rettype) -{ - int ntparms = DECL_NTPARMS (fn); - tree targs = make_tree_vec (ntparms); - tree decl_type; - tree decl_arg_types; - - /* Substitute the explicit template arguments into the type of DECL. - The call to fn_type_unification will handle substitution into the - FN. */ - decl_type = TREE_TYPE (decl); - if (explicit_args && uses_template_parms (decl_type)) - { - tree tmpl; - tree converted_args; - - if (DECL_TEMPLATE_INFO (decl)) - tmpl = DECL_TI_TEMPLATE (decl); - else - /* We can get here for some invalid specializations. */ - return NULL_TREE; - - converted_args - = coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl), - explicit_args, NULL_TREE, - tf_none, - /*require_all_args=*/false, - /*use_default_args=*/false); - if (converted_args == error_mark_node) - return NULL_TREE; - - decl_type = tsubst (decl_type, converted_args, tf_none, NULL_TREE); - if (decl_type == error_mark_node) - return NULL_TREE; - } - - /* Never do unification on the 'this' parameter. */ - decl_arg_types = skip_artificial_parms_for (decl, - TYPE_ARG_TYPES (decl_type)); - - if (fn_type_unification (fn, explicit_args, targs, - decl_arg_types, - (check_rettype || DECL_CONV_FN_P (fn) - ? TREE_TYPE (decl_type) : NULL_TREE), - DEDUCE_EXACT, LOOKUP_NORMAL)) - return NULL_TREE; - - return targs; -} - -/* Return the innermost template arguments that, when applied to a - template specialization whose innermost template parameters are - TPARMS, and whose specialization arguments are PARMS, yield the - ARGS. - - For example, suppose we have: - - template <class T, class U> struct S {}; - template <class T> struct S<T*, int> {}; - - Then, suppose we want to get `S<double*, int>'. The TPARMS will be - {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*, - int}. The resulting vector will be {double}, indicating that `T' - is bound to `double'. */ - -static tree -get_class_bindings (tree tparms, tree spec_args, tree args) -{ - int i, ntparms = TREE_VEC_LENGTH (tparms); - tree deduced_args; - tree innermost_deduced_args; - - innermost_deduced_args = make_tree_vec (ntparms); - if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args)) - { - deduced_args = copy_node (args); - SET_TMPL_ARGS_LEVEL (deduced_args, - TMPL_ARGS_DEPTH (deduced_args), - innermost_deduced_args); - } - else - deduced_args = innermost_deduced_args; - - if (unify (tparms, deduced_args, - INNERMOST_TEMPLATE_ARGS (spec_args), - INNERMOST_TEMPLATE_ARGS (args), - UNIFY_ALLOW_NONE)) - return NULL_TREE; - - for (i = 0; i < ntparms; ++i) - if (! TREE_VEC_ELT (innermost_deduced_args, i)) - return NULL_TREE; - - /* Verify that nondeduced template arguments agree with the type - obtained from argument deduction. - - For example: - - struct A { typedef int X; }; - template <class T, class U> struct C {}; - template <class T> struct C<T, typename T::X> {}; - - Then with the instantiation `C<A, int>', we can deduce that - `T' is `A' but unify () does not check whether `typename T::X' - is `int'. */ - spec_args = tsubst (spec_args, deduced_args, tf_none, NULL_TREE); - if (spec_args == error_mark_node - /* We only need to check the innermost arguments; the other - arguments will always agree. */ - || !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args), - INNERMOST_TEMPLATE_ARGS (args))) - return NULL_TREE; - - return deduced_args; -} - -/* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL. - Return the TREE_LIST node with the most specialized template, if - any. If there is no most specialized template, the error_mark_node - is returned. - - Note that this function does not look at, or modify, the - TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node - returned is one of the elements of INSTANTIATIONS, callers may - store information in the TREE_PURPOSE or TREE_TYPE of the nodes, - and retrieve it from the value returned. */ - -tree -most_specialized_instantiation (tree templates) -{ - tree fn, champ; - - ++processing_template_decl; - - champ = templates; - for (fn = TREE_CHAIN (templates); fn; fn = TREE_CHAIN (fn)) - { - int fate = 0; - - if (get_bindings (TREE_VALUE (champ), - DECL_TEMPLATE_RESULT (TREE_VALUE (fn)), - NULL_TREE, /*check_ret=*/false)) - fate--; - - if (get_bindings (TREE_VALUE (fn), - DECL_TEMPLATE_RESULT (TREE_VALUE (champ)), - NULL_TREE, /*check_ret=*/false)) - fate++; - - if (fate == -1) - champ = fn; - else if (!fate) - { - /* Equally specialized, move to next function. If there - is no next function, nothing's most specialized. */ - fn = TREE_CHAIN (fn); - champ = fn; - if (!fn) - break; - } - } - - if (champ) - /* Now verify that champ is better than everything earlier in the - instantiation list. */ - for (fn = templates; fn != champ; fn = TREE_CHAIN (fn)) - if (get_bindings (TREE_VALUE (champ), - DECL_TEMPLATE_RESULT (TREE_VALUE (fn)), - NULL_TREE, /*check_ret=*/false) - || !get_bindings (TREE_VALUE (fn), - DECL_TEMPLATE_RESULT (TREE_VALUE (champ)), - NULL_TREE, /*check_ret=*/false)) - { - champ = NULL_TREE; - break; - } - - processing_template_decl--; - - if (!champ) - return error_mark_node; - - return champ; -} - -/* If DECL is a specialization of some template, return the most - general such template. Otherwise, returns NULL_TREE. - - For example, given: - - template <class T> struct S { template <class U> void f(U); }; - - if TMPL is `template <class U> void S<int>::f(U)' this will return - the full template. This function will not trace past partial - specializations, however. For example, given in addition: - - template <class T> struct S<T*> { template <class U> void f(U); }; - - if TMPL is `template <class U> void S<int*>::f(U)' this will return - `template <class T> template <class U> S<T*>::f(U)'. */ - -tree -most_general_template (tree decl) -{ - /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is - an immediate specialization. */ - if (TREE_CODE (decl) == FUNCTION_DECL) - { - if (DECL_TEMPLATE_INFO (decl)) { - decl = DECL_TI_TEMPLATE (decl); - - /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a - template friend. */ - if (TREE_CODE (decl) != TEMPLATE_DECL) - return NULL_TREE; - } else - return NULL_TREE; - } - - /* Look for more and more general templates. */ - while (DECL_TEMPLATE_INFO (decl)) - { - /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases. - (See cp-tree.h for details.) */ - if (TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL) - break; - - if (CLASS_TYPE_P (TREE_TYPE (decl)) - && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl))) - break; - - /* Stop if we run into an explicitly specialized class template. */ - if (!DECL_NAMESPACE_SCOPE_P (decl) - && DECL_CONTEXT (decl) - && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl))) - break; - - decl = DECL_TI_TEMPLATE (decl); - } - - return decl; -} - -/* Return the most specialized of the class template partial - specializations of TMPL which can produce TYPE, a specialization of - TMPL. The value returned is actually a TREE_LIST; the TREE_TYPE is - a _TYPE node corresponding to the partial specialization, while the - TREE_PURPOSE is the set of template arguments that must be - substituted into the TREE_TYPE in order to generate TYPE. - - If the choice of partial specialization is ambiguous, a diagnostic - is issued, and the error_mark_node is returned. If there are no - partial specializations of TMPL matching TYPE, then NULL_TREE is - returned. */ - -static tree -most_specialized_class (tree type, tree tmpl) -{ - tree list = NULL_TREE; - tree t; - tree champ; - int fate; - bool ambiguous_p; - tree args; - - tmpl = most_general_template (tmpl); - args = CLASSTYPE_TI_ARGS (type); - for (t = DECL_TEMPLATE_SPECIALIZATIONS (tmpl); t; t = TREE_CHAIN (t)) - { - tree partial_spec_args; - tree spec_args; - - partial_spec_args = CLASSTYPE_TI_ARGS (TREE_TYPE (t)); - spec_args = get_class_bindings (TREE_VALUE (t), - partial_spec_args, - args); - if (spec_args) - { - list = tree_cons (spec_args, TREE_VALUE (t), list); - TREE_TYPE (list) = TREE_TYPE (t); - } - } - - if (! list) - return NULL_TREE; - - ambiguous_p = false; - t = list; - champ = t; - t = TREE_CHAIN (t); - for (; t; t = TREE_CHAIN (t)) - { - fate = more_specialized_class (champ, t); - if (fate == 1) - ; - else - { - if (fate == 0) - { - t = TREE_CHAIN (t); - if (! t) - { - ambiguous_p = true; - break; - } - } - champ = t; - } - } - - if (!ambiguous_p) - for (t = list; t && t != champ; t = TREE_CHAIN (t)) - { - fate = more_specialized_class (champ, t); - if (fate != 1) - { - ambiguous_p = true; - break; - } - } - - if (ambiguous_p) - { - const char *str = "candidates are:"; - error ("ambiguous class template instantiation for %q#T", type); - for (t = list; t; t = TREE_CHAIN (t)) - { - error ("%s %+#T", str, TREE_TYPE (t)); - str = " "; - } - return error_mark_node; - } - - return champ; -} - -/* Explicitly instantiate DECL. */ - -void -do_decl_instantiation (tree decl, tree storage) -{ - tree result = NULL_TREE; - int extern_p = 0; - - if (!decl || decl == error_mark_node) - /* An error occurred, for which grokdeclarator has already issued - an appropriate message. */ - return; - else if (! DECL_LANG_SPECIFIC (decl)) - { - error ("explicit instantiation of non-template %q#D", decl); - return; - } - else if (TREE_CODE (decl) == VAR_DECL) - { - /* There is an asymmetry here in the way VAR_DECLs and - FUNCTION_DECLs are handled by grokdeclarator. In the case of - the latter, the DECL we get back will be marked as a - template instantiation, and the appropriate - DECL_TEMPLATE_INFO will be set up. This does not happen for - VAR_DECLs so we do the lookup here. Probably, grokdeclarator - should handle VAR_DECLs as it currently handles - FUNCTION_DECLs. */ - result = lookup_field (DECL_CONTEXT (decl), DECL_NAME (decl), 0, false); - if (!result || TREE_CODE (result) != VAR_DECL) - { - error ("no matching template for %qD found", decl); - return; - } - } - else if (TREE_CODE (decl) != FUNCTION_DECL) - { - error ("explicit instantiation of %q#D", decl); - return; - } - else - result = decl; - - /* Check for various error cases. Note that if the explicit - instantiation is valid the RESULT will currently be marked as an - *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set - until we get here. */ - - if (DECL_TEMPLATE_SPECIALIZATION (result)) - { - /* DR 259 [temp.spec]. - - Both an explicit instantiation and a declaration of an explicit - specialization shall not appear in a program unless the explicit - instantiation follows a declaration of the explicit specialization. - - For a given set of template parameters, if an explicit - instantiation of a template appears after a declaration of an - explicit specialization for that template, the explicit - instantiation has no effect. */ - return; - } - else if (DECL_EXPLICIT_INSTANTIATION (result)) - { - /* [temp.spec] - - No program shall explicitly instantiate any template more - than once. - - We check DECL_NOT_REALLY_EXTERN so as not to complain when - the first instantiation was `extern' and the second is not, - and EXTERN_P for the opposite case. */ - if (DECL_NOT_REALLY_EXTERN (result) && !extern_p) - pedwarn ("duplicate explicit instantiation of %q#D", result); - /* If an "extern" explicit instantiation follows an ordinary - explicit instantiation, the template is instantiated. */ - if (extern_p) - return; - } - else if (!DECL_IMPLICIT_INSTANTIATION (result)) - { - error ("no matching template for %qD found", result); - return; - } - else if (!DECL_TEMPLATE_INFO (result)) - { - pedwarn ("explicit instantiation of non-template %q#D", result); - return; - } - - if (storage == NULL_TREE) - ; - else if (storage == ridpointers[(int) RID_EXTERN]) - { - if (pedantic && !in_system_header) - pedwarn ("ISO C++ forbids the use of %<extern%> on explicit " - "instantiations"); - extern_p = 1; - } - else - error ("storage class %qD applied to template instantiation", storage); - - check_explicit_instantiation_namespace (result); - mark_decl_instantiated (result, extern_p); - if (! extern_p) - instantiate_decl (result, /*defer_ok=*/1, - /*expl_inst_class_mem_p=*/false); -} - -static void -mark_class_instantiated (tree t, int extern_p) -{ - SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t); - SET_CLASSTYPE_INTERFACE_KNOWN (t); - CLASSTYPE_INTERFACE_ONLY (t) = extern_p; - TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = extern_p; - if (! extern_p) - { - CLASSTYPE_DEBUG_REQUESTED (t) = 1; - rest_of_type_compilation (t, 1); - } -} - -/* Called from do_type_instantiation through binding_table_foreach to - do recursive instantiation for the type bound in ENTRY. */ -static void -bt_instantiate_type_proc (binding_entry entry, void *data) -{ - tree storage = *(tree *) data; - - if (IS_AGGR_TYPE (entry->type) - && !uses_template_parms (CLASSTYPE_TI_ARGS (entry->type))) - do_type_instantiation (TYPE_MAIN_DECL (entry->type), storage, 0); -} - -/* Called from do_type_instantiation to instantiate a member - (a member function or a static member variable) of an - explicitly instantiated class template. */ -static void -instantiate_class_member (tree decl, int extern_p) -{ - mark_decl_instantiated (decl, extern_p); - if (! extern_p) - instantiate_decl (decl, /*defer_ok=*/1, - /*expl_inst_class_mem_p=*/true); -} - -/* Perform an explicit instantiation of template class T. STORAGE, if - non-null, is the RID for extern, inline or static. COMPLAIN is - nonzero if this is called from the parser, zero if called recursively, - since the standard is unclear (as detailed below). */ - -void -do_type_instantiation (tree t, tree storage, tsubst_flags_t complain) -{ - int extern_p = 0; - int nomem_p = 0; - int static_p = 0; - int previous_instantiation_extern_p = 0; - - if (TREE_CODE (t) == TYPE_DECL) - t = TREE_TYPE (t); - - if (! CLASS_TYPE_P (t) || ! CLASSTYPE_TEMPLATE_INFO (t)) - { - error ("explicit instantiation of non-template type %qT", t); - return; - } - - complete_type (t); - - if (!COMPLETE_TYPE_P (t)) - { - if (complain & tf_error) - error ("explicit instantiation of %q#T before definition of template", - t); - return; - } - - if (storage != NULL_TREE) - { - if (pedantic && !in_system_header) - pedwarn("ISO C++ forbids the use of %qE on explicit instantiations", - storage); - - if (storage == ridpointers[(int) RID_INLINE]) - nomem_p = 1; - else if (storage == ridpointers[(int) RID_EXTERN]) - extern_p = 1; - else if (storage == ridpointers[(int) RID_STATIC]) - static_p = 1; - else - { - error ("storage class %qD applied to template instantiation", - storage); - extern_p = 0; - } - } - - if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t)) - { - /* DR 259 [temp.spec]. - - Both an explicit instantiation and a declaration of an explicit - specialization shall not appear in a program unless the explicit - instantiation follows a declaration of the explicit specialization. - - For a given set of template parameters, if an explicit - instantiation of a template appears after a declaration of an - explicit specialization for that template, the explicit - instantiation has no effect. */ - return; - } - else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t)) - { - /* [temp.spec] - - No program shall explicitly instantiate any template more - than once. - - If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit - instantiation was `extern'. If EXTERN_P then the second is. - These cases are OK. */ - previous_instantiation_extern_p = CLASSTYPE_INTERFACE_ONLY (t); - - if (!previous_instantiation_extern_p && !extern_p - && (complain & tf_error)) - pedwarn ("duplicate explicit instantiation of %q#T", t); - - /* If we've already instantiated the template, just return now. */ - if (!CLASSTYPE_INTERFACE_ONLY (t)) - return; - } - - check_explicit_instantiation_namespace (TYPE_NAME (t)); - mark_class_instantiated (t, extern_p); - - if (nomem_p) - return; - - { - tree tmp; - - /* In contrast to implicit instantiation, where only the - declarations, and not the definitions, of members are - instantiated, we have here: - - [temp.explicit] - - The explicit instantiation of a class template specialization - implies the instantiation of all of its members not - previously explicitly specialized in the translation unit - containing the explicit instantiation. - - Of course, we can't instantiate member template classes, since - we don't have any arguments for them. Note that the standard - is unclear on whether the instantiation of the members are - *explicit* instantiations or not. However, the most natural - interpretation is that it should be an explicit instantiation. */ - - if (! static_p) - for (tmp = TYPE_METHODS (t); tmp; tmp = TREE_CHAIN (tmp)) - if (TREE_CODE (tmp) == FUNCTION_DECL - && DECL_TEMPLATE_INSTANTIATION (tmp)) - instantiate_class_member (tmp, extern_p); - - for (tmp = TYPE_FIELDS (t); tmp; tmp = TREE_CHAIN (tmp)) - if (TREE_CODE (tmp) == VAR_DECL && DECL_TEMPLATE_INSTANTIATION (tmp)) - instantiate_class_member (tmp, extern_p); - - if (CLASSTYPE_NESTED_UTDS (t)) - binding_table_foreach (CLASSTYPE_NESTED_UTDS (t), - bt_instantiate_type_proc, &storage); - } -} - -/* Given a function DECL, which is a specialization of TMPL, modify - DECL to be a re-instantiation of TMPL with the same template - arguments. TMPL should be the template into which tsubst'ing - should occur for DECL, not the most general template. - - One reason for doing this is a scenario like this: - - template <class T> - void f(const T&, int i); - - void g() { f(3, 7); } - - template <class T> - void f(const T& t, const int i) { } - - Note that when the template is first instantiated, with - instantiate_template, the resulting DECL will have no name for the - first parameter, and the wrong type for the second. So, when we go - to instantiate the DECL, we regenerate it. */ - -static void -regenerate_decl_from_template (tree decl, tree tmpl) -{ - /* The arguments used to instantiate DECL, from the most general - template. */ - tree args; - tree code_pattern; - - args = DECL_TI_ARGS (decl); - code_pattern = DECL_TEMPLATE_RESULT (tmpl); - - /* Make sure that we can see identifiers, and compute access - correctly. */ - push_access_scope (decl); - - if (TREE_CODE (decl) == FUNCTION_DECL) - { - tree decl_parm; - tree pattern_parm; - tree specs; - int args_depth; - int parms_depth; - - args_depth = TMPL_ARGS_DEPTH (args); - parms_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)); - if (args_depth > parms_depth) - args = get_innermost_template_args (args, parms_depth); - - specs = tsubst_exception_specification (TREE_TYPE (code_pattern), - args, tf_error, NULL_TREE); - if (specs) - TREE_TYPE (decl) = build_exception_variant (TREE_TYPE (decl), - specs); - - /* Merge parameter declarations. */ - decl_parm = skip_artificial_parms_for (decl, - DECL_ARGUMENTS (decl)); - pattern_parm - = skip_artificial_parms_for (code_pattern, - DECL_ARGUMENTS (code_pattern)); - while (decl_parm) - { - tree parm_type; - tree attributes; - - if (DECL_NAME (decl_parm) != DECL_NAME (pattern_parm)) - DECL_NAME (decl_parm) = DECL_NAME (pattern_parm); - parm_type = tsubst (TREE_TYPE (pattern_parm), args, tf_error, - NULL_TREE); - parm_type = type_decays_to (parm_type); - if (!same_type_p (TREE_TYPE (decl_parm), parm_type)) - TREE_TYPE (decl_parm) = parm_type; - attributes = DECL_ATTRIBUTES (pattern_parm); - if (DECL_ATTRIBUTES (decl_parm) != attributes) - { - DECL_ATTRIBUTES (decl_parm) = attributes; - cplus_decl_attributes (&decl_parm, attributes, /*flags=*/0); - } - decl_parm = TREE_CHAIN (decl_parm); - pattern_parm = TREE_CHAIN (pattern_parm); - } - - /* Merge additional specifiers from the CODE_PATTERN. */ - if (DECL_DECLARED_INLINE_P (code_pattern) - && !DECL_DECLARED_INLINE_P (decl)) - DECL_DECLARED_INLINE_P (decl) = 1; - if (DECL_INLINE (code_pattern) && !DECL_INLINE (decl)) - DECL_INLINE (decl) = 1; - } - else if (TREE_CODE (decl) == VAR_DECL) - DECL_INITIAL (decl) = - tsubst_expr (DECL_INITIAL (code_pattern), args, - tf_error, DECL_TI_TEMPLATE (decl), - /*integral_constant_expression_p=*/false); - else - gcc_unreachable (); - - pop_access_scope (decl); -} - -/* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be - substituted to get DECL. */ - -tree -template_for_substitution (tree decl) -{ - tree tmpl = DECL_TI_TEMPLATE (decl); - - /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern - for the instantiation. This is not always the most general - template. Consider, for example: - - template <class T> - struct S { template <class U> void f(); - template <> void f<int>(); }; - - and an instantiation of S<double>::f<int>. We want TD to be the - specialization S<T>::f<int>, not the more general S<T>::f<U>. */ - while (/* An instantiation cannot have a definition, so we need a - more general template. */ - DECL_TEMPLATE_INSTANTIATION (tmpl) - /* We must also deal with friend templates. Given: - - template <class T> struct S { - template <class U> friend void f() {}; - }; - - S<int>::f<U> say, is not an instantiation of S<T>::f<U>, - so far as the language is concerned, but that's still - where we get the pattern for the instantiation from. On - other hand, if the definition comes outside the class, say: - - template <class T> struct S { - template <class U> friend void f(); - }; - template <class U> friend void f() {} - - we don't need to look any further. That's what the check for - DECL_INITIAL is for. */ - || (TREE_CODE (decl) == FUNCTION_DECL - && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl) - && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl)))) - { - /* The present template, TD, should not be a definition. If it - were a definition, we should be using it! Note that we - cannot restructure the loop to just keep going until we find - a template with a definition, since that might go too far if - a specialization was declared, but not defined. */ - gcc_assert (TREE_CODE (decl) != VAR_DECL - || DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (tmpl))); - - /* Fetch the more general template. */ - tmpl = DECL_TI_TEMPLATE (tmpl); - } - - return tmpl; -} - -/* Produce the definition of D, a _DECL generated from a template. If - DEFER_OK is nonzero, then we don't have to actually do the - instantiation now; we just have to do it sometime. Normally it is - an error if this is an explicit instantiation but D is undefined. - EXPL_INST_CLASS_MEM_P is true iff D is a member of an - explicitly instantiated class template. */ - -tree -instantiate_decl (tree d, int defer_ok, - bool expl_inst_class_mem_p) -{ - tree tmpl = DECL_TI_TEMPLATE (d); - tree gen_args; - tree args; - tree td; - tree code_pattern; - tree spec; - tree gen_tmpl; - bool pattern_defined; - int need_push; - location_t saved_loc = input_location; - int saved_in_system_header = in_system_header; - bool external_p; - - /* This function should only be used to instantiate templates for - functions and static member variables. */ - gcc_assert (TREE_CODE (d) == FUNCTION_DECL - || TREE_CODE (d) == VAR_DECL); - - /* Variables are never deferred; if instantiation is required, they - are instantiated right away. That allows for better code in the - case that an expression refers to the value of the variable -- - if the variable has a constant value the referring expression can - take advantage of that fact. */ - if (TREE_CODE (d) == VAR_DECL) - defer_ok = 0; - - /* Don't instantiate cloned functions. Instead, instantiate the - functions they cloned. */ - if (TREE_CODE (d) == FUNCTION_DECL && DECL_CLONED_FUNCTION_P (d)) - d = DECL_CLONED_FUNCTION (d); - - if (DECL_TEMPLATE_INSTANTIATED (d)) - /* D has already been instantiated. It might seem reasonable to - check whether or not D is an explicit instantiation, and, if so, - stop here. But when an explicit instantiation is deferred - until the end of the compilation, DECL_EXPLICIT_INSTANTIATION - is set, even though we still need to do the instantiation. */ - return d; - - /* If we already have a specialization of this declaration, then - there's no reason to instantiate it. Note that - retrieve_specialization gives us both instantiations and - specializations, so we must explicitly check - DECL_TEMPLATE_SPECIALIZATION. */ - gen_tmpl = most_general_template (tmpl); - gen_args = DECL_TI_ARGS (d); - spec = retrieve_specialization (gen_tmpl, gen_args, - /*class_specializations_p=*/false); - if (spec != NULL_TREE && DECL_TEMPLATE_SPECIALIZATION (spec)) - return spec; - - /* This needs to happen before any tsubsting. */ - if (! push_tinst_level (d)) - return d; - - timevar_push (TV_PARSE); - - /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern - for the instantiation. */ - td = template_for_substitution (d); - code_pattern = DECL_TEMPLATE_RESULT (td); - - /* We should never be trying to instantiate a member of a class - template or partial specialization. */ - gcc_assert (d != code_pattern); - - if ((DECL_NAMESPACE_SCOPE_P (d) && !DECL_INITIALIZED_IN_CLASS_P (d)) - || DECL_TEMPLATE_SPECIALIZATION (td)) - /* In the case of a friend template whose definition is provided - outside the class, we may have too many arguments. Drop the - ones we don't need. The same is true for specializations. */ - args = get_innermost_template_args - (gen_args, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td))); - else - args = gen_args; - - if (TREE_CODE (d) == FUNCTION_DECL) - pattern_defined = (DECL_SAVED_TREE (code_pattern) != NULL_TREE); - else - pattern_defined = ! DECL_IN_AGGR_P (code_pattern); - - /* We may be in the middle of deferred access check. Disable it now. */ - push_deferring_access_checks (dk_no_deferred); - - /* Unless an explicit instantiation directive has already determined - the linkage of D, remember that a definition is available for - this entity. */ - if (pattern_defined - && !DECL_INTERFACE_KNOWN (d) - && !DECL_NOT_REALLY_EXTERN (d)) - mark_definable (d); - - input_location = DECL_SOURCE_LOCATION (d); - in_system_header = DECL_IN_SYSTEM_HEADER (d); - - /* If D is a member of an explicitly instantiated class template, - and no definition is available, treat it like an implicit - instantiation. */ - if (!pattern_defined && expl_inst_class_mem_p - && DECL_EXPLICIT_INSTANTIATION (d)) - { - DECL_NOT_REALLY_EXTERN (d) = 0; - DECL_INTERFACE_KNOWN (d) = 0; - SET_DECL_IMPLICIT_INSTANTIATION (d); - } - - if (!defer_ok) - { - /* Recheck the substitutions to obtain any warning messages - about ignoring cv qualifiers. */ - tree gen = DECL_TEMPLATE_RESULT (gen_tmpl); - tree type = TREE_TYPE (gen); - - /* Make sure that we can see identifiers, and compute access - correctly. D is already the target FUNCTION_DECL with the - right context. */ - push_access_scope (d); - - if (TREE_CODE (gen) == FUNCTION_DECL) - { - tsubst (DECL_ARGUMENTS (gen), gen_args, tf_warning_or_error, d); - tsubst (TYPE_RAISES_EXCEPTIONS (type), gen_args, - tf_warning_or_error, d); - /* Don't simply tsubst the function type, as that will give - duplicate warnings about poor parameter qualifications. - The function arguments are the same as the decl_arguments - without the top level cv qualifiers. */ - type = TREE_TYPE (type); - } - tsubst (type, gen_args, tf_warning_or_error, d); - - pop_access_scope (d); - } - - /* Check to see whether we know that this template will be - instantiated in some other file, as with "extern template" - extension. */ - external_p = (DECL_INTERFACE_KNOWN (d) && DECL_REALLY_EXTERN (d)); - /* In general, we do not instantiate such templates... */ - if (external_p - /* ... but we instantiate inline functions so that we can inline - them and ... */ - && ! (TREE_CODE (d) == FUNCTION_DECL && DECL_INLINE (d)) - /* ... we instantiate static data members whose values are - needed in integral constant expressions. */ - && ! (TREE_CODE (d) == VAR_DECL - && DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (d))) - goto out; - /* Defer all other templates, unless we have been explicitly - forbidden from doing so. */ - if (/* If there is no definition, we cannot instantiate the - template. */ - ! pattern_defined - /* If it's OK to postpone instantiation, do so. */ - || defer_ok - /* If this is a static data member that will be defined - elsewhere, we don't want to instantiate the entire data - member, but we do want to instantiate the initializer so that - we can substitute that elsewhere. */ - || (external_p && TREE_CODE (d) == VAR_DECL)) - { - /* The definition of the static data member is now required so - we must substitute the initializer. */ - if (TREE_CODE (d) == VAR_DECL - && !DECL_INITIAL (d) - && DECL_INITIAL (code_pattern)) - { - tree ns; - tree init; - - ns = decl_namespace_context (d); - push_nested_namespace (ns); - push_nested_class (DECL_CONTEXT (d)); - init = tsubst_expr (DECL_INITIAL (code_pattern), - args, - tf_warning_or_error, NULL_TREE, - /*integral_constant_expression_p=*/false); - cp_finish_decl (d, init, /*init_const_expr_p=*/false, - /*asmspec_tree=*/NULL_TREE, - LOOKUP_ONLYCONVERTING); - pop_nested_class (); - pop_nested_namespace (ns); - } - - /* We restore the source position here because it's used by - add_pending_template. */ - input_location = saved_loc; - - if (at_eof && !pattern_defined - && DECL_EXPLICIT_INSTANTIATION (d)) - /* [temp.explicit] - - The definition of a non-exported function template, a - non-exported member function template, or a non-exported - member function or static data member of a class template - shall be present in every translation unit in which it is - explicitly instantiated. */ - pedwarn - ("explicit instantiation of %qD but no definition available", d); - - /* ??? Historically, we have instantiated inline functions, even - when marked as "extern template". */ - if (!(external_p && TREE_CODE (d) == VAR_DECL)) - add_pending_template (d); - goto out; - } - /* Tell the repository that D is available in this translation unit - -- and see if it is supposed to be instantiated here. */ - if (TREE_PUBLIC (d) && !DECL_REALLY_EXTERN (d) && !repo_emit_p (d)) - { - /* In a PCH file, despite the fact that the repository hasn't - requested instantiation in the PCH it is still possible that - an instantiation will be required in a file that includes the - PCH. */ - if (pch_file) - add_pending_template (d); - /* Instantiate inline functions so that the inliner can do its - job, even though we'll not be emitting a copy of this - function. */ - if (!(TREE_CODE (d) == FUNCTION_DECL - && flag_inline_trees - && DECL_DECLARED_INLINE_P (d))) - goto out; - } - - need_push = !cfun || !global_bindings_p (); - if (need_push) - push_to_top_level (); - - /* Mark D as instantiated so that recursive calls to - instantiate_decl do not try to instantiate it again. */ - DECL_TEMPLATE_INSTANTIATED (d) = 1; - - /* Regenerate the declaration in case the template has been modified - by a subsequent redeclaration. */ - regenerate_decl_from_template (d, td); - - /* We already set the file and line above. Reset them now in case - they changed as a result of calling regenerate_decl_from_template. */ - input_location = DECL_SOURCE_LOCATION (d); - - if (TREE_CODE (d) == VAR_DECL) - { - tree init; - - /* Clear out DECL_RTL; whatever was there before may not be right - since we've reset the type of the declaration. */ - SET_DECL_RTL (d, NULL_RTX); - DECL_IN_AGGR_P (d) = 0; - - /* The initializer is placed in DECL_INITIAL by - regenerate_decl_from_template. Pull it out so that - finish_decl can process it. */ - init = DECL_INITIAL (d); - DECL_INITIAL (d) = NULL_TREE; - DECL_INITIALIZED_P (d) = 0; - - /* Clear DECL_EXTERNAL so that cp_finish_decl will process the - initializer. That function will defer actual emission until - we have a chance to determine linkage. */ - DECL_EXTERNAL (d) = 0; - - /* Enter the scope of D so that access-checking works correctly. */ - push_nested_class (DECL_CONTEXT (d)); - finish_decl (d, init, NULL_TREE); - pop_nested_class (); - } - else if (TREE_CODE (d) == FUNCTION_DECL) - { - htab_t saved_local_specializations; - tree subst_decl; - tree tmpl_parm; - tree spec_parm; - - /* Save away the current list, in case we are instantiating one - template from within the body of another. */ - saved_local_specializations = local_specializations; - - /* Set up the list of local specializations. */ - local_specializations = htab_create (37, - hash_local_specialization, - eq_local_specializations, - NULL); - - /* Set up context. */ - start_preparsed_function (d, NULL_TREE, SF_PRE_PARSED); - - /* Create substitution entries for the parameters. */ - subst_decl = DECL_TEMPLATE_RESULT (template_for_substitution (d)); - tmpl_parm = DECL_ARGUMENTS (subst_decl); - spec_parm = DECL_ARGUMENTS (d); - if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d)) - { - register_local_specialization (spec_parm, tmpl_parm); - spec_parm = skip_artificial_parms_for (d, spec_parm); - tmpl_parm = skip_artificial_parms_for (subst_decl, tmpl_parm); - } - while (tmpl_parm) - { - register_local_specialization (spec_parm, tmpl_parm); - tmpl_parm = TREE_CHAIN (tmpl_parm); - spec_parm = TREE_CHAIN (spec_parm); - } - gcc_assert (!spec_parm); - - /* Substitute into the body of the function. */ - tsubst_expr (DECL_SAVED_TREE (code_pattern), args, - tf_warning_or_error, tmpl, - /*integral_constant_expression_p=*/false); - - /* We don't need the local specializations any more. */ - htab_delete (local_specializations); - local_specializations = saved_local_specializations; - - /* Finish the function. */ - d = finish_function (0); - expand_or_defer_fn (d); - } - - /* We're not deferring instantiation any more. */ - TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d)) = 0; - - if (need_push) - pop_from_top_level (); - -out: - input_location = saved_loc; - in_system_header = saved_in_system_header; - pop_deferring_access_checks (); - pop_tinst_level (); - - timevar_pop (TV_PARSE); - - return d; -} - -/* Run through the list of templates that we wish we could - instantiate, and instantiate any we can. RETRIES is the - number of times we retry pending template instantiation. */ - -void -instantiate_pending_templates (int retries) -{ - tree *t; - tree last = NULL_TREE; - int reconsider; - location_t saved_loc = input_location; - int saved_in_system_header = in_system_header; - - /* Instantiating templates may trigger vtable generation. This in turn - may require further template instantiations. We place a limit here - to avoid infinite loop. */ - if (pending_templates && retries >= max_tinst_depth) - { - tree decl = TREE_VALUE (pending_templates); - - error ("template instantiation depth exceeds maximum of %d" - " instantiating %q+D, possibly from virtual table generation" - " (use -ftemplate-depth-NN to increase the maximum)", - max_tinst_depth, decl); - if (TREE_CODE (decl) == FUNCTION_DECL) - /* Pretend that we defined it. */ - DECL_INITIAL (decl) = error_mark_node; - return; - } - - do - { - reconsider = 0; - - t = &pending_templates; - while (*t) - { - tree instantiation = TREE_VALUE (*t); - - reopen_tinst_level (TREE_PURPOSE (*t)); - - if (TYPE_P (instantiation)) - { - tree fn; - - if (!COMPLETE_TYPE_P (instantiation)) - { - instantiate_class_template (instantiation); - if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation)) - for (fn = TYPE_METHODS (instantiation); - fn; - fn = TREE_CHAIN (fn)) - if (! DECL_ARTIFICIAL (fn)) - instantiate_decl (fn, - /*defer_ok=*/0, - /*expl_inst_class_mem_p=*/false); - if (COMPLETE_TYPE_P (instantiation)) - reconsider = 1; - } - - if (COMPLETE_TYPE_P (instantiation)) - /* If INSTANTIATION has been instantiated, then we don't - need to consider it again in the future. */ - *t = TREE_CHAIN (*t); - else - { - last = *t; - t = &TREE_CHAIN (*t); - } - } - else - { - if (!DECL_TEMPLATE_SPECIALIZATION (instantiation) - && !DECL_TEMPLATE_INSTANTIATED (instantiation)) - { - instantiation - = instantiate_decl (instantiation, - /*defer_ok=*/0, - /*expl_inst_class_mem_p=*/false); - if (DECL_TEMPLATE_INSTANTIATED (instantiation)) - reconsider = 1; - } - - if (DECL_TEMPLATE_SPECIALIZATION (instantiation) - || DECL_TEMPLATE_INSTANTIATED (instantiation)) - /* If INSTANTIATION has been instantiated, then we don't - need to consider it again in the future. */ - *t = TREE_CHAIN (*t); - else - { - last = *t; - t = &TREE_CHAIN (*t); - } - } - tinst_depth = 0; - current_tinst_level = NULL_TREE; - } - last_pending_template = last; - } - while (reconsider); - - input_location = saved_loc; - in_system_header = saved_in_system_header; -} - -/* Substitute ARGVEC into T, which is a list of initializers for - either base class or a non-static data member. The TREE_PURPOSEs - are DECLs, and the TREE_VALUEs are the initializer values. Used by - instantiate_decl. */ - -static tree -tsubst_initializer_list (tree t, tree argvec) -{ - tree inits = NULL_TREE; - - for (; t; t = TREE_CHAIN (t)) - { - tree decl; - tree init; - - decl = tsubst_copy (TREE_PURPOSE (t), argvec, tf_warning_or_error, - NULL_TREE); - decl = expand_member_init (decl); - if (decl && !DECL_P (decl)) - in_base_initializer = 1; - - init = tsubst_expr (TREE_VALUE (t), argvec, tf_warning_or_error, - NULL_TREE, - /*integral_constant_expression_p=*/false); - in_base_initializer = 0; - - if (decl) - { - init = build_tree_list (decl, init); - TREE_CHAIN (init) = inits; - inits = init; - } - } - return inits; -} - -/* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */ - -static void -set_current_access_from_decl (tree decl) -{ - if (TREE_PRIVATE (decl)) - current_access_specifier = access_private_node; - else if (TREE_PROTECTED (decl)) - current_access_specifier = access_protected_node; - else - current_access_specifier = access_public_node; -} - -/* Instantiate an enumerated type. TAG is the template type, NEWTAG - is the instantiation (which should have been created with - start_enum) and ARGS are the template arguments to use. */ - -static void -tsubst_enum (tree tag, tree newtag, tree args) -{ - tree e; - - for (e = TYPE_VALUES (tag); e; e = TREE_CHAIN (e)) - { - tree value; - tree decl; - - decl = TREE_VALUE (e); - /* Note that in a template enum, the TREE_VALUE is the - CONST_DECL, not the corresponding INTEGER_CST. */ - value = tsubst_expr (DECL_INITIAL (decl), - args, tf_warning_or_error, NULL_TREE, - /*integral_constant_expression_p=*/true); - - /* Give this enumeration constant the correct access. */ - set_current_access_from_decl (decl); - - /* Actually build the enumerator itself. */ - build_enumerator (DECL_NAME (decl), value, newtag); - } - - finish_enum (newtag); - DECL_SOURCE_LOCATION (TYPE_NAME (newtag)) - = DECL_SOURCE_LOCATION (TYPE_NAME (tag)); -} - -/* DECL is a FUNCTION_DECL that is a template specialization. Return - its type -- but without substituting the innermost set of template - arguments. So, innermost set of template parameters will appear in - the type. */ - -tree -get_mostly_instantiated_function_type (tree decl) -{ - tree fn_type; - tree tmpl; - tree targs; - tree tparms; - int parm_depth; - - tmpl = most_general_template (DECL_TI_TEMPLATE (decl)); - targs = DECL_TI_ARGS (decl); - tparms = DECL_TEMPLATE_PARMS (tmpl); - parm_depth = TMPL_PARMS_DEPTH (tparms); - - /* There should be as many levels of arguments as there are levels - of parameters. */ - gcc_assert (parm_depth == TMPL_ARGS_DEPTH (targs)); - - fn_type = TREE_TYPE (tmpl); - - if (parm_depth == 1) - /* No substitution is necessary. */ - ; - else - { - int i, save_access_control; - tree partial_args; - - /* Replace the innermost level of the TARGS with NULL_TREEs to - let tsubst know not to substitute for those parameters. */ - partial_args = make_tree_vec (TREE_VEC_LENGTH (targs)); - for (i = 1; i < TMPL_ARGS_DEPTH (targs); ++i) - SET_TMPL_ARGS_LEVEL (partial_args, i, - TMPL_ARGS_LEVEL (targs, i)); - SET_TMPL_ARGS_LEVEL (partial_args, - TMPL_ARGS_DEPTH (targs), - make_tree_vec (DECL_NTPARMS (tmpl))); - - /* Disable access control as this function is used only during - name-mangling. */ - save_access_control = flag_access_control; - flag_access_control = 0; - - ++processing_template_decl; - /* Now, do the (partial) substitution to figure out the - appropriate function type. */ - fn_type = tsubst (fn_type, partial_args, tf_error, NULL_TREE); - --processing_template_decl; - - /* Substitute into the template parameters to obtain the real - innermost set of parameters. This step is important if the - innermost set of template parameters contains value - parameters whose types depend on outer template parameters. */ - TREE_VEC_LENGTH (partial_args)--; - tparms = tsubst_template_parms (tparms, partial_args, tf_error); - - flag_access_control = save_access_control; - } - - return fn_type; -} - -/* Return truthvalue if we're processing a template different from - the last one involved in diagnostics. */ -int -problematic_instantiation_changed (void) -{ - return last_template_error_tick != tinst_level_tick; -} - -/* Remember current template involved in diagnostics. */ -void -record_last_problematic_instantiation (void) -{ - last_template_error_tick = tinst_level_tick; -} - -tree -current_instantiation (void) -{ - return current_tinst_level; -} - -/* [temp.param] Check that template non-type parm TYPE is of an allowable - type. Return zero for ok, nonzero for disallowed. Issue error and - warning messages under control of COMPLAIN. */ - -static int -invalid_nontype_parm_type_p (tree type, tsubst_flags_t complain) -{ - if (INTEGRAL_TYPE_P (type)) - return 0; - else if (POINTER_TYPE_P (type)) - return 0; - else if (TYPE_PTR_TO_MEMBER_P (type)) - return 0; - else if (TREE_CODE (type) == TEMPLATE_TYPE_PARM) - return 0; - else if (TREE_CODE (type) == TYPENAME_TYPE) - return 0; - - if (complain & tf_error) - error ("%q#T is not a valid type for a template constant parameter", type); - return 1; -} - -/* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type]. - Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/ - -static bool -dependent_type_p_r (tree type) -{ - tree scope; - - /* [temp.dep.type] - - A type is dependent if it is: - - -- a template parameter. Template template parameters are types - for us (since TYPE_P holds true for them) so we handle - them here. */ - if (TREE_CODE (type) == TEMPLATE_TYPE_PARM - || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM) - return true; - /* -- a qualified-id with a nested-name-specifier which contains a - class-name that names a dependent type or whose unqualified-id - names a dependent type. */ - if (TREE_CODE (type) == TYPENAME_TYPE) - return true; - /* -- a cv-qualified type where the cv-unqualified type is - dependent. */ - type = TYPE_MAIN_VARIANT (type); - /* -- a compound type constructed from any dependent type. */ - if (TYPE_PTR_TO_MEMBER_P (type)) - return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type)) - || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE - (type))); - else if (TREE_CODE (type) == POINTER_TYPE - || TREE_CODE (type) == REFERENCE_TYPE) - return dependent_type_p (TREE_TYPE (type)); - else if (TREE_CODE (type) == FUNCTION_TYPE - || TREE_CODE (type) == METHOD_TYPE) - { - tree arg_type; - - if (dependent_type_p (TREE_TYPE (type))) - return true; - for (arg_type = TYPE_ARG_TYPES (type); - arg_type; - arg_type = TREE_CHAIN (arg_type)) - if (dependent_type_p (TREE_VALUE (arg_type))) - return true; - return false; - } - /* -- an array type constructed from any dependent type or whose - size is specified by a constant expression that is - value-dependent. */ - if (TREE_CODE (type) == ARRAY_TYPE) - { - if (TYPE_DOMAIN (type) - && ((value_dependent_expression_p - (TYPE_MAX_VALUE (TYPE_DOMAIN (type)))) - || (type_dependent_expression_p - (TYPE_MAX_VALUE (TYPE_DOMAIN (type)))))) - return true; - return dependent_type_p (TREE_TYPE (type)); - } - - /* -- a template-id in which either the template name is a template - parameter ... */ - if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM) - return true; - /* ... or any of the template arguments is a dependent type or - an expression that is type-dependent or value-dependent. */ - else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INFO (type) - && (any_dependent_template_arguments_p - (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type))))) - return true; - - /* All TYPEOF_TYPEs are dependent; if the argument of the `typeof' - expression is not type-dependent, then it should already been - have resolved. */ - if (TREE_CODE (type) == TYPEOF_TYPE) - return true; - - /* The standard does not specifically mention types that are local - to template functions or local classes, but they should be - considered dependent too. For example: - - template <int I> void f() { - enum E { a = I }; - S<sizeof (E)> s; - } - - The size of `E' cannot be known until the value of `I' has been - determined. Therefore, `E' must be considered dependent. */ - scope = TYPE_CONTEXT (type); - if (scope && TYPE_P (scope)) - return dependent_type_p (scope); - else if (scope && TREE_CODE (scope) == FUNCTION_DECL) - return type_dependent_expression_p (scope); - - /* Other types are non-dependent. */ - return false; -} - -/* Returns TRUE if TYPE is dependent, in the sense of - [temp.dep.type]. */ - -bool -dependent_type_p (tree type) -{ - /* If there are no template parameters in scope, then there can't be - any dependent types. */ - if (!processing_template_decl) - { - /* If we are not processing a template, then nobody should be - providing us with a dependent type. */ - gcc_assert (type); - gcc_assert (TREE_CODE (type) != TEMPLATE_TYPE_PARM); - return false; - } - - /* If the type is NULL, we have not computed a type for the entity - in question; in that case, the type is dependent. */ - if (!type) - return true; - - /* Erroneous types can be considered non-dependent. */ - if (type == error_mark_node) - return false; - - /* If we have not already computed the appropriate value for TYPE, - do so now. */ - if (!TYPE_DEPENDENT_P_VALID (type)) - { - TYPE_DEPENDENT_P (type) = dependent_type_p_r (type); - TYPE_DEPENDENT_P_VALID (type) = 1; - } - - return TYPE_DEPENDENT_P (type); -} - -/* Returns TRUE if EXPRESSION is dependent, according to CRITERION. */ - -static bool -dependent_scope_ref_p (tree expression, bool criterion (tree)) -{ - tree scope; - tree name; - - gcc_assert (TREE_CODE (expression) == SCOPE_REF); - - if (!TYPE_P (TREE_OPERAND (expression, 0))) - return true; - - scope = TREE_OPERAND (expression, 0); - name = TREE_OPERAND (expression, 1); - - /* [temp.dep.expr] - - An id-expression is type-dependent if it contains a - nested-name-specifier that contains a class-name that names a - dependent type. */ - /* The suggested resolution to Core Issue 2 implies that if the - qualifying type is the current class, then we must peek - inside it. */ - if (DECL_P (name) - && currently_open_class (scope) - && !criterion (name)) - return false; - if (dependent_type_p (scope)) - return true; - - return false; -} - -/* Returns TRUE if the EXPRESSION is value-dependent, in the sense of - [temp.dep.constexpr]. EXPRESSION is already known to be a constant - expression. */ - -bool -value_dependent_expression_p (tree expression) -{ - if (!processing_template_decl) - return false; - - /* A name declared with a dependent type. */ - if (DECL_P (expression) && type_dependent_expression_p (expression)) - return true; - - switch (TREE_CODE (expression)) - { - case IDENTIFIER_NODE: - /* A name that has not been looked up -- must be dependent. */ - return true; - - case TEMPLATE_PARM_INDEX: - /* A non-type template parm. */ - return true; - - case CONST_DECL: - /* A non-type template parm. */ - if (DECL_TEMPLATE_PARM_P (expression)) - return true; - return false; - - case VAR_DECL: - /* A constant with integral or enumeration type and is initialized - with an expression that is value-dependent. */ - if (DECL_INITIAL (expression) - && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (expression)) - && value_dependent_expression_p (DECL_INITIAL (expression))) - return true; - return false; - - case DYNAMIC_CAST_EXPR: - case STATIC_CAST_EXPR: - case CONST_CAST_EXPR: - case REINTERPRET_CAST_EXPR: - case CAST_EXPR: - /* These expressions are value-dependent if the type to which - the cast occurs is dependent or the expression being casted - is value-dependent. */ - { - tree type = TREE_TYPE (expression); - - if (dependent_type_p (type)) - return true; - - /* A functional cast has a list of operands. */ - expression = TREE_OPERAND (expression, 0); - if (!expression) - { - /* If there are no operands, it must be an expression such - as "int()". This should not happen for aggregate types - because it would form non-constant expressions. */ - gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type)); - - return false; - } - - if (TREE_CODE (expression) == TREE_LIST) - return any_value_dependent_elements_p (expression); - - return value_dependent_expression_p (expression); - } - - case SIZEOF_EXPR: - case ALIGNOF_EXPR: - /* APPLE LOCAL radar 5619052 */ - case AT_ENCODE_EXPR: - /* A `sizeof' expression is value-dependent if the operand is - type-dependent. */ - expression = TREE_OPERAND (expression, 0); - if (TYPE_P (expression)) - return dependent_type_p (expression); - return type_dependent_expression_p (expression); - - case SCOPE_REF: - return dependent_scope_ref_p (expression, value_dependent_expression_p); - - case COMPONENT_REF: - return (value_dependent_expression_p (TREE_OPERAND (expression, 0)) - || value_dependent_expression_p (TREE_OPERAND (expression, 1))); - - case CALL_EXPR: - /* A CALL_EXPR may appear in a constant expression if it is a - call to a builtin function, e.g., __builtin_constant_p. All - such calls are value-dependent. */ - return true; - - case MODOP_EXPR: - return ((value_dependent_expression_p (TREE_OPERAND (expression, 0))) - || (value_dependent_expression_p (TREE_OPERAND (expression, 2)))); - - default: - /* A constant expression is value-dependent if any subexpression is - value-dependent. */ - switch (TREE_CODE_CLASS (TREE_CODE (expression))) - { - case tcc_reference: - case tcc_unary: - return (value_dependent_expression_p - (TREE_OPERAND (expression, 0))); - - case tcc_comparison: - case tcc_binary: - return ((value_dependent_expression_p - (TREE_OPERAND (expression, 0))) - || (value_dependent_expression_p - (TREE_OPERAND (expression, 1)))); - - case tcc_expression: - { - int i; - for (i = 0; i < TREE_CODE_LENGTH (TREE_CODE (expression)); ++i) - /* In some cases, some of the operands may be missing. - (For example, in the case of PREDECREMENT_EXPR, the - amount to increment by may be missing.) That doesn't - make the expression dependent. */ - if (TREE_OPERAND (expression, i) - && (value_dependent_expression_p - (TREE_OPERAND (expression, i)))) - return true; - return false; - } - - default: - break; - } - } - - /* The expression is not value-dependent. */ - return false; -} - -/* Returns TRUE if the EXPRESSION is type-dependent, in the sense of - [temp.dep.expr]. */ - -bool -type_dependent_expression_p (tree expression) -{ - if (!processing_template_decl) - return false; - - if (expression == error_mark_node) - return false; - - /* An unresolved name is always dependent. */ - if (TREE_CODE (expression) == IDENTIFIER_NODE - || TREE_CODE (expression) == USING_DECL) - return true; - - /* Some expression forms are never type-dependent. */ - if (TREE_CODE (expression) == PSEUDO_DTOR_EXPR - || TREE_CODE (expression) == SIZEOF_EXPR - || TREE_CODE (expression) == ALIGNOF_EXPR - || TREE_CODE (expression) == TYPEID_EXPR - || TREE_CODE (expression) == DELETE_EXPR - || TREE_CODE (expression) == VEC_DELETE_EXPR - /* APPLE LOCAL begin radar 5619052 */ - || TREE_CODE (expression) == THROW_EXPR - || TREE_CODE (expression) == AT_ENCODE_EXPR) - /* APPLE LOCAL end radar 5619052 */ - return false; - - /* The types of these expressions depends only on the type to which - the cast occurs. */ - if (TREE_CODE (expression) == DYNAMIC_CAST_EXPR - || TREE_CODE (expression) == STATIC_CAST_EXPR - || TREE_CODE (expression) == CONST_CAST_EXPR - || TREE_CODE (expression) == REINTERPRET_CAST_EXPR - || TREE_CODE (expression) == CAST_EXPR) - return dependent_type_p (TREE_TYPE (expression)); - - /* The types of these expressions depends only on the type created - by the expression. */ - if (TREE_CODE (expression) == NEW_EXPR - || TREE_CODE (expression) == VEC_NEW_EXPR) - { - /* For NEW_EXPR tree nodes created inside a template, either - the object type itself or a TREE_LIST may appear as the - operand 1. */ - tree type = TREE_OPERAND (expression, 1); - if (TREE_CODE (type) == TREE_LIST) - /* This is an array type. We need to check array dimensions - as well. */ - return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type))) - || value_dependent_expression_p - (TREE_OPERAND (TREE_VALUE (type), 1)); - else - return dependent_type_p (type); - } - - if (TREE_CODE (expression) == SCOPE_REF - && dependent_scope_ref_p (expression, - type_dependent_expression_p)) - return true; - - if (TREE_CODE (expression) == FUNCTION_DECL - && DECL_LANG_SPECIFIC (expression) - && DECL_TEMPLATE_INFO (expression) - && (any_dependent_template_arguments_p - (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression))))) - return true; - - if (TREE_CODE (expression) == TEMPLATE_DECL - && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression)) - return false; - - if (TREE_TYPE (expression) == unknown_type_node) - { - if (TREE_CODE (expression) == ADDR_EXPR) - return type_dependent_expression_p (TREE_OPERAND (expression, 0)); - if (TREE_CODE (expression) == COMPONENT_REF - || TREE_CODE (expression) == OFFSET_REF) - { - if (type_dependent_expression_p (TREE_OPERAND (expression, 0))) - return true; - expression = TREE_OPERAND (expression, 1); - if (TREE_CODE (expression) == IDENTIFIER_NODE) - return false; - } - /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */ - if (TREE_CODE (expression) == SCOPE_REF) - return false; - - if (TREE_CODE (expression) == BASELINK) - expression = BASELINK_FUNCTIONS (expression); - - if (TREE_CODE (expression) == TEMPLATE_ID_EXPR) - { - if (any_dependent_template_arguments_p - (TREE_OPERAND (expression, 1))) - return true; - expression = TREE_OPERAND (expression, 0); - } - gcc_assert (TREE_CODE (expression) == OVERLOAD - || TREE_CODE (expression) == FUNCTION_DECL); - - while (expression) - { - if (type_dependent_expression_p (OVL_CURRENT (expression))) - return true; - expression = OVL_NEXT (expression); - } - return false; - } - - gcc_assert (TREE_CODE (expression) != TYPE_DECL); - - return (dependent_type_p (TREE_TYPE (expression))); -} - -/* Returns TRUE if ARGS (a TREE_LIST of arguments to a function call) - contains a type-dependent expression. */ - -bool -any_type_dependent_arguments_p (tree args) -{ - while (args) - { - tree arg = TREE_VALUE (args); - - if (type_dependent_expression_p (arg)) - return true; - args = TREE_CHAIN (args); - } - return false; -} - -/* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are - expressions) contains any value-dependent expressions. */ - -bool -any_value_dependent_elements_p (tree list) -{ - for (; list; list = TREE_CHAIN (list)) - if (value_dependent_expression_p (TREE_VALUE (list))) - return true; - - return false; -} - -/* Returns TRUE if the ARG (a template argument) is dependent. */ - -static bool -dependent_template_arg_p (tree arg) -{ - if (!processing_template_decl) - return false; - - if (TREE_CODE (arg) == TEMPLATE_DECL - || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM) - return dependent_template_p (arg); - else if (TYPE_P (arg)) - return dependent_type_p (arg); - else - return (type_dependent_expression_p (arg) - || value_dependent_expression_p (arg)); -} - -/* Returns true if ARGS (a collection of template arguments) contains - any dependent arguments. */ - -bool -any_dependent_template_arguments_p (tree args) -{ - int i; - int j; - - if (!args) - return false; - if (args == error_mark_node) - return true; - - for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i) - { - tree level = TMPL_ARGS_LEVEL (args, i + 1); - for (j = 0; j < TREE_VEC_LENGTH (level); ++j) - if (dependent_template_arg_p (TREE_VEC_ELT (level, j))) - return true; - } - - return false; -} - -/* Returns TRUE if the template TMPL is dependent. */ - -bool -dependent_template_p (tree tmpl) -{ - if (TREE_CODE (tmpl) == OVERLOAD) - { - while (tmpl) - { - if (dependent_template_p (OVL_FUNCTION (tmpl))) - return true; - tmpl = OVL_CHAIN (tmpl); - } - return false; - } - - /* Template template parameters are dependent. */ - if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl) - || TREE_CODE (tmpl) == TEMPLATE_TEMPLATE_PARM) - return true; - /* So are names that have not been looked up. */ - if (TREE_CODE (tmpl) == SCOPE_REF - || TREE_CODE (tmpl) == IDENTIFIER_NODE) - return true; - /* So are member templates of dependent classes. */ - if (TYPE_P (CP_DECL_CONTEXT (tmpl))) - return dependent_type_p (DECL_CONTEXT (tmpl)); - return false; -} - -/* Returns TRUE if the specialization TMPL<ARGS> is dependent. */ - -bool -dependent_template_id_p (tree tmpl, tree args) -{ - return (dependent_template_p (tmpl) - || any_dependent_template_arguments_p (args)); -} - -/* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the - TYPENAME_TYPE corresponds. Returns ERROR_MARK_NODE if no such TYPE - can be found. Note that this function peers inside uninstantiated - templates and therefore should be used only in extremely limited - situations. ONLY_CURRENT_P restricts this peering to the currently - open classes hierarchy (which is required when comparing types). */ - -tree -resolve_typename_type (tree type, bool only_current_p) -{ - tree scope; - tree name; - tree decl; - int quals; - tree pushed_scope; - - gcc_assert (TREE_CODE (type) == TYPENAME_TYPE); - - scope = TYPE_CONTEXT (type); - name = TYPE_IDENTIFIER (type); - - /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve - it first before we can figure out what NAME refers to. */ - if (TREE_CODE (scope) == TYPENAME_TYPE) - scope = resolve_typename_type (scope, only_current_p); - /* If we don't know what SCOPE refers to, then we cannot resolve the - TYPENAME_TYPE. */ - if (scope == error_mark_node || TREE_CODE (scope) == TYPENAME_TYPE) - return error_mark_node; - /* If the SCOPE is a template type parameter, we have no way of - resolving the name. */ - if (TREE_CODE (scope) == TEMPLATE_TYPE_PARM) - return type; - /* If the SCOPE is not the current instantiation, there's no reason - to look inside it. */ - if (only_current_p && !currently_open_class (scope)) - return error_mark_node; - /* If SCOPE is a partial instantiation, it will not have a valid - TYPE_FIELDS list, so use the original template. */ - scope = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope); - /* Enter the SCOPE so that name lookup will be resolved as if we - were in the class definition. In particular, SCOPE will no - longer be considered a dependent type. */ - pushed_scope = push_scope (scope); - /* Look up the declaration. */ - decl = lookup_member (scope, name, /*protect=*/0, /*want_type=*/true); - /* Obtain the set of qualifiers applied to the TYPE. */ - quals = cp_type_quals (type); - /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to - find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */ - if (!decl) - type = error_mark_node; - else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == IDENTIFIER_NODE - && TREE_CODE (decl) == TYPE_DECL) - type = TREE_TYPE (decl); - else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == TEMPLATE_ID_EXPR - && DECL_CLASS_TEMPLATE_P (decl)) - { - tree tmpl; - tree args; - /* Obtain the template and the arguments. */ - tmpl = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 0); - args = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 1); - /* Instantiate the template. */ - type = lookup_template_class (tmpl, args, NULL_TREE, NULL_TREE, - /*entering_scope=*/0, tf_error | tf_user); - } - else - type = error_mark_node; - /* Qualify the resulting type. */ - if (type != error_mark_node && quals) - type = cp_build_qualified_type (type, quals); - /* Leave the SCOPE. */ - if (pushed_scope) - pop_scope (pushed_scope); - - return type; -} - -/* EXPR is an expression which is not type-dependent. Return a proxy - for EXPR that can be used to compute the types of larger - expressions containing EXPR. */ - -tree -build_non_dependent_expr (tree expr) -{ - tree inner_expr; - - /* Preserve null pointer constants so that the type of things like - "p == 0" where "p" is a pointer can be determined. */ - if (null_ptr_cst_p (expr)) - return expr; - /* Preserve OVERLOADs; the functions must be available to resolve - types. */ - inner_expr = expr; - if (TREE_CODE (inner_expr) == ADDR_EXPR) - inner_expr = TREE_OPERAND (inner_expr, 0); - if (TREE_CODE (inner_expr) == COMPONENT_REF) - inner_expr = TREE_OPERAND (inner_expr, 1); - if (is_overloaded_fn (inner_expr) - || TREE_CODE (inner_expr) == OFFSET_REF) - return expr; - /* There is no need to return a proxy for a variable. */ - if (TREE_CODE (expr) == VAR_DECL) - return expr; - /* Preserve string constants; conversions from string constants to - "char *" are allowed, even though normally a "const char *" - cannot be used to initialize a "char *". */ - if (TREE_CODE (expr) == STRING_CST) - return expr; - /* Preserve arithmetic constants, as an optimization -- there is no - reason to create a new node. */ - if (TREE_CODE (expr) == INTEGER_CST || TREE_CODE (expr) == REAL_CST) - return expr; - /* Preserve THROW_EXPRs -- all throw-expressions have type "void". - There is at least one place where we want to know that a - particular expression is a throw-expression: when checking a ?: - expression, there are special rules if the second or third - argument is a throw-expression. */ - if (TREE_CODE (expr) == THROW_EXPR) - return expr; - - if (TREE_CODE (expr) == COND_EXPR) - return build3 (COND_EXPR, - TREE_TYPE (expr), - TREE_OPERAND (expr, 0), - (TREE_OPERAND (expr, 1) - ? build_non_dependent_expr (TREE_OPERAND (expr, 1)) - : build_non_dependent_expr (TREE_OPERAND (expr, 0))), - build_non_dependent_expr (TREE_OPERAND (expr, 2))); - if (TREE_CODE (expr) == COMPOUND_EXPR - && !COMPOUND_EXPR_OVERLOADED (expr)) - return build2 (COMPOUND_EXPR, - TREE_TYPE (expr), - TREE_OPERAND (expr, 0), - build_non_dependent_expr (TREE_OPERAND (expr, 1))); - - /* If the type is unknown, it can't really be non-dependent */ - gcc_assert (TREE_TYPE (expr) != unknown_type_node); - - /* Otherwise, build a NON_DEPENDENT_EXPR. - - REFERENCE_TYPEs are not stripped for expressions in templates - because doing so would play havoc with mangling. Consider, for - example: - - template <typename T> void f<T& g>() { g(); } - - In the body of "f", the expression for "g" will have - REFERENCE_TYPE, even though the standard says that it should - not. The reason is that we must preserve the syntactic form of - the expression so that mangling (say) "f<g>" inside the body of - "f" works out correctly. Therefore, the REFERENCE_TYPE is - stripped here. */ - return build1 (NON_DEPENDENT_EXPR, non_reference (TREE_TYPE (expr)), expr); -} - -/* ARGS is a TREE_LIST of expressions as arguments to a function call. - Return a new TREE_LIST with the various arguments replaced with - equivalent non-dependent expressions. */ - -tree -build_non_dependent_args (tree args) -{ - tree a; - tree new_args; - - new_args = NULL_TREE; - for (a = args; a; a = TREE_CHAIN (a)) - new_args = tree_cons (NULL_TREE, - build_non_dependent_expr (TREE_VALUE (a)), - new_args); - return nreverse (new_args); -} - -#include "gt-cp-pt.h" |