1 |
12 |
jlechner |
/* Handle parameterized types (templates) for GNU C++.
|
2 |
|
|
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
|
3 |
|
|
2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
|
4 |
|
|
Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing.
|
5 |
|
|
Rewritten by Jason Merrill (jason@cygnus.com).
|
6 |
|
|
|
7 |
|
|
This file is part of GCC.
|
8 |
|
|
|
9 |
|
|
GCC is free software; you can redistribute it and/or modify
|
10 |
|
|
it under the terms of the GNU General Public License as published by
|
11 |
|
|
the Free Software Foundation; either version 2, or (at your option)
|
12 |
|
|
any later version.
|
13 |
|
|
|
14 |
|
|
GCC is distributed in the hope that it will be useful,
|
15 |
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
16 |
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
17 |
|
|
GNU General Public License for more details.
|
18 |
|
|
|
19 |
|
|
You should have received a copy of the GNU General Public License
|
20 |
|
|
along with GCC; see the file COPYING. If not, write to
|
21 |
|
|
the Free Software Foundation, 51 Franklin Street, Fifth Floor,
|
22 |
|
|
Boston, MA 02110-1301, USA. */
|
23 |
|
|
|
24 |
|
|
/* Known bugs or deficiencies include:
|
25 |
|
|
|
26 |
|
|
all methods must be provided in header files; can't use a source
|
27 |
|
|
file that contains only the method templates and "just win". */
|
28 |
|
|
|
29 |
|
|
#include "config.h"
|
30 |
|
|
#include "system.h"
|
31 |
|
|
#include "coretypes.h"
|
32 |
|
|
#include "tm.h"
|
33 |
|
|
#include "obstack.h"
|
34 |
|
|
#include "tree.h"
|
35 |
|
|
#include "pointer-set.h"
|
36 |
|
|
#include "flags.h"
|
37 |
|
|
#include "c-common.h"
|
38 |
|
|
#include "cp-tree.h"
|
39 |
|
|
#include "cp-objcp-common.h"
|
40 |
|
|
#include "tree-inline.h"
|
41 |
|
|
#include "decl.h"
|
42 |
|
|
#include "output.h"
|
43 |
|
|
#include "except.h"
|
44 |
|
|
#include "toplev.h"
|
45 |
|
|
#include "rtl.h"
|
46 |
|
|
#include "timevar.h"
|
47 |
|
|
#include "tree-iterator.h"
|
48 |
|
|
|
49 |
|
|
/* The type of functions taking a tree, and some additional data, and
|
50 |
|
|
returning an int. */
|
51 |
|
|
typedef int (*tree_fn_t) (tree, void*);
|
52 |
|
|
|
53 |
|
|
/* The PENDING_TEMPLATES is a TREE_LIST of templates whose
|
54 |
|
|
instantiations have been deferred, either because their definitions
|
55 |
|
|
were not yet available, or because we were putting off doing the work.
|
56 |
|
|
The TREE_PURPOSE of each entry is either a DECL (for a function or
|
57 |
|
|
static data member), or a TYPE (for a class) indicating what we are
|
58 |
|
|
hoping to instantiate. The TREE_VALUE is not used. */
|
59 |
|
|
static GTY(()) tree pending_templates;
|
60 |
|
|
static GTY(()) tree last_pending_template;
|
61 |
|
|
|
62 |
|
|
int processing_template_parmlist;
|
63 |
|
|
static int template_header_count;
|
64 |
|
|
|
65 |
|
|
static GTY(()) tree saved_trees;
|
66 |
|
|
static GTY(()) varray_type inline_parm_levels;
|
67 |
|
|
static size_t inline_parm_levels_used;
|
68 |
|
|
|
69 |
|
|
static GTY(()) tree current_tinst_level;
|
70 |
|
|
|
71 |
|
|
static GTY(()) tree saved_access_scope;
|
72 |
|
|
|
73 |
|
|
/* Live only within one (recursive) call to tsubst_expr. We use
|
74 |
|
|
this to pass the statement expression node from the STMT_EXPR
|
75 |
|
|
to the EXPR_STMT that is its result. */
|
76 |
|
|
static tree cur_stmt_expr;
|
77 |
|
|
|
78 |
|
|
/* A map from local variable declarations in the body of the template
|
79 |
|
|
presently being instantiated to the corresponding instantiated
|
80 |
|
|
local variables. */
|
81 |
|
|
static htab_t local_specializations;
|
82 |
|
|
|
83 |
|
|
#define UNIFY_ALLOW_NONE 0
|
84 |
|
|
#define UNIFY_ALLOW_MORE_CV_QUAL 1
|
85 |
|
|
#define UNIFY_ALLOW_LESS_CV_QUAL 2
|
86 |
|
|
#define UNIFY_ALLOW_DERIVED 4
|
87 |
|
|
#define UNIFY_ALLOW_INTEGER 8
|
88 |
|
|
#define UNIFY_ALLOW_OUTER_LEVEL 16
|
89 |
|
|
#define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
|
90 |
|
|
#define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
|
91 |
|
|
|
92 |
|
|
static void push_access_scope (tree);
|
93 |
|
|
static void pop_access_scope (tree);
|
94 |
|
|
static int resolve_overloaded_unification (tree, tree, tree, tree,
|
95 |
|
|
unification_kind_t, int);
|
96 |
|
|
static int try_one_overload (tree, tree, tree, tree, tree,
|
97 |
|
|
unification_kind_t, int, bool);
|
98 |
|
|
static int unify (tree, tree, tree, tree, int);
|
99 |
|
|
static void add_pending_template (tree);
|
100 |
|
|
static void reopen_tinst_level (tree);
|
101 |
|
|
static tree classtype_mangled_name (tree);
|
102 |
|
|
static char* mangle_class_name_for_template (const char *, tree, tree);
|
103 |
|
|
static tree tsubst_initializer_list (tree, tree);
|
104 |
|
|
static tree get_class_bindings (tree, tree, tree);
|
105 |
|
|
static tree coerce_template_parms (tree, tree, tree, tsubst_flags_t, int);
|
106 |
|
|
static void tsubst_enum (tree, tree, tree);
|
107 |
|
|
static tree add_to_template_args (tree, tree);
|
108 |
|
|
static tree add_outermost_template_args (tree, tree);
|
109 |
|
|
static bool check_instantiated_args (tree, tree, tsubst_flags_t);
|
110 |
|
|
static int maybe_adjust_types_for_deduction (unification_kind_t, tree*, tree*);
|
111 |
|
|
static int type_unification_real (tree, tree, tree, tree,
|
112 |
|
|
int, unification_kind_t, int);
|
113 |
|
|
static void note_template_header (int);
|
114 |
|
|
static tree convert_nontype_argument_function (tree, tree);
|
115 |
|
|
static tree convert_nontype_argument (tree, tree);
|
116 |
|
|
static tree convert_template_argument (tree, tree, tree,
|
117 |
|
|
tsubst_flags_t, int, tree);
|
118 |
|
|
static int for_each_template_parm (tree, tree_fn_t, void*,
|
119 |
|
|
struct pointer_set_t*);
|
120 |
|
|
static tree build_template_parm_index (int, int, int, tree, tree);
|
121 |
|
|
static int inline_needs_template_parms (tree);
|
122 |
|
|
static void push_inline_template_parms_recursive (tree, int);
|
123 |
|
|
static tree retrieve_local_specialization (tree);
|
124 |
|
|
static void register_local_specialization (tree, tree);
|
125 |
|
|
static tree reduce_template_parm_level (tree, tree, int);
|
126 |
|
|
static int mark_template_parm (tree, void *);
|
127 |
|
|
static int template_parm_this_level_p (tree, void *);
|
128 |
|
|
static tree tsubst_friend_function (tree, tree);
|
129 |
|
|
static tree tsubst_friend_class (tree, tree);
|
130 |
|
|
static int can_complete_type_without_circularity (tree);
|
131 |
|
|
static tree get_bindings (tree, tree, tree, bool);
|
132 |
|
|
static int template_decl_level (tree);
|
133 |
|
|
static int check_cv_quals_for_unify (int, tree, tree);
|
134 |
|
|
static tree tsubst_template_arg (tree, tree, tsubst_flags_t, tree);
|
135 |
|
|
static tree tsubst_template_args (tree, tree, tsubst_flags_t, tree);
|
136 |
|
|
static tree tsubst_template_parms (tree, tree, tsubst_flags_t);
|
137 |
|
|
static void regenerate_decl_from_template (tree, tree);
|
138 |
|
|
static tree most_specialized (tree, tree, tree);
|
139 |
|
|
static tree most_specialized_class (tree, tree);
|
140 |
|
|
static int template_class_depth_real (tree, int);
|
141 |
|
|
static tree tsubst_aggr_type (tree, tree, tsubst_flags_t, tree, int);
|
142 |
|
|
static tree tsubst_arg_types (tree, tree, tsubst_flags_t, tree);
|
143 |
|
|
static tree tsubst_function_type (tree, tree, tsubst_flags_t, tree);
|
144 |
|
|
static void check_specialization_scope (void);
|
145 |
|
|
static tree process_partial_specialization (tree);
|
146 |
|
|
static void set_current_access_from_decl (tree);
|
147 |
|
|
static void check_default_tmpl_args (tree, tree, int, int);
|
148 |
|
|
static tree tsubst_call_declarator_parms (tree, tree, tsubst_flags_t, tree);
|
149 |
|
|
static tree get_template_base (tree, tree, tree, tree);
|
150 |
|
|
static tree try_class_unification (tree, tree, tree, tree);
|
151 |
|
|
static int coerce_template_template_parms (tree, tree, tsubst_flags_t,
|
152 |
|
|
tree, tree);
|
153 |
|
|
static tree determine_specialization (tree, tree, tree *, int, int);
|
154 |
|
|
static int template_args_equal (tree, tree);
|
155 |
|
|
static void tsubst_default_arguments (tree);
|
156 |
|
|
static tree for_each_template_parm_r (tree *, int *, void *);
|
157 |
|
|
static tree copy_default_args_to_explicit_spec_1 (tree, tree);
|
158 |
|
|
static void copy_default_args_to_explicit_spec (tree);
|
159 |
|
|
static int invalid_nontype_parm_type_p (tree, tsubst_flags_t);
|
160 |
|
|
static int eq_local_specializations (const void *, const void *);
|
161 |
|
|
static bool dependent_type_p_r (tree);
|
162 |
|
|
static tree tsubst (tree, tree, tsubst_flags_t, tree);
|
163 |
|
|
static tree tsubst_expr (tree, tree, tsubst_flags_t, tree);
|
164 |
|
|
static tree tsubst_copy (tree, tree, tsubst_flags_t, tree);
|
165 |
|
|
|
166 |
|
|
/* Make the current scope suitable for access checking when we are
|
167 |
|
|
processing T. T can be FUNCTION_DECL for instantiated function
|
168 |
|
|
template, or VAR_DECL for static member variable (need by
|
169 |
|
|
instantiate_decl). */
|
170 |
|
|
|
171 |
|
|
static void
|
172 |
|
|
push_access_scope (tree t)
|
173 |
|
|
{
|
174 |
|
|
gcc_assert (TREE_CODE (t) == FUNCTION_DECL
|
175 |
|
|
|| TREE_CODE (t) == VAR_DECL);
|
176 |
|
|
|
177 |
|
|
if (DECL_FRIEND_CONTEXT (t))
|
178 |
|
|
push_nested_class (DECL_FRIEND_CONTEXT (t));
|
179 |
|
|
else if (DECL_CLASS_SCOPE_P (t))
|
180 |
|
|
push_nested_class (DECL_CONTEXT (t));
|
181 |
|
|
else
|
182 |
|
|
push_to_top_level ();
|
183 |
|
|
|
184 |
|
|
if (TREE_CODE (t) == FUNCTION_DECL)
|
185 |
|
|
{
|
186 |
|
|
saved_access_scope = tree_cons
|
187 |
|
|
(NULL_TREE, current_function_decl, saved_access_scope);
|
188 |
|
|
current_function_decl = t;
|
189 |
|
|
}
|
190 |
|
|
}
|
191 |
|
|
|
192 |
|
|
/* Restore the scope set up by push_access_scope. T is the node we
|
193 |
|
|
are processing. */
|
194 |
|
|
|
195 |
|
|
static void
|
196 |
|
|
pop_access_scope (tree t)
|
197 |
|
|
{
|
198 |
|
|
if (TREE_CODE (t) == FUNCTION_DECL)
|
199 |
|
|
{
|
200 |
|
|
current_function_decl = TREE_VALUE (saved_access_scope);
|
201 |
|
|
saved_access_scope = TREE_CHAIN (saved_access_scope);
|
202 |
|
|
}
|
203 |
|
|
|
204 |
|
|
if (DECL_FRIEND_CONTEXT (t) || DECL_CLASS_SCOPE_P (t))
|
205 |
|
|
pop_nested_class ();
|
206 |
|
|
else
|
207 |
|
|
pop_from_top_level ();
|
208 |
|
|
}
|
209 |
|
|
|
210 |
|
|
/* Do any processing required when DECL (a member template
|
211 |
|
|
declaration) is finished. Returns the TEMPLATE_DECL corresponding
|
212 |
|
|
to DECL, unless it is a specialization, in which case the DECL
|
213 |
|
|
itself is returned. */
|
214 |
|
|
|
215 |
|
|
tree
|
216 |
|
|
finish_member_template_decl (tree decl)
|
217 |
|
|
{
|
218 |
|
|
if (decl == error_mark_node)
|
219 |
|
|
return error_mark_node;
|
220 |
|
|
|
221 |
|
|
gcc_assert (DECL_P (decl));
|
222 |
|
|
|
223 |
|
|
if (TREE_CODE (decl) == TYPE_DECL)
|
224 |
|
|
{
|
225 |
|
|
tree type;
|
226 |
|
|
|
227 |
|
|
type = TREE_TYPE (decl);
|
228 |
|
|
if (IS_AGGR_TYPE (type)
|
229 |
|
|
&& CLASSTYPE_TEMPLATE_INFO (type)
|
230 |
|
|
&& !CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
|
231 |
|
|
{
|
232 |
|
|
tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
|
233 |
|
|
check_member_template (tmpl);
|
234 |
|
|
return tmpl;
|
235 |
|
|
}
|
236 |
|
|
return NULL_TREE;
|
237 |
|
|
}
|
238 |
|
|
else if (TREE_CODE (decl) == FIELD_DECL)
|
239 |
|
|
error ("data member %qD cannot be a member template", decl);
|
240 |
|
|
else if (DECL_TEMPLATE_INFO (decl))
|
241 |
|
|
{
|
242 |
|
|
if (!DECL_TEMPLATE_SPECIALIZATION (decl))
|
243 |
|
|
{
|
244 |
|
|
check_member_template (DECL_TI_TEMPLATE (decl));
|
245 |
|
|
return DECL_TI_TEMPLATE (decl);
|
246 |
|
|
}
|
247 |
|
|
else
|
248 |
|
|
return decl;
|
249 |
|
|
}
|
250 |
|
|
else
|
251 |
|
|
error ("invalid member template declaration %qD", decl);
|
252 |
|
|
|
253 |
|
|
return error_mark_node;
|
254 |
|
|
}
|
255 |
|
|
|
256 |
|
|
/* Returns the template nesting level of the indicated class TYPE.
|
257 |
|
|
|
258 |
|
|
For example, in:
|
259 |
|
|
template <class T>
|
260 |
|
|
struct A
|
261 |
|
|
{
|
262 |
|
|
template <class U>
|
263 |
|
|
struct B {};
|
264 |
|
|
};
|
265 |
|
|
|
266 |
|
|
A<T>::B<U> has depth two, while A<T> has depth one.
|
267 |
|
|
Both A<T>::B<int> and A<int>::B<U> have depth one, if
|
268 |
|
|
COUNT_SPECIALIZATIONS is 0 or if they are instantiations, not
|
269 |
|
|
specializations.
|
270 |
|
|
|
271 |
|
|
This function is guaranteed to return 0 if passed NULL_TREE so
|
272 |
|
|
that, for example, `template_class_depth (current_class_type)' is
|
273 |
|
|
always safe. */
|
274 |
|
|
|
275 |
|
|
static int
|
276 |
|
|
template_class_depth_real (tree type, int count_specializations)
|
277 |
|
|
{
|
278 |
|
|
int depth;
|
279 |
|
|
|
280 |
|
|
for (depth = 0;
|
281 |
|
|
type && TREE_CODE (type) != NAMESPACE_DECL;
|
282 |
|
|
type = (TREE_CODE (type) == FUNCTION_DECL)
|
283 |
|
|
? CP_DECL_CONTEXT (type) : TYPE_CONTEXT (type))
|
284 |
|
|
{
|
285 |
|
|
if (TREE_CODE (type) != FUNCTION_DECL)
|
286 |
|
|
{
|
287 |
|
|
if (CLASSTYPE_TEMPLATE_INFO (type)
|
288 |
|
|
&& PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type))
|
289 |
|
|
&& ((count_specializations
|
290 |
|
|
&& CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
|
291 |
|
|
|| uses_template_parms (CLASSTYPE_TI_ARGS (type))))
|
292 |
|
|
++depth;
|
293 |
|
|
}
|
294 |
|
|
else
|
295 |
|
|
{
|
296 |
|
|
if (DECL_TEMPLATE_INFO (type)
|
297 |
|
|
&& PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (type))
|
298 |
|
|
&& ((count_specializations
|
299 |
|
|
&& DECL_TEMPLATE_SPECIALIZATION (type))
|
300 |
|
|
|| uses_template_parms (DECL_TI_ARGS (type))))
|
301 |
|
|
++depth;
|
302 |
|
|
}
|
303 |
|
|
}
|
304 |
|
|
|
305 |
|
|
return depth;
|
306 |
|
|
}
|
307 |
|
|
|
308 |
|
|
/* Returns the template nesting level of the indicated class TYPE.
|
309 |
|
|
Like template_class_depth_real, but instantiations do not count in
|
310 |
|
|
the depth. */
|
311 |
|
|
|
312 |
|
|
int
|
313 |
|
|
template_class_depth (tree type)
|
314 |
|
|
{
|
315 |
|
|
return template_class_depth_real (type, /*count_specializations=*/0);
|
316 |
|
|
}
|
317 |
|
|
|
318 |
|
|
/* Returns 1 if processing DECL as part of do_pending_inlines
|
319 |
|
|
needs us to push template parms. */
|
320 |
|
|
|
321 |
|
|
static int
|
322 |
|
|
inline_needs_template_parms (tree decl)
|
323 |
|
|
{
|
324 |
|
|
if (! DECL_TEMPLATE_INFO (decl))
|
325 |
|
|
return 0;
|
326 |
|
|
|
327 |
|
|
return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl)))
|
328 |
|
|
> (processing_template_decl + DECL_TEMPLATE_SPECIALIZATION (decl)));
|
329 |
|
|
}
|
330 |
|
|
|
331 |
|
|
/* Subroutine of maybe_begin_member_template_processing.
|
332 |
|
|
Push the template parms in PARMS, starting from LEVELS steps into the
|
333 |
|
|
chain, and ending at the beginning, since template parms are listed
|
334 |
|
|
innermost first. */
|
335 |
|
|
|
336 |
|
|
static void
|
337 |
|
|
push_inline_template_parms_recursive (tree parmlist, int levels)
|
338 |
|
|
{
|
339 |
|
|
tree parms = TREE_VALUE (parmlist);
|
340 |
|
|
int i;
|
341 |
|
|
|
342 |
|
|
if (levels > 1)
|
343 |
|
|
push_inline_template_parms_recursive (TREE_CHAIN (parmlist), levels - 1);
|
344 |
|
|
|
345 |
|
|
++processing_template_decl;
|
346 |
|
|
current_template_parms
|
347 |
|
|
= tree_cons (size_int (processing_template_decl),
|
348 |
|
|
parms, current_template_parms);
|
349 |
|
|
TEMPLATE_PARMS_FOR_INLINE (current_template_parms) = 1;
|
350 |
|
|
|
351 |
|
|
begin_scope (TREE_VEC_LENGTH (parms) ? sk_template_parms : sk_template_spec,
|
352 |
|
|
NULL);
|
353 |
|
|
for (i = 0; i < TREE_VEC_LENGTH (parms); ++i)
|
354 |
|
|
{
|
355 |
|
|
tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
|
356 |
|
|
gcc_assert (DECL_P (parm));
|
357 |
|
|
|
358 |
|
|
switch (TREE_CODE (parm))
|
359 |
|
|
{
|
360 |
|
|
case TYPE_DECL:
|
361 |
|
|
case TEMPLATE_DECL:
|
362 |
|
|
pushdecl (parm);
|
363 |
|
|
break;
|
364 |
|
|
|
365 |
|
|
case PARM_DECL:
|
366 |
|
|
{
|
367 |
|
|
/* Make a CONST_DECL as is done in process_template_parm.
|
368 |
|
|
It is ugly that we recreate this here; the original
|
369 |
|
|
version built in process_template_parm is no longer
|
370 |
|
|
available. */
|
371 |
|
|
tree decl = build_decl (CONST_DECL, DECL_NAME (parm),
|
372 |
|
|
TREE_TYPE (parm));
|
373 |
|
|
DECL_ARTIFICIAL (decl) = 1;
|
374 |
|
|
TREE_CONSTANT (decl) = 1;
|
375 |
|
|
TREE_INVARIANT (decl) = 1;
|
376 |
|
|
TREE_READONLY (decl) = 1;
|
377 |
|
|
DECL_INITIAL (decl) = DECL_INITIAL (parm);
|
378 |
|
|
SET_DECL_TEMPLATE_PARM_P (decl);
|
379 |
|
|
pushdecl (decl);
|
380 |
|
|
}
|
381 |
|
|
break;
|
382 |
|
|
|
383 |
|
|
default:
|
384 |
|
|
gcc_unreachable ();
|
385 |
|
|
}
|
386 |
|
|
}
|
387 |
|
|
}
|
388 |
|
|
|
389 |
|
|
/* Restore the template parameter context for a member template or
|
390 |
|
|
a friend template defined in a class definition. */
|
391 |
|
|
|
392 |
|
|
void
|
393 |
|
|
maybe_begin_member_template_processing (tree decl)
|
394 |
|
|
{
|
395 |
|
|
tree parms;
|
396 |
|
|
int levels = 0;
|
397 |
|
|
|
398 |
|
|
if (inline_needs_template_parms (decl))
|
399 |
|
|
{
|
400 |
|
|
parms = DECL_TEMPLATE_PARMS (most_general_template (decl));
|
401 |
|
|
levels = TMPL_PARMS_DEPTH (parms) - processing_template_decl;
|
402 |
|
|
|
403 |
|
|
if (DECL_TEMPLATE_SPECIALIZATION (decl))
|
404 |
|
|
{
|
405 |
|
|
--levels;
|
406 |
|
|
parms = TREE_CHAIN (parms);
|
407 |
|
|
}
|
408 |
|
|
|
409 |
|
|
push_inline_template_parms_recursive (parms, levels);
|
410 |
|
|
}
|
411 |
|
|
|
412 |
|
|
/* Remember how many levels of template parameters we pushed so that
|
413 |
|
|
we can pop them later. */
|
414 |
|
|
if (!inline_parm_levels)
|
415 |
|
|
VARRAY_INT_INIT (inline_parm_levels, 4, "inline_parm_levels");
|
416 |
|
|
if (inline_parm_levels_used == inline_parm_levels->num_elements)
|
417 |
|
|
VARRAY_GROW (inline_parm_levels, 2 * inline_parm_levels_used);
|
418 |
|
|
VARRAY_INT (inline_parm_levels, inline_parm_levels_used) = levels;
|
419 |
|
|
++inline_parm_levels_used;
|
420 |
|
|
}
|
421 |
|
|
|
422 |
|
|
/* Undo the effects of maybe_begin_member_template_processing. */
|
423 |
|
|
|
424 |
|
|
void
|
425 |
|
|
maybe_end_member_template_processing (void)
|
426 |
|
|
{
|
427 |
|
|
int i;
|
428 |
|
|
|
429 |
|
|
if (!inline_parm_levels_used)
|
430 |
|
|
return;
|
431 |
|
|
|
432 |
|
|
--inline_parm_levels_used;
|
433 |
|
|
for (i = 0;
|
434 |
|
|
i < VARRAY_INT (inline_parm_levels, inline_parm_levels_used);
|
435 |
|
|
++i)
|
436 |
|
|
{
|
437 |
|
|
--processing_template_decl;
|
438 |
|
|
current_template_parms = TREE_CHAIN (current_template_parms);
|
439 |
|
|
poplevel (0, 0, 0);
|
440 |
|
|
}
|
441 |
|
|
}
|
442 |
|
|
|
443 |
|
|
/* Return a new template argument vector which contains all of ARGS,
|
444 |
|
|
but has as its innermost set of arguments the EXTRA_ARGS. */
|
445 |
|
|
|
446 |
|
|
static tree
|
447 |
|
|
add_to_template_args (tree args, tree extra_args)
|
448 |
|
|
{
|
449 |
|
|
tree new_args;
|
450 |
|
|
int extra_depth;
|
451 |
|
|
int i;
|
452 |
|
|
int j;
|
453 |
|
|
|
454 |
|
|
extra_depth = TMPL_ARGS_DEPTH (extra_args);
|
455 |
|
|
new_args = make_tree_vec (TMPL_ARGS_DEPTH (args) + extra_depth);
|
456 |
|
|
|
457 |
|
|
for (i = 1; i <= TMPL_ARGS_DEPTH (args); ++i)
|
458 |
|
|
SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (args, i));
|
459 |
|
|
|
460 |
|
|
for (j = 1; j <= extra_depth; ++j, ++i)
|
461 |
|
|
SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (extra_args, j));
|
462 |
|
|
|
463 |
|
|
return new_args;
|
464 |
|
|
}
|
465 |
|
|
|
466 |
|
|
/* Like add_to_template_args, but only the outermost ARGS are added to
|
467 |
|
|
the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
|
468 |
|
|
(EXTRA_ARGS) levels are added. This function is used to combine
|
469 |
|
|
the template arguments from a partial instantiation with the
|
470 |
|
|
template arguments used to attain the full instantiation from the
|
471 |
|
|
partial instantiation. */
|
472 |
|
|
|
473 |
|
|
static tree
|
474 |
|
|
add_outermost_template_args (tree args, tree extra_args)
|
475 |
|
|
{
|
476 |
|
|
tree new_args;
|
477 |
|
|
|
478 |
|
|
/* If there are more levels of EXTRA_ARGS than there are ARGS,
|
479 |
|
|
something very fishy is going on. */
|
480 |
|
|
gcc_assert (TMPL_ARGS_DEPTH (args) >= TMPL_ARGS_DEPTH (extra_args));
|
481 |
|
|
|
482 |
|
|
/* If *all* the new arguments will be the EXTRA_ARGS, just return
|
483 |
|
|
them. */
|
484 |
|
|
if (TMPL_ARGS_DEPTH (args) == TMPL_ARGS_DEPTH (extra_args))
|
485 |
|
|
return extra_args;
|
486 |
|
|
|
487 |
|
|
/* For the moment, we make ARGS look like it contains fewer levels. */
|
488 |
|
|
TREE_VEC_LENGTH (args) -= TMPL_ARGS_DEPTH (extra_args);
|
489 |
|
|
|
490 |
|
|
new_args = add_to_template_args (args, extra_args);
|
491 |
|
|
|
492 |
|
|
/* Now, we restore ARGS to its full dimensions. */
|
493 |
|
|
TREE_VEC_LENGTH (args) += TMPL_ARGS_DEPTH (extra_args);
|
494 |
|
|
|
495 |
|
|
return new_args;
|
496 |
|
|
}
|
497 |
|
|
|
498 |
|
|
/* Return the N levels of innermost template arguments from the ARGS. */
|
499 |
|
|
|
500 |
|
|
tree
|
501 |
|
|
get_innermost_template_args (tree args, int n)
|
502 |
|
|
{
|
503 |
|
|
tree new_args;
|
504 |
|
|
int extra_levels;
|
505 |
|
|
int i;
|
506 |
|
|
|
507 |
|
|
gcc_assert (n >= 0);
|
508 |
|
|
|
509 |
|
|
/* If N is 1, just return the innermost set of template arguments. */
|
510 |
|
|
if (n == 1)
|
511 |
|
|
return TMPL_ARGS_LEVEL (args, TMPL_ARGS_DEPTH (args));
|
512 |
|
|
|
513 |
|
|
/* If we're not removing anything, just return the arguments we were
|
514 |
|
|
given. */
|
515 |
|
|
extra_levels = TMPL_ARGS_DEPTH (args) - n;
|
516 |
|
|
gcc_assert (extra_levels >= 0);
|
517 |
|
|
if (extra_levels == 0)
|
518 |
|
|
return args;
|
519 |
|
|
|
520 |
|
|
/* Make a new set of arguments, not containing the outer arguments. */
|
521 |
|
|
new_args = make_tree_vec (n);
|
522 |
|
|
for (i = 1; i <= n; ++i)
|
523 |
|
|
SET_TMPL_ARGS_LEVEL (new_args, i,
|
524 |
|
|
TMPL_ARGS_LEVEL (args, i + extra_levels));
|
525 |
|
|
|
526 |
|
|
return new_args;
|
527 |
|
|
}
|
528 |
|
|
|
529 |
|
|
/* We've got a template header coming up; push to a new level for storing
|
530 |
|
|
the parms. */
|
531 |
|
|
|
532 |
|
|
void
|
533 |
|
|
begin_template_parm_list (void)
|
534 |
|
|
{
|
535 |
|
|
/* We use a non-tag-transparent scope here, which causes pushtag to
|
536 |
|
|
put tags in this scope, rather than in the enclosing class or
|
537 |
|
|
namespace scope. This is the right thing, since we want
|
538 |
|
|
TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
|
539 |
|
|
global template class, push_template_decl handles putting the
|
540 |
|
|
TEMPLATE_DECL into top-level scope. For a nested template class,
|
541 |
|
|
e.g.:
|
542 |
|
|
|
543 |
|
|
template <class T> struct S1 {
|
544 |
|
|
template <class T> struct S2 {};
|
545 |
|
|
};
|
546 |
|
|
|
547 |
|
|
pushtag contains special code to call pushdecl_with_scope on the
|
548 |
|
|
TEMPLATE_DECL for S2. */
|
549 |
|
|
begin_scope (sk_template_parms, NULL);
|
550 |
|
|
++processing_template_decl;
|
551 |
|
|
++processing_template_parmlist;
|
552 |
|
|
note_template_header (0);
|
553 |
|
|
}
|
554 |
|
|
|
555 |
|
|
/* This routine is called when a specialization is declared. If it is
|
556 |
|
|
invalid to declare a specialization here, an error is reported. */
|
557 |
|
|
|
558 |
|
|
static void
|
559 |
|
|
check_specialization_scope (void)
|
560 |
|
|
{
|
561 |
|
|
tree scope = current_scope ();
|
562 |
|
|
|
563 |
|
|
/* [temp.expl.spec]
|
564 |
|
|
|
565 |
|
|
An explicit specialization shall be declared in the namespace of
|
566 |
|
|
which the template is a member, or, for member templates, in the
|
567 |
|
|
namespace of which the enclosing class or enclosing class
|
568 |
|
|
template is a member. An explicit specialization of a member
|
569 |
|
|
function, member class or static data member of a class template
|
570 |
|
|
shall be declared in the namespace of which the class template
|
571 |
|
|
is a member. */
|
572 |
|
|
if (scope && TREE_CODE (scope) != NAMESPACE_DECL)
|
573 |
|
|
error ("explicit specialization in non-namespace scope %qD", scope);
|
574 |
|
|
|
575 |
|
|
/* [temp.expl.spec]
|
576 |
|
|
|
577 |
|
|
In an explicit specialization declaration for a member of a class
|
578 |
|
|
template or a member template that appears in namespace scope,
|
579 |
|
|
the member template and some of its enclosing class templates may
|
580 |
|
|
remain unspecialized, except that the declaration shall not
|
581 |
|
|
explicitly specialize a class member template if its enclosing
|
582 |
|
|
class templates are not explicitly specialized as well. */
|
583 |
|
|
if (current_template_parms)
|
584 |
|
|
error ("enclosing class templates are not explicitly specialized");
|
585 |
|
|
}
|
586 |
|
|
|
587 |
|
|
/* We've just seen template <>. */
|
588 |
|
|
|
589 |
|
|
void
|
590 |
|
|
begin_specialization (void)
|
591 |
|
|
{
|
592 |
|
|
begin_scope (sk_template_spec, NULL);
|
593 |
|
|
note_template_header (1);
|
594 |
|
|
check_specialization_scope ();
|
595 |
|
|
}
|
596 |
|
|
|
597 |
|
|
/* Called at then end of processing a declaration preceded by
|
598 |
|
|
template<>. */
|
599 |
|
|
|
600 |
|
|
void
|
601 |
|
|
end_specialization (void)
|
602 |
|
|
{
|
603 |
|
|
finish_scope ();
|
604 |
|
|
reset_specialization ();
|
605 |
|
|
}
|
606 |
|
|
|
607 |
|
|
/* Any template <>'s that we have seen thus far are not referring to a
|
608 |
|
|
function specialization. */
|
609 |
|
|
|
610 |
|
|
void
|
611 |
|
|
reset_specialization (void)
|
612 |
|
|
{
|
613 |
|
|
processing_specialization = 0;
|
614 |
|
|
template_header_count = 0;
|
615 |
|
|
}
|
616 |
|
|
|
617 |
|
|
/* We've just seen a template header. If SPECIALIZATION is nonzero,
|
618 |
|
|
it was of the form template <>. */
|
619 |
|
|
|
620 |
|
|
static void
|
621 |
|
|
note_template_header (int specialization)
|
622 |
|
|
{
|
623 |
|
|
processing_specialization = specialization;
|
624 |
|
|
template_header_count++;
|
625 |
|
|
}
|
626 |
|
|
|
627 |
|
|
/* We're beginning an explicit instantiation. */
|
628 |
|
|
|
629 |
|
|
void
|
630 |
|
|
begin_explicit_instantiation (void)
|
631 |
|
|
{
|
632 |
|
|
gcc_assert (!processing_explicit_instantiation);
|
633 |
|
|
processing_explicit_instantiation = true;
|
634 |
|
|
}
|
635 |
|
|
|
636 |
|
|
|
637 |
|
|
void
|
638 |
|
|
end_explicit_instantiation (void)
|
639 |
|
|
{
|
640 |
|
|
gcc_assert (processing_explicit_instantiation);
|
641 |
|
|
processing_explicit_instantiation = false;
|
642 |
|
|
}
|
643 |
|
|
|
644 |
|
|
/* An explicit specialization or partial specialization TMPL is being
|
645 |
|
|
declared. Check that the namespace in which the specialization is
|
646 |
|
|
occurring is permissible. Returns false iff it is invalid to
|
647 |
|
|
specialize TMPL in the current namespace. */
|
648 |
|
|
|
649 |
|
|
static bool
|
650 |
|
|
check_specialization_namespace (tree tmpl)
|
651 |
|
|
{
|
652 |
|
|
tree tpl_ns = decl_namespace_context (tmpl);
|
653 |
|
|
|
654 |
|
|
/* [tmpl.expl.spec]
|
655 |
|
|
|
656 |
|
|
An explicit specialization shall be declared in the namespace of
|
657 |
|
|
which the template is a member, or, for member templates, in the
|
658 |
|
|
namespace of which the enclosing class or enclosing class
|
659 |
|
|
template is a member. An explicit specialization of a member
|
660 |
|
|
function, member class or static data member of a class template
|
661 |
|
|
shall be declared in the namespace of which the class template is
|
662 |
|
|
a member. */
|
663 |
|
|
if (is_associated_namespace (current_namespace, tpl_ns))
|
664 |
|
|
/* Same or super-using namespace. */
|
665 |
|
|
return true;
|
666 |
|
|
else
|
667 |
|
|
{
|
668 |
|
|
pedwarn ("specialization of %qD in different namespace", tmpl);
|
669 |
|
|
pedwarn (" from definition of %q+#D", tmpl);
|
670 |
|
|
return false;
|
671 |
|
|
}
|
672 |
|
|
}
|
673 |
|
|
|
674 |
|
|
/* SPEC is an explicit instantiation. Check that it is valid to
|
675 |
|
|
perform this explicit instantiation in the current namespace. */
|
676 |
|
|
|
677 |
|
|
static void
|
678 |
|
|
check_explicit_instantiation_namespace (tree spec)
|
679 |
|
|
{
|
680 |
|
|
tree ns;
|
681 |
|
|
|
682 |
|
|
/* DR 275: An explicit instantiation shall appear in an enclosing
|
683 |
|
|
namespace of its template. */
|
684 |
|
|
ns = decl_namespace_context (spec);
|
685 |
|
|
if (!is_ancestor (current_namespace, ns))
|
686 |
|
|
pedwarn ("explicit instantiation of %qD in namespace %qD "
|
687 |
|
|
"(which does not enclose namespace %qD)",
|
688 |
|
|
spec, current_namespace, ns);
|
689 |
|
|
}
|
690 |
|
|
|
691 |
|
|
/* The TYPE is being declared. If it is a template type, that means it
|
692 |
|
|
is a partial specialization. Do appropriate error-checking. */
|
693 |
|
|
|
694 |
|
|
void
|
695 |
|
|
maybe_process_partial_specialization (tree type)
|
696 |
|
|
{
|
697 |
|
|
tree context;
|
698 |
|
|
|
699 |
|
|
if (type == error_mark_node)
|
700 |
|
|
return;
|
701 |
|
|
|
702 |
|
|
context = TYPE_CONTEXT (type);
|
703 |
|
|
|
704 |
|
|
if (CLASS_TYPE_P (type) && CLASSTYPE_USE_TEMPLATE (type))
|
705 |
|
|
{
|
706 |
|
|
/* This is for ordinary explicit specialization and partial
|
707 |
|
|
specialization of a template class such as:
|
708 |
|
|
|
709 |
|
|
template <> class C<int>;
|
710 |
|
|
|
711 |
|
|
or:
|
712 |
|
|
|
713 |
|
|
template <class T> class C<T*>;
|
714 |
|
|
|
715 |
|
|
Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
|
716 |
|
|
|
717 |
|
|
if (CLASSTYPE_IMPLICIT_INSTANTIATION (type)
|
718 |
|
|
&& !COMPLETE_TYPE_P (type))
|
719 |
|
|
{
|
720 |
|
|
check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (type));
|
721 |
|
|
SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
|
722 |
|
|
if (processing_template_decl)
|
723 |
|
|
push_template_decl (TYPE_MAIN_DECL (type));
|
724 |
|
|
}
|
725 |
|
|
else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type))
|
726 |
|
|
error ("specialization of %qT after instantiation", type);
|
727 |
|
|
}
|
728 |
|
|
else if (CLASS_TYPE_P (type)
|
729 |
|
|
&& !CLASSTYPE_USE_TEMPLATE (type)
|
730 |
|
|
&& CLASSTYPE_TEMPLATE_INFO (type)
|
731 |
|
|
&& context && CLASS_TYPE_P (context)
|
732 |
|
|
&& CLASSTYPE_TEMPLATE_INFO (context))
|
733 |
|
|
{
|
734 |
|
|
/* This is for an explicit specialization of member class
|
735 |
|
|
template according to [temp.expl.spec/18]:
|
736 |
|
|
|
737 |
|
|
template <> template <class U> class C<int>::D;
|
738 |
|
|
|
739 |
|
|
The context `C<int>' must be an implicit instantiation.
|
740 |
|
|
Otherwise this is just a member class template declared
|
741 |
|
|
earlier like:
|
742 |
|
|
|
743 |
|
|
template <> class C<int> { template <class U> class D; };
|
744 |
|
|
template <> template <class U> class C<int>::D;
|
745 |
|
|
|
746 |
|
|
In the first case, `C<int>::D' is a specialization of `C<T>::D'
|
747 |
|
|
while in the second case, `C<int>::D' is a primary template
|
748 |
|
|
and `C<T>::D' may not exist. */
|
749 |
|
|
|
750 |
|
|
if (CLASSTYPE_IMPLICIT_INSTANTIATION (context)
|
751 |
|
|
&& !COMPLETE_TYPE_P (type))
|
752 |
|
|
{
|
753 |
|
|
tree t;
|
754 |
|
|
|
755 |
|
|
if (current_namespace
|
756 |
|
|
!= decl_namespace_context (CLASSTYPE_TI_TEMPLATE (type)))
|
757 |
|
|
{
|
758 |
|
|
pedwarn ("specializing %q#T in different namespace", type);
|
759 |
|
|
pedwarn (" from definition of %q+#D",
|
760 |
|
|
CLASSTYPE_TI_TEMPLATE (type));
|
761 |
|
|
}
|
762 |
|
|
|
763 |
|
|
/* Check for invalid specialization after instantiation:
|
764 |
|
|
|
765 |
|
|
template <> template <> class C<int>::D<int>;
|
766 |
|
|
template <> template <class U> class C<int>::D; */
|
767 |
|
|
|
768 |
|
|
for (t = DECL_TEMPLATE_INSTANTIATIONS
|
769 |
|
|
(most_general_template (CLASSTYPE_TI_TEMPLATE (type)));
|
770 |
|
|
t; t = TREE_CHAIN (t))
|
771 |
|
|
if (TREE_VALUE (t) != type
|
772 |
|
|
&& TYPE_CONTEXT (TREE_VALUE (t)) == context)
|
773 |
|
|
error ("specialization %qT after instantiation %qT",
|
774 |
|
|
type, TREE_VALUE (t));
|
775 |
|
|
|
776 |
|
|
/* Mark TYPE as a specialization. And as a result, we only
|
777 |
|
|
have one level of template argument for the innermost
|
778 |
|
|
class template. */
|
779 |
|
|
SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
|
780 |
|
|
CLASSTYPE_TI_ARGS (type)
|
781 |
|
|
= INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
|
782 |
|
|
}
|
783 |
|
|
}
|
784 |
|
|
else if (processing_specialization)
|
785 |
|
|
error ("explicit specialization of non-template %qT", type);
|
786 |
|
|
}
|
787 |
|
|
|
788 |
|
|
/* Returns nonzero if we can optimize the retrieval of specializations
|
789 |
|
|
for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
|
790 |
|
|
do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
|
791 |
|
|
|
792 |
|
|
static inline bool
|
793 |
|
|
optimize_specialization_lookup_p (tree tmpl)
|
794 |
|
|
{
|
795 |
|
|
return (DECL_FUNCTION_TEMPLATE_P (tmpl)
|
796 |
|
|
&& DECL_CLASS_SCOPE_P (tmpl)
|
797 |
|
|
/* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
|
798 |
|
|
parameter. */
|
799 |
|
|
&& CLASS_TYPE_P (DECL_CONTEXT (tmpl))
|
800 |
|
|
/* The optimized lookup depends on the fact that the
|
801 |
|
|
template arguments for the member function template apply
|
802 |
|
|
purely to the containing class, which is not true if the
|
803 |
|
|
containing class is an explicit or partial
|
804 |
|
|
specialization. */
|
805 |
|
|
&& !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl))
|
806 |
|
|
&& !DECL_MEMBER_TEMPLATE_P (tmpl)
|
807 |
|
|
&& !DECL_CONV_FN_P (tmpl)
|
808 |
|
|
/* It is possible to have a template that is not a member
|
809 |
|
|
template and is not a member of a template class:
|
810 |
|
|
|
811 |
|
|
template <typename T>
|
812 |
|
|
struct S { friend A::f(); };
|
813 |
|
|
|
814 |
|
|
Here, the friend function is a template, but the context does
|
815 |
|
|
not have template information. The optimized lookup relies
|
816 |
|
|
on having ARGS be the template arguments for both the class
|
817 |
|
|
and the function template. */
|
818 |
|
|
&& !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl)));
|
819 |
|
|
}
|
820 |
|
|
|
821 |
|
|
/* Retrieve the specialization (in the sense of [temp.spec] - a
|
822 |
|
|
specialization is either an instantiation or an explicit
|
823 |
|
|
specialization) of TMPL for the given template ARGS. If there is
|
824 |
|
|
no such specialization, return NULL_TREE. The ARGS are a vector of
|
825 |
|
|
arguments, or a vector of vectors of arguments, in the case of
|
826 |
|
|
templates with more than one level of parameters.
|
827 |
|
|
|
828 |
|
|
If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
|
829 |
|
|
then we search for a partial specialization matching ARGS. This
|
830 |
|
|
parameter is ignored if TMPL is not a class template. */
|
831 |
|
|
|
832 |
|
|
static tree
|
833 |
|
|
retrieve_specialization (tree tmpl, tree args,
|
834 |
|
|
bool class_specializations_p)
|
835 |
|
|
{
|
836 |
|
|
gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
|
837 |
|
|
|
838 |
|
|
/* There should be as many levels of arguments as there are
|
839 |
|
|
levels of parameters. */
|
840 |
|
|
gcc_assert (TMPL_ARGS_DEPTH (args)
|
841 |
|
|
== TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)));
|
842 |
|
|
|
843 |
|
|
if (optimize_specialization_lookup_p (tmpl))
|
844 |
|
|
{
|
845 |
|
|
tree class_template;
|
846 |
|
|
tree class_specialization;
|
847 |
|
|
VEC(tree,gc) *methods;
|
848 |
|
|
tree fns;
|
849 |
|
|
int idx;
|
850 |
|
|
|
851 |
|
|
/* The template arguments actually apply to the containing
|
852 |
|
|
class. Find the class specialization with those
|
853 |
|
|
arguments. */
|
854 |
|
|
class_template = CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl));
|
855 |
|
|
class_specialization
|
856 |
|
|
= retrieve_specialization (class_template, args,
|
857 |
|
|
/*class_specializations_p=*/false);
|
858 |
|
|
if (!class_specialization)
|
859 |
|
|
return NULL_TREE;
|
860 |
|
|
/* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
|
861 |
|
|
for the specialization. */
|
862 |
|
|
idx = class_method_index_for_fn (class_specialization, tmpl);
|
863 |
|
|
if (idx == -1)
|
864 |
|
|
return NULL_TREE;
|
865 |
|
|
/* Iterate through the methods with the indicated name, looking
|
866 |
|
|
for the one that has an instance of TMPL. */
|
867 |
|
|
methods = CLASSTYPE_METHOD_VEC (class_specialization);
|
868 |
|
|
for (fns = VEC_index (tree, methods, idx); fns; fns = OVL_NEXT (fns))
|
869 |
|
|
{
|
870 |
|
|
tree fn = OVL_CURRENT (fns);
|
871 |
|
|
if (DECL_TEMPLATE_INFO (fn) && DECL_TI_TEMPLATE (fn) == tmpl)
|
872 |
|
|
return fn;
|
873 |
|
|
}
|
874 |
|
|
return NULL_TREE;
|
875 |
|
|
}
|
876 |
|
|
else
|
877 |
|
|
{
|
878 |
|
|
tree *sp;
|
879 |
|
|
tree *head;
|
880 |
|
|
|
881 |
|
|
/* Class templates store their instantiations on the
|
882 |
|
|
DECL_TEMPLATE_INSTANTIATIONS list; other templates use the
|
883 |
|
|
DECL_TEMPLATE_SPECIALIZATIONS list. */
|
884 |
|
|
if (!class_specializations_p
|
885 |
|
|
&& TREE_CODE (DECL_TEMPLATE_RESULT (tmpl)) == TYPE_DECL)
|
886 |
|
|
sp = &DECL_TEMPLATE_INSTANTIATIONS (tmpl);
|
887 |
|
|
else
|
888 |
|
|
sp = &DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
|
889 |
|
|
head = sp;
|
890 |
|
|
/* Iterate through the list until we find a matching template. */
|
891 |
|
|
while (*sp != NULL_TREE)
|
892 |
|
|
{
|
893 |
|
|
tree spec = *sp;
|
894 |
|
|
|
895 |
|
|
if (comp_template_args (TREE_PURPOSE (spec), args))
|
896 |
|
|
{
|
897 |
|
|
/* Use the move-to-front heuristic to speed up future
|
898 |
|
|
searches. */
|
899 |
|
|
if (spec != *head)
|
900 |
|
|
{
|
901 |
|
|
*sp = TREE_CHAIN (*sp);
|
902 |
|
|
TREE_CHAIN (spec) = *head;
|
903 |
|
|
*head = spec;
|
904 |
|
|
}
|
905 |
|
|
return TREE_VALUE (spec);
|
906 |
|
|
}
|
907 |
|
|
sp = &TREE_CHAIN (spec);
|
908 |
|
|
}
|
909 |
|
|
}
|
910 |
|
|
|
911 |
|
|
return NULL_TREE;
|
912 |
|
|
}
|
913 |
|
|
|
914 |
|
|
/* Like retrieve_specialization, but for local declarations. */
|
915 |
|
|
|
916 |
|
|
static tree
|
917 |
|
|
retrieve_local_specialization (tree tmpl)
|
918 |
|
|
{
|
919 |
|
|
tree spec = htab_find_with_hash (local_specializations, tmpl,
|
920 |
|
|
htab_hash_pointer (tmpl));
|
921 |
|
|
return spec ? TREE_PURPOSE (spec) : NULL_TREE;
|
922 |
|
|
}
|
923 |
|
|
|
924 |
|
|
/* Returns nonzero iff DECL is a specialization of TMPL. */
|
925 |
|
|
|
926 |
|
|
int
|
927 |
|
|
is_specialization_of (tree decl, tree tmpl)
|
928 |
|
|
{
|
929 |
|
|
tree t;
|
930 |
|
|
|
931 |
|
|
if (TREE_CODE (decl) == FUNCTION_DECL)
|
932 |
|
|
{
|
933 |
|
|
for (t = decl;
|
934 |
|
|
t != NULL_TREE;
|
935 |
|
|
t = DECL_TEMPLATE_INFO (t) ? DECL_TI_TEMPLATE (t) : NULL_TREE)
|
936 |
|
|
if (t == tmpl)
|
937 |
|
|
return 1;
|
938 |
|
|
}
|
939 |
|
|
else
|
940 |
|
|
{
|
941 |
|
|
gcc_assert (TREE_CODE (decl) == TYPE_DECL);
|
942 |
|
|
|
943 |
|
|
for (t = TREE_TYPE (decl);
|
944 |
|
|
t != NULL_TREE;
|
945 |
|
|
t = CLASSTYPE_USE_TEMPLATE (t)
|
946 |
|
|
? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t)) : NULL_TREE)
|
947 |
|
|
if (same_type_ignoring_top_level_qualifiers_p (t, TREE_TYPE (tmpl)))
|
948 |
|
|
return 1;
|
949 |
|
|
}
|
950 |
|
|
|
951 |
|
|
return 0;
|
952 |
|
|
}
|
953 |
|
|
|
954 |
|
|
/* Returns nonzero iff DECL is a specialization of friend declaration
|
955 |
|
|
FRIEND according to [temp.friend]. */
|
956 |
|
|
|
957 |
|
|
bool
|
958 |
|
|
is_specialization_of_friend (tree decl, tree friend)
|
959 |
|
|
{
|
960 |
|
|
bool need_template = true;
|
961 |
|
|
int template_depth;
|
962 |
|
|
|
963 |
|
|
gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
|
964 |
|
|
|| TREE_CODE (decl) == TYPE_DECL);
|
965 |
|
|
|
966 |
|
|
/* For [temp.friend/6] when FRIEND is an ordinary member function
|
967 |
|
|
of a template class, we want to check if DECL is a specialization
|
968 |
|
|
if this. */
|
969 |
|
|
if (TREE_CODE (friend) == FUNCTION_DECL
|
970 |
|
|
&& DECL_TEMPLATE_INFO (friend)
|
971 |
|
|
&& !DECL_USE_TEMPLATE (friend))
|
972 |
|
|
{
|
973 |
|
|
/* We want a TEMPLATE_DECL for `is_specialization_of'. */
|
974 |
|
|
friend = DECL_TI_TEMPLATE (friend);
|
975 |
|
|
need_template = false;
|
976 |
|
|
}
|
977 |
|
|
else if (TREE_CODE (friend) == TEMPLATE_DECL
|
978 |
|
|
&& !PRIMARY_TEMPLATE_P (friend))
|
979 |
|
|
need_template = false;
|
980 |
|
|
|
981 |
|
|
/* There is nothing to do if this is not a template friend. */
|
982 |
|
|
if (TREE_CODE (friend) != TEMPLATE_DECL)
|
983 |
|
|
return false;
|
984 |
|
|
|
985 |
|
|
if (is_specialization_of (decl, friend))
|
986 |
|
|
return true;
|
987 |
|
|
|
988 |
|
|
/* [temp.friend/6]
|
989 |
|
|
A member of a class template may be declared to be a friend of a
|
990 |
|
|
non-template class. In this case, the corresponding member of
|
991 |
|
|
every specialization of the class template is a friend of the
|
992 |
|
|
class granting friendship.
|
993 |
|
|
|
994 |
|
|
For example, given a template friend declaration
|
995 |
|
|
|
996 |
|
|
template <class T> friend void A<T>::f();
|
997 |
|
|
|
998 |
|
|
the member function below is considered a friend
|
999 |
|
|
|
1000 |
|
|
template <> struct A<int> {
|
1001 |
|
|
void f();
|
1002 |
|
|
};
|
1003 |
|
|
|
1004 |
|
|
For this type of template friend, TEMPLATE_DEPTH below will be
|
1005 |
|
|
nonzero. To determine if DECL is a friend of FRIEND, we first
|
1006 |
|
|
check if the enclosing class is a specialization of another. */
|
1007 |
|
|
|
1008 |
|
|
template_depth = template_class_depth (DECL_CONTEXT (friend));
|
1009 |
|
|
if (template_depth
|
1010 |
|
|
&& DECL_CLASS_SCOPE_P (decl)
|
1011 |
|
|
&& is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl)),
|
1012 |
|
|
CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend))))
|
1013 |
|
|
{
|
1014 |
|
|
/* Next, we check the members themselves. In order to handle
|
1015 |
|
|
a few tricky cases, such as when FRIEND's are
|
1016 |
|
|
|
1017 |
|
|
template <class T> friend void A<T>::g(T t);
|
1018 |
|
|
template <class T> template <T t> friend void A<T>::h();
|
1019 |
|
|
|
1020 |
|
|
and DECL's are
|
1021 |
|
|
|
1022 |
|
|
void A<int>::g(int);
|
1023 |
|
|
template <int> void A<int>::h();
|
1024 |
|
|
|
1025 |
|
|
we need to figure out ARGS, the template arguments from
|
1026 |
|
|
the context of DECL. This is required for template substitution
|
1027 |
|
|
of `T' in the function parameter of `g' and template parameter
|
1028 |
|
|
of `h' in the above examples. Here ARGS corresponds to `int'. */
|
1029 |
|
|
|
1030 |
|
|
tree context = DECL_CONTEXT (decl);
|
1031 |
|
|
tree args = NULL_TREE;
|
1032 |
|
|
int current_depth = 0;
|
1033 |
|
|
|
1034 |
|
|
while (current_depth < template_depth)
|
1035 |
|
|
{
|
1036 |
|
|
if (CLASSTYPE_TEMPLATE_INFO (context))
|
1037 |
|
|
{
|
1038 |
|
|
if (current_depth == 0)
|
1039 |
|
|
args = TYPE_TI_ARGS (context);
|
1040 |
|
|
else
|
1041 |
|
|
args = add_to_template_args (TYPE_TI_ARGS (context), args);
|
1042 |
|
|
current_depth++;
|
1043 |
|
|
}
|
1044 |
|
|
context = TYPE_CONTEXT (context);
|
1045 |
|
|
}
|
1046 |
|
|
|
1047 |
|
|
if (TREE_CODE (decl) == FUNCTION_DECL)
|
1048 |
|
|
{
|
1049 |
|
|
bool is_template;
|
1050 |
|
|
tree friend_type;
|
1051 |
|
|
tree decl_type;
|
1052 |
|
|
tree friend_args_type;
|
1053 |
|
|
tree decl_args_type;
|
1054 |
|
|
|
1055 |
|
|
/* Make sure that both DECL and FRIEND are templates or
|
1056 |
|
|
non-templates. */
|
1057 |
|
|
is_template = DECL_TEMPLATE_INFO (decl)
|
1058 |
|
|
&& PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl));
|
1059 |
|
|
if (need_template ^ is_template)
|
1060 |
|
|
return false;
|
1061 |
|
|
else if (is_template)
|
1062 |
|
|
{
|
1063 |
|
|
/* If both are templates, check template parameter list. */
|
1064 |
|
|
tree friend_parms
|
1065 |
|
|
= tsubst_template_parms (DECL_TEMPLATE_PARMS (friend),
|
1066 |
|
|
args, tf_none);
|
1067 |
|
|
if (!comp_template_parms
|
1068 |
|
|
(DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl)),
|
1069 |
|
|
friend_parms))
|
1070 |
|
|
return false;
|
1071 |
|
|
|
1072 |
|
|
decl_type = TREE_TYPE (DECL_TI_TEMPLATE (decl));
|
1073 |
|
|
}
|
1074 |
|
|
else
|
1075 |
|
|
decl_type = TREE_TYPE (decl);
|
1076 |
|
|
|
1077 |
|
|
friend_type = tsubst_function_type (TREE_TYPE (friend), args,
|
1078 |
|
|
tf_none, NULL_TREE);
|
1079 |
|
|
if (friend_type == error_mark_node)
|
1080 |
|
|
return false;
|
1081 |
|
|
|
1082 |
|
|
/* Check if return types match. */
|
1083 |
|
|
if (!same_type_p (TREE_TYPE (decl_type), TREE_TYPE (friend_type)))
|
1084 |
|
|
return false;
|
1085 |
|
|
|
1086 |
|
|
/* Check if function parameter types match, ignoring the
|
1087 |
|
|
`this' parameter. */
|
1088 |
|
|
friend_args_type = TYPE_ARG_TYPES (friend_type);
|
1089 |
|
|
decl_args_type = TYPE_ARG_TYPES (decl_type);
|
1090 |
|
|
if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend))
|
1091 |
|
|
friend_args_type = TREE_CHAIN (friend_args_type);
|
1092 |
|
|
if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
|
1093 |
|
|
decl_args_type = TREE_CHAIN (decl_args_type);
|
1094 |
|
|
|
1095 |
|
|
return compparms (decl_args_type, friend_args_type);
|
1096 |
|
|
}
|
1097 |
|
|
else
|
1098 |
|
|
{
|
1099 |
|
|
/* DECL is a TYPE_DECL */
|
1100 |
|
|
bool is_template;
|
1101 |
|
|
tree decl_type = TREE_TYPE (decl);
|
1102 |
|
|
|
1103 |
|
|
/* Make sure that both DECL and FRIEND are templates or
|
1104 |
|
|
non-templates. */
|
1105 |
|
|
is_template
|
1106 |
|
|
= CLASSTYPE_TEMPLATE_INFO (decl_type)
|
1107 |
|
|
&& PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type));
|
1108 |
|
|
|
1109 |
|
|
if (need_template ^ is_template)
|
1110 |
|
|
return false;
|
1111 |
|
|
else if (is_template)
|
1112 |
|
|
{
|
1113 |
|
|
tree friend_parms;
|
1114 |
|
|
/* If both are templates, check the name of the two
|
1115 |
|
|
TEMPLATE_DECL's first because is_friend didn't. */
|
1116 |
|
|
if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type))
|
1117 |
|
|
!= DECL_NAME (friend))
|
1118 |
|
|
return false;
|
1119 |
|
|
|
1120 |
|
|
/* Now check template parameter list. */
|
1121 |
|
|
friend_parms
|
1122 |
|
|
= tsubst_template_parms (DECL_TEMPLATE_PARMS (friend),
|
1123 |
|
|
args, tf_none);
|
1124 |
|
|
return comp_template_parms
|
1125 |
|
|
(DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type)),
|
1126 |
|
|
friend_parms);
|
1127 |
|
|
}
|
1128 |
|
|
else
|
1129 |
|
|
return (DECL_NAME (decl)
|
1130 |
|
|
== DECL_NAME (friend));
|
1131 |
|
|
}
|
1132 |
|
|
}
|
1133 |
|
|
return false;
|
1134 |
|
|
}
|
1135 |
|
|
|
1136 |
|
|
/* Register the specialization SPEC as a specialization of TMPL with
|
1137 |
|
|
the indicated ARGS. IS_FRIEND indicates whether the specialization
|
1138 |
|
|
is actually just a friend declaration. Returns SPEC, or an
|
1139 |
|
|
equivalent prior declaration, if available. */
|
1140 |
|
|
|
1141 |
|
|
static tree
|
1142 |
|
|
register_specialization (tree spec, tree tmpl, tree args, bool is_friend)
|
1143 |
|
|
{
|
1144 |
|
|
tree fn;
|
1145 |
|
|
|
1146 |
|
|
gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
|
1147 |
|
|
|
1148 |
|
|
if (TREE_CODE (spec) == FUNCTION_DECL
|
1149 |
|
|
&& uses_template_parms (DECL_TI_ARGS (spec)))
|
1150 |
|
|
/* This is the FUNCTION_DECL for a partial instantiation. Don't
|
1151 |
|
|
register it; we want the corresponding TEMPLATE_DECL instead.
|
1152 |
|
|
We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
|
1153 |
|
|
the more obvious `uses_template_parms (spec)' to avoid problems
|
1154 |
|
|
with default function arguments. In particular, given
|
1155 |
|
|
something like this:
|
1156 |
|
|
|
1157 |
|
|
template <class T> void f(T t1, T t = T())
|
1158 |
|
|
|
1159 |
|
|
the default argument expression is not substituted for in an
|
1160 |
|
|
instantiation unless and until it is actually needed. */
|
1161 |
|
|
return spec;
|
1162 |
|
|
|
1163 |
|
|
fn = retrieve_specialization (tmpl, args,
|
1164 |
|
|
/*class_specializations_p=*/false);
|
1165 |
|
|
/* We can sometimes try to re-register a specialization that we've
|
1166 |
|
|
already got. In particular, regenerate_decl_from_template calls
|
1167 |
|
|
duplicate_decls which will update the specialization list. But,
|
1168 |
|
|
we'll still get called again here anyhow. It's more convenient
|
1169 |
|
|
to simply allow this than to try to prevent it. */
|
1170 |
|
|
if (fn == spec)
|
1171 |
|
|
return spec;
|
1172 |
|
|
else if (fn && DECL_TEMPLATE_SPECIALIZATION (spec))
|
1173 |
|
|
{
|
1174 |
|
|
if (DECL_TEMPLATE_INSTANTIATION (fn))
|
1175 |
|
|
{
|
1176 |
|
|
if (TREE_USED (fn)
|
1177 |
|
|
|| DECL_EXPLICIT_INSTANTIATION (fn))
|
1178 |
|
|
{
|
1179 |
|
|
error ("specialization of %qD after instantiation",
|
1180 |
|
|
fn);
|
1181 |
|
|
return spec;
|
1182 |
|
|
}
|
1183 |
|
|
else
|
1184 |
|
|
{
|
1185 |
|
|
tree clone;
|
1186 |
|
|
/* This situation should occur only if the first
|
1187 |
|
|
specialization is an implicit instantiation, the
|
1188 |
|
|
second is an explicit specialization, and the
|
1189 |
|
|
implicit instantiation has not yet been used. That
|
1190 |
|
|
situation can occur if we have implicitly
|
1191 |
|
|
instantiated a member function and then specialized
|
1192 |
|
|
it later.
|
1193 |
|
|
|
1194 |
|
|
We can also wind up here if a friend declaration that
|
1195 |
|
|
looked like an instantiation turns out to be a
|
1196 |
|
|
specialization:
|
1197 |
|
|
|
1198 |
|
|
template <class T> void foo(T);
|
1199 |
|
|
class S { friend void foo<>(int) };
|
1200 |
|
|
template <> void foo(int);
|
1201 |
|
|
|
1202 |
|
|
We transform the existing DECL in place so that any
|
1203 |
|
|
pointers to it become pointers to the updated
|
1204 |
|
|
declaration.
|
1205 |
|
|
|
1206 |
|
|
If there was a definition for the template, but not
|
1207 |
|
|
for the specialization, we want this to look as if
|
1208 |
|
|
there were no definition, and vice versa. */
|
1209 |
|
|
DECL_INITIAL (fn) = NULL_TREE;
|
1210 |
|
|
duplicate_decls (spec, fn, is_friend);
|
1211 |
|
|
/* The call to duplicate_decls will have applied
|
1212 |
|
|
[temp.expl.spec]:
|
1213 |
|
|
|
1214 |
|
|
An explicit specialization of a function template
|
1215 |
|
|
is inline only if it is explicitly declared to be,
|
1216 |
|
|
and independently of whether its function tempalte
|
1217 |
|
|
is.
|
1218 |
|
|
|
1219 |
|
|
to the primary function; now copy the inline bits to
|
1220 |
|
|
the various clones. */
|
1221 |
|
|
FOR_EACH_CLONE (clone, fn)
|
1222 |
|
|
{
|
1223 |
|
|
DECL_DECLARED_INLINE_P (clone)
|
1224 |
|
|
= DECL_DECLARED_INLINE_P (fn);
|
1225 |
|
|
DECL_INLINE (clone)
|
1226 |
|
|
= DECL_INLINE (fn);
|
1227 |
|
|
}
|
1228 |
|
|
check_specialization_namespace (fn);
|
1229 |
|
|
|
1230 |
|
|
return fn;
|
1231 |
|
|
}
|
1232 |
|
|
}
|
1233 |
|
|
else if (DECL_TEMPLATE_SPECIALIZATION (fn))
|
1234 |
|
|
{
|
1235 |
|
|
if (!duplicate_decls (spec, fn, is_friend) && DECL_INITIAL (spec))
|
1236 |
|
|
/* Dup decl failed, but this is a new definition. Set the
|
1237 |
|
|
line number so any errors match this new
|
1238 |
|
|
definition. */
|
1239 |
|
|
DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (spec);
|
1240 |
|
|
|
1241 |
|
|
return fn;
|
1242 |
|
|
}
|
1243 |
|
|
}
|
1244 |
|
|
|
1245 |
|
|
/* A specialization must be declared in the same namespace as the
|
1246 |
|
|
template it is specializing. */
|
1247 |
|
|
if (DECL_TEMPLATE_SPECIALIZATION (spec)
|
1248 |
|
|
&& !check_specialization_namespace (tmpl))
|
1249 |
|
|
DECL_CONTEXT (spec) = decl_namespace_context (tmpl);
|
1250 |
|
|
|
1251 |
|
|
if (!optimize_specialization_lookup_p (tmpl))
|
1252 |
|
|
DECL_TEMPLATE_SPECIALIZATIONS (tmpl)
|
1253 |
|
|
= tree_cons (args, spec, DECL_TEMPLATE_SPECIALIZATIONS (tmpl));
|
1254 |
|
|
|
1255 |
|
|
return spec;
|
1256 |
|
|
}
|
1257 |
|
|
|
1258 |
|
|
/* Unregister the specialization SPEC as a specialization of TMPL.
|
1259 |
|
|
Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
|
1260 |
|
|
if the SPEC was listed as a specialization of TMPL. */
|
1261 |
|
|
|
1262 |
|
|
bool
|
1263 |
|
|
reregister_specialization (tree spec, tree tmpl, tree new_spec)
|
1264 |
|
|
{
|
1265 |
|
|
tree* s;
|
1266 |
|
|
|
1267 |
|
|
for (s = &DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
|
1268 |
|
|
*s != NULL_TREE;
|
1269 |
|
|
s = &TREE_CHAIN (*s))
|
1270 |
|
|
if (TREE_VALUE (*s) == spec)
|
1271 |
|
|
{
|
1272 |
|
|
if (!new_spec)
|
1273 |
|
|
*s = TREE_CHAIN (*s);
|
1274 |
|
|
else
|
1275 |
|
|
TREE_VALUE (*s) = new_spec;
|
1276 |
|
|
return 1;
|
1277 |
|
|
}
|
1278 |
|
|
|
1279 |
|
|
return 0;
|
1280 |
|
|
}
|
1281 |
|
|
|
1282 |
|
|
/* Compare an entry in the local specializations hash table P1 (which
|
1283 |
|
|
is really a pointer to a TREE_LIST) with P2 (which is really a
|
1284 |
|
|
DECL). */
|
1285 |
|
|
|
1286 |
|
|
static int
|
1287 |
|
|
eq_local_specializations (const void *p1, const void *p2)
|
1288 |
|
|
{
|
1289 |
|
|
return TREE_VALUE ((tree) p1) == (tree) p2;
|
1290 |
|
|
}
|
1291 |
|
|
|
1292 |
|
|
/* Hash P1, an entry in the local specializations table. */
|
1293 |
|
|
|
1294 |
|
|
static hashval_t
|
1295 |
|
|
hash_local_specialization (const void* p1)
|
1296 |
|
|
{
|
1297 |
|
|
return htab_hash_pointer (TREE_VALUE ((tree) p1));
|
1298 |
|
|
}
|
1299 |
|
|
|
1300 |
|
|
/* Like register_specialization, but for local declarations. We are
|
1301 |
|
|
registering SPEC, an instantiation of TMPL. */
|
1302 |
|
|
|
1303 |
|
|
static void
|
1304 |
|
|
register_local_specialization (tree spec, tree tmpl)
|
1305 |
|
|
{
|
1306 |
|
|
void **slot;
|
1307 |
|
|
|
1308 |
|
|
slot = htab_find_slot_with_hash (local_specializations, tmpl,
|
1309 |
|
|
htab_hash_pointer (tmpl), INSERT);
|
1310 |
|
|
*slot = build_tree_list (spec, tmpl);
|
1311 |
|
|
}
|
1312 |
|
|
|
1313 |
|
|
/* Print the list of candidate FNS in an error message. */
|
1314 |
|
|
|
1315 |
|
|
void
|
1316 |
|
|
print_candidates (tree fns)
|
1317 |
|
|
{
|
1318 |
|
|
tree fn;
|
1319 |
|
|
|
1320 |
|
|
const char *str = "candidates are:";
|
1321 |
|
|
|
1322 |
|
|
for (fn = fns; fn != NULL_TREE; fn = TREE_CHAIN (fn))
|
1323 |
|
|
{
|
1324 |
|
|
tree f;
|
1325 |
|
|
|
1326 |
|
|
for (f = TREE_VALUE (fn); f; f = OVL_NEXT (f))
|
1327 |
|
|
error ("%s %+#D", str, OVL_CURRENT (f));
|
1328 |
|
|
str = " ";
|
1329 |
|
|
}
|
1330 |
|
|
}
|
1331 |
|
|
|
1332 |
|
|
/* Returns the template (one of the functions given by TEMPLATE_ID)
|
1333 |
|
|
which can be specialized to match the indicated DECL with the
|
1334 |
|
|
explicit template args given in TEMPLATE_ID. The DECL may be
|
1335 |
|
|
NULL_TREE if none is available. In that case, the functions in
|
1336 |
|
|
TEMPLATE_ID are non-members.
|
1337 |
|
|
|
1338 |
|
|
If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
|
1339 |
|
|
specialization of a member template.
|
1340 |
|
|
|
1341 |
|
|
The TEMPLATE_COUNT is the number of references to qualifying
|
1342 |
|
|
template classes that appeared in the name of the function. See
|
1343 |
|
|
check_explicit_specialization for a more accurate description.
|
1344 |
|
|
|
1345 |
|
|
The template args (those explicitly specified and those deduced)
|
1346 |
|
|
are output in a newly created vector *TARGS_OUT.
|
1347 |
|
|
|
1348 |
|
|
If it is impossible to determine the result, an error message is
|
1349 |
|
|
issued. The error_mark_node is returned to indicate failure. */
|
1350 |
|
|
|
1351 |
|
|
static tree
|
1352 |
|
|
determine_specialization (tree template_id,
|
1353 |
|
|
tree decl,
|
1354 |
|
|
tree* targs_out,
|
1355 |
|
|
int need_member_template,
|
1356 |
|
|
int template_count)
|
1357 |
|
|
{
|
1358 |
|
|
tree fns;
|
1359 |
|
|
tree targs;
|
1360 |
|
|
tree explicit_targs;
|
1361 |
|
|
tree candidates = NULL_TREE;
|
1362 |
|
|
tree templates = NULL_TREE;
|
1363 |
|
|
int header_count;
|
1364 |
|
|
struct cp_binding_level *b;
|
1365 |
|
|
|
1366 |
|
|
*targs_out = NULL_TREE;
|
1367 |
|
|
|
1368 |
|
|
if (template_id == error_mark_node)
|
1369 |
|
|
return error_mark_node;
|
1370 |
|
|
|
1371 |
|
|
fns = TREE_OPERAND (template_id, 0);
|
1372 |
|
|
explicit_targs = TREE_OPERAND (template_id, 1);
|
1373 |
|
|
|
1374 |
|
|
if (fns == error_mark_node)
|
1375 |
|
|
return error_mark_node;
|
1376 |
|
|
|
1377 |
|
|
/* Check for baselinks. */
|
1378 |
|
|
if (BASELINK_P (fns))
|
1379 |
|
|
fns = BASELINK_FUNCTIONS (fns);
|
1380 |
|
|
|
1381 |
|
|
if (!is_overloaded_fn (fns))
|
1382 |
|
|
{
|
1383 |
|
|
error ("%qD is not a function template", fns);
|
1384 |
|
|
return error_mark_node;
|
1385 |
|
|
}
|
1386 |
|
|
|
1387 |
|
|
/* Count the number of template headers specified for this
|
1388 |
|
|
specialization. */
|
1389 |
|
|
header_count = 0;
|
1390 |
|
|
for (b = current_binding_level;
|
1391 |
|
|
b->kind == sk_template_parms;
|
1392 |
|
|
b = b->level_chain)
|
1393 |
|
|
++header_count;
|
1394 |
|
|
|
1395 |
|
|
for (; fns; fns = OVL_NEXT (fns))
|
1396 |
|
|
{
|
1397 |
|
|
tree fn = OVL_CURRENT (fns);
|
1398 |
|
|
|
1399 |
|
|
if (TREE_CODE (fn) == TEMPLATE_DECL)
|
1400 |
|
|
{
|
1401 |
|
|
tree decl_arg_types;
|
1402 |
|
|
tree fn_arg_types;
|
1403 |
|
|
|
1404 |
|
|
/* DECL might be a specialization of FN. */
|
1405 |
|
|
|
1406 |
|
|
/* Adjust the type of DECL in case FN is a static member. */
|
1407 |
|
|
decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
|
1408 |
|
|
if (DECL_STATIC_FUNCTION_P (fn)
|
1409 |
|
|
&& DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
|
1410 |
|
|
decl_arg_types = TREE_CHAIN (decl_arg_types);
|
1411 |
|
|
|
1412 |
|
|
/* Check that the number of function parameters matches.
|
1413 |
|
|
For example,
|
1414 |
|
|
template <class T> void f(int i = 0);
|
1415 |
|
|
template <> void f<int>();
|
1416 |
|
|
The specialization f<int> is invalid but is not caught
|
1417 |
|
|
by get_bindings below. */
|
1418 |
|
|
|
1419 |
|
|
fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
|
1420 |
|
|
if (list_length (fn_arg_types) != list_length (decl_arg_types))
|
1421 |
|
|
continue;
|
1422 |
|
|
|
1423 |
|
|
/* For a non-static member function, we need to make sure that
|
1424 |
|
|
the const qualification is the same. This can be done by
|
1425 |
|
|
checking the 'this' in the argument list. */
|
1426 |
|
|
if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
|
1427 |
|
|
&& !same_type_p (TREE_VALUE (fn_arg_types),
|
1428 |
|
|
TREE_VALUE (decl_arg_types)))
|
1429 |
|
|
continue;
|
1430 |
|
|
|
1431 |
|
|
/* In case of explicit specialization, we need to check if
|
1432 |
|
|
the number of template headers appearing in the specialization
|
1433 |
|
|
is correct. This is usually done in check_explicit_specialization,
|
1434 |
|
|
but the check done there cannot be exhaustive when specializing
|
1435 |
|
|
member functions. Consider the following code:
|
1436 |
|
|
|
1437 |
|
|
template <> void A<int>::f(int);
|
1438 |
|
|
template <> template <> void A<int>::f(int);
|
1439 |
|
|
|
1440 |
|
|
Assuming that A<int> is not itself an explicit specialization
|
1441 |
|
|
already, the first line specializes "f" which is a non-template
|
1442 |
|
|
member function, whilst the second line specializes "f" which
|
1443 |
|
|
is a template member function. So both lines are syntactically
|
1444 |
|
|
correct, and check_explicit_specialization does not reject
|
1445 |
|
|
them.
|
1446 |
|
|
|
1447 |
|
|
Here, we can do better, as we are matching the specialization
|
1448 |
|
|
against the declarations. We count the number of template
|
1449 |
|
|
headers, and we check if they match TEMPLATE_COUNT + 1
|
1450 |
|
|
(TEMPLATE_COUNT is the number of qualifying template classes,
|
1451 |
|
|
plus there must be another header for the member template
|
1452 |
|
|
itself).
|
1453 |
|
|
|
1454 |
|
|
Notice that if header_count is zero, this is not a
|
1455 |
|
|
specialization but rather a template instantiation, so there
|
1456 |
|
|
is no check we can perform here. */
|
1457 |
|
|
if (header_count && header_count != template_count + 1)
|
1458 |
|
|
continue;
|
1459 |
|
|
|
1460 |
|
|
/* Check that the number of template arguments at the
|
1461 |
|
|
innermost level for DECL is the same as for FN. */
|
1462 |
|
|
if (current_binding_level->kind == sk_template_parms
|
1463 |
|
|
&& !current_binding_level->explicit_spec_p
|
1464 |
|
|
&& (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn))
|
1465 |
|
|
!= TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
|
1466 |
|
|
(current_template_parms))))
|
1467 |
|
|
continue;
|
1468 |
|
|
|
1469 |
|
|
/* See whether this function might be a specialization of this
|
1470 |
|
|
template. */
|
1471 |
|
|
targs = get_bindings (fn, decl, explicit_targs, /*check_ret=*/true);
|
1472 |
|
|
|
1473 |
|
|
if (!targs)
|
1474 |
|
|
/* We cannot deduce template arguments that when used to
|
1475 |
|
|
specialize TMPL will produce DECL. */
|
1476 |
|
|
continue;
|
1477 |
|
|
|
1478 |
|
|
/* Save this template, and the arguments deduced. */
|
1479 |
|
|
templates = tree_cons (targs, fn, templates);
|
1480 |
|
|
}
|
1481 |
|
|
else if (need_member_template)
|
1482 |
|
|
/* FN is an ordinary member function, and we need a
|
1483 |
|
|
specialization of a member template. */
|
1484 |
|
|
;
|
1485 |
|
|
else if (TREE_CODE (fn) != FUNCTION_DECL)
|
1486 |
|
|
/* We can get IDENTIFIER_NODEs here in certain erroneous
|
1487 |
|
|
cases. */
|
1488 |
|
|
;
|
1489 |
|
|
else if (!DECL_FUNCTION_MEMBER_P (fn))
|
1490 |
|
|
/* This is just an ordinary non-member function. Nothing can
|
1491 |
|
|
be a specialization of that. */
|
1492 |
|
|
;
|
1493 |
|
|
else if (DECL_ARTIFICIAL (fn))
|
1494 |
|
|
/* Cannot specialize functions that are created implicitly. */
|
1495 |
|
|
;
|
1496 |
|
|
else
|
1497 |
|
|
{
|
1498 |
|
|
tree decl_arg_types;
|
1499 |
|
|
|
1500 |
|
|
/* This is an ordinary member function. However, since
|
1501 |
|
|
we're here, we can assume it's enclosing class is a
|
1502 |
|
|
template class. For example,
|
1503 |
|
|
|
1504 |
|
|
template <typename T> struct S { void f(); };
|
1505 |
|
|
template <> void S<int>::f() {}
|
1506 |
|
|
|
1507 |
|
|
Here, S<int>::f is a non-template, but S<int> is a
|
1508 |
|
|
template class. If FN has the same type as DECL, we
|
1509 |
|
|
might be in business. */
|
1510 |
|
|
|
1511 |
|
|
if (!DECL_TEMPLATE_INFO (fn))
|
1512 |
|
|
/* Its enclosing class is an explicit specialization
|
1513 |
|
|
of a template class. This is not a candidate. */
|
1514 |
|
|
continue;
|
1515 |
|
|
|
1516 |
|
|
if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
|
1517 |
|
|
TREE_TYPE (TREE_TYPE (fn))))
|
1518 |
|
|
/* The return types differ. */
|
1519 |
|
|
continue;
|
1520 |
|
|
|
1521 |
|
|
/* Adjust the type of DECL in case FN is a static member. */
|
1522 |
|
|
decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
|
1523 |
|
|
if (DECL_STATIC_FUNCTION_P (fn)
|
1524 |
|
|
&& DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
|
1525 |
|
|
decl_arg_types = TREE_CHAIN (decl_arg_types);
|
1526 |
|
|
|
1527 |
|
|
if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
|
1528 |
|
|
decl_arg_types))
|
1529 |
|
|
/* They match! */
|
1530 |
|
|
candidates = tree_cons (NULL_TREE, fn, candidates);
|
1531 |
|
|
}
|
1532 |
|
|
}
|
1533 |
|
|
|
1534 |
|
|
if (templates && TREE_CHAIN (templates))
|
1535 |
|
|
{
|
1536 |
|
|
/* We have:
|
1537 |
|
|
|
1538 |
|
|
[temp.expl.spec]
|
1539 |
|
|
|
1540 |
|
|
It is possible for a specialization with a given function
|
1541 |
|
|
signature to be instantiated from more than one function
|
1542 |
|
|
template. In such cases, explicit specification of the
|
1543 |
|
|
template arguments must be used to uniquely identify the
|
1544 |
|
|
function template specialization being specialized.
|
1545 |
|
|
|
1546 |
|
|
Note that here, there's no suggestion that we're supposed to
|
1547 |
|
|
determine which of the candidate templates is most
|
1548 |
|
|
specialized. However, we, also have:
|
1549 |
|
|
|
1550 |
|
|
[temp.func.order]
|
1551 |
|
|
|
1552 |
|
|
Partial ordering of overloaded function template
|
1553 |
|
|
declarations is used in the following contexts to select
|
1554 |
|
|
the function template to which a function template
|
1555 |
|
|
specialization refers:
|
1556 |
|
|
|
1557 |
|
|
-- when an explicit specialization refers to a function
|
1558 |
|
|
template.
|
1559 |
|
|
|
1560 |
|
|
So, we do use the partial ordering rules, at least for now.
|
1561 |
|
|
This extension can only serve to make invalid programs valid,
|
1562 |
|
|
so it's safe. And, there is strong anecdotal evidence that
|
1563 |
|
|
the committee intended the partial ordering rules to apply;
|
1564 |
|
|
the EDG front-end has that behavior, and John Spicer claims
|
1565 |
|
|
that the committee simply forgot to delete the wording in
|
1566 |
|
|
[temp.expl.spec]. */
|
1567 |
|
|
tree tmpl = most_specialized (templates, decl, explicit_targs);
|
1568 |
|
|
if (tmpl && tmpl != error_mark_node)
|
1569 |
|
|
{
|
1570 |
|
|
targs = get_bindings (tmpl, decl, explicit_targs, /*check_ret=*/true);
|
1571 |
|
|
templates = tree_cons (targs, tmpl, NULL_TREE);
|
1572 |
|
|
}
|
1573 |
|
|
}
|
1574 |
|
|
|
1575 |
|
|
if (templates == NULL_TREE && candidates == NULL_TREE)
|
1576 |
|
|
{
|
1577 |
|
|
error ("template-id %qD for %q+D does not match any template "
|
1578 |
|
|
"declaration", template_id, decl);
|
1579 |
|
|
return error_mark_node;
|
1580 |
|
|
}
|
1581 |
|
|
else if ((templates && TREE_CHAIN (templates))
|
1582 |
|
|
|| (candidates && TREE_CHAIN (candidates))
|
1583 |
|
|
|| (templates && candidates))
|
1584 |
|
|
{
|
1585 |
|
|
error ("ambiguous template specialization %qD for %q+D",
|
1586 |
|
|
template_id, decl);
|
1587 |
|
|
chainon (candidates, templates);
|
1588 |
|
|
print_candidates (candidates);
|
1589 |
|
|
return error_mark_node;
|
1590 |
|
|
}
|
1591 |
|
|
|
1592 |
|
|
/* We have one, and exactly one, match. */
|
1593 |
|
|
if (candidates)
|
1594 |
|
|
{
|
1595 |
|
|
/* It was a specialization of an ordinary member function in a
|
1596 |
|
|
template class. */
|
1597 |
|
|
*targs_out = copy_node (DECL_TI_ARGS (TREE_VALUE (candidates)));
|
1598 |
|
|
return DECL_TI_TEMPLATE (TREE_VALUE (candidates));
|
1599 |
|
|
}
|
1600 |
|
|
|
1601 |
|
|
/* It was a specialization of a template. */
|
1602 |
|
|
targs = DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates)));
|
1603 |
|
|
if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs))
|
1604 |
|
|
{
|
1605 |
|
|
*targs_out = copy_node (targs);
|
1606 |
|
|
SET_TMPL_ARGS_LEVEL (*targs_out,
|
1607 |
|
|
TMPL_ARGS_DEPTH (*targs_out),
|
1608 |
|
|
TREE_PURPOSE (templates));
|
1609 |
|
|
}
|
1610 |
|
|
else
|
1611 |
|
|
*targs_out = TREE_PURPOSE (templates);
|
1612 |
|
|
return TREE_VALUE (templates);
|
1613 |
|
|
}
|
1614 |
|
|
|
1615 |
|
|
/* Returns a chain of parameter types, exactly like the SPEC_TYPES,
|
1616 |
|
|
but with the default argument values filled in from those in the
|
1617 |
|
|
TMPL_TYPES. */
|
1618 |
|
|
|
1619 |
|
|
static tree
|
1620 |
|
|
copy_default_args_to_explicit_spec_1 (tree spec_types,
|
1621 |
|
|
tree tmpl_types)
|
1622 |
|
|
{
|
1623 |
|
|
tree new_spec_types;
|
1624 |
|
|
|
1625 |
|
|
if (!spec_types)
|
1626 |
|
|
return NULL_TREE;
|
1627 |
|
|
|
1628 |
|
|
if (spec_types == void_list_node)
|
1629 |
|
|
return void_list_node;
|
1630 |
|
|
|
1631 |
|
|
/* Substitute into the rest of the list. */
|
1632 |
|
|
new_spec_types =
|
1633 |
|
|
copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types),
|
1634 |
|
|
TREE_CHAIN (tmpl_types));
|
1635 |
|
|
|
1636 |
|
|
/* Add the default argument for this parameter. */
|
1637 |
|
|
return hash_tree_cons (TREE_PURPOSE (tmpl_types),
|
1638 |
|
|
TREE_VALUE (spec_types),
|
1639 |
|
|
new_spec_types);
|
1640 |
|
|
}
|
1641 |
|
|
|
1642 |
|
|
/* DECL is an explicit specialization. Replicate default arguments
|
1643 |
|
|
from the template it specializes. (That way, code like:
|
1644 |
|
|
|
1645 |
|
|
template <class T> void f(T = 3);
|
1646 |
|
|
template <> void f(double);
|
1647 |
|
|
void g () { f (); }
|
1648 |
|
|
|
1649 |
|
|
works, as required.) An alternative approach would be to look up
|
1650 |
|
|
the correct default arguments at the call-site, but this approach
|
1651 |
|
|
is consistent with how implicit instantiations are handled. */
|
1652 |
|
|
|
1653 |
|
|
static void
|
1654 |
|
|
copy_default_args_to_explicit_spec (tree decl)
|
1655 |
|
|
{
|
1656 |
|
|
tree tmpl;
|
1657 |
|
|
tree spec_types;
|
1658 |
|
|
tree tmpl_types;
|
1659 |
|
|
tree new_spec_types;
|
1660 |
|
|
tree old_type;
|
1661 |
|
|
tree new_type;
|
1662 |
|
|
tree t;
|
1663 |
|
|
tree object_type = NULL_TREE;
|
1664 |
|
|
tree in_charge = NULL_TREE;
|
1665 |
|
|
tree vtt = NULL_TREE;
|
1666 |
|
|
|
1667 |
|
|
/* See if there's anything we need to do. */
|
1668 |
|
|
tmpl = DECL_TI_TEMPLATE (decl);
|
1669 |
|
|
tmpl_types = TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl)));
|
1670 |
|
|
for (t = tmpl_types; t; t = TREE_CHAIN (t))
|
1671 |
|
|
if (TREE_PURPOSE (t))
|
1672 |
|
|
break;
|
1673 |
|
|
if (!t)
|
1674 |
|
|
return;
|
1675 |
|
|
|
1676 |
|
|
old_type = TREE_TYPE (decl);
|
1677 |
|
|
spec_types = TYPE_ARG_TYPES (old_type);
|
1678 |
|
|
|
1679 |
|
|
if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
|
1680 |
|
|
{
|
1681 |
|
|
/* Remove the this pointer, but remember the object's type for
|
1682 |
|
|
CV quals. */
|
1683 |
|
|
object_type = TREE_TYPE (TREE_VALUE (spec_types));
|
1684 |
|
|
spec_types = TREE_CHAIN (spec_types);
|
1685 |
|
|
tmpl_types = TREE_CHAIN (tmpl_types);
|
1686 |
|
|
|
1687 |
|
|
if (DECL_HAS_IN_CHARGE_PARM_P (decl))
|
1688 |
|
|
{
|
1689 |
|
|
/* DECL may contain more parameters than TMPL due to the extra
|
1690 |
|
|
in-charge parameter in constructors and destructors. */
|
1691 |
|
|
in_charge = spec_types;
|
1692 |
|
|
spec_types = TREE_CHAIN (spec_types);
|
1693 |
|
|
}
|
1694 |
|
|
if (DECL_HAS_VTT_PARM_P (decl))
|
1695 |
|
|
{
|
1696 |
|
|
vtt = spec_types;
|
1697 |
|
|
spec_types = TREE_CHAIN (spec_types);
|
1698 |
|
|
}
|
1699 |
|
|
}
|
1700 |
|
|
|
1701 |
|
|
/* Compute the merged default arguments. */
|
1702 |
|
|
new_spec_types =
|
1703 |
|
|
copy_default_args_to_explicit_spec_1 (spec_types, tmpl_types);
|
1704 |
|
|
|
1705 |
|
|
/* Compute the new FUNCTION_TYPE. */
|
1706 |
|
|
if (object_type)
|
1707 |
|
|
{
|
1708 |
|
|
if (vtt)
|
1709 |
|
|
new_spec_types = hash_tree_cons (TREE_PURPOSE (vtt),
|
1710 |
|
|
TREE_VALUE (vtt),
|
1711 |
|
|
new_spec_types);
|
1712 |
|
|
|
1713 |
|
|
if (in_charge)
|
1714 |
|
|
/* Put the in-charge parameter back. */
|
1715 |
|
|
new_spec_types = hash_tree_cons (TREE_PURPOSE (in_charge),
|
1716 |
|
|
TREE_VALUE (in_charge),
|
1717 |
|
|
new_spec_types);
|
1718 |
|
|
|
1719 |
|
|
new_type = build_method_type_directly (object_type,
|
1720 |
|
|
TREE_TYPE (old_type),
|
1721 |
|
|
new_spec_types);
|
1722 |
|
|
}
|
1723 |
|
|
else
|
1724 |
|
|
new_type = build_function_type (TREE_TYPE (old_type),
|
1725 |
|
|
new_spec_types);
|
1726 |
|
|
new_type = cp_build_type_attribute_variant (new_type,
|
1727 |
|
|
TYPE_ATTRIBUTES (old_type));
|
1728 |
|
|
new_type = build_exception_variant (new_type,
|
1729 |
|
|
TYPE_RAISES_EXCEPTIONS (old_type));
|
1730 |
|
|
TREE_TYPE (decl) = new_type;
|
1731 |
|
|
}
|
1732 |
|
|
|
1733 |
|
|
/* Check to see if the function just declared, as indicated in
|
1734 |
|
|
DECLARATOR, and in DECL, is a specialization of a function
|
1735 |
|
|
template. We may also discover that the declaration is an explicit
|
1736 |
|
|
instantiation at this point.
|
1737 |
|
|
|
1738 |
|
|
Returns DECL, or an equivalent declaration that should be used
|
1739 |
|
|
instead if all goes well. Issues an error message if something is
|
1740 |
|
|
amiss. Returns error_mark_node if the error is not easily
|
1741 |
|
|
recoverable.
|
1742 |
|
|
|
1743 |
|
|
FLAGS is a bitmask consisting of the following flags:
|
1744 |
|
|
|
1745 |
|
|
2: The function has a definition.
|
1746 |
|
|
4: The function is a friend.
|
1747 |
|
|
|
1748 |
|
|
The TEMPLATE_COUNT is the number of references to qualifying
|
1749 |
|
|
template classes that appeared in the name of the function. For
|
1750 |
|
|
example, in
|
1751 |
|
|
|
1752 |
|
|
template <class T> struct S { void f(); };
|
1753 |
|
|
void S<int>::f();
|
1754 |
|
|
|
1755 |
|
|
the TEMPLATE_COUNT would be 1. However, explicitly specialized
|
1756 |
|
|
classes are not counted in the TEMPLATE_COUNT, so that in
|
1757 |
|
|
|
1758 |
|
|
template <class T> struct S {};
|
1759 |
|
|
template <> struct S<int> { void f(); }
|
1760 |
|
|
template <> void S<int>::f();
|
1761 |
|
|
|
1762 |
|
|
the TEMPLATE_COUNT would be 0. (Note that this declaration is
|
1763 |
|
|
invalid; there should be no template <>.)
|
1764 |
|
|
|
1765 |
|
|
If the function is a specialization, it is marked as such via
|
1766 |
|
|
DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
|
1767 |
|
|
is set up correctly, and it is added to the list of specializations
|
1768 |
|
|
for that template. */
|
1769 |
|
|
|
1770 |
|
|
tree
|
1771 |
|
|
check_explicit_specialization (tree declarator,
|
1772 |
|
|
tree decl,
|
1773 |
|
|
int template_count,
|
1774 |
|
|
int flags)
|
1775 |
|
|
{
|
1776 |
|
|
int have_def = flags & 2;
|
1777 |
|
|
int is_friend = flags & 4;
|
1778 |
|
|
int specialization = 0;
|
1779 |
|
|
int explicit_instantiation = 0;
|
1780 |
|
|
int member_specialization = 0;
|
1781 |
|
|
tree ctype = DECL_CLASS_CONTEXT (decl);
|
1782 |
|
|
tree dname = DECL_NAME (decl);
|
1783 |
|
|
tmpl_spec_kind tsk;
|
1784 |
|
|
|
1785 |
|
|
if (is_friend)
|
1786 |
|
|
{
|
1787 |
|
|
if (!processing_specialization)
|
1788 |
|
|
tsk = tsk_none;
|
1789 |
|
|
else
|
1790 |
|
|
tsk = tsk_excessive_parms;
|
1791 |
|
|
}
|
1792 |
|
|
else
|
1793 |
|
|
tsk = current_tmpl_spec_kind (template_count);
|
1794 |
|
|
|
1795 |
|
|
switch (tsk)
|
1796 |
|
|
{
|
1797 |
|
|
case tsk_none:
|
1798 |
|
|
if (processing_specialization)
|
1799 |
|
|
{
|
1800 |
|
|
specialization = 1;
|
1801 |
|
|
SET_DECL_TEMPLATE_SPECIALIZATION (decl);
|
1802 |
|
|
}
|
1803 |
|
|
else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
|
1804 |
|
|
{
|
1805 |
|
|
if (is_friend)
|
1806 |
|
|
/* This could be something like:
|
1807 |
|
|
|
1808 |
|
|
template <class T> void f(T);
|
1809 |
|
|
class S { friend void f<>(int); } */
|
1810 |
|
|
specialization = 1;
|
1811 |
|
|
else
|
1812 |
|
|
{
|
1813 |
|
|
/* This case handles bogus declarations like template <>
|
1814 |
|
|
template <class T> void f<int>(); */
|
1815 |
|
|
|
1816 |
|
|
error ("template-id %qD in declaration of primary template",
|
1817 |
|
|
declarator);
|
1818 |
|
|
return decl;
|
1819 |
|
|
}
|
1820 |
|
|
}
|
1821 |
|
|
break;
|
1822 |
|
|
|
1823 |
|
|
case tsk_invalid_member_spec:
|
1824 |
|
|
/* The error has already been reported in
|
1825 |
|
|
check_specialization_scope. */
|
1826 |
|
|
return error_mark_node;
|
1827 |
|
|
|
1828 |
|
|
case tsk_invalid_expl_inst:
|
1829 |
|
|
error ("template parameter list used in explicit instantiation");
|
1830 |
|
|
|
1831 |
|
|
/* Fall through. */
|
1832 |
|
|
|
1833 |
|
|
case tsk_expl_inst:
|
1834 |
|
|
if (have_def)
|
1835 |
|
|
error ("definition provided for explicit instantiation");
|
1836 |
|
|
|
1837 |
|
|
explicit_instantiation = 1;
|
1838 |
|
|
break;
|
1839 |
|
|
|
1840 |
|
|
case tsk_excessive_parms:
|
1841 |
|
|
case tsk_insufficient_parms:
|
1842 |
|
|
if (tsk == tsk_excessive_parms)
|
1843 |
|
|
error ("too many template parameter lists in declaration of %qD",
|
1844 |
|
|
decl);
|
1845 |
|
|
else if (template_header_count)
|
1846 |
|
|
error("too few template parameter lists in declaration of %qD", decl);
|
1847 |
|
|
else
|
1848 |
|
|
error("explicit specialization of %qD must be introduced by "
|
1849 |
|
|
"%<template <>%>", decl);
|
1850 |
|
|
|
1851 |
|
|
/* Fall through. */
|
1852 |
|
|
case tsk_expl_spec:
|
1853 |
|
|
SET_DECL_TEMPLATE_SPECIALIZATION (decl);
|
1854 |
|
|
if (ctype)
|
1855 |
|
|
member_specialization = 1;
|
1856 |
|
|
else
|
1857 |
|
|
specialization = 1;
|
1858 |
|
|
break;
|
1859 |
|
|
|
1860 |
|
|
case tsk_template:
|
1861 |
|
|
if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
|
1862 |
|
|
{
|
1863 |
|
|
/* This case handles bogus declarations like template <>
|
1864 |
|
|
template <class T> void f<int>(); */
|
1865 |
|
|
|
1866 |
|
|
if (uses_template_parms (declarator))
|
1867 |
|
|
error ("function template partial specialization %qD "
|
1868 |
|
|
"is not allowed", declarator);
|
1869 |
|
|
else
|
1870 |
|
|
error ("template-id %qD in declaration of primary template",
|
1871 |
|
|
declarator);
|
1872 |
|
|
return decl;
|
1873 |
|
|
}
|
1874 |
|
|
|
1875 |
|
|
if (ctype && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype))
|
1876 |
|
|
/* This is a specialization of a member template, without
|
1877 |
|
|
specialization the containing class. Something like:
|
1878 |
|
|
|
1879 |
|
|
template <class T> struct S {
|
1880 |
|
|
template <class U> void f (U);
|
1881 |
|
|
};
|
1882 |
|
|
template <> template <class U> void S<int>::f(U) {}
|
1883 |
|
|
|
1884 |
|
|
That's a specialization -- but of the entire template. */
|
1885 |
|
|
specialization = 1;
|
1886 |
|
|
break;
|
1887 |
|
|
|
1888 |
|
|
default:
|
1889 |
|
|
gcc_unreachable ();
|
1890 |
|
|
}
|
1891 |
|
|
|
1892 |
|
|
if (specialization || member_specialization)
|
1893 |
|
|
{
|
1894 |
|
|
tree t = TYPE_ARG_TYPES (TREE_TYPE (decl));
|
1895 |
|
|
for (; t; t = TREE_CHAIN (t))
|
1896 |
|
|
if (TREE_PURPOSE (t))
|
1897 |
|
|
{
|
1898 |
|
|
pedwarn
|
1899 |
|
|
("default argument specified in explicit specialization");
|
1900 |
|
|
break;
|
1901 |
|
|
}
|
1902 |
|
|
}
|
1903 |
|
|
|
1904 |
|
|
if (specialization || member_specialization || explicit_instantiation)
|
1905 |
|
|
{
|
1906 |
|
|
tree tmpl = NULL_TREE;
|
1907 |
|
|
tree targs = NULL_TREE;
|
1908 |
|
|
|
1909 |
|
|
/* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
|
1910 |
|
|
if (TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
|
1911 |
|
|
{
|
1912 |
|
|
tree fns;
|
1913 |
|
|
|
1914 |
|
|
gcc_assert (TREE_CODE (declarator) == IDENTIFIER_NODE);
|
1915 |
|
|
if (ctype)
|
1916 |
|
|
fns = dname;
|
1917 |
|
|
else
|
1918 |
|
|
{
|
1919 |
|
|
/* If there is no class context, the explicit instantiation
|
1920 |
|
|
must be at namespace scope. */
|
1921 |
|
|
gcc_assert (DECL_NAMESPACE_SCOPE_P (decl));
|
1922 |
|
|
|
1923 |
|
|
/* Find the namespace binding, using the declaration
|
1924 |
|
|
context. */
|
1925 |
|
|
fns = namespace_binding (dname, CP_DECL_CONTEXT (decl));
|
1926 |
|
|
if (!fns || !is_overloaded_fn (fns))
|
1927 |
|
|
{
|
1928 |
|
|
error ("%qD is not a template function", dname);
|
1929 |
|
|
fns = error_mark_node;
|
1930 |
|
|
}
|
1931 |
|
|
}
|
1932 |
|
|
|
1933 |
|
|
declarator = lookup_template_function (fns, NULL_TREE);
|
1934 |
|
|
}
|
1935 |
|
|
|
1936 |
|
|
if (declarator == error_mark_node)
|
1937 |
|
|
return error_mark_node;
|
1938 |
|
|
|
1939 |
|
|
if (ctype != NULL_TREE && TYPE_BEING_DEFINED (ctype))
|
1940 |
|
|
{
|
1941 |
|
|
if (!explicit_instantiation)
|
1942 |
|
|
/* A specialization in class scope. This is invalid,
|
1943 |
|
|
but the error will already have been flagged by
|
1944 |
|
|
check_specialization_scope. */
|
1945 |
|
|
return error_mark_node;
|
1946 |
|
|
else
|
1947 |
|
|
{
|
1948 |
|
|
/* It's not valid to write an explicit instantiation in
|
1949 |
|
|
class scope, e.g.:
|
1950 |
|
|
|
1951 |
|
|
class C { template void f(); }
|
1952 |
|
|
|
1953 |
|
|
This case is caught by the parser. However, on
|
1954 |
|
|
something like:
|
1955 |
|
|
|
1956 |
|
|
template class C { void f(); };
|
1957 |
|
|
|
1958 |
|
|
(which is invalid) we can get here. The error will be
|
1959 |
|
|
issued later. */
|
1960 |
|
|
;
|
1961 |
|
|
}
|
1962 |
|
|
|
1963 |
|
|
return decl;
|
1964 |
|
|
}
|
1965 |
|
|
else if (ctype != NULL_TREE
|
1966 |
|
|
&& (TREE_CODE (TREE_OPERAND (declarator, 0)) ==
|
1967 |
|
|
IDENTIFIER_NODE))
|
1968 |
|
|
{
|
1969 |
|
|
/* Find the list of functions in ctype that have the same
|
1970 |
|
|
name as the declared function. */
|
1971 |
|
|
tree name = TREE_OPERAND (declarator, 0);
|
1972 |
|
|
tree fns = NULL_TREE;
|
1973 |
|
|
int idx;
|
1974 |
|
|
|
1975 |
|
|
if (constructor_name_p (name, ctype))
|
1976 |
|
|
{
|
1977 |
|
|
int is_constructor = DECL_CONSTRUCTOR_P (decl);
|
1978 |
|
|
|
1979 |
|
|
if (is_constructor ? !TYPE_HAS_CONSTRUCTOR (ctype)
|
1980 |
|
|
: !CLASSTYPE_DESTRUCTORS (ctype))
|
1981 |
|
|
{
|
1982 |
|
|
/* From [temp.expl.spec]:
|
1983 |
|
|
|
1984 |
|
|
If such an explicit specialization for the member
|
1985 |
|
|
of a class template names an implicitly-declared
|
1986 |
|
|
special member function (clause _special_), the
|
1987 |
|
|
program is ill-formed.
|
1988 |
|
|
|
1989 |
|
|
Similar language is found in [temp.explicit]. */
|
1990 |
|
|
error ("specialization of implicitly-declared special member function");
|
1991 |
|
|
return error_mark_node;
|
1992 |
|
|
}
|
1993 |
|
|
|
1994 |
|
|
name = is_constructor ? ctor_identifier : dtor_identifier;
|
1995 |
|
|
}
|
1996 |
|
|
|
1997 |
|
|
if (!DECL_CONV_FN_P (decl))
|
1998 |
|
|
{
|
1999 |
|
|
idx = lookup_fnfields_1 (ctype, name);
|
2000 |
|
|
if (idx >= 0)
|
2001 |
|
|
fns = VEC_index (tree, CLASSTYPE_METHOD_VEC (ctype), idx);
|
2002 |
|
|
}
|
2003 |
|
|
else
|
2004 |
|
|
{
|
2005 |
|
|
VEC(tree,gc) *methods;
|
2006 |
|
|
tree ovl;
|
2007 |
|
|
|
2008 |
|
|
/* For a type-conversion operator, we cannot do a
|
2009 |
|
|
name-based lookup. We might be looking for `operator
|
2010 |
|
|
int' which will be a specialization of `operator T'.
|
2011 |
|
|
So, we find *all* the conversion operators, and then
|
2012 |
|
|
select from them. */
|
2013 |
|
|
fns = NULL_TREE;
|
2014 |
|
|
|
2015 |
|
|
methods = CLASSTYPE_METHOD_VEC (ctype);
|
2016 |
|
|
if (methods)
|
2017 |
|
|
for (idx = CLASSTYPE_FIRST_CONVERSION_SLOT;
|
2018 |
|
|
VEC_iterate (tree, methods, idx, ovl);
|
2019 |
|
|
++idx)
|
2020 |
|
|
{
|
2021 |
|
|
if (!DECL_CONV_FN_P (OVL_CURRENT (ovl)))
|
2022 |
|
|
/* There are no more conversion functions. */
|
2023 |
|
|
break;
|
2024 |
|
|
|
2025 |
|
|
/* Glue all these conversion functions together
|
2026 |
|
|
with those we already have. */
|
2027 |
|
|
for (; ovl; ovl = OVL_NEXT (ovl))
|
2028 |
|
|
fns = ovl_cons (OVL_CURRENT (ovl), fns);
|
2029 |
|
|
}
|
2030 |
|
|
}
|
2031 |
|
|
|
2032 |
|
|
if (fns == NULL_TREE)
|
2033 |
|
|
{
|
2034 |
|
|
error ("no member function %qD declared in %qT", name, ctype);
|
2035 |
|
|
return error_mark_node;
|
2036 |
|
|
}
|
2037 |
|
|
else
|
2038 |
|
|
TREE_OPERAND (declarator, 0) = fns;
|
2039 |
|
|
}
|
2040 |
|
|
|
2041 |
|
|
/* Figure out what exactly is being specialized at this point.
|
2042 |
|
|
Note that for an explicit instantiation, even one for a
|
2043 |
|
|
member function, we cannot tell apriori whether the
|
2044 |
|
|
instantiation is for a member template, or just a member
|
2045 |
|
|
function of a template class. Even if a member template is
|
2046 |
|
|
being instantiated, the member template arguments may be
|
2047 |
|
|
elided if they can be deduced from the rest of the
|
2048 |
|
|
declaration. */
|
2049 |
|
|
tmpl = determine_specialization (declarator, decl,
|
2050 |
|
|
&targs,
|
2051 |
|
|
member_specialization,
|
2052 |
|
|
template_count);
|
2053 |
|
|
|
2054 |
|
|
if (!tmpl || tmpl == error_mark_node)
|
2055 |
|
|
/* We couldn't figure out what this declaration was
|
2056 |
|
|
specializing. */
|
2057 |
|
|
return error_mark_node;
|
2058 |
|
|
else
|
2059 |
|
|
{
|
2060 |
|
|
tree gen_tmpl = most_general_template (tmpl);
|
2061 |
|
|
|
2062 |
|
|
if (explicit_instantiation)
|
2063 |
|
|
{
|
2064 |
|
|
/* We don't set DECL_EXPLICIT_INSTANTIATION here; that
|
2065 |
|
|
is done by do_decl_instantiation later. */
|
2066 |
|
|
|
2067 |
|
|
int arg_depth = TMPL_ARGS_DEPTH (targs);
|
2068 |
|
|
int parm_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
|
2069 |
|
|
|
2070 |
|
|
if (arg_depth > parm_depth)
|
2071 |
|
|
{
|
2072 |
|
|
/* If TMPL is not the most general template (for
|
2073 |
|
|
example, if TMPL is a friend template that is
|
2074 |
|
|
injected into namespace scope), then there will
|
2075 |
|
|
be too many levels of TARGS. Remove some of them
|
2076 |
|
|
here. */
|
2077 |
|
|
int i;
|
2078 |
|
|
tree new_targs;
|
2079 |
|
|
|
2080 |
|
|
new_targs = make_tree_vec (parm_depth);
|
2081 |
|
|
for (i = arg_depth - parm_depth; i < arg_depth; ++i)
|
2082 |
|
|
TREE_VEC_ELT (new_targs, i - (arg_depth - parm_depth))
|
2083 |
|
|
= TREE_VEC_ELT (targs, i);
|
2084 |
|
|
targs = new_targs;
|
2085 |
|
|
}
|
2086 |
|
|
|
2087 |
|
|
return instantiate_template (tmpl, targs, tf_error);
|
2088 |
|
|
}
|
2089 |
|
|
|
2090 |
|
|
/* If we thought that the DECL was a member function, but it
|
2091 |
|
|
turns out to be specializing a static member function,
|
2092 |
|
|
make DECL a static member function as well. */
|
2093 |
|
|
if (DECL_STATIC_FUNCTION_P (tmpl)
|
2094 |
|
|
&& DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
|
2095 |
|
|
revert_static_member_fn (decl);
|
2096 |
|
|
|
2097 |
|
|
/* If this is a specialization of a member template of a
|
2098 |
|
|
template class. In we want to return the TEMPLATE_DECL,
|
2099 |
|
|
not the specialization of it. */
|
2100 |
|
|
if (tsk == tsk_template)
|
2101 |
|
|
{
|
2102 |
|
|
SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
|
2103 |
|
|
DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl)) = NULL_TREE;
|
2104 |
|
|
if (have_def)
|
2105 |
|
|
{
|
2106 |
|
|
DECL_SOURCE_LOCATION (tmpl) = DECL_SOURCE_LOCATION (decl);
|
2107 |
|
|
DECL_SOURCE_LOCATION (DECL_TEMPLATE_RESULT (tmpl))
|
2108 |
|
|
= DECL_SOURCE_LOCATION (decl);
|
2109 |
|
|
/* We want to use the argument list specified in the
|
2110 |
|
|
definition, not in the original declaration. */
|
2111 |
|
|
DECL_ARGUMENTS (DECL_TEMPLATE_RESULT (tmpl))
|
2112 |
|
|
= DECL_ARGUMENTS (decl);
|
2113 |
|
|
}
|
2114 |
|
|
return tmpl;
|
2115 |
|
|
}
|
2116 |
|
|
|
2117 |
|
|
/* Set up the DECL_TEMPLATE_INFO for DECL. */
|
2118 |
|
|
DECL_TEMPLATE_INFO (decl) = tree_cons (tmpl, targs, NULL_TREE);
|
2119 |
|
|
|
2120 |
|
|
/* Inherit default function arguments from the template
|
2121 |
|
|
DECL is specializing. */
|
2122 |
|
|
copy_default_args_to_explicit_spec (decl);
|
2123 |
|
|
|
2124 |
|
|
/* This specialization has the same protection as the
|
2125 |
|
|
template it specializes. */
|
2126 |
|
|
TREE_PRIVATE (decl) = TREE_PRIVATE (gen_tmpl);
|
2127 |
|
|
TREE_PROTECTED (decl) = TREE_PROTECTED (gen_tmpl);
|
2128 |
|
|
/* The specialization has the same visibility as the
|
2129 |
|
|
template it specializes. */
|
2130 |
|
|
if (DECL_VISIBILITY_SPECIFIED (gen_tmpl))
|
2131 |
|
|
{
|
2132 |
|
|
DECL_VISIBILITY_SPECIFIED (decl) = 1;
|
2133 |
|
|
DECL_VISIBILITY (decl) = DECL_VISIBILITY (gen_tmpl);
|
2134 |
|
|
}
|
2135 |
|
|
/* If DECL is a friend declaration, declared using an
|
2136 |
|
|
unqualified name, the namespace associated with DECL may
|
2137 |
|
|
have been set incorrectly. For example, in:
|
2138 |
|
|
|
2139 |
|
|
template <typename T> void f(T);
|
2140 |
|
|
namespace N {
|
2141 |
|
|
struct S { friend void f<int>(int); }
|
2142 |
|
|
}
|
2143 |
|
|
|
2144 |
|
|
we will have set the DECL_CONTEXT for the friend
|
2145 |
|
|
declaration to N, rather than to the global namespace. */
|
2146 |
|
|
if (DECL_NAMESPACE_SCOPE_P (decl))
|
2147 |
|
|
DECL_CONTEXT (decl) = DECL_CONTEXT (tmpl);
|
2148 |
|
|
|
2149 |
|
|
if (is_friend && !have_def)
|
2150 |
|
|
/* This is not really a declaration of a specialization.
|
2151 |
|
|
It's just the name of an instantiation. But, it's not
|
2152 |
|
|
a request for an instantiation, either. */
|
2153 |
|
|
SET_DECL_IMPLICIT_INSTANTIATION (decl);
|
2154 |
|
|
else if (DECL_CONSTRUCTOR_P (decl) || DECL_DESTRUCTOR_P (decl))
|
2155 |
|
|
/* This is indeed a specialization. In case of constructors
|
2156 |
|
|
and destructors, we need in-charge and not-in-charge
|
2157 |
|
|
versions in V3 ABI. */
|
2158 |
|
|
clone_function_decl (decl, /*update_method_vec_p=*/0);
|
2159 |
|
|
|
2160 |
|
|
/* Register this specialization so that we can find it
|
2161 |
|
|
again. */
|
2162 |
|
|
decl = register_specialization (decl, gen_tmpl, targs, is_friend);
|
2163 |
|
|
}
|
2164 |
|
|
}
|
2165 |
|
|
|
2166 |
|
|
return decl;
|
2167 |
|
|
}
|
2168 |
|
|
|
2169 |
|
|
/* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
|
2170 |
|
|
parameters. These are represented in the same format used for
|
2171 |
|
|
DECL_TEMPLATE_PARMS. */
|
2172 |
|
|
|
2173 |
|
|
int
|
2174 |
|
|
comp_template_parms (tree parms1, tree parms2)
|
2175 |
|
|
{
|
2176 |
|
|
tree p1;
|
2177 |
|
|
tree p2;
|
2178 |
|
|
|
2179 |
|
|
if (parms1 == parms2)
|
2180 |
|
|
return 1;
|
2181 |
|
|
|
2182 |
|
|
for (p1 = parms1, p2 = parms2;
|
2183 |
|
|
p1 != NULL_TREE && p2 != NULL_TREE;
|
2184 |
|
|
p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2))
|
2185 |
|
|
{
|
2186 |
|
|
tree t1 = TREE_VALUE (p1);
|
2187 |
|
|
tree t2 = TREE_VALUE (p2);
|
2188 |
|
|
int i;
|
2189 |
|
|
|
2190 |
|
|
gcc_assert (TREE_CODE (t1) == TREE_VEC);
|
2191 |
|
|
gcc_assert (TREE_CODE (t2) == TREE_VEC);
|
2192 |
|
|
|
2193 |
|
|
if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2))
|
2194 |
|
|
return 0;
|
2195 |
|
|
|
2196 |
|
|
for (i = 0; i < TREE_VEC_LENGTH (t2); ++i)
|
2197 |
|
|
{
|
2198 |
|
|
tree parm1 = TREE_VALUE (TREE_VEC_ELT (t1, i));
|
2199 |
|
|
tree parm2 = TREE_VALUE (TREE_VEC_ELT (t2, i));
|
2200 |
|
|
|
2201 |
|
|
if (TREE_CODE (parm1) != TREE_CODE (parm2))
|
2202 |
|
|
return 0;
|
2203 |
|
|
|
2204 |
|
|
if (TREE_CODE (parm1) == TEMPLATE_TYPE_PARM)
|
2205 |
|
|
continue;
|
2206 |
|
|
else if (!same_type_p (TREE_TYPE (parm1), TREE_TYPE (parm2)))
|
2207 |
|
|
return 0;
|
2208 |
|
|
}
|
2209 |
|
|
}
|
2210 |
|
|
|
2211 |
|
|
if ((p1 != NULL_TREE) != (p2 != NULL_TREE))
|
2212 |
|
|
/* One set of parameters has more parameters lists than the
|
2213 |
|
|
other. */
|
2214 |
|
|
return 0;
|
2215 |
|
|
|
2216 |
|
|
return 1;
|
2217 |
|
|
}
|
2218 |
|
|
|
2219 |
|
|
/* Complain if DECL shadows a template parameter.
|
2220 |
|
|
|
2221 |
|
|
[temp.local]: A template-parameter shall not be redeclared within its
|
2222 |
|
|
scope (including nested scopes). */
|
2223 |
|
|
|
2224 |
|
|
void
|
2225 |
|
|
check_template_shadow (tree decl)
|
2226 |
|
|
{
|
2227 |
|
|
tree olddecl;
|
2228 |
|
|
|
2229 |
|
|
/* If we're not in a template, we can't possibly shadow a template
|
2230 |
|
|
parameter. */
|
2231 |
|
|
if (!current_template_parms)
|
2232 |
|
|
return;
|
2233 |
|
|
|
2234 |
|
|
/* Figure out what we're shadowing. */
|
2235 |
|
|
if (TREE_CODE (decl) == OVERLOAD)
|
2236 |
|
|
decl = OVL_CURRENT (decl);
|
2237 |
|
|
olddecl = innermost_non_namespace_value (DECL_NAME (decl));
|
2238 |
|
|
|
2239 |
|
|
/* If there's no previous binding for this name, we're not shadowing
|
2240 |
|
|
anything, let alone a template parameter. */
|
2241 |
|
|
if (!olddecl)
|
2242 |
|
|
return;
|
2243 |
|
|
|
2244 |
|
|
/* If we're not shadowing a template parameter, we're done. Note
|
2245 |
|
|
that OLDDECL might be an OVERLOAD (or perhaps even an
|
2246 |
|
|
ERROR_MARK), so we can't just blithely assume it to be a _DECL
|
2247 |
|
|
node. */
|
2248 |
|
|
if (!DECL_P (olddecl) || !DECL_TEMPLATE_PARM_P (olddecl))
|
2249 |
|
|
return;
|
2250 |
|
|
|
2251 |
|
|
/* We check for decl != olddecl to avoid bogus errors for using a
|
2252 |
|
|
name inside a class. We check TPFI to avoid duplicate errors for
|
2253 |
|
|
inline member templates. */
|
2254 |
|
|
if (decl == olddecl
|
2255 |
|
|
|| TEMPLATE_PARMS_FOR_INLINE (current_template_parms))
|
2256 |
|
|
return;
|
2257 |
|
|
|
2258 |
|
|
error ("declaration of %q+#D", decl);
|
2259 |
|
|
error (" shadows template parm %q+#D", olddecl);
|
2260 |
|
|
}
|
2261 |
|
|
|
2262 |
|
|
/* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
|
2263 |
|
|
ORIG_LEVEL, DECL, and TYPE. */
|
2264 |
|
|
|
2265 |
|
|
static tree
|
2266 |
|
|
build_template_parm_index (int index,
|
2267 |
|
|
int level,
|
2268 |
|
|
int orig_level,
|
2269 |
|
|
tree decl,
|
2270 |
|
|
tree type)
|
2271 |
|
|
{
|
2272 |
|
|
tree t = make_node (TEMPLATE_PARM_INDEX);
|
2273 |
|
|
TEMPLATE_PARM_IDX (t) = index;
|
2274 |
|
|
TEMPLATE_PARM_LEVEL (t) = level;
|
2275 |
|
|
TEMPLATE_PARM_ORIG_LEVEL (t) = orig_level;
|
2276 |
|
|
TEMPLATE_PARM_DECL (t) = decl;
|
2277 |
|
|
TREE_TYPE (t) = type;
|
2278 |
|
|
TREE_CONSTANT (t) = TREE_CONSTANT (decl);
|
2279 |
|
|
TREE_INVARIANT (t) = TREE_INVARIANT (decl);
|
2280 |
|
|
TREE_READONLY (t) = TREE_READONLY (decl);
|
2281 |
|
|
|
2282 |
|
|
return t;
|
2283 |
|
|
}
|
2284 |
|
|
|
2285 |
|
|
/* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
|
2286 |
|
|
TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
|
2287 |
|
|
TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
|
2288 |
|
|
new one is created. */
|
2289 |
|
|
|
2290 |
|
|
static tree
|
2291 |
|
|
reduce_template_parm_level (tree index, tree type, int levels)
|
2292 |
|
|
{
|
2293 |
|
|
if (TEMPLATE_PARM_DESCENDANTS (index) == NULL_TREE
|
2294 |
|
|
|| (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index))
|
2295 |
|
|
!= TEMPLATE_PARM_LEVEL (index) - levels))
|
2296 |
|
|
{
|
2297 |
|
|
tree orig_decl = TEMPLATE_PARM_DECL (index);
|
2298 |
|
|
tree decl, t;
|
2299 |
|
|
|
2300 |
|
|
decl = build_decl (TREE_CODE (orig_decl), DECL_NAME (orig_decl), type);
|
2301 |
|
|
TREE_CONSTANT (decl) = TREE_CONSTANT (orig_decl);
|
2302 |
|
|
TREE_INVARIANT (decl) = TREE_INVARIANT (orig_decl);
|
2303 |
|
|
TREE_READONLY (decl) = TREE_READONLY (orig_decl);
|
2304 |
|
|
DECL_ARTIFICIAL (decl) = 1;
|
2305 |
|
|
SET_DECL_TEMPLATE_PARM_P (decl);
|
2306 |
|
|
|
2307 |
|
|
t = build_template_parm_index (TEMPLATE_PARM_IDX (index),
|
2308 |
|
|
TEMPLATE_PARM_LEVEL (index) - levels,
|
2309 |
|
|
TEMPLATE_PARM_ORIG_LEVEL (index),
|
2310 |
|
|
decl, type);
|
2311 |
|
|
TEMPLATE_PARM_DESCENDANTS (index) = t;
|
2312 |
|
|
|
2313 |
|
|
/* Template template parameters need this. */
|
2314 |
|
|
if (TREE_CODE (decl) != CONST_DECL)
|
2315 |
|
|
DECL_TEMPLATE_PARMS (decl)
|
2316 |
|
|
= DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index));
|
2317 |
|
|
}
|
2318 |
|
|
|
2319 |
|
|
return TEMPLATE_PARM_DESCENDANTS (index);
|
2320 |
|
|
}
|
2321 |
|
|
|
2322 |
|
|
/* Process information from new template parameter NEXT and append it to the
|
2323 |
|
|
LIST being built. This new parameter is a non-type parameter iff
|
2324 |
|
|
IS_NON_TYPE is true. */
|
2325 |
|
|
|
2326 |
|
|
tree
|
2327 |
|
|
process_template_parm (tree list, tree next, bool is_non_type)
|
2328 |
|
|
{
|
2329 |
|
|
tree parm;
|
2330 |
|
|
tree decl = 0;
|
2331 |
|
|
tree defval;
|
2332 |
|
|
int idx;
|
2333 |
|
|
|
2334 |
|
|
parm = next;
|
2335 |
|
|
gcc_assert (TREE_CODE (parm) == TREE_LIST);
|
2336 |
|
|
defval = TREE_PURPOSE (parm);
|
2337 |
|
|
|
2338 |
|
|
if (list)
|
2339 |
|
|
{
|
2340 |
|
|
tree p = TREE_VALUE (tree_last (list));
|
2341 |
|
|
|
2342 |
|
|
if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
|
2343 |
|
|
idx = TEMPLATE_TYPE_IDX (TREE_TYPE (p));
|
2344 |
|
|
else
|
2345 |
|
|
idx = TEMPLATE_PARM_IDX (DECL_INITIAL (p));
|
2346 |
|
|
++idx;
|
2347 |
|
|
}
|
2348 |
|
|
else
|
2349 |
|
|
idx = 0;
|
2350 |
|
|
|
2351 |
|
|
if (is_non_type)
|
2352 |
|
|
{
|
2353 |
|
|
parm = TREE_VALUE (parm);
|
2354 |
|
|
|
2355 |
|
|
SET_DECL_TEMPLATE_PARM_P (parm);
|
2356 |
|
|
|
2357 |
|
|
/* [temp.param]
|
2358 |
|
|
|
2359 |
|
|
The top-level cv-qualifiers on the template-parameter are
|
2360 |
|
|
ignored when determining its type. */
|
2361 |
|
|
TREE_TYPE (parm) = TYPE_MAIN_VARIANT (TREE_TYPE (parm));
|
2362 |
|
|
|
2363 |
|
|
/* A template parameter is not modifiable. */
|
2364 |
|
|
TREE_CONSTANT (parm) = 1;
|
2365 |
|
|
TREE_INVARIANT (parm) = 1;
|
2366 |
|
|
TREE_READONLY (parm) = 1;
|
2367 |
|
|
if (invalid_nontype_parm_type_p (TREE_TYPE (parm), 1))
|
2368 |
|
|
TREE_TYPE (parm) = void_type_node;
|
2369 |
|
|
decl = build_decl (CONST_DECL, DECL_NAME (parm), TREE_TYPE (parm));
|
2370 |
|
|
TREE_CONSTANT (decl) = 1;
|
2371 |
|
|
TREE_INVARIANT (decl) = 1;
|
2372 |
|
|
TREE_READONLY (decl) = 1;
|
2373 |
|
|
DECL_INITIAL (parm) = DECL_INITIAL (decl)
|
2374 |
|
|
= build_template_parm_index (idx, processing_template_decl,
|
2375 |
|
|
processing_template_decl,
|
2376 |
|
|
decl, TREE_TYPE (parm));
|
2377 |
|
|
}
|
2378 |
|
|
else
|
2379 |
|
|
{
|
2380 |
|
|
tree t;
|
2381 |
|
|
parm = TREE_VALUE (TREE_VALUE (parm));
|
2382 |
|
|
|
2383 |
|
|
if (parm && TREE_CODE (parm) == TEMPLATE_DECL)
|
2384 |
|
|
{
|
2385 |
|
|
t = make_aggr_type (TEMPLATE_TEMPLATE_PARM);
|
2386 |
|
|
/* This is for distinguishing between real templates and template
|
2387 |
|
|
template parameters */
|
2388 |
|
|
TREE_TYPE (parm) = t;
|
2389 |
|
|
TREE_TYPE (DECL_TEMPLATE_RESULT (parm)) = t;
|
2390 |
|
|
decl = parm;
|
2391 |
|
|
}
|
2392 |
|
|
else
|
2393 |
|
|
{
|
2394 |
|
|
t = make_aggr_type (TEMPLATE_TYPE_PARM);
|
2395 |
|
|
/* parm is either IDENTIFIER_NODE or NULL_TREE. */
|
2396 |
|
|
decl = build_decl (TYPE_DECL, parm, t);
|
2397 |
|
|
}
|
2398 |
|
|
|
2399 |
|
|
TYPE_NAME (t) = decl;
|
2400 |
|
|
TYPE_STUB_DECL (t) = decl;
|
2401 |
|
|
parm = decl;
|
2402 |
|
|
TEMPLATE_TYPE_PARM_INDEX (t)
|
2403 |
|
|
= build_template_parm_index (idx, processing_template_decl,
|
2404 |
|
|
processing_template_decl,
|
2405 |
|
|
decl, TREE_TYPE (parm));
|
2406 |
|
|
}
|
2407 |
|
|
DECL_ARTIFICIAL (decl) = 1;
|
2408 |
|
|
SET_DECL_TEMPLATE_PARM_P (decl);
|
2409 |
|
|
pushdecl (decl);
|
2410 |
|
|
parm = build_tree_list (defval, parm);
|
2411 |
|
|
return chainon (list, parm);
|
2412 |
|
|
}
|
2413 |
|
|
|
2414 |
|
|
/* The end of a template parameter list has been reached. Process the
|
2415 |
|
|
tree list into a parameter vector, converting each parameter into a more
|
2416 |
|
|
useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
|
2417 |
|
|
as PARM_DECLs. */
|
2418 |
|
|
|
2419 |
|
|
tree
|
2420 |
|
|
end_template_parm_list (tree parms)
|
2421 |
|
|
{
|
2422 |
|
|
int nparms;
|
2423 |
|
|
tree parm, next;
|
2424 |
|
|
tree saved_parmlist = make_tree_vec (list_length (parms));
|
2425 |
|
|
|
2426 |
|
|
current_template_parms
|
2427 |
|
|
= tree_cons (size_int (processing_template_decl),
|
2428 |
|
|
saved_parmlist, current_template_parms);
|
2429 |
|
|
|
2430 |
|
|
for (parm = parms, nparms = 0; parm; parm = next, nparms++)
|
2431 |
|
|
{
|
2432 |
|
|
next = TREE_CHAIN (parm);
|
2433 |
|
|
TREE_VEC_ELT (saved_parmlist, nparms) = parm;
|
2434 |
|
|
TREE_CHAIN (parm) = NULL_TREE;
|
2435 |
|
|
}
|
2436 |
|
|
|
2437 |
|
|
--processing_template_parmlist;
|
2438 |
|
|
|
2439 |
|
|
return saved_parmlist;
|
2440 |
|
|
}
|
2441 |
|
|
|
2442 |
|
|
/* end_template_decl is called after a template declaration is seen. */
|
2443 |
|
|
|
2444 |
|
|
void
|
2445 |
|
|
end_template_decl (void)
|
2446 |
|
|
{
|
2447 |
|
|
reset_specialization ();
|
2448 |
|
|
|
2449 |
|
|
if (! processing_template_decl)
|
2450 |
|
|
return;
|
2451 |
|
|
|
2452 |
|
|
/* This matches the pushlevel in begin_template_parm_list. */
|
2453 |
|
|
finish_scope ();
|
2454 |
|
|
|
2455 |
|
|
--processing_template_decl;
|
2456 |
|
|
current_template_parms = TREE_CHAIN (current_template_parms);
|
2457 |
|
|
}
|
2458 |
|
|
|
2459 |
|
|
/* Given a template argument vector containing the template PARMS.
|
2460 |
|
|
The innermost PARMS are given first. */
|
2461 |
|
|
|
2462 |
|
|
tree
|
2463 |
|
|
current_template_args (void)
|
2464 |
|
|
{
|
2465 |
|
|
tree header;
|
2466 |
|
|
tree args = NULL_TREE;
|
2467 |
|
|
int length = TMPL_PARMS_DEPTH (current_template_parms);
|
2468 |
|
|
int l = length;
|
2469 |
|
|
|
2470 |
|
|
/* If there is only one level of template parameters, we do not
|
2471 |
|
|
create a TREE_VEC of TREE_VECs. Instead, we return a single
|
2472 |
|
|
TREE_VEC containing the arguments. */
|
2473 |
|
|
if (length > 1)
|
2474 |
|
|
args = make_tree_vec (length);
|
2475 |
|
|
|
2476 |
|
|
for (header = current_template_parms; header; header = TREE_CHAIN (header))
|
2477 |
|
|
{
|
2478 |
|
|
tree a = copy_node (TREE_VALUE (header));
|
2479 |
|
|
int i;
|
2480 |
|
|
|
2481 |
|
|
TREE_TYPE (a) = NULL_TREE;
|
2482 |
|
|
for (i = TREE_VEC_LENGTH (a) - 1; i >= 0; --i)
|
2483 |
|
|
{
|
2484 |
|
|
tree t = TREE_VEC_ELT (a, i);
|
2485 |
|
|
|
2486 |
|
|
/* T will be a list if we are called from within a
|
2487 |
|
|
begin/end_template_parm_list pair, but a vector directly
|
2488 |
|
|
if within a begin/end_member_template_processing pair. */
|
2489 |
|
|
if (TREE_CODE (t) == TREE_LIST)
|
2490 |
|
|
{
|
2491 |
|
|
t = TREE_VALUE (t);
|
2492 |
|
|
|
2493 |
|
|
if (TREE_CODE (t) == TYPE_DECL
|
2494 |
|
|
|| TREE_CODE (t) == TEMPLATE_DECL)
|
2495 |
|
|
t = TREE_TYPE (t);
|
2496 |
|
|
else
|
2497 |
|
|
t = DECL_INITIAL (t);
|
2498 |
|
|
TREE_VEC_ELT (a, i) = t;
|
2499 |
|
|
}
|
2500 |
|
|
}
|
2501 |
|
|
|
2502 |
|
|
if (length > 1)
|
2503 |
|
|
TREE_VEC_ELT (args, --l) = a;
|
2504 |
|
|
else
|
2505 |
|
|
args = a;
|
2506 |
|
|
}
|
2507 |
|
|
|
2508 |
|
|
return args;
|
2509 |
|
|
}
|
2510 |
|
|
|
2511 |
|
|
/* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
|
2512 |
|
|
template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
|
2513 |
|
|
a member template. Used by push_template_decl below. */
|
2514 |
|
|
|
2515 |
|
|
static tree
|
2516 |
|
|
build_template_decl (tree decl, tree parms, bool member_template_p)
|
2517 |
|
|
{
|
2518 |
|
|
tree tmpl = build_lang_decl (TEMPLATE_DECL, DECL_NAME (decl), NULL_TREE);
|
2519 |
|
|
DECL_TEMPLATE_PARMS (tmpl) = parms;
|
2520 |
|
|
DECL_CONTEXT (tmpl) = DECL_CONTEXT (decl);
|
2521 |
|
|
DECL_MEMBER_TEMPLATE_P (tmpl) = member_template_p;
|
2522 |
|
|
if (DECL_LANG_SPECIFIC (decl))
|
2523 |
|
|
{
|
2524 |
|
|
DECL_STATIC_FUNCTION_P (tmpl) = DECL_STATIC_FUNCTION_P (decl);
|
2525 |
|
|
DECL_CONSTRUCTOR_P (tmpl) = DECL_CONSTRUCTOR_P (decl);
|
2526 |
|
|
DECL_DESTRUCTOR_P (tmpl) = DECL_DESTRUCTOR_P (decl);
|
2527 |
|
|
DECL_NONCONVERTING_P (tmpl) = DECL_NONCONVERTING_P (decl);
|
2528 |
|
|
DECL_ASSIGNMENT_OPERATOR_P (tmpl) = DECL_ASSIGNMENT_OPERATOR_P (decl);
|
2529 |
|
|
if (DECL_OVERLOADED_OPERATOR_P (decl))
|
2530 |
|
|
SET_OVERLOADED_OPERATOR_CODE (tmpl,
|
2531 |
|
|
DECL_OVERLOADED_OPERATOR_P (decl));
|
2532 |
|
|
}
|
2533 |
|
|
|
2534 |
|
|
return tmpl;
|
2535 |
|
|
}
|
2536 |
|
|
|
2537 |
|
|
struct template_parm_data
|
2538 |
|
|
{
|
2539 |
|
|
/* The level of the template parameters we are currently
|
2540 |
|
|
processing. */
|
2541 |
|
|
int level;
|
2542 |
|
|
|
2543 |
|
|
/* The index of the specialization argument we are currently
|
2544 |
|
|
processing. */
|
2545 |
|
|
int current_arg;
|
2546 |
|
|
|
2547 |
|
|
/* An array whose size is the number of template parameters. The
|
2548 |
|
|
elements are nonzero if the parameter has been used in any one
|
2549 |
|
|
of the arguments processed so far. */
|
2550 |
|
|
int* parms;
|
2551 |
|
|
|
2552 |
|
|
/* An array whose size is the number of template arguments. The
|
2553 |
|
|
elements are nonzero if the argument makes use of template
|
2554 |
|
|
parameters of this level. */
|
2555 |
|
|
int* arg_uses_template_parms;
|
2556 |
|
|
};
|
2557 |
|
|
|
2558 |
|
|
/* Subroutine of push_template_decl used to see if each template
|
2559 |
|
|
parameter in a partial specialization is used in the explicit
|
2560 |
|
|
argument list. If T is of the LEVEL given in DATA (which is
|
2561 |
|
|
treated as a template_parm_data*), then DATA->PARMS is marked
|
2562 |
|
|
appropriately. */
|
2563 |
|
|
|
2564 |
|
|
static int
|
2565 |
|
|
mark_template_parm (tree t, void* data)
|
2566 |
|
|
{
|
2567 |
|
|
int level;
|
2568 |
|
|
int idx;
|
2569 |
|
|
struct template_parm_data* tpd = (struct template_parm_data*) data;
|
2570 |
|
|
|
2571 |
|
|
if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
|
2572 |
|
|
{
|
2573 |
|
|
level = TEMPLATE_PARM_LEVEL (t);
|
2574 |
|
|
idx = TEMPLATE_PARM_IDX (t);
|
2575 |
|
|
}
|
2576 |
|
|
else
|
2577 |
|
|
{
|
2578 |
|
|
level = TEMPLATE_TYPE_LEVEL (t);
|
2579 |
|
|
idx = TEMPLATE_TYPE_IDX (t);
|
2580 |
|
|
}
|
2581 |
|
|
|
2582 |
|
|
if (level == tpd->level)
|
2583 |
|
|
{
|
2584 |
|
|
tpd->parms[idx] = 1;
|
2585 |
|
|
tpd->arg_uses_template_parms[tpd->current_arg] = 1;
|
2586 |
|
|
}
|
2587 |
|
|
|
2588 |
|
|
/* Return zero so that for_each_template_parm will continue the
|
2589 |
|
|
traversal of the tree; we want to mark *every* template parm. */
|
2590 |
|
|
return 0;
|
2591 |
|
|
}
|
2592 |
|
|
|
2593 |
|
|
/* Process the partial specialization DECL. */
|
2594 |
|
|
|
2595 |
|
|
static tree
|
2596 |
|
|
process_partial_specialization (tree decl)
|
2597 |
|
|
{
|
2598 |
|
|
tree type = TREE_TYPE (decl);
|
2599 |
|
|
tree maintmpl = CLASSTYPE_TI_TEMPLATE (type);
|
2600 |
|
|
tree specargs = CLASSTYPE_TI_ARGS (type);
|
2601 |
|
|
tree inner_args = INNERMOST_TEMPLATE_ARGS (specargs);
|
2602 |
|
|
tree inner_parms = INNERMOST_TEMPLATE_PARMS (current_template_parms);
|
2603 |
|
|
tree main_inner_parms = DECL_INNERMOST_TEMPLATE_PARMS (maintmpl);
|
2604 |
|
|
int nargs = TREE_VEC_LENGTH (inner_args);
|
2605 |
|
|
int ntparms = TREE_VEC_LENGTH (inner_parms);
|
2606 |
|
|
int i;
|
2607 |
|
|
int did_error_intro = 0;
|
2608 |
|
|
struct template_parm_data tpd;
|
2609 |
|
|
struct template_parm_data tpd2;
|
2610 |
|
|
|
2611 |
|
|
/* We check that each of the template parameters given in the
|
2612 |
|
|
partial specialization is used in the argument list to the
|
2613 |
|
|
specialization. For example:
|
2614 |
|
|
|
2615 |
|
|
template <class T> struct S;
|
2616 |
|
|
template <class T> struct S<T*>;
|
2617 |
|
|
|
2618 |
|
|
The second declaration is OK because `T*' uses the template
|
2619 |
|
|
parameter T, whereas
|
2620 |
|
|
|
2621 |
|
|
template <class T> struct S<int>;
|
2622 |
|
|
|
2623 |
|
|
is no good. Even trickier is:
|
2624 |
|
|
|
2625 |
|
|
template <class T>
|
2626 |
|
|
struct S1
|
2627 |
|
|
{
|
2628 |
|
|
template <class U>
|
2629 |
|
|
struct S2;
|
2630 |
|
|
template <class U>
|
2631 |
|
|
struct S2<T>;
|
2632 |
|
|
};
|
2633 |
|
|
|
2634 |
|
|
The S2<T> declaration is actually invalid; it is a
|
2635 |
|
|
full-specialization. Of course,
|
2636 |
|
|
|
2637 |
|
|
template <class U>
|
2638 |
|
|
struct S2<T (*)(U)>;
|
2639 |
|
|
|
2640 |
|
|
or some such would have been OK. */
|
2641 |
|
|
tpd.level = TMPL_PARMS_DEPTH (current_template_parms);
|
2642 |
|
|
tpd.parms = alloca (sizeof (int) * ntparms);
|
2643 |
|
|
memset (tpd.parms, 0, sizeof (int) * ntparms);
|
2644 |
|
|
|
2645 |
|
|
tpd.arg_uses_template_parms = alloca (sizeof (int) * nargs);
|
2646 |
|
|
memset (tpd.arg_uses_template_parms, 0, sizeof (int) * nargs);
|
2647 |
|
|
for (i = 0; i < nargs; ++i)
|
2648 |
|
|
{
|
2649 |
|
|
tpd.current_arg = i;
|
2650 |
|
|
for_each_template_parm (TREE_VEC_ELT (inner_args, i),
|
2651 |
|
|
&mark_template_parm,
|
2652 |
|
|
&tpd,
|
2653 |
|
|
NULL);
|
2654 |
|
|
}
|
2655 |
|
|
for (i = 0; i < ntparms; ++i)
|
2656 |
|
|
if (tpd.parms[i] == 0)
|
2657 |
|
|
{
|
2658 |
|
|
/* One of the template parms was not used in the
|
2659 |
|
|
specialization. */
|
2660 |
|
|
if (!did_error_intro)
|
2661 |
|
|
{
|
2662 |
|
|
error ("template parameters not used in partial specialization:");
|
2663 |
|
|
did_error_intro = 1;
|
2664 |
|
|
}
|
2665 |
|
|
|
2666 |
|
|
error (" %qD", TREE_VALUE (TREE_VEC_ELT (inner_parms, i)));
|
2667 |
|
|
}
|
2668 |
|
|
|
2669 |
|
|
/* [temp.class.spec]
|
2670 |
|
|
|
2671 |
|
|
The argument list of the specialization shall not be identical to
|
2672 |
|
|
the implicit argument list of the primary template. */
|
2673 |
|
|
if (comp_template_args
|
2674 |
|
|
(inner_args,
|
2675 |
|
|
INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE
|
2676 |
|
|
(maintmpl)))))
|
2677 |
|
|
error ("partial specialization %qT does not specialize any template arguments", type);
|
2678 |
|
|
|
2679 |
|
|
/* [temp.class.spec]
|
2680 |
|
|
|
2681 |
|
|
A partially specialized non-type argument expression shall not
|
2682 |
|
|
involve template parameters of the partial specialization except
|
2683 |
|
|
when the argument expression is a simple identifier.
|
2684 |
|
|
|
2685 |
|
|
The type of a template parameter corresponding to a specialized
|
2686 |
|
|
non-type argument shall not be dependent on a parameter of the
|
2687 |
|
|
specialization. */
|
2688 |
|
|
gcc_assert (nargs == DECL_NTPARMS (maintmpl));
|
2689 |
|
|
tpd2.parms = 0;
|
2690 |
|
|
for (i = 0; i < nargs; ++i)
|
2691 |
|
|
{
|
2692 |
|
|
tree arg = TREE_VEC_ELT (inner_args, i);
|
2693 |
|
|
if (/* These first two lines are the `non-type' bit. */
|
2694 |
|
|
!TYPE_P (arg)
|
2695 |
|
|
&& TREE_CODE (arg) != TEMPLATE_DECL
|
2696 |
|
|
/* This next line is the `argument expression is not just a
|
2697 |
|
|
simple identifier' condition and also the `specialized
|
2698 |
|
|
non-type argument' bit. */
|
2699 |
|
|
&& TREE_CODE (arg) != TEMPLATE_PARM_INDEX)
|
2700 |
|
|
{
|
2701 |
|
|
if (tpd.arg_uses_template_parms[i])
|
2702 |
|
|
error ("template argument %qE involves template parameter(s)", arg);
|
2703 |
|
|
else
|
2704 |
|
|
{
|
2705 |
|
|
/* Look at the corresponding template parameter,
|
2706 |
|
|
marking which template parameters its type depends
|
2707 |
|
|
upon. */
|
2708 |
|
|
tree type =
|
2709 |
|
|
TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (main_inner_parms,
|
2710 |
|
|
i)));
|
2711 |
|
|
|
2712 |
|
|
if (!tpd2.parms)
|
2713 |
|
|
{
|
2714 |
|
|
/* We haven't yet initialized TPD2. Do so now. */
|
2715 |
|
|
tpd2.arg_uses_template_parms
|
2716 |
|
|
= alloca (sizeof (int) * nargs);
|
2717 |
|
|
/* The number of parameters here is the number in the
|
2718 |
|
|
main template, which, as checked in the assertion
|
2719 |
|
|
above, is NARGS. */
|
2720 |
|
|
tpd2.parms = alloca (sizeof (int) * nargs);
|
2721 |
|
|
tpd2.level =
|
2722 |
|
|
TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl));
|
2723 |
|
|
}
|
2724 |
|
|
|
2725 |
|
|
/* Mark the template parameters. But this time, we're
|
2726 |
|
|
looking for the template parameters of the main
|
2727 |
|
|
template, not in the specialization. */
|
2728 |
|
|
tpd2.current_arg = i;
|
2729 |
|
|
tpd2.arg_uses_template_parms[i] = 0;
|
2730 |
|
|
memset (tpd2.parms, 0, sizeof (int) * nargs);
|
2731 |
|
|
for_each_template_parm (type,
|
2732 |
|
|
&mark_template_parm,
|
2733 |
|
|
&tpd2,
|
2734 |
|
|
NULL);
|
2735 |
|
|
|
2736 |
|
|
if (tpd2.arg_uses_template_parms [i])
|
2737 |
|
|
{
|
2738 |
|
|
/* The type depended on some template parameters.
|
2739 |
|
|
If they are fully specialized in the
|
2740 |
|
|
specialization, that's OK. */
|
2741 |
|
|
int j;
|
2742 |
|
|
for (j = 0; j < nargs; ++j)
|
2743 |
|
|
if (tpd2.parms[j] != 0
|
2744 |
|
|
&& tpd.arg_uses_template_parms [j])
|
2745 |
|
|
{
|
2746 |
|
|
error ("type %qT of template argument %qE depends "
|
2747 |
|
|
"on template parameter(s)",
|
2748 |
|
|
type,
|
2749 |
|
|
arg);
|
2750 |
|
|
break;
|
2751 |
|
|
}
|
2752 |
|
|
}
|
2753 |
|
|
}
|
2754 |
|
|
}
|
2755 |
|
|
}
|
2756 |
|
|
|
2757 |
|
|
if (retrieve_specialization (maintmpl, specargs,
|
2758 |
|
|
/*class_specializations_p=*/true))
|
2759 |
|
|
/* We've already got this specialization. */
|
2760 |
|
|
return decl;
|
2761 |
|
|
|
2762 |
|
|
DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)
|
2763 |
|
|
= tree_cons (specargs, inner_parms,
|
2764 |
|
|
DECL_TEMPLATE_SPECIALIZATIONS (maintmpl));
|
2765 |
|
|
TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)) = type;
|
2766 |
|
|
return decl;
|
2767 |
|
|
}
|
2768 |
|
|
|
2769 |
|
|
/* Check that a template declaration's use of default arguments is not
|
2770 |
|
|
invalid. Here, PARMS are the template parameters. IS_PRIMARY is
|
2771 |
|
|
nonzero if DECL is the thing declared by a primary template.
|
2772 |
|
|
IS_PARTIAL is nonzero if DECL is a partial specialization. */
|
2773 |
|
|
|
2774 |
|
|
static void
|
2775 |
|
|
check_default_tmpl_args (tree decl, tree parms, int is_primary, int is_partial)
|
2776 |
|
|
{
|
2777 |
|
|
const char *msg;
|
2778 |
|
|
int last_level_to_check;
|
2779 |
|
|
tree parm_level;
|
2780 |
|
|
|
2781 |
|
|
/* [temp.param]
|
2782 |
|
|
|
2783 |
|
|
A default template-argument shall not be specified in a
|
2784 |
|
|
function template declaration or a function template definition, nor
|
2785 |
|
|
in the template-parameter-list of the definition of a member of a
|
2786 |
|
|
class template. */
|
2787 |
|
|
|
2788 |
|
|
if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
|
2789 |
|
|
/* You can't have a function template declaration in a local
|
2790 |
|
|
scope, nor you can you define a member of a class template in a
|
2791 |
|
|
local scope. */
|
2792 |
|
|
return;
|
2793 |
|
|
|
2794 |
|
|
if (current_class_type
|
2795 |
|
|
&& !TYPE_BEING_DEFINED (current_class_type)
|
2796 |
|
|
&& DECL_LANG_SPECIFIC (decl)
|
2797 |
|
|
/* If this is either a friend defined in the scope of the class
|
2798 |
|
|
or a member function. */
|
2799 |
|
|
&& (DECL_FUNCTION_MEMBER_P (decl)
|
2800 |
|
|
? same_type_p (DECL_CONTEXT (decl), current_class_type)
|
2801 |
|
|
: DECL_FRIEND_CONTEXT (decl)
|
2802 |
|
|
? same_type_p (DECL_FRIEND_CONTEXT (decl), current_class_type)
|
2803 |
|
|
: false)
|
2804 |
|
|
/* And, if it was a member function, it really was defined in
|
2805 |
|
|
the scope of the class. */
|
2806 |
|
|
&& (!DECL_FUNCTION_MEMBER_P (decl)
|
2807 |
|
|
|| DECL_INITIALIZED_IN_CLASS_P (decl)))
|
2808 |
|
|
/* We already checked these parameters when the template was
|
2809 |
|
|
declared, so there's no need to do it again now. This function
|
2810 |
|
|
was defined in class scope, but we're processing it's body now
|
2811 |
|
|
that the class is complete. */
|
2812 |
|
|
return;
|
2813 |
|
|
|
2814 |
|
|
/* [temp.param]
|
2815 |
|
|
|
2816 |
|
|
If a template-parameter has a default template-argument, all
|
2817 |
|
|
subsequent template-parameters shall have a default
|
2818 |
|
|
template-argument supplied. */
|
2819 |
|
|
for (parm_level = parms; parm_level; parm_level = TREE_CHAIN (parm_level))
|
2820 |
|
|
{
|
2821 |
|
|
tree inner_parms = TREE_VALUE (parm_level);
|
2822 |
|
|
int ntparms = TREE_VEC_LENGTH (inner_parms);
|
2823 |
|
|
int seen_def_arg_p = 0;
|
2824 |
|
|
int i;
|
2825 |
|
|
|
2826 |
|
|
for (i = 0; i < ntparms; ++i)
|
2827 |
|
|
{
|
2828 |
|
|
tree parm = TREE_VEC_ELT (inner_parms, i);
|
2829 |
|
|
if (TREE_PURPOSE (parm))
|
2830 |
|
|
seen_def_arg_p = 1;
|
2831 |
|
|
else if (seen_def_arg_p)
|
2832 |
|
|
{
|
2833 |
|
|
error ("no default argument for %qD", TREE_VALUE (parm));
|
2834 |
|
|
/* For better subsequent error-recovery, we indicate that
|
2835 |
|
|
there should have been a default argument. */
|
2836 |
|
|
TREE_PURPOSE (parm) = error_mark_node;
|
2837 |
|
|
}
|
2838 |
|
|
}
|
2839 |
|
|
}
|
2840 |
|
|
|
2841 |
|
|
if (TREE_CODE (decl) != TYPE_DECL || is_partial || !is_primary)
|
2842 |
|
|
/* For an ordinary class template, default template arguments are
|
2843 |
|
|
allowed at the innermost level, e.g.:
|
2844 |
|
|
template <class T = int>
|
2845 |
|
|
struct S {};
|
2846 |
|
|
but, in a partial specialization, they're not allowed even
|
2847 |
|
|
there, as we have in [temp.class.spec]:
|
2848 |
|
|
|
2849 |
|
|
The template parameter list of a specialization shall not
|
2850 |
|
|
contain default template argument values.
|
2851 |
|
|
|
2852 |
|
|
So, for a partial specialization, or for a function template,
|
2853 |
|
|
we look at all of them. */
|
2854 |
|
|
;
|
2855 |
|
|
else
|
2856 |
|
|
/* But, for a primary class template that is not a partial
|
2857 |
|
|
specialization we look at all template parameters except the
|
2858 |
|
|
innermost ones. */
|
2859 |
|
|
parms = TREE_CHAIN (parms);
|
2860 |
|
|
|
2861 |
|
|
/* Figure out what error message to issue. */
|
2862 |
|
|
if (TREE_CODE (decl) == FUNCTION_DECL)
|
2863 |
|
|
msg = "default template arguments may not be used in function templates";
|
2864 |
|
|
else if (is_partial)
|
2865 |
|
|
msg = "default template arguments may not be used in partial specializations";
|
2866 |
|
|
else
|
2867 |
|
|
msg = "default argument for template parameter for class enclosing %qD";
|
2868 |
|
|
|
2869 |
|
|
if (current_class_type && TYPE_BEING_DEFINED (current_class_type))
|
2870 |
|
|
/* If we're inside a class definition, there's no need to
|
2871 |
|
|
examine the parameters to the class itself. On the one
|
2872 |
|
|
hand, they will be checked when the class is defined, and,
|
2873 |
|
|
on the other, default arguments are valid in things like:
|
2874 |
|
|
template <class T = double>
|
2875 |
|
|
struct S { template <class U> void f(U); };
|
2876 |
|
|
Here the default argument for `S' has no bearing on the
|
2877 |
|
|
declaration of `f'. */
|
2878 |
|
|
last_level_to_check = template_class_depth (current_class_type) + 1;
|
2879 |
|
|
else
|
2880 |
|
|
/* Check everything. */
|
2881 |
|
|
last_level_to_check = 0;
|
2882 |
|
|
|
2883 |
|
|
for (parm_level = parms;
|
2884 |
|
|
parm_level && TMPL_PARMS_DEPTH (parm_level) >= last_level_to_check;
|
2885 |
|
|
parm_level = TREE_CHAIN (parm_level))
|
2886 |
|
|
{
|
2887 |
|
|
tree inner_parms = TREE_VALUE (parm_level);
|
2888 |
|
|
int i;
|
2889 |
|
|
int ntparms;
|
2890 |
|
|
|
2891 |
|
|
ntparms = TREE_VEC_LENGTH (inner_parms);
|
2892 |
|
|
for (i = 0; i < ntparms; ++i)
|
2893 |
|
|
if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)))
|
2894 |
|
|
{
|
2895 |
|
|
if (msg)
|
2896 |
|
|
{
|
2897 |
|
|
error (msg, decl);
|
2898 |
|
|
msg = 0;
|
2899 |
|
|
}
|
2900 |
|
|
|
2901 |
|
|
/* Clear out the default argument so that we are not
|
2902 |
|
|
confused later. */
|
2903 |
|
|
TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)) = NULL_TREE;
|
2904 |
|
|
}
|
2905 |
|
|
|
2906 |
|
|
/* At this point, if we're still interested in issuing messages,
|
2907 |
|
|
they must apply to classes surrounding the object declared. */
|
2908 |
|
|
if (msg)
|
2909 |
|
|
msg = "default argument for template parameter for class enclosing %qD";
|
2910 |
|
|
}
|
2911 |
|
|
}
|
2912 |
|
|
|
2913 |
|
|
/* Worker for push_template_decl_real, called via
|
2914 |
|
|
for_each_template_parm. DATA is really an int, indicating the
|
2915 |
|
|
level of the parameters we are interested in. If T is a template
|
2916 |
|
|
parameter of that level, return nonzero. */
|
2917 |
|
|
|
2918 |
|
|
static int
|
2919 |
|
|
template_parm_this_level_p (tree t, void* data)
|
2920 |
|
|
{
|
2921 |
|
|
int this_level = *(int *)data;
|
2922 |
|
|
int level;
|
2923 |
|
|
|
2924 |
|
|
if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
|
2925 |
|
|
level = TEMPLATE_PARM_LEVEL (t);
|
2926 |
|
|
else
|
2927 |
|
|
level = TEMPLATE_TYPE_LEVEL (t);
|
2928 |
|
|
return level == this_level;
|
2929 |
|
|
}
|
2930 |
|
|
|
2931 |
|
|
/* Creates a TEMPLATE_DECL for the indicated DECL using the template
|
2932 |
|
|
parameters given by current_template_args, or reuses a
|
2933 |
|
|
previously existing one, if appropriate. Returns the DECL, or an
|
2934 |
|
|
equivalent one, if it is replaced via a call to duplicate_decls.
|
2935 |
|
|
|
2936 |
|
|
If IS_FRIEND is true, DECL is a friend declaration. */
|
2937 |
|
|
|
2938 |
|
|
tree
|
2939 |
|
|
push_template_decl_real (tree decl, bool is_friend)
|
2940 |
|
|
{
|
2941 |
|
|
tree tmpl;
|
2942 |
|
|
tree args;
|
2943 |
|
|
tree info;
|
2944 |
|
|
tree ctx;
|
2945 |
|
|
int primary;
|
2946 |
|
|
int is_partial;
|
2947 |
|
|
int new_template_p = 0;
|
2948 |
|
|
/* True if the template is a member template, in the sense of
|
2949 |
|
|
[temp.mem]. */
|
2950 |
|
|
bool member_template_p = false;
|
2951 |
|
|
|
2952 |
|
|
if (decl == error_mark_node)
|
2953 |
|
|
return decl;
|
2954 |
|
|
|
2955 |
|
|
/* See if this is a partial specialization. */
|
2956 |
|
|
is_partial = (DECL_IMPLICIT_TYPEDEF_P (decl)
|
2957 |
|
|
&& TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE
|
2958 |
|
|
&& CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)));
|
2959 |
|
|
|
2960 |
|
|
if (TREE_CODE (decl) == FUNCTION_DECL && DECL_FRIEND_P (decl))
|
2961 |
|
|
is_friend = true;
|
2962 |
|
|
|
2963 |
|
|
if (is_friend)
|
2964 |
|
|
/* For a friend, we want the context of the friend function, not
|
2965 |
|
|
the type of which it is a friend. */
|
2966 |
|
|
ctx = DECL_CONTEXT (decl);
|
2967 |
|
|
else if (CP_DECL_CONTEXT (decl)
|
2968 |
|
|
&& TREE_CODE (CP_DECL_CONTEXT (decl)) != NAMESPACE_DECL)
|
2969 |
|
|
/* In the case of a virtual function, we want the class in which
|
2970 |
|
|
it is defined. */
|
2971 |
|
|
ctx = CP_DECL_CONTEXT (decl);
|
2972 |
|
|
else
|
2973 |
|
|
/* Otherwise, if we're currently defining some class, the DECL
|
2974 |
|
|
is assumed to be a member of the class. */
|
2975 |
|
|
ctx = current_scope ();
|
2976 |
|
|
|
2977 |
|
|
if (ctx && TREE_CODE (ctx) == NAMESPACE_DECL)
|
2978 |
|
|
ctx = NULL_TREE;
|
2979 |
|
|
|
2980 |
|
|
if (!DECL_CONTEXT (decl))
|
2981 |
|
|
DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
|
2982 |
|
|
|
2983 |
|
|
/* See if this is a primary template. */
|
2984 |
|
|
primary = template_parm_scope_p ();
|
2985 |
|
|
|
2986 |
|
|
if (primary)
|
2987 |
|
|
{
|
2988 |
|
|
if (DECL_CLASS_SCOPE_P (decl))
|
2989 |
|
|
member_template_p = true;
|
2990 |
|
|
if (TREE_CODE (decl) == TYPE_DECL
|
2991 |
|
|
&& ANON_AGGRNAME_P (DECL_NAME (decl)))
|
2992 |
|
|
error ("template class without a name");
|
2993 |
|
|
else if (TREE_CODE (decl) == FUNCTION_DECL)
|
2994 |
|
|
{
|
2995 |
|
|
if (DECL_DESTRUCTOR_P (decl))
|
2996 |
|
|
{
|
2997 |
|
|
/* [temp.mem]
|
2998 |
|
|
|
2999 |
|
|
A destructor shall not be a member template. */
|
3000 |
|
|
error ("destructor %qD declared as member template", decl);
|
3001 |
|
|
return error_mark_node;
|
3002 |
|
|
}
|
3003 |
|
|
if (NEW_DELETE_OPNAME_P (DECL_NAME (decl))
|
3004 |
|
|
&& (!TYPE_ARG_TYPES (TREE_TYPE (decl))
|
3005 |
|
|
|| TYPE_ARG_TYPES (TREE_TYPE (decl)) == void_list_node
|
3006 |
|
|
|| !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
|
3007 |
|
|
|| (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl))))
|
3008 |
|
|
== void_list_node)))
|
3009 |
|
|
{
|
3010 |
|
|
/* [basic.stc.dynamic.allocation]
|
3011 |
|
|
|
3012 |
|
|
An allocation function can be a function
|
3013 |
|
|
template. ... Template allocation functions shall
|
3014 |
|
|
have two or more parameters. */
|
3015 |
|
|
error ("invalid template declaration of %qD", decl);
|
3016 |
|
|
return decl;
|
3017 |
|
|
}
|
3018 |
|
|
}
|
3019 |
|
|
else if (DECL_IMPLICIT_TYPEDEF_P (decl)
|
3020 |
|
|
&& CLASS_TYPE_P (TREE_TYPE (decl)))
|
3021 |
|
|
/* OK */;
|
3022 |
|
|
else
|
3023 |
|
|
{
|
3024 |
|
|
error ("template declaration of %q#D", decl);
|
3025 |
|
|
return error_mark_node;
|
3026 |
|
|
}
|
3027 |
|
|
}
|
3028 |
|
|
|
3029 |
|
|
/* Check to see that the rules regarding the use of default
|
3030 |
|
|
arguments are not being violated. */
|
3031 |
|
|
check_default_tmpl_args (decl, current_template_parms,
|
3032 |
|
|
primary, is_partial);
|
3033 |
|
|
|
3034 |
|
|
if (is_partial)
|
3035 |
|
|
return process_partial_specialization (decl);
|
3036 |
|
|
|
3037 |
|
|
args = current_template_args ();
|
3038 |
|
|
|
3039 |
|
|
if (!ctx
|
3040 |
|
|
|| TREE_CODE (ctx) == FUNCTION_DECL
|
3041 |
|
|
|| (CLASS_TYPE_P (ctx) && TYPE_BEING_DEFINED (ctx))
|
3042 |
|
|
|| (is_friend && !DECL_TEMPLATE_INFO (decl)))
|
3043 |
|
|
{
|
3044 |
|
|
if (DECL_LANG_SPECIFIC (decl)
|
3045 |
|
|
&& DECL_TEMPLATE_INFO (decl)
|
3046 |
|
|
&& DECL_TI_TEMPLATE (decl))
|
3047 |
|
|
tmpl = DECL_TI_TEMPLATE (decl);
|
3048 |
|
|
/* If DECL is a TYPE_DECL for a class-template, then there won't
|
3049 |
|
|
be DECL_LANG_SPECIFIC. The information equivalent to
|
3050 |
|
|
DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
|
3051 |
|
|
else if (DECL_IMPLICIT_TYPEDEF_P (decl)
|
3052 |
|
|
&& TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
|
3053 |
|
|
&& TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
|
3054 |
|
|
{
|
3055 |
|
|
/* Since a template declaration already existed for this
|
3056 |
|
|
class-type, we must be redeclaring it here. Make sure
|
3057 |
|
|
that the redeclaration is valid. */
|
3058 |
|
|
redeclare_class_template (TREE_TYPE (decl),
|
3059 |
|
|
current_template_parms);
|
3060 |
|
|
/* We don't need to create a new TEMPLATE_DECL; just use the
|
3061 |
|
|
one we already had. */
|
3062 |
|
|
tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
|
3063 |
|
|
}
|
3064 |
|
|
else
|
3065 |
|
|
{
|
3066 |
|
|
tmpl = build_template_decl (decl, current_template_parms,
|
3067 |
|
|
member_template_p);
|
3068 |
|
|
new_template_p = 1;
|
3069 |
|
|
|
3070 |
|
|
if (DECL_LANG_SPECIFIC (decl)
|
3071 |
|
|
&& DECL_TEMPLATE_SPECIALIZATION (decl))
|
3072 |
|
|
{
|
3073 |
|
|
/* A specialization of a member template of a template
|
3074 |
|
|
class. */
|
3075 |
|
|
SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
|
3076 |
|
|
DECL_TEMPLATE_INFO (tmpl) = DECL_TEMPLATE_INFO (decl);
|
3077 |
|
|
DECL_TEMPLATE_INFO (decl) = NULL_TREE;
|
3078 |
|
|
}
|
3079 |
|
|
}
|
3080 |
|
|
}
|
3081 |
|
|
else
|
3082 |
|
|
{
|
3083 |
|
|
tree a, t, current, parms;
|
3084 |
|
|
int i;
|
3085 |
|
|
|
3086 |
|
|
if (TREE_CODE (decl) == TYPE_DECL)
|
3087 |
|
|
{
|
3088 |
|
|
if ((IS_AGGR_TYPE_CODE (TREE_CODE (TREE_TYPE (decl)))
|
3089 |
|
|
|| TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
|
3090 |
|
|
&& TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
|
3091 |
|
|
&& TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
|
3092 |
|
|
tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
|
3093 |
|
|
else
|
3094 |
|
|
{
|
3095 |
|
|
error ("%qD does not declare a template type", decl);
|
3096 |
|
|
return decl;
|
3097 |
|
|
}
|
3098 |
|
|
}
|
3099 |
|
|
else if (!DECL_LANG_SPECIFIC (decl) || !DECL_TEMPLATE_INFO (decl))
|
3100 |
|
|
{
|
3101 |
|
|
error ("template definition of non-template %q#D", decl);
|
3102 |
|
|
return decl;
|
3103 |
|
|
}
|
3104 |
|
|
else
|
3105 |
|
|
tmpl = DECL_TI_TEMPLATE (decl);
|
3106 |
|
|
|
3107 |
|
|
if (DECL_FUNCTION_TEMPLATE_P (tmpl)
|
3108 |
|
|
&& DECL_TEMPLATE_INFO (decl) && DECL_TI_ARGS (decl)
|
3109 |
|
|
&& DECL_TEMPLATE_SPECIALIZATION (decl)
|
3110 |
|
|
&& DECL_MEMBER_TEMPLATE_P (tmpl))
|
3111 |
|
|
{
|
3112 |
|
|
tree new_tmpl;
|
3113 |
|
|
|
3114 |
|
|
/* The declaration is a specialization of a member
|
3115 |
|
|
template, declared outside the class. Therefore, the
|
3116 |
|
|
innermost template arguments will be NULL, so we
|
3117 |
|
|
replace them with the arguments determined by the
|
3118 |
|
|
earlier call to check_explicit_specialization. */
|
3119 |
|
|
args = DECL_TI_ARGS (decl);
|
3120 |
|
|
|
3121 |
|
|
new_tmpl
|
3122 |
|
|
= build_template_decl (decl, current_template_parms,
|
3123 |
|
|
member_template_p);
|
3124 |
|
|
DECL_TEMPLATE_RESULT (new_tmpl) = decl;
|
3125 |
|
|
TREE_TYPE (new_tmpl) = TREE_TYPE (decl);
|
3126 |
|
|
DECL_TI_TEMPLATE (decl) = new_tmpl;
|
3127 |
|
|
SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl);
|
3128 |
|
|
DECL_TEMPLATE_INFO (new_tmpl)
|
3129 |
|
|
= tree_cons (tmpl, args, NULL_TREE);
|
3130 |
|
|
|
3131 |
|
|
register_specialization (new_tmpl,
|
3132 |
|
|
most_general_template (tmpl),
|
3133 |
|
|
args,
|
3134 |
|
|
is_friend);
|
3135 |
|
|
return decl;
|
3136 |
|
|
}
|
3137 |
|
|
|
3138 |
|
|
/* Make sure the template headers we got make sense. */
|
3139 |
|
|
|
3140 |
|
|
parms = DECL_TEMPLATE_PARMS (tmpl);
|
3141 |
|
|
i = TMPL_PARMS_DEPTH (parms);
|
3142 |
|
|
if (TMPL_ARGS_DEPTH (args) != i)
|
3143 |
|
|
{
|
3144 |
|
|
error ("expected %d levels of template parms for %q#D, got %d",
|
3145 |
|
|
i, decl, TMPL_ARGS_DEPTH (args));
|
3146 |
|
|
}
|
3147 |
|
|
else
|
3148 |
|
|
for (current = decl; i > 0; --i, parms = TREE_CHAIN (parms))
|
3149 |
|
|
{
|
3150 |
|
|
a = TMPL_ARGS_LEVEL (args, i);
|
3151 |
|
|
t = INNERMOST_TEMPLATE_PARMS (parms);
|
3152 |
|
|
|
3153 |
|
|
if (TREE_VEC_LENGTH (t) != TREE_VEC_LENGTH (a))
|
3154 |
|
|
{
|
3155 |
|
|
if (current == decl)
|
3156 |
|
|
error ("got %d template parameters for %q#D",
|
3157 |
|
|
TREE_VEC_LENGTH (a), decl);
|
3158 |
|
|
else
|
3159 |
|
|
error ("got %d template parameters for %q#T",
|
3160 |
|
|
TREE_VEC_LENGTH (a), current);
|
3161 |
|
|
error (" but %d required", TREE_VEC_LENGTH (t));
|
3162 |
|
|
return error_mark_node;
|
3163 |
|
|
}
|
3164 |
|
|
|
3165 |
|
|
/* Perhaps we should also check that the parms are used in the
|
3166 |
|
|
appropriate qualifying scopes in the declarator? */
|
3167 |
|
|
|
3168 |
|
|
if (current == decl)
|
3169 |
|
|
current = ctx;
|
3170 |
|
|
else
|
3171 |
|
|
current = TYPE_CONTEXT (current);
|
3172 |
|
|
}
|
3173 |
|
|
}
|
3174 |
|
|
|
3175 |
|
|
DECL_TEMPLATE_RESULT (tmpl) = decl;
|
3176 |
|
|
TREE_TYPE (tmpl) = TREE_TYPE (decl);
|
3177 |
|
|
|
3178 |
|
|
/* Push template declarations for global functions and types. Note
|
3179 |
|
|
that we do not try to push a global template friend declared in a
|
3180 |
|
|
template class; such a thing may well depend on the template
|
3181 |
|
|
parameters of the class. */
|
3182 |
|
|
if (new_template_p && !ctx
|
3183 |
|
|
&& !(is_friend && template_class_depth (current_class_type) > 0))
|
3184 |
|
|
{
|
3185 |
|
|
tmpl = pushdecl_namespace_level (tmpl, is_friend);
|
3186 |
|
|
if (tmpl == error_mark_node)
|
3187 |
|
|
return error_mark_node;
|
3188 |
|
|
|
3189 |
|
|
/* Hide template friend classes that haven't been declared yet. */
|
3190 |
|
|
if (is_friend && TREE_CODE (decl) == TYPE_DECL)
|
3191 |
|
|
{
|
3192 |
|
|
DECL_ANTICIPATED (tmpl) = 1;
|
3193 |
|
|
DECL_FRIEND_P (tmpl) = 1;
|
3194 |
|
|
}
|
3195 |
|
|
}
|
3196 |
|
|
|
3197 |
|
|
if (primary)
|
3198 |
|
|
{
|
3199 |
|
|
DECL_PRIMARY_TEMPLATE (tmpl) = tmpl;
|
3200 |
|
|
if (DECL_CONV_FN_P (tmpl))
|
3201 |
|
|
{
|
3202 |
|
|
int depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
|
3203 |
|
|
|
3204 |
|
|
/* It is a conversion operator. See if the type converted to
|
3205 |
|
|
depends on innermost template operands. */
|
3206 |
|
|
|
3207 |
|
|
if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl)),
|
3208 |
|
|
depth))
|
3209 |
|
|
DECL_TEMPLATE_CONV_FN_P (tmpl) = 1;
|
3210 |
|
|
}
|
3211 |
|
|
}
|
3212 |
|
|
|
3213 |
|
|
/* The DECL_TI_ARGS of DECL contains full set of arguments referring
|
3214 |
|
|
back to its most general template. If TMPL is a specialization,
|
3215 |
|
|
ARGS may only have the innermost set of arguments. Add the missing
|
3216 |
|
|
argument levels if necessary. */
|
3217 |
|
|
if (DECL_TEMPLATE_INFO (tmpl))
|
3218 |
|
|
args = add_outermost_template_args (DECL_TI_ARGS (tmpl), args);
|
3219 |
|
|
|
3220 |
|
|
info = tree_cons (tmpl, args, NULL_TREE);
|
3221 |
|
|
|
3222 |
|
|
if (DECL_IMPLICIT_TYPEDEF_P (decl))
|
3223 |
|
|
{
|
3224 |
|
|
SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl), info);
|
3225 |
|
|
if ((!ctx || TREE_CODE (ctx) != FUNCTION_DECL)
|
3226 |
|
|
&& TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE
|
3227 |
|
|
/* Don't change the name if we've already set it up. */
|
3228 |
|
|
&& !IDENTIFIER_TEMPLATE (DECL_NAME (decl)))
|
3229 |
|
|
DECL_NAME (decl) = classtype_mangled_name (TREE_TYPE (decl));
|
3230 |
|
|
}
|
3231 |
|
|
else if (DECL_LANG_SPECIFIC (decl))
|
3232 |
|
|
DECL_TEMPLATE_INFO (decl) = info;
|
3233 |
|
|
|
3234 |
|
|
return DECL_TEMPLATE_RESULT (tmpl);
|
3235 |
|
|
}
|
3236 |
|
|
|
3237 |
|
|
tree
|
3238 |
|
|
push_template_decl (tree decl)
|
3239 |
|
|
{
|
3240 |
|
|
return push_template_decl_real (decl, false);
|
3241 |
|
|
}
|
3242 |
|
|
|
3243 |
|
|
/* Called when a class template TYPE is redeclared with the indicated
|
3244 |
|
|
template PARMS, e.g.:
|
3245 |
|
|
|
3246 |
|
|
template <class T> struct S;
|
3247 |
|
|
template <class T> struct S {}; */
|
3248 |
|
|
|
3249 |
|
|
void
|
3250 |
|
|
redeclare_class_template (tree type, tree parms)
|
3251 |
|
|
{
|
3252 |
|
|
tree tmpl;
|
3253 |
|
|
tree tmpl_parms;
|
3254 |
|
|
int i;
|
3255 |
|
|
|
3256 |
|
|
if (!TYPE_TEMPLATE_INFO (type))
|
3257 |
|
|
{
|
3258 |
|
|
error ("%qT is not a template type", type);
|
3259 |
|
|
return;
|
3260 |
|
|
}
|
3261 |
|
|
|
3262 |
|
|
tmpl = TYPE_TI_TEMPLATE (type);
|
3263 |
|
|
if (!PRIMARY_TEMPLATE_P (tmpl))
|
3264 |
|
|
/* The type is nested in some template class. Nothing to worry
|
3265 |
|
|
about here; there are no new template parameters for the nested
|
3266 |
|
|
type. */
|
3267 |
|
|
return;
|
3268 |
|
|
|
3269 |
|
|
if (!parms)
|
3270 |
|
|
{
|
3271 |
|
|
error ("template specifiers not specified in declaration of %qD",
|
3272 |
|
|
tmpl);
|
3273 |
|
|
return;
|
3274 |
|
|
}
|
3275 |
|
|
|
3276 |
|
|
parms = INNERMOST_TEMPLATE_PARMS (parms);
|
3277 |
|
|
tmpl_parms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl);
|
3278 |
|
|
|
3279 |
|
|
if (TREE_VEC_LENGTH (parms) != TREE_VEC_LENGTH (tmpl_parms))
|
3280 |
|
|
{
|
3281 |
|
|
error ("previous declaration %q+D", tmpl);
|
3282 |
|
|
error ("used %d template parameter(s) instead of %d",
|
3283 |
|
|
TREE_VEC_LENGTH (tmpl_parms),
|
3284 |
|
|
TREE_VEC_LENGTH (parms));
|
3285 |
|
|
return;
|
3286 |
|
|
}
|
3287 |
|
|
|
3288 |
|
|
for (i = 0; i < TREE_VEC_LENGTH (tmpl_parms); ++i)
|
3289 |
|
|
{
|
3290 |
|
|
tree tmpl_parm = TREE_VALUE (TREE_VEC_ELT (tmpl_parms, i));
|
3291 |
|
|
tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
|
3292 |
|
|
tree tmpl_default = TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i));
|
3293 |
|
|
tree parm_default = TREE_PURPOSE (TREE_VEC_ELT (parms, i));
|
3294 |
|
|
|
3295 |
|
|
/* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
|
3296 |
|
|
TEMPLATE_DECL. */
|
3297 |
|
|
if (TREE_CODE (tmpl_parm) != TREE_CODE (parm)
|
3298 |
|
|
|| (TREE_CODE (tmpl_parm) != TYPE_DECL
|
3299 |
|
|
&& !same_type_p (TREE_TYPE (tmpl_parm), TREE_TYPE (parm))))
|
3300 |
|
|
{
|
3301 |
|
|
error ("template parameter %q+#D", tmpl_parm);
|
3302 |
|
|
error ("redeclared here as %q#D", parm);
|
3303 |
|
|
return;
|
3304 |
|
|
}
|
3305 |
|
|
|
3306 |
|
|
if (tmpl_default != NULL_TREE && parm_default != NULL_TREE)
|
3307 |
|
|
{
|
3308 |
|
|
/* We have in [temp.param]:
|
3309 |
|
|
|
3310 |
|
|
A template-parameter may not be given default arguments
|
3311 |
|
|
by two different declarations in the same scope. */
|
3312 |
|
|
error ("redefinition of default argument for %q#D", parm);
|
3313 |
|
|
error ("%J original definition appeared here", tmpl_parm);
|
3314 |
|
|
return;
|
3315 |
|
|
}
|
3316 |
|
|
|
3317 |
|
|
if (parm_default != NULL_TREE)
|
3318 |
|
|
/* Update the previous template parameters (which are the ones
|
3319 |
|
|
that will really count) with the new default value. */
|
3320 |
|
|
TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i)) = parm_default;
|
3321 |
|
|
else if (tmpl_default != NULL_TREE)
|
3322 |
|
|
/* Update the new parameters, too; they'll be used as the
|
3323 |
|
|
parameters for any members. */
|
3324 |
|
|
TREE_PURPOSE (TREE_VEC_ELT (parms, i)) = tmpl_default;
|
3325 |
|
|
}
|
3326 |
|
|
}
|
3327 |
|
|
|
3328 |
|
|
/* Simplify EXPR if it is a non-dependent expression. Returns the
|
3329 |
|
|
(possibly simplified) expression. */
|
3330 |
|
|
|
3331 |
|
|
tree
|
3332 |
|
|
fold_non_dependent_expr (tree expr)
|
3333 |
|
|
{
|
3334 |
|
|
/* If we're in a template, but EXPR isn't value dependent, simplify
|
3335 |
|
|
it. We're supposed to treat:
|
3336 |
|
|
|
3337 |
|
|
template <typename T> void f(T[1 + 1]);
|
3338 |
|
|
template <typename T> void f(T[2]);
|
3339 |
|
|
|
3340 |
|
|
as two declarations of the same function, for example. */
|
3341 |
|
|
if (processing_template_decl
|
3342 |
|
|
&& !type_dependent_expression_p (expr)
|
3343 |
|
|
&& !value_dependent_expression_p (expr))
|
3344 |
|
|
{
|
3345 |
|
|
HOST_WIDE_INT saved_processing_template_decl;
|
3346 |
|
|
|
3347 |
|
|
saved_processing_template_decl = processing_template_decl;
|
3348 |
|
|
processing_template_decl = 0;
|
3349 |
|
|
expr = tsubst_copy_and_build (expr,
|
3350 |
|
|
/*args=*/NULL_TREE,
|
3351 |
|
|
tf_error,
|
3352 |
|
|
/*in_decl=*/NULL_TREE,
|
3353 |
|
|
/*function_p=*/false);
|
3354 |
|
|
processing_template_decl = saved_processing_template_decl;
|
3355 |
|
|
}
|
3356 |
|
|
return expr;
|
3357 |
|
|
}
|
3358 |
|
|
|
3359 |
|
|
/* EXPR is an expression which is used in a constant-expression context.
|
3360 |
|
|
For instance, it could be a VAR_DECL with a constant initializer.
|
3361 |
|
|
Extract the innest constant expression.
|
3362 |
|
|
|
3363 |
|
|
This is basically a more powerful version of
|
3364 |
|
|
integral_constant_value, which can be used also in templates where
|
3365 |
|
|
initializers can maintain a syntactic rather than semantic form
|
3366 |
|
|
(even if they are non-dependent, for access-checking purposes). */
|
3367 |
|
|
|
3368 |
|
|
tree
|
3369 |
|
|
fold_decl_constant_value (tree expr)
|
3370 |
|
|
{
|
3371 |
|
|
tree const_expr = expr;
|
3372 |
|
|
do
|
3373 |
|
|
{
|
3374 |
|
|
expr = fold_non_dependent_expr (const_expr);
|
3375 |
|
|
const_expr = integral_constant_value (expr);
|
3376 |
|
|
}
|
3377 |
|
|
while (expr != const_expr);
|
3378 |
|
|
|
3379 |
|
|
return expr;
|
3380 |
|
|
}
|
3381 |
|
|
|
3382 |
|
|
/* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
|
3383 |
|
|
must be a function or a pointer-to-function type, as specified
|
3384 |
|
|
in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
|
3385 |
|
|
and check that the resulting function has external linkage. */
|
3386 |
|
|
|
3387 |
|
|
static tree
|
3388 |
|
|
convert_nontype_argument_function (tree type, tree expr)
|
3389 |
|
|
{
|
3390 |
|
|
tree fns = expr;
|
3391 |
|
|
tree fn, fn_no_ptr;
|
3392 |
|
|
|
3393 |
|
|
fn = instantiate_type (type, fns, tf_none);
|
3394 |
|
|
if (fn == error_mark_node)
|
3395 |
|
|
return error_mark_node;
|
3396 |
|
|
|
3397 |
|
|
fn_no_ptr = fn;
|
3398 |
|
|
if (TREE_CODE (fn_no_ptr) == ADDR_EXPR)
|
3399 |
|
|
fn_no_ptr = TREE_OPERAND (fn_no_ptr, 0);
|
3400 |
|
|
|
3401 |
|
|
/* [temp.arg.nontype]/1
|
3402 |
|
|
|
3403 |
|
|
A template-argument for a non-type, non-template template-parameter
|
3404 |
|
|
shall be one of:
|
3405 |
|
|
[...]
|
3406 |
|
|
-- the address of an object or function with external linkage. */
|
3407 |
|
|
if (!DECL_EXTERNAL_LINKAGE_P (fn_no_ptr))
|
3408 |
|
|
{
|
3409 |
|
|
error ("%qE is not a valid template argument for type %qT "
|
3410 |
|
|
"because function %qD has not external linkage",
|
3411 |
|
|
expr, type, fn_no_ptr);
|
3412 |
|
|
return NULL_TREE;
|
3413 |
|
|
}
|
3414 |
|
|
|
3415 |
|
|
return fn;
|
3416 |
|
|
}
|
3417 |
|
|
|
3418 |
|
|
/* Attempt to convert the non-type template parameter EXPR to the
|
3419 |
|
|
indicated TYPE. If the conversion is successful, return the
|
3420 |
|
|
converted value. If the conversion is unsuccessful, return
|
3421 |
|
|
NULL_TREE if we issued an error message, or error_mark_node if we
|
3422 |
|
|
did not. We issue error messages for out-and-out bad template
|
3423 |
|
|
parameters, but not simply because the conversion failed, since we
|
3424 |
|
|
might be just trying to do argument deduction. Both TYPE and EXPR
|
3425 |
|
|
must be non-dependent.
|
3426 |
|
|
|
3427 |
|
|
The conversion follows the special rules described in
|
3428 |
|
|
[temp.arg.nontype], and it is much more strict than an implicit
|
3429 |
|
|
conversion.
|
3430 |
|
|
|
3431 |
|
|
This function is called twice for each template argument (see
|
3432 |
|
|
lookup_template_class for a more accurate description of this
|
3433 |
|
|
problem). This means that we need to handle expressions which
|
3434 |
|
|
are not valid in a C++ source, but can be created from the
|
3435 |
|
|
first call (for instance, casts to perform conversions). These
|
3436 |
|
|
hacks can go away after we fix the double coercion problem. */
|
3437 |
|
|
|
3438 |
|
|
static tree
|
3439 |
|
|
convert_nontype_argument (tree type, tree expr)
|
3440 |
|
|
{
|
3441 |
|
|
tree expr_type;
|
3442 |
|
|
|
3443 |
|
|
/* Detect immediately string literals as invalid non-type argument.
|
3444 |
|
|
This special-case is not needed for correctness (we would easily
|
3445 |
|
|
catch this later), but only to provide better diagnostic for this
|
3446 |
|
|
common user mistake. As suggested by DR 100, we do not mention
|
3447 |
|
|
linkage issues in the diagnostic as this is not the point. */
|
3448 |
|
|
if (TREE_CODE (expr) == STRING_CST)
|
3449 |
|
|
{
|
3450 |
|
|
error ("%qE is not a valid template argument for type %qT "
|
3451 |
|
|
"because string literals can never be used in this context",
|
3452 |
|
|
expr, type);
|
3453 |
|
|
return NULL_TREE;
|
3454 |
|
|
}
|
3455 |
|
|
|
3456 |
|
|
/* If we are in a template, EXPR may be non-dependent, but still
|
3457 |
|
|
have a syntactic, rather than semantic, form. For example, EXPR
|
3458 |
|
|
might be a SCOPE_REF, rather than the VAR_DECL to which the
|
3459 |
|
|
SCOPE_REF refers. Preserving the qualifying scope is necessary
|
3460 |
|
|
so that access checking can be performed when the template is
|
3461 |
|
|
instantiated -- but here we need the resolved form so that we can
|
3462 |
|
|
convert the argument. */
|
3463 |
|
|
expr = fold_non_dependent_expr (expr);
|
3464 |
|
|
if (error_operand_p (expr))
|
3465 |
|
|
return error_mark_node;
|
3466 |
|
|
expr_type = TREE_TYPE (expr);
|
3467 |
|
|
|
3468 |
|
|
/* HACK: Due to double coercion, we can get a
|
3469 |
|
|
NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
|
3470 |
|
|
which is the tree that we built on the first call (see
|
3471 |
|
|
below when coercing to reference to object or to reference to
|
3472 |
|
|
function). We just strip everything and get to the arg.
|
3473 |
|
|
See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
|
3474 |
|
|
for examples. */
|
3475 |
|
|
if (TREE_CODE (expr) == NOP_EXPR)
|
3476 |
|
|
{
|
3477 |
|
|
if (TYPE_REF_OBJ_P (type) || TYPE_REFFN_P (type))
|
3478 |
|
|
{
|
3479 |
|
|
/* ??? Maybe we could use convert_from_reference here, but we
|
3480 |
|
|
would need to relax its constraints because the NOP_EXPR
|
3481 |
|
|
could actually change the type to something more cv-qualified,
|
3482 |
|
|
and this is not folded by convert_from_reference. */
|
3483 |
|
|
tree addr = TREE_OPERAND (expr, 0);
|
3484 |
|
|
gcc_assert (TREE_CODE (expr_type) == REFERENCE_TYPE);
|
3485 |
|
|
gcc_assert (TREE_CODE (addr) == ADDR_EXPR);
|
3486 |
|
|
gcc_assert (TREE_CODE (TREE_TYPE (addr)) == POINTER_TYPE);
|
3487 |
|
|
gcc_assert (same_type_ignoring_top_level_qualifiers_p
|
3488 |
|
|
(TREE_TYPE (expr_type),
|
3489 |
|
|
TREE_TYPE (TREE_TYPE (addr))));
|
3490 |
|
|
|
3491 |
|
|
expr = TREE_OPERAND (addr, 0);
|
3492 |
|
|
expr_type = TREE_TYPE (expr);
|
3493 |
|
|
}
|
3494 |
|
|
|
3495 |
|
|
/* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
|
3496 |
|
|
parameter is a pointer to object, through decay and
|
3497 |
|
|
qualification conversion. Let's strip everything. */
|
3498 |
|
|
else if (TYPE_PTROBV_P (type))
|
3499 |
|
|
{
|
3500 |
|
|
STRIP_NOPS (expr);
|
3501 |
|
|
gcc_assert (TREE_CODE (expr) == ADDR_EXPR);
|
3502 |
|
|
gcc_assert (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE);
|
3503 |
|
|
/* Skip the ADDR_EXPR only if it is part of the decay for
|
3504 |
|
|
an array. Otherwise, it is part of the original argument
|
3505 |
|
|
in the source code. */
|
3506 |
|
|
if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == ARRAY_TYPE)
|
3507 |
|
|
expr = TREE_OPERAND (expr, 0);
|
3508 |
|
|
expr_type = TREE_TYPE (expr);
|
3509 |
|
|
}
|
3510 |
|
|
}
|
3511 |
|
|
|
3512 |
|
|
/* [temp.arg.nontype]/5, bullet 1
|
3513 |
|
|
|
3514 |
|
|
For a non-type template-parameter of integral or enumeration type,
|
3515 |
|
|
integral promotions (_conv.prom_) and integral conversions
|
3516 |
|
|
(_conv.integral_) are applied. */
|
3517 |
|
|
if (INTEGRAL_TYPE_P (type))
|
3518 |
|
|
{
|
3519 |
|
|
if (!INTEGRAL_TYPE_P (expr_type))
|
3520 |
|
|
return error_mark_node;
|
3521 |
|
|
|
3522 |
|
|
expr = fold_decl_constant_value (expr);
|
3523 |
|
|
/* Notice that there are constant expressions like '4 % 0' which
|
3524 |
|
|
do not fold into integer constants. */
|
3525 |
|
|
if (TREE_CODE (expr) != INTEGER_CST)
|
3526 |
|
|
{
|
3527 |
|
|
error ("%qE is not a valid template argument for type %qT "
|
3528 |
|
|
"because it is a non-constant expression", expr, type);
|
3529 |
|
|
return NULL_TREE;
|
3530 |
|
|
}
|
3531 |
|
|
|
3532 |
|
|
/* At this point, an implicit conversion does what we want,
|
3533 |
|
|
because we already know that the expression is of integral
|
3534 |
|
|
type. */
|
3535 |
|
|
expr = ocp_convert (type, expr, CONV_IMPLICIT, LOOKUP_PROTECT);
|
3536 |
|
|
if (expr == error_mark_node)
|
3537 |
|
|
return error_mark_node;
|
3538 |
|
|
|
3539 |
|
|
/* Conversion was allowed: fold it to a bare integer constant. */
|
3540 |
|
|
expr = fold (expr);
|
3541 |
|
|
}
|
3542 |
|
|
/* [temp.arg.nontype]/5, bullet 2
|
3543 |
|
|
|
3544 |
|
|
For a non-type template-parameter of type pointer to object,
|
3545 |
|
|
qualification conversions (_conv.qual_) and the array-to-pointer
|
3546 |
|
|
conversion (_conv.array_) are applied. */
|
3547 |
|
|
else if (TYPE_PTROBV_P (type))
|
3548 |
|
|
{
|
3549 |
|
|
/* [temp.arg.nontype]/1 (TC1 version, DR 49):
|
3550 |
|
|
|
3551 |
|
|
A template-argument for a non-type, non-template template-parameter
|
3552 |
|
|
shall be one of: [...]
|
3553 |
|
|
|
3554 |
|
|
-- the name of a non-type template-parameter;
|
3555 |
|
|
-- the address of an object or function with external linkage, [...]
|
3556 |
|
|
expressed as "& id-expression" where the & is optional if the name
|
3557 |
|
|
refers to a function or array, or if the corresponding
|
3558 |
|
|
template-parameter is a reference.
|
3559 |
|
|
|
3560 |
|
|
Here, we do not care about functions, as they are invalid anyway
|
3561 |
|
|
for a parameter of type pointer-to-object. */
|
3562 |
|
|
bool constant_address_p =
|
3563 |
|
|
(TREE_CODE (expr) == ADDR_EXPR
|
3564 |
|
|
|| TREE_CODE (expr_type) == ARRAY_TYPE
|
3565 |
|
|
|| (DECL_P (expr) && DECL_TEMPLATE_PARM_P (expr)));
|
3566 |
|
|
|
3567 |
|
|
expr = decay_conversion (expr);
|
3568 |
|
|
if (expr == error_mark_node)
|
3569 |
|
|
return error_mark_node;
|
3570 |
|
|
|
3571 |
|
|
expr = perform_qualification_conversions (type, expr);
|
3572 |
|
|
if (expr == error_mark_node)
|
3573 |
|
|
return error_mark_node;
|
3574 |
|
|
|
3575 |
|
|
if (!constant_address_p)
|
3576 |
|
|
{
|
3577 |
|
|
error ("%qE is not a valid template argument for type %qT "
|
3578 |
|
|
"because it is not a constant pointer", expr, type);
|
3579 |
|
|
return NULL_TREE;
|
3580 |
|
|
}
|
3581 |
|
|
}
|
3582 |
|
|
/* [temp.arg.nontype]/5, bullet 3
|
3583 |
|
|
|
3584 |
|
|
For a non-type template-parameter of type reference to object, no
|
3585 |
|
|
conversions apply. The type referred to by the reference may be more
|
3586 |
|
|
cv-qualified than the (otherwise identical) type of the
|
3587 |
|
|
template-argument. The template-parameter is bound directly to the
|
3588 |
|
|
template-argument, which must be an lvalue. */
|
3589 |
|
|
else if (TYPE_REF_OBJ_P (type))
|
3590 |
|
|
{
|
3591 |
|
|
if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type),
|
3592 |
|
|
expr_type))
|
3593 |
|
|
return error_mark_node;
|
3594 |
|
|
|
3595 |
|
|
if (!at_least_as_qualified_p (TREE_TYPE (type), expr_type))
|
3596 |
|
|
{
|
3597 |
|
|
error ("%qE is not a valid template argument for type %qT "
|
3598 |
|
|
"because of conflicts in cv-qualification", expr, type);
|
3599 |
|
|
return NULL_TREE;
|
3600 |
|
|
}
|
3601 |
|
|
|
3602 |
|
|
if (!real_lvalue_p (expr))
|
3603 |
|
|
{
|
3604 |
|
|
error ("%qE is not a valid template argument for type %qT "
|
3605 |
|
|
"because it is not a lvalue", expr, type);
|
3606 |
|
|
return NULL_TREE;
|
3607 |
|
|
}
|
3608 |
|
|
|
3609 |
|
|
/* [temp.arg.nontype]/1
|
3610 |
|
|
|
3611 |
|
|
A template-argument for a non-type, non-template template-parameter
|
3612 |
|
|
shall be one of: [...]
|
3613 |
|
|
|
3614 |
|
|
-- the address of an object or function with external linkage. */
|
3615 |
|
|
if (!DECL_EXTERNAL_LINKAGE_P (expr))
|
3616 |
|
|
{
|
3617 |
|
|
error ("%qE is not a valid template argument for type %qT "
|
3618 |
|
|
"because object %qD has not external linkage",
|
3619 |
|
|
expr, type, expr);
|
3620 |
|
|
return NULL_TREE;
|
3621 |
|
|
}
|
3622 |
|
|
|
3623 |
|
|
expr = build_nop (type, build_address (expr));
|
3624 |
|
|
}
|
3625 |
|
|
/* [temp.arg.nontype]/5, bullet 4
|
3626 |
|
|
|
3627 |
|
|
For a non-type template-parameter of type pointer to function, only
|
3628 |
|
|
the function-to-pointer conversion (_conv.func_) is applied. If the
|
3629 |
|
|
template-argument represents a set of overloaded functions (or a
|
3630 |
|
|
pointer to such), the matching function is selected from the set
|
3631 |
|
|
(_over.over_). */
|
3632 |
|
|
else if (TYPE_PTRFN_P (type))
|
3633 |
|
|
{
|
3634 |
|
|
/* If the argument is a template-id, we might not have enough
|
3635 |
|
|
context information to decay the pointer. */
|
3636 |
|
|
if (!type_unknown_p (expr_type))
|
3637 |
|
|
{
|
3638 |
|
|
expr = decay_conversion (expr);
|
3639 |
|
|
if (expr == error_mark_node)
|
3640 |
|
|
return error_mark_node;
|
3641 |
|
|
}
|
3642 |
|
|
|
3643 |
|
|
expr = convert_nontype_argument_function (type, expr);
|
3644 |
|
|
if (!expr || expr == error_mark_node)
|
3645 |
|
|
return expr;
|
3646 |
|
|
}
|
3647 |
|
|
/* [temp.arg.nontype]/5, bullet 5
|
3648 |
|
|
|
3649 |
|
|
For a non-type template-parameter of type reference to function, no
|
3650 |
|
|
conversions apply. If the template-argument represents a set of
|
3651 |
|
|
overloaded functions, the matching function is selected from the set
|
3652 |
|
|
(_over.over_). */
|
3653 |
|
|
else if (TYPE_REFFN_P (type))
|
3654 |
|
|
{
|
3655 |
|
|
if (TREE_CODE (expr) == ADDR_EXPR)
|
3656 |
|
|
{
|
3657 |
|
|
error ("%qE is not a valid template argument for type %qT "
|
3658 |
|
|
"because it is a pointer", expr, type);
|
3659 |
|
|
inform ("try using %qE instead", TREE_OPERAND (expr, 0));
|
3660 |
|
|
return NULL_TREE;
|
3661 |
|
|
}
|
3662 |
|
|
|
3663 |
|
|
expr = convert_nontype_argument_function (TREE_TYPE (type), expr);
|
3664 |
|
|
if (!expr || expr == error_mark_node)
|
3665 |
|
|
return expr;
|
3666 |
|
|
|
3667 |
|
|
expr = build_nop (type, build_address (expr));
|
3668 |
|
|
}
|
3669 |
|
|
/* [temp.arg.nontype]/5, bullet 6
|
3670 |
|
|
|
3671 |
|
|
For a non-type template-parameter of type pointer to member function,
|
3672 |
|
|
no conversions apply. If the template-argument represents a set of
|
3673 |
|
|
overloaded member functions, the matching member function is selected
|
3674 |
|
|
from the set (_over.over_). */
|
3675 |
|
|
else if (TYPE_PTRMEMFUNC_P (type))
|
3676 |
|
|
{
|
3677 |
|
|
expr = instantiate_type (type, expr, tf_none);
|
3678 |
|
|
if (expr == error_mark_node)
|
3679 |
|
|
return error_mark_node;
|
3680 |
|
|
|
3681 |
|
|
/* There is no way to disable standard conversions in
|
3682 |
|
|
resolve_address_of_overloaded_function (called by
|
3683 |
|
|
instantiate_type). It is possible that the call succeeded by
|
3684 |
|
|
converting &B::I to &D::I (where B is a base of D), so we need
|
3685 |
|
|
to reject this conversion here.
|
3686 |
|
|
|
3687 |
|
|
Actually, even if there was a way to disable standard conversions,
|
3688 |
|
|
it would still be better to reject them here so that we can
|
3689 |
|
|
provide a superior diagnostic. */
|
3690 |
|
|
if (!same_type_p (TREE_TYPE (expr), type))
|
3691 |
|
|
{
|
3692 |
|
|
/* Make sure we are just one standard conversion off. */
|
3693 |
|
|
gcc_assert (can_convert (type, TREE_TYPE (expr)));
|
3694 |
|
|
error ("%qE is not a valid template argument for type %qT "
|
3695 |
|
|
"because it is of type %qT", expr, type,
|
3696 |
|
|
TREE_TYPE (expr));
|
3697 |
|
|
inform ("standard conversions are not allowed in this context");
|
3698 |
|
|
return NULL_TREE;
|
3699 |
|
|
}
|
3700 |
|
|
}
|
3701 |
|
|
/* [temp.arg.nontype]/5, bullet 7
|
3702 |
|
|
|
3703 |
|
|
For a non-type template-parameter of type pointer to data member,
|
3704 |
|
|
qualification conversions (_conv.qual_) are applied. */
|
3705 |
|
|
else if (TYPE_PTRMEM_P (type))
|
3706 |
|
|
{
|
3707 |
|
|
expr = perform_qualification_conversions (type, expr);
|
3708 |
|
|
if (expr == error_mark_node)
|
3709 |
|
|
return expr;
|
3710 |
|
|
}
|
3711 |
|
|
/* A template non-type parameter must be one of the above. */
|
3712 |
|
|
else
|
3713 |
|
|
gcc_unreachable ();
|
3714 |
|
|
|
3715 |
|
|
/* Sanity check: did we actually convert the argument to the
|
3716 |
|
|
right type? */
|
3717 |
|
|
gcc_assert (same_type_p (type, TREE_TYPE (expr)));
|
3718 |
|
|
return expr;
|
3719 |
|
|
}
|
3720 |
|
|
|
3721 |
|
|
|
3722 |
|
|
/* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
|
3723 |
|
|
template template parameters. Both PARM_PARMS and ARG_PARMS are
|
3724 |
|
|
vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
|
3725 |
|
|
or PARM_DECL.
|
3726 |
|
|
|
3727 |
|
|
ARG_PARMS may contain more parameters than PARM_PARMS. If this is
|
3728 |
|
|
the case, then extra parameters must have default arguments.
|
3729 |
|
|
|
3730 |
|
|
Consider the example:
|
3731 |
|
|
template <class T, class Allocator = allocator> class vector;
|
3732 |
|
|
template<template <class U> class TT> class C;
|
3733 |
|
|
|
3734 |
|
|
C<vector> is a valid instantiation. PARM_PARMS for the above code
|
3735 |
|
|
contains a TYPE_DECL (for U), ARG_PARMS contains two TYPE_DECLs (for
|
3736 |
|
|
T and Allocator) and OUTER_ARGS contains the argument that is used to
|
3737 |
|
|
substitute the TT parameter. */
|
3738 |
|
|
|
3739 |
|
|
static int
|
3740 |
|
|
coerce_template_template_parms (tree parm_parms,
|
3741 |
|
|
tree arg_parms,
|
3742 |
|
|
tsubst_flags_t complain,
|
3743 |
|
|
tree in_decl,
|
3744 |
|
|
tree outer_args)
|
3745 |
|
|
{
|
3746 |
|
|
int nparms, nargs, i;
|
3747 |
|
|
tree parm, arg;
|
3748 |
|
|
|
3749 |
|
|
gcc_assert (TREE_CODE (parm_parms) == TREE_VEC);
|
3750 |
|
|
gcc_assert (TREE_CODE (arg_parms) == TREE_VEC);
|
3751 |
|
|
|
3752 |
|
|
nparms = TREE_VEC_LENGTH (parm_parms);
|
3753 |
|
|
nargs = TREE_VEC_LENGTH (arg_parms);
|
3754 |
|
|
|
3755 |
|
|
/* The rule here is opposite of coerce_template_parms. */
|
3756 |
|
|
if (nargs < nparms
|
3757 |
|
|
|| (nargs > nparms
|
3758 |
|
|
&& TREE_PURPOSE (TREE_VEC_ELT (arg_parms, nparms)) == NULL_TREE))
|
3759 |
|
|
return 0;
|
3760 |
|
|
|
3761 |
|
|
for (i = 0; i < nparms; ++i)
|
3762 |
|
|
{
|
3763 |
|
|
parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, i));
|
3764 |
|
|
arg = TREE_VALUE (TREE_VEC_ELT (arg_parms, i));
|
3765 |
|
|
|
3766 |
|
|
if (arg == NULL_TREE || arg == error_mark_node
|
3767 |
|
|
|| parm == NULL_TREE || parm == error_mark_node)
|
3768 |
|
|
return 0;
|
3769 |
|
|
|
3770 |
|
|
if (TREE_CODE (arg) != TREE_CODE (parm))
|
3771 |
|
|
return 0;
|
3772 |
|
|
|
3773 |
|
|
switch (TREE_CODE (parm))
|
3774 |
|
|
{
|
3775 |
|
|
case TYPE_DECL:
|
3776 |
|
|
break;
|
3777 |
|
|
|
3778 |
|
|
case TEMPLATE_DECL:
|
3779 |
|
|
/* We encounter instantiations of templates like
|
3780 |
|
|
template <template <template <class> class> class TT>
|
3781 |
|
|
class C; */
|
3782 |
|
|
{
|
3783 |
|
|
tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
|
3784 |
|
|
tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
|
3785 |
|
|
|
3786 |
|
|
if (!coerce_template_template_parms
|
3787 |
|
|
(parmparm, argparm, complain, in_decl, outer_args))
|
3788 |
|
|
return 0;
|
3789 |
|
|
}
|
3790 |
|
|
break;
|
3791 |
|
|
|
3792 |
|
|
case PARM_DECL:
|
3793 |
|
|
/* The tsubst call is used to handle cases such as
|
3794 |
|
|
|
3795 |
|
|
template <int> class C {};
|
3796 |
|
|
template <class T, template <T> class TT> class D {};
|
3797 |
|
|
D<int, C> d;
|
3798 |
|
|
|
3799 |
|
|
i.e. the parameter list of TT depends on earlier parameters. */
|
3800 |
|
|
if (!dependent_type_p (TREE_TYPE (arg))
|
3801 |
|
|
&& !same_type_p
|
3802 |
|
|
(tsubst (TREE_TYPE (parm), outer_args, complain, in_decl),
|
3803 |
|
|
TREE_TYPE (arg)))
|
3804 |
|
|
return 0;
|
3805 |
|
|
break;
|
3806 |
|
|
|
3807 |
|
|
default:
|
3808 |
|
|
gcc_unreachable ();
|
3809 |
|
|
}
|
3810 |
|
|
}
|
3811 |
|
|
return 1;
|
3812 |
|
|
}
|
3813 |
|
|
|
3814 |
|
|
/* Convert the indicated template ARG as necessary to match the
|
3815 |
|
|
indicated template PARM. Returns the converted ARG, or
|
3816 |
|
|
error_mark_node if the conversion was unsuccessful. Error and
|
3817 |
|
|
warning messages are issued under control of COMPLAIN. This
|
3818 |
|
|
conversion is for the Ith parameter in the parameter list. ARGS is
|
3819 |
|
|
the full set of template arguments deduced so far. */
|
3820 |
|
|
|
3821 |
|
|
static tree
|
3822 |
|
|
convert_template_argument (tree parm,
|
3823 |
|
|
tree arg,
|
3824 |
|
|
tree args,
|
3825 |
|
|
tsubst_flags_t complain,
|
3826 |
|
|
int i,
|
3827 |
|
|
tree in_decl)
|
3828 |
|
|
{
|
3829 |
|
|
tree val;
|
3830 |
|
|
tree inner_args;
|
3831 |
|
|
int is_type, requires_type, is_tmpl_type, requires_tmpl_type;
|
3832 |
|
|
|
3833 |
|
|
inner_args = INNERMOST_TEMPLATE_ARGS (args);
|
3834 |
|
|
|
3835 |
|
|
if (TREE_CODE (arg) == TREE_LIST
|
3836 |
|
|
&& TREE_CODE (TREE_VALUE (arg)) == OFFSET_REF)
|
3837 |
|
|
{
|
3838 |
|
|
/* The template argument was the name of some
|
3839 |
|
|
member function. That's usually
|
3840 |
|
|
invalid, but static members are OK. In any
|
3841 |
|
|
case, grab the underlying fields/functions
|
3842 |
|
|
and issue an error later if required. */
|
3843 |
|
|
arg = TREE_VALUE (arg);
|
3844 |
|
|
TREE_TYPE (arg) = unknown_type_node;
|
3845 |
|
|
}
|
3846 |
|
|
|
3847 |
|
|
requires_tmpl_type = TREE_CODE (parm) == TEMPLATE_DECL;
|
3848 |
|
|
requires_type = (TREE_CODE (parm) == TYPE_DECL
|
3849 |
|
|
|| requires_tmpl_type);
|
3850 |
|
|
|
3851 |
|
|
is_tmpl_type = ((TREE_CODE (arg) == TEMPLATE_DECL
|
3852 |
|
|
&& TREE_CODE (DECL_TEMPLATE_RESULT (arg)) == TYPE_DECL)
|
3853 |
|
|
|| TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
|
3854 |
|
|
|| TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE);
|
3855 |
|
|
|
3856 |
|
|
if (is_tmpl_type
|
3857 |
|
|
&& (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
|
3858 |
|
|
|| TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE))
|
3859 |
|
|
arg = TYPE_STUB_DECL (arg);
|
3860 |
|
|
|
3861 |
|
|
is_type = TYPE_P (arg) || is_tmpl_type;
|
3862 |
|
|
|
3863 |
|
|
if (requires_type && ! is_type && TREE_CODE (arg) == SCOPE_REF
|
3864 |
|
|
&& TREE_CODE (TREE_OPERAND (arg, 0)) == TEMPLATE_TYPE_PARM)
|
3865 |
|
|
{
|
3866 |
|
|
pedwarn ("to refer to a type member of a template parameter, "
|
3867 |
|
|
"use %<typename %E%>", arg);
|
3868 |
|
|
|
3869 |
|
|
arg = make_typename_type (TREE_OPERAND (arg, 0),
|
3870 |
|
|
TREE_OPERAND (arg, 1),
|
3871 |
|
|
typename_type,
|
3872 |
|
|
complain & tf_error);
|
3873 |
|
|
is_type = 1;
|
3874 |
|
|
}
|
3875 |
|
|
if (is_type != requires_type)
|
3876 |
|
|
{
|
3877 |
|
|
if (in_decl)
|
3878 |
|
|
{
|
3879 |
|
|
if (complain & tf_error)
|
3880 |
|
|
{
|
3881 |
|
|
error ("type/value mismatch at argument %d in template "
|
3882 |
|
|
"parameter list for %qD",
|
3883 |
|
|
i + 1, in_decl);
|
3884 |
|
|
if (is_type)
|
3885 |
|
|
error (" expected a constant of type %qT, got %qT",
|
3886 |
|
|
TREE_TYPE (parm),
|
3887 |
|
|
(is_tmpl_type ? DECL_NAME (arg) : arg));
|
3888 |
|
|
else if (requires_tmpl_type)
|
3889 |
|
|
error (" expected a class template, got %qE", arg);
|
3890 |
|
|
else
|
3891 |
|
|
error (" expected a type, got %qE", arg);
|
3892 |
|
|
}
|
3893 |
|
|
}
|
3894 |
|
|
return error_mark_node;
|
3895 |
|
|
}
|
3896 |
|
|
if (is_tmpl_type ^ requires_tmpl_type)
|
3897 |
|
|
{
|
3898 |
|
|
if (in_decl && (complain & tf_error))
|
3899 |
|
|
{
|
3900 |
|
|
error ("type/value mismatch at argument %d in template "
|
3901 |
|
|
"parameter list for %qD",
|
3902 |
|
|
i + 1, in_decl);
|
3903 |
|
|
if (is_tmpl_type)
|
3904 |
|
|
error (" expected a type, got %qT", DECL_NAME (arg));
|
3905 |
|
|
else
|
3906 |
|
|
error (" expected a class template, got %qT", arg);
|
3907 |
|
|
}
|
3908 |
|
|
return error_mark_node;
|
3909 |
|
|
}
|
3910 |
|
|
|
3911 |
|
|
if (is_type)
|
3912 |
|
|
{
|
3913 |
|
|
if (requires_tmpl_type)
|
3914 |
|
|
{
|
3915 |
|
|
if (TREE_CODE (TREE_TYPE (arg)) == UNBOUND_CLASS_TEMPLATE)
|
3916 |
|
|
/* The number of argument required is not known yet.
|
3917 |
|
|
Just accept it for now. */
|
3918 |
|
|
val = TREE_TYPE (arg);
|
3919 |
|
|
else
|
3920 |
|
|
{
|
3921 |
|
|
tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
|
3922 |
|
|
tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
|
3923 |
|
|
|
3924 |
|
|
if (coerce_template_template_parms (parmparm, argparm,
|
3925 |
|
|
complain, in_decl,
|
3926 |
|
|
inner_args))
|
3927 |
|
|
{
|
3928 |
|
|
val = arg;
|
3929 |
|
|
|
3930 |
|
|
/* TEMPLATE_TEMPLATE_PARM node is preferred over
|
3931 |
|
|
TEMPLATE_DECL. */
|
3932 |
|
|
if (val != error_mark_node
|
3933 |
|
|
&& DECL_TEMPLATE_TEMPLATE_PARM_P (val))
|
3934 |
|
|
val = TREE_TYPE (val);
|
3935 |
|
|
}
|
3936 |
|
|
else
|
3937 |
|
|
{
|
3938 |
|
|
if (in_decl && (complain & tf_error))
|
3939 |
|
|
{
|
3940 |
|
|
error ("type/value mismatch at argument %d in "
|
3941 |
|
|
"template parameter list for %qD",
|
3942 |
|
|
i + 1, in_decl);
|
3943 |
|
|
error (" expected a template of type %qD, got %qD",
|
3944 |
|
|
parm, arg);
|
3945 |
|
|
}
|
3946 |
|
|
|
3947 |
|
|
val = error_mark_node;
|
3948 |
|
|
}
|
3949 |
|
|
}
|
3950 |
|
|
}
|
3951 |
|
|
else
|
3952 |
|
|
val = arg;
|
3953 |
|
|
/* We only form one instance of each template specialization.
|
3954 |
|
|
Therefore, if we use a non-canonical variant (i.e., a
|
3955 |
|
|
typedef), any future messages referring to the type will use
|
3956 |
|
|
the typedef, which is confusing if those future uses do not
|
3957 |
|
|
themselves also use the typedef. */
|
3958 |
|
|
if (TYPE_P (val))
|
3959 |
|
|
val = canonical_type_variant (val);
|
3960 |
|
|
}
|
3961 |
|
|
else
|
3962 |
|
|
{
|
3963 |
|
|
tree t = tsubst (TREE_TYPE (parm), args, complain, in_decl);
|
3964 |
|
|
|
3965 |
|
|
if (invalid_nontype_parm_type_p (t, complain))
|
3966 |
|
|
return error_mark_node;
|
3967 |
|
|
|
3968 |
|
|
if (!uses_template_parms (arg) && !uses_template_parms (t))
|
3969 |
|
|
/* We used to call digest_init here. However, digest_init
|
3970 |
|
|
will report errors, which we don't want when complain
|
3971 |
|
|
is zero. More importantly, digest_init will try too
|
3972 |
|
|
hard to convert things: for example, `0' should not be
|
3973 |
|
|
converted to pointer type at this point according to
|
3974 |
|
|
the standard. Accepting this is not merely an
|
3975 |
|
|
extension, since deciding whether or not these
|
3976 |
|
|
conversions can occur is part of determining which
|
3977 |
|
|
function template to call, or whether a given explicit
|
3978 |
|
|
argument specification is valid. */
|
3979 |
|
|
val = convert_nontype_argument (t, arg);
|
3980 |
|
|
else
|
3981 |
|
|
val = arg;
|
3982 |
|
|
|
3983 |
|
|
if (val == NULL_TREE)
|
3984 |
|
|
val = error_mark_node;
|
3985 |
|
|
else if (val == error_mark_node && (complain & tf_error))
|
3986 |
|
|
error ("could not convert template argument %qE to %qT", arg, t);
|
3987 |
|
|
}
|
3988 |
|
|
|
3989 |
|
|
return val;
|
3990 |
|
|
}
|
3991 |
|
|
|
3992 |
|
|
/* Convert all template arguments to their appropriate types, and
|
3993 |
|
|
return a vector containing the innermost resulting template
|
3994 |
|
|
arguments. If any error occurs, return error_mark_node. Error and
|
3995 |
|
|
warning messages are issued under control of COMPLAIN.
|
3996 |
|
|
|
3997 |
|
|
If REQUIRE_ALL_ARGUMENTS is nonzero, all arguments must be
|
3998 |
|
|
provided in ARGLIST, or else trailing parameters must have default
|
3999 |
|
|
values. If REQUIRE_ALL_ARGUMENTS is zero, we will attempt argument
|
4000 |
|
|
deduction for any unspecified trailing arguments. */
|
4001 |
|
|
|
4002 |
|
|
static tree
|
4003 |
|
|
coerce_template_parms (tree parms,
|
4004 |
|
|
tree args,
|
4005 |
|
|
tree in_decl,
|
4006 |
|
|
tsubst_flags_t complain,
|
4007 |
|
|
int require_all_arguments)
|
4008 |
|
|
{
|
4009 |
|
|
int nparms, nargs, i, lost = 0;
|
4010 |
|
|
tree inner_args;
|
4011 |
|
|
tree new_args;
|
4012 |
|
|
tree new_inner_args;
|
4013 |
|
|
|
4014 |
|
|
inner_args = INNERMOST_TEMPLATE_ARGS (args);
|
4015 |
|
|
nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0;
|
4016 |
|
|
nparms = TREE_VEC_LENGTH (parms);
|
4017 |
|
|
|
4018 |
|
|
if (nargs > nparms
|
4019 |
|
|
|| (nargs < nparms
|
4020 |
|
|
&& require_all_arguments
|
4021 |
|
|
&& TREE_PURPOSE (TREE_VEC_ELT (parms, nargs)) == NULL_TREE))
|
4022 |
|
|
{
|
4023 |
|
|
if (complain & tf_error)
|
4024 |
|
|
{
|
4025 |
|
|
error ("wrong number of template arguments (%d, should be %d)",
|
4026 |
|
|
nargs, nparms);
|
4027 |
|
|
|
4028 |
|
|
if (in_decl)
|
4029 |
|
|
error ("provided for %q+D", in_decl);
|
4030 |
|
|
}
|
4031 |
|
|
|
4032 |
|
|
return error_mark_node;
|
4033 |
|
|
}
|
4034 |
|
|
|
4035 |
|
|
new_inner_args = make_tree_vec (nparms);
|
4036 |
|
|
new_args = add_outermost_template_args (args, new_inner_args);
|
4037 |
|
|
for (i = 0; i < nparms; i++)
|
4038 |
|
|
{
|
4039 |
|
|
tree arg;
|
4040 |
|
|
tree parm;
|
4041 |
|
|
|
4042 |
|
|
/* Get the Ith template parameter. */
|
4043 |
|
|
parm = TREE_VEC_ELT (parms, i);
|
4044 |
|
|
|
4045 |
|
|
/* Calculate the Ith argument. */
|
4046 |
|
|
if (i < nargs)
|
4047 |
|
|
arg = TREE_VEC_ELT (inner_args, i);
|
4048 |
|
|
else if (require_all_arguments)
|
4049 |
|
|
/* There must be a default arg in this case. */
|
4050 |
|
|
arg = tsubst_template_arg (TREE_PURPOSE (parm), new_args,
|
4051 |
|
|
complain, in_decl);
|
4052 |
|
|
else
|
4053 |
|
|
break;
|
4054 |
|
|
|
4055 |
|
|
gcc_assert (arg);
|
4056 |
|
|
if (arg == error_mark_node)
|
4057 |
|
|
{
|
4058 |
|
|
if (complain & tf_error)
|
4059 |
|
|
error ("template argument %d is invalid", i + 1);
|
4060 |
|
|
}
|
4061 |
|
|
else
|
4062 |
|
|
arg = convert_template_argument (TREE_VALUE (parm),
|
4063 |
|
|
arg, new_args, complain, i,
|
4064 |
|
|
in_decl);
|
4065 |
|
|
|
4066 |
|
|
if (arg == error_mark_node)
|
4067 |
|
|
lost++;
|
4068 |
|
|
TREE_VEC_ELT (new_inner_args, i) = arg;
|
4069 |
|
|
}
|
4070 |
|
|
|
4071 |
|
|
if (lost)
|
4072 |
|
|
return error_mark_node;
|
4073 |
|
|
|
4074 |
|
|
return new_inner_args;
|
4075 |
|
|
}
|
4076 |
|
|
|
4077 |
|
|
/* Returns 1 if template args OT and NT are equivalent. */
|
4078 |
|
|
|
4079 |
|
|
static int
|
4080 |
|
|
template_args_equal (tree ot, tree nt)
|
4081 |
|
|
{
|
4082 |
|
|
if (nt == ot)
|
4083 |
|
|
return 1;
|
4084 |
|
|
|
4085 |
|
|
if (TREE_CODE (nt) == TREE_VEC)
|
4086 |
|
|
/* For member templates */
|
4087 |
|
|
return TREE_CODE (ot) == TREE_VEC && comp_template_args (ot, nt);
|
4088 |
|
|
else if (TYPE_P (nt))
|
4089 |
|
|
return TYPE_P (ot) && same_type_p (ot, nt);
|
4090 |
|
|
else if (TREE_CODE (ot) == TREE_VEC || TYPE_P (ot))
|
4091 |
|
|
return 0;
|
4092 |
|
|
else
|
4093 |
|
|
return cp_tree_equal (ot, nt);
|
4094 |
|
|
}
|
4095 |
|
|
|
4096 |
|
|
/* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
|
4097 |
|
|
of template arguments. Returns 0 otherwise. */
|
4098 |
|
|
|
4099 |
|
|
int
|
4100 |
|
|
comp_template_args (tree oldargs, tree newargs)
|
4101 |
|
|
{
|
4102 |
|
|
int i;
|
4103 |
|
|
|
4104 |
|
|
if (TREE_VEC_LENGTH (oldargs) != TREE_VEC_LENGTH (newargs))
|
4105 |
|
|
return 0;
|
4106 |
|
|
|
4107 |
|
|
for (i = 0; i < TREE_VEC_LENGTH (oldargs); ++i)
|
4108 |
|
|
{
|
4109 |
|
|
tree nt = TREE_VEC_ELT (newargs, i);
|
4110 |
|
|
tree ot = TREE_VEC_ELT (oldargs, i);
|
4111 |
|
|
|
4112 |
|
|
if (! template_args_equal (ot, nt))
|
4113 |
|
|
return 0;
|
4114 |
|
|
}
|
4115 |
|
|
return 1;
|
4116 |
|
|
}
|
4117 |
|
|
|
4118 |
|
|
/* Given class template name and parameter list, produce a user-friendly name
|
4119 |
|
|
for the instantiation. */
|
4120 |
|
|
|
4121 |
|
|
static char *
|
4122 |
|
|
mangle_class_name_for_template (const char* name, tree parms, tree arglist)
|
4123 |
|
|
{
|
4124 |
|
|
static struct obstack scratch_obstack;
|
4125 |
|
|
static char *scratch_firstobj;
|
4126 |
|
|
int i, nparms;
|
4127 |
|
|
|
4128 |
|
|
if (!scratch_firstobj)
|
4129 |
|
|
gcc_obstack_init (&scratch_obstack);
|
4130 |
|
|
else
|
4131 |
|
|
obstack_free (&scratch_obstack, scratch_firstobj);
|
4132 |
|
|
scratch_firstobj = obstack_alloc (&scratch_obstack, 1);
|
4133 |
|
|
|
4134 |
|
|
#define ccat(C) obstack_1grow (&scratch_obstack, (C));
|
4135 |
|
|
#define cat(S) obstack_grow (&scratch_obstack, (S), strlen (S))
|
4136 |
|
|
|
4137 |
|
|
cat (name);
|
4138 |
|
|
ccat ('<');
|
4139 |
|
|
nparms = TREE_VEC_LENGTH (parms);
|
4140 |
|
|
arglist = INNERMOST_TEMPLATE_ARGS (arglist);
|
4141 |
|
|
gcc_assert (nparms == TREE_VEC_LENGTH (arglist));
|
4142 |
|
|
for (i = 0; i < nparms; i++)
|
4143 |
|
|
{
|
4144 |
|
|
tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
|
4145 |
|
|
tree arg = TREE_VEC_ELT (arglist, i);
|
4146 |
|
|
|
4147 |
|
|
if (i)
|
4148 |
|
|
ccat (',');
|
4149 |
|
|
|
4150 |
|
|
if (TREE_CODE (parm) == TYPE_DECL)
|
4151 |
|
|
{
|
4152 |
|
|
cat (type_as_string (arg, TFF_CHASE_TYPEDEF));
|
4153 |
|
|
continue;
|
4154 |
|
|
}
|
4155 |
|
|
else if (TREE_CODE (parm) == TEMPLATE_DECL)
|
4156 |
|
|
{
|
4157 |
|
|
if (TREE_CODE (arg) == TEMPLATE_DECL)
|
4158 |
|
|
{
|
4159 |
|
|
/* Already substituted with real template. Just output
|
4160 |
|
|
the template name here */
|
4161 |
|
|
tree context = DECL_CONTEXT (arg);
|
4162 |
|
|
if (context)
|
4163 |
|
|
{
|
4164 |
|
|
/* The template may be defined in a namespace, or
|
4165 |
|
|
may be a member template. */
|
4166 |
|
|
gcc_assert (TREE_CODE (context) == NAMESPACE_DECL
|
4167 |
|
|
|| CLASS_TYPE_P (context));
|
4168 |
|
|
cat (decl_as_string (DECL_CONTEXT (arg),
|
4169 |
|
|
TFF_PLAIN_IDENTIFIER));
|
4170 |
|
|
cat ("::");
|
4171 |
|
|
}
|
4172 |
|
|
cat (IDENTIFIER_POINTER (DECL_NAME (arg)));
|
4173 |
|
|
}
|
4174 |
|
|
else
|
4175 |
|
|
/* Output the parameter declaration. */
|
4176 |
|
|
cat (type_as_string (arg, TFF_CHASE_TYPEDEF));
|
4177 |
|
|
continue;
|
4178 |
|
|
}
|
4179 |
|
|
else
|
4180 |
|
|
gcc_assert (TREE_CODE (parm) == PARM_DECL);
|
4181 |
|
|
|
4182 |
|
|
/* No need to check arglist against parmlist here; we did that
|
4183 |
|
|
in coerce_template_parms, called from lookup_template_class. */
|
4184 |
|
|
cat (expr_as_string (arg, TFF_PLAIN_IDENTIFIER));
|
4185 |
|
|
}
|
4186 |
|
|
{
|
4187 |
|
|
char *bufp = obstack_next_free (&scratch_obstack);
|
4188 |
|
|
int offset = 0;
|
4189 |
|
|
while (bufp[offset - 1] == ' ')
|
4190 |
|
|
offset--;
|
4191 |
|
|
obstack_blank_fast (&scratch_obstack, offset);
|
4192 |
|
|
|
4193 |
|
|
/* B<C<char> >, not B<C<char>> */
|
4194 |
|
|
if (bufp[offset - 1] == '>')
|
4195 |
|
|
ccat (' ');
|
4196 |
|
|
}
|
4197 |
|
|
ccat ('>');
|
4198 |
|
|
ccat ('\0');
|
4199 |
|
|
return (char *) obstack_base (&scratch_obstack);
|
4200 |
|
|
}
|
4201 |
|
|
|
4202 |
|
|
static tree
|
4203 |
|
|
classtype_mangled_name (tree t)
|
4204 |
|
|
{
|
4205 |
|
|
if (CLASSTYPE_TEMPLATE_INFO (t)
|
4206 |
|
|
/* Specializations have already had their names set up in
|
4207 |
|
|
lookup_template_class. */
|
4208 |
|
|
&& !CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
|
4209 |
|
|
{
|
4210 |
|
|
tree tmpl = most_general_template (CLASSTYPE_TI_TEMPLATE (t));
|
4211 |
|
|
|
4212 |
|
|
/* For non-primary templates, the template parameters are
|
4213 |
|
|
implicit from their surrounding context. */
|
4214 |
|
|
if (PRIMARY_TEMPLATE_P (tmpl))
|
4215 |
|
|
{
|
4216 |
|
|
tree name = DECL_NAME (tmpl);
|
4217 |
|
|
char *mangled_name = mangle_class_name_for_template
|
4218 |
|
|
(IDENTIFIER_POINTER (name),
|
4219 |
|
|
DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
|
4220 |
|
|
CLASSTYPE_TI_ARGS (t));
|
4221 |
|
|
tree id = get_identifier (mangled_name);
|
4222 |
|
|
IDENTIFIER_TEMPLATE (id) = name;
|
4223 |
|
|
return id;
|
4224 |
|
|
}
|
4225 |
|
|
}
|
4226 |
|
|
|
4227 |
|
|
return TYPE_IDENTIFIER (t);
|
4228 |
|
|
}
|
4229 |
|
|
|
4230 |
|
|
static void
|
4231 |
|
|
add_pending_template (tree d)
|
4232 |
|
|
{
|
4233 |
|
|
tree ti = (TYPE_P (d)
|
4234 |
|
|
? CLASSTYPE_TEMPLATE_INFO (d)
|
4235 |
|
|
: DECL_TEMPLATE_INFO (d));
|
4236 |
|
|
tree pt;
|
4237 |
|
|
int level;
|
4238 |
|
|
|
4239 |
|
|
if (TI_PENDING_TEMPLATE_FLAG (ti))
|
4240 |
|
|
return;
|
4241 |
|
|
|
4242 |
|
|
/* We are called both from instantiate_decl, where we've already had a
|
4243 |
|
|
tinst_level pushed, and instantiate_template, where we haven't.
|
4244 |
|
|
Compensate. */
|
4245 |
|
|
level = !(current_tinst_level && TINST_DECL (current_tinst_level) == d);
|
4246 |
|
|
|
4247 |
|
|
if (level)
|
4248 |
|
|
push_tinst_level (d);
|
4249 |
|
|
|
4250 |
|
|
pt = tree_cons (current_tinst_level, d, NULL_TREE);
|
4251 |
|
|
if (last_pending_template)
|
4252 |
|
|
TREE_CHAIN (last_pending_template) = pt;
|
4253 |
|
|
else
|
4254 |
|
|
pending_templates = pt;
|
4255 |
|
|
|
4256 |
|
|
last_pending_template = pt;
|
4257 |
|
|
|
4258 |
|
|
TI_PENDING_TEMPLATE_FLAG (ti) = 1;
|
4259 |
|
|
|
4260 |
|
|
if (level)
|
4261 |
|
|
pop_tinst_level ();
|
4262 |
|
|
}
|
4263 |
|
|
|
4264 |
|
|
|
4265 |
|
|
/* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
|
4266 |
|
|
ARGLIST. Valid choices for FNS are given in the cp-tree.def
|
4267 |
|
|
documentation for TEMPLATE_ID_EXPR. */
|
4268 |
|
|
|
4269 |
|
|
tree
|
4270 |
|
|
lookup_template_function (tree fns, tree arglist)
|
4271 |
|
|
{
|
4272 |
|
|
tree type;
|
4273 |
|
|
|
4274 |
|
|
if (fns == error_mark_node || arglist == error_mark_node)
|
4275 |
|
|
return error_mark_node;
|
4276 |
|
|
|
4277 |
|
|
gcc_assert (!arglist || TREE_CODE (arglist) == TREE_VEC);
|
4278 |
|
|
gcc_assert (fns && (is_overloaded_fn (fns)
|
4279 |
|
|
|| TREE_CODE (fns) == IDENTIFIER_NODE));
|
4280 |
|
|
|
4281 |
|
|
if (BASELINK_P (fns))
|
4282 |
|
|
{
|
4283 |
|
|
BASELINK_FUNCTIONS (fns) = build2 (TEMPLATE_ID_EXPR,
|
4284 |
|
|
unknown_type_node,
|
4285 |
|
|
BASELINK_FUNCTIONS (fns),
|
4286 |
|
|
arglist);
|
4287 |
|
|
return fns;
|
4288 |
|
|
}
|
4289 |
|
|
|
4290 |
|
|
type = TREE_TYPE (fns);
|
4291 |
|
|
if (TREE_CODE (fns) == OVERLOAD || !type)
|
4292 |
|
|
type = unknown_type_node;
|
4293 |
|
|
|
4294 |
|
|
return build2 (TEMPLATE_ID_EXPR, type, fns, arglist);
|
4295 |
|
|
}
|
4296 |
|
|
|
4297 |
|
|
/* Within the scope of a template class S<T>, the name S gets bound
|
4298 |
|
|
(in build_self_reference) to a TYPE_DECL for the class, not a
|
4299 |
|
|
TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
|
4300 |
|
|
or one of its enclosing classes, and that type is a template,
|
4301 |
|
|
return the associated TEMPLATE_DECL. Otherwise, the original
|
4302 |
|
|
DECL is returned. */
|
4303 |
|
|
|
4304 |
|
|
tree
|
4305 |
|
|
maybe_get_template_decl_from_type_decl (tree decl)
|
4306 |
|
|
{
|
4307 |
|
|
return (decl != NULL_TREE
|
4308 |
|
|
&& TREE_CODE (decl) == TYPE_DECL
|
4309 |
|
|
&& DECL_ARTIFICIAL (decl)
|
4310 |
|
|
&& CLASS_TYPE_P (TREE_TYPE (decl))
|
4311 |
|
|
&& CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl)))
|
4312 |
|
|
? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl)) : decl;
|
4313 |
|
|
}
|
4314 |
|
|
|
4315 |
|
|
/* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
|
4316 |
|
|
parameters, find the desired type.
|
4317 |
|
|
|
4318 |
|
|
D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
|
4319 |
|
|
|
4320 |
|
|
IN_DECL, if non-NULL, is the template declaration we are trying to
|
4321 |
|
|
instantiate.
|
4322 |
|
|
|
4323 |
|
|
If ENTERING_SCOPE is nonzero, we are about to enter the scope of
|
4324 |
|
|
the class we are looking up.
|
4325 |
|
|
|
4326 |
|
|
Issue error and warning messages under control of COMPLAIN.
|
4327 |
|
|
|
4328 |
|
|
If the template class is really a local class in a template
|
4329 |
|
|
function, then the FUNCTION_CONTEXT is the function in which it is
|
4330 |
|
|
being instantiated.
|
4331 |
|
|
|
4332 |
|
|
??? Note that this function is currently called *twice* for each
|
4333 |
|
|
template-id: the first time from the parser, while creating the
|
4334 |
|
|
incomplete type (finish_template_type), and the second type during the
|
4335 |
|
|
real instantiation (instantiate_template_class). This is surely something
|
4336 |
|
|
that we want to avoid. It also causes some problems with argument
|
4337 |
|
|
coercion (see convert_nontype_argument for more information on this). */
|
4338 |
|
|
|
4339 |
|
|
tree
|
4340 |
|
|
lookup_template_class (tree d1,
|
4341 |
|
|
tree arglist,
|
4342 |
|
|
tree in_decl,
|
4343 |
|
|
tree context,
|
4344 |
|
|
int entering_scope,
|
4345 |
|
|
tsubst_flags_t complain)
|
4346 |
|
|
{
|
4347 |
|
|
tree template = NULL_TREE, parmlist;
|
4348 |
|
|
tree t;
|
4349 |
|
|
|
4350 |
|
|
timevar_push (TV_NAME_LOOKUP);
|
4351 |
|
|
|
4352 |
|
|
if (TREE_CODE (d1) == IDENTIFIER_NODE)
|
4353 |
|
|
{
|
4354 |
|
|
tree value = innermost_non_namespace_value (d1);
|
4355 |
|
|
if (value && DECL_TEMPLATE_TEMPLATE_PARM_P (value))
|
4356 |
|
|
template = value;
|
4357 |
|
|
else
|
4358 |
|
|
{
|
4359 |
|
|
if (context)
|
4360 |
|
|
push_decl_namespace (context);
|
4361 |
|
|
template = lookup_name (d1, /*prefer_type=*/0);
|
4362 |
|
|
template = maybe_get_template_decl_from_type_decl (template);
|
4363 |
|
|
if (context)
|
4364 |
|
|
pop_decl_namespace ();
|
4365 |
|
|
}
|
4366 |
|
|
if (template)
|
4367 |
|
|
context = DECL_CONTEXT (template);
|
4368 |
|
|
}
|
4369 |
|
|
else if (TREE_CODE (d1) == TYPE_DECL && IS_AGGR_TYPE (TREE_TYPE (d1)))
|
4370 |
|
|
{
|
4371 |
|
|
tree type = TREE_TYPE (d1);
|
4372 |
|
|
|
4373 |
|
|
/* If we are declaring a constructor, say A<T>::A<T>, we will get
|
4374 |
|
|
an implicit typename for the second A. Deal with it. */
|
4375 |
|
|
if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
|
4376 |
|
|
type = TREE_TYPE (type);
|
4377 |
|
|
|
4378 |
|
|
if (CLASSTYPE_TEMPLATE_INFO (type))
|
4379 |
|
|
{
|
4380 |
|
|
template = CLASSTYPE_TI_TEMPLATE (type);
|
4381 |
|
|
d1 = DECL_NAME (template);
|
4382 |
|
|
}
|
4383 |
|
|
}
|
4384 |
|
|
else if (TREE_CODE (d1) == ENUMERAL_TYPE
|
4385 |
|
|
|| (TYPE_P (d1) && IS_AGGR_TYPE (d1)))
|
4386 |
|
|
{
|
4387 |
|
|
template = TYPE_TI_TEMPLATE (d1);
|
4388 |
|
|
d1 = DECL_NAME (template);
|
4389 |
|
|
}
|
4390 |
|
|
else if (TREE_CODE (d1) == TEMPLATE_DECL
|
4391 |
|
|
&& TREE_CODE (DECL_TEMPLATE_RESULT (d1)) == TYPE_DECL)
|
4392 |
|
|
{
|
4393 |
|
|
template = d1;
|
4394 |
|
|
d1 = DECL_NAME (template);
|
4395 |
|
|
context = DECL_CONTEXT (template);
|
4396 |
|
|
}
|
4397 |
|
|
|
4398 |
|
|
/* Issue an error message if we didn't find a template. */
|
4399 |
|
|
if (! template)
|
4400 |
|
|
{
|
4401 |
|
|
if (complain & tf_error)
|
4402 |
|
|
error ("%qT is not a template", d1);
|
4403 |
|
|
POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
|
4404 |
|
|
}
|
4405 |
|
|
|
4406 |
|
|
if (TREE_CODE (template) != TEMPLATE_DECL
|
4407 |
|
|
/* Make sure it's a user visible template, if it was named by
|
4408 |
|
|
the user. */
|
4409 |
|
|
|| ((complain & tf_user) && !DECL_TEMPLATE_PARM_P (template)
|
4410 |
|
|
&& !PRIMARY_TEMPLATE_P (template)))
|
4411 |
|
|
{
|
4412 |
|
|
if (complain & tf_error)
|
4413 |
|
|
{
|
4414 |
|
|
error ("non-template type %qT used as a template", d1);
|
4415 |
|
|
if (in_decl)
|
4416 |
|
|
error ("for template declaration %q+D", in_decl);
|
4417 |
|
|
}
|
4418 |
|
|
POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
|
4419 |
|
|
}
|
4420 |
|
|
|
4421 |
|
|
complain &= ~tf_user;
|
4422 |
|
|
|
4423 |
|
|
if (DECL_TEMPLATE_TEMPLATE_PARM_P (template))
|
4424 |
|
|
{
|
4425 |
|
|
/* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
|
4426 |
|
|
template arguments */
|
4427 |
|
|
|
4428 |
|
|
tree parm;
|
4429 |
|
|
tree arglist2;
|
4430 |
|
|
|
4431 |
|
|
parmlist = DECL_INNERMOST_TEMPLATE_PARMS (template);
|
4432 |
|
|
|
4433 |
|
|
/* Consider an example where a template template parameter declared as
|
4434 |
|
|
|
4435 |
|
|
template <class T, class U = std::allocator<T> > class TT
|
4436 |
|
|
|
4437 |
|
|
The template parameter level of T and U are one level larger than
|
4438 |
|
|
of TT. To proper process the default argument of U, say when an
|
4439 |
|
|
instantiation `TT<int>' is seen, we need to build the full
|
4440 |
|
|
arguments containing {int} as the innermost level. Outer levels,
|
4441 |
|
|
available when not appearing as default template argument, can be
|
4442 |
|
|
obtained from `current_template_args ()'.
|
4443 |
|
|
|
4444 |
|
|
Suppose that TT is later substituted with std::vector. The above
|
4445 |
|
|
instantiation is `TT<int, std::allocator<T> >' with TT at
|
4446 |
|
|
level 1, and T at level 2, while the template arguments at level 1
|
4447 |
|
|
becomes {std::vector} and the inner level 2 is {int}. */
|
4448 |
|
|
|
4449 |
|
|
if (current_template_parms)
|
4450 |
|
|
arglist = add_to_template_args (current_template_args (), arglist);
|
4451 |
|
|
|
4452 |
|
|
arglist2 = coerce_template_parms (parmlist, arglist, template,
|
4453 |
|
|
complain, /*require_all_args=*/1);
|
4454 |
|
|
if (arglist2 == error_mark_node
|
4455 |
|
|
|| (!uses_template_parms (arglist2)
|
4456 |
|
|
&& check_instantiated_args (template, arglist2, complain)))
|
4457 |
|
|
POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
|
4458 |
|
|
|
4459 |
|
|
parm = bind_template_template_parm (TREE_TYPE (template), arglist2);
|
4460 |
|
|
POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, parm);
|
4461 |
|
|
}
|
4462 |
|
|
else
|
4463 |
|
|
{
|
4464 |
|
|
tree template_type = TREE_TYPE (template);
|
4465 |
|
|
tree gen_tmpl;
|
4466 |
|
|
tree type_decl;
|
4467 |
|
|
tree found = NULL_TREE;
|
4468 |
|
|
int arg_depth;
|
4469 |
|
|
int parm_depth;
|
4470 |
|
|
int is_partial_instantiation;
|
4471 |
|
|
|
4472 |
|
|
gen_tmpl = most_general_template (template);
|
4473 |
|
|
parmlist = DECL_TEMPLATE_PARMS (gen_tmpl);
|
4474 |
|
|
parm_depth = TMPL_PARMS_DEPTH (parmlist);
|
4475 |
|
|
arg_depth = TMPL_ARGS_DEPTH (arglist);
|
4476 |
|
|
|
4477 |
|
|
if (arg_depth == 1 && parm_depth > 1)
|
4478 |
|
|
{
|
4479 |
|
|
/* We've been given an incomplete set of template arguments.
|
4480 |
|
|
For example, given:
|
4481 |
|
|
|
4482 |
|
|
template <class T> struct S1 {
|
4483 |
|
|
template <class U> struct S2 {};
|
4484 |
|
|
template <class U> struct S2<U*> {};
|
4485 |
|
|
};
|
4486 |
|
|
|
4487 |
|
|
we will be called with an ARGLIST of `U*', but the
|
4488 |
|
|
TEMPLATE will be `template <class T> template
|
4489 |
|
|
<class U> struct S1<T>::S2'. We must fill in the missing
|
4490 |
|
|
arguments. */
|
4491 |
|
|
arglist
|
4492 |
|
|
= add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (template)),
|
4493 |
|
|
arglist);
|
4494 |
|
|
arg_depth = TMPL_ARGS_DEPTH (arglist);
|
4495 |
|
|
}
|
4496 |
|
|
|
4497 |
|
|
/* Now we should have enough arguments. */
|
4498 |
|
|
gcc_assert (parm_depth == arg_depth);
|
4499 |
|
|
|
4500 |
|
|
/* From here on, we're only interested in the most general
|
4501 |
|
|
template. */
|
4502 |
|
|
template = gen_tmpl;
|
4503 |
|
|
|
4504 |
|
|
/* Calculate the BOUND_ARGS. These will be the args that are
|
4505 |
|
|
actually tsubst'd into the definition to create the
|
4506 |
|
|
instantiation. */
|
4507 |
|
|
if (parm_depth > 1)
|
4508 |
|
|
{
|
4509 |
|
|
/* We have multiple levels of arguments to coerce, at once. */
|
4510 |
|
|
int i;
|
4511 |
|
|
int saved_depth = TMPL_ARGS_DEPTH (arglist);
|
4512 |
|
|
|
4513 |
|
|
tree bound_args = make_tree_vec (parm_depth);
|
4514 |
|
|
|
4515 |
|
|
for (i = saved_depth,
|
4516 |
|
|
t = DECL_TEMPLATE_PARMS (template);
|
4517 |
|
|
i > 0 && t != NULL_TREE;
|
4518 |
|
|
--i, t = TREE_CHAIN (t))
|
4519 |
|
|
{
|
4520 |
|
|
tree a = coerce_template_parms (TREE_VALUE (t),
|
4521 |
|
|
arglist, template,
|
4522 |
|
|
complain, /*require_all_args=*/1);
|
4523 |
|
|
|
4524 |
|
|
/* Don't process further if one of the levels fails. */
|
4525 |
|
|
if (a == error_mark_node)
|
4526 |
|
|
{
|
4527 |
|
|
/* Restore the ARGLIST to its full size. */
|
4528 |
|
|
TREE_VEC_LENGTH (arglist) = saved_depth;
|
4529 |
|
|
POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
|
4530 |
|
|
}
|
4531 |
|
|
|
4532 |
|
|
SET_TMPL_ARGS_LEVEL (bound_args, i, a);
|
4533 |
|
|
|
4534 |
|
|
/* We temporarily reduce the length of the ARGLIST so
|
4535 |
|
|
that coerce_template_parms will see only the arguments
|
4536 |
|
|
corresponding to the template parameters it is
|
4537 |
|
|
examining. */
|
4538 |
|
|
TREE_VEC_LENGTH (arglist)--;
|
4539 |
|
|
}
|
4540 |
|
|
|
4541 |
|
|
/* Restore the ARGLIST to its full size. */
|
4542 |
|
|
TREE_VEC_LENGTH (arglist) = saved_depth;
|
4543 |
|
|
|
4544 |
|
|
arglist = bound_args;
|
4545 |
|
|
}
|
4546 |
|
|
else
|
4547 |
|
|
arglist
|
4548 |
|
|
= coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist),
|
4549 |
|
|
INNERMOST_TEMPLATE_ARGS (arglist),
|
4550 |
|
|
template,
|
4551 |
|
|
complain, /*require_all_args=*/1);
|
4552 |
|
|
|
4553 |
|
|
if (arglist == error_mark_node)
|
4554 |
|
|
/* We were unable to bind the arguments. */
|
4555 |
|
|
POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
|
4556 |
|
|
|
4557 |
|
|
/* In the scope of a template class, explicit references to the
|
4558 |
|
|
template class refer to the type of the template, not any
|
4559 |
|
|
instantiation of it. For example, in:
|
4560 |
|
|
|
4561 |
|
|
template <class T> class C { void f(C<T>); }
|
4562 |
|
|
|
4563 |
|
|
the `C<T>' is just the same as `C'. Outside of the
|
4564 |
|
|
class, however, such a reference is an instantiation. */
|
4565 |
|
|
if (comp_template_args (TYPE_TI_ARGS (template_type),
|
4566 |
|
|
arglist))
|
4567 |
|
|
{
|
4568 |
|
|
found = template_type;
|
4569 |
|
|
|
4570 |
|
|
if (!entering_scope && PRIMARY_TEMPLATE_P (template))
|
4571 |
|
|
{
|
4572 |
|
|
tree ctx;
|
4573 |
|
|
|
4574 |
|
|
for (ctx = current_class_type;
|
4575 |
|
|
ctx && TREE_CODE (ctx) != NAMESPACE_DECL;
|
4576 |
|
|
ctx = (TYPE_P (ctx)
|
4577 |
|
|
? TYPE_CONTEXT (ctx)
|
4578 |
|
|
: DECL_CONTEXT (ctx)))
|
4579 |
|
|
if (TYPE_P (ctx) && same_type_p (ctx, template_type))
|
4580 |
|
|
goto found_ctx;
|
4581 |
|
|
|
4582 |
|
|
/* We're not in the scope of the class, so the
|
4583 |
|
|
TEMPLATE_TYPE is not the type we want after all. */
|
4584 |
|
|
found = NULL_TREE;
|
4585 |
|
|
found_ctx:;
|
4586 |
|
|
}
|
4587 |
|
|
}
|
4588 |
|
|
if (found)
|
4589 |
|
|
POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
|
4590 |
|
|
|
4591 |
|
|
/* If we already have this specialization, return it. */
|
4592 |
|
|
found = retrieve_specialization (template, arglist,
|
4593 |
|
|
/*class_specializations_p=*/false);
|
4594 |
|
|
if (found)
|
4595 |
|
|
POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
|
4596 |
|
|
|
4597 |
|
|
/* This type is a "partial instantiation" if any of the template
|
4598 |
|
|
arguments still involve template parameters. Note that we set
|
4599 |
|
|
IS_PARTIAL_INSTANTIATION for partial specializations as
|
4600 |
|
|
well. */
|
4601 |
|
|
is_partial_instantiation = uses_template_parms (arglist);
|
4602 |
|
|
|
4603 |
|
|
/* If the deduced arguments are invalid, then the binding
|
4604 |
|
|
failed. */
|
4605 |
|
|
if (!is_partial_instantiation
|
4606 |
|
|
&& check_instantiated_args (template,
|
4607 |
|
|
INNERMOST_TEMPLATE_ARGS (arglist),
|
4608 |
|
|
complain))
|
4609 |
|
|
POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
|
4610 |
|
|
|
4611 |
|
|
if (!is_partial_instantiation
|
4612 |
|
|
&& !PRIMARY_TEMPLATE_P (template)
|
4613 |
|
|
&& TREE_CODE (CP_DECL_CONTEXT (template)) == NAMESPACE_DECL)
|
4614 |
|
|
{
|
4615 |
|
|
found = xref_tag_from_type (TREE_TYPE (template),
|
4616 |
|
|
DECL_NAME (template),
|
4617 |
|
|
/*tag_scope=*/ts_global);
|
4618 |
|
|
POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
|
4619 |
|
|
}
|
4620 |
|
|
|
4621 |
|
|
context = tsubst (DECL_CONTEXT (template), arglist,
|
4622 |
|
|
complain, in_decl);
|
4623 |
|
|
if (!context)
|
4624 |
|
|
context = global_namespace;
|
4625 |
|
|
|
4626 |
|
|
/* Create the type. */
|
4627 |
|
|
if (TREE_CODE (template_type) == ENUMERAL_TYPE)
|
4628 |
|
|
{
|
4629 |
|
|
if (!is_partial_instantiation)
|
4630 |
|
|
{
|
4631 |
|
|
set_current_access_from_decl (TYPE_NAME (template_type));
|
4632 |
|
|
t = start_enum (TYPE_IDENTIFIER (template_type));
|
4633 |
|
|
}
|
4634 |
|
|
else
|
4635 |
|
|
/* We don't want to call start_enum for this type, since
|
4636 |
|
|
the values for the enumeration constants may involve
|
4637 |
|
|
template parameters. And, no one should be interested
|
4638 |
|
|
in the enumeration constants for such a type. */
|
4639 |
|
|
t = make_node (ENUMERAL_TYPE);
|
4640 |
|
|
}
|
4641 |
|
|
else
|
4642 |
|
|
{
|
4643 |
|
|
t = make_aggr_type (TREE_CODE (template_type));
|
4644 |
|
|
CLASSTYPE_DECLARED_CLASS (t)
|
4645 |
|
|
= CLASSTYPE_DECLARED_CLASS (template_type);
|
4646 |
|
|
SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t);
|
4647 |
|
|
TYPE_FOR_JAVA (t) = TYPE_FOR_JAVA (template_type);
|
4648 |
|
|
|
4649 |
|
|
/* A local class. Make sure the decl gets registered properly. */
|
4650 |
|
|
if (context == current_function_decl)
|
4651 |
|
|
pushtag (DECL_NAME (template), t, /*tag_scope=*/ts_current);
|
4652 |
|
|
}
|
4653 |
|
|
|
4654 |
|
|
/* If we called start_enum or pushtag above, this information
|
4655 |
|
|
will already be set up. */
|
4656 |
|
|
if (!TYPE_NAME (t))
|
4657 |
|
|
{
|
4658 |
|
|
TYPE_CONTEXT (t) = FROB_CONTEXT (context);
|
4659 |
|
|
|
4660 |
|
|
type_decl = create_implicit_typedef (DECL_NAME (template), t);
|
4661 |
|
|
DECL_CONTEXT (type_decl) = TYPE_CONTEXT (t);
|
4662 |
|
|
TYPE_STUB_DECL (t) = type_decl;
|
4663 |
|
|
DECL_SOURCE_LOCATION (type_decl)
|
4664 |
|
|
= DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type));
|
4665 |
|
|
}
|
4666 |
|
|
else
|
4667 |
|
|
type_decl = TYPE_NAME (t);
|
4668 |
|
|
|
4669 |
|
|
TREE_PRIVATE (type_decl)
|
4670 |
|
|
= TREE_PRIVATE (TYPE_STUB_DECL (template_type));
|
4671 |
|
|
TREE_PROTECTED (type_decl)
|
4672 |
|
|
= TREE_PROTECTED (TYPE_STUB_DECL (template_type));
|
4673 |
|
|
DECL_IN_SYSTEM_HEADER (type_decl)
|
4674 |
|
|
= DECL_IN_SYSTEM_HEADER (template);
|
4675 |
|
|
if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type))
|
4676 |
|
|
{
|
4677 |
|
|
DECL_VISIBILITY_SPECIFIED (type_decl) = 1;
|
4678 |
|
|
DECL_VISIBILITY (type_decl) = CLASSTYPE_VISIBILITY (template_type);
|
4679 |
|
|
}
|
4680 |
|
|
|
4681 |
|
|
/* Set up the template information. We have to figure out which
|
4682 |
|
|
template is the immediate parent if this is a full
|
4683 |
|
|
instantiation. */
|
4684 |
|
|
if (parm_depth == 1 || is_partial_instantiation
|
4685 |
|
|
|| !PRIMARY_TEMPLATE_P (template))
|
4686 |
|
|
/* This case is easy; there are no member templates involved. */
|
4687 |
|
|
found = template;
|
4688 |
|
|
else
|
4689 |
|
|
{
|
4690 |
|
|
/* This is a full instantiation of a member template. Look
|
4691 |
|
|
for a partial instantiation of which this is an instance. */
|
4692 |
|
|
|
4693 |
|
|
for (found = DECL_TEMPLATE_INSTANTIATIONS (template);
|
4694 |
|
|
found; found = TREE_CHAIN (found))
|
4695 |
|
|
{
|
4696 |
|
|
int success;
|
4697 |
|
|
tree tmpl = CLASSTYPE_TI_TEMPLATE (TREE_VALUE (found));
|
4698 |
|
|
|
4699 |
|
|
/* We only want partial instantiations, here, not
|
4700 |
|
|
specializations or full instantiations. */
|
4701 |
|
|
if (CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_VALUE (found))
|
4702 |
|
|
|| !uses_template_parms (TREE_VALUE (found)))
|
4703 |
|
|
continue;
|
4704 |
|
|
|
4705 |
|
|
/* Temporarily reduce by one the number of levels in the
|
4706 |
|
|
ARGLIST and in FOUND so as to avoid comparing the
|
4707 |
|
|
last set of arguments. */
|
4708 |
|
|
TREE_VEC_LENGTH (arglist)--;
|
4709 |
|
|
TREE_VEC_LENGTH (TREE_PURPOSE (found)) --;
|
4710 |
|
|
|
4711 |
|
|
/* See if the arguments match. If they do, then TMPL is
|
4712 |
|
|
the partial instantiation we want. */
|
4713 |
|
|
success = comp_template_args (TREE_PURPOSE (found), arglist);
|
4714 |
|
|
|
4715 |
|
|
/* Restore the argument vectors to their full size. */
|
4716 |
|
|
TREE_VEC_LENGTH (arglist)++;
|
4717 |
|
|
TREE_VEC_LENGTH (TREE_PURPOSE (found))++;
|
4718 |
|
|
|
4719 |
|
|
if (success)
|
4720 |
|
|
{
|
4721 |
|
|
found = tmpl;
|
4722 |
|
|
break;
|
4723 |
|
|
}
|
4724 |
|
|
}
|
4725 |
|
|
|
4726 |
|
|
if (!found)
|
4727 |
|
|
{
|
4728 |
|
|
/* There was no partial instantiation. This happens
|
4729 |
|
|
where C<T> is a member template of A<T> and it's used
|
4730 |
|
|
in something like
|
4731 |
|
|
|
4732 |
|
|
template <typename T> struct B { A<T>::C<int> m; };
|
4733 |
|
|
B<float>;
|
4734 |
|
|
|
4735 |
|
|
Create the partial instantiation.
|
4736 |
|
|
*/
|
4737 |
|
|
TREE_VEC_LENGTH (arglist)--;
|
4738 |
|
|
found = tsubst (template, arglist, complain, NULL_TREE);
|
4739 |
|
|
TREE_VEC_LENGTH (arglist)++;
|
4740 |
|
|
}
|
4741 |
|
|
}
|
4742 |
|
|
|
4743 |
|
|
SET_TYPE_TEMPLATE_INFO (t, tree_cons (found, arglist, NULL_TREE));
|
4744 |
|
|
DECL_TEMPLATE_INSTANTIATIONS (template)
|
4745 |
|
|
= tree_cons (arglist, t,
|
4746 |
|
|
DECL_TEMPLATE_INSTANTIATIONS (template));
|
4747 |
|
|
|
4748 |
|
|
if (TREE_CODE (t) == ENUMERAL_TYPE
|
4749 |
|
|
&& !is_partial_instantiation)
|
4750 |
|
|
/* Now that the type has been registered on the instantiations
|
4751 |
|
|
list, we set up the enumerators. Because the enumeration
|
4752 |
|
|
constants may involve the enumeration type itself, we make
|
4753 |
|
|
sure to register the type first, and then create the
|
4754 |
|
|
constants. That way, doing tsubst_expr for the enumeration
|
4755 |
|
|
constants won't result in recursive calls here; we'll find
|
4756 |
|
|
the instantiation and exit above. */
|
4757 |
|
|
tsubst_enum (template_type, t, arglist);
|
4758 |
|
|
|
4759 |
|
|
/* Reset the name of the type, now that CLASSTYPE_TEMPLATE_INFO
|
4760 |
|
|
is set up. */
|
4761 |
|
|
if (TREE_CODE (t) != ENUMERAL_TYPE)
|
4762 |
|
|
DECL_NAME (type_decl) = classtype_mangled_name (t);
|
4763 |
|
|
if (is_partial_instantiation)
|
4764 |
|
|
/* If the type makes use of template parameters, the
|
4765 |
|
|
code that generates debugging information will crash. */
|
4766 |
|
|
DECL_IGNORED_P (TYPE_STUB_DECL (t)) = 1;
|
4767 |
|
|
|
4768 |
|
|
POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
|
4769 |
|
|
}
|
4770 |
|
|
timevar_pop (TV_NAME_LOOKUP);
|
4771 |
|
|
}
|
4772 |
|
|
|
4773 |
|
|
struct pair_fn_data
|
4774 |
|
|
{
|
4775 |
|
|
tree_fn_t fn;
|
4776 |
|
|
void *data;
|
4777 |
|
|
struct pointer_set_t *visited;
|
4778 |
|
|
};
|
4779 |
|
|
|
4780 |
|
|
/* Called from for_each_template_parm via walk_tree. */
|
4781 |
|
|
|
4782 |
|
|
static tree
|
4783 |
|
|
for_each_template_parm_r (tree *tp, int *walk_subtrees, void *d)
|
4784 |
|
|
{
|
4785 |
|
|
tree t = *tp;
|
4786 |
|
|
struct pair_fn_data *pfd = (struct pair_fn_data *) d;
|
4787 |
|
|
tree_fn_t fn = pfd->fn;
|
4788 |
|
|
void *data = pfd->data;
|
4789 |
|
|
|
4790 |
|
|
if (TYPE_P (t)
|
4791 |
|
|
&& for_each_template_parm (TYPE_CONTEXT (t), fn, data, pfd->visited))
|
4792 |
|
|
return error_mark_node;
|
4793 |
|
|
|
4794 |
|
|
switch (TREE_CODE (t))
|
4795 |
|
|
{
|
4796 |
|
|
case RECORD_TYPE:
|
4797 |
|
|
if (TYPE_PTRMEMFUNC_P (t))
|
4798 |
|
|
break;
|
4799 |
|
|
/* Fall through. */
|
4800 |
|
|
|
4801 |
|
|
case UNION_TYPE:
|
4802 |
|
|
case ENUMERAL_TYPE:
|
4803 |
|
|
if (!TYPE_TEMPLATE_INFO (t))
|
4804 |
|
|
*walk_subtrees = 0;
|
4805 |
|
|
else if (for_each_template_parm (TREE_VALUE (TYPE_TEMPLATE_INFO (t)),
|
4806 |
|
|
fn, data, pfd->visited))
|
4807 |
|
|
return error_mark_node;
|
4808 |
|
|
break;
|
4809 |
|
|
|
4810 |
|
|
case METHOD_TYPE:
|
4811 |
|
|
/* Since we're not going to walk subtrees, we have to do this
|
4812 |
|
|
explicitly here. */
|
4813 |
|
|
if (for_each_template_parm (TYPE_METHOD_BASETYPE (t), fn, data,
|
4814 |
|
|
pfd->visited))
|
4815 |
|
|
return error_mark_node;
|
4816 |
|
|
/* Fall through. */
|
4817 |
|
|
|
4818 |
|
|
case FUNCTION_TYPE:
|
4819 |
|
|
/* Check the return type. */
|
4820 |
|
|
if (for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited))
|
4821 |
|
|
return error_mark_node;
|
4822 |
|
|
|
4823 |
|
|
/* Check the parameter types. Since default arguments are not
|
4824 |
|
|
instantiated until they are needed, the TYPE_ARG_TYPES may
|
4825 |
|
|
contain expressions that involve template parameters. But,
|
4826 |
|
|
no-one should be looking at them yet. And, once they're
|
4827 |
|
|
instantiated, they don't contain template parameters, so
|
4828 |
|
|
there's no point in looking at them then, either. */
|
4829 |
|
|
{
|
4830 |
|
|
tree parm;
|
4831 |
|
|
|
4832 |
|
|
for (parm = TYPE_ARG_TYPES (t); parm; parm = TREE_CHAIN (parm))
|
4833 |
|
|
if (for_each_template_parm (TREE_VALUE (parm), fn, data,
|
4834 |
|
|
pfd->visited))
|
4835 |
|
|
return error_mark_node;
|
4836 |
|
|
|
4837 |
|
|
/* Since we've already handled the TYPE_ARG_TYPES, we don't
|
4838 |
|
|
want walk_tree walking into them itself. */
|
4839 |
|
|
*walk_subtrees = 0;
|
4840 |
|
|
}
|
4841 |
|
|
break;
|
4842 |
|
|
|
4843 |
|
|
case TYPEOF_TYPE:
|
4844 |
|
|
if (for_each_template_parm (TYPE_FIELDS (t), fn, data,
|
4845 |
|
|
pfd->visited))
|
4846 |
|
|
return error_mark_node;
|
4847 |
|
|
break;
|
4848 |
|
|
|
4849 |
|
|
case FUNCTION_DECL:
|
4850 |
|
|
case VAR_DECL:
|
4851 |
|
|
if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t)
|
4852 |
|
|
&& for_each_template_parm (DECL_TI_ARGS (t), fn, data,
|
4853 |
|
|
pfd->visited))
|
4854 |
|
|
return error_mark_node;
|
4855 |
|
|
/* Fall through. */
|
4856 |
|
|
|
4857 |
|
|
case PARM_DECL:
|
4858 |
|
|
case CONST_DECL:
|
4859 |
|
|
if (TREE_CODE (t) == CONST_DECL && DECL_TEMPLATE_PARM_P (t)
|
4860 |
|
|
&& for_each_template_parm (DECL_INITIAL (t), fn, data,
|
4861 |
|
|
pfd->visited))
|
4862 |
|
|
return error_mark_node;
|
4863 |
|
|
if (DECL_CONTEXT (t)
|
4864 |
|
|
&& for_each_template_parm (DECL_CONTEXT (t), fn, data,
|
4865 |
|
|
pfd->visited))
|
4866 |
|
|
return error_mark_node;
|
4867 |
|
|
break;
|
4868 |
|
|
|
4869 |
|
|
case BOUND_TEMPLATE_TEMPLATE_PARM:
|
4870 |
|
|
/* Record template parameters such as `T' inside `TT<T>'. */
|
4871 |
|
|
if (for_each_template_parm (TYPE_TI_ARGS (t), fn, data, pfd->visited))
|
4872 |
|
|
return error_mark_node;
|
4873 |
|
|
/* Fall through. */
|
4874 |
|
|
|
4875 |
|
|
case TEMPLATE_TEMPLATE_PARM:
|
4876 |
|
|
case TEMPLATE_TYPE_PARM:
|
4877 |
|
|
case TEMPLATE_PARM_INDEX:
|
4878 |
|
|
if (fn && (*fn)(t, data))
|
4879 |
|
|
return error_mark_node;
|
4880 |
|
|
else if (!fn)
|
4881 |
|
|
return error_mark_node;
|
4882 |
|
|
break;
|
4883 |
|
|
|
4884 |
|
|
case TEMPLATE_DECL:
|
4885 |
|
|
/* A template template parameter is encountered. */
|
4886 |
|
|
if (DECL_TEMPLATE_TEMPLATE_PARM_P (t)
|
4887 |
|
|
&& for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited))
|
4888 |
|
|
return error_mark_node;
|
4889 |
|
|
|
4890 |
|
|
/* Already substituted template template parameter */
|
4891 |
|
|
*walk_subtrees = 0;
|
4892 |
|
|
break;
|
4893 |
|
|
|
4894 |
|
|
case TYPENAME_TYPE:
|
4895 |
|
|
if (!fn
|
4896 |
|
|
|| for_each_template_parm (TYPENAME_TYPE_FULLNAME (t), fn,
|
4897 |
|
|
data, pfd->visited))
|
4898 |
|
|
return error_mark_node;
|
4899 |
|
|
break;
|
4900 |
|
|
|
4901 |
|
|
case CONSTRUCTOR:
|
4902 |
|
|
if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t))
|
4903 |
|
|
&& for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
|
4904 |
|
|
(TREE_TYPE (t)), fn, data,
|
4905 |
|
|
pfd->visited))
|
4906 |
|
|
return error_mark_node;
|
4907 |
|
|
break;
|
4908 |
|
|
|
4909 |
|
|
case INDIRECT_REF:
|
4910 |
|
|
case COMPONENT_REF:
|
4911 |
|
|
/* If there's no type, then this thing must be some expression
|
4912 |
|
|
involving template parameters. */
|
4913 |
|
|
if (!fn && !TREE_TYPE (t))
|
4914 |
|
|
return error_mark_node;
|
4915 |
|
|
break;
|
4916 |
|
|
|
4917 |
|
|
case MODOP_EXPR:
|
4918 |
|
|
case CAST_EXPR:
|
4919 |
|
|
case REINTERPRET_CAST_EXPR:
|
4920 |
|
|
case CONST_CAST_EXPR:
|
4921 |
|
|
case STATIC_CAST_EXPR:
|
4922 |
|
|
case DYNAMIC_CAST_EXPR:
|
4923 |
|
|
case ARROW_EXPR:
|
4924 |
|
|
case DOTSTAR_EXPR:
|
4925 |
|
|
case TYPEID_EXPR:
|
4926 |
|
|
case PSEUDO_DTOR_EXPR:
|
4927 |
|
|
if (!fn)
|
4928 |
|
|
return error_mark_node;
|
4929 |
|
|
break;
|
4930 |
|
|
|
4931 |
|
|
case BASELINK:
|
4932 |
|
|
/* If we do not handle this case specially, we end up walking
|
4933 |
|
|
the BINFO hierarchy, which is circular, and therefore
|
4934 |
|
|
confuses walk_tree. */
|
4935 |
|
|
*walk_subtrees = 0;
|
4936 |
|
|
if (for_each_template_parm (BASELINK_FUNCTIONS (*tp), fn, data,
|
4937 |
|
|
pfd->visited))
|
4938 |
|
|
return error_mark_node;
|
4939 |
|
|
break;
|
4940 |
|
|
|
4941 |
|
|
default:
|
4942 |
|
|
break;
|
4943 |
|
|
}
|
4944 |
|
|
|
4945 |
|
|
/* We didn't find any template parameters we liked. */
|
4946 |
|
|
return NULL_TREE;
|
4947 |
|
|
}
|
4948 |
|
|
|
4949 |
|
|
/* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
|
4950 |
|
|
BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
|
4951 |
|
|
call FN with the parameter and the DATA.
|
4952 |
|
|
If FN returns nonzero, the iteration is terminated, and
|
4953 |
|
|
for_each_template_parm returns 1. Otherwise, the iteration
|
4954 |
|
|
continues. If FN never returns a nonzero value, the value
|
4955 |
|
|
returned by for_each_template_parm is 0. If FN is NULL, it is
|
4956 |
|
|
considered to be the function which always returns 1. */
|
4957 |
|
|
|
4958 |
|
|
static int
|
4959 |
|
|
for_each_template_parm (tree t, tree_fn_t fn, void* data,
|
4960 |
|
|
struct pointer_set_t *visited)
|
4961 |
|
|
{
|
4962 |
|
|
struct pair_fn_data pfd;
|
4963 |
|
|
int result;
|
4964 |
|
|
|
4965 |
|
|
/* Set up. */
|
4966 |
|
|
pfd.fn = fn;
|
4967 |
|
|
pfd.data = data;
|
4968 |
|
|
|
4969 |
|
|
/* Walk the tree. (Conceptually, we would like to walk without
|
4970 |
|
|
duplicates, but for_each_template_parm_r recursively calls
|
4971 |
|
|
for_each_template_parm, so we would need to reorganize a fair
|
4972 |
|
|
bit to use walk_tree_without_duplicates, so we keep our own
|
4973 |
|
|
visited list.) */
|
4974 |
|
|
if (visited)
|
4975 |
|
|
pfd.visited = visited;
|
4976 |
|
|
else
|
4977 |
|
|
pfd.visited = pointer_set_create ();
|
4978 |
|
|
result = walk_tree (&t,
|
4979 |
|
|
for_each_template_parm_r,
|
4980 |
|
|
&pfd,
|
4981 |
|
|
pfd.visited) != NULL_TREE;
|
4982 |
|
|
|
4983 |
|
|
/* Clean up. */
|
4984 |
|
|
if (!visited)
|
4985 |
|
|
{
|
4986 |
|
|
pointer_set_destroy (pfd.visited);
|
4987 |
|
|
pfd.visited = 0;
|
4988 |
|
|
}
|
4989 |
|
|
|
4990 |
|
|
return result;
|
4991 |
|
|
}
|
4992 |
|
|
|
4993 |
|
|
/* Returns true if T depends on any template parameter. */
|
4994 |
|
|
|
4995 |
|
|
int
|
4996 |
|
|
uses_template_parms (tree t)
|
4997 |
|
|
{
|
4998 |
|
|
bool dependent_p;
|
4999 |
|
|
int saved_processing_template_decl;
|
5000 |
|
|
|
5001 |
|
|
saved_processing_template_decl = processing_template_decl;
|
5002 |
|
|
if (!saved_processing_template_decl)
|
5003 |
|
|
processing_template_decl = 1;
|
5004 |
|
|
if (TYPE_P (t))
|
5005 |
|
|
dependent_p = dependent_type_p (t);
|
5006 |
|
|
else if (TREE_CODE (t) == TREE_VEC)
|
5007 |
|
|
dependent_p = any_dependent_template_arguments_p (t);
|
5008 |
|
|
else if (TREE_CODE (t) == TREE_LIST)
|
5009 |
|
|
dependent_p = (uses_template_parms (TREE_VALUE (t))
|
5010 |
|
|
|| uses_template_parms (TREE_CHAIN (t)));
|
5011 |
|
|
else if (TREE_CODE (t) == TYPE_DECL)
|
5012 |
|
|
dependent_p = dependent_type_p (TREE_TYPE (t));
|
5013 |
|
|
else if (DECL_P (t)
|
5014 |
|
|
|| EXPR_P (t)
|
5015 |
|
|
|| TREE_CODE (t) == TEMPLATE_PARM_INDEX
|
5016 |
|
|
|| TREE_CODE (t) == OVERLOAD
|
5017 |
|
|
|| TREE_CODE (t) == BASELINK
|
5018 |
|
|
|| TREE_CODE (t) == IDENTIFIER_NODE
|
5019 |
|
|
|| CONSTANT_CLASS_P (t))
|
5020 |
|
|
dependent_p = (type_dependent_expression_p (t)
|
5021 |
|
|
|| value_dependent_expression_p (t));
|
5022 |
|
|
else
|
5023 |
|
|
{
|
5024 |
|
|
gcc_assert (t == error_mark_node);
|
5025 |
|
|
dependent_p = false;
|
5026 |
|
|
}
|
5027 |
|
|
|
5028 |
|
|
processing_template_decl = saved_processing_template_decl;
|
5029 |
|
|
|
5030 |
|
|
return dependent_p;
|
5031 |
|
|
}
|
5032 |
|
|
|
5033 |
|
|
/* Returns true if T depends on any template parameter with level LEVEL. */
|
5034 |
|
|
|
5035 |
|
|
int
|
5036 |
|
|
uses_template_parms_level (tree t, int level)
|
5037 |
|
|
{
|
5038 |
|
|
return for_each_template_parm (t, template_parm_this_level_p, &level, NULL);
|
5039 |
|
|
}
|
5040 |
|
|
|
5041 |
|
|
static int tinst_depth;
|
5042 |
|
|
extern int max_tinst_depth;
|
5043 |
|
|
#ifdef GATHER_STATISTICS
|
5044 |
|
|
int depth_reached;
|
5045 |
|
|
#endif
|
5046 |
|
|
static int tinst_level_tick;
|
5047 |
|
|
static int last_template_error_tick;
|
5048 |
|
|
|
5049 |
|
|
/* We're starting to instantiate D; record the template instantiation context
|
5050 |
|
|
for diagnostics and to restore it later. */
|
5051 |
|
|
|
5052 |
|
|
int
|
5053 |
|
|
push_tinst_level (tree d)
|
5054 |
|
|
{
|
5055 |
|
|
tree new;
|
5056 |
|
|
|
5057 |
|
|
if (tinst_depth >= max_tinst_depth)
|
5058 |
|
|
{
|
5059 |
|
|
/* If the instantiation in question still has unbound template parms,
|
5060 |
|
|
we don't really care if we can't instantiate it, so just return.
|
5061 |
|
|
This happens with base instantiation for implicit `typename'. */
|
5062 |
|
|
if (uses_template_parms (d))
|
5063 |
|
|
return 0;
|
5064 |
|
|
|
5065 |
|
|
last_template_error_tick = tinst_level_tick;
|
5066 |
|
|
error ("template instantiation depth exceeds maximum of %d (use "
|
5067 |
|
|
"-ftemplate-depth-NN to increase the maximum) instantiating %qD",
|
5068 |
|
|
max_tinst_depth, d);
|
5069 |
|
|
|
5070 |
|
|
print_instantiation_context ();
|
5071 |
|
|
|
5072 |
|
|
return 0;
|
5073 |
|
|
}
|
5074 |
|
|
|
5075 |
|
|
new = make_node (TINST_LEVEL);
|
5076 |
|
|
TINST_DECL (new) = d;
|
5077 |
|
|
TINST_LOCATION (new) = input_location;
|
5078 |
|
|
TINST_IN_SYSTEM_HEADER_P (new) = in_system_header;
|
5079 |
|
|
TREE_CHAIN (new) = current_tinst_level;
|
5080 |
|
|
current_tinst_level = new;
|
5081 |
|
|
|
5082 |
|
|
++tinst_depth;
|
5083 |
|
|
#ifdef GATHER_STATISTICS
|
5084 |
|
|
if (tinst_depth > depth_reached)
|
5085 |
|
|
depth_reached = tinst_depth;
|
5086 |
|
|
#endif
|
5087 |
|
|
|
5088 |
|
|
++tinst_level_tick;
|
5089 |
|
|
return 1;
|
5090 |
|
|
}
|
5091 |
|
|
|
5092 |
|
|
/* We're done instantiating this template; return to the instantiation
|
5093 |
|
|
context. */
|
5094 |
|
|
|
5095 |
|
|
void
|
5096 |
|
|
pop_tinst_level (void)
|
5097 |
|
|
{
|
5098 |
|
|
tree old = current_tinst_level;
|
5099 |
|
|
|
5100 |
|
|
/* Restore the filename and line number stashed away when we started
|
5101 |
|
|
this instantiation. */
|
5102 |
|
|
input_location = TINST_LOCATION (old);
|
5103 |
|
|
in_system_header = TINST_IN_SYSTEM_HEADER_P (old);
|
5104 |
|
|
current_tinst_level = TREE_CHAIN (old);
|
5105 |
|
|
--tinst_depth;
|
5106 |
|
|
++tinst_level_tick;
|
5107 |
|
|
}
|
5108 |
|
|
|
5109 |
|
|
/* We're instantiating a deferred template; restore the template
|
5110 |
|
|
instantiation context in which the instantiation was requested, which
|
5111 |
|
|
is one step out from LEVEL. */
|
5112 |
|
|
|
5113 |
|
|
static void
|
5114 |
|
|
reopen_tinst_level (tree level)
|
5115 |
|
|
{
|
5116 |
|
|
tree t;
|
5117 |
|
|
|
5118 |
|
|
tinst_depth = 0;
|
5119 |
|
|
for (t = level; t; t = TREE_CHAIN (t))
|
5120 |
|
|
++tinst_depth;
|
5121 |
|
|
|
5122 |
|
|
current_tinst_level = level;
|
5123 |
|
|
pop_tinst_level ();
|
5124 |
|
|
}
|
5125 |
|
|
|
5126 |
|
|
/* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
|
5127 |
|
|
vector of template arguments, as for tsubst.
|
5128 |
|
|
|
5129 |
|
|
Returns an appropriate tsubst'd friend declaration. */
|
5130 |
|
|
|
5131 |
|
|
static tree
|
5132 |
|
|
tsubst_friend_function (tree decl, tree args)
|
5133 |
|
|
{
|
5134 |
|
|
tree new_friend;
|
5135 |
|
|
|
5136 |
|
|
if (TREE_CODE (decl) == FUNCTION_DECL
|
5137 |
|
|
&& DECL_TEMPLATE_INSTANTIATION (decl)
|
5138 |
|
|
&& TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
|
5139 |
|
|
/* This was a friend declared with an explicit template
|
5140 |
|
|
argument list, e.g.:
|
5141 |
|
|
|
5142 |
|
|
friend void f<>(T);
|
5143 |
|
|
|
5144 |
|
|
to indicate that f was a template instantiation, not a new
|
5145 |
|
|
function declaration. Now, we have to figure out what
|
5146 |
|
|
instantiation of what template. */
|
5147 |
|
|
{
|
5148 |
|
|
tree template_id, arglist, fns;
|
5149 |
|
|
tree new_args;
|
5150 |
|
|
tree tmpl;
|
5151 |
|
|
tree ns = decl_namespace_context (TYPE_MAIN_DECL (current_class_type));
|
5152 |
|
|
|
5153 |
|
|
/* Friend functions are looked up in the containing namespace scope.
|
5154 |
|
|
We must enter that scope, to avoid finding member functions of the
|
5155 |
|
|
current cless with same name. */
|
5156 |
|
|
push_nested_namespace (ns);
|
5157 |
|
|
fns = tsubst_expr (DECL_TI_TEMPLATE (decl), args,
|
5158 |
|
|
tf_error | tf_warning, NULL_TREE);
|
5159 |
|
|
pop_nested_namespace (ns);
|
5160 |
|
|
arglist = tsubst (DECL_TI_ARGS (decl), args,
|
5161 |
|
|
tf_error | tf_warning, NULL_TREE);
|
5162 |
|
|
template_id = lookup_template_function (fns, arglist);
|
5163 |
|
|
|
5164 |
|
|
new_friend = tsubst (decl, args, tf_error | tf_warning, NULL_TREE);
|
5165 |
|
|
tmpl = determine_specialization (template_id, new_friend,
|
5166 |
|
|
&new_args,
|
5167 |
|
|
/*need_member_template=*/0,
|
5168 |
|
|
TREE_VEC_LENGTH (args));
|
5169 |
|
|
return instantiate_template (tmpl, new_args, tf_error);
|
5170 |
|
|
}
|
5171 |
|
|
|
5172 |
|
|
new_friend = tsubst (decl, args, tf_error | tf_warning, NULL_TREE);
|
5173 |
|
|
|
5174 |
|
|
/* The NEW_FRIEND will look like an instantiation, to the
|
5175 |
|
|
compiler, but is not an instantiation from the point of view of
|
5176 |
|
|
the language. For example, we might have had:
|
5177 |
|
|
|
5178 |
|
|
template <class T> struct S {
|
5179 |
|
|
template <class U> friend void f(T, U);
|
5180 |
|
|
};
|
5181 |
|
|
|
5182 |
|
|
Then, in S<int>, template <class U> void f(int, U) is not an
|
5183 |
|
|
instantiation of anything. */
|
5184 |
|
|
if (new_friend == error_mark_node)
|
5185 |
|
|
return error_mark_node;
|
5186 |
|
|
|
5187 |
|
|
DECL_USE_TEMPLATE (new_friend) = 0;
|
5188 |
|
|
if (TREE_CODE (decl) == TEMPLATE_DECL)
|
5189 |
|
|
{
|
5190 |
|
|
DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend)) = 0;
|
5191 |
|
|
DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend))
|
5192 |
|
|
= DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl));
|
5193 |
|
|
}
|
5194 |
|
|
|
5195 |
|
|
/* The mangled name for the NEW_FRIEND is incorrect. The function
|
5196 |
|
|
is not a template instantiation and should not be mangled like
|
5197 |
|
|
one. Therefore, we forget the mangling here; we'll recompute it
|
5198 |
|
|
later if we need it. */
|
5199 |
|
|
if (TREE_CODE (new_friend) != TEMPLATE_DECL)
|
5200 |
|
|
{
|
5201 |
|
|
SET_DECL_RTL (new_friend, NULL_RTX);
|
5202 |
|
|
SET_DECL_ASSEMBLER_NAME (new_friend, NULL_TREE);
|
5203 |
|
|
}
|
5204 |
|
|
|
5205 |
|
|
if (DECL_NAMESPACE_SCOPE_P (new_friend))
|
5206 |
|
|
{
|
5207 |
|
|
tree old_decl;
|
5208 |
|
|
tree new_friend_template_info;
|
5209 |
|
|
tree new_friend_result_template_info;
|
5210 |
|
|
tree ns;
|
5211 |
|
|
int new_friend_is_defn;
|
5212 |
|
|
|
5213 |
|
|
/* We must save some information from NEW_FRIEND before calling
|
5214 |
|
|
duplicate decls since that function will free NEW_FRIEND if
|
5215 |
|
|
possible. */
|
5216 |
|
|
new_friend_template_info = DECL_TEMPLATE_INFO (new_friend);
|
5217 |
|
|
new_friend_is_defn =
|
5218 |
|
|
(DECL_INITIAL (DECL_TEMPLATE_RESULT
|
5219 |
|
|
(template_for_substitution (new_friend)))
|
5220 |
|
|
!= NULL_TREE);
|
5221 |
|
|
if (TREE_CODE (new_friend) == TEMPLATE_DECL)
|
5222 |
|
|
{
|
5223 |
|
|
/* This declaration is a `primary' template. */
|
5224 |
|
|
DECL_PRIMARY_TEMPLATE (new_friend) = new_friend;
|
5225 |
|
|
|
5226 |
|
|
new_friend_result_template_info
|
5227 |
|
|
= DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend));
|
5228 |
|
|
}
|
5229 |
|
|
else
|
5230 |
|
|
new_friend_result_template_info = NULL_TREE;
|
5231 |
|
|
|
5232 |
|
|
/* Inside pushdecl_namespace_level, we will push into the
|
5233 |
|
|
current namespace. However, the friend function should go
|
5234 |
|
|
into the namespace of the template. */
|
5235 |
|
|
ns = decl_namespace_context (new_friend);
|
5236 |
|
|
push_nested_namespace (ns);
|
5237 |
|
|
old_decl = pushdecl_namespace_level (new_friend, /*is_friend=*/true);
|
5238 |
|
|
pop_nested_namespace (ns);
|
5239 |
|
|
|
5240 |
|
|
if (old_decl != new_friend)
|
5241 |
|
|
{
|
5242 |
|
|
/* This new friend declaration matched an existing
|
5243 |
|
|
declaration. For example, given:
|
5244 |
|
|
|
5245 |
|
|
template <class T> void f(T);
|
5246 |
|
|
template <class U> class C {
|
5247 |
|
|
template <class T> friend void f(T) {}
|
5248 |
|
|
};
|
5249 |
|
|
|
5250 |
|
|
the friend declaration actually provides the definition
|
5251 |
|
|
of `f', once C has been instantiated for some type. So,
|
5252 |
|
|
old_decl will be the out-of-class template declaration,
|
5253 |
|
|
while new_friend is the in-class definition.
|
5254 |
|
|
|
5255 |
|
|
But, if `f' was called before this point, the
|
5256 |
|
|
instantiation of `f' will have DECL_TI_ARGS corresponding
|
5257 |
|
|
to `T' but not to `U', references to which might appear
|
5258 |
|
|
in the definition of `f'. Previously, the most general
|
5259 |
|
|
template for an instantiation of `f' was the out-of-class
|
5260 |
|
|
version; now it is the in-class version. Therefore, we
|
5261 |
|
|
run through all specialization of `f', adding to their
|
5262 |
|
|
DECL_TI_ARGS appropriately. In particular, they need a
|
5263 |
|
|
new set of outer arguments, corresponding to the
|
5264 |
|
|
arguments for this class instantiation.
|
5265 |
|
|
|
5266 |
|
|
The same situation can arise with something like this:
|
5267 |
|
|
|
5268 |
|
|
friend void f(int);
|
5269 |
|
|
template <class T> class C {
|
5270 |
|
|
friend void f(T) {}
|
5271 |
|
|
};
|
5272 |
|
|
|
5273 |
|
|
when `C<int>' is instantiated. Now, `f(int)' is defined
|
5274 |
|
|
in the class. */
|
5275 |
|
|
|
5276 |
|
|
if (!new_friend_is_defn)
|
5277 |
|
|
/* On the other hand, if the in-class declaration does
|
5278 |
|
|
*not* provide a definition, then we don't want to alter
|
5279 |
|
|
existing definitions. We can just leave everything
|
5280 |
|
|
alone. */
|
5281 |
|
|
;
|
5282 |
|
|
else
|
5283 |
|
|
{
|
5284 |
|
|
/* Overwrite whatever template info was there before, if
|
5285 |
|
|
any, with the new template information pertaining to
|
5286 |
|
|
the declaration. */
|
5287 |
|
|
DECL_TEMPLATE_INFO (old_decl) = new_friend_template_info;
|
5288 |
|
|
|
5289 |
|
|
if (TREE_CODE (old_decl) != TEMPLATE_DECL)
|
5290 |
|
|
reregister_specialization (new_friend,
|
5291 |
|
|
most_general_template (old_decl),
|
5292 |
|
|
old_decl);
|
5293 |
|
|
else
|
5294 |
|
|
{
|
5295 |
|
|
tree t;
|
5296 |
|
|
tree new_friend_args;
|
5297 |
|
|
|
5298 |
|
|
DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl))
|
5299 |
|
|
= new_friend_result_template_info;
|
5300 |
|
|
|
5301 |
|
|
new_friend_args = TI_ARGS (new_friend_template_info);
|
5302 |
|
|
for (t = DECL_TEMPLATE_SPECIALIZATIONS (old_decl);
|
5303 |
|
|
t != NULL_TREE;
|
5304 |
|
|
t = TREE_CHAIN (t))
|
5305 |
|
|
{
|
5306 |
|
|
tree spec = TREE_VALUE (t);
|
5307 |
|
|
|
5308 |
|
|
DECL_TI_ARGS (spec)
|
5309 |
|
|
= add_outermost_template_args (new_friend_args,
|
5310 |
|
|
DECL_TI_ARGS (spec));
|
5311 |
|
|
}
|
5312 |
|
|
|
5313 |
|
|
/* Now, since specializations are always supposed to
|
5314 |
|
|
hang off of the most general template, we must move
|
5315 |
|
|
them. */
|
5316 |
|
|
t = most_general_template (old_decl);
|
5317 |
|
|
if (t != old_decl)
|
5318 |
|
|
{
|
5319 |
|
|
DECL_TEMPLATE_SPECIALIZATIONS (t)
|
5320 |
|
|
= chainon (DECL_TEMPLATE_SPECIALIZATIONS (t),
|
5321 |
|
|
DECL_TEMPLATE_SPECIALIZATIONS (old_decl));
|
5322 |
|
|
DECL_TEMPLATE_SPECIALIZATIONS (old_decl) = NULL_TREE;
|
5323 |
|
|
}
|
5324 |
|
|
}
|
5325 |
|
|
}
|
5326 |
|
|
|
5327 |
|
|
/* The information from NEW_FRIEND has been merged into OLD_DECL
|
5328 |
|
|
by duplicate_decls. */
|
5329 |
|
|
new_friend = old_decl;
|
5330 |
|
|
}
|
5331 |
|
|
}
|
5332 |
|
|
else
|
5333 |
|
|
{
|
5334 |
|
|
tree context = DECL_CONTEXT (new_friend);
|
5335 |
|
|
bool dependent_p;
|
5336 |
|
|
|
5337 |
|
|
/* In the code
|
5338 |
|
|
template <class T> class C {
|
5339 |
|
|
template <class U> friend void C1<U>::f (); // case 1
|
5340 |
|
|
friend void C2<T>::f (); // case 2
|
5341 |
|
|
};
|
5342 |
|
|
we only need to make sure CONTEXT is a complete type for
|
5343 |
|
|
case 2. To distinguish between the two cases, we note that
|
5344 |
|
|
CONTEXT of case 1 remains dependent type after tsubst while
|
5345 |
|
|
this isn't true for case 2. */
|
5346 |
|
|
++processing_template_decl;
|
5347 |
|
|
dependent_p = dependent_type_p (context);
|
5348 |
|
|
--processing_template_decl;
|
5349 |
|
|
|
5350 |
|
|
if (!dependent_p
|
5351 |
|
|
&& !complete_type_or_else (context, NULL_TREE))
|
5352 |
|
|
return error_mark_node;
|
5353 |
|
|
|
5354 |
|
|
if (COMPLETE_TYPE_P (context))
|
5355 |
|
|
{
|
5356 |
|
|
/* Check to see that the declaration is really present, and,
|
5357 |
|
|
possibly obtain an improved declaration. */
|
5358 |
|
|
tree fn = check_classfn (context,
|
5359 |
|
|
new_friend, NULL_TREE);
|
5360 |
|
|
|
5361 |
|
|
if (fn)
|
5362 |
|
|
new_friend = fn;
|
5363 |
|
|
}
|
5364 |
|
|
}
|
5365 |
|
|
|
5366 |
|
|
return new_friend;
|
5367 |
|
|
}
|
5368 |
|
|
|
5369 |
|
|
/* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
|
5370 |
|
|
template arguments, as for tsubst.
|
5371 |
|
|
|
5372 |
|
|
Returns an appropriate tsubst'd friend type or error_mark_node on
|
5373 |
|
|
failure. */
|
5374 |
|
|
|
5375 |
|
|
static tree
|
5376 |
|
|
tsubst_friend_class (tree friend_tmpl, tree args)
|
5377 |
|
|
{
|
5378 |
|
|
tree friend_type;
|
5379 |
|
|
tree tmpl;
|
5380 |
|
|
tree context;
|
5381 |
|
|
|
5382 |
|
|
context = DECL_CONTEXT (friend_tmpl);
|
5383 |
|
|
|
5384 |
|
|
if (context)
|
5385 |
|
|
{
|
5386 |
|
|
if (TREE_CODE (context) == NAMESPACE_DECL)
|
5387 |
|
|
push_nested_namespace (context);
|
5388 |
|
|
else
|
5389 |
|
|
push_nested_class (tsubst (context, args, tf_none, NULL_TREE));
|
5390 |
|
|
}
|
5391 |
|
|
|
5392 |
|
|
/* First, we look for a class template. */
|
5393 |
|
|
tmpl = lookup_name (DECL_NAME (friend_tmpl), /*prefer_type=*/0);
|
5394 |
|
|
|
5395 |
|
|
/* But, if we don't find one, it might be because we're in a
|
5396 |
|
|
situation like this:
|
5397 |
|
|
|
5398 |
|
|
template <class T>
|
5399 |
|
|
struct S {
|
5400 |
|
|
template <class U>
|
5401 |
|
|
friend struct S;
|
5402 |
|
|
};
|
5403 |
|
|
|
5404 |
|
|
Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
|
5405 |
|
|
for `S<int>', not the TEMPLATE_DECL. */
|
5406 |
|
|
if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
|
5407 |
|
|
{
|
5408 |
|
|
tmpl = lookup_name (DECL_NAME (friend_tmpl), /*prefer_type=*/1);
|
5409 |
|
|
tmpl = maybe_get_template_decl_from_type_decl (tmpl);
|
5410 |
|
|
}
|
5411 |
|
|
|
5412 |
|
|
if (tmpl && DECL_CLASS_TEMPLATE_P (tmpl))
|
5413 |
|
|
{
|
5414 |
|
|
/* The friend template has already been declared. Just
|
5415 |
|
|
check to see that the declarations match, and install any new
|
5416 |
|
|
default parameters. We must tsubst the default parameters,
|
5417 |
|
|
of course. We only need the innermost template parameters
|
5418 |
|
|
because that is all that redeclare_class_template will look
|
5419 |
|
|
at. */
|
5420 |
|
|
if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl))
|
5421 |
|
|
> TMPL_ARGS_DEPTH (args))
|
5422 |
|
|
{
|
5423 |
|
|
tree parms;
|
5424 |
|
|
parms = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl),
|
5425 |
|
|
args, tf_error | tf_warning);
|
5426 |
|
|
redeclare_class_template (TREE_TYPE (tmpl), parms);
|
5427 |
|
|
}
|
5428 |
|
|
|
5429 |
|
|
friend_type = TREE_TYPE (tmpl);
|
5430 |
|
|
}
|
5431 |
|
|
else
|
5432 |
|
|
{
|
5433 |
|
|
/* The friend template has not already been declared. In this
|
5434 |
|
|
case, the instantiation of the template class will cause the
|
5435 |
|
|
injection of this template into the global scope. */
|
5436 |
|
|
tmpl = tsubst (friend_tmpl, args, tf_error | tf_warning, NULL_TREE);
|
5437 |
|
|
|
5438 |
|
|
/* The new TMPL is not an instantiation of anything, so we
|
5439 |
|
|
forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
|
5440 |
|
|
the new type because that is supposed to be the corresponding
|
5441 |
|
|
template decl, i.e., TMPL. */
|
5442 |
|
|
DECL_USE_TEMPLATE (tmpl) = 0;
|
5443 |
|
|
DECL_TEMPLATE_INFO (tmpl) = NULL_TREE;
|
5444 |
|
|
CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl)) = 0;
|
5445 |
|
|
CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl))
|
5446 |
|
|
= INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl)));
|
5447 |
|
|
|
5448 |
|
|
/* Inject this template into the global scope. */
|
5449 |
|
|
friend_type = TREE_TYPE (pushdecl_top_level_maybe_friend (tmpl, true));
|
5450 |
|
|
}
|
5451 |
|
|
|
5452 |
|
|
if (context)
|
5453 |
|
|
{
|
5454 |
|
|
if (TREE_CODE (context) == NAMESPACE_DECL)
|
5455 |
|
|
pop_nested_namespace (context);
|
5456 |
|
|
else
|
5457 |
|
|
pop_nested_class ();
|
5458 |
|
|
}
|
5459 |
|
|
|
5460 |
|
|
return friend_type;
|
5461 |
|
|
}
|
5462 |
|
|
|
5463 |
|
|
/* Returns zero if TYPE cannot be completed later due to circularity.
|
5464 |
|
|
Otherwise returns one. */
|
5465 |
|
|
|
5466 |
|
|
static int
|
5467 |
|
|
can_complete_type_without_circularity (tree type)
|
5468 |
|
|
{
|
5469 |
|
|
if (type == NULL_TREE || type == error_mark_node)
|
5470 |
|
|
return 0;
|
5471 |
|
|
else if (COMPLETE_TYPE_P (type))
|
5472 |
|
|
return 1;
|
5473 |
|
|
else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
|
5474 |
|
|
return can_complete_type_without_circularity (TREE_TYPE (type));
|
5475 |
|
|
else if (CLASS_TYPE_P (type)
|
5476 |
|
|
&& TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type)))
|
5477 |
|
|
return 0;
|
5478 |
|
|
else
|
5479 |
|
|
return 1;
|
5480 |
|
|
}
|
5481 |
|
|
|
5482 |
|
|
tree
|
5483 |
|
|
instantiate_class_template (tree type)
|
5484 |
|
|
{
|
5485 |
|
|
tree template, args, pattern, t, member;
|
5486 |
|
|
tree typedecl;
|
5487 |
|
|
tree pbinfo;
|
5488 |
|
|
tree base_list;
|
5489 |
|
|
|
5490 |
|
|
if (type == error_mark_node)
|
5491 |
|
|
return error_mark_node;
|
5492 |
|
|
|
5493 |
|
|
if (TYPE_BEING_DEFINED (type)
|
5494 |
|
|
|| COMPLETE_TYPE_P (type)
|
5495 |
|
|
|| dependent_type_p (type))
|
5496 |
|
|
return type;
|
5497 |
|
|
|
5498 |
|
|
/* Figure out which template is being instantiated. */
|
5499 |
|
|
template = most_general_template (CLASSTYPE_TI_TEMPLATE (type));
|
5500 |
|
|
gcc_assert (TREE_CODE (template) == TEMPLATE_DECL);
|
5501 |
|
|
|
5502 |
|
|
/* Determine what specialization of the original template to
|
5503 |
|
|
instantiate. */
|
5504 |
|
|
t = most_specialized_class (type, template);
|
5505 |
|
|
if (t == error_mark_node)
|
5506 |
|
|
{
|
5507 |
|
|
TYPE_BEING_DEFINED (type) = 1;
|
5508 |
|
|
return error_mark_node;
|
5509 |
|
|
}
|
5510 |
|
|
else if (t)
|
5511 |
|
|
{
|
5512 |
|
|
/* This TYPE is actually an instantiation of a partial
|
5513 |
|
|
specialization. We replace the innermost set of ARGS with
|
5514 |
|
|
the arguments appropriate for substitution. For example,
|
5515 |
|
|
given:
|
5516 |
|
|
|
5517 |
|
|
template <class T> struct S {};
|
5518 |
|
|
template <class T> struct S<T*> {};
|
5519 |
|
|
|
5520 |
|
|
and supposing that we are instantiating S<int*>, ARGS will
|
5521 |
|
|
presently be {int*} -- but we need {int}. */
|
5522 |
|
|
pattern = TREE_TYPE (t);
|
5523 |
|
|
args = TREE_PURPOSE (t);
|
5524 |
|
|
}
|
5525 |
|
|
else
|
5526 |
|
|
{
|
5527 |
|
|
pattern = TREE_TYPE (template);
|
5528 |
|
|
args = CLASSTYPE_TI_ARGS (type);
|
5529 |
|
|
}
|
5530 |
|
|
|
5531 |
|
|
/* If the template we're instantiating is incomplete, then clearly
|
5532 |
|
|
there's nothing we can do. */
|
5533 |
|
|
if (!COMPLETE_TYPE_P (pattern))
|
5534 |
|
|
return type;
|
5535 |
|
|
|
5536 |
|
|
/* If we've recursively instantiated too many templates, stop. */
|
5537 |
|
|
if (! push_tinst_level (type))
|
5538 |
|
|
return type;
|
5539 |
|
|
|
5540 |
|
|
/* Now we're really doing the instantiation. Mark the type as in
|
5541 |
|
|
the process of being defined. */
|
5542 |
|
|
TYPE_BEING_DEFINED (type) = 1;
|
5543 |
|
|
|
5544 |
|
|
/* We may be in the middle of deferred access check. Disable
|
5545 |
|
|
it now. */
|
5546 |
|
|
push_deferring_access_checks (dk_no_deferred);
|
5547 |
|
|
|
5548 |
|
|
push_to_top_level ();
|
5549 |
|
|
|
5550 |
|
|
SET_CLASSTYPE_INTERFACE_UNKNOWN (type);
|
5551 |
|
|
|
5552 |
|
|
/* Set the input location to the template definition. This is needed
|
5553 |
|
|
if tsubsting causes an error. */
|
5554 |
|
|
typedecl = TYPE_MAIN_DECL (type);
|
5555 |
|
|
input_location = DECL_SOURCE_LOCATION (typedecl);
|
5556 |
|
|
in_system_header = DECL_IN_SYSTEM_HEADER (typedecl);
|
5557 |
|
|
|
5558 |
|
|
TYPE_HAS_CONSTRUCTOR (type) = TYPE_HAS_CONSTRUCTOR (pattern);
|
5559 |
|
|
TYPE_HAS_NEW_OPERATOR (type) = TYPE_HAS_NEW_OPERATOR (pattern);
|
5560 |
|
|
TYPE_HAS_ARRAY_NEW_OPERATOR (type) = TYPE_HAS_ARRAY_NEW_OPERATOR (pattern);
|
5561 |
|
|
TYPE_GETS_DELETE (type) = TYPE_GETS_DELETE (pattern);
|
5562 |
|
|
TYPE_HAS_ASSIGN_REF (type) = TYPE_HAS_ASSIGN_REF (pattern);
|
5563 |
|
|
TYPE_HAS_CONST_ASSIGN_REF (type) = TYPE_HAS_CONST_ASSIGN_REF (pattern);
|
5564 |
|
|
TYPE_HAS_INIT_REF (type) = TYPE_HAS_INIT_REF (pattern);
|
5565 |
|
|
TYPE_HAS_CONST_INIT_REF (type) = TYPE_HAS_CONST_INIT_REF (pattern);
|
5566 |
|
|
TYPE_HAS_DEFAULT_CONSTRUCTOR (type) = TYPE_HAS_DEFAULT_CONSTRUCTOR (pattern);
|
5567 |
|
|
TYPE_HAS_CONVERSION (type) = TYPE_HAS_CONVERSION (pattern);
|
5568 |
|
|
TYPE_PACKED (type) = TYPE_PACKED (pattern);
|
5569 |
|
|
TYPE_ALIGN (type) = TYPE_ALIGN (pattern);
|
5570 |
|
|
TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (pattern);
|
5571 |
|
|
TYPE_FOR_JAVA (type) = TYPE_FOR_JAVA (pattern); /* For libjava's JArray<T> */
|
5572 |
|
|
if (ANON_AGGR_TYPE_P (pattern))
|
5573 |
|
|
SET_ANON_AGGR_TYPE_P (type);
|
5574 |
|
|
if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern))
|
5575 |
|
|
{
|
5576 |
|
|
CLASSTYPE_VISIBILITY_SPECIFIED (type) = 1;
|
5577 |
|
|
CLASSTYPE_VISIBILITY (type) = CLASSTYPE_VISIBILITY (pattern);
|
5578 |
|
|
}
|
5579 |
|
|
|
5580 |
|
|
pbinfo = TYPE_BINFO (pattern);
|
5581 |
|
|
|
5582 |
|
|
/* We should never instantiate a nested class before its enclosing
|
5583 |
|
|
class; we need to look up the nested class by name before we can
|
5584 |
|
|
instantiate it, and that lookup should instantiate the enclosing
|
5585 |
|
|
class. */
|
5586 |
|
|
gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern))
|
5587 |
|
|
|| COMPLETE_TYPE_P (TYPE_CONTEXT (type))
|
5588 |
|
|
|| TYPE_BEING_DEFINED (TYPE_CONTEXT (type)));
|
5589 |
|
|
|
5590 |
|
|
base_list = NULL_TREE;
|
5591 |
|
|
if (BINFO_N_BASE_BINFOS (pbinfo))
|
5592 |
|
|
{
|
5593 |
|
|
tree pbase_binfo;
|
5594 |
|
|
tree context = TYPE_CONTEXT (type);
|
5595 |
|
|
tree pushed_scope;
|
5596 |
|
|
int i;
|
5597 |
|
|
|
5598 |
|
|
/* We must enter the scope containing the type, as that is where
|
5599 |
|
|
the accessibility of types named in dependent bases are
|
5600 |
|
|
looked up from. */
|
5601 |
|
|
pushed_scope = push_scope (context ? context : global_namespace);
|
5602 |
|
|
|
5603 |
|
|
/* Substitute into each of the bases to determine the actual
|
5604 |
|
|
basetypes. */
|
5605 |
|
|
for (i = 0; BINFO_BASE_ITERATE (pbinfo, i, pbase_binfo); i++)
|
5606 |
|
|
{
|
5607 |
|
|
tree base;
|
5608 |
|
|
tree access = BINFO_BASE_ACCESS (pbinfo, i);
|
5609 |
|
|
|
5610 |
|
|
/* Substitute to figure out the base class. */
|
5611 |
|
|
base = tsubst (BINFO_TYPE (pbase_binfo), args, tf_error, NULL_TREE);
|
5612 |
|
|
if (base == error_mark_node)
|
5613 |
|
|
continue;
|
5614 |
|
|
|
5615 |
|
|
base_list = tree_cons (access, base, base_list);
|
5616 |
|
|
if (BINFO_VIRTUAL_P (pbase_binfo))
|
5617 |
|
|
TREE_TYPE (base_list) = integer_type_node;
|
5618 |
|
|
}
|
5619 |
|
|
|
5620 |
|
|
/* The list is now in reverse order; correct that. */
|
5621 |
|
|
base_list = nreverse (base_list);
|
5622 |
|
|
|
5623 |
|
|
if (pushed_scope)
|
5624 |
|
|
pop_scope (pushed_scope);
|
5625 |
|
|
}
|
5626 |
|
|
/* Now call xref_basetypes to set up all the base-class
|
5627 |
|
|
information. */
|
5628 |
|
|
xref_basetypes (type, base_list);
|
5629 |
|
|
|
5630 |
|
|
|
5631 |
|
|
/* Now that our base classes are set up, enter the scope of the
|
5632 |
|
|
class, so that name lookups into base classes, etc. will work
|
5633 |
|
|
correctly. This is precisely analogous to what we do in
|
5634 |
|
|
begin_class_definition when defining an ordinary non-template
|
5635 |
|
|
class. */
|
5636 |
|
|
pushclass (type);
|
5637 |
|
|
|
5638 |
|
|
/* Now members are processed in the order of declaration. */
|
5639 |
|
|
for (member = CLASSTYPE_DECL_LIST (pattern);
|
5640 |
|
|
member; member = TREE_CHAIN (member))
|
5641 |
|
|
{
|
5642 |
|
|
tree t = TREE_VALUE (member);
|
5643 |
|
|
|
5644 |
|
|
if (TREE_PURPOSE (member))
|
5645 |
|
|
{
|
5646 |
|
|
if (TYPE_P (t))
|
5647 |
|
|
{
|
5648 |
|
|
/* Build new CLASSTYPE_NESTED_UTDS. */
|
5649 |
|
|
|
5650 |
|
|
tree tag = t;
|
5651 |
|
|
tree name = TYPE_IDENTIFIER (tag);
|
5652 |
|
|
tree newtag;
|
5653 |
|
|
bool class_template_p;
|
5654 |
|
|
|
5655 |
|
|
class_template_p = (TREE_CODE (tag) != ENUMERAL_TYPE
|
5656 |
|
|
&& TYPE_LANG_SPECIFIC (tag)
|
5657 |
|
|
&& CLASSTYPE_IS_TEMPLATE (tag));
|
5658 |
|
|
/* If the member is a class template, then -- even after
|
5659 |
|
|
substitution -- there may be dependent types in the
|
5660 |
|
|
template argument list for the class. We increment
|
5661 |
|
|
PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
|
5662 |
|
|
that function will assume that no types are dependent
|
5663 |
|
|
when outside of a template. */
|
5664 |
|
|
if (class_template_p)
|
5665 |
|
|
++processing_template_decl;
|
5666 |
|
|
newtag = tsubst (tag, args, tf_error, NULL_TREE);
|
5667 |
|
|
if (class_template_p)
|
5668 |
|
|
--processing_template_decl;
|
5669 |
|
|
if (newtag == error_mark_node)
|
5670 |
|
|
continue;
|
5671 |
|
|
|
5672 |
|
|
if (TREE_CODE (newtag) != ENUMERAL_TYPE)
|
5673 |
|
|
{
|
5674 |
|
|
if (class_template_p)
|
5675 |
|
|
/* Unfortunately, lookup_template_class sets
|
5676 |
|
|
CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
|
5677 |
|
|
instantiation (i.e., for the type of a member
|
5678 |
|
|
template class nested within a template class.)
|
5679 |
|
|
This behavior is required for
|
5680 |
|
|
maybe_process_partial_specialization to work
|
5681 |
|
|
correctly, but is not accurate in this case;
|
5682 |
|
|
the TAG is not an instantiation of anything.
|
5683 |
|
|
(The corresponding TEMPLATE_DECL is an
|
5684 |
|
|
instantiation, but the TYPE is not.) */
|
5685 |
|
|
CLASSTYPE_USE_TEMPLATE (newtag) = 0;
|
5686 |
|
|
|
5687 |
|
|
/* Now, we call pushtag to put this NEWTAG into the scope of
|
5688 |
|
|
TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
|
5689 |
|
|
pushtag calling push_template_decl. We don't have to do
|
5690 |
|
|
this for enums because it will already have been done in
|
5691 |
|
|
tsubst_enum. */
|
5692 |
|
|
if (name)
|
5693 |
|
|
SET_IDENTIFIER_TYPE_VALUE (name, newtag);
|
5694 |
|
|
pushtag (name, newtag, /*tag_scope=*/ts_current);
|
5695 |
|
|
}
|
5696 |
|
|
}
|
5697 |
|
|
else if (TREE_CODE (t) == FUNCTION_DECL
|
5698 |
|
|
|| DECL_FUNCTION_TEMPLATE_P (t))
|
5699 |
|
|
{
|
5700 |
|
|
/* Build new TYPE_METHODS. */
|
5701 |
|
|
tree r;
|
5702 |
|
|
|
5703 |
|
|
if (TREE_CODE (t) == TEMPLATE_DECL)
|
5704 |
|
|
++processing_template_decl;
|
5705 |
|
|
r = tsubst (t, args, tf_error, NULL_TREE);
|
5706 |
|
|
if (TREE_CODE (t) == TEMPLATE_DECL)
|
5707 |
|
|
--processing_template_decl;
|
5708 |
|
|
set_current_access_from_decl (r);
|
5709 |
|
|
grok_special_member_properties (r);
|
5710 |
|
|
finish_member_declaration (r);
|
5711 |
|
|
}
|
5712 |
|
|
else
|
5713 |
|
|
{
|
5714 |
|
|
/* Build new TYPE_FIELDS. */
|
5715 |
|
|
|
5716 |
|
|
if (TREE_CODE (t) != CONST_DECL)
|
5717 |
|
|
{
|
5718 |
|
|
tree r;
|
5719 |
|
|
|
5720 |
|
|
/* The the file and line for this declaration, to
|
5721 |
|
|
assist in error message reporting. Since we
|
5722 |
|
|
called push_tinst_level above, we don't need to
|
5723 |
|
|
restore these. */
|
5724 |
|
|
input_location = DECL_SOURCE_LOCATION (t);
|
5725 |
|
|
|
5726 |
|
|
if (TREE_CODE (t) == TEMPLATE_DECL)
|
5727 |
|
|
++processing_template_decl;
|
5728 |
|
|
r = tsubst (t, args, tf_error | tf_warning, NULL_TREE);
|
5729 |
|
|
if (TREE_CODE (t) == TEMPLATE_DECL)
|
5730 |
|
|
--processing_template_decl;
|
5731 |
|
|
if (TREE_CODE (r) == VAR_DECL)
|
5732 |
|
|
{
|
5733 |
|
|
/* In [temp.inst]:
|
5734 |
|
|
|
5735 |
|
|
[t]he initialization (and any associated
|
5736 |
|
|
side-effects) of a static data member does
|
5737 |
|
|
not occur unless the static data member is
|
5738 |
|
|
itself used in a way that requires the
|
5739 |
|
|
definition of the static data member to
|
5740 |
|
|
exist.
|
5741 |
|
|
|
5742 |
|
|
Therefore, we do not substitute into the
|
5743 |
|
|
initialized for the static data member here. */
|
5744 |
|
|
finish_static_data_member_decl
|
5745 |
|
|
(r,
|
5746 |
|
|
/*init=*/NULL_TREE,
|
5747 |
|
|
/*init_const_expr_p=*/false,
|
5748 |
|
|
/*asmspec_tree=*/NULL_TREE,
|
5749 |
|
|
/*flags=*/0);
|
5750 |
|
|
if (DECL_INITIALIZED_IN_CLASS_P (r))
|
5751 |
|
|
check_static_variable_definition (r, TREE_TYPE (r));
|
5752 |
|
|
}
|
5753 |
|
|
else if (TREE_CODE (r) == FIELD_DECL)
|
5754 |
|
|
{
|
5755 |
|
|
/* Determine whether R has a valid type and can be
|
5756 |
|
|
completed later. If R is invalid, then it is
|
5757 |
|
|
replaced by error_mark_node so that it will not be
|
5758 |
|
|
added to TYPE_FIELDS. */
|
5759 |
|
|
tree rtype = TREE_TYPE (r);
|
5760 |
|
|
if (can_complete_type_without_circularity (rtype))
|
5761 |
|
|
complete_type (rtype);
|
5762 |
|
|
|
5763 |
|
|
if (!COMPLETE_TYPE_P (rtype))
|
5764 |
|
|
{
|
5765 |
|
|
cxx_incomplete_type_error (r, rtype);
|
5766 |
|
|
r = error_mark_node;
|
5767 |
|
|
}
|
5768 |
|
|
}
|
5769 |
|
|
|
5770 |
|
|
/* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
|
5771 |
|
|
such a thing will already have been added to the field
|
5772 |
|
|
list by tsubst_enum in finish_member_declaration in the
|
5773 |
|
|
CLASSTYPE_NESTED_UTDS case above. */
|
5774 |
|
|
if (!(TREE_CODE (r) == TYPE_DECL
|
5775 |
|
|
&& TREE_CODE (TREE_TYPE (r)) == ENUMERAL_TYPE
|
5776 |
|
|
&& DECL_ARTIFICIAL (r)))
|
5777 |
|
|
{
|
5778 |
|
|
set_current_access_from_decl (r);
|
5779 |
|
|
finish_member_declaration (r);
|
5780 |
|
|
}
|
5781 |
|
|
}
|
5782 |
|
|
}
|
5783 |
|
|
}
|
5784 |
|
|
else
|
5785 |
|
|
{
|
5786 |
|
|
if (TYPE_P (t) || DECL_CLASS_TEMPLATE_P (t))
|
5787 |
|
|
{
|
5788 |
|
|
/* Build new CLASSTYPE_FRIEND_CLASSES. */
|
5789 |
|
|
|
5790 |
|
|
tree friend_type = t;
|
5791 |
|
|
bool adjust_processing_template_decl = false;
|
5792 |
|
|
|
5793 |
|
|
if (TREE_CODE (friend_type) == TEMPLATE_DECL)
|
5794 |
|
|
{
|
5795 |
|
|
/* template <class T> friend class C; */
|
5796 |
|
|
friend_type = tsubst_friend_class (friend_type, args);
|
5797 |
|
|
adjust_processing_template_decl = true;
|
5798 |
|
|
}
|
5799 |
|
|
else if (TREE_CODE (friend_type) == UNBOUND_CLASS_TEMPLATE)
|
5800 |
|
|
{
|
5801 |
|
|
/* template <class T> friend class C::D; */
|
5802 |
|
|
friend_type = tsubst (friend_type, args,
|
5803 |
|
|
tf_error | tf_warning, NULL_TREE);
|
5804 |
|
|
if (TREE_CODE (friend_type) == TEMPLATE_DECL)
|
5805 |
|
|
friend_type = TREE_TYPE (friend_type);
|
5806 |
|
|
adjust_processing_template_decl = true;
|
5807 |
|
|
}
|
5808 |
|
|
else if (TREE_CODE (friend_type) == TYPENAME_TYPE)
|
5809 |
|
|
{
|
5810 |
|
|
/* This could be either
|
5811 |
|
|
|
5812 |
|
|
friend class T::C;
|
5813 |
|
|
|
5814 |
|
|
when dependent_type_p is false or
|
5815 |
|
|
|
5816 |
|
|
template <class U> friend class T::C;
|
5817 |
|
|
|
5818 |
|
|
otherwise. */
|
5819 |
|
|
friend_type = tsubst (friend_type, args,
|
5820 |
|
|
tf_error | tf_warning, NULL_TREE);
|
5821 |
|
|
/* Bump processing_template_decl for correct
|
5822 |
|
|
dependent_type_p calculation. */
|
5823 |
|
|
++processing_template_decl;
|
5824 |
|
|
if (dependent_type_p (friend_type))
|
5825 |
|
|
adjust_processing_template_decl = true;
|
5826 |
|
|
--processing_template_decl;
|
5827 |
|
|
}
|
5828 |
|
|
else if (!CLASSTYPE_USE_TEMPLATE (friend_type)
|
5829 |
|
|
&& hidden_name_p (TYPE_NAME (friend_type)))
|
5830 |
|
|
{
|
5831 |
|
|
/* friend class C;
|
5832 |
|
|
|
5833 |
|
|
where C hasn't been declared yet. Let's lookup name
|
5834 |
|
|
from namespace scope directly, bypassing any name that
|
5835 |
|
|
come from dependent base class. */
|
5836 |
|
|
tree ns = decl_namespace_context (TYPE_MAIN_DECL (friend_type));
|
5837 |
|
|
|
5838 |
|
|
/* The call to xref_tag_from_type does injection for friend
|
5839 |
|
|
classes. */
|
5840 |
|
|
push_nested_namespace (ns);
|
5841 |
|
|
friend_type =
|
5842 |
|
|
xref_tag_from_type (friend_type, NULL_TREE,
|
5843 |
|
|
/*tag_scope=*/ts_current);
|
5844 |
|
|
pop_nested_namespace (ns);
|
5845 |
|
|
}
|
5846 |
|
|
else if (uses_template_parms (friend_type))
|
5847 |
|
|
/* friend class C<T>; */
|
5848 |
|
|
friend_type = tsubst (friend_type, args,
|
5849 |
|
|
tf_error | tf_warning, NULL_TREE);
|
5850 |
|
|
/* Otherwise it's
|
5851 |
|
|
|
5852 |
|
|
friend class C;
|
5853 |
|
|
|
5854 |
|
|
where C is already declared or
|
5855 |
|
|
|
5856 |
|
|
friend class C<int>;
|
5857 |
|
|
|
5858 |
|
|
We don't have to do anything in these cases. */
|
5859 |
|
|
|
5860 |
|
|
if (adjust_processing_template_decl)
|
5861 |
|
|
/* Trick make_friend_class into realizing that the friend
|
5862 |
|
|
we're adding is a template, not an ordinary class. It's
|
5863 |
|
|
important that we use make_friend_class since it will
|
5864 |
|
|
perform some error-checking and output cross-reference
|
5865 |
|
|
information. */
|
5866 |
|
|
++processing_template_decl;
|
5867 |
|
|
|
5868 |
|
|
if (friend_type != error_mark_node)
|
5869 |
|
|
make_friend_class (type, friend_type, /*complain=*/false);
|
5870 |
|
|
|
5871 |
|
|
if (adjust_processing_template_decl)
|
5872 |
|
|
--processing_template_decl;
|
5873 |
|
|
}
|
5874 |
|
|
else
|
5875 |
|
|
{
|
5876 |
|
|
/* Build new DECL_FRIENDLIST. */
|
5877 |
|
|
tree r;
|
5878 |
|
|
|
5879 |
|
|
/* The the file and line for this declaration, to
|
5880 |
|
|
assist in error message reporting. Since we
|
5881 |
|
|
called push_tinst_level above, we don't need to
|
5882 |
|
|
restore these. */
|
5883 |
|
|
input_location = DECL_SOURCE_LOCATION (t);
|
5884 |
|
|
|
5885 |
|
|
if (TREE_CODE (t) == TEMPLATE_DECL)
|
5886 |
|
|
{
|
5887 |
|
|
++processing_template_decl;
|
5888 |
|
|
push_deferring_access_checks (dk_no_check);
|
5889 |
|
|
}
|
5890 |
|
|
|
5891 |
|
|
r = tsubst_friend_function (t, args);
|
5892 |
|
|
add_friend (type, r, /*complain=*/false);
|
5893 |
|
|
if (TREE_CODE (t) == TEMPLATE_DECL)
|
5894 |
|
|
{
|
5895 |
|
|
pop_deferring_access_checks ();
|
5896 |
|
|
--processing_template_decl;
|
5897 |
|
|
}
|
5898 |
|
|
}
|
5899 |
|
|
}
|
5900 |
|
|
}
|
5901 |
|
|
|
5902 |
|
|
/* Set the file and line number information to whatever is given for
|
5903 |
|
|
the class itself. This puts error messages involving generated
|
5904 |
|
|
implicit functions at a predictable point, and the same point
|
5905 |
|
|
that would be used for non-template classes. */
|
5906 |
|
|
input_location = DECL_SOURCE_LOCATION (typedecl);
|
5907 |
|
|
|
5908 |
|
|
unreverse_member_declarations (type);
|
5909 |
|
|
finish_struct_1 (type);
|
5910 |
|
|
TYPE_BEING_DEFINED (type) = 0;
|
5911 |
|
|
|
5912 |
|
|
/* Now that the class is complete, instantiate default arguments for
|
5913 |
|
|
any member functions. We don't do this earlier because the
|
5914 |
|
|
default arguments may reference members of the class. */
|
5915 |
|
|
if (!PRIMARY_TEMPLATE_P (template))
|
5916 |
|
|
for (t = TYPE_METHODS (type); t; t = TREE_CHAIN (t))
|
5917 |
|
|
if (TREE_CODE (t) == FUNCTION_DECL
|
5918 |
|
|
/* Implicitly generated member functions will not have template
|
5919 |
|
|
information; they are not instantiations, but instead are
|
5920 |
|
|
created "fresh" for each instantiation. */
|
5921 |
|
|
&& DECL_TEMPLATE_INFO (t))
|
5922 |
|
|
tsubst_default_arguments (t);
|
5923 |
|
|
|
5924 |
|
|
popclass ();
|
5925 |
|
|
pop_from_top_level ();
|
5926 |
|
|
pop_deferring_access_checks ();
|
5927 |
|
|
pop_tinst_level ();
|
5928 |
|
|
|
5929 |
|
|
/* The vtable for a template class can be emitted in any translation
|
5930 |
|
|
unit in which the class is instantiated. When there is no key
|
5931 |
|
|
method, however, finish_struct_1 will already have added TYPE to
|
5932 |
|
|
the keyed_classes list. */
|
5933 |
|
|
if (TYPE_CONTAINS_VPTR_P (type) && CLASSTYPE_KEY_METHOD (type))
|
5934 |
|
|
keyed_classes = tree_cons (NULL_TREE, type, keyed_classes);
|
5935 |
|
|
|
5936 |
|
|
return type;
|
5937 |
|
|
}
|
5938 |
|
|
|
5939 |
|
|
static tree
|
5940 |
|
|
tsubst_template_arg (tree t, tree args, tsubst_flags_t complain, tree in_decl)
|
5941 |
|
|
{
|
5942 |
|
|
tree r;
|
5943 |
|
|
|
5944 |
|
|
if (!t)
|
5945 |
|
|
r = t;
|
5946 |
|
|
else if (TYPE_P (t))
|
5947 |
|
|
r = tsubst (t, args, complain, in_decl);
|
5948 |
|
|
else
|
5949 |
|
|
{
|
5950 |
|
|
r = tsubst_expr (t, args, complain, in_decl);
|
5951 |
|
|
r = fold_non_dependent_expr (r);
|
5952 |
|
|
}
|
5953 |
|
|
return r;
|
5954 |
|
|
}
|
5955 |
|
|
|
5956 |
|
|
/* Substitute ARGS into the vector or list of template arguments T. */
|
5957 |
|
|
|
5958 |
|
|
static tree
|
5959 |
|
|
tsubst_template_args (tree t, tree args, tsubst_flags_t complain, tree in_decl)
|
5960 |
|
|
{
|
5961 |
|
|
int len = TREE_VEC_LENGTH (t);
|
5962 |
|
|
int need_new = 0, i;
|
5963 |
|
|
tree *elts = alloca (len * sizeof (tree));
|
5964 |
|
|
|
5965 |
|
|
for (i = 0; i < len; i++)
|
5966 |
|
|
{
|
5967 |
|
|
tree orig_arg = TREE_VEC_ELT (t, i);
|
5968 |
|
|
tree new_arg;
|
5969 |
|
|
|
5970 |
|
|
if (TREE_CODE (orig_arg) == TREE_VEC)
|
5971 |
|
|
new_arg = tsubst_template_args (orig_arg, args, complain, in_decl);
|
5972 |
|
|
else
|
5973 |
|
|
new_arg = tsubst_template_arg (orig_arg, args, complain, in_decl);
|
5974 |
|
|
|
5975 |
|
|
if (new_arg == error_mark_node)
|
5976 |
|
|
return error_mark_node;
|
5977 |
|
|
|
5978 |
|
|
elts[i] = new_arg;
|
5979 |
|
|
if (new_arg != orig_arg)
|
5980 |
|
|
need_new = 1;
|
5981 |
|
|
}
|
5982 |
|
|
|
5983 |
|
|
if (!need_new)
|
5984 |
|
|
return t;
|
5985 |
|
|
|
5986 |
|
|
t = make_tree_vec (len);
|
5987 |
|
|
for (i = 0; i < len; i++)
|
5988 |
|
|
TREE_VEC_ELT (t, i) = elts[i];
|
5989 |
|
|
|
5990 |
|
|
return t;
|
5991 |
|
|
}
|
5992 |
|
|
|
5993 |
|
|
/* Return the result of substituting ARGS into the template parameters
|
5994 |
|
|
given by PARMS. If there are m levels of ARGS and m + n levels of
|
5995 |
|
|
PARMS, then the result will contain n levels of PARMS. For
|
5996 |
|
|
example, if PARMS is `template <class T> template <class U>
|
5997 |
|
|
template <T*, U, class V>' and ARGS is {{int}, {double}} then the
|
5998 |
|
|
result will be `template <int*, double, class V>'. */
|
5999 |
|
|
|
6000 |
|
|
static tree
|
6001 |
|
|
tsubst_template_parms (tree parms, tree args, tsubst_flags_t complain)
|
6002 |
|
|
{
|
6003 |
|
|
tree r = NULL_TREE;
|
6004 |
|
|
tree* new_parms;
|
6005 |
|
|
|
6006 |
|
|
/* When substituting into a template, we must set
|
6007 |
|
|
PROCESSING_TEMPLATE_DECL as the template parameters may be
|
6008 |
|
|
dependent if they are based on one-another, and the dependency
|
6009 |
|
|
predicates are short-circuit outside of templates. */
|
6010 |
|
|
++processing_template_decl;
|
6011 |
|
|
|
6012 |
|
|
for (new_parms = &r;
|
6013 |
|
|
TMPL_PARMS_DEPTH (parms) > TMPL_ARGS_DEPTH (args);
|
6014 |
|
|
new_parms = &(TREE_CHAIN (*new_parms)),
|
6015 |
|
|
parms = TREE_CHAIN (parms))
|
6016 |
|
|
{
|
6017 |
|
|
tree new_vec =
|
6018 |
|
|
make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms)));
|
6019 |
|
|
int i;
|
6020 |
|
|
|
6021 |
|
|
for (i = 0; i < TREE_VEC_LENGTH (new_vec); ++i)
|
6022 |
|
|
{
|
6023 |
|
|
tree tuple = TREE_VEC_ELT (TREE_VALUE (parms), i);
|
6024 |
|
|
tree default_value = TREE_PURPOSE (tuple);
|
6025 |
|
|
tree parm_decl = TREE_VALUE (tuple);
|
6026 |
|
|
|
6027 |
|
|
parm_decl = tsubst (parm_decl, args, complain, NULL_TREE);
|
6028 |
|
|
if (TREE_CODE (parm_decl) == PARM_DECL
|
6029 |
|
|
&& invalid_nontype_parm_type_p (TREE_TYPE (parm_decl), complain))
|
6030 |
|
|
parm_decl = error_mark_node;
|
6031 |
|
|
default_value = tsubst_template_arg (default_value, args,
|
6032 |
|
|
complain, NULL_TREE);
|
6033 |
|
|
|
6034 |
|
|
tuple = build_tree_list (default_value, parm_decl);
|
6035 |
|
|
TREE_VEC_ELT (new_vec, i) = tuple;
|
6036 |
|
|
}
|
6037 |
|
|
|
6038 |
|
|
*new_parms =
|
6039 |
|
|
tree_cons (size_int (TMPL_PARMS_DEPTH (parms)
|
6040 |
|
|
- TMPL_ARGS_DEPTH (args)),
|
6041 |
|
|
new_vec, NULL_TREE);
|
6042 |
|
|
}
|
6043 |
|
|
|
6044 |
|
|
--processing_template_decl;
|
6045 |
|
|
|
6046 |
|
|
return r;
|
6047 |
|
|
}
|
6048 |
|
|
|
6049 |
|
|
/* Substitute the ARGS into the indicated aggregate (or enumeration)
|
6050 |
|
|
type T. If T is not an aggregate or enumeration type, it is
|
6051 |
|
|
handled as if by tsubst. IN_DECL is as for tsubst. If
|
6052 |
|
|
ENTERING_SCOPE is nonzero, T is the context for a template which
|
6053 |
|
|
we are presently tsubst'ing. Return the substituted value. */
|
6054 |
|
|
|
6055 |
|
|
static tree
|
6056 |
|
|
tsubst_aggr_type (tree t,
|
6057 |
|
|
tree args,
|
6058 |
|
|
tsubst_flags_t complain,
|
6059 |
|
|
tree in_decl,
|
6060 |
|
|
int entering_scope)
|
6061 |
|
|
{
|
6062 |
|
|
if (t == NULL_TREE)
|
6063 |
|
|
return NULL_TREE;
|
6064 |
|
|
|
6065 |
|
|
switch (TREE_CODE (t))
|
6066 |
|
|
{
|
6067 |
|
|
case RECORD_TYPE:
|
6068 |
|
|
if (TYPE_PTRMEMFUNC_P (t))
|
6069 |
|
|
return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t), args, complain, in_decl);
|
6070 |
|
|
|
6071 |
|
|
/* Else fall through. */
|
6072 |
|
|
case ENUMERAL_TYPE:
|
6073 |
|
|
case UNION_TYPE:
|
6074 |
|
|
if (TYPE_TEMPLATE_INFO (t))
|
6075 |
|
|
{
|
6076 |
|
|
tree argvec;
|
6077 |
|
|
tree context;
|
6078 |
|
|
tree r;
|
6079 |
|
|
bool saved_skip_evaluation;
|
6080 |
|
|
|
6081 |
|
|
/* In "sizeof(X<I>)" we need to evaluate "I". */
|
6082 |
|
|
saved_skip_evaluation = skip_evaluation;
|
6083 |
|
|
skip_evaluation = false;
|
6084 |
|
|
|
6085 |
|
|
/* First, determine the context for the type we are looking
|
6086 |
|
|
up. */
|
6087 |
|
|
context = TYPE_CONTEXT (t);
|
6088 |
|
|
if (context)
|
6089 |
|
|
context = tsubst_aggr_type (context, args, complain,
|
6090 |
|
|
in_decl, /*entering_scope=*/1);
|
6091 |
|
|
|
6092 |
|
|
/* Then, figure out what arguments are appropriate for the
|
6093 |
|
|
type we are trying to find. For example, given:
|
6094 |
|
|
|
6095 |
|
|
template <class T> struct S;
|
6096 |
|
|
template <class T, class U> void f(T, U) { S<U> su; }
|
6097 |
|
|
|
6098 |
|
|
and supposing that we are instantiating f<int, double>,
|
6099 |
|
|
then our ARGS will be {int, double}, but, when looking up
|
6100 |
|
|
S we only want {double}. */
|
6101 |
|
|
argvec = tsubst_template_args (TYPE_TI_ARGS (t), args,
|
6102 |
|
|
complain, in_decl);
|
6103 |
|
|
if (argvec == error_mark_node)
|
6104 |
|
|
r = error_mark_node;
|
6105 |
|
|
else
|
6106 |
|
|
{
|
6107 |
|
|
r = lookup_template_class (t, argvec, in_decl, context,
|
6108 |
|
|
entering_scope, complain);
|
6109 |
|
|
r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
|
6110 |
|
|
}
|
6111 |
|
|
|
6112 |
|
|
skip_evaluation = saved_skip_evaluation;
|
6113 |
|
|
|
6114 |
|
|
return r;
|
6115 |
|
|
}
|
6116 |
|
|
else
|
6117 |
|
|
/* This is not a template type, so there's nothing to do. */
|
6118 |
|
|
return t;
|
6119 |
|
|
|
6120 |
|
|
default:
|
6121 |
|
|
return tsubst (t, args, complain, in_decl);
|
6122 |
|
|
}
|
6123 |
|
|
}
|
6124 |
|
|
|
6125 |
|
|
/* Substitute into the default argument ARG (a default argument for
|
6126 |
|
|
FN), which has the indicated TYPE. */
|
6127 |
|
|
|
6128 |
|
|
tree
|
6129 |
|
|
tsubst_default_argument (tree fn, tree type, tree arg)
|
6130 |
|
|
{
|
6131 |
|
|
tree saved_class_ptr = NULL_TREE;
|
6132 |
|
|
tree saved_class_ref = NULL_TREE;
|
6133 |
|
|
|
6134 |
|
|
/* This default argument came from a template. Instantiate the
|
6135 |
|
|
default argument here, not in tsubst. In the case of
|
6136 |
|
|
something like:
|
6137 |
|
|
|
6138 |
|
|
template <class T>
|
6139 |
|
|
struct S {
|
6140 |
|
|
static T t();
|
6141 |
|
|
void f(T = t());
|
6142 |
|
|
};
|
6143 |
|
|
|
6144 |
|
|
we must be careful to do name lookup in the scope of S<T>,
|
6145 |
|
|
rather than in the current class. */
|
6146 |
|
|
push_access_scope (fn);
|
6147 |
|
|
/* The "this" pointer is not valid in a default argument. */
|
6148 |
|
|
if (cfun)
|
6149 |
|
|
{
|
6150 |
|
|
saved_class_ptr = current_class_ptr;
|
6151 |
|
|
cp_function_chain->x_current_class_ptr = NULL_TREE;
|
6152 |
|
|
saved_class_ref = current_class_ref;
|
6153 |
|
|
cp_function_chain->x_current_class_ref = NULL_TREE;
|
6154 |
|
|
}
|
6155 |
|
|
|
6156 |
|
|
push_deferring_access_checks(dk_no_deferred);
|
6157 |
|
|
/* The default argument expression may cause implicitly defined
|
6158 |
|
|
member functions to be synthesized, which will result in garbage
|
6159 |
|
|
collection. We must treat this situation as if we were within
|
6160 |
|
|
the body of function so as to avoid collecting live data on the
|
6161 |
|
|
stack. */
|
6162 |
|
|
++function_depth;
|
6163 |
|
|
arg = tsubst_expr (arg, DECL_TI_ARGS (fn),
|
6164 |
|
|
tf_error | tf_warning, NULL_TREE);
|
6165 |
|
|
--function_depth;
|
6166 |
|
|
pop_deferring_access_checks();
|
6167 |
|
|
|
6168 |
|
|
/* Restore the "this" pointer. */
|
6169 |
|
|
if (cfun)
|
6170 |
|
|
{
|
6171 |
|
|
cp_function_chain->x_current_class_ptr = saved_class_ptr;
|
6172 |
|
|
cp_function_chain->x_current_class_ref = saved_class_ref;
|
6173 |
|
|
}
|
6174 |
|
|
|
6175 |
|
|
pop_access_scope (fn);
|
6176 |
|
|
|
6177 |
|
|
/* Make sure the default argument is reasonable. */
|
6178 |
|
|
arg = check_default_argument (type, arg);
|
6179 |
|
|
|
6180 |
|
|
return arg;
|
6181 |
|
|
}
|
6182 |
|
|
|
6183 |
|
|
/* Substitute into all the default arguments for FN. */
|
6184 |
|
|
|
6185 |
|
|
static void
|
6186 |
|
|
tsubst_default_arguments (tree fn)
|
6187 |
|
|
{
|
6188 |
|
|
tree arg;
|
6189 |
|
|
tree tmpl_args;
|
6190 |
|
|
|
6191 |
|
|
tmpl_args = DECL_TI_ARGS (fn);
|
6192 |
|
|
|
6193 |
|
|
/* If this function is not yet instantiated, we certainly don't need
|
6194 |
|
|
its default arguments. */
|
6195 |
|
|
if (uses_template_parms (tmpl_args))
|
6196 |
|
|
return;
|
6197 |
|
|
|
6198 |
|
|
for (arg = TYPE_ARG_TYPES (TREE_TYPE (fn));
|
6199 |
|
|
arg;
|
6200 |
|
|
arg = TREE_CHAIN (arg))
|
6201 |
|
|
if (TREE_PURPOSE (arg))
|
6202 |
|
|
TREE_PURPOSE (arg) = tsubst_default_argument (fn,
|
6203 |
|
|
TREE_VALUE (arg),
|
6204 |
|
|
TREE_PURPOSE (arg));
|
6205 |
|
|
}
|
6206 |
|
|
|
6207 |
|
|
/* Substitute the ARGS into the T, which is a _DECL. Return the
|
6208 |
|
|
result of the substitution. Issue error and warning messages under
|
6209 |
|
|
control of COMPLAIN. */
|
6210 |
|
|
|
6211 |
|
|
static tree
|
6212 |
|
|
tsubst_decl (tree t, tree args, tsubst_flags_t complain)
|
6213 |
|
|
{
|
6214 |
|
|
location_t saved_loc;
|
6215 |
|
|
tree r = NULL_TREE;
|
6216 |
|
|
tree in_decl = t;
|
6217 |
|
|
|
6218 |
|
|
/* Set the filename and linenumber to improve error-reporting. */
|
6219 |
|
|
saved_loc = input_location;
|
6220 |
|
|
input_location = DECL_SOURCE_LOCATION (t);
|
6221 |
|
|
|
6222 |
|
|
switch (TREE_CODE (t))
|
6223 |
|
|
{
|
6224 |
|
|
case TEMPLATE_DECL:
|
6225 |
|
|
{
|
6226 |
|
|
/* We can get here when processing a member function template,
|
6227 |
|
|
member class template, and template template parameter of
|
6228 |
|
|
a template class. */
|
6229 |
|
|
tree decl = DECL_TEMPLATE_RESULT (t);
|
6230 |
|
|
tree spec;
|
6231 |
|
|
tree tmpl_args;
|
6232 |
|
|
tree full_args;
|
6233 |
|
|
|
6234 |
|
|
if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
|
6235 |
|
|
{
|
6236 |
|
|
/* Template template parameter is treated here. */
|
6237 |
|
|
tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
|
6238 |
|
|
if (new_type == error_mark_node)
|
6239 |
|
|
return error_mark_node;
|
6240 |
|
|
|
6241 |
|
|
r = copy_decl (t);
|
6242 |
|
|
TREE_CHAIN (r) = NULL_TREE;
|
6243 |
|
|
TREE_TYPE (r) = new_type;
|
6244 |
|
|
DECL_TEMPLATE_RESULT (r)
|
6245 |
|
|
= build_decl (TYPE_DECL, DECL_NAME (decl), new_type);
|
6246 |
|
|
DECL_TEMPLATE_PARMS (r)
|
6247 |
|
|
= tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
|
6248 |
|
|
complain);
|
6249 |
|
|
TYPE_NAME (new_type) = r;
|
6250 |
|
|
break;
|
6251 |
|
|
}
|
6252 |
|
|
|
6253 |
|
|
/* We might already have an instance of this template.
|
6254 |
|
|
The ARGS are for the surrounding class type, so the
|
6255 |
|
|
full args contain the tsubst'd args for the context,
|
6256 |
|
|
plus the innermost args from the template decl. */
|
6257 |
|
|
tmpl_args = DECL_CLASS_TEMPLATE_P (t)
|
6258 |
|
|
? CLASSTYPE_TI_ARGS (TREE_TYPE (t))
|
6259 |
|
|
: DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t));
|
6260 |
|
|
/* Because this is a template, the arguments will still be
|
6261 |
|
|
dependent, even after substitution. If
|
6262 |
|
|
PROCESSING_TEMPLATE_DECL is not set, the dependency
|
6263 |
|
|
predicates will short-circuit. */
|
6264 |
|
|
++processing_template_decl;
|
6265 |
|
|
full_args = tsubst_template_args (tmpl_args, args,
|
6266 |
|
|
complain, in_decl);
|
6267 |
|
|
--processing_template_decl;
|
6268 |
|
|
if (full_args == error_mark_node)
|
6269 |
|
|
return error_mark_node;
|
6270 |
|
|
|
6271 |
|
|
/* tsubst_template_args doesn't copy the vector if
|
6272 |
|
|
nothing changed. But, *something* should have
|
6273 |
|
|
changed. */
|
6274 |
|
|
gcc_assert (full_args != tmpl_args);
|
6275 |
|
|
|
6276 |
|
|
spec = retrieve_specialization (t, full_args,
|
6277 |
|
|
/*class_specializations_p=*/true);
|
6278 |
|
|
if (spec != NULL_TREE)
|
6279 |
|
|
{
|
6280 |
|
|
r = spec;
|
6281 |
|
|
break;
|
6282 |
|
|
}
|
6283 |
|
|
|
6284 |
|
|
/* Make a new template decl. It will be similar to the
|
6285 |
|
|
original, but will record the current template arguments.
|
6286 |
|
|
We also create a new function declaration, which is just
|
6287 |
|
|
like the old one, but points to this new template, rather
|
6288 |
|
|
than the old one. */
|
6289 |
|
|
r = copy_decl (t);
|
6290 |
|
|
gcc_assert (DECL_LANG_SPECIFIC (r) != 0);
|
6291 |
|
|
TREE_CHAIN (r) = NULL_TREE;
|
6292 |
|
|
|
6293 |
|
|
DECL_TEMPLATE_INFO (r) = build_tree_list (t, args);
|
6294 |
|
|
|
6295 |
|
|
if (TREE_CODE (decl) == TYPE_DECL)
|
6296 |
|
|
{
|
6297 |
|
|
tree new_type;
|
6298 |
|
|
++processing_template_decl;
|
6299 |
|
|
new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
|
6300 |
|
|
--processing_template_decl;
|
6301 |
|
|
if (new_type == error_mark_node)
|
6302 |
|
|
return error_mark_node;
|
6303 |
|
|
|
6304 |
|
|
TREE_TYPE (r) = new_type;
|
6305 |
|
|
CLASSTYPE_TI_TEMPLATE (new_type) = r;
|
6306 |
|
|
DECL_TEMPLATE_RESULT (r) = TYPE_MAIN_DECL (new_type);
|
6307 |
|
|
DECL_TI_ARGS (r) = CLASSTYPE_TI_ARGS (new_type);
|
6308 |
|
|
DECL_CONTEXT (r) = TYPE_CONTEXT (new_type);
|
6309 |
|
|
}
|
6310 |
|
|
else
|
6311 |
|
|
{
|
6312 |
|
|
tree new_decl;
|
6313 |
|
|
++processing_template_decl;
|
6314 |
|
|
new_decl = tsubst (decl, args, complain, in_decl);
|
6315 |
|
|
--processing_template_decl;
|
6316 |
|
|
if (new_decl == error_mark_node)
|
6317 |
|
|
return error_mark_node;
|
6318 |
|
|
|
6319 |
|
|
DECL_TEMPLATE_RESULT (r) = new_decl;
|
6320 |
|
|
DECL_TI_TEMPLATE (new_decl) = r;
|
6321 |
|
|
TREE_TYPE (r) = TREE_TYPE (new_decl);
|
6322 |
|
|
DECL_TI_ARGS (r) = DECL_TI_ARGS (new_decl);
|
6323 |
|
|
DECL_CONTEXT (r) = DECL_CONTEXT (new_decl);
|
6324 |
|
|
}
|
6325 |
|
|
|
6326 |
|
|
SET_DECL_IMPLICIT_INSTANTIATION (r);
|
6327 |
|
|
DECL_TEMPLATE_INSTANTIATIONS (r) = NULL_TREE;
|
6328 |
|
|
DECL_TEMPLATE_SPECIALIZATIONS (r) = NULL_TREE;
|
6329 |
|
|
|
6330 |
|
|
/* The template parameters for this new template are all the
|
6331 |
|
|
template parameters for the old template, except the
|
6332 |
|
|
outermost level of parameters. */
|
6333 |
|
|
DECL_TEMPLATE_PARMS (r)
|
6334 |
|
|
= tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
|
6335 |
|
|
complain);
|
6336 |
|
|
|
6337 |
|
|
if (PRIMARY_TEMPLATE_P (t))
|
6338 |
|
|
DECL_PRIMARY_TEMPLATE (r) = r;
|
6339 |
|
|
|
6340 |
|
|
if (TREE_CODE (decl) != TYPE_DECL)
|
6341 |
|
|
/* Record this non-type partial instantiation. */
|
6342 |
|
|
register_specialization (r, t,
|
6343 |
|
|
DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r)),
|
6344 |
|
|
false);
|
6345 |
|
|
}
|
6346 |
|
|
break;
|
6347 |
|
|
|
6348 |
|
|
case FUNCTION_DECL:
|
6349 |
|
|
{
|
6350 |
|
|
tree ctx;
|
6351 |
|
|
tree argvec = NULL_TREE;
|
6352 |
|
|
tree *friends;
|
6353 |
|
|
tree gen_tmpl;
|
6354 |
|
|
tree type;
|
6355 |
|
|
int member;
|
6356 |
|
|
int args_depth;
|
6357 |
|
|
int parms_depth;
|
6358 |
|
|
|
6359 |
|
|
/* Nobody should be tsubst'ing into non-template functions. */
|
6360 |
|
|
gcc_assert (DECL_TEMPLATE_INFO (t) != NULL_TREE);
|
6361 |
|
|
|
6362 |
|
|
if (TREE_CODE (DECL_TI_TEMPLATE (t)) == TEMPLATE_DECL)
|
6363 |
|
|
{
|
6364 |
|
|
tree spec;
|
6365 |
|
|
bool dependent_p;
|
6366 |
|
|
|
6367 |
|
|
/* If T is not dependent, just return it. We have to
|
6368 |
|
|
increment PROCESSING_TEMPLATE_DECL because
|
6369 |
|
|
value_dependent_expression_p assumes that nothing is
|
6370 |
|
|
dependent when PROCESSING_TEMPLATE_DECL is zero. */
|
6371 |
|
|
++processing_template_decl;
|
6372 |
|
|
dependent_p = value_dependent_expression_p (t);
|
6373 |
|
|
--processing_template_decl;
|
6374 |
|
|
if (!dependent_p)
|
6375 |
|
|
return t;
|
6376 |
|
|
|
6377 |
|
|
/* Calculate the most general template of which R is a
|
6378 |
|
|
specialization, and the complete set of arguments used to
|
6379 |
|
|
specialize R. */
|
6380 |
|
|
gen_tmpl = most_general_template (DECL_TI_TEMPLATE (t));
|
6381 |
|
|
argvec = tsubst_template_args (DECL_TI_ARGS
|
6382 |
|
|
(DECL_TEMPLATE_RESULT (gen_tmpl)),
|
6383 |
|
|
args, complain, in_decl);
|
6384 |
|
|
|
6385 |
|
|
/* Check to see if we already have this specialization. */
|
6386 |
|
|
spec = retrieve_specialization (gen_tmpl, argvec,
|
6387 |
|
|
/*class_specializations_p=*/false);
|
6388 |
|
|
|
6389 |
|
|
if (spec)
|
6390 |
|
|
{
|
6391 |
|
|
r = spec;
|
6392 |
|
|
break;
|
6393 |
|
|
}
|
6394 |
|
|
|
6395 |
|
|
/* We can see more levels of arguments than parameters if
|
6396 |
|
|
there was a specialization of a member template, like
|
6397 |
|
|
this:
|
6398 |
|
|
|
6399 |
|
|
template <class T> struct S { template <class U> void f(); }
|
6400 |
|
|
template <> template <class U> void S<int>::f(U);
|
6401 |
|
|
|
6402 |
|
|
Here, we'll be substituting into the specialization,
|
6403 |
|
|
because that's where we can find the code we actually
|
6404 |
|
|
want to generate, but we'll have enough arguments for
|
6405 |
|
|
the most general template.
|
6406 |
|
|
|
6407 |
|
|
We also deal with the peculiar case:
|
6408 |
|
|
|
6409 |
|
|
template <class T> struct S {
|
6410 |
|
|
template <class U> friend void f();
|
6411 |
|
|
};
|
6412 |
|
|
template <class U> void f() {}
|
6413 |
|
|
template S<int>;
|
6414 |
|
|
template void f<double>();
|
6415 |
|
|
|
6416 |
|
|
Here, the ARGS for the instantiation of will be {int,
|
6417 |
|
|
double}. But, we only need as many ARGS as there are
|
6418 |
|
|
levels of template parameters in CODE_PATTERN. We are
|
6419 |
|
|
careful not to get fooled into reducing the ARGS in
|
6420 |
|
|
situations like:
|
6421 |
|
|
|
6422 |
|
|
template <class T> struct S { template <class U> void f(U); }
|
6423 |
|
|
template <class T> template <> void S<T>::f(int) {}
|
6424 |
|
|
|
6425 |
|
|
which we can spot because the pattern will be a
|
6426 |
|
|
specialization in this case. */
|
6427 |
|
|
args_depth = TMPL_ARGS_DEPTH (args);
|
6428 |
|
|
parms_depth =
|
6429 |
|
|
TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t)));
|
6430 |
|
|
if (args_depth > parms_depth
|
6431 |
|
|
&& !DECL_TEMPLATE_SPECIALIZATION (t))
|
6432 |
|
|
args = get_innermost_template_args (args, parms_depth);
|
6433 |
|
|
}
|
6434 |
|
|
else
|
6435 |
|
|
{
|
6436 |
|
|
/* This special case arises when we have something like this:
|
6437 |
|
|
|
6438 |
|
|
template <class T> struct S {
|
6439 |
|
|
friend void f<int>(int, double);
|
6440 |
|
|
};
|
6441 |
|
|
|
6442 |
|
|
Here, the DECL_TI_TEMPLATE for the friend declaration
|
6443 |
|
|
will be an IDENTIFIER_NODE. We are being called from
|
6444 |
|
|
tsubst_friend_function, and we want only to create a
|
6445 |
|
|
new decl (R) with appropriate types so that we can call
|
6446 |
|
|
determine_specialization. */
|
6447 |
|
|
gen_tmpl = NULL_TREE;
|
6448 |
|
|
}
|
6449 |
|
|
|
6450 |
|
|
if (DECL_CLASS_SCOPE_P (t))
|
6451 |
|
|
{
|
6452 |
|
|
if (DECL_NAME (t) == constructor_name (DECL_CONTEXT (t)))
|
6453 |
|
|
member = 2;
|
6454 |
|
|
else
|
6455 |
|
|
member = 1;
|
6456 |
|
|
ctx = tsubst_aggr_type (DECL_CONTEXT (t), args,
|
6457 |
|
|
complain, t, /*entering_scope=*/1);
|
6458 |
|
|
}
|
6459 |
|
|
else
|
6460 |
|
|
{
|
6461 |
|
|
member = 0;
|
6462 |
|
|
ctx = DECL_CONTEXT (t);
|
6463 |
|
|
}
|
6464 |
|
|
type = tsubst (TREE_TYPE (t), args, complain, in_decl);
|
6465 |
|
|
if (type == error_mark_node)
|
6466 |
|
|
return error_mark_node;
|
6467 |
|
|
|
6468 |
|
|
/* We do NOT check for matching decls pushed separately at this
|
6469 |
|
|
point, as they may not represent instantiations of this
|
6470 |
|
|
template, and in any case are considered separate under the
|
6471 |
|
|
discrete model. */
|
6472 |
|
|
r = copy_decl (t);
|
6473 |
|
|
DECL_USE_TEMPLATE (r) = 0;
|
6474 |
|
|
TREE_TYPE (r) = type;
|
6475 |
|
|
/* Clear out the mangled name and RTL for the instantiation. */
|
6476 |
|
|
SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
|
6477 |
|
|
SET_DECL_RTL (r, NULL_RTX);
|
6478 |
|
|
DECL_INITIAL (r) = NULL_TREE;
|
6479 |
|
|
DECL_CONTEXT (r) = ctx;
|
6480 |
|
|
|
6481 |
|
|
if (member && DECL_CONV_FN_P (r))
|
6482 |
|
|
/* Type-conversion operator. Reconstruct the name, in
|
6483 |
|
|
case it's the name of one of the template's parameters. */
|
6484 |
|
|
DECL_NAME (r) = mangle_conv_op_name_for_type (TREE_TYPE (type));
|
6485 |
|
|
|
6486 |
|
|
DECL_ARGUMENTS (r) = tsubst (DECL_ARGUMENTS (t), args,
|
6487 |
|
|
complain, t);
|
6488 |
|
|
DECL_RESULT (r) = NULL_TREE;
|
6489 |
|
|
|
6490 |
|
|
TREE_STATIC (r) = 0;
|
6491 |
|
|
TREE_PUBLIC (r) = TREE_PUBLIC (t);
|
6492 |
|
|
DECL_EXTERNAL (r) = 1;
|
6493 |
|
|
/* If this is an instantiation of a function with internal
|
6494 |
|
|
linkage, we already know what object file linkage will be
|
6495 |
|
|
assigned to the instantiation. */
|
6496 |
|
|
DECL_INTERFACE_KNOWN (r) = !TREE_PUBLIC (r);
|
6497 |
|
|
DECL_DEFER_OUTPUT (r) = 0;
|
6498 |
|
|
TREE_CHAIN (r) = NULL_TREE;
|
6499 |
|
|
DECL_PENDING_INLINE_INFO (r) = 0;
|
6500 |
|
|
DECL_PENDING_INLINE_P (r) = 0;
|
6501 |
|
|
DECL_SAVED_TREE (r) = NULL_TREE;
|
6502 |
|
|
TREE_USED (r) = 0;
|
6503 |
|
|
if (DECL_CLONED_FUNCTION (r))
|
6504 |
|
|
{
|
6505 |
|
|
DECL_CLONED_FUNCTION (r) = tsubst (DECL_CLONED_FUNCTION (t),
|
6506 |
|
|
args, complain, t);
|
6507 |
|
|
TREE_CHAIN (r) = TREE_CHAIN (DECL_CLONED_FUNCTION (r));
|
6508 |
|
|
TREE_CHAIN (DECL_CLONED_FUNCTION (r)) = r;
|
6509 |
|
|
}
|
6510 |
|
|
|
6511 |
|
|
/* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
|
6512 |
|
|
this in the special friend case mentioned above where
|
6513 |
|
|
GEN_TMPL is NULL. */
|
6514 |
|
|
if (gen_tmpl)
|
6515 |
|
|
{
|
6516 |
|
|
DECL_TEMPLATE_INFO (r)
|
6517 |
|
|
= tree_cons (gen_tmpl, argvec, NULL_TREE);
|
6518 |
|
|
SET_DECL_IMPLICIT_INSTANTIATION (r);
|
6519 |
|
|
register_specialization (r, gen_tmpl, argvec, false);
|
6520 |
|
|
|
6521 |
|
|
/* We're not supposed to instantiate default arguments
|
6522 |
|
|
until they are called, for a template. But, for a
|
6523 |
|
|
declaration like:
|
6524 |
|
|
|
6525 |
|
|
template <class T> void f ()
|
6526 |
|
|
{ extern void g(int i = T()); }
|
6527 |
|
|
|
6528 |
|
|
we should do the substitution when the template is
|
6529 |
|
|
instantiated. We handle the member function case in
|
6530 |
|
|
instantiate_class_template since the default arguments
|
6531 |
|
|
might refer to other members of the class. */
|
6532 |
|
|
if (!member
|
6533 |
|
|
&& !PRIMARY_TEMPLATE_P (gen_tmpl)
|
6534 |
|
|
&& !uses_template_parms (argvec))
|
6535 |
|
|
tsubst_default_arguments (r);
|
6536 |
|
|
}
|
6537 |
|
|
else
|
6538 |
|
|
DECL_TEMPLATE_INFO (r) = NULL_TREE;
|
6539 |
|
|
|
6540 |
|
|
/* Copy the list of befriending classes. */
|
6541 |
|
|
for (friends = &DECL_BEFRIENDING_CLASSES (r);
|
6542 |
|
|
*friends;
|
6543 |
|
|
friends = &TREE_CHAIN (*friends))
|
6544 |
|
|
{
|
6545 |
|
|
*friends = copy_node (*friends);
|
6546 |
|
|
TREE_VALUE (*friends) = tsubst (TREE_VALUE (*friends),
|
6547 |
|
|
args, complain,
|
6548 |
|
|
in_decl);
|
6549 |
|
|
}
|
6550 |
|
|
|
6551 |
|
|
if (DECL_CONSTRUCTOR_P (r) || DECL_DESTRUCTOR_P (r))
|
6552 |
|
|
{
|
6553 |
|
|
maybe_retrofit_in_chrg (r);
|
6554 |
|
|
if (DECL_CONSTRUCTOR_P (r))
|
6555 |
|
|
grok_ctor_properties (ctx, r);
|
6556 |
|
|
/* If this is an instantiation of a member template, clone it.
|
6557 |
|
|
If it isn't, that'll be handled by
|
6558 |
|
|
clone_constructors_and_destructors. */
|
6559 |
|
|
if (PRIMARY_TEMPLATE_P (gen_tmpl))
|
6560 |
|
|
clone_function_decl (r, /*update_method_vec_p=*/0);
|
6561 |
|
|
}
|
6562 |
|
|
else if (IDENTIFIER_OPNAME_P (DECL_NAME (r)))
|
6563 |
|
|
grok_op_properties (r, (complain & tf_error) != 0);
|
6564 |
|
|
|
6565 |
|
|
if (DECL_FRIEND_P (t) && DECL_FRIEND_CONTEXT (t))
|
6566 |
|
|
SET_DECL_FRIEND_CONTEXT (r,
|
6567 |
|
|
tsubst (DECL_FRIEND_CONTEXT (t),
|
6568 |
|
|
args, complain, in_decl));
|
6569 |
|
|
}
|
6570 |
|
|
break;
|
6571 |
|
|
|
6572 |
|
|
case PARM_DECL:
|
6573 |
|
|
{
|
6574 |
|
|
tree type;
|
6575 |
|
|
|
6576 |
|
|
r = copy_node (t);
|
6577 |
|
|
if (DECL_TEMPLATE_PARM_P (t))
|
6578 |
|
|
SET_DECL_TEMPLATE_PARM_P (r);
|
6579 |
|
|
|
6580 |
|
|
type = tsubst (TREE_TYPE (t), args, complain, in_decl);
|
6581 |
|
|
type = type_decays_to (type);
|
6582 |
|
|
TREE_TYPE (r) = type;
|
6583 |
|
|
cp_apply_type_quals_to_decl (cp_type_quals (type), r);
|
6584 |
|
|
|
6585 |
|
|
if (DECL_INITIAL (r))
|
6586 |
|
|
{
|
6587 |
|
|
if (TREE_CODE (DECL_INITIAL (r)) != TEMPLATE_PARM_INDEX)
|
6588 |
|
|
DECL_INITIAL (r) = TREE_TYPE (r);
|
6589 |
|
|
else
|
6590 |
|
|
DECL_INITIAL (r) = tsubst (DECL_INITIAL (r), args,
|
6591 |
|
|
complain, in_decl);
|
6592 |
|
|
}
|
6593 |
|
|
|
6594 |
|
|
DECL_CONTEXT (r) = NULL_TREE;
|
6595 |
|
|
|
6596 |
|
|
if (!DECL_TEMPLATE_PARM_P (r))
|
6597 |
|
|
DECL_ARG_TYPE (r) = type_passed_as (type);
|
6598 |
|
|
if (TREE_CHAIN (t))
|
6599 |
|
|
TREE_CHAIN (r) = tsubst (TREE_CHAIN (t), args,
|
6600 |
|
|
complain, TREE_CHAIN (t));
|
6601 |
|
|
}
|
6602 |
|
|
break;
|
6603 |
|
|
|
6604 |
|
|
case FIELD_DECL:
|
6605 |
|
|
{
|
6606 |
|
|
tree type;
|
6607 |
|
|
|
6608 |
|
|
r = copy_decl (t);
|
6609 |
|
|
type = tsubst (TREE_TYPE (t), args, complain, in_decl);
|
6610 |
|
|
if (type == error_mark_node)
|
6611 |
|
|
return error_mark_node;
|
6612 |
|
|
TREE_TYPE (r) = type;
|
6613 |
|
|
cp_apply_type_quals_to_decl (cp_type_quals (type), r);
|
6614 |
|
|
|
6615 |
|
|
/* We don't have to set DECL_CONTEXT here; it is set by
|
6616 |
|
|
finish_member_declaration. */
|
6617 |
|
|
DECL_INITIAL (r) = tsubst_expr (DECL_INITIAL (t), args,
|
6618 |
|
|
complain, in_decl);
|
6619 |
|
|
TREE_CHAIN (r) = NULL_TREE;
|
6620 |
|
|
if (VOID_TYPE_P (type))
|
6621 |
|
|
error ("instantiation of %q+D as type %qT", r, type);
|
6622 |
|
|
}
|
6623 |
|
|
break;
|
6624 |
|
|
|
6625 |
|
|
case USING_DECL:
|
6626 |
|
|
/* We reach here only for member using decls. */
|
6627 |
|
|
if (DECL_DEPENDENT_P (t))
|
6628 |
|
|
{
|
6629 |
|
|
r = do_class_using_decl
|
6630 |
|
|
(tsubst_copy (USING_DECL_SCOPE (t), args, complain, in_decl),
|
6631 |
|
|
tsubst_copy (DECL_NAME (t), args, complain, in_decl));
|
6632 |
|
|
if (!r)
|
6633 |
|
|
r = error_mark_node;
|
6634 |
|
|
}
|
6635 |
|
|
else
|
6636 |
|
|
{
|
6637 |
|
|
r = copy_node (t);
|
6638 |
|
|
TREE_CHAIN (r) = NULL_TREE;
|
6639 |
|
|
}
|
6640 |
|
|
break;
|
6641 |
|
|
|
6642 |
|
|
case TYPE_DECL:
|
6643 |
|
|
case VAR_DECL:
|
6644 |
|
|
{
|
6645 |
|
|
tree argvec = NULL_TREE;
|
6646 |
|
|
tree gen_tmpl = NULL_TREE;
|
6647 |
|
|
tree spec;
|
6648 |
|
|
tree tmpl = NULL_TREE;
|
6649 |
|
|
tree ctx;
|
6650 |
|
|
tree type = NULL_TREE;
|
6651 |
|
|
int local_p;
|
6652 |
|
|
|
6653 |
|
|
if (TREE_CODE (t) == TYPE_DECL)
|
6654 |
|
|
{
|
6655 |
|
|
type = tsubst (TREE_TYPE (t), args, complain, in_decl);
|
6656 |
|
|
if (TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
|
6657 |
|
|
|| t == TYPE_MAIN_DECL (TREE_TYPE (t)))
|
6658 |
|
|
{
|
6659 |
|
|
/* If this is the canonical decl, we don't have to
|
6660 |
|
|
mess with instantiations, and often we can't (for
|
6661 |
|
|
typename, template type parms and such). Note that
|
6662 |
|
|
TYPE_NAME is not correct for the above test if
|
6663 |
|
|
we've copied the type for a typedef. */
|
6664 |
|
|
r = TYPE_NAME (type);
|
6665 |
|
|
break;
|
6666 |
|
|
}
|
6667 |
|
|
}
|
6668 |
|
|
|
6669 |
|
|
/* Assume this is a non-local variable. */
|
6670 |
|
|
local_p = 0;
|
6671 |
|
|
|
6672 |
|
|
if (TYPE_P (CP_DECL_CONTEXT (t)))
|
6673 |
|
|
ctx = tsubst_aggr_type (DECL_CONTEXT (t), args,
|
6674 |
|
|
complain,
|
6675 |
|
|
in_decl, /*entering_scope=*/1);
|
6676 |
|
|
else if (DECL_NAMESPACE_SCOPE_P (t))
|
6677 |
|
|
ctx = DECL_CONTEXT (t);
|
6678 |
|
|
else
|
6679 |
|
|
{
|
6680 |
|
|
/* Subsequent calls to pushdecl will fill this in. */
|
6681 |
|
|
ctx = NULL_TREE;
|
6682 |
|
|
local_p = 1;
|
6683 |
|
|
}
|
6684 |
|
|
|
6685 |
|
|
/* Check to see if we already have this specialization. */
|
6686 |
|
|
if (!local_p)
|
6687 |
|
|
{
|
6688 |
|
|
tmpl = DECL_TI_TEMPLATE (t);
|
6689 |
|
|
gen_tmpl = most_general_template (tmpl);
|
6690 |
|
|
argvec = tsubst (DECL_TI_ARGS (t), args, complain, in_decl);
|
6691 |
|
|
spec = retrieve_specialization (gen_tmpl, argvec,
|
6692 |
|
|
/*class_specializations_p=*/false);
|
6693 |
|
|
}
|
6694 |
|
|
else
|
6695 |
|
|
spec = retrieve_local_specialization (t);
|
6696 |
|
|
|
6697 |
|
|
if (spec)
|
6698 |
|
|
{
|
6699 |
|
|
r = spec;
|
6700 |
|
|
break;
|
6701 |
|
|
}
|
6702 |
|
|
|
6703 |
|
|
r = copy_decl (t);
|
6704 |
|
|
if (TREE_CODE (r) == VAR_DECL)
|
6705 |
|
|
{
|
6706 |
|
|
/* Even if the original location is out of scope, the
|
6707 |
|
|
newly substituted one is not. */
|
6708 |
|
|
DECL_DEAD_FOR_LOCAL (r) = 0;
|
6709 |
|
|
DECL_INITIALIZED_P (r) = 0;
|
6710 |
|
|
DECL_TEMPLATE_INSTANTIATED (r) = 0;
|
6711 |
|
|
type = tsubst (TREE_TYPE (t), args, complain, in_decl);
|
6712 |
|
|
if (type == error_mark_node)
|
6713 |
|
|
return error_mark_node;
|
6714 |
|
|
type = complete_type (type);
|
6715 |
|
|
DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r)
|
6716 |
|
|
= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t);
|
6717 |
|
|
type = check_var_type (DECL_NAME (r), type);
|
6718 |
|
|
|
6719 |
|
|
if (DECL_HAS_VALUE_EXPR_P (t))
|
6720 |
|
|
{
|
6721 |
|
|
tree ve = DECL_VALUE_EXPR (t);
|
6722 |
|
|
ve = tsubst_expr (ve, args, complain, in_decl);
|
6723 |
|
|
SET_DECL_VALUE_EXPR (r, ve);
|
6724 |
|
|
}
|
6725 |
|
|
}
|
6726 |
|
|
else if (DECL_SELF_REFERENCE_P (t))
|
6727 |
|
|
SET_DECL_SELF_REFERENCE_P (r);
|
6728 |
|
|
TREE_TYPE (r) = type;
|
6729 |
|
|
cp_apply_type_quals_to_decl (cp_type_quals (type), r);
|
6730 |
|
|
DECL_CONTEXT (r) = ctx;
|
6731 |
|
|
/* Clear out the mangled name and RTL for the instantiation. */
|
6732 |
|
|
SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
|
6733 |
|
|
if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
|
6734 |
|
|
SET_DECL_RTL (r, NULL_RTX);
|
6735 |
|
|
/* The initializer must not be expanded until it is required;
|
6736 |
|
|
see [temp.inst]. */
|
6737 |
|
|
DECL_INITIAL (r) = NULL_TREE;
|
6738 |
|
|
if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
|
6739 |
|
|
SET_DECL_RTL (r, NULL_RTX);
|
6740 |
|
|
DECL_SIZE (r) = DECL_SIZE_UNIT (r) = 0;
|
6741 |
|
|
|
6742 |
|
|
if (!local_p)
|
6743 |
|
|
{
|
6744 |
|
|
/* A static data member declaration is always marked
|
6745 |
|
|
external when it is declared in-class, even if an
|
6746 |
|
|
initializer is present. We mimic the non-template
|
6747 |
|
|
processing here. */
|
6748 |
|
|
DECL_EXTERNAL (r) = 1;
|
6749 |
|
|
|
6750 |
|
|
register_specialization (r, gen_tmpl, argvec, false);
|
6751 |
|
|
DECL_TEMPLATE_INFO (r) = tree_cons (tmpl, argvec, NULL_TREE);
|
6752 |
|
|
SET_DECL_IMPLICIT_INSTANTIATION (r);
|
6753 |
|
|
}
|
6754 |
|
|
else
|
6755 |
|
|
register_local_specialization (r, t);
|
6756 |
|
|
|
6757 |
|
|
TREE_CHAIN (r) = NULL_TREE;
|
6758 |
|
|
layout_decl (r, 0);
|
6759 |
|
|
}
|
6760 |
|
|
break;
|
6761 |
|
|
|
6762 |
|
|
default:
|
6763 |
|
|
gcc_unreachable ();
|
6764 |
|
|
}
|
6765 |
|
|
|
6766 |
|
|
/* Restore the file and line information. */
|
6767 |
|
|
input_location = saved_loc;
|
6768 |
|
|
|
6769 |
|
|
return r;
|
6770 |
|
|
}
|
6771 |
|
|
|
6772 |
|
|
/* Substitute into the ARG_TYPES of a function type. */
|
6773 |
|
|
|
6774 |
|
|
static tree
|
6775 |
|
|
tsubst_arg_types (tree arg_types,
|
6776 |
|
|
tree args,
|
6777 |
|
|
tsubst_flags_t complain,
|
6778 |
|
|
tree in_decl)
|
6779 |
|
|
{
|
6780 |
|
|
tree remaining_arg_types;
|
6781 |
|
|
tree type;
|
6782 |
|
|
tree default_arg;
|
6783 |
|
|
tree result = NULL_TREE;
|
6784 |
|
|
|
6785 |
|
|
if (!arg_types || arg_types == void_list_node)
|
6786 |
|
|
return arg_types;
|
6787 |
|
|
|
6788 |
|
|
remaining_arg_types = tsubst_arg_types (TREE_CHAIN (arg_types),
|
6789 |
|
|
args, complain, in_decl);
|
6790 |
|
|
if (remaining_arg_types == error_mark_node)
|
6791 |
|
|
return error_mark_node;
|
6792 |
|
|
|
6793 |
|
|
type = tsubst (TREE_VALUE (arg_types), args, complain, in_decl);
|
6794 |
|
|
if (type == error_mark_node)
|
6795 |
|
|
return error_mark_node;
|
6796 |
|
|
if (VOID_TYPE_P (type))
|
6797 |
|
|
{
|
6798 |
|
|
if (complain & tf_error)
|
6799 |
|
|
{
|
6800 |
|
|
error ("invalid parameter type %qT", type);
|
6801 |
|
|
if (in_decl)
|
6802 |
|
|
error ("in declaration %q+D", in_decl);
|
6803 |
|
|
}
|
6804 |
|
|
return error_mark_node;
|
6805 |
|
|
}
|
6806 |
|
|
|
6807 |
|
|
/* Do array-to-pointer, function-to-pointer conversion, and ignore
|
6808 |
|
|
top-level qualifiers as required. */
|
6809 |
|
|
type = TYPE_MAIN_VARIANT (type_decays_to (type));
|
6810 |
|
|
|
6811 |
|
|
/* We do not substitute into default arguments here. The standard
|
6812 |
|
|
mandates that they be instantiated only when needed, which is
|
6813 |
|
|
done in build_over_call. */
|
6814 |
|
|
default_arg = TREE_PURPOSE (arg_types);
|
6815 |
|
|
|
6816 |
|
|
if (default_arg && TREE_CODE (default_arg) == DEFAULT_ARG)
|
6817 |
|
|
{
|
6818 |
|
|
/* We've instantiated a template before its default arguments
|
6819 |
|
|
have been parsed. This can happen for a nested template
|
6820 |
|
|
class, and is not an error unless we require the default
|
6821 |
|
|
argument in a call of this function. */
|
6822 |
|
|
result = tree_cons (default_arg, type, remaining_arg_types);
|
6823 |
|
|
VEC_safe_push (tree, gc, DEFARG_INSTANTIATIONS (default_arg), result);
|
6824 |
|
|
}
|
6825 |
|
|
else
|
6826 |
|
|
result = hash_tree_cons (default_arg, type, remaining_arg_types);
|
6827 |
|
|
|
6828 |
|
|
return result;
|
6829 |
|
|
}
|
6830 |
|
|
|
6831 |
|
|
/* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
|
6832 |
|
|
*not* handle the exception-specification for FNTYPE, because the
|
6833 |
|
|
initial substitution of explicitly provided template parameters
|
6834 |
|
|
during argument deduction forbids substitution into the
|
6835 |
|
|
exception-specification:
|
6836 |
|
|
|
6837 |
|
|
[temp.deduct]
|
6838 |
|
|
|
6839 |
|
|
All references in the function type of the function template to the
|
6840 |
|
|
corresponding template parameters are replaced by the specified tem-
|
6841 |
|
|
plate argument values. If a substitution in a template parameter or
|
6842 |
|
|
in the function type of the function template results in an invalid
|
6843 |
|
|
type, type deduction fails. [Note: The equivalent substitution in
|
6844 |
|
|
exception specifications is done only when the function is instanti-
|
6845 |
|
|
ated, at which point a program is ill-formed if the substitution
|
6846 |
|
|
results in an invalid type.] */
|
6847 |
|
|
|
6848 |
|
|
static tree
|
6849 |
|
|
tsubst_function_type (tree t,
|
6850 |
|
|
tree args,
|
6851 |
|
|
tsubst_flags_t complain,
|
6852 |
|
|
tree in_decl)
|
6853 |
|
|
{
|
6854 |
|
|
tree return_type;
|
6855 |
|
|
tree arg_types;
|
6856 |
|
|
tree fntype;
|
6857 |
|
|
|
6858 |
|
|
/* The TYPE_CONTEXT is not used for function/method types. */
|
6859 |
|
|
gcc_assert (TYPE_CONTEXT (t) == NULL_TREE);
|
6860 |
|
|
|
6861 |
|
|
/* Substitute the return type. */
|
6862 |
|
|
return_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
|
6863 |
|
|
if (return_type == error_mark_node)
|
6864 |
|
|
return error_mark_node;
|
6865 |
|
|
/* The standard does not presently indicate that creation of a
|
6866 |
|
|
function type with an invalid return type is a deduction failure.
|
6867 |
|
|
However, that is clearly analogous to creating an array of "void"
|
6868 |
|
|
or a reference to a reference. This is core issue #486. */
|
6869 |
|
|
if (TREE_CODE (return_type) == ARRAY_TYPE
|
6870 |
|
|
|| TREE_CODE (return_type) == FUNCTION_TYPE)
|
6871 |
|
|
{
|
6872 |
|
|
if (complain & tf_error)
|
6873 |
|
|
{
|
6874 |
|
|
if (TREE_CODE (return_type) == ARRAY_TYPE)
|
6875 |
|
|
error ("function returning an array");
|
6876 |
|
|
else
|
6877 |
|
|
error ("function returning a function");
|
6878 |
|
|
}
|
6879 |
|
|
return error_mark_node;
|
6880 |
|
|
}
|
6881 |
|
|
|
6882 |
|
|
/* Substitute the argument types. */
|
6883 |
|
|
arg_types = tsubst_arg_types (TYPE_ARG_TYPES (t), args,
|
6884 |
|
|
complain, in_decl);
|
6885 |
|
|
if (arg_types == error_mark_node)
|
6886 |
|
|
return error_mark_node;
|
6887 |
|
|
|
6888 |
|
|
/* Construct a new type node and return it. */
|
6889 |
|
|
if (TREE_CODE (t) == FUNCTION_TYPE)
|
6890 |
|
|
fntype = build_function_type (return_type, arg_types);
|
6891 |
|
|
else
|
6892 |
|
|
{
|
6893 |
|
|
tree r = TREE_TYPE (TREE_VALUE (arg_types));
|
6894 |
|
|
if (! IS_AGGR_TYPE (r))
|
6895 |
|
|
{
|
6896 |
|
|
/* [temp.deduct]
|
6897 |
|
|
|
6898 |
|
|
Type deduction may fail for any of the following
|
6899 |
|
|
reasons:
|
6900 |
|
|
|
6901 |
|
|
-- Attempting to create "pointer to member of T" when T
|
6902 |
|
|
is not a class type. */
|
6903 |
|
|
if (complain & tf_error)
|
6904 |
|
|
error ("creating pointer to member function of non-class type %qT",
|
6905 |
|
|
r);
|
6906 |
|
|
return error_mark_node;
|
6907 |
|
|
}
|
6908 |
|
|
|
6909 |
|
|
fntype = build_method_type_directly (r, return_type,
|
6910 |
|
|
TREE_CHAIN (arg_types));
|
6911 |
|
|
}
|
6912 |
|
|
fntype = cp_build_qualified_type_real (fntype, TYPE_QUALS (t), complain);
|
6913 |
|
|
fntype = cp_build_type_attribute_variant (fntype, TYPE_ATTRIBUTES (t));
|
6914 |
|
|
|
6915 |
|
|
return fntype;
|
6916 |
|
|
}
|
6917 |
|
|
|
6918 |
|
|
/* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
|
6919 |
|
|
ARGS into that specification, and return the substituted
|
6920 |
|
|
specification. If there is no specification, return NULL_TREE. */
|
6921 |
|
|
|
6922 |
|
|
static tree
|
6923 |
|
|
tsubst_exception_specification (tree fntype,
|
6924 |
|
|
tree args,
|
6925 |
|
|
tsubst_flags_t complain,
|
6926 |
|
|
tree in_decl)
|
6927 |
|
|
{
|
6928 |
|
|
tree specs;
|
6929 |
|
|
tree new_specs;
|
6930 |
|
|
|
6931 |
|
|
specs = TYPE_RAISES_EXCEPTIONS (fntype);
|
6932 |
|
|
new_specs = NULL_TREE;
|
6933 |
|
|
if (specs)
|
6934 |
|
|
{
|
6935 |
|
|
if (! TREE_VALUE (specs))
|
6936 |
|
|
new_specs = specs;
|
6937 |
|
|
else
|
6938 |
|
|
while (specs)
|
6939 |
|
|
{
|
6940 |
|
|
tree spec;
|
6941 |
|
|
spec = tsubst (TREE_VALUE (specs), args, complain, in_decl);
|
6942 |
|
|
if (spec == error_mark_node)
|
6943 |
|
|
return spec;
|
6944 |
|
|
new_specs = add_exception_specifier (new_specs, spec, complain);
|
6945 |
|
|
specs = TREE_CHAIN (specs);
|
6946 |
|
|
}
|
6947 |
|
|
}
|
6948 |
|
|
return new_specs;
|
6949 |
|
|
}
|
6950 |
|
|
|
6951 |
|
|
/* Substitute into the PARMS of a call-declarator. */
|
6952 |
|
|
|
6953 |
|
|
static tree
|
6954 |
|
|
tsubst_call_declarator_parms (tree parms,
|
6955 |
|
|
tree args,
|
6956 |
|
|
tsubst_flags_t complain,
|
6957 |
|
|
tree in_decl)
|
6958 |
|
|
{
|
6959 |
|
|
tree new_parms;
|
6960 |
|
|
tree type;
|
6961 |
|
|
tree defarg;
|
6962 |
|
|
|
6963 |
|
|
if (!parms || parms == void_list_node)
|
6964 |
|
|
return parms;
|
6965 |
|
|
|
6966 |
|
|
new_parms = tsubst_call_declarator_parms (TREE_CHAIN (parms),
|
6967 |
|
|
args, complain, in_decl);
|
6968 |
|
|
|
6969 |
|
|
/* Figure out the type of this parameter. */
|
6970 |
|
|
type = tsubst (TREE_VALUE (parms), args, complain, in_decl);
|
6971 |
|
|
|
6972 |
|
|
/* Figure out the default argument as well. Note that we use
|
6973 |
|
|
tsubst_expr since the default argument is really an expression. */
|
6974 |
|
|
defarg = tsubst_expr (TREE_PURPOSE (parms), args, complain, in_decl);
|
6975 |
|
|
|
6976 |
|
|
/* Chain this parameter on to the front of those we have already
|
6977 |
|
|
processed. We don't use hash_tree_cons because that function
|
6978 |
|
|
doesn't check TREE_PARMLIST. */
|
6979 |
|
|
new_parms = tree_cons (defarg, type, new_parms);
|
6980 |
|
|
|
6981 |
|
|
return new_parms;
|
6982 |
|
|
}
|
6983 |
|
|
|
6984 |
|
|
/* Take the tree structure T and replace template parameters used
|
6985 |
|
|
therein with the argument vector ARGS. IN_DECL is an associated
|
6986 |
|
|
decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
|
6987 |
|
|
Issue error and warning messages under control of COMPLAIN. Note
|
6988 |
|
|
that we must be relatively non-tolerant of extensions here, in
|
6989 |
|
|
order to preserve conformance; if we allow substitutions that
|
6990 |
|
|
should not be allowed, we may allow argument deductions that should
|
6991 |
|
|
not succeed, and therefore report ambiguous overload situations
|
6992 |
|
|
where there are none. In theory, we could allow the substitution,
|
6993 |
|
|
but indicate that it should have failed, and allow our caller to
|
6994 |
|
|
make sure that the right thing happens, but we don't try to do this
|
6995 |
|
|
yet.
|
6996 |
|
|
|
6997 |
|
|
This function is used for dealing with types, decls and the like;
|
6998 |
|
|
for expressions, use tsubst_expr or tsubst_copy. */
|
6999 |
|
|
|
7000 |
|
|
static tree
|
7001 |
|
|
tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
|
7002 |
|
|
{
|
7003 |
|
|
tree type, r;
|
7004 |
|
|
|
7005 |
|
|
if (t == NULL_TREE || t == error_mark_node
|
7006 |
|
|
|| t == integer_type_node
|
7007 |
|
|
|| t == void_type_node
|
7008 |
|
|
|| t == char_type_node
|
7009 |
|
|
|| t == unknown_type_node
|
7010 |
|
|
|| TREE_CODE (t) == NAMESPACE_DECL)
|
7011 |
|
|
return t;
|
7012 |
|
|
|
7013 |
|
|
if (DECL_P (t))
|
7014 |
|
|
return tsubst_decl (t, args, complain);
|
7015 |
|
|
|
7016 |
|
|
if (TREE_CODE (t) == IDENTIFIER_NODE)
|
7017 |
|
|
type = IDENTIFIER_TYPE_VALUE (t);
|
7018 |
|
|
else
|
7019 |
|
|
type = TREE_TYPE (t);
|
7020 |
|
|
|
7021 |
|
|
gcc_assert (type != unknown_type_node);
|
7022 |
|
|
|
7023 |
|
|
if (type
|
7024 |
|
|
&& TREE_CODE (t) != TYPENAME_TYPE
|
7025 |
|
|
&& TREE_CODE (t) != IDENTIFIER_NODE
|
7026 |
|
|
&& TREE_CODE (t) != FUNCTION_TYPE
|
7027 |
|
|
&& TREE_CODE (t) != METHOD_TYPE)
|
7028 |
|
|
type = tsubst (type, args, complain, in_decl);
|
7029 |
|
|
if (type == error_mark_node)
|
7030 |
|
|
return error_mark_node;
|
7031 |
|
|
|
7032 |
|
|
switch (TREE_CODE (t))
|
7033 |
|
|
{
|
7034 |
|
|
case RECORD_TYPE:
|
7035 |
|
|
case UNION_TYPE:
|
7036 |
|
|
case ENUMERAL_TYPE:
|
7037 |
|
|
return tsubst_aggr_type (t, args, complain, in_decl,
|
7038 |
|
|
/*entering_scope=*/0);
|
7039 |
|
|
|
7040 |
|
|
case ERROR_MARK:
|
7041 |
|
|
case IDENTIFIER_NODE:
|
7042 |
|
|
case VOID_TYPE:
|
7043 |
|
|
case REAL_TYPE:
|
7044 |
|
|
case COMPLEX_TYPE:
|
7045 |
|
|
case VECTOR_TYPE:
|
7046 |
|
|
case BOOLEAN_TYPE:
|
7047 |
|
|
case INTEGER_CST:
|
7048 |
|
|
case REAL_CST:
|
7049 |
|
|
case STRING_CST:
|
7050 |
|
|
return t;
|
7051 |
|
|
|
7052 |
|
|
case INTEGER_TYPE:
|
7053 |
|
|
if (t == integer_type_node)
|
7054 |
|
|
return t;
|
7055 |
|
|
|
7056 |
|
|
if (TREE_CODE (TYPE_MIN_VALUE (t)) == INTEGER_CST
|
7057 |
|
|
&& TREE_CODE (TYPE_MAX_VALUE (t)) == INTEGER_CST)
|
7058 |
|
|
return t;
|
7059 |
|
|
|
7060 |
|
|
{
|
7061 |
|
|
tree max, omax = TREE_OPERAND (TYPE_MAX_VALUE (t), 0);
|
7062 |
|
|
|
7063 |
|
|
/* The array dimension behaves like a non-type template arg,
|
7064 |
|
|
in that we want to fold it as much as possible. */
|
7065 |
|
|
max = tsubst_template_arg (omax, args, complain, in_decl);
|
7066 |
|
|
max = fold_decl_constant_value (max);
|
7067 |
|
|
|
7068 |
|
|
/* [temp.deduct]
|
7069 |
|
|
|
7070 |
|
|
Type deduction may fail for any of the following
|
7071 |
|
|
reasons:
|
7072 |
|
|
|
7073 |
|
|
Attempting to create an array with a size that is
|
7074 |
|
|
zero or negative. */
|
7075 |
|
|
if (integer_zerop (max) && !(complain & tf_error))
|
7076 |
|
|
/* We must fail if performing argument deduction (as
|
7077 |
|
|
indicated by the state of complain), so that
|
7078 |
|
|
another substitution can be found. */
|
7079 |
|
|
return error_mark_node;
|
7080 |
|
|
|
7081 |
|
|
else if (TREE_CODE (max) == INTEGER_CST
|
7082 |
|
|
&& INT_CST_LT (max, integer_zero_node))
|
7083 |
|
|
{
|
7084 |
|
|
if (complain & tf_error)
|
7085 |
|
|
error ("creating array with negative size (%qE)", max);
|
7086 |
|
|
|
7087 |
|
|
return error_mark_node;
|
7088 |
|
|
}
|
7089 |
|
|
|
7090 |
|
|
return compute_array_index_type (NULL_TREE, max);
|
7091 |
|
|
}
|
7092 |
|
|
|
7093 |
|
|
case TEMPLATE_TYPE_PARM:
|
7094 |
|
|
case TEMPLATE_TEMPLATE_PARM:
|
7095 |
|
|
case BOUND_TEMPLATE_TEMPLATE_PARM:
|
7096 |
|
|
case TEMPLATE_PARM_INDEX:
|
7097 |
|
|
{
|
7098 |
|
|
int idx;
|
7099 |
|
|
int level;
|
7100 |
|
|
int levels;
|
7101 |
|
|
tree arg = NULL_TREE;
|
7102 |
|
|
|
7103 |
|
|
r = NULL_TREE;
|
7104 |
|
|
|
7105 |
|
|
gcc_assert (TREE_VEC_LENGTH (args) > 0);
|
7106 |
|
|
if (TREE_CODE (t) == TEMPLATE_TYPE_PARM
|
7107 |
|
|
|| TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM
|
7108 |
|
|
|| TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
|
7109 |
|
|
{
|
7110 |
|
|
idx = TEMPLATE_TYPE_IDX (t);
|
7111 |
|
|
level = TEMPLATE_TYPE_LEVEL (t);
|
7112 |
|
|
}
|
7113 |
|
|
else
|
7114 |
|
|
{
|
7115 |
|
|
idx = TEMPLATE_PARM_IDX (t);
|
7116 |
|
|
level = TEMPLATE_PARM_LEVEL (t);
|
7117 |
|
|
}
|
7118 |
|
|
|
7119 |
|
|
levels = TMPL_ARGS_DEPTH (args);
|
7120 |
|
|
if (level <= levels)
|
7121 |
|
|
arg = TMPL_ARG (args, level, idx);
|
7122 |
|
|
|
7123 |
|
|
if (arg == error_mark_node)
|
7124 |
|
|
return error_mark_node;
|
7125 |
|
|
else if (arg != NULL_TREE)
|
7126 |
|
|
{
|
7127 |
|
|
if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
|
7128 |
|
|
{
|
7129 |
|
|
gcc_assert (TYPE_P (arg));
|
7130 |
|
|
return cp_build_qualified_type_real
|
7131 |
|
|
(arg, cp_type_quals (arg) | cp_type_quals (t),
|
7132 |
|
|
complain | tf_ignore_bad_quals);
|
7133 |
|
|
}
|
7134 |
|
|
else if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
|
7135 |
|
|
{
|
7136 |
|
|
/* We are processing a type constructed from a
|
7137 |
|
|
template template parameter. */
|
7138 |
|
|
tree argvec = tsubst (TYPE_TI_ARGS (t),
|
7139 |
|
|
args, complain, in_decl);
|
7140 |
|
|
if (argvec == error_mark_node)
|
7141 |
|
|
return error_mark_node;
|
7142 |
|
|
|
7143 |
|
|
/* We can get a TEMPLATE_TEMPLATE_PARM here when we
|
7144 |
|
|
are resolving nested-types in the signature of a
|
7145 |
|
|
member function templates. Otherwise ARG is a
|
7146 |
|
|
TEMPLATE_DECL and is the real template to be
|
7147 |
|
|
instantiated. */
|
7148 |
|
|
if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
|
7149 |
|
|
arg = TYPE_NAME (arg);
|
7150 |
|
|
|
7151 |
|
|
r = lookup_template_class (arg,
|
7152 |
|
|
argvec, in_decl,
|
7153 |
|
|
DECL_CONTEXT (arg),
|
7154 |
|
|
/*entering_scope=*/0,
|
7155 |
|
|
complain);
|
7156 |
|
|
return cp_build_qualified_type_real
|
7157 |
|
|
(r, TYPE_QUALS (t), complain);
|
7158 |
|
|
}
|
7159 |
|
|
else
|
7160 |
|
|
/* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
|
7161 |
|
|
return arg;
|
7162 |
|
|
}
|
7163 |
|
|
|
7164 |
|
|
if (level == 1)
|
7165 |
|
|
/* This can happen during the attempted tsubst'ing in
|
7166 |
|
|
unify. This means that we don't yet have any information
|
7167 |
|
|
about the template parameter in question. */
|
7168 |
|
|
return t;
|
7169 |
|
|
|
7170 |
|
|
/* If we get here, we must have been looking at a parm for a
|
7171 |
|
|
more deeply nested template. Make a new version of this
|
7172 |
|
|
template parameter, but with a lower level. */
|
7173 |
|
|
switch (TREE_CODE (t))
|
7174 |
|
|
{
|
7175 |
|
|
case TEMPLATE_TYPE_PARM:
|
7176 |
|
|
case TEMPLATE_TEMPLATE_PARM:
|
7177 |
|
|
case BOUND_TEMPLATE_TEMPLATE_PARM:
|
7178 |
|
|
if (cp_type_quals (t))
|
7179 |
|
|
{
|
7180 |
|
|
r = tsubst (TYPE_MAIN_VARIANT (t), args, complain, in_decl);
|
7181 |
|
|
r = cp_build_qualified_type_real
|
7182 |
|
|
(r, cp_type_quals (t),
|
7183 |
|
|
complain | (TREE_CODE (t) == TEMPLATE_TYPE_PARM
|
7184 |
|
|
? tf_ignore_bad_quals : 0));
|
7185 |
|
|
}
|
7186 |
|
|
else
|
7187 |
|
|
{
|
7188 |
|
|
r = copy_type (t);
|
7189 |
|
|
TEMPLATE_TYPE_PARM_INDEX (r)
|
7190 |
|
|
= reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t),
|
7191 |
|
|
r, levels);
|
7192 |
|
|
TYPE_STUB_DECL (r) = TYPE_NAME (r) = TEMPLATE_TYPE_DECL (r);
|
7193 |
|
|
TYPE_MAIN_VARIANT (r) = r;
|
7194 |
|
|
TYPE_POINTER_TO (r) = NULL_TREE;
|
7195 |
|
|
TYPE_REFERENCE_TO (r) = NULL_TREE;
|
7196 |
|
|
|
7197 |
|
|
if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
|
7198 |
|
|
{
|
7199 |
|
|
tree argvec = tsubst (TYPE_TI_ARGS (t), args,
|
7200 |
|
|
complain, in_decl);
|
7201 |
|
|
if (argvec == error_mark_node)
|
7202 |
|
|
return error_mark_node;
|
7203 |
|
|
|
7204 |
|
|
TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r)
|
7205 |
|
|
= tree_cons (TYPE_TI_TEMPLATE (t), argvec, NULL_TREE);
|
7206 |
|
|
}
|
7207 |
|
|
}
|
7208 |
|
|
break;
|
7209 |
|
|
|
7210 |
|
|
case TEMPLATE_PARM_INDEX:
|
7211 |
|
|
r = reduce_template_parm_level (t, type, levels);
|
7212 |
|
|
break;
|
7213 |
|
|
|
7214 |
|
|
default:
|
7215 |
|
|
gcc_unreachable ();
|
7216 |
|
|
}
|
7217 |
|
|
|
7218 |
|
|
return r;
|
7219 |
|
|
}
|
7220 |
|
|
|
7221 |
|
|
case TREE_LIST:
|
7222 |
|
|
{
|
7223 |
|
|
tree purpose, value, chain;
|
7224 |
|
|
|
7225 |
|
|
if (t == void_list_node)
|
7226 |
|
|
return t;
|
7227 |
|
|
|
7228 |
|
|
purpose = TREE_PURPOSE (t);
|
7229 |
|
|
if (purpose)
|
7230 |
|
|
{
|
7231 |
|
|
purpose = tsubst (purpose, args, complain, in_decl);
|
7232 |
|
|
if (purpose == error_mark_node)
|
7233 |
|
|
return error_mark_node;
|
7234 |
|
|
}
|
7235 |
|
|
value = TREE_VALUE (t);
|
7236 |
|
|
if (value)
|
7237 |
|
|
{
|
7238 |
|
|
value = tsubst (value, args, complain, in_decl);
|
7239 |
|
|
if (value == error_mark_node)
|
7240 |
|
|
return error_mark_node;
|
7241 |
|
|
}
|
7242 |
|
|
chain = TREE_CHAIN (t);
|
7243 |
|
|
if (chain && chain != void_type_node)
|
7244 |
|
|
{
|
7245 |
|
|
chain = tsubst (chain, args, complain, in_decl);
|
7246 |
|
|
if (chain == error_mark_node)
|
7247 |
|
|
return error_mark_node;
|
7248 |
|
|
}
|
7249 |
|
|
if (purpose == TREE_PURPOSE (t)
|
7250 |
|
|
&& value == TREE_VALUE (t)
|
7251 |
|
|
&& chain == TREE_CHAIN (t))
|
7252 |
|
|
return t;
|
7253 |
|
|
return hash_tree_cons (purpose, value, chain);
|
7254 |
|
|
}
|
7255 |
|
|
|
7256 |
|
|
case TREE_BINFO:
|
7257 |
|
|
/* We should never be tsubsting a binfo. */
|
7258 |
|
|
gcc_unreachable ();
|
7259 |
|
|
|
7260 |
|
|
case TREE_VEC:
|
7261 |
|
|
/* A vector of template arguments. */
|
7262 |
|
|
gcc_assert (!type);
|
7263 |
|
|
return tsubst_template_args (t, args, complain, in_decl);
|
7264 |
|
|
|
7265 |
|
|
case POINTER_TYPE:
|
7266 |
|
|
case REFERENCE_TYPE:
|
7267 |
|
|
{
|
7268 |
|
|
enum tree_code code;
|
7269 |
|
|
|
7270 |
|
|
if (type == TREE_TYPE (t) && TREE_CODE (type) != METHOD_TYPE)
|
7271 |
|
|
return t;
|
7272 |
|
|
|
7273 |
|
|
code = TREE_CODE (t);
|
7274 |
|
|
|
7275 |
|
|
|
7276 |
|
|
/* [temp.deduct]
|
7277 |
|
|
|
7278 |
|
|
Type deduction may fail for any of the following
|
7279 |
|
|
reasons:
|
7280 |
|
|
|
7281 |
|
|
-- Attempting to create a pointer to reference type.
|
7282 |
|
|
-- Attempting to create a reference to a reference type or
|
7283 |
|
|
a reference to void. */
|
7284 |
|
|
if (TREE_CODE (type) == REFERENCE_TYPE
|
7285 |
|
|
|| (code == REFERENCE_TYPE && TREE_CODE (type) == VOID_TYPE))
|
7286 |
|
|
{
|
7287 |
|
|
static location_t last_loc;
|
7288 |
|
|
|
7289 |
|
|
/* We keep track of the last time we issued this error
|
7290 |
|
|
message to avoid spewing a ton of messages during a
|
7291 |
|
|
single bad template instantiation. */
|
7292 |
|
|
if (complain & tf_error
|
7293 |
|
|
#ifdef USE_MAPPED_LOCATION
|
7294 |
|
|
&& last_loc != input_location
|
7295 |
|
|
#else
|
7296 |
|
|
&& (last_loc.line != input_line
|
7297 |
|
|
|| last_loc.file != input_filename)
|
7298 |
|
|
#endif
|
7299 |
|
|
)
|
7300 |
|
|
{
|
7301 |
|
|
if (TREE_CODE (type) == VOID_TYPE)
|
7302 |
|
|
error ("forming reference to void");
|
7303 |
|
|
else
|
7304 |
|
|
error ("forming %s to reference type %qT",
|
7305 |
|
|
(code == POINTER_TYPE) ? "pointer" : "reference",
|
7306 |
|
|
type);
|
7307 |
|
|
last_loc = input_location;
|
7308 |
|
|
}
|
7309 |
|
|
|
7310 |
|
|
return error_mark_node;
|
7311 |
|
|
}
|
7312 |
|
|
else if (code == POINTER_TYPE)
|
7313 |
|
|
{
|
7314 |
|
|
r = build_pointer_type (type);
|
7315 |
|
|
if (TREE_CODE (type) == METHOD_TYPE)
|
7316 |
|
|
r = build_ptrmemfunc_type (r);
|
7317 |
|
|
}
|
7318 |
|
|
else
|
7319 |
|
|
r = build_reference_type (type);
|
7320 |
|
|
r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
|
7321 |
|
|
|
7322 |
|
|
if (r != error_mark_node)
|
7323 |
|
|
/* Will this ever be needed for TYPE_..._TO values? */
|
7324 |
|
|
layout_type (r);
|
7325 |
|
|
|
7326 |
|
|
return r;
|
7327 |
|
|
}
|
7328 |
|
|
case OFFSET_TYPE:
|
7329 |
|
|
{
|
7330 |
|
|
r = tsubst (TYPE_OFFSET_BASETYPE (t), args, complain, in_decl);
|
7331 |
|
|
if (r == error_mark_node || !IS_AGGR_TYPE (r))
|
7332 |
|
|
{
|
7333 |
|
|
/* [temp.deduct]
|
7334 |
|
|
|
7335 |
|
|
Type deduction may fail for any of the following
|
7336 |
|
|
reasons:
|
7337 |
|
|
|
7338 |
|
|
-- Attempting to create "pointer to member of T" when T
|
7339 |
|
|
is not a class type. */
|
7340 |
|
|
if (complain & tf_error)
|
7341 |
|
|
error ("creating pointer to member of non-class type %qT", r);
|
7342 |
|
|
return error_mark_node;
|
7343 |
|
|
}
|
7344 |
|
|
if (TREE_CODE (type) == REFERENCE_TYPE)
|
7345 |
|
|
{
|
7346 |
|
|
if (complain & tf_error)
|
7347 |
|
|
error ("creating pointer to member reference type %qT", type);
|
7348 |
|
|
return error_mark_node;
|
7349 |
|
|
}
|
7350 |
|
|
if (TREE_CODE (type) == VOID_TYPE)
|
7351 |
|
|
{
|
7352 |
|
|
if (complain & tf_error)
|
7353 |
|
|
error ("creating pointer to member of type void");
|
7354 |
|
|
return error_mark_node;
|
7355 |
|
|
}
|
7356 |
|
|
gcc_assert (TREE_CODE (type) != METHOD_TYPE);
|
7357 |
|
|
if (TREE_CODE (type) == FUNCTION_TYPE)
|
7358 |
|
|
{
|
7359 |
|
|
/* The type of the implicit object parameter gets its
|
7360 |
|
|
cv-qualifiers from the FUNCTION_TYPE. */
|
7361 |
|
|
tree method_type;
|
7362 |
|
|
tree this_type = cp_build_qualified_type (TYPE_MAIN_VARIANT (r),
|
7363 |
|
|
cp_type_quals (type));
|
7364 |
|
|
tree memptr;
|
7365 |
|
|
method_type = build_method_type_directly (this_type,
|
7366 |
|
|
TREE_TYPE (type),
|
7367 |
|
|
TYPE_ARG_TYPES (type));
|
7368 |
|
|
memptr = build_ptrmemfunc_type (build_pointer_type (method_type));
|
7369 |
|
|
return cp_build_qualified_type_real (memptr, cp_type_quals (t),
|
7370 |
|
|
complain);
|
7371 |
|
|
}
|
7372 |
|
|
else
|
7373 |
|
|
return cp_build_qualified_type_real (build_ptrmem_type (r, type),
|
7374 |
|
|
TYPE_QUALS (t),
|
7375 |
|
|
complain);
|
7376 |
|
|
}
|
7377 |
|
|
case FUNCTION_TYPE:
|
7378 |
|
|
case METHOD_TYPE:
|
7379 |
|
|
{
|
7380 |
|
|
tree fntype;
|
7381 |
|
|
tree specs;
|
7382 |
|
|
fntype = tsubst_function_type (t, args, complain, in_decl);
|
7383 |
|
|
if (fntype == error_mark_node)
|
7384 |
|
|
return error_mark_node;
|
7385 |
|
|
|
7386 |
|
|
/* Substitute the exception specification. */
|
7387 |
|
|
specs = tsubst_exception_specification (t, args, complain,
|
7388 |
|
|
in_decl);
|
7389 |
|
|
if (specs == error_mark_node)
|
7390 |
|
|
return error_mark_node;
|
7391 |
|
|
if (specs)
|
7392 |
|
|
fntype = build_exception_variant (fntype, specs);
|
7393 |
|
|
return fntype;
|
7394 |
|
|
}
|
7395 |
|
|
case ARRAY_TYPE:
|
7396 |
|
|
{
|
7397 |
|
|
tree domain = tsubst (TYPE_DOMAIN (t), args, complain, in_decl);
|
7398 |
|
|
if (domain == error_mark_node)
|
7399 |
|
|
return error_mark_node;
|
7400 |
|
|
|
7401 |
|
|
/* As an optimization, we avoid regenerating the array type if
|
7402 |
|
|
it will obviously be the same as T. */
|
7403 |
|
|
if (type == TREE_TYPE (t) && domain == TYPE_DOMAIN (t))
|
7404 |
|
|
return t;
|
7405 |
|
|
|
7406 |
|
|
/* These checks should match the ones in grokdeclarator.
|
7407 |
|
|
|
7408 |
|
|
[temp.deduct]
|
7409 |
|
|
|
7410 |
|
|
The deduction may fail for any of the following reasons:
|
7411 |
|
|
|
7412 |
|
|
-- Attempting to create an array with an element type that
|
7413 |
|
|
is void, a function type, or a reference type, or [DR337]
|
7414 |
|
|
an abstract class type. */
|
7415 |
|
|
if (TREE_CODE (type) == VOID_TYPE
|
7416 |
|
|
|| TREE_CODE (type) == FUNCTION_TYPE
|
7417 |
|
|
|| TREE_CODE (type) == REFERENCE_TYPE)
|
7418 |
|
|
{
|
7419 |
|
|
if (complain & tf_error)
|
7420 |
|
|
error ("creating array of %qT", type);
|
7421 |
|
|
return error_mark_node;
|
7422 |
|
|
}
|
7423 |
|
|
if (CLASS_TYPE_P (type) && CLASSTYPE_PURE_VIRTUALS (type))
|
7424 |
|
|
{
|
7425 |
|
|
if (complain & tf_error)
|
7426 |
|
|
error ("creating array of %qT, which is an abstract class type",
|
7427 |
|
|
type);
|
7428 |
|
|
return error_mark_node;
|
7429 |
|
|
}
|
7430 |
|
|
|
7431 |
|
|
r = build_cplus_array_type (type, domain);
|
7432 |
|
|
return r;
|
7433 |
|
|
}
|
7434 |
|
|
|
7435 |
|
|
case PLUS_EXPR:
|
7436 |
|
|
case MINUS_EXPR:
|
7437 |
|
|
{
|
7438 |
|
|
tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
|
7439 |
|
|
tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
|
7440 |
|
|
|
7441 |
|
|
if (e1 == error_mark_node || e2 == error_mark_node)
|
7442 |
|
|
return error_mark_node;
|
7443 |
|
|
|
7444 |
|
|
return fold_build2 (TREE_CODE (t), TREE_TYPE (t), e1, e2);
|
7445 |
|
|
}
|
7446 |
|
|
|
7447 |
|
|
case NEGATE_EXPR:
|
7448 |
|
|
case NOP_EXPR:
|
7449 |
|
|
{
|
7450 |
|
|
tree e = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
|
7451 |
|
|
if (e == error_mark_node)
|
7452 |
|
|
return error_mark_node;
|
7453 |
|
|
|
7454 |
|
|
return fold_build1 (TREE_CODE (t), TREE_TYPE (t), e);
|
7455 |
|
|
}
|
7456 |
|
|
|
7457 |
|
|
case TYPENAME_TYPE:
|
7458 |
|
|
{
|
7459 |
|
|
tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
|
7460 |
|
|
in_decl, /*entering_scope=*/1);
|
7461 |
|
|
tree f = tsubst_copy (TYPENAME_TYPE_FULLNAME (t), args,
|
7462 |
|
|
complain, in_decl);
|
7463 |
|
|
|
7464 |
|
|
if (ctx == error_mark_node || f == error_mark_node)
|
7465 |
|
|
return error_mark_node;
|
7466 |
|
|
|
7467 |
|
|
if (!IS_AGGR_TYPE (ctx))
|
7468 |
|
|
{
|
7469 |
|
|
if (complain & tf_error)
|
7470 |
|
|
error ("%qT is not a class, struct, or union type", ctx);
|
7471 |
|
|
return error_mark_node;
|
7472 |
|
|
}
|
7473 |
|
|
else if (!uses_template_parms (ctx) && !TYPE_BEING_DEFINED (ctx))
|
7474 |
|
|
{
|
7475 |
|
|
/* Normally, make_typename_type does not require that the CTX
|
7476 |
|
|
have complete type in order to allow things like:
|
7477 |
|
|
|
7478 |
|
|
template <class T> struct S { typename S<T>::X Y; };
|
7479 |
|
|
|
7480 |
|
|
But, such constructs have already been resolved by this
|
7481 |
|
|
point, so here CTX really should have complete type, unless
|
7482 |
|
|
it's a partial instantiation. */
|
7483 |
|
|
ctx = complete_type (ctx);
|
7484 |
|
|
if (!COMPLETE_TYPE_P (ctx))
|
7485 |
|
|
{
|
7486 |
|
|
if (complain & tf_error)
|
7487 |
|
|
cxx_incomplete_type_error (NULL_TREE, ctx);
|
7488 |
|
|
return error_mark_node;
|
7489 |
|
|
}
|
7490 |
|
|
}
|
7491 |
|
|
|
7492 |
|
|
f = make_typename_type (ctx, f, typename_type,
|
7493 |
|
|
(complain & tf_error) | tf_keep_type_decl);
|
7494 |
|
|
if (f == error_mark_node)
|
7495 |
|
|
return f;
|
7496 |
|
|
if (TREE_CODE (f) == TYPE_DECL)
|
7497 |
|
|
{
|
7498 |
|
|
complain |= tf_ignore_bad_quals;
|
7499 |
|
|
f = TREE_TYPE (f);
|
7500 |
|
|
}
|
7501 |
|
|
|
7502 |
|
|
if (TREE_CODE (f) != TYPENAME_TYPE)
|
7503 |
|
|
{
|
7504 |
|
|
if (TYPENAME_IS_ENUM_P (t) && TREE_CODE (f) != ENUMERAL_TYPE)
|
7505 |
|
|
error ("%qT resolves to %qT, which is not an enumeration type",
|
7506 |
|
|
t, f);
|
7507 |
|
|
else if (TYPENAME_IS_CLASS_P (t) && !CLASS_TYPE_P (f))
|
7508 |
|
|
error ("%qT resolves to %qT, which is is not a class type",
|
7509 |
|
|
t, f);
|
7510 |
|
|
}
|
7511 |
|
|
|
7512 |
|
|
return cp_build_qualified_type_real
|
7513 |
|
|
(f, cp_type_quals (f) | cp_type_quals (t), complain);
|
7514 |
|
|
}
|
7515 |
|
|
|
7516 |
|
|
case UNBOUND_CLASS_TEMPLATE:
|
7517 |
|
|
{
|
7518 |
|
|
tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
|
7519 |
|
|
in_decl, /*entering_scope=*/1);
|
7520 |
|
|
tree name = TYPE_IDENTIFIER (t);
|
7521 |
|
|
tree parm_list = DECL_TEMPLATE_PARMS (TYPE_NAME (t));
|
7522 |
|
|
|
7523 |
|
|
if (ctx == error_mark_node || name == error_mark_node)
|
7524 |
|
|
return error_mark_node;
|
7525 |
|
|
|
7526 |
|
|
if (parm_list)
|
7527 |
|
|
parm_list = tsubst_template_parms (parm_list, args, complain);
|
7528 |
|
|
return make_unbound_class_template (ctx, name, parm_list, complain);
|
7529 |
|
|
}
|
7530 |
|
|
|
7531 |
|
|
case INDIRECT_REF:
|
7532 |
|
|
case ADDR_EXPR:
|
7533 |
|
|
case CALL_EXPR:
|
7534 |
|
|
gcc_unreachable ();
|
7535 |
|
|
|
7536 |
|
|
case ARRAY_REF:
|
7537 |
|
|
{
|
7538 |
|
|
tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
|
7539 |
|
|
tree e2 = tsubst_expr (TREE_OPERAND (t, 1), args, complain, in_decl);
|
7540 |
|
|
if (e1 == error_mark_node || e2 == error_mark_node)
|
7541 |
|
|
return error_mark_node;
|
7542 |
|
|
|
7543 |
|
|
return build_nt (ARRAY_REF, e1, e2, NULL_TREE, NULL_TREE);
|
7544 |
|
|
}
|
7545 |
|
|
|
7546 |
|
|
case SCOPE_REF:
|
7547 |
|
|
{
|
7548 |
|
|
tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
|
7549 |
|
|
tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
|
7550 |
|
|
if (e1 == error_mark_node || e2 == error_mark_node)
|
7551 |
|
|
return error_mark_node;
|
7552 |
|
|
|
7553 |
|
|
return build_qualified_name (/*type=*/NULL_TREE,
|
7554 |
|
|
e1, e2, QUALIFIED_NAME_IS_TEMPLATE (t));
|
7555 |
|
|
}
|
7556 |
|
|
|
7557 |
|
|
case TYPEOF_TYPE:
|
7558 |
|
|
{
|
7559 |
|
|
tree type;
|
7560 |
|
|
|
7561 |
|
|
type = finish_typeof (tsubst_expr (TYPEOF_TYPE_EXPR (t), args,
|
7562 |
|
|
complain, in_decl));
|
7563 |
|
|
return cp_build_qualified_type_real (type,
|
7564 |
|
|
cp_type_quals (t)
|
7565 |
|
|
| cp_type_quals (type),
|
7566 |
|
|
complain);
|
7567 |
|
|
}
|
7568 |
|
|
|
7569 |
|
|
default:
|
7570 |
|
|
sorry ("use of %qs in template",
|
7571 |
|
|
tree_code_name [(int) TREE_CODE (t)]);
|
7572 |
|
|
return error_mark_node;
|
7573 |
|
|
}
|
7574 |
|
|
}
|
7575 |
|
|
|
7576 |
|
|
/* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
|
7577 |
|
|
type of the expression on the left-hand side of the "." or "->"
|
7578 |
|
|
operator. */
|
7579 |
|
|
|
7580 |
|
|
static tree
|
7581 |
|
|
tsubst_baselink (tree baselink, tree object_type,
|
7582 |
|
|
tree args, tsubst_flags_t complain, tree in_decl)
|
7583 |
|
|
{
|
7584 |
|
|
tree name;
|
7585 |
|
|
tree qualifying_scope;
|
7586 |
|
|
tree fns;
|
7587 |
|
|
tree template_args = 0;
|
7588 |
|
|
bool template_id_p = false;
|
7589 |
|
|
|
7590 |
|
|
/* A baselink indicates a function from a base class. The
|
7591 |
|
|
BASELINK_ACCESS_BINFO and BASELINK_BINFO are going to have
|
7592 |
|
|
non-dependent types; otherwise, the lookup could not have
|
7593 |
|
|
succeeded. However, they may indicate bases of the template
|
7594 |
|
|
class, rather than the instantiated class.
|
7595 |
|
|
|
7596 |
|
|
In addition, lookups that were not ambiguous before may be
|
7597 |
|
|
ambiguous now. Therefore, we perform the lookup again. */
|
7598 |
|
|
qualifying_scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink));
|
7599 |
|
|
fns = BASELINK_FUNCTIONS (baselink);
|
7600 |
|
|
if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
|
7601 |
|
|
{
|
7602 |
|
|
template_id_p = true;
|
7603 |
|
|
template_args = TREE_OPERAND (fns, 1);
|
7604 |
|
|
fns = TREE_OPERAND (fns, 0);
|
7605 |
|
|
if (template_args)
|
7606 |
|
|
template_args = tsubst_template_args (template_args, args,
|
7607 |
|
|
complain, in_decl);
|
7608 |
|
|
}
|
7609 |
|
|
name = DECL_NAME (get_first_fn (fns));
|
7610 |
|
|
baselink = lookup_fnfields (qualifying_scope, name, /*protect=*/1);
|
7611 |
|
|
|
7612 |
|
|
/* If lookup found a single function, mark it as used at this
|
7613 |
|
|
point. (If it lookup found multiple functions the one selected
|
7614 |
|
|
later by overload resolution will be marked as used at that
|
7615 |
|
|
point.) */
|
7616 |
|
|
if (BASELINK_P (baselink))
|
7617 |
|
|
fns = BASELINK_FUNCTIONS (baselink);
|
7618 |
|
|
if (!template_id_p && !really_overloaded_fn (fns))
|
7619 |
|
|
mark_used (OVL_CURRENT (fns));
|
7620 |
|
|
|
7621 |
|
|
/* Add back the template arguments, if present. */
|
7622 |
|
|
if (BASELINK_P (baselink) && template_id_p)
|
7623 |
|
|
BASELINK_FUNCTIONS (baselink)
|
7624 |
|
|
= build_nt (TEMPLATE_ID_EXPR,
|
7625 |
|
|
BASELINK_FUNCTIONS (baselink),
|
7626 |
|
|
template_args);
|
7627 |
|
|
|
7628 |
|
|
if (!object_type)
|
7629 |
|
|
object_type = current_class_type;
|
7630 |
|
|
return adjust_result_of_qualified_name_lookup (baselink,
|
7631 |
|
|
qualifying_scope,
|
7632 |
|
|
object_type);
|
7633 |
|
|
}
|
7634 |
|
|
|
7635 |
|
|
/* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
|
7636 |
|
|
true if the qualified-id will be a postfix-expression in-and-of
|
7637 |
|
|
itself; false if more of the postfix-expression follows the
|
7638 |
|
|
QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
|
7639 |
|
|
of "&". */
|
7640 |
|
|
|
7641 |
|
|
static tree
|
7642 |
|
|
tsubst_qualified_id (tree qualified_id, tree args,
|
7643 |
|
|
tsubst_flags_t complain, tree in_decl,
|
7644 |
|
|
bool done, bool address_p)
|
7645 |
|
|
{
|
7646 |
|
|
tree expr;
|
7647 |
|
|
tree scope;
|
7648 |
|
|
tree name;
|
7649 |
|
|
bool is_template;
|
7650 |
|
|
tree template_args;
|
7651 |
|
|
|
7652 |
|
|
gcc_assert (TREE_CODE (qualified_id) == SCOPE_REF);
|
7653 |
|
|
|
7654 |
|
|
/* Figure out what name to look up. */
|
7655 |
|
|
name = TREE_OPERAND (qualified_id, 1);
|
7656 |
|
|
if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
|
7657 |
|
|
{
|
7658 |
|
|
is_template = true;
|
7659 |
|
|
template_args = TREE_OPERAND (name, 1);
|
7660 |
|
|
if (template_args)
|
7661 |
|
|
template_args = tsubst_template_args (template_args, args,
|
7662 |
|
|
complain, in_decl);
|
7663 |
|
|
name = TREE_OPERAND (name, 0);
|
7664 |
|
|
}
|
7665 |
|
|
else
|
7666 |
|
|
{
|
7667 |
|
|
is_template = false;
|
7668 |
|
|
template_args = NULL_TREE;
|
7669 |
|
|
}
|
7670 |
|
|
|
7671 |
|
|
/* Substitute into the qualifying scope. When there are no ARGS, we
|
7672 |
|
|
are just trying to simplify a non-dependent expression. In that
|
7673 |
|
|
case the qualifying scope may be dependent, and, in any case,
|
7674 |
|
|
substituting will not help. */
|
7675 |
|
|
scope = TREE_OPERAND (qualified_id, 0);
|
7676 |
|
|
if (args)
|
7677 |
|
|
{
|
7678 |
|
|
scope = tsubst (scope, args, complain, in_decl);
|
7679 |
|
|
expr = tsubst_copy (name, args, complain, in_decl);
|
7680 |
|
|
}
|
7681 |
|
|
else
|
7682 |
|
|
expr = name;
|
7683 |
|
|
|
7684 |
|
|
if (dependent_type_p (scope))
|
7685 |
|
|
return build_qualified_name (/*type=*/NULL_TREE,
|
7686 |
|
|
scope, expr,
|
7687 |
|
|
QUALIFIED_NAME_IS_TEMPLATE (qualified_id));
|
7688 |
|
|
|
7689 |
|
|
if (!BASELINK_P (name) && !DECL_P (expr))
|
7690 |
|
|
{
|
7691 |
|
|
if (TREE_CODE (expr) == BIT_NOT_EXPR)
|
7692 |
|
|
/* If this were actually a destructor call, it would have been
|
7693 |
|
|
parsed as such by the parser. */
|
7694 |
|
|
expr = error_mark_node;
|
7695 |
|
|
else
|
7696 |
|
|
expr = lookup_qualified_name (scope, expr, /*is_type_p=*/0, false);
|
7697 |
|
|
if (TREE_CODE (TREE_CODE (expr) == TEMPLATE_DECL
|
7698 |
|
|
? DECL_TEMPLATE_RESULT (expr) : expr) == TYPE_DECL)
|
7699 |
|
|
{
|
7700 |
|
|
if (complain & tf_error)
|
7701 |
|
|
{
|
7702 |
|
|
error ("dependent-name %qE is parsed as a non-type, but "
|
7703 |
|
|
"instantiation yields a type", qualified_id);
|
7704 |
|
|
inform ("say %<typename %E%> if a type is meant", qualified_id);
|
7705 |
|
|
}
|
7706 |
|
|
return error_mark_node;
|
7707 |
|
|
}
|
7708 |
|
|
}
|
7709 |
|
|
|
7710 |
|
|
if (DECL_P (expr))
|
7711 |
|
|
{
|
7712 |
|
|
check_accessibility_of_qualified_id (expr, /*object_type=*/NULL_TREE,
|
7713 |
|
|
scope);
|
7714 |
|
|
/* Remember that there was a reference to this entity. */
|
7715 |
|
|
mark_used (expr);
|
7716 |
|
|
}
|
7717 |
|
|
|
7718 |
|
|
if (expr == error_mark_node || TREE_CODE (expr) == TREE_LIST)
|
7719 |
|
|
{
|
7720 |
|
|
if (complain & tf_error)
|
7721 |
|
|
qualified_name_lookup_error (scope,
|
7722 |
|
|
TREE_OPERAND (qualified_id, 1),
|
7723 |
|
|
expr);
|
7724 |
|
|
return error_mark_node;
|
7725 |
|
|
}
|
7726 |
|
|
|
7727 |
|
|
if (is_template)
|
7728 |
|
|
expr = lookup_template_function (expr, template_args);
|
7729 |
|
|
|
7730 |
|
|
if (expr == error_mark_node && complain & tf_error)
|
7731 |
|
|
qualified_name_lookup_error (scope, TREE_OPERAND (qualified_id, 1),
|
7732 |
|
|
expr);
|
7733 |
|
|
else if (TYPE_P (scope))
|
7734 |
|
|
{
|
7735 |
|
|
expr = (adjust_result_of_qualified_name_lookup
|
7736 |
|
|
(expr, scope, current_class_type));
|
7737 |
|
|
expr = (finish_qualified_id_expr
|
7738 |
|
|
(scope, expr, done, address_p,
|
7739 |
|
|
QUALIFIED_NAME_IS_TEMPLATE (qualified_id),
|
7740 |
|
|
/*template_arg_p=*/false));
|
7741 |
|
|
}
|
7742 |
|
|
|
7743 |
|
|
if (TREE_CODE (expr) != SCOPE_REF)
|
7744 |
|
|
expr = convert_from_reference (expr);
|
7745 |
|
|
|
7746 |
|
|
return expr;
|
7747 |
|
|
}
|
7748 |
|
|
|
7749 |
|
|
/* Like tsubst, but deals with expressions. This function just replaces
|
7750 |
|
|
template parms; to finish processing the resultant expression, use
|
7751 |
|
|
tsubst_expr. */
|
7752 |
|
|
|
7753 |
|
|
static tree
|
7754 |
|
|
tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl)
|
7755 |
|
|
{
|
7756 |
|
|
enum tree_code code;
|
7757 |
|
|
tree r;
|
7758 |
|
|
|
7759 |
|
|
if (t == NULL_TREE || t == error_mark_node)
|
7760 |
|
|
return t;
|
7761 |
|
|
|
7762 |
|
|
code = TREE_CODE (t);
|
7763 |
|
|
|
7764 |
|
|
switch (code)
|
7765 |
|
|
{
|
7766 |
|
|
case PARM_DECL:
|
7767 |
|
|
r = retrieve_local_specialization (t);
|
7768 |
|
|
gcc_assert (r != NULL);
|
7769 |
|
|
mark_used (r);
|
7770 |
|
|
return r;
|
7771 |
|
|
|
7772 |
|
|
case CONST_DECL:
|
7773 |
|
|
{
|
7774 |
|
|
tree enum_type;
|
7775 |
|
|
tree v;
|
7776 |
|
|
|
7777 |
|
|
if (DECL_TEMPLATE_PARM_P (t))
|
7778 |
|
|
return tsubst_copy (DECL_INITIAL (t), args, complain, in_decl);
|
7779 |
|
|
/* There is no need to substitute into namespace-scope
|
7780 |
|
|
enumerators. */
|
7781 |
|
|
if (DECL_NAMESPACE_SCOPE_P (t))
|
7782 |
|
|
return t;
|
7783 |
|
|
/* If ARGS is NULL, then T is known to be non-dependent. */
|
7784 |
|
|
if (args == NULL_TREE)
|
7785 |
|
|
return integral_constant_value (t);
|
7786 |
|
|
|
7787 |
|
|
/* Unfortunately, we cannot just call lookup_name here.
|
7788 |
|
|
Consider:
|
7789 |
|
|
|
7790 |
|
|
template <int I> int f() {
|
7791 |
|
|
enum E { a = I };
|
7792 |
|
|
struct S { void g() { E e = a; } };
|
7793 |
|
|
};
|
7794 |
|
|
|
7795 |
|
|
When we instantiate f<7>::S::g(), say, lookup_name is not
|
7796 |
|
|
clever enough to find f<7>::a. */
|
7797 |
|
|
enum_type
|
7798 |
|
|
= tsubst_aggr_type (TREE_TYPE (t), args, complain, in_decl,
|
7799 |
|
|
/*entering_scope=*/0);
|
7800 |
|
|
|
7801 |
|
|
for (v = TYPE_VALUES (enum_type);
|
7802 |
|
|
v != NULL_TREE;
|
7803 |
|
|
v = TREE_CHAIN (v))
|
7804 |
|
|
if (TREE_PURPOSE (v) == DECL_NAME (t))
|
7805 |
|
|
return TREE_VALUE (v);
|
7806 |
|
|
|
7807 |
|
|
/* We didn't find the name. That should never happen; if
|
7808 |
|
|
name-lookup found it during preliminary parsing, we
|
7809 |
|
|
should find it again here during instantiation. */
|
7810 |
|
|
gcc_unreachable ();
|
7811 |
|
|
}
|
7812 |
|
|
return t;
|
7813 |
|
|
|
7814 |
|
|
case FIELD_DECL:
|
7815 |
|
|
if (DECL_CONTEXT (t))
|
7816 |
|
|
{
|
7817 |
|
|
tree ctx;
|
7818 |
|
|
|
7819 |
|
|
ctx = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, in_decl,
|
7820 |
|
|
/*entering_scope=*/1);
|
7821 |
|
|
if (ctx != DECL_CONTEXT (t))
|
7822 |
|
|
{
|
7823 |
|
|
tree r = lookup_field (ctx, DECL_NAME (t), 0, false);
|
7824 |
|
|
if (!r)
|
7825 |
|
|
{
|
7826 |
|
|
if (complain & tf_error)
|
7827 |
|
|
error ("using invalid field %qD", t);
|
7828 |
|
|
return error_mark_node;
|
7829 |
|
|
}
|
7830 |
|
|
return r;
|
7831 |
|
|
}
|
7832 |
|
|
}
|
7833 |
|
|
|
7834 |
|
|
return t;
|
7835 |
|
|
|
7836 |
|
|
case VAR_DECL:
|
7837 |
|
|
case FUNCTION_DECL:
|
7838 |
|
|
if ((DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t))
|
7839 |
|
|
|| local_variable_p (t))
|
7840 |
|
|
t = tsubst (t, args, complain, in_decl);
|
7841 |
|
|
mark_used (t);
|
7842 |
|
|
return t;
|
7843 |
|
|
|
7844 |
|
|
case BASELINK:
|
7845 |
|
|
return tsubst_baselink (t, current_class_type, args, complain, in_decl);
|
7846 |
|
|
|
7847 |
|
|
case TEMPLATE_DECL:
|
7848 |
|
|
if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
|
7849 |
|
|
return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
|
7850 |
|
|
args, complain, in_decl);
|
7851 |
|
|
else if (DECL_FUNCTION_TEMPLATE_P (t) && DECL_MEMBER_TEMPLATE_P (t))
|
7852 |
|
|
return tsubst (t, args, complain, in_decl);
|
7853 |
|
|
else if (DECL_CLASS_SCOPE_P (t)
|
7854 |
|
|
&& uses_template_parms (DECL_CONTEXT (t)))
|
7855 |
|
|
{
|
7856 |
|
|
/* Template template argument like the following example need
|
7857 |
|
|
special treatment:
|
7858 |
|
|
|
7859 |
|
|
template <template <class> class TT> struct C {};
|
7860 |
|
|
template <class T> struct D {
|
7861 |
|
|
template <class U> struct E {};
|
7862 |
|
|
C<E> c; // #1
|
7863 |
|
|
};
|
7864 |
|
|
D<int> d; // #2
|
7865 |
|
|
|
7866 |
|
|
We are processing the template argument `E' in #1 for
|
7867 |
|
|
the template instantiation #2. Originally, `E' is a
|
7868 |
|
|
TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
|
7869 |
|
|
have to substitute this with one having context `D<int>'. */
|
7870 |
|
|
|
7871 |
|
|
tree context = tsubst (DECL_CONTEXT (t), args, complain, in_decl);
|
7872 |
|
|
return lookup_field (context, DECL_NAME(t), 0, false);
|
7873 |
|
|
}
|
7874 |
|
|
else
|
7875 |
|
|
/* Ordinary template template argument. */
|
7876 |
|
|
return t;
|
7877 |
|
|
|
7878 |
|
|
case CAST_EXPR:
|
7879 |
|
|
case REINTERPRET_CAST_EXPR:
|
7880 |
|
|
case CONST_CAST_EXPR:
|
7881 |
|
|
case STATIC_CAST_EXPR:
|
7882 |
|
|
case DYNAMIC_CAST_EXPR:
|
7883 |
|
|
case NOP_EXPR:
|
7884 |
|
|
return build1
|
7885 |
|
|
(code, tsubst (TREE_TYPE (t), args, complain, in_decl),
|
7886 |
|
|
tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
|
7887 |
|
|
|
7888 |
|
|
case INDIRECT_REF:
|
7889 |
|
|
case NEGATE_EXPR:
|
7890 |
|
|
case TRUTH_NOT_EXPR:
|
7891 |
|
|
case BIT_NOT_EXPR:
|
7892 |
|
|
case ADDR_EXPR:
|
7893 |
|
|
case UNARY_PLUS_EXPR: /* Unary + */
|
7894 |
|
|
case SIZEOF_EXPR:
|
7895 |
|
|
case ALIGNOF_EXPR:
|
7896 |
|
|
case ARROW_EXPR:
|
7897 |
|
|
case THROW_EXPR:
|
7898 |
|
|
case TYPEID_EXPR:
|
7899 |
|
|
case REALPART_EXPR:
|
7900 |
|
|
case IMAGPART_EXPR:
|
7901 |
|
|
return build1
|
7902 |
|
|
(code, tsubst (TREE_TYPE (t), args, complain, in_decl),
|
7903 |
|
|
tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
|
7904 |
|
|
|
7905 |
|
|
case COMPONENT_REF:
|
7906 |
|
|
{
|
7907 |
|
|
tree object;
|
7908 |
|
|
tree name;
|
7909 |
|
|
|
7910 |
|
|
object = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
|
7911 |
|
|
name = TREE_OPERAND (t, 1);
|
7912 |
|
|
if (TREE_CODE (name) == BIT_NOT_EXPR)
|
7913 |
|
|
{
|
7914 |
|
|
name = tsubst_copy (TREE_OPERAND (name, 0), args,
|
7915 |
|
|
complain, in_decl);
|
7916 |
|
|
name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
|
7917 |
|
|
}
|
7918 |
|
|
else if (TREE_CODE (name) == SCOPE_REF
|
7919 |
|
|
&& TREE_CODE (TREE_OPERAND (name, 1)) == BIT_NOT_EXPR)
|
7920 |
|
|
{
|
7921 |
|
|
tree base = tsubst_copy (TREE_OPERAND (name, 0), args,
|
7922 |
|
|
complain, in_decl);
|
7923 |
|
|
name = TREE_OPERAND (name, 1);
|
7924 |
|
|
name = tsubst_copy (TREE_OPERAND (name, 0), args,
|
7925 |
|
|
complain, in_decl);
|
7926 |
|
|
name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
|
7927 |
|
|
name = build_qualified_name (/*type=*/NULL_TREE,
|
7928 |
|
|
base, name,
|
7929 |
|
|
/*template_p=*/false);
|
7930 |
|
|
}
|
7931 |
|
|
else if (TREE_CODE (name) == BASELINK)
|
7932 |
|
|
name = tsubst_baselink (name,
|
7933 |
|
|
non_reference (TREE_TYPE (object)),
|
7934 |
|
|
args, complain,
|
7935 |
|
|
in_decl);
|
7936 |
|
|
else
|
7937 |
|
|
name = tsubst_copy (name, args, complain, in_decl);
|
7938 |
|
|
return build_nt (COMPONENT_REF, object, name, NULL_TREE);
|
7939 |
|
|
}
|
7940 |
|
|
|
7941 |
|
|
case PLUS_EXPR:
|
7942 |
|
|
case MINUS_EXPR:
|
7943 |
|
|
case MULT_EXPR:
|
7944 |
|
|
case TRUNC_DIV_EXPR:
|
7945 |
|
|
case CEIL_DIV_EXPR:
|
7946 |
|
|
case FLOOR_DIV_EXPR:
|
7947 |
|
|
case ROUND_DIV_EXPR:
|
7948 |
|
|
case EXACT_DIV_EXPR:
|
7949 |
|
|
case BIT_AND_EXPR:
|
7950 |
|
|
case BIT_IOR_EXPR:
|
7951 |
|
|
case BIT_XOR_EXPR:
|
7952 |
|
|
case TRUNC_MOD_EXPR:
|
7953 |
|
|
case FLOOR_MOD_EXPR:
|
7954 |
|
|
case TRUTH_ANDIF_EXPR:
|
7955 |
|
|
case TRUTH_ORIF_EXPR:
|
7956 |
|
|
case TRUTH_AND_EXPR:
|
7957 |
|
|
case TRUTH_OR_EXPR:
|
7958 |
|
|
case RSHIFT_EXPR:
|
7959 |
|
|
case LSHIFT_EXPR:
|
7960 |
|
|
case RROTATE_EXPR:
|
7961 |
|
|
case LROTATE_EXPR:
|
7962 |
|
|
case EQ_EXPR:
|
7963 |
|
|
case NE_EXPR:
|
7964 |
|
|
case MAX_EXPR:
|
7965 |
|
|
case MIN_EXPR:
|
7966 |
|
|
case LE_EXPR:
|
7967 |
|
|
case GE_EXPR:
|
7968 |
|
|
case LT_EXPR:
|
7969 |
|
|
case GT_EXPR:
|
7970 |
|
|
case COMPOUND_EXPR:
|
7971 |
|
|
case DOTSTAR_EXPR:
|
7972 |
|
|
case MEMBER_REF:
|
7973 |
|
|
case PREDECREMENT_EXPR:
|
7974 |
|
|
case PREINCREMENT_EXPR:
|
7975 |
|
|
case POSTDECREMENT_EXPR:
|
7976 |
|
|
case POSTINCREMENT_EXPR:
|
7977 |
|
|
return build_nt
|
7978 |
|
|
(code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
|
7979 |
|
|
tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
|
7980 |
|
|
|
7981 |
|
|
case SCOPE_REF:
|
7982 |
|
|
return build_qualified_name (/*type=*/NULL_TREE,
|
7983 |
|
|
tsubst_copy (TREE_OPERAND (t, 0),
|
7984 |
|
|
args, complain, in_decl),
|
7985 |
|
|
tsubst_copy (TREE_OPERAND (t, 1),
|
7986 |
|
|
args, complain, in_decl),
|
7987 |
|
|
QUALIFIED_NAME_IS_TEMPLATE (t));
|
7988 |
|
|
|
7989 |
|
|
case ARRAY_REF:
|
7990 |
|
|
return build_nt
|
7991 |
|
|
(ARRAY_REF,
|
7992 |
|
|
tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
|
7993 |
|
|
tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
|
7994 |
|
|
NULL_TREE, NULL_TREE);
|
7995 |
|
|
|
7996 |
|
|
case CALL_EXPR:
|
7997 |
|
|
return build_nt (code,
|
7998 |
|
|
tsubst_copy (TREE_OPERAND (t, 0), args,
|
7999 |
|
|
complain, in_decl),
|
8000 |
|
|
tsubst_copy (TREE_OPERAND (t, 1), args, complain,
|
8001 |
|
|
in_decl),
|
8002 |
|
|
NULL_TREE);
|
8003 |
|
|
|
8004 |
|
|
case COND_EXPR:
|
8005 |
|
|
case MODOP_EXPR:
|
8006 |
|
|
case PSEUDO_DTOR_EXPR:
|
8007 |
|
|
{
|
8008 |
|
|
r = build_nt
|
8009 |
|
|
(code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
|
8010 |
|
|
tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
|
8011 |
|
|
tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
|
8012 |
|
|
TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
|
8013 |
|
|
return r;
|
8014 |
|
|
}
|
8015 |
|
|
|
8016 |
|
|
case NEW_EXPR:
|
8017 |
|
|
{
|
8018 |
|
|
r = build_nt
|
8019 |
|
|
(code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
|
8020 |
|
|
tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
|
8021 |
|
|
tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
|
8022 |
|
|
NEW_EXPR_USE_GLOBAL (r) = NEW_EXPR_USE_GLOBAL (t);
|
8023 |
|
|
return r;
|
8024 |
|
|
}
|
8025 |
|
|
|
8026 |
|
|
case DELETE_EXPR:
|
8027 |
|
|
{
|
8028 |
|
|
r = build_nt
|
8029 |
|
|
(code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
|
8030 |
|
|
tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
|
8031 |
|
|
DELETE_EXPR_USE_GLOBAL (r) = DELETE_EXPR_USE_GLOBAL (t);
|
8032 |
|
|
DELETE_EXPR_USE_VEC (r) = DELETE_EXPR_USE_VEC (t);
|
8033 |
|
|
return r;
|
8034 |
|
|
}
|
8035 |
|
|
|
8036 |
|
|
case TEMPLATE_ID_EXPR:
|
8037 |
|
|
{
|
8038 |
|
|
/* Substituted template arguments */
|
8039 |
|
|
tree fn = TREE_OPERAND (t, 0);
|
8040 |
|
|
tree targs = TREE_OPERAND (t, 1);
|
8041 |
|
|
|
8042 |
|
|
fn = tsubst_copy (fn, args, complain, in_decl);
|
8043 |
|
|
if (targs)
|
8044 |
|
|
targs = tsubst_template_args (targs, args, complain, in_decl);
|
8045 |
|
|
|
8046 |
|
|
return lookup_template_function (fn, targs);
|
8047 |
|
|
}
|
8048 |
|
|
|
8049 |
|
|
case TREE_LIST:
|
8050 |
|
|
{
|
8051 |
|
|
tree purpose, value, chain;
|
8052 |
|
|
|
8053 |
|
|
if (t == void_list_node)
|
8054 |
|
|
return t;
|
8055 |
|
|
|
8056 |
|
|
purpose = TREE_PURPOSE (t);
|
8057 |
|
|
if (purpose)
|
8058 |
|
|
purpose = tsubst_copy (purpose, args, complain, in_decl);
|
8059 |
|
|
value = TREE_VALUE (t);
|
8060 |
|
|
if (value)
|
8061 |
|
|
value = tsubst_copy (value, args, complain, in_decl);
|
8062 |
|
|
chain = TREE_CHAIN (t);
|
8063 |
|
|
if (chain && chain != void_type_node)
|
8064 |
|
|
chain = tsubst_copy (chain, args, complain, in_decl);
|
8065 |
|
|
if (purpose == TREE_PURPOSE (t)
|
8066 |
|
|
&& value == TREE_VALUE (t)
|
8067 |
|
|
&& chain == TREE_CHAIN (t))
|
8068 |
|
|
return t;
|
8069 |
|
|
return tree_cons (purpose, value, chain);
|
8070 |
|
|
}
|
8071 |
|
|
|
8072 |
|
|
case RECORD_TYPE:
|
8073 |
|
|
case UNION_TYPE:
|
8074 |
|
|
case ENUMERAL_TYPE:
|
8075 |
|
|
case INTEGER_TYPE:
|
8076 |
|
|
case TEMPLATE_TYPE_PARM:
|
8077 |
|
|
case TEMPLATE_TEMPLATE_PARM:
|
8078 |
|
|
case BOUND_TEMPLATE_TEMPLATE_PARM:
|
8079 |
|
|
case TEMPLATE_PARM_INDEX:
|
8080 |
|
|
case POINTER_TYPE:
|
8081 |
|
|
case REFERENCE_TYPE:
|
8082 |
|
|
case OFFSET_TYPE:
|
8083 |
|
|
case FUNCTION_TYPE:
|
8084 |
|
|
case METHOD_TYPE:
|
8085 |
|
|
case ARRAY_TYPE:
|
8086 |
|
|
case TYPENAME_TYPE:
|
8087 |
|
|
case UNBOUND_CLASS_TEMPLATE:
|
8088 |
|
|
case TYPEOF_TYPE:
|
8089 |
|
|
case TYPE_DECL:
|
8090 |
|
|
return tsubst (t, args, complain, in_decl);
|
8091 |
|
|
|
8092 |
|
|
case IDENTIFIER_NODE:
|
8093 |
|
|
if (IDENTIFIER_TYPENAME_P (t))
|
8094 |
|
|
{
|
8095 |
|
|
tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
|
8096 |
|
|
return mangle_conv_op_name_for_type (new_type);
|
8097 |
|
|
}
|
8098 |
|
|
else
|
8099 |
|
|
return t;
|
8100 |
|
|
|
8101 |
|
|
case CONSTRUCTOR:
|
8102 |
|
|
/* This is handled by tsubst_copy_and_build. */
|
8103 |
|
|
gcc_unreachable ();
|
8104 |
|
|
|
8105 |
|
|
case VA_ARG_EXPR:
|
8106 |
|
|
return build_x_va_arg (tsubst_copy (TREE_OPERAND (t, 0), args, complain,
|
8107 |
|
|
in_decl),
|
8108 |
|
|
tsubst (TREE_TYPE (t), args, complain, in_decl));
|
8109 |
|
|
|
8110 |
|
|
case CLEANUP_POINT_EXPR:
|
8111 |
|
|
/* We shouldn't have built any of these during initial template
|
8112 |
|
|
generation. Instead, they should be built during instantiation
|
8113 |
|
|
in response to the saved STMT_IS_FULL_EXPR_P setting. */
|
8114 |
|
|
gcc_unreachable ();
|
8115 |
|
|
|
8116 |
|
|
case OFFSET_REF:
|
8117 |
|
|
mark_used (TREE_OPERAND (t, 1));
|
8118 |
|
|
return t;
|
8119 |
|
|
|
8120 |
|
|
default:
|
8121 |
|
|
return t;
|
8122 |
|
|
}
|
8123 |
|
|
}
|
8124 |
|
|
|
8125 |
|
|
/* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
|
8126 |
|
|
|
8127 |
|
|
static tree
|
8128 |
|
|
tsubst_copy_asm_operands (tree t, tree args, tsubst_flags_t complain,
|
8129 |
|
|
tree in_decl)
|
8130 |
|
|
{
|
8131 |
|
|
#define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
|
8132 |
|
|
|
8133 |
|
|
tree purpose, value, chain;
|
8134 |
|
|
|
8135 |
|
|
if (t == NULL)
|
8136 |
|
|
return t;
|
8137 |
|
|
|
8138 |
|
|
if (TREE_CODE (t) != TREE_LIST)
|
8139 |
|
|
return tsubst_copy_and_build (t, args, complain, in_decl,
|
8140 |
|
|
/*function_p=*/false);
|
8141 |
|
|
|
8142 |
|
|
if (t == void_list_node)
|
8143 |
|
|
return t;
|
8144 |
|
|
|
8145 |
|
|
purpose = TREE_PURPOSE (t);
|
8146 |
|
|
if (purpose)
|
8147 |
|
|
purpose = RECUR (purpose);
|
8148 |
|
|
value = TREE_VALUE (t);
|
8149 |
|
|
if (value)
|
8150 |
|
|
value = RECUR (value);
|
8151 |
|
|
chain = TREE_CHAIN (t);
|
8152 |
|
|
if (chain && chain != void_type_node)
|
8153 |
|
|
chain = RECUR (chain);
|
8154 |
|
|
return tree_cons (purpose, value, chain);
|
8155 |
|
|
#undef RECUR
|
8156 |
|
|
}
|
8157 |
|
|
|
8158 |
|
|
/* Like tsubst_copy for expressions, etc. but also does semantic
|
8159 |
|
|
processing. */
|
8160 |
|
|
|
8161 |
|
|
static tree
|
8162 |
|
|
tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl)
|
8163 |
|
|
{
|
8164 |
|
|
tree stmt, tmp;
|
8165 |
|
|
|
8166 |
|
|
if (t == NULL_TREE || t == error_mark_node)
|
8167 |
|
|
return t;
|
8168 |
|
|
|
8169 |
|
|
if (EXPR_HAS_LOCATION (t))
|
8170 |
|
|
input_location = EXPR_LOCATION (t);
|
8171 |
|
|
if (STATEMENT_CODE_P (TREE_CODE (t)))
|
8172 |
|
|
current_stmt_tree ()->stmts_are_full_exprs_p = STMT_IS_FULL_EXPR_P (t);
|
8173 |
|
|
|
8174 |
|
|
switch (TREE_CODE (t))
|
8175 |
|
|
{
|
8176 |
|
|
case STATEMENT_LIST:
|
8177 |
|
|
{
|
8178 |
|
|
tree_stmt_iterator i;
|
8179 |
|
|
for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
|
8180 |
|
|
tsubst_expr (tsi_stmt (i), args, complain, in_decl);
|
8181 |
|
|
break;
|
8182 |
|
|
}
|
8183 |
|
|
|
8184 |
|
|
case CTOR_INITIALIZER:
|
8185 |
|
|
finish_mem_initializers (tsubst_initializer_list
|
8186 |
|
|
(TREE_OPERAND (t, 0), args));
|
8187 |
|
|
break;
|
8188 |
|
|
|
8189 |
|
|
case RETURN_EXPR:
|
8190 |
|
|
finish_return_stmt (tsubst_expr (TREE_OPERAND (t, 0),
|
8191 |
|
|
args, complain, in_decl));
|
8192 |
|
|
break;
|
8193 |
|
|
|
8194 |
|
|
case EXPR_STMT:
|
8195 |
|
|
tmp = tsubst_expr (EXPR_STMT_EXPR (t), args, complain, in_decl);
|
8196 |
|
|
if (EXPR_STMT_STMT_EXPR_RESULT (t))
|
8197 |
|
|
finish_stmt_expr_expr (tmp, cur_stmt_expr);
|
8198 |
|
|
else
|
8199 |
|
|
finish_expr_stmt (tmp);
|
8200 |
|
|
break;
|
8201 |
|
|
|
8202 |
|
|
case USING_STMT:
|
8203 |
|
|
do_using_directive (tsubst_expr (USING_STMT_NAMESPACE (t),
|
8204 |
|
|
args, complain, in_decl));
|
8205 |
|
|
break;
|
8206 |
|
|
|
8207 |
|
|
case DECL_EXPR:
|
8208 |
|
|
{
|
8209 |
|
|
tree decl;
|
8210 |
|
|
tree init;
|
8211 |
|
|
|
8212 |
|
|
decl = DECL_EXPR_DECL (t);
|
8213 |
|
|
if (TREE_CODE (decl) == LABEL_DECL)
|
8214 |
|
|
finish_label_decl (DECL_NAME (decl));
|
8215 |
|
|
else if (TREE_CODE (decl) == USING_DECL)
|
8216 |
|
|
{
|
8217 |
|
|
tree scope = USING_DECL_SCOPE (decl);
|
8218 |
|
|
tree name = DECL_NAME (decl);
|
8219 |
|
|
tree decl;
|
8220 |
|
|
|
8221 |
|
|
scope = tsubst_expr (scope, args, complain, in_decl);
|
8222 |
|
|
decl = lookup_qualified_name (scope, name,
|
8223 |
|
|
/*is_type_p=*/false,
|
8224 |
|
|
/*complain=*/false);
|
8225 |
|
|
if (decl == error_mark_node || TREE_CODE (decl) == TREE_LIST)
|
8226 |
|
|
qualified_name_lookup_error (scope, name, decl);
|
8227 |
|
|
else
|
8228 |
|
|
do_local_using_decl (decl, scope, name);
|
8229 |
|
|
}
|
8230 |
|
|
else
|
8231 |
|
|
{
|
8232 |
|
|
init = DECL_INITIAL (decl);
|
8233 |
|
|
decl = tsubst (decl, args, complain, in_decl);
|
8234 |
|
|
if (decl != error_mark_node)
|
8235 |
|
|
{
|
8236 |
|
|
if (init)
|
8237 |
|
|
DECL_INITIAL (decl) = error_mark_node;
|
8238 |
|
|
/* By marking the declaration as instantiated, we avoid
|
8239 |
|
|
trying to instantiate it. Since instantiate_decl can't
|
8240 |
|
|
handle local variables, and since we've already done
|
8241 |
|
|
all that needs to be done, that's the right thing to
|
8242 |
|
|
do. */
|
8243 |
|
|
if (TREE_CODE (decl) == VAR_DECL)
|
8244 |
|
|
DECL_TEMPLATE_INSTANTIATED (decl) = 1;
|
8245 |
|
|
if (TREE_CODE (decl) == VAR_DECL
|
8246 |
|
|
&& ANON_AGGR_TYPE_P (TREE_TYPE (decl)))
|
8247 |
|
|
/* Anonymous aggregates are a special case. */
|
8248 |
|
|
finish_anon_union (decl);
|
8249 |
|
|
else
|
8250 |
|
|
{
|
8251 |
|
|
maybe_push_decl (decl);
|
8252 |
|
|
if (TREE_CODE (decl) == VAR_DECL
|
8253 |
|
|
&& DECL_PRETTY_FUNCTION_P (decl))
|
8254 |
|
|
{
|
8255 |
|
|
/* For __PRETTY_FUNCTION__ we have to adjust the
|
8256 |
|
|
initializer. */
|
8257 |
|
|
const char *const name
|
8258 |
|
|
= cxx_printable_name (current_function_decl, 2);
|
8259 |
|
|
init = cp_fname_init (name, &TREE_TYPE (decl));
|
8260 |
|
|
}
|
8261 |
|
|
else
|
8262 |
|
|
init = tsubst_expr (init, args, complain, in_decl);
|
8263 |
|
|
finish_decl (decl, init, NULL_TREE);
|
8264 |
|
|
}
|
8265 |
|
|
}
|
8266 |
|
|
}
|
8267 |
|
|
|
8268 |
|
|
/* A DECL_EXPR can also be used as an expression, in the condition
|
8269 |
|
|
clause of an if/for/while construct. */
|
8270 |
|
|
return decl;
|
8271 |
|
|
}
|
8272 |
|
|
|
8273 |
|
|
case FOR_STMT:
|
8274 |
|
|
stmt = begin_for_stmt ();
|
8275 |
|
|
tsubst_expr (FOR_INIT_STMT (t), args, complain, in_decl);
|
8276 |
|
|
finish_for_init_stmt (stmt);
|
8277 |
|
|
tmp = tsubst_expr (FOR_COND (t), args, complain, in_decl);
|
8278 |
|
|
finish_for_cond (tmp, stmt);
|
8279 |
|
|
tmp = tsubst_expr (FOR_EXPR (t), args, complain, in_decl);
|
8280 |
|
|
finish_for_expr (tmp, stmt);
|
8281 |
|
|
tsubst_expr (FOR_BODY (t), args, complain, in_decl);
|
8282 |
|
|
finish_for_stmt (stmt);
|
8283 |
|
|
break;
|
8284 |
|
|
|
8285 |
|
|
case WHILE_STMT:
|
8286 |
|
|
stmt = begin_while_stmt ();
|
8287 |
|
|
tmp = tsubst_expr (WHILE_COND (t), args, complain, in_decl);
|
8288 |
|
|
finish_while_stmt_cond (tmp, stmt);
|
8289 |
|
|
tsubst_expr (WHILE_BODY (t), args, complain, in_decl);
|
8290 |
|
|
finish_while_stmt (stmt);
|
8291 |
|
|
break;
|
8292 |
|
|
|
8293 |
|
|
case DO_STMT:
|
8294 |
|
|
stmt = begin_do_stmt ();
|
8295 |
|
|
tsubst_expr (DO_BODY (t), args, complain, in_decl);
|
8296 |
|
|
finish_do_body (stmt);
|
8297 |
|
|
tmp = tsubst_expr (DO_COND (t), args, complain, in_decl);
|
8298 |
|
|
finish_do_stmt (tmp, stmt);
|
8299 |
|
|
break;
|
8300 |
|
|
|
8301 |
|
|
case IF_STMT:
|
8302 |
|
|
stmt = begin_if_stmt ();
|
8303 |
|
|
tmp = tsubst_expr (IF_COND (t), args, complain, in_decl);
|
8304 |
|
|
finish_if_stmt_cond (tmp, stmt);
|
8305 |
|
|
tsubst_expr (THEN_CLAUSE (t), args, complain, in_decl);
|
8306 |
|
|
finish_then_clause (stmt);
|
8307 |
|
|
|
8308 |
|
|
if (ELSE_CLAUSE (t))
|
8309 |
|
|
{
|
8310 |
|
|
begin_else_clause (stmt);
|
8311 |
|
|
tsubst_expr (ELSE_CLAUSE (t), args, complain, in_decl);
|
8312 |
|
|
finish_else_clause (stmt);
|
8313 |
|
|
}
|
8314 |
|
|
|
8315 |
|
|
finish_if_stmt (stmt);
|
8316 |
|
|
break;
|
8317 |
|
|
|
8318 |
|
|
case BIND_EXPR:
|
8319 |
|
|
if (BIND_EXPR_BODY_BLOCK (t))
|
8320 |
|
|
stmt = begin_function_body ();
|
8321 |
|
|
else
|
8322 |
|
|
stmt = begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t)
|
8323 |
|
|
? BCS_TRY_BLOCK : 0);
|
8324 |
|
|
|
8325 |
|
|
tsubst_expr (BIND_EXPR_BODY (t), args, complain, in_decl);
|
8326 |
|
|
|
8327 |
|
|
if (BIND_EXPR_BODY_BLOCK (t))
|
8328 |
|
|
finish_function_body (stmt);
|
8329 |
|
|
else
|
8330 |
|
|
finish_compound_stmt (stmt);
|
8331 |
|
|
break;
|
8332 |
|
|
|
8333 |
|
|
case BREAK_STMT:
|
8334 |
|
|
finish_break_stmt ();
|
8335 |
|
|
break;
|
8336 |
|
|
|
8337 |
|
|
case CONTINUE_STMT:
|
8338 |
|
|
finish_continue_stmt ();
|
8339 |
|
|
break;
|
8340 |
|
|
|
8341 |
|
|
case SWITCH_STMT:
|
8342 |
|
|
stmt = begin_switch_stmt ();
|
8343 |
|
|
tmp = tsubst_expr (SWITCH_STMT_COND (t), args, complain, in_decl);
|
8344 |
|
|
finish_switch_cond (tmp, stmt);
|
8345 |
|
|
tsubst_expr (SWITCH_STMT_BODY (t), args, complain, in_decl);
|
8346 |
|
|
finish_switch_stmt (stmt);
|
8347 |
|
|
break;
|
8348 |
|
|
|
8349 |
|
|
case CASE_LABEL_EXPR:
|
8350 |
|
|
finish_case_label (tsubst_expr (CASE_LOW (t), args, complain, in_decl),
|
8351 |
|
|
tsubst_expr (CASE_HIGH (t), args, complain,
|
8352 |
|
|
in_decl));
|
8353 |
|
|
break;
|
8354 |
|
|
|
8355 |
|
|
case LABEL_EXPR:
|
8356 |
|
|
finish_label_stmt (DECL_NAME (LABEL_EXPR_LABEL (t)));
|
8357 |
|
|
break;
|
8358 |
|
|
|
8359 |
|
|
case GOTO_EXPR:
|
8360 |
|
|
tmp = GOTO_DESTINATION (t);
|
8361 |
|
|
if (TREE_CODE (tmp) != LABEL_DECL)
|
8362 |
|
|
/* Computed goto's must be tsubst'd into. On the other hand,
|
8363 |
|
|
non-computed gotos must not be; the identifier in question
|
8364 |
|
|
will have no binding. */
|
8365 |
|
|
tmp = tsubst_expr (tmp, args, complain, in_decl);
|
8366 |
|
|
else
|
8367 |
|
|
tmp = DECL_NAME (tmp);
|
8368 |
|
|
finish_goto_stmt (tmp);
|
8369 |
|
|
break;
|
8370 |
|
|
|
8371 |
|
|
case ASM_EXPR:
|
8372 |
|
|
tmp = finish_asm_stmt
|
8373 |
|
|
(ASM_VOLATILE_P (t),
|
8374 |
|
|
tsubst_expr (ASM_STRING (t), args, complain, in_decl),
|
8375 |
|
|
tsubst_copy_asm_operands (ASM_OUTPUTS (t), args, complain, in_decl),
|
8376 |
|
|
tsubst_copy_asm_operands (ASM_INPUTS (t), args, complain, in_decl),
|
8377 |
|
|
tsubst_copy_asm_operands (ASM_CLOBBERS (t), args, complain, in_decl));
|
8378 |
|
|
{
|
8379 |
|
|
tree asm_expr = tmp;
|
8380 |
|
|
if (TREE_CODE (asm_expr) == CLEANUP_POINT_EXPR)
|
8381 |
|
|
asm_expr = TREE_OPERAND (asm_expr, 0);
|
8382 |
|
|
ASM_INPUT_P (asm_expr) = ASM_INPUT_P (t);
|
8383 |
|
|
}
|
8384 |
|
|
break;
|
8385 |
|
|
|
8386 |
|
|
case TRY_BLOCK:
|
8387 |
|
|
if (CLEANUP_P (t))
|
8388 |
|
|
{
|
8389 |
|
|
stmt = begin_try_block ();
|
8390 |
|
|
tsubst_expr (TRY_STMTS (t), args, complain, in_decl);
|
8391 |
|
|
finish_cleanup_try_block (stmt);
|
8392 |
|
|
finish_cleanup (tsubst_expr (TRY_HANDLERS (t), args,
|
8393 |
|
|
complain, in_decl),
|
8394 |
|
|
stmt);
|
8395 |
|
|
}
|
8396 |
|
|
else
|
8397 |
|
|
{
|
8398 |
|
|
if (FN_TRY_BLOCK_P (t))
|
8399 |
|
|
stmt = begin_function_try_block ();
|
8400 |
|
|
else
|
8401 |
|
|
stmt = begin_try_block ();
|
8402 |
|
|
|
8403 |
|
|
tsubst_expr (TRY_STMTS (t), args, complain, in_decl);
|
8404 |
|
|
|
8405 |
|
|
if (FN_TRY_BLOCK_P (t))
|
8406 |
|
|
finish_function_try_block (stmt);
|
8407 |
|
|
else
|
8408 |
|
|
finish_try_block (stmt);
|
8409 |
|
|
|
8410 |
|
|
tsubst_expr (TRY_HANDLERS (t), args, complain, in_decl);
|
8411 |
|
|
if (FN_TRY_BLOCK_P (t))
|
8412 |
|
|
finish_function_handler_sequence (stmt);
|
8413 |
|
|
else
|
8414 |
|
|
finish_handler_sequence (stmt);
|
8415 |
|
|
}
|
8416 |
|
|
break;
|
8417 |
|
|
|
8418 |
|
|
case HANDLER:
|
8419 |
|
|
{
|
8420 |
|
|
tree decl;
|
8421 |
|
|
|
8422 |
|
|
stmt = begin_handler ();
|
8423 |
|
|
if (HANDLER_PARMS (t))
|
8424 |
|
|
{
|
8425 |
|
|
decl = HANDLER_PARMS (t);
|
8426 |
|
|
decl = tsubst (decl, args, complain, in_decl);
|
8427 |
|
|
/* Prevent instantiate_decl from trying to instantiate
|
8428 |
|
|
this variable. We've already done all that needs to be
|
8429 |
|
|
done. */
|
8430 |
|
|
DECL_TEMPLATE_INSTANTIATED (decl) = 1;
|
8431 |
|
|
}
|
8432 |
|
|
else
|
8433 |
|
|
decl = NULL_TREE;
|
8434 |
|
|
finish_handler_parms (decl, stmt);
|
8435 |
|
|
tsubst_expr (HANDLER_BODY (t), args, complain, in_decl);
|
8436 |
|
|
finish_handler (stmt);
|
8437 |
|
|
}
|
8438 |
|
|
break;
|
8439 |
|
|
|
8440 |
|
|
case TAG_DEFN:
|
8441 |
|
|
tsubst (TREE_TYPE (t), args, complain, NULL_TREE);
|
8442 |
|
|
break;
|
8443 |
|
|
|
8444 |
|
|
default:
|
8445 |
|
|
gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t)));
|
8446 |
|
|
|
8447 |
|
|
return tsubst_copy_and_build (t, args, complain, in_decl,
|
8448 |
|
|
/*function_p=*/false);
|
8449 |
|
|
}
|
8450 |
|
|
|
8451 |
|
|
return NULL_TREE;
|
8452 |
|
|
}
|
8453 |
|
|
|
8454 |
|
|
/* T is a postfix-expression that is not being used in a function
|
8455 |
|
|
call. Return the substituted version of T. */
|
8456 |
|
|
|
8457 |
|
|
static tree
|
8458 |
|
|
tsubst_non_call_postfix_expression (tree t, tree args,
|
8459 |
|
|
tsubst_flags_t complain,
|
8460 |
|
|
tree in_decl)
|
8461 |
|
|
{
|
8462 |
|
|
if (TREE_CODE (t) == SCOPE_REF)
|
8463 |
|
|
t = tsubst_qualified_id (t, args, complain, in_decl,
|
8464 |
|
|
/*done=*/false, /*address_p=*/false);
|
8465 |
|
|
else
|
8466 |
|
|
t = tsubst_copy_and_build (t, args, complain, in_decl,
|
8467 |
|
|
/*function_p=*/false);
|
8468 |
|
|
|
8469 |
|
|
return t;
|
8470 |
|
|
}
|
8471 |
|
|
|
8472 |
|
|
/* Like tsubst but deals with expressions and performs semantic
|
8473 |
|
|
analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
|
8474 |
|
|
|
8475 |
|
|
tree
|
8476 |
|
|
tsubst_copy_and_build (tree t,
|
8477 |
|
|
tree args,
|
8478 |
|
|
tsubst_flags_t complain,
|
8479 |
|
|
tree in_decl,
|
8480 |
|
|
bool function_p)
|
8481 |
|
|
{
|
8482 |
|
|
#define RECUR(NODE) \
|
8483 |
|
|
tsubst_copy_and_build (NODE, args, complain, in_decl, /*function_p=*/false)
|
8484 |
|
|
|
8485 |
|
|
tree op1;
|
8486 |
|
|
|
8487 |
|
|
if (t == NULL_TREE || t == error_mark_node)
|
8488 |
|
|
return t;
|
8489 |
|
|
|
8490 |
|
|
switch (TREE_CODE (t))
|
8491 |
|
|
{
|
8492 |
|
|
case USING_DECL:
|
8493 |
|
|
t = DECL_NAME (t);
|
8494 |
|
|
/* Fall through. */
|
8495 |
|
|
case IDENTIFIER_NODE:
|
8496 |
|
|
{
|
8497 |
|
|
tree decl;
|
8498 |
|
|
cp_id_kind idk;
|
8499 |
|
|
bool non_integral_constant_expression_p;
|
8500 |
|
|
const char *error_msg;
|
8501 |
|
|
|
8502 |
|
|
if (IDENTIFIER_TYPENAME_P (t))
|
8503 |
|
|
{
|
8504 |
|
|
tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
|
8505 |
|
|
t = mangle_conv_op_name_for_type (new_type);
|
8506 |
|
|
}
|
8507 |
|
|
|
8508 |
|
|
/* Look up the name. */
|
8509 |
|
|
decl = lookup_name (t, 0);
|
8510 |
|
|
|
8511 |
|
|
/* By convention, expressions use ERROR_MARK_NODE to indicate
|
8512 |
|
|
failure, not NULL_TREE. */
|
8513 |
|
|
if (decl == NULL_TREE)
|
8514 |
|
|
decl = error_mark_node;
|
8515 |
|
|
|
8516 |
|
|
decl = finish_id_expression (t, decl, NULL_TREE,
|
8517 |
|
|
&idk,
|
8518 |
|
|
/*integral_constant_expression_p=*/false,
|
8519 |
|
|
/*allow_non_integral_constant_expression_p=*/false,
|
8520 |
|
|
&non_integral_constant_expression_p,
|
8521 |
|
|
/*template_p=*/false,
|
8522 |
|
|
/*done=*/true,
|
8523 |
|
|
/*address_p=*/false,
|
8524 |
|
|
/*template_arg_p=*/false,
|
8525 |
|
|
&error_msg);
|
8526 |
|
|
if (error_msg)
|
8527 |
|
|
error (error_msg);
|
8528 |
|
|
if (!function_p && TREE_CODE (decl) == IDENTIFIER_NODE)
|
8529 |
|
|
decl = unqualified_name_lookup_error (decl);
|
8530 |
|
|
return decl;
|
8531 |
|
|
}
|
8532 |
|
|
|
8533 |
|
|
case TEMPLATE_ID_EXPR:
|
8534 |
|
|
{
|
8535 |
|
|
tree object;
|
8536 |
|
|
tree template = RECUR (TREE_OPERAND (t, 0));
|
8537 |
|
|
tree targs = TREE_OPERAND (t, 1);
|
8538 |
|
|
|
8539 |
|
|
if (targs)
|
8540 |
|
|
targs = tsubst_template_args (targs, args, complain, in_decl);
|
8541 |
|
|
|
8542 |
|
|
if (TREE_CODE (template) == COMPONENT_REF)
|
8543 |
|
|
{
|
8544 |
|
|
object = TREE_OPERAND (template, 0);
|
8545 |
|
|
template = TREE_OPERAND (template, 1);
|
8546 |
|
|
}
|
8547 |
|
|
else
|
8548 |
|
|
object = NULL_TREE;
|
8549 |
|
|
template = lookup_template_function (template, targs);
|
8550 |
|
|
|
8551 |
|
|
if (object)
|
8552 |
|
|
return build3 (COMPONENT_REF, TREE_TYPE (template),
|
8553 |
|
|
object, template, NULL_TREE);
|
8554 |
|
|
else
|
8555 |
|
|
return template;
|
8556 |
|
|
}
|
8557 |
|
|
|
8558 |
|
|
case INDIRECT_REF:
|
8559 |
|
|
{
|
8560 |
|
|
tree r = RECUR (TREE_OPERAND (t, 0));
|
8561 |
|
|
|
8562 |
|
|
if (REFERENCE_REF_P (t))
|
8563 |
|
|
{
|
8564 |
|
|
/* A type conversion to reference type will be enclosed in
|
8565 |
|
|
such an indirect ref, but the substitution of the cast
|
8566 |
|
|
will have also added such an indirect ref. */
|
8567 |
|
|
if (TREE_CODE (TREE_TYPE (r)) == REFERENCE_TYPE)
|
8568 |
|
|
r = convert_from_reference (r);
|
8569 |
|
|
}
|
8570 |
|
|
else
|
8571 |
|
|
r = build_x_indirect_ref (r, "unary *");
|
8572 |
|
|
return r;
|
8573 |
|
|
}
|
8574 |
|
|
|
8575 |
|
|
case NOP_EXPR:
|
8576 |
|
|
return build_nop
|
8577 |
|
|
(tsubst (TREE_TYPE (t), args, complain, in_decl),
|
8578 |
|
|
RECUR (TREE_OPERAND (t, 0)));
|
8579 |
|
|
|
8580 |
|
|
case CAST_EXPR:
|
8581 |
|
|
return build_functional_cast
|
8582 |
|
|
(tsubst (TREE_TYPE (t), args, complain, in_decl),
|
8583 |
|
|
RECUR (TREE_OPERAND (t, 0)));
|
8584 |
|
|
|
8585 |
|
|
case REINTERPRET_CAST_EXPR:
|
8586 |
|
|
return build_reinterpret_cast
|
8587 |
|
|
(tsubst (TREE_TYPE (t), args, complain, in_decl),
|
8588 |
|
|
RECUR (TREE_OPERAND (t, 0)));
|
8589 |
|
|
|
8590 |
|
|
case CONST_CAST_EXPR:
|
8591 |
|
|
return build_const_cast
|
8592 |
|
|
(tsubst (TREE_TYPE (t), args, complain, in_decl),
|
8593 |
|
|
RECUR (TREE_OPERAND (t, 0)));
|
8594 |
|
|
|
8595 |
|
|
case DYNAMIC_CAST_EXPR:
|
8596 |
|
|
return build_dynamic_cast
|
8597 |
|
|
(tsubst (TREE_TYPE (t), args, complain, in_decl),
|
8598 |
|
|
RECUR (TREE_OPERAND (t, 0)));
|
8599 |
|
|
|
8600 |
|
|
case STATIC_CAST_EXPR:
|
8601 |
|
|
return build_static_cast
|
8602 |
|
|
(tsubst (TREE_TYPE (t), args, complain, in_decl),
|
8603 |
|
|
RECUR (TREE_OPERAND (t, 0)));
|
8604 |
|
|
|
8605 |
|
|
case POSTDECREMENT_EXPR:
|
8606 |
|
|
case POSTINCREMENT_EXPR:
|
8607 |
|
|
op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
|
8608 |
|
|
args, complain, in_decl);
|
8609 |
|
|
return build_x_unary_op (TREE_CODE (t), op1);
|
8610 |
|
|
|
8611 |
|
|
case PREDECREMENT_EXPR:
|
8612 |
|
|
case PREINCREMENT_EXPR:
|
8613 |
|
|
case NEGATE_EXPR:
|
8614 |
|
|
case BIT_NOT_EXPR:
|
8615 |
|
|
case ABS_EXPR:
|
8616 |
|
|
case TRUTH_NOT_EXPR:
|
8617 |
|
|
case UNARY_PLUS_EXPR: /* Unary + */
|
8618 |
|
|
case REALPART_EXPR:
|
8619 |
|
|
case IMAGPART_EXPR:
|
8620 |
|
|
return build_x_unary_op (TREE_CODE (t), RECUR (TREE_OPERAND (t, 0)));
|
8621 |
|
|
|
8622 |
|
|
case ADDR_EXPR:
|
8623 |
|
|
op1 = TREE_OPERAND (t, 0);
|
8624 |
|
|
if (TREE_CODE (op1) == SCOPE_REF)
|
8625 |
|
|
op1 = tsubst_qualified_id (op1, args, complain, in_decl,
|
8626 |
|
|
/*done=*/true, /*address_p=*/true);
|
8627 |
|
|
else
|
8628 |
|
|
op1 = tsubst_non_call_postfix_expression (op1, args, complain,
|
8629 |
|
|
in_decl);
|
8630 |
|
|
if (TREE_CODE (op1) == LABEL_DECL)
|
8631 |
|
|
return finish_label_address_expr (DECL_NAME (op1));
|
8632 |
|
|
return build_x_unary_op (ADDR_EXPR, op1);
|
8633 |
|
|
|
8634 |
|
|
case PLUS_EXPR:
|
8635 |
|
|
case MINUS_EXPR:
|
8636 |
|
|
case MULT_EXPR:
|
8637 |
|
|
case TRUNC_DIV_EXPR:
|
8638 |
|
|
case CEIL_DIV_EXPR:
|
8639 |
|
|
case FLOOR_DIV_EXPR:
|
8640 |
|
|
case ROUND_DIV_EXPR:
|
8641 |
|
|
case EXACT_DIV_EXPR:
|
8642 |
|
|
case BIT_AND_EXPR:
|
8643 |
|
|
case BIT_IOR_EXPR:
|
8644 |
|
|
case BIT_XOR_EXPR:
|
8645 |
|
|
case TRUNC_MOD_EXPR:
|
8646 |
|
|
case FLOOR_MOD_EXPR:
|
8647 |
|
|
case TRUTH_ANDIF_EXPR:
|
8648 |
|
|
case TRUTH_ORIF_EXPR:
|
8649 |
|
|
case TRUTH_AND_EXPR:
|
8650 |
|
|
case TRUTH_OR_EXPR:
|
8651 |
|
|
case RSHIFT_EXPR:
|
8652 |
|
|
case LSHIFT_EXPR:
|
8653 |
|
|
case RROTATE_EXPR:
|
8654 |
|
|
case LROTATE_EXPR:
|
8655 |
|
|
case EQ_EXPR:
|
8656 |
|
|
case NE_EXPR:
|
8657 |
|
|
case MAX_EXPR:
|
8658 |
|
|
case MIN_EXPR:
|
8659 |
|
|
case LE_EXPR:
|
8660 |
|
|
case GE_EXPR:
|
8661 |
|
|
case LT_EXPR:
|
8662 |
|
|
case GT_EXPR:
|
8663 |
|
|
case MEMBER_REF:
|
8664 |
|
|
case DOTSTAR_EXPR:
|
8665 |
|
|
return build_x_binary_op
|
8666 |
|
|
(TREE_CODE (t),
|
8667 |
|
|
RECUR (TREE_OPERAND (t, 0)),
|
8668 |
|
|
RECUR (TREE_OPERAND (t, 1)),
|
8669 |
|
|
/*overloaded_p=*/NULL);
|
8670 |
|
|
|
8671 |
|
|
case SCOPE_REF:
|
8672 |
|
|
return tsubst_qualified_id (t, args, complain, in_decl, /*done=*/true,
|
8673 |
|
|
/*address_p=*/false);
|
8674 |
|
|
case ARRAY_REF:
|
8675 |
|
|
op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
|
8676 |
|
|
args, complain, in_decl);
|
8677 |
|
|
return build_x_binary_op (ARRAY_REF, op1, RECUR (TREE_OPERAND (t, 1)),
|
8678 |
|
|
/*overloaded_p=*/NULL);
|
8679 |
|
|
|
8680 |
|
|
case SIZEOF_EXPR:
|
8681 |
|
|
case ALIGNOF_EXPR:
|
8682 |
|
|
op1 = TREE_OPERAND (t, 0);
|
8683 |
|
|
if (!args)
|
8684 |
|
|
{
|
8685 |
|
|
/* When there are no ARGS, we are trying to evaluate a
|
8686 |
|
|
non-dependent expression from the parser. Trying to do
|
8687 |
|
|
the substitutions may not work. */
|
8688 |
|
|
if (!TYPE_P (op1))
|
8689 |
|
|
op1 = TREE_TYPE (op1);
|
8690 |
|
|
}
|
8691 |
|
|
else
|
8692 |
|
|
{
|
8693 |
|
|
++skip_evaluation;
|
8694 |
|
|
op1 = RECUR (op1);
|
8695 |
|
|
--skip_evaluation;
|
8696 |
|
|
}
|
8697 |
|
|
if (TYPE_P (op1))
|
8698 |
|
|
return cxx_sizeof_or_alignof_type (op1, TREE_CODE (t), true);
|
8699 |
|
|
else
|
8700 |
|
|
return cxx_sizeof_or_alignof_expr (op1, TREE_CODE (t));
|
8701 |
|
|
|
8702 |
|
|
case MODOP_EXPR:
|
8703 |
|
|
{
|
8704 |
|
|
tree r = build_x_modify_expr
|
8705 |
|
|
(RECUR (TREE_OPERAND (t, 0)),
|
8706 |
|
|
TREE_CODE (TREE_OPERAND (t, 1)),
|
8707 |
|
|
RECUR (TREE_OPERAND (t, 2)));
|
8708 |
|
|
/* TREE_NO_WARNING must be set if either the expression was
|
8709 |
|
|
parenthesized or it uses an operator such as >>= rather
|
8710 |
|
|
than plain assignment. In the former case, it was already
|
8711 |
|
|
set and must be copied. In the latter case,
|
8712 |
|
|
build_x_modify_expr sets it and it must not be reset
|
8713 |
|
|
here. */
|
8714 |
|
|
if (TREE_NO_WARNING (t))
|
8715 |
|
|
TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
|
8716 |
|
|
return r;
|
8717 |
|
|
}
|
8718 |
|
|
|
8719 |
|
|
case ARROW_EXPR:
|
8720 |
|
|
op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
|
8721 |
|
|
args, complain, in_decl);
|
8722 |
|
|
/* Remember that there was a reference to this entity. */
|
8723 |
|
|
if (DECL_P (op1))
|
8724 |
|
|
mark_used (op1);
|
8725 |
|
|
return build_x_arrow (op1);
|
8726 |
|
|
|
8727 |
|
|
case NEW_EXPR:
|
8728 |
|
|
return build_new
|
8729 |
|
|
(RECUR (TREE_OPERAND (t, 0)),
|
8730 |
|
|
RECUR (TREE_OPERAND (t, 1)),
|
8731 |
|
|
RECUR (TREE_OPERAND (t, 2)),
|
8732 |
|
|
RECUR (TREE_OPERAND (t, 3)),
|
8733 |
|
|
NEW_EXPR_USE_GLOBAL (t));
|
8734 |
|
|
|
8735 |
|
|
case DELETE_EXPR:
|
8736 |
|
|
return delete_sanity
|
8737 |
|
|
(RECUR (TREE_OPERAND (t, 0)),
|
8738 |
|
|
RECUR (TREE_OPERAND (t, 1)),
|
8739 |
|
|
DELETE_EXPR_USE_VEC (t),
|
8740 |
|
|
DELETE_EXPR_USE_GLOBAL (t));
|
8741 |
|
|
|
8742 |
|
|
case COMPOUND_EXPR:
|
8743 |
|
|
return build_x_compound_expr (RECUR (TREE_OPERAND (t, 0)),
|
8744 |
|
|
RECUR (TREE_OPERAND (t, 1)));
|
8745 |
|
|
|
8746 |
|
|
case CALL_EXPR:
|
8747 |
|
|
{
|
8748 |
|
|
tree function;
|
8749 |
|
|
tree call_args;
|
8750 |
|
|
bool qualified_p;
|
8751 |
|
|
bool koenig_p;
|
8752 |
|
|
|
8753 |
|
|
function = TREE_OPERAND (t, 0);
|
8754 |
|
|
/* When we parsed the expression, we determined whether or
|
8755 |
|
|
not Koenig lookup should be performed. */
|
8756 |
|
|
koenig_p = KOENIG_LOOKUP_P (t);
|
8757 |
|
|
if (TREE_CODE (function) == SCOPE_REF)
|
8758 |
|
|
{
|
8759 |
|
|
qualified_p = true;
|
8760 |
|
|
function = tsubst_qualified_id (function, args, complain, in_decl,
|
8761 |
|
|
/*done=*/false,
|
8762 |
|
|
/*address_p=*/false);
|
8763 |
|
|
}
|
8764 |
|
|
else
|
8765 |
|
|
{
|
8766 |
|
|
if (TREE_CODE (function) == COMPONENT_REF)
|
8767 |
|
|
{
|
8768 |
|
|
tree op = TREE_OPERAND (function, 1);
|
8769 |
|
|
|
8770 |
|
|
qualified_p = (TREE_CODE (op) == SCOPE_REF
|
8771 |
|
|
|| (BASELINK_P (op)
|
8772 |
|
|
&& BASELINK_QUALIFIED_P (op)));
|
8773 |
|
|
}
|
8774 |
|
|
else
|
8775 |
|
|
qualified_p = false;
|
8776 |
|
|
|
8777 |
|
|
function = tsubst_copy_and_build (function, args, complain,
|
8778 |
|
|
in_decl,
|
8779 |
|
|
!qualified_p);
|
8780 |
|
|
if (BASELINK_P (function))
|
8781 |
|
|
qualified_p = true;
|
8782 |
|
|
}
|
8783 |
|
|
|
8784 |
|
|
call_args = RECUR (TREE_OPERAND (t, 1));
|
8785 |
|
|
|
8786 |
|
|
/* We do not perform argument-dependent lookup if normal
|
8787 |
|
|
lookup finds a non-function, in accordance with the
|
8788 |
|
|
expected resolution of DR 218. */
|
8789 |
|
|
if (koenig_p
|
8790 |
|
|
&& ((is_overloaded_fn (function)
|
8791 |
|
|
/* If lookup found a member function, the Koenig lookup is
|
8792 |
|
|
not appropriate, even if an unqualified-name was used
|
8793 |
|
|
to denote the function. */
|
8794 |
|
|
&& !DECL_FUNCTION_MEMBER_P (get_first_fn (function)))
|
8795 |
|
|
|| TREE_CODE (function) == IDENTIFIER_NODE))
|
8796 |
|
|
function = perform_koenig_lookup (function, call_args);
|
8797 |
|
|
|
8798 |
|
|
if (TREE_CODE (function) == IDENTIFIER_NODE)
|
8799 |
|
|
{
|
8800 |
|
|
unqualified_name_lookup_error (function);
|
8801 |
|
|
return error_mark_node;
|
8802 |
|
|
}
|
8803 |
|
|
|
8804 |
|
|
/* Remember that there was a reference to this entity. */
|
8805 |
|
|
if (DECL_P (function))
|
8806 |
|
|
mark_used (function);
|
8807 |
|
|
|
8808 |
|
|
if (TREE_CODE (function) == OFFSET_REF)
|
8809 |
|
|
return build_offset_ref_call_from_tree (function, call_args);
|
8810 |
|
|
if (TREE_CODE (function) == COMPONENT_REF)
|
8811 |
|
|
{
|
8812 |
|
|
if (!BASELINK_P (TREE_OPERAND (function, 1)))
|
8813 |
|
|
return finish_call_expr (function, call_args,
|
8814 |
|
|
/*disallow_virtual=*/false,
|
8815 |
|
|
/*koenig_p=*/false);
|
8816 |
|
|
else
|
8817 |
|
|
return (build_new_method_call
|
8818 |
|
|
(TREE_OPERAND (function, 0),
|
8819 |
|
|
TREE_OPERAND (function, 1),
|
8820 |
|
|
call_args, NULL_TREE,
|
8821 |
|
|
qualified_p ? LOOKUP_NONVIRTUAL : LOOKUP_NORMAL));
|
8822 |
|
|
}
|
8823 |
|
|
return finish_call_expr (function, call_args,
|
8824 |
|
|
/*disallow_virtual=*/qualified_p,
|
8825 |
|
|
koenig_p);
|
8826 |
|
|
}
|
8827 |
|
|
|
8828 |
|
|
case COND_EXPR:
|
8829 |
|
|
return build_x_conditional_expr
|
8830 |
|
|
(RECUR (TREE_OPERAND (t, 0)),
|
8831 |
|
|
RECUR (TREE_OPERAND (t, 1)),
|
8832 |
|
|
RECUR (TREE_OPERAND (t, 2)));
|
8833 |
|
|
|
8834 |
|
|
case PSEUDO_DTOR_EXPR:
|
8835 |
|
|
return finish_pseudo_destructor_expr
|
8836 |
|
|
(RECUR (TREE_OPERAND (t, 0)),
|
8837 |
|
|
RECUR (TREE_OPERAND (t, 1)),
|
8838 |
|
|
RECUR (TREE_OPERAND (t, 2)));
|
8839 |
|
|
|
8840 |
|
|
case TREE_LIST:
|
8841 |
|
|
{
|
8842 |
|
|
tree purpose, value, chain;
|
8843 |
|
|
|
8844 |
|
|
if (t == void_list_node)
|
8845 |
|
|
return t;
|
8846 |
|
|
|
8847 |
|
|
purpose = TREE_PURPOSE (t);
|
8848 |
|
|
if (purpose)
|
8849 |
|
|
purpose = RECUR (purpose);
|
8850 |
|
|
value = TREE_VALUE (t);
|
8851 |
|
|
if (value)
|
8852 |
|
|
value = RECUR (value);
|
8853 |
|
|
chain = TREE_CHAIN (t);
|
8854 |
|
|
if (chain && chain != void_type_node)
|
8855 |
|
|
chain = RECUR (chain);
|
8856 |
|
|
if (purpose == TREE_PURPOSE (t)
|
8857 |
|
|
&& value == TREE_VALUE (t)
|
8858 |
|
|
&& chain == TREE_CHAIN (t))
|
8859 |
|
|
return t;
|
8860 |
|
|
return tree_cons (purpose, value, chain);
|
8861 |
|
|
}
|
8862 |
|
|
|
8863 |
|
|
case COMPONENT_REF:
|
8864 |
|
|
{
|
8865 |
|
|
tree object;
|
8866 |
|
|
tree object_type;
|
8867 |
|
|
tree member;
|
8868 |
|
|
|
8869 |
|
|
object = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
|
8870 |
|
|
args, complain, in_decl);
|
8871 |
|
|
/* Remember that there was a reference to this entity. */
|
8872 |
|
|
if (DECL_P (object))
|
8873 |
|
|
mark_used (object);
|
8874 |
|
|
object_type = TREE_TYPE (object);
|
8875 |
|
|
|
8876 |
|
|
member = TREE_OPERAND (t, 1);
|
8877 |
|
|
if (BASELINK_P (member))
|
8878 |
|
|
member = tsubst_baselink (member,
|
8879 |
|
|
non_reference (TREE_TYPE (object)),
|
8880 |
|
|
args, complain, in_decl);
|
8881 |
|
|
else
|
8882 |
|
|
member = tsubst_copy (member, args, complain, in_decl);
|
8883 |
|
|
if (member == error_mark_node)
|
8884 |
|
|
return error_mark_node;
|
8885 |
|
|
|
8886 |
|
|
if (object_type && !CLASS_TYPE_P (object_type))
|
8887 |
|
|
{
|
8888 |
|
|
if (TREE_CODE (member) == BIT_NOT_EXPR)
|
8889 |
|
|
return finish_pseudo_destructor_expr (object,
|
8890 |
|
|
NULL_TREE,
|
8891 |
|
|
object_type);
|
8892 |
|
|
else if (TREE_CODE (member) == SCOPE_REF
|
8893 |
|
|
&& (TREE_CODE (TREE_OPERAND (member, 1)) == BIT_NOT_EXPR))
|
8894 |
|
|
return finish_pseudo_destructor_expr (object,
|
8895 |
|
|
object,
|
8896 |
|
|
object_type);
|
8897 |
|
|
}
|
8898 |
|
|
else if (TREE_CODE (member) == SCOPE_REF
|
8899 |
|
|
&& TREE_CODE (TREE_OPERAND (member, 1)) == TEMPLATE_ID_EXPR)
|
8900 |
|
|
{
|
8901 |
|
|
tree tmpl;
|
8902 |
|
|
tree args;
|
8903 |
|
|
|
8904 |
|
|
/* Lookup the template functions now that we know what the
|
8905 |
|
|
scope is. */
|
8906 |
|
|
tmpl = TREE_OPERAND (TREE_OPERAND (member, 1), 0);
|
8907 |
|
|
args = TREE_OPERAND (TREE_OPERAND (member, 1), 1);
|
8908 |
|
|
member = lookup_qualified_name (TREE_OPERAND (member, 0), tmpl,
|
8909 |
|
|
/*is_type_p=*/false,
|
8910 |
|
|
/*complain=*/false);
|
8911 |
|
|
if (BASELINK_P (member))
|
8912 |
|
|
{
|
8913 |
|
|
BASELINK_FUNCTIONS (member)
|
8914 |
|
|
= build_nt (TEMPLATE_ID_EXPR, BASELINK_FUNCTIONS (member),
|
8915 |
|
|
args);
|
8916 |
|
|
member = (adjust_result_of_qualified_name_lookup
|
8917 |
|
|
(member, BINFO_TYPE (BASELINK_BINFO (member)),
|
8918 |
|
|
object_type));
|
8919 |
|
|
}
|
8920 |
|
|
else
|
8921 |
|
|
{
|
8922 |
|
|
qualified_name_lookup_error (object_type, tmpl, member);
|
8923 |
|
|
return error_mark_node;
|
8924 |
|
|
}
|
8925 |
|
|
}
|
8926 |
|
|
else if (TREE_CODE (member) == SCOPE_REF
|
8927 |
|
|
&& !CLASS_TYPE_P (TREE_OPERAND (member, 0))
|
8928 |
|
|
&& TREE_CODE (TREE_OPERAND (member, 0)) != NAMESPACE_DECL)
|
8929 |
|
|
{
|
8930 |
|
|
if (complain & tf_error)
|
8931 |
|
|
{
|
8932 |
|
|
if (TYPE_P (TREE_OPERAND (member, 0)))
|
8933 |
|
|
error ("%qT is not a class or namespace",
|
8934 |
|
|
TREE_OPERAND (member, 0));
|
8935 |
|
|
else
|
8936 |
|
|
error ("%qD is not a class or namespace",
|
8937 |
|
|
TREE_OPERAND (member, 0));
|
8938 |
|
|
}
|
8939 |
|
|
return error_mark_node;
|
8940 |
|
|
}
|
8941 |
|
|
else if (TREE_CODE (member) == FIELD_DECL)
|
8942 |
|
|
return finish_non_static_data_member (member, object, NULL_TREE);
|
8943 |
|
|
|
8944 |
|
|
return finish_class_member_access_expr (object, member,
|
8945 |
|
|
/*template_p=*/false);
|
8946 |
|
|
}
|
8947 |
|
|
|
8948 |
|
|
case THROW_EXPR:
|
8949 |
|
|
return build_throw
|
8950 |
|
|
(RECUR (TREE_OPERAND (t, 0)));
|
8951 |
|
|
|
8952 |
|
|
case CONSTRUCTOR:
|
8953 |
|
|
{
|
8954 |
|
|
VEC(constructor_elt,gc) *n;
|
8955 |
|
|
constructor_elt *ce;
|
8956 |
|
|
unsigned HOST_WIDE_INT idx;
|
8957 |
|
|
tree r;
|
8958 |
|
|
tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
|
8959 |
|
|
bool process_index_p;
|
8960 |
|
|
|
8961 |
|
|
/* digest_init will do the wrong thing if we let it. */
|
8962 |
|
|
if (type && TYPE_PTRMEMFUNC_P (type))
|
8963 |
|
|
return t;
|
8964 |
|
|
|
8965 |
|
|
/* We do not want to process the index of aggregate
|
8966 |
|
|
initializers as they are identifier nodes which will be
|
8967 |
|
|
looked up by digest_init. */
|
8968 |
|
|
process_index_p = !(type && IS_AGGR_TYPE (type));
|
8969 |
|
|
|
8970 |
|
|
n = VEC_copy (constructor_elt, gc, CONSTRUCTOR_ELTS (t));
|
8971 |
|
|
for (idx = 0; VEC_iterate (constructor_elt, n, idx, ce); idx++)
|
8972 |
|
|
{
|
8973 |
|
|
if (ce->index && process_index_p)
|
8974 |
|
|
ce->index = RECUR (ce->index);
|
8975 |
|
|
ce->value = RECUR (ce->value);
|
8976 |
|
|
}
|
8977 |
|
|
|
8978 |
|
|
r = build_constructor (NULL_TREE, n);
|
8979 |
|
|
TREE_HAS_CONSTRUCTOR (r) = TREE_HAS_CONSTRUCTOR (t);
|
8980 |
|
|
|
8981 |
|
|
if (type)
|
8982 |
|
|
return digest_init (type, r);
|
8983 |
|
|
return r;
|
8984 |
|
|
}
|
8985 |
|
|
|
8986 |
|
|
case TYPEID_EXPR:
|
8987 |
|
|
{
|
8988 |
|
|
tree operand_0 = RECUR (TREE_OPERAND (t, 0));
|
8989 |
|
|
if (TYPE_P (operand_0))
|
8990 |
|
|
return get_typeid (operand_0);
|
8991 |
|
|
return build_typeid (operand_0);
|
8992 |
|
|
}
|
8993 |
|
|
|
8994 |
|
|
case VAR_DECL:
|
8995 |
|
|
if (!args)
|
8996 |
|
|
return t;
|
8997 |
|
|
/* Fall through */
|
8998 |
|
|
|
8999 |
|
|
case PARM_DECL:
|
9000 |
|
|
{
|
9001 |
|
|
tree r = tsubst_copy (t, args, complain, in_decl);
|
9002 |
|
|
|
9003 |
|
|
if (TREE_CODE (TREE_TYPE (t)) != REFERENCE_TYPE)
|
9004 |
|
|
/* If the original type was a reference, we'll be wrapped in
|
9005 |
|
|
the appropriate INDIRECT_REF. */
|
9006 |
|
|
r = convert_from_reference (r);
|
9007 |
|
|
return r;
|
9008 |
|
|
}
|
9009 |
|
|
|
9010 |
|
|
case VA_ARG_EXPR:
|
9011 |
|
|
return build_x_va_arg (RECUR (TREE_OPERAND (t, 0)),
|
9012 |
|
|
tsubst_copy (TREE_TYPE (t), args, complain,
|
9013 |
|
|
in_decl));
|
9014 |
|
|
|
9015 |
|
|
case OFFSETOF_EXPR:
|
9016 |
|
|
return fold_offsetof (RECUR (TREE_OPERAND (t, 0)));
|
9017 |
|
|
|
9018 |
|
|
case STMT_EXPR:
|
9019 |
|
|
{
|
9020 |
|
|
tree old_stmt_expr = cur_stmt_expr;
|
9021 |
|
|
tree stmt_expr = begin_stmt_expr ();
|
9022 |
|
|
|
9023 |
|
|
cur_stmt_expr = stmt_expr;
|
9024 |
|
|
tsubst_expr (STMT_EXPR_STMT (t), args, complain, in_decl);
|
9025 |
|
|
stmt_expr = finish_stmt_expr (stmt_expr, false);
|
9026 |
|
|
cur_stmt_expr = old_stmt_expr;
|
9027 |
|
|
|
9028 |
|
|
return stmt_expr;
|
9029 |
|
|
}
|
9030 |
|
|
|
9031 |
|
|
case CONST_DECL:
|
9032 |
|
|
t = tsubst_copy (t, args, complain, in_decl);
|
9033 |
|
|
/* As in finish_id_expression, we resolve enumeration constants
|
9034 |
|
|
to their underlying values. */
|
9035 |
|
|
if (TREE_CODE (t) == CONST_DECL)
|
9036 |
|
|
return DECL_INITIAL (t);
|
9037 |
|
|
return t;
|
9038 |
|
|
|
9039 |
|
|
default:
|
9040 |
|
|
/* Handle Objective-C++ constructs, if appropriate. */
|
9041 |
|
|
{
|
9042 |
|
|
tree subst
|
9043 |
|
|
= objcp_tsubst_copy_and_build (t, args, complain,
|
9044 |
|
|
in_decl, /*function_p=*/false);
|
9045 |
|
|
if (subst)
|
9046 |
|
|
return subst;
|
9047 |
|
|
}
|
9048 |
|
|
return tsubst_copy (t, args, complain, in_decl);
|
9049 |
|
|
}
|
9050 |
|
|
|
9051 |
|
|
#undef RECUR
|
9052 |
|
|
}
|
9053 |
|
|
|
9054 |
|
|
/* Verify that the instantiated ARGS are valid. For type arguments,
|
9055 |
|
|
make sure that the type's linkage is ok. For non-type arguments,
|
9056 |
|
|
make sure they are constants if they are integral or enumerations.
|
9057 |
|
|
Emit an error under control of COMPLAIN, and return TRUE on error. */
|
9058 |
|
|
|
9059 |
|
|
static bool
|
9060 |
|
|
check_instantiated_args (tree tmpl, tree args, tsubst_flags_t complain)
|
9061 |
|
|
{
|
9062 |
|
|
int ix, len = DECL_NTPARMS (tmpl);
|
9063 |
|
|
bool result = false;
|
9064 |
|
|
|
9065 |
|
|
for (ix = 0; ix != len; ix++)
|
9066 |
|
|
{
|
9067 |
|
|
tree t = TREE_VEC_ELT (args, ix);
|
9068 |
|
|
|
9069 |
|
|
if (TYPE_P (t))
|
9070 |
|
|
{
|
9071 |
|
|
/* [basic.link]: A name with no linkage (notably, the name
|
9072 |
|
|
of a class or enumeration declared in a local scope)
|
9073 |
|
|
shall not be used to declare an entity with linkage.
|
9074 |
|
|
This implies that names with no linkage cannot be used as
|
9075 |
|
|
template arguments. */
|
9076 |
|
|
tree nt = no_linkage_check (t, /*relaxed_p=*/false);
|
9077 |
|
|
|
9078 |
|
|
if (nt)
|
9079 |
|
|
{
|
9080 |
|
|
/* DR 488 makes use of a type with no linkage cause
|
9081 |
|
|
type deduction to fail. */
|
9082 |
|
|
if (complain & tf_error)
|
9083 |
|
|
{
|
9084 |
|
|
if (TYPE_ANONYMOUS_P (nt))
|
9085 |
|
|
error ("%qT is/uses anonymous type", t);
|
9086 |
|
|
else
|
9087 |
|
|
error ("%qT uses local type %qT", t, nt);
|
9088 |
|
|
}
|
9089 |
|
|
result = true;
|
9090 |
|
|
}
|
9091 |
|
|
/* In order to avoid all sorts of complications, we do not
|
9092 |
|
|
allow variably-modified types as template arguments. */
|
9093 |
|
|
else if (variably_modified_type_p (t, NULL_TREE))
|
9094 |
|
|
{
|
9095 |
|
|
if (complain & tf_error)
|
9096 |
|
|
error ("%qT is a variably modified type", t);
|
9097 |
|
|
result = true;
|
9098 |
|
|
}
|
9099 |
|
|
}
|
9100 |
|
|
/* A non-type argument of integral or enumerated type must be a
|
9101 |
|
|
constant. */
|
9102 |
|
|
else if (TREE_TYPE (t)
|
9103 |
|
|
&& INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t))
|
9104 |
|
|
&& !TREE_CONSTANT (t))
|
9105 |
|
|
{
|
9106 |
|
|
if (complain & tf_error)
|
9107 |
|
|
error ("integral expression %qE is not constant", t);
|
9108 |
|
|
result = true;
|
9109 |
|
|
}
|
9110 |
|
|
}
|
9111 |
|
|
if (result && (complain & tf_error))
|
9112 |
|
|
error (" trying to instantiate %qD", tmpl);
|
9113 |
|
|
return result;
|
9114 |
|
|
}
|
9115 |
|
|
|
9116 |
|
|
/* Instantiate the indicated variable or function template TMPL with
|
9117 |
|
|
the template arguments in TARG_PTR. */
|
9118 |
|
|
|
9119 |
|
|
tree
|
9120 |
|
|
instantiate_template (tree tmpl, tree targ_ptr, tsubst_flags_t complain)
|
9121 |
|
|
{
|
9122 |
|
|
tree fndecl;
|
9123 |
|
|
tree gen_tmpl;
|
9124 |
|
|
tree spec;
|
9125 |
|
|
|
9126 |
|
|
if (tmpl == error_mark_node)
|
9127 |
|
|
return error_mark_node;
|
9128 |
|
|
|
9129 |
|
|
gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
|
9130 |
|
|
|
9131 |
|
|
/* If this function is a clone, handle it specially. */
|
9132 |
|
|
if (DECL_CLONED_FUNCTION_P (tmpl))
|
9133 |
|
|
{
|
9134 |
|
|
tree spec;
|
9135 |
|
|
tree clone;
|
9136 |
|
|
|
9137 |
|
|
spec = instantiate_template (DECL_CLONED_FUNCTION (tmpl), targ_ptr,
|
9138 |
|
|
complain);
|
9139 |
|
|
if (spec == error_mark_node)
|
9140 |
|
|
return error_mark_node;
|
9141 |
|
|
|
9142 |
|
|
/* Look for the clone. */
|
9143 |
|
|
FOR_EACH_CLONE (clone, spec)
|
9144 |
|
|
if (DECL_NAME (clone) == DECL_NAME (tmpl))
|
9145 |
|
|
return clone;
|
9146 |
|
|
/* We should always have found the clone by now. */
|
9147 |
|
|
gcc_unreachable ();
|
9148 |
|
|
return NULL_TREE;
|
9149 |
|
|
}
|
9150 |
|
|
|
9151 |
|
|
/* Check to see if we already have this specialization. */
|
9152 |
|
|
spec = retrieve_specialization (tmpl, targ_ptr,
|
9153 |
|
|
/*class_specializations_p=*/false);
|
9154 |
|
|
if (spec != NULL_TREE)
|
9155 |
|
|
return spec;
|
9156 |
|
|
|
9157 |
|
|
gen_tmpl = most_general_template (tmpl);
|
9158 |
|
|
if (tmpl != gen_tmpl)
|
9159 |
|
|
{
|
9160 |
|
|
/* The TMPL is a partial instantiation. To get a full set of
|
9161 |
|
|
arguments we must add the arguments used to perform the
|
9162 |
|
|
partial instantiation. */
|
9163 |
|
|
targ_ptr = add_outermost_template_args (DECL_TI_ARGS (tmpl),
|
9164 |
|
|
targ_ptr);
|
9165 |
|
|
|
9166 |
|
|
/* Check to see if we already have this specialization. */
|
9167 |
|
|
spec = retrieve_specialization (gen_tmpl, targ_ptr,
|
9168 |
|
|
/*class_specializations_p=*/false);
|
9169 |
|
|
if (spec != NULL_TREE)
|
9170 |
|
|
return spec;
|
9171 |
|
|
}
|
9172 |
|
|
|
9173 |
|
|
if (check_instantiated_args (gen_tmpl, INNERMOST_TEMPLATE_ARGS (targ_ptr),
|
9174 |
|
|
complain))
|
9175 |
|
|
return error_mark_node;
|
9176 |
|
|
|
9177 |
|
|
/* We are building a FUNCTION_DECL, during which the access of its
|
9178 |
|
|
parameters and return types have to be checked. However this
|
9179 |
|
|
FUNCTION_DECL which is the desired context for access checking
|
9180 |
|
|
is not built yet. We solve this chicken-and-egg problem by
|
9181 |
|
|
deferring all checks until we have the FUNCTION_DECL. */
|
9182 |
|
|
push_deferring_access_checks (dk_deferred);
|
9183 |
|
|
|
9184 |
|
|
/* Substitute template parameters. */
|
9185 |
|
|
fndecl = tsubst (DECL_TEMPLATE_RESULT (gen_tmpl),
|
9186 |
|
|
targ_ptr, complain, gen_tmpl);
|
9187 |
|
|
if (fndecl == error_mark_node)
|
9188 |
|
|
return error_mark_node;
|
9189 |
|
|
|
9190 |
|
|
/* Now we know the specialization, compute access previously
|
9191 |
|
|
deferred. */
|
9192 |
|
|
push_access_scope (fndecl);
|
9193 |
|
|
perform_deferred_access_checks ();
|
9194 |
|
|
pop_access_scope (fndecl);
|
9195 |
|
|
pop_deferring_access_checks ();
|
9196 |
|
|
|
9197 |
|
|
/* The DECL_TI_TEMPLATE should always be the immediate parent
|
9198 |
|
|
template, not the most general template. */
|
9199 |
|
|
DECL_TI_TEMPLATE (fndecl) = tmpl;
|
9200 |
|
|
|
9201 |
|
|
/* If we've just instantiated the main entry point for a function,
|
9202 |
|
|
instantiate all the alternate entry points as well. We do this
|
9203 |
|
|
by cloning the instantiation of the main entry point, not by
|
9204 |
|
|
instantiating the template clones. */
|
9205 |
|
|
if (TREE_CHAIN (gen_tmpl) && DECL_CLONED_FUNCTION_P (TREE_CHAIN (gen_tmpl)))
|
9206 |
|
|
clone_function_decl (fndecl, /*update_method_vec_p=*/0);
|
9207 |
|
|
|
9208 |
|
|
return fndecl;
|
9209 |
|
|
}
|
9210 |
|
|
|
9211 |
|
|
/* The FN is a TEMPLATE_DECL for a function. The ARGS are the
|
9212 |
|
|
arguments that are being used when calling it. TARGS is a vector
|
9213 |
|
|
into which the deduced template arguments are placed.
|
9214 |
|
|
|
9215 |
|
|
Return zero for success, 2 for an incomplete match that doesn't resolve
|
9216 |
|
|
all the types, and 1 for complete failure. An error message will be
|
9217 |
|
|
printed only for an incomplete match.
|
9218 |
|
|
|
9219 |
|
|
If FN is a conversion operator, or we are trying to produce a specific
|
9220 |
|
|
specialization, RETURN_TYPE is the return type desired.
|
9221 |
|
|
|
9222 |
|
|
The EXPLICIT_TARGS are explicit template arguments provided via a
|
9223 |
|
|
template-id.
|
9224 |
|
|
|
9225 |
|
|
The parameter STRICT is one of:
|
9226 |
|
|
|
9227 |
|
|
DEDUCE_CALL:
|
9228 |
|
|
We are deducing arguments for a function call, as in
|
9229 |
|
|
[temp.deduct.call].
|
9230 |
|
|
|
9231 |
|
|
DEDUCE_CONV:
|
9232 |
|
|
We are deducing arguments for a conversion function, as in
|
9233 |
|
|
[temp.deduct.conv].
|
9234 |
|
|
|
9235 |
|
|
DEDUCE_EXACT:
|
9236 |
|
|
We are deducing arguments when doing an explicit instantiation
|
9237 |
|
|
as in [temp.explicit], when determining an explicit specialization
|
9238 |
|
|
as in [temp.expl.spec], or when taking the address of a function
|
9239 |
|
|
template, as in [temp.deduct.funcaddr]. */
|
9240 |
|
|
|
9241 |
|
|
int
|
9242 |
|
|
fn_type_unification (tree fn,
|
9243 |
|
|
tree explicit_targs,
|
9244 |
|
|
tree targs,
|
9245 |
|
|
tree args,
|
9246 |
|
|
tree return_type,
|
9247 |
|
|
unification_kind_t strict,
|
9248 |
|
|
int flags)
|
9249 |
|
|
{
|
9250 |
|
|
tree parms;
|
9251 |
|
|
tree fntype;
|
9252 |
|
|
int result;
|
9253 |
|
|
|
9254 |
|
|
gcc_assert (TREE_CODE (fn) == TEMPLATE_DECL);
|
9255 |
|
|
|
9256 |
|
|
fntype = TREE_TYPE (fn);
|
9257 |
|
|
if (explicit_targs)
|
9258 |
|
|
{
|
9259 |
|
|
/* [temp.deduct]
|
9260 |
|
|
|
9261 |
|
|
The specified template arguments must match the template
|
9262 |
|
|
parameters in kind (i.e., type, nontype, template), and there
|
9263 |
|
|
must not be more arguments than there are parameters;
|
9264 |
|
|
otherwise type deduction fails.
|
9265 |
|
|
|
9266 |
|
|
Nontype arguments must match the types of the corresponding
|
9267 |
|
|
nontype template parameters, or must be convertible to the
|
9268 |
|
|
types of the corresponding nontype parameters as specified in
|
9269 |
|
|
_temp.arg.nontype_, otherwise type deduction fails.
|
9270 |
|
|
|
9271 |
|
|
All references in the function type of the function template
|
9272 |
|
|
to the corresponding template parameters are replaced by the
|
9273 |
|
|
specified template argument values. If a substitution in a
|
9274 |
|
|
template parameter or in the function type of the function
|
9275 |
|
|
template results in an invalid type, type deduction fails. */
|
9276 |
|
|
int i;
|
9277 |
|
|
tree converted_args;
|
9278 |
|
|
bool incomplete;
|
9279 |
|
|
|
9280 |
|
|
if (explicit_targs == error_mark_node)
|
9281 |
|
|
return 1;
|
9282 |
|
|
|
9283 |
|
|
converted_args
|
9284 |
|
|
= (coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn),
|
9285 |
|
|
explicit_targs, NULL_TREE, tf_none,
|
9286 |
|
|
/*require_all_arguments=*/0));
|
9287 |
|
|
if (converted_args == error_mark_node)
|
9288 |
|
|
return 1;
|
9289 |
|
|
|
9290 |
|
|
/* Substitute the explicit args into the function type. This is
|
9291 |
|
|
necessary so that, for instance, explicitly declared function
|
9292 |
|
|
arguments can match null pointed constants. If we were given
|
9293 |
|
|
an incomplete set of explicit args, we must not do semantic
|
9294 |
|
|
processing during substitution as we could create partial
|
9295 |
|
|
instantiations. */
|
9296 |
|
|
incomplete = NUM_TMPL_ARGS (explicit_targs) != NUM_TMPL_ARGS (targs);
|
9297 |
|
|
processing_template_decl += incomplete;
|
9298 |
|
|
fntype = tsubst (fntype, converted_args, tf_none, NULL_TREE);
|
9299 |
|
|
processing_template_decl -= incomplete;
|
9300 |
|
|
|
9301 |
|
|
if (fntype == error_mark_node)
|
9302 |
|
|
return 1;
|
9303 |
|
|
|
9304 |
|
|
/* Place the explicitly specified arguments in TARGS. */
|
9305 |
|
|
for (i = NUM_TMPL_ARGS (converted_args); i--;)
|
9306 |
|
|
TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (converted_args, i);
|
9307 |
|
|
}
|
9308 |
|
|
|
9309 |
|
|
parms = TYPE_ARG_TYPES (fntype);
|
9310 |
|
|
/* Never do unification on the 'this' parameter. */
|
9311 |
|
|
if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
|
9312 |
|
|
parms = TREE_CHAIN (parms);
|
9313 |
|
|
|
9314 |
|
|
if (return_type)
|
9315 |
|
|
{
|
9316 |
|
|
parms = tree_cons (NULL_TREE, TREE_TYPE (fntype), parms);
|
9317 |
|
|
args = tree_cons (NULL_TREE, return_type, args);
|
9318 |
|
|
}
|
9319 |
|
|
|
9320 |
|
|
/* We allow incomplete unification without an error message here
|
9321 |
|
|
because the standard doesn't seem to explicitly prohibit it. Our
|
9322 |
|
|
callers must be ready to deal with unification failures in any
|
9323 |
|
|
event. */
|
9324 |
|
|
result = type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn),
|
9325 |
|
|
targs, parms, args, /*subr=*/0,
|
9326 |
|
|
strict, flags);
|
9327 |
|
|
|
9328 |
|
|
if (result == 0)
|
9329 |
|
|
/* All is well so far. Now, check:
|
9330 |
|
|
|
9331 |
|
|
[temp.deduct]
|
9332 |
|
|
|
9333 |
|
|
When all template arguments have been deduced, all uses of
|
9334 |
|
|
template parameters in nondeduced contexts are replaced with
|
9335 |
|
|
the corresponding deduced argument values. If the
|
9336 |
|
|
substitution results in an invalid type, as described above,
|
9337 |
|
|
type deduction fails. */
|
9338 |
|
|
if (tsubst (TREE_TYPE (fn), targs, tf_none, NULL_TREE)
|
9339 |
|
|
== error_mark_node)
|
9340 |
|
|
return 1;
|
9341 |
|
|
|
9342 |
|
|
return result;
|
9343 |
|
|
}
|
9344 |
|
|
|
9345 |
|
|
/* Adjust types before performing type deduction, as described in
|
9346 |
|
|
[temp.deduct.call] and [temp.deduct.conv]. The rules in these two
|
9347 |
|
|
sections are symmetric. PARM is the type of a function parameter
|
9348 |
|
|
or the return type of the conversion function. ARG is the type of
|
9349 |
|
|
the argument passed to the call, or the type of the value
|
9350 |
|
|
initialized with the result of the conversion function. */
|
9351 |
|
|
|
9352 |
|
|
static int
|
9353 |
|
|
maybe_adjust_types_for_deduction (unification_kind_t strict,
|
9354 |
|
|
tree* parm,
|
9355 |
|
|
tree* arg)
|
9356 |
|
|
{
|
9357 |
|
|
int result = 0;
|
9358 |
|
|
|
9359 |
|
|
switch (strict)
|
9360 |
|
|
{
|
9361 |
|
|
case DEDUCE_CALL:
|
9362 |
|
|
break;
|
9363 |
|
|
|
9364 |
|
|
case DEDUCE_CONV:
|
9365 |
|
|
{
|
9366 |
|
|
/* Swap PARM and ARG throughout the remainder of this
|
9367 |
|
|
function; the handling is precisely symmetric since PARM
|
9368 |
|
|
will initialize ARG rather than vice versa. */
|
9369 |
|
|
tree* temp = parm;
|
9370 |
|
|
parm = arg;
|
9371 |
|
|
arg = temp;
|
9372 |
|
|
break;
|
9373 |
|
|
}
|
9374 |
|
|
|
9375 |
|
|
case DEDUCE_EXACT:
|
9376 |
|
|
/* There is nothing to do in this case. */
|
9377 |
|
|
return 0;
|
9378 |
|
|
|
9379 |
|
|
default:
|
9380 |
|
|
gcc_unreachable ();
|
9381 |
|
|
}
|
9382 |
|
|
|
9383 |
|
|
if (TREE_CODE (*parm) != REFERENCE_TYPE)
|
9384 |
|
|
{
|
9385 |
|
|
/* [temp.deduct.call]
|
9386 |
|
|
|
9387 |
|
|
If P is not a reference type:
|
9388 |
|
|
|
9389 |
|
|
--If A is an array type, the pointer type produced by the
|
9390 |
|
|
array-to-pointer standard conversion (_conv.array_) is
|
9391 |
|
|
used in place of A for type deduction; otherwise,
|
9392 |
|
|
|
9393 |
|
|
--If A is a function type, the pointer type produced by
|
9394 |
|
|
the function-to-pointer standard conversion
|
9395 |
|
|
(_conv.func_) is used in place of A for type deduction;
|
9396 |
|
|
otherwise,
|
9397 |
|
|
|
9398 |
|
|
--If A is a cv-qualified type, the top level
|
9399 |
|
|
cv-qualifiers of A's type are ignored for type
|
9400 |
|
|
deduction. */
|
9401 |
|
|
if (TREE_CODE (*arg) == ARRAY_TYPE)
|
9402 |
|
|
*arg = build_pointer_type (TREE_TYPE (*arg));
|
9403 |
|
|
else if (TREE_CODE (*arg) == FUNCTION_TYPE)
|
9404 |
|
|
*arg = build_pointer_type (*arg);
|
9405 |
|
|
else
|
9406 |
|
|
*arg = TYPE_MAIN_VARIANT (*arg);
|
9407 |
|
|
}
|
9408 |
|
|
|
9409 |
|
|
/* [temp.deduct.call]
|
9410 |
|
|
|
9411 |
|
|
If P is a cv-qualified type, the top level cv-qualifiers
|
9412 |
|
|
of P's type are ignored for type deduction. If P is a
|
9413 |
|
|
reference type, the type referred to by P is used for
|
9414 |
|
|
type deduction. */
|
9415 |
|
|
*parm = TYPE_MAIN_VARIANT (*parm);
|
9416 |
|
|
if (TREE_CODE (*parm) == REFERENCE_TYPE)
|
9417 |
|
|
{
|
9418 |
|
|
*parm = TREE_TYPE (*parm);
|
9419 |
|
|
result |= UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
|
9420 |
|
|
}
|
9421 |
|
|
|
9422 |
|
|
/* DR 322. For conversion deduction, remove a reference type on parm
|
9423 |
|
|
too (which has been swapped into ARG). */
|
9424 |
|
|
if (strict == DEDUCE_CONV && TREE_CODE (*arg) == REFERENCE_TYPE)
|
9425 |
|
|
*arg = TREE_TYPE (*arg);
|
9426 |
|
|
|
9427 |
|
|
return result;
|
9428 |
|
|
}
|
9429 |
|
|
|
9430 |
|
|
/* Most parms like fn_type_unification.
|
9431 |
|
|
|
9432 |
|
|
If SUBR is 1, we're being called recursively (to unify the
|
9433 |
|
|
arguments of a function or method parameter of a function
|
9434 |
|
|
template). */
|
9435 |
|
|
|
9436 |
|
|
static int
|
9437 |
|
|
type_unification_real (tree tparms,
|
9438 |
|
|
tree targs,
|
9439 |
|
|
tree xparms,
|
9440 |
|
|
tree xargs,
|
9441 |
|
|
int subr,
|
9442 |
|
|
unification_kind_t strict,
|
9443 |
|
|
int flags)
|
9444 |
|
|
{
|
9445 |
|
|
tree parm, arg;
|
9446 |
|
|
int i;
|
9447 |
|
|
int ntparms = TREE_VEC_LENGTH (tparms);
|
9448 |
|
|
int sub_strict;
|
9449 |
|
|
int saw_undeduced = 0;
|
9450 |
|
|
tree parms, args;
|
9451 |
|
|
|
9452 |
|
|
gcc_assert (TREE_CODE (tparms) == TREE_VEC);
|
9453 |
|
|
gcc_assert (xparms == NULL_TREE || TREE_CODE (xparms) == TREE_LIST);
|
9454 |
|
|
gcc_assert (!xargs || TREE_CODE (xargs) == TREE_LIST);
|
9455 |
|
|
gcc_assert (ntparms > 0);
|
9456 |
|
|
|
9457 |
|
|
switch (strict)
|
9458 |
|
|
{
|
9459 |
|
|
case DEDUCE_CALL:
|
9460 |
|
|
sub_strict = (UNIFY_ALLOW_OUTER_LEVEL | UNIFY_ALLOW_MORE_CV_QUAL
|
9461 |
|
|
| UNIFY_ALLOW_DERIVED);
|
9462 |
|
|
break;
|
9463 |
|
|
|
9464 |
|
|
case DEDUCE_CONV:
|
9465 |
|
|
sub_strict = UNIFY_ALLOW_LESS_CV_QUAL;
|
9466 |
|
|
break;
|
9467 |
|
|
|
9468 |
|
|
case DEDUCE_EXACT:
|
9469 |
|
|
sub_strict = UNIFY_ALLOW_NONE;
|
9470 |
|
|
break;
|
9471 |
|
|
|
9472 |
|
|
default:
|
9473 |
|
|
gcc_unreachable ();
|
9474 |
|
|
}
|
9475 |
|
|
|
9476 |
|
|
again:
|
9477 |
|
|
parms = xparms;
|
9478 |
|
|
args = xargs;
|
9479 |
|
|
|
9480 |
|
|
while (parms && parms != void_list_node
|
9481 |
|
|
&& args && args != void_list_node)
|
9482 |
|
|
{
|
9483 |
|
|
parm = TREE_VALUE (parms);
|
9484 |
|
|
parms = TREE_CHAIN (parms);
|
9485 |
|
|
arg = TREE_VALUE (args);
|
9486 |
|
|
args = TREE_CHAIN (args);
|
9487 |
|
|
|
9488 |
|
|
if (arg == error_mark_node)
|
9489 |
|
|
return 1;
|
9490 |
|
|
if (arg == unknown_type_node)
|
9491 |
|
|
/* We can't deduce anything from this, but we might get all the
|
9492 |
|
|
template args from other function args. */
|
9493 |
|
|
continue;
|
9494 |
|
|
|
9495 |
|
|
/* Conversions will be performed on a function argument that
|
9496 |
|
|
corresponds with a function parameter that contains only
|
9497 |
|
|
non-deducible template parameters and explicitly specified
|
9498 |
|
|
template parameters. */
|
9499 |
|
|
if (!uses_template_parms (parm))
|
9500 |
|
|
{
|
9501 |
|
|
tree type;
|
9502 |
|
|
|
9503 |
|
|
if (!TYPE_P (arg))
|
9504 |
|
|
type = TREE_TYPE (arg);
|
9505 |
|
|
else
|
9506 |
|
|
type = arg;
|
9507 |
|
|
|
9508 |
|
|
if (same_type_p (parm, type))
|
9509 |
|
|
continue;
|
9510 |
|
|
if (strict != DEDUCE_EXACT
|
9511 |
|
|
&& can_convert_arg (parm, type, TYPE_P (arg) ? NULL_TREE : arg,
|
9512 |
|
|
flags))
|
9513 |
|
|
continue;
|
9514 |
|
|
|
9515 |
|
|
return 1;
|
9516 |
|
|
}
|
9517 |
|
|
|
9518 |
|
|
if (!TYPE_P (arg))
|
9519 |
|
|
{
|
9520 |
|
|
gcc_assert (TREE_TYPE (arg) != NULL_TREE);
|
9521 |
|
|
if (type_unknown_p (arg))
|
9522 |
|
|
{
|
9523 |
|
|
/* [temp.deduct.type] A template-argument can be deduced from
|
9524 |
|
|
a pointer to function or pointer to member function
|
9525 |
|
|
argument if the set of overloaded functions does not
|
9526 |
|
|
contain function templates and at most one of a set of
|
9527 |
|
|
overloaded functions provides a unique match. */
|
9528 |
|
|
|
9529 |
|
|
if (resolve_overloaded_unification
|
9530 |
|
|
(tparms, targs, parm, arg, strict, sub_strict)
|
9531 |
|
|
!= 0)
|
9532 |
|
|
return 1;
|
9533 |
|
|
continue;
|
9534 |
|
|
}
|
9535 |
|
|
arg = TREE_TYPE (arg);
|
9536 |
|
|
if (arg == error_mark_node)
|
9537 |
|
|
return 1;
|
9538 |
|
|
}
|
9539 |
|
|
|
9540 |
|
|
{
|
9541 |
|
|
int arg_strict = sub_strict;
|
9542 |
|
|
|
9543 |
|
|
if (!subr)
|
9544 |
|
|
arg_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg);
|
9545 |
|
|
|
9546 |
|
|
if (unify (tparms, targs, parm, arg, arg_strict))
|
9547 |
|
|
return 1;
|
9548 |
|
|
}
|
9549 |
|
|
}
|
9550 |
|
|
|
9551 |
|
|
/* Fail if we've reached the end of the parm list, and more args
|
9552 |
|
|
are present, and the parm list isn't variadic. */
|
9553 |
|
|
if (args && args != void_list_node && parms == void_list_node)
|
9554 |
|
|
return 1;
|
9555 |
|
|
/* Fail if parms are left and they don't have default values. */
|
9556 |
|
|
if (parms && parms != void_list_node
|
9557 |
|
|
&& TREE_PURPOSE (parms) == NULL_TREE)
|
9558 |
|
|
return 1;
|
9559 |
|
|
|
9560 |
|
|
if (!subr)
|
9561 |
|
|
for (i = 0; i < ntparms; i++)
|
9562 |
|
|
if (!TREE_VEC_ELT (targs, i))
|
9563 |
|
|
{
|
9564 |
|
|
tree tparm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
|
9565 |
|
|
|
9566 |
|
|
/* If this is an undeduced nontype parameter that depends on
|
9567 |
|
|
a type parameter, try another pass; its type may have been
|
9568 |
|
|
deduced from a later argument than the one from which
|
9569 |
|
|
this parameter can be deduced. */
|
9570 |
|
|
if (TREE_CODE (tparm) == PARM_DECL
|
9571 |
|
|
&& uses_template_parms (TREE_TYPE (tparm))
|
9572 |
|
|
&& !saw_undeduced++)
|
9573 |
|
|
goto again;
|
9574 |
|
|
|
9575 |
|
|
return 2;
|
9576 |
|
|
}
|
9577 |
|
|
|
9578 |
|
|
return 0;
|
9579 |
|
|
}
|
9580 |
|
|
|
9581 |
|
|
/* Subroutine of type_unification_real. Args are like the variables at the
|
9582 |
|
|
call site. ARG is an overloaded function (or template-id); we try
|
9583 |
|
|
deducing template args from each of the overloads, and if only one
|
9584 |
|
|
succeeds, we go with that. Modifies TARGS and returns 0 on success. */
|
9585 |
|
|
|
9586 |
|
|
static int
|
9587 |
|
|
resolve_overloaded_unification (tree tparms,
|
9588 |
|
|
tree targs,
|
9589 |
|
|
tree parm,
|
9590 |
|
|
tree arg,
|
9591 |
|
|
unification_kind_t strict,
|
9592 |
|
|
int sub_strict)
|
9593 |
|
|
{
|
9594 |
|
|
tree tempargs = copy_node (targs);
|
9595 |
|
|
int good = 0;
|
9596 |
|
|
bool addr_p;
|
9597 |
|
|
|
9598 |
|
|
if (TREE_CODE (arg) == ADDR_EXPR)
|
9599 |
|
|
{
|
9600 |
|
|
arg = TREE_OPERAND (arg, 0);
|
9601 |
|
|
addr_p = true;
|
9602 |
|
|
}
|
9603 |
|
|
else
|
9604 |
|
|
addr_p = false;
|
9605 |
|
|
|
9606 |
|
|
if (TREE_CODE (arg) == COMPONENT_REF)
|
9607 |
|
|
/* Handle `&x' where `x' is some static or non-static member
|
9608 |
|
|
function name. */
|
9609 |
|
|
arg = TREE_OPERAND (arg, 1);
|
9610 |
|
|
|
9611 |
|
|
if (TREE_CODE (arg) == OFFSET_REF)
|
9612 |
|
|
arg = TREE_OPERAND (arg, 1);
|
9613 |
|
|
|
9614 |
|
|
/* Strip baselink information. */
|
9615 |
|
|
if (BASELINK_P (arg))
|
9616 |
|
|
arg = BASELINK_FUNCTIONS (arg);
|
9617 |
|
|
|
9618 |
|
|
if (TREE_CODE (arg) == TEMPLATE_ID_EXPR)
|
9619 |
|
|
{
|
9620 |
|
|
/* If we got some explicit template args, we need to plug them into
|
9621 |
|
|
the affected templates before we try to unify, in case the
|
9622 |
|
|
explicit args will completely resolve the templates in question. */
|
9623 |
|
|
|
9624 |
|
|
tree expl_subargs = TREE_OPERAND (arg, 1);
|
9625 |
|
|
arg = TREE_OPERAND (arg, 0);
|
9626 |
|
|
|
9627 |
|
|
for (; arg; arg = OVL_NEXT (arg))
|
9628 |
|
|
{
|
9629 |
|
|
tree fn = OVL_CURRENT (arg);
|
9630 |
|
|
tree subargs, elem;
|
9631 |
|
|
|
9632 |
|
|
if (TREE_CODE (fn) != TEMPLATE_DECL)
|
9633 |
|
|
continue;
|
9634 |
|
|
|
9635 |
|
|
subargs = get_bindings (fn, DECL_TEMPLATE_RESULT (fn),
|
9636 |
|
|
expl_subargs, /*check_ret=*/false);
|
9637 |
|
|
if (subargs)
|
9638 |
|
|
{
|
9639 |
|
|
elem = tsubst (TREE_TYPE (fn), subargs, tf_none, NULL_TREE);
|
9640 |
|
|
good += try_one_overload (tparms, targs, tempargs, parm,
|
9641 |
|
|
elem, strict, sub_strict, addr_p);
|
9642 |
|
|
}
|
9643 |
|
|
}
|
9644 |
|
|
}
|
9645 |
|
|
else
|
9646 |
|
|
{
|
9647 |
|
|
gcc_assert (TREE_CODE (arg) == OVERLOAD
|
9648 |
|
|
|| TREE_CODE (arg) == FUNCTION_DECL);
|
9649 |
|
|
|
9650 |
|
|
for (; arg; arg = OVL_NEXT (arg))
|
9651 |
|
|
good += try_one_overload (tparms, targs, tempargs, parm,
|
9652 |
|
|
TREE_TYPE (OVL_CURRENT (arg)),
|
9653 |
|
|
strict, sub_strict, addr_p);
|
9654 |
|
|
}
|
9655 |
|
|
|
9656 |
|
|
/* [temp.deduct.type] A template-argument can be deduced from a pointer
|
9657 |
|
|
to function or pointer to member function argument if the set of
|
9658 |
|
|
overloaded functions does not contain function templates and at most
|
9659 |
|
|
one of a set of overloaded functions provides a unique match.
|
9660 |
|
|
|
9661 |
|
|
So if we found multiple possibilities, we return success but don't
|
9662 |
|
|
deduce anything. */
|
9663 |
|
|
|
9664 |
|
|
if (good == 1)
|
9665 |
|
|
{
|
9666 |
|
|
int i = TREE_VEC_LENGTH (targs);
|
9667 |
|
|
for (; i--; )
|
9668 |
|
|
if (TREE_VEC_ELT (tempargs, i))
|
9669 |
|
|
TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (tempargs, i);
|
9670 |
|
|
}
|
9671 |
|
|
if (good)
|
9672 |
|
|
return 0;
|
9673 |
|
|
|
9674 |
|
|
return 1;
|
9675 |
|
|
}
|
9676 |
|
|
|
9677 |
|
|
/* Subroutine of resolve_overloaded_unification; does deduction for a single
|
9678 |
|
|
overload. Fills TARGS with any deduced arguments, or error_mark_node if
|
9679 |
|
|
different overloads deduce different arguments for a given parm.
|
9680 |
|
|
ADDR_P is true if the expression for which deduction is being
|
9681 |
|
|
performed was of the form "& fn" rather than simply "fn".
|
9682 |
|
|
|
9683 |
|
|
Returns 1 on success. */
|
9684 |
|
|
|
9685 |
|
|
static int
|
9686 |
|
|
try_one_overload (tree tparms,
|
9687 |
|
|
tree orig_targs,
|
9688 |
|
|
tree targs,
|
9689 |
|
|
tree parm,
|
9690 |
|
|
tree arg,
|
9691 |
|
|
unification_kind_t strict,
|
9692 |
|
|
int sub_strict,
|
9693 |
|
|
bool addr_p)
|
9694 |
|
|
{
|
9695 |
|
|
int nargs;
|
9696 |
|
|
tree tempargs;
|
9697 |
|
|
int i;
|
9698 |
|
|
|
9699 |
|
|
/* [temp.deduct.type] A template-argument can be deduced from a pointer
|
9700 |
|
|
to function or pointer to member function argument if the set of
|
9701 |
|
|
overloaded functions does not contain function templates and at most
|
9702 |
|
|
one of a set of overloaded functions provides a unique match.
|
9703 |
|
|
|
9704 |
|
|
So if this is a template, just return success. */
|
9705 |
|
|
|
9706 |
|
|
if (uses_template_parms (arg))
|
9707 |
|
|
return 1;
|
9708 |
|
|
|
9709 |
|
|
if (TREE_CODE (arg) == METHOD_TYPE)
|
9710 |
|
|
arg = build_ptrmemfunc_type (build_pointer_type (arg));
|
9711 |
|
|
else if (addr_p)
|
9712 |
|
|
arg = build_pointer_type (arg);
|
9713 |
|
|
|
9714 |
|
|
sub_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg);
|
9715 |
|
|
|
9716 |
|
|
/* We don't copy orig_targs for this because if we have already deduced
|
9717 |
|
|
some template args from previous args, unify would complain when we
|
9718 |
|
|
try to deduce a template parameter for the same argument, even though
|
9719 |
|
|
there isn't really a conflict. */
|
9720 |
|
|
nargs = TREE_VEC_LENGTH (targs);
|
9721 |
|
|
tempargs = make_tree_vec (nargs);
|
9722 |
|
|
|
9723 |
|
|
if (unify (tparms, tempargs, parm, arg, sub_strict) != 0)
|
9724 |
|
|
return 0;
|
9725 |
|
|
|
9726 |
|
|
/* First make sure we didn't deduce anything that conflicts with
|
9727 |
|
|
explicitly specified args. */
|
9728 |
|
|
for (i = nargs; i--; )
|
9729 |
|
|
{
|
9730 |
|
|
tree elt = TREE_VEC_ELT (tempargs, i);
|
9731 |
|
|
tree oldelt = TREE_VEC_ELT (orig_targs, i);
|
9732 |
|
|
|
9733 |
|
|
if (!elt)
|
9734 |
|
|
/*NOP*/;
|
9735 |
|
|
else if (uses_template_parms (elt))
|
9736 |
|
|
/* Since we're unifying against ourselves, we will fill in
|
9737 |
|
|
template args used in the function parm list with our own
|
9738 |
|
|
template parms. Discard them. */
|
9739 |
|
|
TREE_VEC_ELT (tempargs, i) = NULL_TREE;
|
9740 |
|
|
else if (oldelt && !template_args_equal (oldelt, elt))
|
9741 |
|
|
return 0;
|
9742 |
|
|
}
|
9743 |
|
|
|
9744 |
|
|
for (i = nargs; i--; )
|
9745 |
|
|
{
|
9746 |
|
|
tree elt = TREE_VEC_ELT (tempargs, i);
|
9747 |
|
|
|
9748 |
|
|
if (elt)
|
9749 |
|
|
TREE_VEC_ELT (targs, i) = elt;
|
9750 |
|
|
}
|
9751 |
|
|
|
9752 |
|
|
return 1;
|
9753 |
|
|
}
|
9754 |
|
|
|
9755 |
|
|
/* PARM is a template class (perhaps with unbound template
|
9756 |
|
|
parameters). ARG is a fully instantiated type. If ARG can be
|
9757 |
|
|
bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
|
9758 |
|
|
TARGS are as for unify. */
|
9759 |
|
|
|
9760 |
|
|
static tree
|
9761 |
|
|
try_class_unification (tree tparms, tree targs, tree parm, tree arg)
|
9762 |
|
|
{
|
9763 |
|
|
tree copy_of_targs;
|
9764 |
|
|
|
9765 |
|
|
if (!CLASSTYPE_TEMPLATE_INFO (arg)
|
9766 |
|
|
|| (most_general_template (CLASSTYPE_TI_TEMPLATE (arg))
|
9767 |
|
|
!= most_general_template (CLASSTYPE_TI_TEMPLATE (parm))))
|
9768 |
|
|
return NULL_TREE;
|
9769 |
|
|
|
9770 |
|
|
/* We need to make a new template argument vector for the call to
|
9771 |
|
|
unify. If we used TARGS, we'd clutter it up with the result of
|
9772 |
|
|
the attempted unification, even if this class didn't work out.
|
9773 |
|
|
We also don't want to commit ourselves to all the unifications
|
9774 |
|
|
we've already done, since unification is supposed to be done on
|
9775 |
|
|
an argument-by-argument basis. In other words, consider the
|
9776 |
|
|
following pathological case:
|
9777 |
|
|
|
9778 |
|
|
template <int I, int J, int K>
|
9779 |
|
|
struct S {};
|
9780 |
|
|
|
9781 |
|
|
template <int I, int J>
|
9782 |
|
|
struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
|
9783 |
|
|
|
9784 |
|
|
template <int I, int J, int K>
|
9785 |
|
|
void f(S<I, J, K>, S<I, I, I>);
|
9786 |
|
|
|
9787 |
|
|
void g() {
|
9788 |
|
|
S<0, 0, 0> s0;
|
9789 |
|
|
S<0, 1, 2> s2;
|
9790 |
|
|
|
9791 |
|
|
f(s0, s2);
|
9792 |
|
|
}
|
9793 |
|
|
|
9794 |
|
|
Now, by the time we consider the unification involving `s2', we
|
9795 |
|
|
already know that we must have `f<0, 0, 0>'. But, even though
|
9796 |
|
|
`S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
|
9797 |
|
|
because there are two ways to unify base classes of S<0, 1, 2>
|
9798 |
|
|
with S<I, I, I>. If we kept the already deduced knowledge, we
|
9799 |
|
|
would reject the possibility I=1. */
|
9800 |
|
|
copy_of_targs = make_tree_vec (TREE_VEC_LENGTH (targs));
|
9801 |
|
|
|
9802 |
|
|
/* If unification failed, we're done. */
|
9803 |
|
|
if (unify (tparms, copy_of_targs, CLASSTYPE_TI_ARGS (parm),
|
9804 |
|
|
CLASSTYPE_TI_ARGS (arg), UNIFY_ALLOW_NONE))
|
9805 |
|
|
return NULL_TREE;
|
9806 |
|
|
|
9807 |
|
|
return arg;
|
9808 |
|
|
}
|
9809 |
|
|
|
9810 |
|
|
/* Given a template type PARM and a class type ARG, find the unique
|
9811 |
|
|
base type in ARG that is an instance of PARM. We do not examine
|
9812 |
|
|
ARG itself; only its base-classes. If there is not exactly one
|
9813 |
|
|
appropriate base class, return NULL_TREE. PARM may be the type of
|
9814 |
|
|
a partial specialization, as well as a plain template type. Used
|
9815 |
|
|
by unify. */
|
9816 |
|
|
|
9817 |
|
|
static tree
|
9818 |
|
|
get_template_base (tree tparms, tree targs, tree parm, tree arg)
|
9819 |
|
|
{
|
9820 |
|
|
tree rval = NULL_TREE;
|
9821 |
|
|
tree binfo;
|
9822 |
|
|
|
9823 |
|
|
gcc_assert (IS_AGGR_TYPE_CODE (TREE_CODE (arg)));
|
9824 |
|
|
|
9825 |
|
|
binfo = TYPE_BINFO (complete_type (arg));
|
9826 |
|
|
if (!binfo)
|
9827 |
|
|
/* The type could not be completed. */
|
9828 |
|
|
return NULL_TREE;
|
9829 |
|
|
|
9830 |
|
|
/* Walk in inheritance graph order. The search order is not
|
9831 |
|
|
important, and this avoids multiple walks of virtual bases. */
|
9832 |
|
|
for (binfo = TREE_CHAIN (binfo); binfo; binfo = TREE_CHAIN (binfo))
|
9833 |
|
|
{
|
9834 |
|
|
tree r = try_class_unification (tparms, targs, parm, BINFO_TYPE (binfo));
|
9835 |
|
|
|
9836 |
|
|
if (r)
|
9837 |
|
|
{
|
9838 |
|
|
/* If there is more than one satisfactory baseclass, then:
|
9839 |
|
|
|
9840 |
|
|
[temp.deduct.call]
|
9841 |
|
|
|
9842 |
|
|
If they yield more than one possible deduced A, the type
|
9843 |
|
|
deduction fails.
|
9844 |
|
|
|
9845 |
|
|
applies. */
|
9846 |
|
|
if (rval && !same_type_p (r, rval))
|
9847 |
|
|
return NULL_TREE;
|
9848 |
|
|
|
9849 |
|
|
rval = r;
|
9850 |
|
|
}
|
9851 |
|
|
}
|
9852 |
|
|
|
9853 |
|
|
return rval;
|
9854 |
|
|
}
|
9855 |
|
|
|
9856 |
|
|
/* Returns the level of DECL, which declares a template parameter. */
|
9857 |
|
|
|
9858 |
|
|
static int
|
9859 |
|
|
template_decl_level (tree decl)
|
9860 |
|
|
{
|
9861 |
|
|
switch (TREE_CODE (decl))
|
9862 |
|
|
{
|
9863 |
|
|
case TYPE_DECL:
|
9864 |
|
|
case TEMPLATE_DECL:
|
9865 |
|
|
return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl));
|
9866 |
|
|
|
9867 |
|
|
case PARM_DECL:
|
9868 |
|
|
return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl));
|
9869 |
|
|
|
9870 |
|
|
default:
|
9871 |
|
|
gcc_unreachable ();
|
9872 |
|
|
}
|
9873 |
|
|
return 0;
|
9874 |
|
|
}
|
9875 |
|
|
|
9876 |
|
|
/* Decide whether ARG can be unified with PARM, considering only the
|
9877 |
|
|
cv-qualifiers of each type, given STRICT as documented for unify.
|
9878 |
|
|
Returns nonzero iff the unification is OK on that basis. */
|
9879 |
|
|
|
9880 |
|
|
static int
|
9881 |
|
|
check_cv_quals_for_unify (int strict, tree arg, tree parm)
|
9882 |
|
|
{
|
9883 |
|
|
int arg_quals = cp_type_quals (arg);
|
9884 |
|
|
int parm_quals = cp_type_quals (parm);
|
9885 |
|
|
|
9886 |
|
|
if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
|
9887 |
|
|
&& !(strict & UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
|
9888 |
|
|
{
|
9889 |
|
|
/* Although a CVR qualifier is ignored when being applied to a
|
9890 |
|
|
substituted template parameter ([8.3.2]/1 for example), that
|
9891 |
|
|
does not apply during deduction [14.8.2.4]/1, (even though
|
9892 |
|
|
that is not explicitly mentioned, [14.8.2.4]/9 indicates
|
9893 |
|
|
this). Except when we're allowing additional CV qualifiers
|
9894 |
|
|
at the outer level [14.8.2.1]/3,1st bullet. */
|
9895 |
|
|
if ((TREE_CODE (arg) == REFERENCE_TYPE
|
9896 |
|
|
|| TREE_CODE (arg) == FUNCTION_TYPE
|
9897 |
|
|
|| TREE_CODE (arg) == METHOD_TYPE)
|
9898 |
|
|
&& (parm_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)))
|
9899 |
|
|
return 0;
|
9900 |
|
|
|
9901 |
|
|
if ((!POINTER_TYPE_P (arg) && TREE_CODE (arg) != TEMPLATE_TYPE_PARM)
|
9902 |
|
|
&& (parm_quals & TYPE_QUAL_RESTRICT))
|
9903 |
|
|
return 0;
|
9904 |
|
|
}
|
9905 |
|
|
|
9906 |
|
|
if (!(strict & (UNIFY_ALLOW_MORE_CV_QUAL | UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
|
9907 |
|
|
&& (arg_quals & parm_quals) != parm_quals)
|
9908 |
|
|
return 0;
|
9909 |
|
|
|
9910 |
|
|
if (!(strict & (UNIFY_ALLOW_LESS_CV_QUAL | UNIFY_ALLOW_OUTER_LESS_CV_QUAL))
|
9911 |
|
|
&& (parm_quals & arg_quals) != arg_quals)
|
9912 |
|
|
return 0;
|
9913 |
|
|
|
9914 |
|
|
return 1;
|
9915 |
|
|
}
|
9916 |
|
|
|
9917 |
|
|
/* Deduce the value of template parameters. TPARMS is the (innermost)
|
9918 |
|
|
set of template parameters to a template. TARGS is the bindings
|
9919 |
|
|
for those template parameters, as determined thus far; TARGS may
|
9920 |
|
|
include template arguments for outer levels of template parameters
|
9921 |
|
|
as well. PARM is a parameter to a template function, or a
|
9922 |
|
|
subcomponent of that parameter; ARG is the corresponding argument.
|
9923 |
|
|
This function attempts to match PARM with ARG in a manner
|
9924 |
|
|
consistent with the existing assignments in TARGS. If more values
|
9925 |
|
|
are deduced, then TARGS is updated.
|
9926 |
|
|
|
9927 |
|
|
Returns 0 if the type deduction succeeds, 1 otherwise. The
|
9928 |
|
|
parameter STRICT is a bitwise or of the following flags:
|
9929 |
|
|
|
9930 |
|
|
UNIFY_ALLOW_NONE:
|
9931 |
|
|
Require an exact match between PARM and ARG.
|
9932 |
|
|
UNIFY_ALLOW_MORE_CV_QUAL:
|
9933 |
|
|
Allow the deduced ARG to be more cv-qualified (by qualification
|
9934 |
|
|
conversion) than ARG.
|
9935 |
|
|
UNIFY_ALLOW_LESS_CV_QUAL:
|
9936 |
|
|
Allow the deduced ARG to be less cv-qualified than ARG.
|
9937 |
|
|
UNIFY_ALLOW_DERIVED:
|
9938 |
|
|
Allow the deduced ARG to be a template base class of ARG,
|
9939 |
|
|
or a pointer to a template base class of the type pointed to by
|
9940 |
|
|
ARG.
|
9941 |
|
|
UNIFY_ALLOW_INTEGER:
|
9942 |
|
|
Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
|
9943 |
|
|
case for more information.
|
9944 |
|
|
UNIFY_ALLOW_OUTER_LEVEL:
|
9945 |
|
|
This is the outermost level of a deduction. Used to determine validity
|
9946 |
|
|
of qualification conversions. A valid qualification conversion must
|
9947 |
|
|
have const qualified pointers leading up to the inner type which
|
9948 |
|
|
requires additional CV quals, except at the outer level, where const
|
9949 |
|
|
is not required [conv.qual]. It would be normal to set this flag in
|
9950 |
|
|
addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
|
9951 |
|
|
UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
|
9952 |
|
|
This is the outermost level of a deduction, and PARM can be more CV
|
9953 |
|
|
qualified at this point.
|
9954 |
|
|
UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
|
9955 |
|
|
This is the outermost level of a deduction, and PARM can be less CV
|
9956 |
|
|
qualified at this point. */
|
9957 |
|
|
|
9958 |
|
|
static int
|
9959 |
|
|
unify (tree tparms, tree targs, tree parm, tree arg, int strict)
|
9960 |
|
|
{
|
9961 |
|
|
int idx;
|
9962 |
|
|
tree targ;
|
9963 |
|
|
tree tparm;
|
9964 |
|
|
int strict_in = strict;
|
9965 |
|
|
|
9966 |
|
|
/* I don't think this will do the right thing with respect to types.
|
9967 |
|
|
But the only case I've seen it in so far has been array bounds, where
|
9968 |
|
|
signedness is the only information lost, and I think that will be
|
9969 |
|
|
okay. */
|
9970 |
|
|
while (TREE_CODE (parm) == NOP_EXPR)
|
9971 |
|
|
parm = TREE_OPERAND (parm, 0);
|
9972 |
|
|
|
9973 |
|
|
if (arg == error_mark_node)
|
9974 |
|
|
return 1;
|
9975 |
|
|
if (arg == unknown_type_node)
|
9976 |
|
|
/* We can't deduce anything from this, but we might get all the
|
9977 |
|
|
template args from other function args. */
|
9978 |
|
|
return 0;
|
9979 |
|
|
|
9980 |
|
|
/* If PARM uses template parameters, then we can't bail out here,
|
9981 |
|
|
even if ARG == PARM, since we won't record unifications for the
|
9982 |
|
|
template parameters. We might need them if we're trying to
|
9983 |
|
|
figure out which of two things is more specialized. */
|
9984 |
|
|
if (arg == parm && !uses_template_parms (parm))
|
9985 |
|
|
return 0;
|
9986 |
|
|
|
9987 |
|
|
/* Immediately reject some pairs that won't unify because of
|
9988 |
|
|
cv-qualification mismatches. */
|
9989 |
|
|
if (TREE_CODE (arg) == TREE_CODE (parm)
|
9990 |
|
|
&& TYPE_P (arg)
|
9991 |
|
|
/* It is the elements of the array which hold the cv quals of an array
|
9992 |
|
|
type, and the elements might be template type parms. We'll check
|
9993 |
|
|
when we recurse. */
|
9994 |
|
|
&& TREE_CODE (arg) != ARRAY_TYPE
|
9995 |
|
|
/* We check the cv-qualifiers when unifying with template type
|
9996 |
|
|
parameters below. We want to allow ARG `const T' to unify with
|
9997 |
|
|
PARM `T' for example, when computing which of two templates
|
9998 |
|
|
is more specialized, for example. */
|
9999 |
|
|
&& TREE_CODE (arg) != TEMPLATE_TYPE_PARM
|
10000 |
|
|
&& !check_cv_quals_for_unify (strict_in, arg, parm))
|
10001 |
|
|
return 1;
|
10002 |
|
|
|
10003 |
|
|
if (!(strict & UNIFY_ALLOW_OUTER_LEVEL)
|
10004 |
|
|
&& TYPE_P (parm) && !CP_TYPE_CONST_P (parm))
|
10005 |
|
|
strict &= ~UNIFY_ALLOW_MORE_CV_QUAL;
|
10006 |
|
|
strict &= ~UNIFY_ALLOW_OUTER_LEVEL;
|
10007 |
|
|
strict &= ~UNIFY_ALLOW_DERIVED;
|
10008 |
|
|
strict &= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
|
10009 |
|
|
strict &= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL;
|
10010 |
|
|
|
10011 |
|
|
switch (TREE_CODE (parm))
|
10012 |
|
|
{
|
10013 |
|
|
case TYPENAME_TYPE:
|
10014 |
|
|
case SCOPE_REF:
|
10015 |
|
|
case UNBOUND_CLASS_TEMPLATE:
|
10016 |
|
|
/* In a type which contains a nested-name-specifier, template
|
10017 |
|
|
argument values cannot be deduced for template parameters used
|
10018 |
|
|
within the nested-name-specifier. */
|
10019 |
|
|
return 0;
|
10020 |
|
|
|
10021 |
|
|
case TEMPLATE_TYPE_PARM:
|
10022 |
|
|
case TEMPLATE_TEMPLATE_PARM:
|
10023 |
|
|
case BOUND_TEMPLATE_TEMPLATE_PARM:
|
10024 |
|
|
tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
|
10025 |
|
|
|
10026 |
|
|
if (TEMPLATE_TYPE_LEVEL (parm)
|
10027 |
|
|
!= template_decl_level (tparm))
|
10028 |
|
|
/* The PARM is not one we're trying to unify. Just check
|
10029 |
|
|
to see if it matches ARG. */
|
10030 |
|
|
return (TREE_CODE (arg) == TREE_CODE (parm)
|
10031 |
|
|
&& same_type_p (parm, arg)) ? 0 : 1;
|
10032 |
|
|
idx = TEMPLATE_TYPE_IDX (parm);
|
10033 |
|
|
targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
|
10034 |
|
|
tparm = TREE_VALUE (TREE_VEC_ELT (tparms, idx));
|
10035 |
|
|
|
10036 |
|
|
/* Check for mixed types and values. */
|
10037 |
|
|
if ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
|
10038 |
|
|
&& TREE_CODE (tparm) != TYPE_DECL)
|
10039 |
|
|
|| (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
|
10040 |
|
|
&& TREE_CODE (tparm) != TEMPLATE_DECL))
|
10041 |
|
|
return 1;
|
10042 |
|
|
|
10043 |
|
|
if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
|
10044 |
|
|
{
|
10045 |
|
|
/* ARG must be constructed from a template class or a template
|
10046 |
|
|
template parameter. */
|
10047 |
|
|
if (TREE_CODE (arg) != BOUND_TEMPLATE_TEMPLATE_PARM
|
10048 |
|
|
&& (TREE_CODE (arg) != RECORD_TYPE || !CLASSTYPE_TEMPLATE_INFO (arg)))
|
10049 |
|
|
return 1;
|
10050 |
|
|
|
10051 |
|
|
{
|
10052 |
|
|
tree parmtmpl = TYPE_TI_TEMPLATE (parm);
|
10053 |
|
|
tree parmvec = TYPE_TI_ARGS (parm);
|
10054 |
|
|
tree argvec = INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg));
|
10055 |
|
|
tree argtmplvec
|
10056 |
|
|
= DECL_INNERMOST_TEMPLATE_PARMS (TYPE_TI_TEMPLATE (arg));
|
10057 |
|
|
int i;
|
10058 |
|
|
|
10059 |
|
|
/* The parameter and argument roles have to be switched here
|
10060 |
|
|
in order to handle default arguments properly. For example,
|
10061 |
|
|
template<template <class> class TT> void f(TT<int>)
|
10062 |
|
|
should be able to accept vector<int> which comes from
|
10063 |
|
|
template <class T, class Allocator = allocator>
|
10064 |
|
|
class vector. */
|
10065 |
|
|
|
10066 |
|
|
if (coerce_template_parms (argtmplvec, parmvec, parmtmpl, 0, 1)
|
10067 |
|
|
== error_mark_node)
|
10068 |
|
|
return 1;
|
10069 |
|
|
|
10070 |
|
|
/* Deduce arguments T, i from TT<T> or TT<i>.
|
10071 |
|
|
We check each element of PARMVEC and ARGVEC individually
|
10072 |
|
|
rather than the whole TREE_VEC since they can have
|
10073 |
|
|
different number of elements. */
|
10074 |
|
|
|
10075 |
|
|
for (i = 0; i < TREE_VEC_LENGTH (parmvec); ++i)
|
10076 |
|
|
{
|
10077 |
|
|
if (unify (tparms, targs,
|
10078 |
|
|
TREE_VEC_ELT (parmvec, i),
|
10079 |
|
|
TREE_VEC_ELT (argvec, i),
|
10080 |
|
|
UNIFY_ALLOW_NONE))
|
10081 |
|
|
return 1;
|
10082 |
|
|
}
|
10083 |
|
|
}
|
10084 |
|
|
arg = TYPE_TI_TEMPLATE (arg);
|
10085 |
|
|
|
10086 |
|
|
/* Fall through to deduce template name. */
|
10087 |
|
|
}
|
10088 |
|
|
|
10089 |
|
|
if (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
|
10090 |
|
|
|| TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
|
10091 |
|
|
{
|
10092 |
|
|
/* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
|
10093 |
|
|
|
10094 |
|
|
/* Simple cases: Value already set, does match or doesn't. */
|
10095 |
|
|
if (targ != NULL_TREE && template_args_equal (targ, arg))
|
10096 |
|
|
return 0;
|
10097 |
|
|
else if (targ)
|
10098 |
|
|
return 1;
|
10099 |
|
|
}
|
10100 |
|
|
else
|
10101 |
|
|
{
|
10102 |
|
|
/* If PARM is `const T' and ARG is only `int', we don't have
|
10103 |
|
|
a match unless we are allowing additional qualification.
|
10104 |
|
|
If ARG is `const int' and PARM is just `T' that's OK;
|
10105 |
|
|
that binds `const int' to `T'. */
|
10106 |
|
|
if (!check_cv_quals_for_unify (strict_in | UNIFY_ALLOW_LESS_CV_QUAL,
|
10107 |
|
|
arg, parm))
|
10108 |
|
|
return 1;
|
10109 |
|
|
|
10110 |
|
|
/* Consider the case where ARG is `const volatile int' and
|
10111 |
|
|
PARM is `const T'. Then, T should be `volatile int'. */
|
10112 |
|
|
arg = cp_build_qualified_type_real
|
10113 |
|
|
(arg, cp_type_quals (arg) & ~cp_type_quals (parm), tf_none);
|
10114 |
|
|
if (arg == error_mark_node)
|
10115 |
|
|
return 1;
|
10116 |
|
|
|
10117 |
|
|
/* Simple cases: Value already set, does match or doesn't. */
|
10118 |
|
|
if (targ != NULL_TREE && same_type_p (targ, arg))
|
10119 |
|
|
return 0;
|
10120 |
|
|
else if (targ)
|
10121 |
|
|
return 1;
|
10122 |
|
|
|
10123 |
|
|
/* Make sure that ARG is not a variable-sized array. (Note
|
10124 |
|
|
that were talking about variable-sized arrays (like
|
10125 |
|
|
`int[n]'), rather than arrays of unknown size (like
|
10126 |
|
|
`int[]').) We'll get very confused by such a type since
|
10127 |
|
|
the bound of the array will not be computable in an
|
10128 |
|
|
instantiation. Besides, such types are not allowed in
|
10129 |
|
|
ISO C++, so we can do as we please here. */
|
10130 |
|
|
if (variably_modified_type_p (arg, NULL_TREE))
|
10131 |
|
|
return 1;
|
10132 |
|
|
}
|
10133 |
|
|
|
10134 |
|
|
TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
|
10135 |
|
|
return 0;
|
10136 |
|
|
|
10137 |
|
|
case TEMPLATE_PARM_INDEX:
|
10138 |
|
|
tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
|
10139 |
|
|
|
10140 |
|
|
if (TEMPLATE_PARM_LEVEL (parm)
|
10141 |
|
|
!= template_decl_level (tparm))
|
10142 |
|
|
/* The PARM is not one we're trying to unify. Just check
|
10143 |
|
|
to see if it matches ARG. */
|
10144 |
|
|
return !(TREE_CODE (arg) == TREE_CODE (parm)
|
10145 |
|
|
&& cp_tree_equal (parm, arg));
|
10146 |
|
|
|
10147 |
|
|
idx = TEMPLATE_PARM_IDX (parm);
|
10148 |
|
|
targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
|
10149 |
|
|
|
10150 |
|
|
if (targ)
|
10151 |
|
|
return !cp_tree_equal (targ, arg);
|
10152 |
|
|
|
10153 |
|
|
/* [temp.deduct.type] If, in the declaration of a function template
|
10154 |
|
|
with a non-type template-parameter, the non-type
|
10155 |
|
|
template-parameter is used in an expression in the function
|
10156 |
|
|
parameter-list and, if the corresponding template-argument is
|
10157 |
|
|
deduced, the template-argument type shall match the type of the
|
10158 |
|
|
template-parameter exactly, except that a template-argument
|
10159 |
|
|
deduced from an array bound may be of any integral type.
|
10160 |
|
|
The non-type parameter might use already deduced type parameters. */
|
10161 |
|
|
tparm = tsubst (TREE_TYPE (parm), targs, 0, NULL_TREE);
|
10162 |
|
|
if (!TREE_TYPE (arg))
|
10163 |
|
|
/* Template-parameter dependent expression. Just accept it for now.
|
10164 |
|
|
It will later be processed in convert_template_argument. */
|
10165 |
|
|
;
|
10166 |
|
|
else if (same_type_p (TREE_TYPE (arg), tparm))
|
10167 |
|
|
/* OK */;
|
10168 |
|
|
else if ((strict & UNIFY_ALLOW_INTEGER)
|
10169 |
|
|
&& (TREE_CODE (tparm) == INTEGER_TYPE
|
10170 |
|
|
|| TREE_CODE (tparm) == BOOLEAN_TYPE))
|
10171 |
|
|
/* Convert the ARG to the type of PARM; the deduced non-type
|
10172 |
|
|
template argument must exactly match the types of the
|
10173 |
|
|
corresponding parameter. */
|
10174 |
|
|
arg = fold (build_nop (TREE_TYPE (parm), arg));
|
10175 |
|
|
else if (uses_template_parms (tparm))
|
10176 |
|
|
/* We haven't deduced the type of this parameter yet. Try again
|
10177 |
|
|
later. */
|
10178 |
|
|
return 0;
|
10179 |
|
|
else
|
10180 |
|
|
return 1;
|
10181 |
|
|
|
10182 |
|
|
TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
|
10183 |
|
|
return 0;
|
10184 |
|
|
|
10185 |
|
|
case PTRMEM_CST:
|
10186 |
|
|
{
|
10187 |
|
|
/* A pointer-to-member constant can be unified only with
|
10188 |
|
|
another constant. */
|
10189 |
|
|
if (TREE_CODE (arg) != PTRMEM_CST)
|
10190 |
|
|
return 1;
|
10191 |
|
|
|
10192 |
|
|
/* Just unify the class member. It would be useless (and possibly
|
10193 |
|
|
wrong, depending on the strict flags) to unify also
|
10194 |
|
|
PTRMEM_CST_CLASS, because we want to be sure that both parm and
|
10195 |
|
|
arg refer to the same variable, even if through different
|
10196 |
|
|
classes. For instance:
|
10197 |
|
|
|
10198 |
|
|
struct A { int x; };
|
10199 |
|
|
struct B : A { };
|
10200 |
|
|
|
10201 |
|
|
Unification of &A::x and &B::x must succeed. */
|
10202 |
|
|
return unify (tparms, targs, PTRMEM_CST_MEMBER (parm),
|
10203 |
|
|
PTRMEM_CST_MEMBER (arg), strict);
|
10204 |
|
|
}
|
10205 |
|
|
|
10206 |
|
|
case POINTER_TYPE:
|
10207 |
|
|
{
|
10208 |
|
|
if (TREE_CODE (arg) != POINTER_TYPE)
|
10209 |
|
|
return 1;
|
10210 |
|
|
|
10211 |
|
|
/* [temp.deduct.call]
|
10212 |
|
|
|
10213 |
|
|
A can be another pointer or pointer to member type that can
|
10214 |
|
|
be converted to the deduced A via a qualification
|
10215 |
|
|
conversion (_conv.qual_).
|
10216 |
|
|
|
10217 |
|
|
We pass down STRICT here rather than UNIFY_ALLOW_NONE.
|
10218 |
|
|
This will allow for additional cv-qualification of the
|
10219 |
|
|
pointed-to types if appropriate. */
|
10220 |
|
|
|
10221 |
|
|
if (TREE_CODE (TREE_TYPE (arg)) == RECORD_TYPE)
|
10222 |
|
|
/* The derived-to-base conversion only persists through one
|
10223 |
|
|
level of pointers. */
|
10224 |
|
|
strict |= (strict_in & UNIFY_ALLOW_DERIVED);
|
10225 |
|
|
|
10226 |
|
|
return unify (tparms, targs, TREE_TYPE (parm),
|
10227 |
|
|
TREE_TYPE (arg), strict);
|
10228 |
|
|
}
|
10229 |
|
|
|
10230 |
|
|
case REFERENCE_TYPE:
|
10231 |
|
|
if (TREE_CODE (arg) != REFERENCE_TYPE)
|
10232 |
|
|
return 1;
|
10233 |
|
|
return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
|
10234 |
|
|
strict & UNIFY_ALLOW_MORE_CV_QUAL);
|
10235 |
|
|
|
10236 |
|
|
case ARRAY_TYPE:
|
10237 |
|
|
if (TREE_CODE (arg) != ARRAY_TYPE)
|
10238 |
|
|
return 1;
|
10239 |
|
|
if ((TYPE_DOMAIN (parm) == NULL_TREE)
|
10240 |
|
|
!= (TYPE_DOMAIN (arg) == NULL_TREE))
|
10241 |
|
|
return 1;
|
10242 |
|
|
if (TYPE_DOMAIN (parm) != NULL_TREE)
|
10243 |
|
|
{
|
10244 |
|
|
tree parm_max;
|
10245 |
|
|
tree arg_max;
|
10246 |
|
|
|
10247 |
|
|
parm_max = TYPE_MAX_VALUE (TYPE_DOMAIN (parm));
|
10248 |
|
|
arg_max = TYPE_MAX_VALUE (TYPE_DOMAIN (arg));
|
10249 |
|
|
|
10250 |
|
|
/* Our representation of array types uses "N - 1" as the
|
10251 |
|
|
TYPE_MAX_VALUE for an array with "N" elements, if "N" is
|
10252 |
|
|
not an integer constant. */
|
10253 |
|
|
if (TREE_CODE (parm_max) == MINUS_EXPR)
|
10254 |
|
|
{
|
10255 |
|
|
arg_max = fold_build2 (PLUS_EXPR,
|
10256 |
|
|
integer_type_node,
|
10257 |
|
|
arg_max,
|
10258 |
|
|
TREE_OPERAND (parm_max, 1));
|
10259 |
|
|
parm_max = TREE_OPERAND (parm_max, 0);
|
10260 |
|
|
}
|
10261 |
|
|
|
10262 |
|
|
if (unify (tparms, targs, parm_max, arg_max, UNIFY_ALLOW_INTEGER))
|
10263 |
|
|
return 1;
|
10264 |
|
|
}
|
10265 |
|
|
return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
|
10266 |
|
|
strict & UNIFY_ALLOW_MORE_CV_QUAL);
|
10267 |
|
|
|
10268 |
|
|
case REAL_TYPE:
|
10269 |
|
|
case COMPLEX_TYPE:
|
10270 |
|
|
case VECTOR_TYPE:
|
10271 |
|
|
case INTEGER_TYPE:
|
10272 |
|
|
case BOOLEAN_TYPE:
|
10273 |
|
|
case ENUMERAL_TYPE:
|
10274 |
|
|
case VOID_TYPE:
|
10275 |
|
|
if (TREE_CODE (arg) != TREE_CODE (parm))
|
10276 |
|
|
return 1;
|
10277 |
|
|
|
10278 |
|
|
/* We have already checked cv-qualification at the top of the
|
10279 |
|
|
function. */
|
10280 |
|
|
if (!same_type_ignoring_top_level_qualifiers_p (arg, parm))
|
10281 |
|
|
return 1;
|
10282 |
|
|
|
10283 |
|
|
/* As far as unification is concerned, this wins. Later checks
|
10284 |
|
|
will invalidate it if necessary. */
|
10285 |
|
|
return 0;
|
10286 |
|
|
|
10287 |
|
|
/* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
|
10288 |
|
|
/* Type INTEGER_CST can come from ordinary constant template args. */
|
10289 |
|
|
case INTEGER_CST:
|
10290 |
|
|
while (TREE_CODE (arg) == NOP_EXPR)
|
10291 |
|
|
arg = TREE_OPERAND (arg, 0);
|
10292 |
|
|
|
10293 |
|
|
if (TREE_CODE (arg) != INTEGER_CST)
|
10294 |
|
|
return 1;
|
10295 |
|
|
return !tree_int_cst_equal (parm, arg);
|
10296 |
|
|
|
10297 |
|
|
case TREE_VEC:
|
10298 |
|
|
{
|
10299 |
|
|
int i;
|
10300 |
|
|
if (TREE_CODE (arg) != TREE_VEC)
|
10301 |
|
|
return 1;
|
10302 |
|
|
if (TREE_VEC_LENGTH (parm) != TREE_VEC_LENGTH (arg))
|
10303 |
|
|
return 1;
|
10304 |
|
|
for (i = 0; i < TREE_VEC_LENGTH (parm); ++i)
|
10305 |
|
|
if (unify (tparms, targs,
|
10306 |
|
|
TREE_VEC_ELT (parm, i), TREE_VEC_ELT (arg, i),
|
10307 |
|
|
UNIFY_ALLOW_NONE))
|
10308 |
|
|
return 1;
|
10309 |
|
|
return 0;
|
10310 |
|
|
}
|
10311 |
|
|
|
10312 |
|
|
case RECORD_TYPE:
|
10313 |
|
|
case UNION_TYPE:
|
10314 |
|
|
if (TREE_CODE (arg) != TREE_CODE (parm))
|
10315 |
|
|
return 1;
|
10316 |
|
|
|
10317 |
|
|
if (TYPE_PTRMEMFUNC_P (parm))
|
10318 |
|
|
{
|
10319 |
|
|
if (!TYPE_PTRMEMFUNC_P (arg))
|
10320 |
|
|
return 1;
|
10321 |
|
|
|
10322 |
|
|
return unify (tparms, targs,
|
10323 |
|
|
TYPE_PTRMEMFUNC_FN_TYPE (parm),
|
10324 |
|
|
TYPE_PTRMEMFUNC_FN_TYPE (arg),
|
10325 |
|
|
strict);
|
10326 |
|
|
}
|
10327 |
|
|
|
10328 |
|
|
if (CLASSTYPE_TEMPLATE_INFO (parm))
|
10329 |
|
|
{
|
10330 |
|
|
tree t = NULL_TREE;
|
10331 |
|
|
|
10332 |
|
|
if (strict_in & UNIFY_ALLOW_DERIVED)
|
10333 |
|
|
{
|
10334 |
|
|
/* First, we try to unify the PARM and ARG directly. */
|
10335 |
|
|
t = try_class_unification (tparms, targs,
|
10336 |
|
|
parm, arg);
|
10337 |
|
|
|
10338 |
|
|
if (!t)
|
10339 |
|
|
{
|
10340 |
|
|
/* Fallback to the special case allowed in
|
10341 |
|
|
[temp.deduct.call]:
|
10342 |
|
|
|
10343 |
|
|
If P is a class, and P has the form
|
10344 |
|
|
template-id, then A can be a derived class of
|
10345 |
|
|
the deduced A. Likewise, if P is a pointer to
|
10346 |
|
|
a class of the form template-id, A can be a
|
10347 |
|
|
pointer to a derived class pointed to by the
|
10348 |
|
|
deduced A. */
|
10349 |
|
|
t = get_template_base (tparms, targs, parm, arg);
|
10350 |
|
|
|
10351 |
|
|
if (!t)
|
10352 |
|
|
return 1;
|
10353 |
|
|
}
|
10354 |
|
|
}
|
10355 |
|
|
else if (CLASSTYPE_TEMPLATE_INFO (arg)
|
10356 |
|
|
&& (CLASSTYPE_TI_TEMPLATE (parm)
|
10357 |
|
|
== CLASSTYPE_TI_TEMPLATE (arg)))
|
10358 |
|
|
/* Perhaps PARM is something like S<U> and ARG is S<int>.
|
10359 |
|
|
Then, we should unify `int' and `U'. */
|
10360 |
|
|
t = arg;
|
10361 |
|
|
else
|
10362 |
|
|
/* There's no chance of unification succeeding. */
|
10363 |
|
|
return 1;
|
10364 |
|
|
|
10365 |
|
|
return unify (tparms, targs, CLASSTYPE_TI_ARGS (parm),
|
10366 |
|
|
CLASSTYPE_TI_ARGS (t), UNIFY_ALLOW_NONE);
|
10367 |
|
|
}
|
10368 |
|
|
else if (!same_type_ignoring_top_level_qualifiers_p (parm, arg))
|
10369 |
|
|
return 1;
|
10370 |
|
|
return 0;
|
10371 |
|
|
|
10372 |
|
|
case METHOD_TYPE:
|
10373 |
|
|
case FUNCTION_TYPE:
|
10374 |
|
|
if (TREE_CODE (arg) != TREE_CODE (parm))
|
10375 |
|
|
return 1;
|
10376 |
|
|
|
10377 |
|
|
/* CV qualifications for methods can never be deduced, they must
|
10378 |
|
|
match exactly. We need to check them explicitly here,
|
10379 |
|
|
because type_unification_real treats them as any other
|
10380 |
|
|
cvqualified parameter. */
|
10381 |
|
|
if (TREE_CODE (parm) == METHOD_TYPE
|
10382 |
|
|
&& (!check_cv_quals_for_unify
|
10383 |
|
|
(UNIFY_ALLOW_NONE,
|
10384 |
|
|
TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (arg))),
|
10385 |
|
|
TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (parm))))))
|
10386 |
|
|
return 1;
|
10387 |
|
|
|
10388 |
|
|
if (unify (tparms, targs, TREE_TYPE (parm),
|
10389 |
|
|
TREE_TYPE (arg), UNIFY_ALLOW_NONE))
|
10390 |
|
|
return 1;
|
10391 |
|
|
return type_unification_real (tparms, targs, TYPE_ARG_TYPES (parm),
|
10392 |
|
|
TYPE_ARG_TYPES (arg), 1, DEDUCE_EXACT,
|
10393 |
|
|
LOOKUP_NORMAL);
|
10394 |
|
|
|
10395 |
|
|
case OFFSET_TYPE:
|
10396 |
|
|
/* Unify a pointer to member with a pointer to member function, which
|
10397 |
|
|
deduces the type of the member as a function type. */
|
10398 |
|
|
if (TYPE_PTRMEMFUNC_P (arg))
|
10399 |
|
|
{
|
10400 |
|
|
tree method_type;
|
10401 |
|
|
tree fntype;
|
10402 |
|
|
cp_cv_quals cv_quals;
|
10403 |
|
|
|
10404 |
|
|
/* Check top-level cv qualifiers */
|
10405 |
|
|
if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE, arg, parm))
|
10406 |
|
|
return 1;
|
10407 |
|
|
|
10408 |
|
|
if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
|
10409 |
|
|
TYPE_PTRMEMFUNC_OBJECT_TYPE (arg), UNIFY_ALLOW_NONE))
|
10410 |
|
|
return 1;
|
10411 |
|
|
|
10412 |
|
|
/* Determine the type of the function we are unifying against. */
|
10413 |
|
|
method_type = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (arg));
|
10414 |
|
|
fntype =
|
10415 |
|
|
build_function_type (TREE_TYPE (method_type),
|
10416 |
|
|
TREE_CHAIN (TYPE_ARG_TYPES (method_type)));
|
10417 |
|
|
|
10418 |
|
|
/* Extract the cv-qualifiers of the member function from the
|
10419 |
|
|
implicit object parameter and place them on the function
|
10420 |
|
|
type to be restored later. */
|
10421 |
|
|
cv_quals =
|
10422 |
|
|
cp_type_quals(TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (method_type))));
|
10423 |
|
|
fntype = build_qualified_type (fntype, cv_quals);
|
10424 |
|
|
return unify (tparms, targs, TREE_TYPE (parm), fntype, strict);
|
10425 |
|
|
}
|
10426 |
|
|
|
10427 |
|
|
if (TREE_CODE (arg) != OFFSET_TYPE)
|
10428 |
|
|
return 1;
|
10429 |
|
|
if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
|
10430 |
|
|
TYPE_OFFSET_BASETYPE (arg), UNIFY_ALLOW_NONE))
|
10431 |
|
|
return 1;
|
10432 |
|
|
return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
|
10433 |
|
|
strict);
|
10434 |
|
|
|
10435 |
|
|
case CONST_DECL:
|
10436 |
|
|
if (DECL_TEMPLATE_PARM_P (parm))
|
10437 |
|
|
return unify (tparms, targs, DECL_INITIAL (parm), arg, strict);
|
10438 |
|
|
if (arg != integral_constant_value (parm))
|
10439 |
|
|
return 1;
|
10440 |
|
|
return 0;
|
10441 |
|
|
|
10442 |
|
|
case FIELD_DECL:
|
10443 |
|
|
case TEMPLATE_DECL:
|
10444 |
|
|
/* Matched cases are handled by the ARG == PARM test above. */
|
10445 |
|
|
return 1;
|
10446 |
|
|
|
10447 |
|
|
default:
|
10448 |
|
|
gcc_assert (EXPR_P (parm));
|
10449 |
|
|
|
10450 |
|
|
/* We must be looking at an expression. This can happen with
|
10451 |
|
|
something like:
|
10452 |
|
|
|
10453 |
|
|
template <int I>
|
10454 |
|
|
void foo(S<I>, S<I + 2>);
|
10455 |
|
|
|
10456 |
|
|
This is a "nondeduced context":
|
10457 |
|
|
|
10458 |
|
|
[deduct.type]
|
10459 |
|
|
|
10460 |
|
|
The nondeduced contexts are:
|
10461 |
|
|
|
10462 |
|
|
--A type that is a template-id in which one or more of
|
10463 |
|
|
the template-arguments is an expression that references
|
10464 |
|
|
a template-parameter.
|
10465 |
|
|
|
10466 |
|
|
In these cases, we assume deduction succeeded, but don't
|
10467 |
|
|
actually infer any unifications. */
|
10468 |
|
|
|
10469 |
|
|
if (!uses_template_parms (parm)
|
10470 |
|
|
&& !template_args_equal (parm, arg))
|
10471 |
|
|
return 1;
|
10472 |
|
|
else
|
10473 |
|
|
return 0;
|
10474 |
|
|
}
|
10475 |
|
|
}
|
10476 |
|
|
|
10477 |
|
|
/* Note that DECL can be defined in this translation unit, if
|
10478 |
|
|
required. */
|
10479 |
|
|
|
10480 |
|
|
static void
|
10481 |
|
|
mark_definable (tree decl)
|
10482 |
|
|
{
|
10483 |
|
|
tree clone;
|
10484 |
|
|
DECL_NOT_REALLY_EXTERN (decl) = 1;
|
10485 |
|
|
FOR_EACH_CLONE (clone, decl)
|
10486 |
|
|
DECL_NOT_REALLY_EXTERN (clone) = 1;
|
10487 |
|
|
}
|
10488 |
|
|
|
10489 |
|
|
/* Called if RESULT is explicitly instantiated, or is a member of an
|
10490 |
|
|
explicitly instantiated class. */
|
10491 |
|
|
|
10492 |
|
|
void
|
10493 |
|
|
mark_decl_instantiated (tree result, int extern_p)
|
10494 |
|
|
{
|
10495 |
|
|
SET_DECL_EXPLICIT_INSTANTIATION (result);
|
10496 |
|
|
|
10497 |
|
|
/* If this entity has already been written out, it's too late to
|
10498 |
|
|
make any modifications. */
|
10499 |
|
|
if (TREE_ASM_WRITTEN (result))
|
10500 |
|
|
return;
|
10501 |
|
|
|
10502 |
|
|
if (TREE_CODE (result) != FUNCTION_DECL)
|
10503 |
|
|
/* The TREE_PUBLIC flag for function declarations will have been
|
10504 |
|
|
set correctly by tsubst. */
|
10505 |
|
|
TREE_PUBLIC (result) = 1;
|
10506 |
|
|
|
10507 |
|
|
/* This might have been set by an earlier implicit instantiation. */
|
10508 |
|
|
DECL_COMDAT (result) = 0;
|
10509 |
|
|
|
10510 |
|
|
if (extern_p)
|
10511 |
|
|
DECL_NOT_REALLY_EXTERN (result) = 0;
|
10512 |
|
|
else
|
10513 |
|
|
{
|
10514 |
|
|
mark_definable (result);
|
10515 |
|
|
/* Always make artificials weak. */
|
10516 |
|
|
if (DECL_ARTIFICIAL (result) && flag_weak)
|
10517 |
|
|
comdat_linkage (result);
|
10518 |
|
|
/* For WIN32 we also want to put explicit instantiations in
|
10519 |
|
|
linkonce sections. */
|
10520 |
|
|
else if (TREE_PUBLIC (result))
|
10521 |
|
|
maybe_make_one_only (result);
|
10522 |
|
|
}
|
10523 |
|
|
|
10524 |
|
|
/* If EXTERN_P, then this function will not be emitted -- unless
|
10525 |
|
|
followed by an explicit instantiation, at which point its linkage
|
10526 |
|
|
will be adjusted. If !EXTERN_P, then this function will be
|
10527 |
|
|
emitted here. In neither circumstance do we want
|
10528 |
|
|
import_export_decl to adjust the linkage. */
|
10529 |
|
|
DECL_INTERFACE_KNOWN (result) = 1;
|
10530 |
|
|
}
|
10531 |
|
|
|
10532 |
|
|
/* Given two function templates PAT1 and PAT2, return:
|
10533 |
|
|
|
10534 |
|
|
1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
|
10535 |
|
|
-1 if PAT2 is more specialized than PAT1.
|
10536 |
|
|
|
10537 |
|
|
|
10538 |
|
|
LEN indicates the number of parameters we should consider
|
10539 |
|
|
(defaulted parameters should not be considered).
|
10540 |
|
|
|
10541 |
|
|
The 1998 std underspecified function template partial ordering, and
|
10542 |
|
|
DR214 addresses the issue. We take pairs of arguments, one from
|
10543 |
|
|
each of the templates, and deduce them against each other. One of
|
10544 |
|
|
the templates will be more specialized if all the *other*
|
10545 |
|
|
template's arguments deduce against its arguments and at least one
|
10546 |
|
|
of its arguments *does* *not* deduce against the other template's
|
10547 |
|
|
corresponding argument. Deduction is done as for class templates.
|
10548 |
|
|
The arguments used in deduction have reference and top level cv
|
10549 |
|
|
qualifiers removed. Iff both arguments were originally reference
|
10550 |
|
|
types *and* deduction succeeds in both directions, the template
|
10551 |
|
|
with the more cv-qualified argument wins for that pairing (if
|
10552 |
|
|
neither is more cv-qualified, they both are equal). Unlike regular
|
10553 |
|
|
deduction, after all the arguments have been deduced in this way,
|
10554 |
|
|
we do *not* verify the deduced template argument values can be
|
10555 |
|
|
substituted into non-deduced contexts, nor do we have to verify
|
10556 |
|
|
that all template arguments have been deduced. */
|
10557 |
|
|
|
10558 |
|
|
int
|
10559 |
|
|
more_specialized_fn (tree pat1, tree pat2, int len)
|
10560 |
|
|
{
|
10561 |
|
|
tree decl1 = DECL_TEMPLATE_RESULT (pat1);
|
10562 |
|
|
tree decl2 = DECL_TEMPLATE_RESULT (pat2);
|
10563 |
|
|
tree targs1 = make_tree_vec (DECL_NTPARMS (pat1));
|
10564 |
|
|
tree targs2 = make_tree_vec (DECL_NTPARMS (pat2));
|
10565 |
|
|
tree tparms1 = DECL_INNERMOST_TEMPLATE_PARMS (pat1);
|
10566 |
|
|
tree tparms2 = DECL_INNERMOST_TEMPLATE_PARMS (pat2);
|
10567 |
|
|
tree args1 = TYPE_ARG_TYPES (TREE_TYPE (decl1));
|
10568 |
|
|
tree args2 = TYPE_ARG_TYPES (TREE_TYPE (decl2));
|
10569 |
|
|
int better1 = 0;
|
10570 |
|
|
int better2 = 0;
|
10571 |
|
|
|
10572 |
|
|
/* Remove the this parameter from non-static member functions. If
|
10573 |
|
|
one is a non-static member function and the other is not a static
|
10574 |
|
|
member function, remove the first parameter from that function
|
10575 |
|
|
also. This situation occurs for operator functions where we
|
10576 |
|
|
locate both a member function (with this pointer) and non-member
|
10577 |
|
|
operator (with explicit first operand). */
|
10578 |
|
|
if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1))
|
10579 |
|
|
{
|
10580 |
|
|
len--; /* LEN is the number of significant arguments for DECL1 */
|
10581 |
|
|
args1 = TREE_CHAIN (args1);
|
10582 |
|
|
if (!DECL_STATIC_FUNCTION_P (decl2))
|
10583 |
|
|
args2 = TREE_CHAIN (args2);
|
10584 |
|
|
}
|
10585 |
|
|
else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2))
|
10586 |
|
|
{
|
10587 |
|
|
args2 = TREE_CHAIN (args2);
|
10588 |
|
|
if (!DECL_STATIC_FUNCTION_P (decl1))
|
10589 |
|
|
{
|
10590 |
|
|
len--;
|
10591 |
|
|
args1 = TREE_CHAIN (args1);
|
10592 |
|
|
}
|
10593 |
|
|
}
|
10594 |
|
|
|
10595 |
|
|
/* If only one is a conversion operator, they are unordered. */
|
10596 |
|
|
if (DECL_CONV_FN_P (decl1) != DECL_CONV_FN_P (decl2))
|
10597 |
|
|
return 0;
|
10598 |
|
|
|
10599 |
|
|
/* Consider the return type for a conversion function */
|
10600 |
|
|
if (DECL_CONV_FN_P (decl1))
|
10601 |
|
|
{
|
10602 |
|
|
args1 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl1)), args1);
|
10603 |
|
|
args2 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl2)), args2);
|
10604 |
|
|
len++;
|
10605 |
|
|
}
|
10606 |
|
|
|
10607 |
|
|
processing_template_decl++;
|
10608 |
|
|
|
10609 |
|
|
while (len--)
|
10610 |
|
|
{
|
10611 |
|
|
tree arg1 = TREE_VALUE (args1);
|
10612 |
|
|
tree arg2 = TREE_VALUE (args2);
|
10613 |
|
|
int deduce1, deduce2;
|
10614 |
|
|
int quals1 = -1;
|
10615 |
|
|
int quals2 = -1;
|
10616 |
|
|
|
10617 |
|
|
if (TREE_CODE (arg1) == REFERENCE_TYPE)
|
10618 |
|
|
{
|
10619 |
|
|
arg1 = TREE_TYPE (arg1);
|
10620 |
|
|
quals1 = cp_type_quals (arg1);
|
10621 |
|
|
}
|
10622 |
|
|
|
10623 |
|
|
if (TREE_CODE (arg2) == REFERENCE_TYPE)
|
10624 |
|
|
{
|
10625 |
|
|
arg2 = TREE_TYPE (arg2);
|
10626 |
|
|
quals2 = cp_type_quals (arg2);
|
10627 |
|
|
}
|
10628 |
|
|
|
10629 |
|
|
if ((quals1 < 0) != (quals2 < 0))
|
10630 |
|
|
{
|
10631 |
|
|
/* Only of the args is a reference, see if we should apply
|
10632 |
|
|
array/function pointer decay to it. This is not part of
|
10633 |
|
|
DR214, but is, IMHO, consistent with the deduction rules
|
10634 |
|
|
for the function call itself, and with our earlier
|
10635 |
|
|
implementation of the underspecified partial ordering
|
10636 |
|
|
rules. (nathan). */
|
10637 |
|
|
if (quals1 >= 0)
|
10638 |
|
|
{
|
10639 |
|
|
switch (TREE_CODE (arg1))
|
10640 |
|
|
{
|
10641 |
|
|
case ARRAY_TYPE:
|
10642 |
|
|
arg1 = TREE_TYPE (arg1);
|
10643 |
|
|
/* FALLTHROUGH. */
|
10644 |
|
|
case FUNCTION_TYPE:
|
10645 |
|
|
arg1 = build_pointer_type (arg1);
|
10646 |
|
|
break;
|
10647 |
|
|
|
10648 |
|
|
default:
|
10649 |
|
|
break;
|
10650 |
|
|
}
|
10651 |
|
|
}
|
10652 |
|
|
else
|
10653 |
|
|
{
|
10654 |
|
|
switch (TREE_CODE (arg2))
|
10655 |
|
|
{
|
10656 |
|
|
case ARRAY_TYPE:
|
10657 |
|
|
arg2 = TREE_TYPE (arg2);
|
10658 |
|
|
/* FALLTHROUGH. */
|
10659 |
|
|
case FUNCTION_TYPE:
|
10660 |
|
|
arg2 = build_pointer_type (arg2);
|
10661 |
|
|
break;
|
10662 |
|
|
|
10663 |
|
|
default:
|
10664 |
|
|
break;
|
10665 |
|
|
}
|
10666 |
|
|
}
|
10667 |
|
|
}
|
10668 |
|
|
|
10669 |
|
|
arg1 = TYPE_MAIN_VARIANT (arg1);
|
10670 |
|
|
arg2 = TYPE_MAIN_VARIANT (arg2);
|
10671 |
|
|
|
10672 |
|
|
deduce1 = !unify (tparms1, targs1, arg1, arg2, UNIFY_ALLOW_NONE);
|
10673 |
|
|
deduce2 = !unify (tparms2, targs2, arg2, arg1, UNIFY_ALLOW_NONE);
|
10674 |
|
|
|
10675 |
|
|
if (!deduce1)
|
10676 |
|
|
better2 = -1;
|
10677 |
|
|
if (!deduce2)
|
10678 |
|
|
better1 = -1;
|
10679 |
|
|
if (better1 < 0 && better2 < 0)
|
10680 |
|
|
/* We've failed to deduce something in either direction.
|
10681 |
|
|
These must be unordered. */
|
10682 |
|
|
break;
|
10683 |
|
|
|
10684 |
|
|
if (deduce1 && deduce2 && quals1 >= 0 && quals2 >= 0)
|
10685 |
|
|
{
|
10686 |
|
|
/* Deduces in both directions, see if quals can
|
10687 |
|
|
disambiguate. Pretend the worse one failed to deduce. */
|
10688 |
|
|
if ((quals1 & quals2) == quals2)
|
10689 |
|
|
deduce1 = 0;
|
10690 |
|
|
if ((quals1 & quals2) == quals1)
|
10691 |
|
|
deduce2 = 0;
|
10692 |
|
|
}
|
10693 |
|
|
if (deduce1 && !deduce2 && !better2)
|
10694 |
|
|
better2 = 1;
|
10695 |
|
|
if (deduce2 && !deduce1 && !better1)
|
10696 |
|
|
better1 = 1;
|
10697 |
|
|
|
10698 |
|
|
args1 = TREE_CHAIN (args1);
|
10699 |
|
|
args2 = TREE_CHAIN (args2);
|
10700 |
|
|
}
|
10701 |
|
|
|
10702 |
|
|
processing_template_decl--;
|
10703 |
|
|
|
10704 |
|
|
return (better1 > 0) - (better2 > 0);
|
10705 |
|
|
}
|
10706 |
|
|
|
10707 |
|
|
/* Determine which of two partial specializations is more specialized.
|
10708 |
|
|
|
10709 |
|
|
PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
|
10710 |
|
|
to the first partial specialization. The TREE_VALUE is the
|
10711 |
|
|
innermost set of template parameters for the partial
|
10712 |
|
|
specialization. PAT2 is similar, but for the second template.
|
10713 |
|
|
|
10714 |
|
|
Return 1 if the first partial specialization is more specialized;
|
10715 |
|
|
-1 if the second is more specialized; 0 if neither is more
|
10716 |
|
|
specialized.
|
10717 |
|
|
|
10718 |
|
|
See [temp.class.order] for information about determining which of
|
10719 |
|
|
two templates is more specialized. */
|
10720 |
|
|
|
10721 |
|
|
int
|
10722 |
|
|
more_specialized_class (tree pat1, tree pat2)
|
10723 |
|
|
{
|
10724 |
|
|
tree targs;
|
10725 |
|
|
tree tmpl1, tmpl2;
|
10726 |
|
|
int winner = 0;
|
10727 |
|
|
|
10728 |
|
|
tmpl1 = TREE_TYPE (pat1);
|
10729 |
|
|
tmpl2 = TREE_TYPE (pat2);
|
10730 |
|
|
|
10731 |
|
|
/* Just like what happens for functions, if we are ordering between
|
10732 |
|
|
different class template specializations, we may encounter dependent
|
10733 |
|
|
types in the arguments, and we need our dependency check functions
|
10734 |
|
|
to behave correctly. */
|
10735 |
|
|
++processing_template_decl;
|
10736 |
|
|
targs = get_class_bindings (TREE_VALUE (pat1),
|
10737 |
|
|
CLASSTYPE_TI_ARGS (tmpl1),
|
10738 |
|
|
CLASSTYPE_TI_ARGS (tmpl2));
|
10739 |
|
|
if (targs)
|
10740 |
|
|
--winner;
|
10741 |
|
|
|
10742 |
|
|
targs = get_class_bindings (TREE_VALUE (pat2),
|
10743 |
|
|
CLASSTYPE_TI_ARGS (tmpl2),
|
10744 |
|
|
CLASSTYPE_TI_ARGS (tmpl1));
|
10745 |
|
|
if (targs)
|
10746 |
|
|
++winner;
|
10747 |
|
|
--processing_template_decl;
|
10748 |
|
|
|
10749 |
|
|
return winner;
|
10750 |
|
|
}
|
10751 |
|
|
|
10752 |
|
|
/* Return the template arguments that will produce the function signature
|
10753 |
|
|
DECL from the function template FN, with the explicit template
|
10754 |
|
|
arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
|
10755 |
|
|
also match. Return NULL_TREE if no satisfactory arguments could be
|
10756 |
|
|
found. */
|
10757 |
|
|
|
10758 |
|
|
static tree
|
10759 |
|
|
get_bindings (tree fn, tree decl, tree explicit_args, bool check_rettype)
|
10760 |
|
|
{
|
10761 |
|
|
int ntparms = DECL_NTPARMS (fn);
|
10762 |
|
|
tree targs = make_tree_vec (ntparms);
|
10763 |
|
|
tree decl_type;
|
10764 |
|
|
tree decl_arg_types;
|
10765 |
|
|
|
10766 |
|
|
/* Substitute the explicit template arguments into the type of DECL.
|
10767 |
|
|
The call to fn_type_unification will handle substitution into the
|
10768 |
|
|
FN. */
|
10769 |
|
|
decl_type = TREE_TYPE (decl);
|
10770 |
|
|
if (explicit_args && uses_template_parms (decl_type))
|
10771 |
|
|
{
|
10772 |
|
|
tree tmpl;
|
10773 |
|
|
tree converted_args;
|
10774 |
|
|
|
10775 |
|
|
if (DECL_TEMPLATE_INFO (decl))
|
10776 |
|
|
tmpl = DECL_TI_TEMPLATE (decl);
|
10777 |
|
|
else
|
10778 |
|
|
/* We can get here for some invalid specializations. */
|
10779 |
|
|
return NULL_TREE;
|
10780 |
|
|
|
10781 |
|
|
converted_args
|
10782 |
|
|
= (coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
|
10783 |
|
|
explicit_args, NULL_TREE,
|
10784 |
|
|
tf_none, /*require_all_arguments=*/0));
|
10785 |
|
|
if (converted_args == error_mark_node)
|
10786 |
|
|
return NULL_TREE;
|
10787 |
|
|
|
10788 |
|
|
decl_type = tsubst (decl_type, converted_args, tf_none, NULL_TREE);
|
10789 |
|
|
if (decl_type == error_mark_node)
|
10790 |
|
|
return NULL_TREE;
|
10791 |
|
|
}
|
10792 |
|
|
|
10793 |
|
|
decl_arg_types = TYPE_ARG_TYPES (decl_type);
|
10794 |
|
|
/* Never do unification on the 'this' parameter. */
|
10795 |
|
|
if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
|
10796 |
|
|
decl_arg_types = TREE_CHAIN (decl_arg_types);
|
10797 |
|
|
|
10798 |
|
|
if (fn_type_unification (fn, explicit_args, targs,
|
10799 |
|
|
decl_arg_types,
|
10800 |
|
|
(check_rettype || DECL_CONV_FN_P (fn)
|
10801 |
|
|
? TREE_TYPE (decl_type) : NULL_TREE),
|
10802 |
|
|
DEDUCE_EXACT, LOOKUP_NORMAL))
|
10803 |
|
|
return NULL_TREE;
|
10804 |
|
|
|
10805 |
|
|
return targs;
|
10806 |
|
|
}
|
10807 |
|
|
|
10808 |
|
|
/* Return the innermost template arguments that, when applied to a
|
10809 |
|
|
template specialization whose innermost template parameters are
|
10810 |
|
|
TPARMS, and whose specialization arguments are PARMS, yield the
|
10811 |
|
|
ARGS.
|
10812 |
|
|
|
10813 |
|
|
For example, suppose we have:
|
10814 |
|
|
|
10815 |
|
|
template <class T, class U> struct S {};
|
10816 |
|
|
template <class T> struct S<T*, int> {};
|
10817 |
|
|
|
10818 |
|
|
Then, suppose we want to get `S<double*, int>'. The TPARMS will be
|
10819 |
|
|
{T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
|
10820 |
|
|
int}. The resulting vector will be {double}, indicating that `T'
|
10821 |
|
|
is bound to `double'. */
|
10822 |
|
|
|
10823 |
|
|
static tree
|
10824 |
|
|
get_class_bindings (tree tparms, tree spec_args, tree args)
|
10825 |
|
|
{
|
10826 |
|
|
int i, ntparms = TREE_VEC_LENGTH (tparms);
|
10827 |
|
|
tree deduced_args;
|
10828 |
|
|
tree innermost_deduced_args;
|
10829 |
|
|
|
10830 |
|
|
innermost_deduced_args = make_tree_vec (ntparms);
|
10831 |
|
|
if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
|
10832 |
|
|
{
|
10833 |
|
|
deduced_args = copy_node (args);
|
10834 |
|
|
SET_TMPL_ARGS_LEVEL (deduced_args,
|
10835 |
|
|
TMPL_ARGS_DEPTH (deduced_args),
|
10836 |
|
|
innermost_deduced_args);
|
10837 |
|
|
}
|
10838 |
|
|
else
|
10839 |
|
|
deduced_args = innermost_deduced_args;
|
10840 |
|
|
|
10841 |
|
|
if (unify (tparms, deduced_args,
|
10842 |
|
|
INNERMOST_TEMPLATE_ARGS (spec_args),
|
10843 |
|
|
INNERMOST_TEMPLATE_ARGS (args),
|
10844 |
|
|
UNIFY_ALLOW_NONE))
|
10845 |
|
|
return NULL_TREE;
|
10846 |
|
|
|
10847 |
|
|
for (i = 0; i < ntparms; ++i)
|
10848 |
|
|
if (! TREE_VEC_ELT (innermost_deduced_args, i))
|
10849 |
|
|
return NULL_TREE;
|
10850 |
|
|
|
10851 |
|
|
/* Verify that nondeduced template arguments agree with the type
|
10852 |
|
|
obtained from argument deduction.
|
10853 |
|
|
|
10854 |
|
|
For example:
|
10855 |
|
|
|
10856 |
|
|
struct A { typedef int X; };
|
10857 |
|
|
template <class T, class U> struct C {};
|
10858 |
|
|
template <class T> struct C<T, typename T::X> {};
|
10859 |
|
|
|
10860 |
|
|
Then with the instantiation `C<A, int>', we can deduce that
|
10861 |
|
|
`T' is `A' but unify () does not check whether `typename T::X'
|
10862 |
|
|
is `int'. */
|
10863 |
|
|
spec_args = tsubst (spec_args, deduced_args, tf_none, NULL_TREE);
|
10864 |
|
|
if (spec_args == error_mark_node
|
10865 |
|
|
/* We only need to check the innermost arguments; the other
|
10866 |
|
|
arguments will always agree. */
|
10867 |
|
|
|| !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args),
|
10868 |
|
|
INNERMOST_TEMPLATE_ARGS (args)))
|
10869 |
|
|
return NULL_TREE;
|
10870 |
|
|
|
10871 |
|
|
return deduced_args;
|
10872 |
|
|
}
|
10873 |
|
|
|
10874 |
|
|
/* In INSTANTIATIONS is a list of <INSTANTIATION, TEMPLATE> pairs.
|
10875 |
|
|
Pick the most specialized template, and return the corresponding
|
10876 |
|
|
instantiation, or if there is no corresponding instantiation, the
|
10877 |
|
|
template itself. If there is no most specialized template,
|
10878 |
|
|
error_mark_node is returned. If there are no templates at all,
|
10879 |
|
|
NULL_TREE is returned. */
|
10880 |
|
|
|
10881 |
|
|
tree
|
10882 |
|
|
most_specialized_instantiation (tree instantiations)
|
10883 |
|
|
{
|
10884 |
|
|
tree fn, champ;
|
10885 |
|
|
|
10886 |
|
|
if (!instantiations)
|
10887 |
|
|
return NULL_TREE;
|
10888 |
|
|
|
10889 |
|
|
++processing_template_decl;
|
10890 |
|
|
|
10891 |
|
|
champ = instantiations;
|
10892 |
|
|
for (fn = TREE_CHAIN (instantiations); fn; fn = TREE_CHAIN (fn))
|
10893 |
|
|
{
|
10894 |
|
|
int fate = 0;
|
10895 |
|
|
|
10896 |
|
|
if (get_bindings (TREE_VALUE (champ),
|
10897 |
|
|
DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
|
10898 |
|
|
NULL_TREE, /*check_ret=*/false))
|
10899 |
|
|
fate--;
|
10900 |
|
|
|
10901 |
|
|
if (get_bindings (TREE_VALUE (fn),
|
10902 |
|
|
DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
|
10903 |
|
|
NULL_TREE, /*check_ret=*/false))
|
10904 |
|
|
fate++;
|
10905 |
|
|
|
10906 |
|
|
if (fate == -1)
|
10907 |
|
|
champ = fn;
|
10908 |
|
|
else if (!fate)
|
10909 |
|
|
{
|
10910 |
|
|
/* Equally specialized, move to next function. If there
|
10911 |
|
|
is no next function, nothing's most specialized. */
|
10912 |
|
|
fn = TREE_CHAIN (fn);
|
10913 |
|
|
champ = fn;
|
10914 |
|
|
if (!fn)
|
10915 |
|
|
break;
|
10916 |
|
|
}
|
10917 |
|
|
}
|
10918 |
|
|
|
10919 |
|
|
if (champ)
|
10920 |
|
|
/* Now verify that champ is better than everything earlier in the
|
10921 |
|
|
instantiation list. */
|
10922 |
|
|
for (fn = instantiations; fn != champ; fn = TREE_CHAIN (fn))
|
10923 |
|
|
if (get_bindings (TREE_VALUE (champ),
|
10924 |
|
|
DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
|
10925 |
|
|
NULL_TREE, /*check_ret=*/false)
|
10926 |
|
|
|| !get_bindings (TREE_VALUE (fn),
|
10927 |
|
|
DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
|
10928 |
|
|
NULL_TREE, /*check_ret=*/false))
|
10929 |
|
|
{
|
10930 |
|
|
champ = NULL_TREE;
|
10931 |
|
|
break;
|
10932 |
|
|
}
|
10933 |
|
|
|
10934 |
|
|
processing_template_decl--;
|
10935 |
|
|
|
10936 |
|
|
if (!champ)
|
10937 |
|
|
return error_mark_node;
|
10938 |
|
|
|
10939 |
|
|
return TREE_PURPOSE (champ) ? TREE_PURPOSE (champ) : TREE_VALUE (champ);
|
10940 |
|
|
}
|
10941 |
|
|
|
10942 |
|
|
/* Return the most specialized of the list of templates in FNS that can
|
10943 |
|
|
produce an instantiation matching DECL, given the explicit template
|
10944 |
|
|
arguments EXPLICIT_ARGS. */
|
10945 |
|
|
|
10946 |
|
|
static tree
|
10947 |
|
|
most_specialized (tree fns, tree decl, tree explicit_args)
|
10948 |
|
|
{
|
10949 |
|
|
tree candidates = NULL_TREE;
|
10950 |
|
|
tree fn, args;
|
10951 |
|
|
|
10952 |
|
|
for (fn = fns; fn; fn = TREE_CHAIN (fn))
|
10953 |
|
|
{
|
10954 |
|
|
tree candidate = TREE_VALUE (fn);
|
10955 |
|
|
|
10956 |
|
|
args = get_bindings (candidate, decl, explicit_args, /*check_ret=*/true);
|
10957 |
|
|
if (args)
|
10958 |
|
|
candidates = tree_cons (NULL_TREE, candidate, candidates);
|
10959 |
|
|
}
|
10960 |
|
|
|
10961 |
|
|
return most_specialized_instantiation (candidates);
|
10962 |
|
|
}
|
10963 |
|
|
|
10964 |
|
|
/* If DECL is a specialization of some template, return the most
|
10965 |
|
|
general such template. Otherwise, returns NULL_TREE.
|
10966 |
|
|
|
10967 |
|
|
For example, given:
|
10968 |
|
|
|
10969 |
|
|
template <class T> struct S { template <class U> void f(U); };
|
10970 |
|
|
|
10971 |
|
|
if TMPL is `template <class U> void S<int>::f(U)' this will return
|
10972 |
|
|
the full template. This function will not trace past partial
|
10973 |
|
|
specializations, however. For example, given in addition:
|
10974 |
|
|
|
10975 |
|
|
template <class T> struct S<T*> { template <class U> void f(U); };
|
10976 |
|
|
|
10977 |
|
|
if TMPL is `template <class U> void S<int*>::f(U)' this will return
|
10978 |
|
|
`template <class T> template <class U> S<T*>::f(U)'. */
|
10979 |
|
|
|
10980 |
|
|
tree
|
10981 |
|
|
most_general_template (tree decl)
|
10982 |
|
|
{
|
10983 |
|
|
/* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
|
10984 |
|
|
an immediate specialization. */
|
10985 |
|
|
if (TREE_CODE (decl) == FUNCTION_DECL)
|
10986 |
|
|
{
|
10987 |
|
|
if (DECL_TEMPLATE_INFO (decl)) {
|
10988 |
|
|
decl = DECL_TI_TEMPLATE (decl);
|
10989 |
|
|
|
10990 |
|
|
/* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
|
10991 |
|
|
template friend. */
|
10992 |
|
|
if (TREE_CODE (decl) != TEMPLATE_DECL)
|
10993 |
|
|
return NULL_TREE;
|
10994 |
|
|
} else
|
10995 |
|
|
return NULL_TREE;
|
10996 |
|
|
}
|
10997 |
|
|
|
10998 |
|
|
/* Look for more and more general templates. */
|
10999 |
|
|
while (DECL_TEMPLATE_INFO (decl))
|
11000 |
|
|
{
|
11001 |
|
|
/* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
|
11002 |
|
|
(See cp-tree.h for details.) */
|
11003 |
|
|
if (TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
|
11004 |
|
|
break;
|
11005 |
|
|
|
11006 |
|
|
if (CLASS_TYPE_P (TREE_TYPE (decl))
|
11007 |
|
|
&& CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)))
|
11008 |
|
|
break;
|
11009 |
|
|
|
11010 |
|
|
/* Stop if we run into an explicitly specialized class template. */
|
11011 |
|
|
if (!DECL_NAMESPACE_SCOPE_P (decl)
|
11012 |
|
|
&& DECL_CONTEXT (decl)
|
11013 |
|
|
&& CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl)))
|
11014 |
|
|
break;
|
11015 |
|
|
|
11016 |
|
|
decl = DECL_TI_TEMPLATE (decl);
|
11017 |
|
|
}
|
11018 |
|
|
|
11019 |
|
|
return decl;
|
11020 |
|
|
}
|
11021 |
|
|
|
11022 |
|
|
/* Return the most specialized of the class template partial
|
11023 |
|
|
specializations of TMPL which can produce TYPE, a specialization of
|
11024 |
|
|
TMPL. The value returned is actually a TREE_LIST; the TREE_TYPE is
|
11025 |
|
|
a _TYPE node corresponding to the partial specialization, while the
|
11026 |
|
|
TREE_PURPOSE is the set of template arguments that must be
|
11027 |
|
|
substituted into the TREE_TYPE in order to generate TYPE.
|
11028 |
|
|
|
11029 |
|
|
If the choice of partial specialization is ambiguous, a diagnostic
|
11030 |
|
|
is issued, and the error_mark_node is returned. If there are no
|
11031 |
|
|
partial specializations of TMPL matching TYPE, then NULL_TREE is
|
11032 |
|
|
returned. */
|
11033 |
|
|
|
11034 |
|
|
static tree
|
11035 |
|
|
most_specialized_class (tree type, tree tmpl)
|
11036 |
|
|
{
|
11037 |
|
|
tree list = NULL_TREE;
|
11038 |
|
|
tree t;
|
11039 |
|
|
tree champ;
|
11040 |
|
|
int fate;
|
11041 |
|
|
bool ambiguous_p;
|
11042 |
|
|
tree args;
|
11043 |
|
|
|
11044 |
|
|
tmpl = most_general_template (tmpl);
|
11045 |
|
|
args = CLASSTYPE_TI_ARGS (type);
|
11046 |
|
|
for (t = DECL_TEMPLATE_SPECIALIZATIONS (tmpl); t; t = TREE_CHAIN (t))
|
11047 |
|
|
{
|
11048 |
|
|
tree partial_spec_args;
|
11049 |
|
|
tree spec_args;
|
11050 |
|
|
|
11051 |
|
|
partial_spec_args = CLASSTYPE_TI_ARGS (TREE_TYPE (t));
|
11052 |
|
|
spec_args = get_class_bindings (TREE_VALUE (t),
|
11053 |
|
|
partial_spec_args,
|
11054 |
|
|
args);
|
11055 |
|
|
if (spec_args)
|
11056 |
|
|
{
|
11057 |
|
|
list = tree_cons (spec_args, TREE_VALUE (t), list);
|
11058 |
|
|
TREE_TYPE (list) = TREE_TYPE (t);
|
11059 |
|
|
}
|
11060 |
|
|
}
|
11061 |
|
|
|
11062 |
|
|
if (! list)
|
11063 |
|
|
return NULL_TREE;
|
11064 |
|
|
|
11065 |
|
|
ambiguous_p = false;
|
11066 |
|
|
t = list;
|
11067 |
|
|
champ = t;
|
11068 |
|
|
t = TREE_CHAIN (t);
|
11069 |
|
|
for (; t; t = TREE_CHAIN (t))
|
11070 |
|
|
{
|
11071 |
|
|
fate = more_specialized_class (champ, t);
|
11072 |
|
|
if (fate == 1)
|
11073 |
|
|
;
|
11074 |
|
|
else
|
11075 |
|
|
{
|
11076 |
|
|
if (fate == 0)
|
11077 |
|
|
{
|
11078 |
|
|
t = TREE_CHAIN (t);
|
11079 |
|
|
if (! t)
|
11080 |
|
|
{
|
11081 |
|
|
ambiguous_p = true;
|
11082 |
|
|
break;
|
11083 |
|
|
}
|
11084 |
|
|
}
|
11085 |
|
|
champ = t;
|
11086 |
|
|
}
|
11087 |
|
|
}
|
11088 |
|
|
|
11089 |
|
|
if (!ambiguous_p)
|
11090 |
|
|
for (t = list; t && t != champ; t = TREE_CHAIN (t))
|
11091 |
|
|
{
|
11092 |
|
|
fate = more_specialized_class (champ, t);
|
11093 |
|
|
if (fate != 1)
|
11094 |
|
|
{
|
11095 |
|
|
ambiguous_p = true;
|
11096 |
|
|
break;
|
11097 |
|
|
}
|
11098 |
|
|
}
|
11099 |
|
|
|
11100 |
|
|
if (ambiguous_p)
|
11101 |
|
|
{
|
11102 |
|
|
const char *str = "candidates are:";
|
11103 |
|
|
error ("ambiguous class template instantiation for %q#T", type);
|
11104 |
|
|
for (t = list; t; t = TREE_CHAIN (t))
|
11105 |
|
|
{
|
11106 |
|
|
error ("%s %+#T", str, TREE_TYPE (t));
|
11107 |
|
|
str = " ";
|
11108 |
|
|
}
|
11109 |
|
|
return error_mark_node;
|
11110 |
|
|
}
|
11111 |
|
|
|
11112 |
|
|
return champ;
|
11113 |
|
|
}
|
11114 |
|
|
|
11115 |
|
|
/* Explicitly instantiate DECL. */
|
11116 |
|
|
|
11117 |
|
|
void
|
11118 |
|
|
do_decl_instantiation (tree decl, tree storage)
|
11119 |
|
|
{
|
11120 |
|
|
tree result = NULL_TREE;
|
11121 |
|
|
int extern_p = 0;
|
11122 |
|
|
|
11123 |
|
|
if (!decl || decl == error_mark_node)
|
11124 |
|
|
/* An error occurred, for which grokdeclarator has already issued
|
11125 |
|
|
an appropriate message. */
|
11126 |
|
|
return;
|
11127 |
|
|
else if (! DECL_LANG_SPECIFIC (decl))
|
11128 |
|
|
{
|
11129 |
|
|
error ("explicit instantiation of non-template %q#D", decl);
|
11130 |
|
|
return;
|
11131 |
|
|
}
|
11132 |
|
|
else if (TREE_CODE (decl) == VAR_DECL)
|
11133 |
|
|
{
|
11134 |
|
|
/* There is an asymmetry here in the way VAR_DECLs and
|
11135 |
|
|
FUNCTION_DECLs are handled by grokdeclarator. In the case of
|
11136 |
|
|
the latter, the DECL we get back will be marked as a
|
11137 |
|
|
template instantiation, and the appropriate
|
11138 |
|
|
DECL_TEMPLATE_INFO will be set up. This does not happen for
|
11139 |
|
|
VAR_DECLs so we do the lookup here. Probably, grokdeclarator
|
11140 |
|
|
should handle VAR_DECLs as it currently handles
|
11141 |
|
|
FUNCTION_DECLs. */
|
11142 |
|
|
result = lookup_field (DECL_CONTEXT (decl), DECL_NAME (decl), 0, false);
|
11143 |
|
|
if (!result || TREE_CODE (result) != VAR_DECL)
|
11144 |
|
|
{
|
11145 |
|
|
error ("no matching template for %qD found", decl);
|
11146 |
|
|
return;
|
11147 |
|
|
}
|
11148 |
|
|
}
|
11149 |
|
|
else if (TREE_CODE (decl) != FUNCTION_DECL)
|
11150 |
|
|
{
|
11151 |
|
|
error ("explicit instantiation of %q#D", decl);
|
11152 |
|
|
return;
|
11153 |
|
|
}
|
11154 |
|
|
else
|
11155 |
|
|
result = decl;
|
11156 |
|
|
|
11157 |
|
|
/* Check for various error cases. Note that if the explicit
|
11158 |
|
|
instantiation is valid the RESULT will currently be marked as an
|
11159 |
|
|
*implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
|
11160 |
|
|
until we get here. */
|
11161 |
|
|
|
11162 |
|
|
if (DECL_TEMPLATE_SPECIALIZATION (result))
|
11163 |
|
|
{
|
11164 |
|
|
/* DR 259 [temp.spec].
|
11165 |
|
|
|
11166 |
|
|
Both an explicit instantiation and a declaration of an explicit
|
11167 |
|
|
specialization shall not appear in a program unless the explicit
|
11168 |
|
|
instantiation follows a declaration of the explicit specialization.
|
11169 |
|
|
|
11170 |
|
|
For a given set of template parameters, if an explicit
|
11171 |
|
|
instantiation of a template appears after a declaration of an
|
11172 |
|
|
explicit specialization for that template, the explicit
|
11173 |
|
|
instantiation has no effect. */
|
11174 |
|
|
return;
|
11175 |
|
|
}
|
11176 |
|
|
else if (DECL_EXPLICIT_INSTANTIATION (result))
|
11177 |
|
|
{
|
11178 |
|
|
/* [temp.spec]
|
11179 |
|
|
|
11180 |
|
|
No program shall explicitly instantiate any template more
|
11181 |
|
|
than once.
|
11182 |
|
|
|
11183 |
|
|
We check DECL_NOT_REALLY_EXTERN so as not to complain when
|
11184 |
|
|
the first instantiation was `extern' and the second is not,
|
11185 |
|
|
and EXTERN_P for the opposite case. */
|
11186 |
|
|
if (DECL_NOT_REALLY_EXTERN (result) && !extern_p)
|
11187 |
|
|
pedwarn ("duplicate explicit instantiation of %q#D", result);
|
11188 |
|
|
/* If an "extern" explicit instantiation follows an ordinary
|
11189 |
|
|
explicit instantiation, the template is instantiated. */
|
11190 |
|
|
if (extern_p)
|
11191 |
|
|
return;
|
11192 |
|
|
}
|
11193 |
|
|
else if (!DECL_IMPLICIT_INSTANTIATION (result))
|
11194 |
|
|
{
|
11195 |
|
|
error ("no matching template for %qD found", result);
|
11196 |
|
|
return;
|
11197 |
|
|
}
|
11198 |
|
|
else if (!DECL_TEMPLATE_INFO (result))
|
11199 |
|
|
{
|
11200 |
|
|
pedwarn ("explicit instantiation of non-template %q#D", result);
|
11201 |
|
|
return;
|
11202 |
|
|
}
|
11203 |
|
|
|
11204 |
|
|
if (storage == NULL_TREE)
|
11205 |
|
|
;
|
11206 |
|
|
else if (storage == ridpointers[(int) RID_EXTERN])
|
11207 |
|
|
{
|
11208 |
|
|
if (pedantic && !in_system_header)
|
11209 |
|
|
pedwarn ("ISO C++ forbids the use of %<extern%> on explicit "
|
11210 |
|
|
"instantiations");
|
11211 |
|
|
extern_p = 1;
|
11212 |
|
|
}
|
11213 |
|
|
else
|
11214 |
|
|
error ("storage class %qD applied to template instantiation", storage);
|
11215 |
|
|
|
11216 |
|
|
check_explicit_instantiation_namespace (result);
|
11217 |
|
|
mark_decl_instantiated (result, extern_p);
|
11218 |
|
|
if (! extern_p)
|
11219 |
|
|
instantiate_decl (result, /*defer_ok=*/1,
|
11220 |
|
|
/*expl_inst_class_mem_p=*/false);
|
11221 |
|
|
}
|
11222 |
|
|
|
11223 |
|
|
void
|
11224 |
|
|
mark_class_instantiated (tree t, int extern_p)
|
11225 |
|
|
{
|
11226 |
|
|
SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t);
|
11227 |
|
|
SET_CLASSTYPE_INTERFACE_KNOWN (t);
|
11228 |
|
|
CLASSTYPE_INTERFACE_ONLY (t) = extern_p;
|
11229 |
|
|
TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = extern_p;
|
11230 |
|
|
if (! extern_p)
|
11231 |
|
|
{
|
11232 |
|
|
CLASSTYPE_DEBUG_REQUESTED (t) = 1;
|
11233 |
|
|
rest_of_type_compilation (t, 1);
|
11234 |
|
|
}
|
11235 |
|
|
}
|
11236 |
|
|
|
11237 |
|
|
/* Called from do_type_instantiation through binding_table_foreach to
|
11238 |
|
|
do recursive instantiation for the type bound in ENTRY. */
|
11239 |
|
|
static void
|
11240 |
|
|
bt_instantiate_type_proc (binding_entry entry, void *data)
|
11241 |
|
|
{
|
11242 |
|
|
tree storage = *(tree *) data;
|
11243 |
|
|
|
11244 |
|
|
if (IS_AGGR_TYPE (entry->type)
|
11245 |
|
|
&& !uses_template_parms (CLASSTYPE_TI_ARGS (entry->type)))
|
11246 |
|
|
do_type_instantiation (TYPE_MAIN_DECL (entry->type), storage, 0);
|
11247 |
|
|
}
|
11248 |
|
|
|
11249 |
|
|
/* Called from do_type_instantiation to instantiate a member
|
11250 |
|
|
(a member function or a static member variable) of an
|
11251 |
|
|
explicitly instantiated class template. */
|
11252 |
|
|
static void
|
11253 |
|
|
instantiate_class_member (tree decl, int extern_p)
|
11254 |
|
|
{
|
11255 |
|
|
mark_decl_instantiated (decl, extern_p);
|
11256 |
|
|
if (! extern_p)
|
11257 |
|
|
instantiate_decl (decl, /*defer_ok=*/1,
|
11258 |
|
|
/*expl_inst_class_mem_p=*/true);
|
11259 |
|
|
}
|
11260 |
|
|
|
11261 |
|
|
/* Perform an explicit instantiation of template class T. STORAGE, if
|
11262 |
|
|
non-null, is the RID for extern, inline or static. COMPLAIN is
|
11263 |
|
|
nonzero if this is called from the parser, zero if called recursively,
|
11264 |
|
|
since the standard is unclear (as detailed below). */
|
11265 |
|
|
|
11266 |
|
|
void
|
11267 |
|
|
do_type_instantiation (tree t, tree storage, tsubst_flags_t complain)
|
11268 |
|
|
{
|
11269 |
|
|
int extern_p = 0;
|
11270 |
|
|
int nomem_p = 0;
|
11271 |
|
|
int static_p = 0;
|
11272 |
|
|
int previous_instantiation_extern_p = 0;
|
11273 |
|
|
|
11274 |
|
|
if (TREE_CODE (t) == TYPE_DECL)
|
11275 |
|
|
t = TREE_TYPE (t);
|
11276 |
|
|
|
11277 |
|
|
if (! CLASS_TYPE_P (t) || ! CLASSTYPE_TEMPLATE_INFO (t))
|
11278 |
|
|
{
|
11279 |
|
|
error ("explicit instantiation of non-template type %qT", t);
|
11280 |
|
|
return;
|
11281 |
|
|
}
|
11282 |
|
|
|
11283 |
|
|
complete_type (t);
|
11284 |
|
|
|
11285 |
|
|
if (!COMPLETE_TYPE_P (t))
|
11286 |
|
|
{
|
11287 |
|
|
if (complain & tf_error)
|
11288 |
|
|
error ("explicit instantiation of %q#T before definition of template",
|
11289 |
|
|
t);
|
11290 |
|
|
return;
|
11291 |
|
|
}
|
11292 |
|
|
|
11293 |
|
|
if (storage != NULL_TREE)
|
11294 |
|
|
{
|
11295 |
|
|
if (pedantic && !in_system_header)
|
11296 |
|
|
pedwarn("ISO C++ forbids the use of %qE on explicit instantiations",
|
11297 |
|
|
storage);
|
11298 |
|
|
|
11299 |
|
|
if (storage == ridpointers[(int) RID_INLINE])
|
11300 |
|
|
nomem_p = 1;
|
11301 |
|
|
else if (storage == ridpointers[(int) RID_EXTERN])
|
11302 |
|
|
extern_p = 1;
|
11303 |
|
|
else if (storage == ridpointers[(int) RID_STATIC])
|
11304 |
|
|
static_p = 1;
|
11305 |
|
|
else
|
11306 |
|
|
{
|
11307 |
|
|
error ("storage class %qD applied to template instantiation",
|
11308 |
|
|
storage);
|
11309 |
|
|
extern_p = 0;
|
11310 |
|
|
}
|
11311 |
|
|
}
|
11312 |
|
|
|
11313 |
|
|
if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
|
11314 |
|
|
{
|
11315 |
|
|
/* DR 259 [temp.spec].
|
11316 |
|
|
|
11317 |
|
|
Both an explicit instantiation and a declaration of an explicit
|
11318 |
|
|
specialization shall not appear in a program unless the explicit
|
11319 |
|
|
instantiation follows a declaration of the explicit specialization.
|
11320 |
|
|
|
11321 |
|
|
For a given set of template parameters, if an explicit
|
11322 |
|
|
instantiation of a template appears after a declaration of an
|
11323 |
|
|
explicit specialization for that template, the explicit
|
11324 |
|
|
instantiation has no effect. */
|
11325 |
|
|
return;
|
11326 |
|
|
}
|
11327 |
|
|
else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t))
|
11328 |
|
|
{
|
11329 |
|
|
/* [temp.spec]
|
11330 |
|
|
|
11331 |
|
|
No program shall explicitly instantiate any template more
|
11332 |
|
|
than once.
|
11333 |
|
|
|
11334 |
|
|
If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
|
11335 |
|
|
instantiation was `extern'. If EXTERN_P then the second is.
|
11336 |
|
|
These cases are OK. */
|
11337 |
|
|
previous_instantiation_extern_p = CLASSTYPE_INTERFACE_ONLY (t);
|
11338 |
|
|
|
11339 |
|
|
if (!previous_instantiation_extern_p && !extern_p
|
11340 |
|
|
&& (complain & tf_error))
|
11341 |
|
|
pedwarn ("duplicate explicit instantiation of %q#T", t);
|
11342 |
|
|
|
11343 |
|
|
/* If we've already instantiated the template, just return now. */
|
11344 |
|
|
if (!CLASSTYPE_INTERFACE_ONLY (t))
|
11345 |
|
|
return;
|
11346 |
|
|
}
|
11347 |
|
|
|
11348 |
|
|
check_explicit_instantiation_namespace (TYPE_NAME (t));
|
11349 |
|
|
mark_class_instantiated (t, extern_p);
|
11350 |
|
|
|
11351 |
|
|
if (nomem_p)
|
11352 |
|
|
return;
|
11353 |
|
|
|
11354 |
|
|
{
|
11355 |
|
|
tree tmp;
|
11356 |
|
|
|
11357 |
|
|
/* In contrast to implicit instantiation, where only the
|
11358 |
|
|
declarations, and not the definitions, of members are
|
11359 |
|
|
instantiated, we have here:
|
11360 |
|
|
|
11361 |
|
|
[temp.explicit]
|
11362 |
|
|
|
11363 |
|
|
The explicit instantiation of a class template specialization
|
11364 |
|
|
implies the instantiation of all of its members not
|
11365 |
|
|
previously explicitly specialized in the translation unit
|
11366 |
|
|
containing the explicit instantiation.
|
11367 |
|
|
|
11368 |
|
|
Of course, we can't instantiate member template classes, since
|
11369 |
|
|
we don't have any arguments for them. Note that the standard
|
11370 |
|
|
is unclear on whether the instantiation of the members are
|
11371 |
|
|
*explicit* instantiations or not. However, the most natural
|
11372 |
|
|
interpretation is that it should be an explicit instantiation. */
|
11373 |
|
|
|
11374 |
|
|
if (! static_p)
|
11375 |
|
|
for (tmp = TYPE_METHODS (t); tmp; tmp = TREE_CHAIN (tmp))
|
11376 |
|
|
if (TREE_CODE (tmp) == FUNCTION_DECL
|
11377 |
|
|
&& DECL_TEMPLATE_INSTANTIATION (tmp))
|
11378 |
|
|
instantiate_class_member (tmp, extern_p);
|
11379 |
|
|
|
11380 |
|
|
for (tmp = TYPE_FIELDS (t); tmp; tmp = TREE_CHAIN (tmp))
|
11381 |
|
|
if (TREE_CODE (tmp) == VAR_DECL && DECL_TEMPLATE_INSTANTIATION (tmp))
|
11382 |
|
|
instantiate_class_member (tmp, extern_p);
|
11383 |
|
|
|
11384 |
|
|
if (CLASSTYPE_NESTED_UTDS (t))
|
11385 |
|
|
binding_table_foreach (CLASSTYPE_NESTED_UTDS (t),
|
11386 |
|
|
bt_instantiate_type_proc, &storage);
|
11387 |
|
|
}
|
11388 |
|
|
}
|
11389 |
|
|
|
11390 |
|
|
/* Given a function DECL, which is a specialization of TMPL, modify
|
11391 |
|
|
DECL to be a re-instantiation of TMPL with the same template
|
11392 |
|
|
arguments. TMPL should be the template into which tsubst'ing
|
11393 |
|
|
should occur for DECL, not the most general template.
|
11394 |
|
|
|
11395 |
|
|
One reason for doing this is a scenario like this:
|
11396 |
|
|
|
11397 |
|
|
template <class T>
|
11398 |
|
|
void f(const T&, int i);
|
11399 |
|
|
|
11400 |
|
|
void g() { f(3, 7); }
|
11401 |
|
|
|
11402 |
|
|
template <class T>
|
11403 |
|
|
void f(const T& t, const int i) { }
|
11404 |
|
|
|
11405 |
|
|
Note that when the template is first instantiated, with
|
11406 |
|
|
instantiate_template, the resulting DECL will have no name for the
|
11407 |
|
|
first parameter, and the wrong type for the second. So, when we go
|
11408 |
|
|
to instantiate the DECL, we regenerate it. */
|
11409 |
|
|
|
11410 |
|
|
static void
|
11411 |
|
|
regenerate_decl_from_template (tree decl, tree tmpl)
|
11412 |
|
|
{
|
11413 |
|
|
/* The arguments used to instantiate DECL, from the most general
|
11414 |
|
|
template. */
|
11415 |
|
|
tree args;
|
11416 |
|
|
tree code_pattern;
|
11417 |
|
|
|
11418 |
|
|
args = DECL_TI_ARGS (decl);
|
11419 |
|
|
code_pattern = DECL_TEMPLATE_RESULT (tmpl);
|
11420 |
|
|
|
11421 |
|
|
/* Make sure that we can see identifiers, and compute access
|
11422 |
|
|
correctly. */
|
11423 |
|
|
push_access_scope (decl);
|
11424 |
|
|
|
11425 |
|
|
if (TREE_CODE (decl) == FUNCTION_DECL)
|
11426 |
|
|
{
|
11427 |
|
|
tree decl_parm;
|
11428 |
|
|
tree pattern_parm;
|
11429 |
|
|
tree specs;
|
11430 |
|
|
int args_depth;
|
11431 |
|
|
int parms_depth;
|
11432 |
|
|
|
11433 |
|
|
args_depth = TMPL_ARGS_DEPTH (args);
|
11434 |
|
|
parms_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
|
11435 |
|
|
if (args_depth > parms_depth)
|
11436 |
|
|
args = get_innermost_template_args (args, parms_depth);
|
11437 |
|
|
|
11438 |
|
|
specs = tsubst_exception_specification (TREE_TYPE (code_pattern),
|
11439 |
|
|
args, tf_error, NULL_TREE);
|
11440 |
|
|
if (specs)
|
11441 |
|
|
TREE_TYPE (decl) = build_exception_variant (TREE_TYPE (decl),
|
11442 |
|
|
specs);
|
11443 |
|
|
|
11444 |
|
|
/* Merge parameter declarations. */
|
11445 |
|
|
decl_parm = skip_artificial_parms_for (decl,
|
11446 |
|
|
DECL_ARGUMENTS (decl));
|
11447 |
|
|
pattern_parm
|
11448 |
|
|
= skip_artificial_parms_for (code_pattern,
|
11449 |
|
|
DECL_ARGUMENTS (code_pattern));
|
11450 |
|
|
while (decl_parm)
|
11451 |
|
|
{
|
11452 |
|
|
tree parm_type;
|
11453 |
|
|
tree attributes;
|
11454 |
|
|
|
11455 |
|
|
if (DECL_NAME (decl_parm) != DECL_NAME (pattern_parm))
|
11456 |
|
|
DECL_NAME (decl_parm) = DECL_NAME (pattern_parm);
|
11457 |
|
|
parm_type = tsubst (TREE_TYPE (pattern_parm), args, tf_error,
|
11458 |
|
|
NULL_TREE);
|
11459 |
|
|
parm_type = type_decays_to (parm_type);
|
11460 |
|
|
if (!same_type_p (TREE_TYPE (decl_parm), parm_type))
|
11461 |
|
|
TREE_TYPE (decl_parm) = parm_type;
|
11462 |
|
|
attributes = DECL_ATTRIBUTES (pattern_parm);
|
11463 |
|
|
if (DECL_ATTRIBUTES (decl_parm) != attributes)
|
11464 |
|
|
{
|
11465 |
|
|
DECL_ATTRIBUTES (decl_parm) = attributes;
|
11466 |
|
|
cplus_decl_attributes (&decl_parm, attributes, /*flags=*/0);
|
11467 |
|
|
}
|
11468 |
|
|
decl_parm = TREE_CHAIN (decl_parm);
|
11469 |
|
|
pattern_parm = TREE_CHAIN (pattern_parm);
|
11470 |
|
|
}
|
11471 |
|
|
|
11472 |
|
|
/* Merge additional specifiers from the CODE_PATTERN. */
|
11473 |
|
|
if (DECL_DECLARED_INLINE_P (code_pattern)
|
11474 |
|
|
&& !DECL_DECLARED_INLINE_P (decl))
|
11475 |
|
|
DECL_DECLARED_INLINE_P (decl) = 1;
|
11476 |
|
|
if (DECL_INLINE (code_pattern) && !DECL_INLINE (decl))
|
11477 |
|
|
DECL_INLINE (decl) = 1;
|
11478 |
|
|
}
|
11479 |
|
|
else if (TREE_CODE (decl) == VAR_DECL)
|
11480 |
|
|
DECL_INITIAL (decl) =
|
11481 |
|
|
tsubst_expr (DECL_INITIAL (code_pattern), args,
|
11482 |
|
|
tf_error, DECL_TI_TEMPLATE (decl));
|
11483 |
|
|
else
|
11484 |
|
|
gcc_unreachable ();
|
11485 |
|
|
|
11486 |
|
|
pop_access_scope (decl);
|
11487 |
|
|
}
|
11488 |
|
|
|
11489 |
|
|
/* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
|
11490 |
|
|
substituted to get DECL. */
|
11491 |
|
|
|
11492 |
|
|
tree
|
11493 |
|
|
template_for_substitution (tree decl)
|
11494 |
|
|
{
|
11495 |
|
|
tree tmpl = DECL_TI_TEMPLATE (decl);
|
11496 |
|
|
|
11497 |
|
|
/* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
|
11498 |
|
|
for the instantiation. This is not always the most general
|
11499 |
|
|
template. Consider, for example:
|
11500 |
|
|
|
11501 |
|
|
template <class T>
|
11502 |
|
|
struct S { template <class U> void f();
|
11503 |
|
|
template <> void f<int>(); };
|
11504 |
|
|
|
11505 |
|
|
and an instantiation of S<double>::f<int>. We want TD to be the
|
11506 |
|
|
specialization S<T>::f<int>, not the more general S<T>::f<U>. */
|
11507 |
|
|
while (/* An instantiation cannot have a definition, so we need a
|
11508 |
|
|
more general template. */
|
11509 |
|
|
DECL_TEMPLATE_INSTANTIATION (tmpl)
|
11510 |
|
|
/* We must also deal with friend templates. Given:
|
11511 |
|
|
|
11512 |
|
|
template <class T> struct S {
|
11513 |
|
|
template <class U> friend void f() {};
|
11514 |
|
|
};
|
11515 |
|
|
|
11516 |
|
|
S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
|
11517 |
|
|
so far as the language is concerned, but that's still
|
11518 |
|
|
where we get the pattern for the instantiation from. On
|
11519 |
|
|
other hand, if the definition comes outside the class, say:
|
11520 |
|
|
|
11521 |
|
|
template <class T> struct S {
|
11522 |
|
|
template <class U> friend void f();
|
11523 |
|
|
};
|
11524 |
|
|
template <class U> friend void f() {}
|
11525 |
|
|
|
11526 |
|
|
we don't need to look any further. That's what the check for
|
11527 |
|
|
DECL_INITIAL is for. */
|
11528 |
|
|
|| (TREE_CODE (decl) == FUNCTION_DECL
|
11529 |
|
|
&& DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl)
|
11530 |
|
|
&& !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl))))
|
11531 |
|
|
{
|
11532 |
|
|
/* The present template, TD, should not be a definition. If it
|
11533 |
|
|
were a definition, we should be using it! Note that we
|
11534 |
|
|
cannot restructure the loop to just keep going until we find
|
11535 |
|
|
a template with a definition, since that might go too far if
|
11536 |
|
|
a specialization was declared, but not defined. */
|
11537 |
|
|
gcc_assert (TREE_CODE (decl) != VAR_DECL
|
11538 |
|
|
|| DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (tmpl)));
|
11539 |
|
|
|
11540 |
|
|
/* Fetch the more general template. */
|
11541 |
|
|
tmpl = DECL_TI_TEMPLATE (tmpl);
|
11542 |
|
|
}
|
11543 |
|
|
|
11544 |
|
|
return tmpl;
|
11545 |
|
|
}
|
11546 |
|
|
|
11547 |
|
|
/* Produce the definition of D, a _DECL generated from a template. If
|
11548 |
|
|
DEFER_OK is nonzero, then we don't have to actually do the
|
11549 |
|
|
instantiation now; we just have to do it sometime. Normally it is
|
11550 |
|
|
an error if this is an explicit instantiation but D is undefined.
|
11551 |
|
|
EXPL_INST_CLASS_MEM_P is true iff D is a member of an
|
11552 |
|
|
explicitly instantiated class template. */
|
11553 |
|
|
|
11554 |
|
|
tree
|
11555 |
|
|
instantiate_decl (tree d, int defer_ok,
|
11556 |
|
|
bool expl_inst_class_mem_p)
|
11557 |
|
|
{
|
11558 |
|
|
tree tmpl = DECL_TI_TEMPLATE (d);
|
11559 |
|
|
tree gen_args;
|
11560 |
|
|
tree args;
|
11561 |
|
|
tree td;
|
11562 |
|
|
tree code_pattern;
|
11563 |
|
|
tree spec;
|
11564 |
|
|
tree gen_tmpl;
|
11565 |
|
|
bool pattern_defined;
|
11566 |
|
|
int need_push;
|
11567 |
|
|
location_t saved_loc = input_location;
|
11568 |
|
|
bool external_p;
|
11569 |
|
|
|
11570 |
|
|
/* This function should only be used to instantiate templates for
|
11571 |
|
|
functions and static member variables. */
|
11572 |
|
|
gcc_assert (TREE_CODE (d) == FUNCTION_DECL
|
11573 |
|
|
|| TREE_CODE (d) == VAR_DECL);
|
11574 |
|
|
|
11575 |
|
|
/* Variables are never deferred; if instantiation is required, they
|
11576 |
|
|
are instantiated right away. That allows for better code in the
|
11577 |
|
|
case that an expression refers to the value of the variable --
|
11578 |
|
|
if the variable has a constant value the referring expression can
|
11579 |
|
|
take advantage of that fact. */
|
11580 |
|
|
if (TREE_CODE (d) == VAR_DECL)
|
11581 |
|
|
defer_ok = 0;
|
11582 |
|
|
|
11583 |
|
|
/* Don't instantiate cloned functions. Instead, instantiate the
|
11584 |
|
|
functions they cloned. */
|
11585 |
|
|
if (TREE_CODE (d) == FUNCTION_DECL && DECL_CLONED_FUNCTION_P (d))
|
11586 |
|
|
d = DECL_CLONED_FUNCTION (d);
|
11587 |
|
|
|
11588 |
|
|
if (DECL_TEMPLATE_INSTANTIATED (d))
|
11589 |
|
|
/* D has already been instantiated. It might seem reasonable to
|
11590 |
|
|
check whether or not D is an explicit instantiation, and, if so,
|
11591 |
|
|
stop here. But when an explicit instantiation is deferred
|
11592 |
|
|
until the end of the compilation, DECL_EXPLICIT_INSTANTIATION
|
11593 |
|
|
is set, even though we still need to do the instantiation. */
|
11594 |
|
|
return d;
|
11595 |
|
|
|
11596 |
|
|
/* If we already have a specialization of this declaration, then
|
11597 |
|
|
there's no reason to instantiate it. Note that
|
11598 |
|
|
retrieve_specialization gives us both instantiations and
|
11599 |
|
|
specializations, so we must explicitly check
|
11600 |
|
|
DECL_TEMPLATE_SPECIALIZATION. */
|
11601 |
|
|
gen_tmpl = most_general_template (tmpl);
|
11602 |
|
|
gen_args = DECL_TI_ARGS (d);
|
11603 |
|
|
spec = retrieve_specialization (gen_tmpl, gen_args,
|
11604 |
|
|
/*class_specializations_p=*/false);
|
11605 |
|
|
if (spec != NULL_TREE && DECL_TEMPLATE_SPECIALIZATION (spec))
|
11606 |
|
|
return spec;
|
11607 |
|
|
|
11608 |
|
|
/* This needs to happen before any tsubsting. */
|
11609 |
|
|
if (! push_tinst_level (d))
|
11610 |
|
|
return d;
|
11611 |
|
|
|
11612 |
|
|
timevar_push (TV_PARSE);
|
11613 |
|
|
|
11614 |
|
|
/* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
|
11615 |
|
|
for the instantiation. */
|
11616 |
|
|
td = template_for_substitution (d);
|
11617 |
|
|
code_pattern = DECL_TEMPLATE_RESULT (td);
|
11618 |
|
|
|
11619 |
|
|
/* We should never be trying to instantiate a member of a class
|
11620 |
|
|
template or partial specialization. */
|
11621 |
|
|
gcc_assert (d != code_pattern);
|
11622 |
|
|
|
11623 |
|
|
if ((DECL_NAMESPACE_SCOPE_P (d) && !DECL_INITIALIZED_IN_CLASS_P (d))
|
11624 |
|
|
|| DECL_TEMPLATE_SPECIALIZATION (td))
|
11625 |
|
|
/* In the case of a friend template whose definition is provided
|
11626 |
|
|
outside the class, we may have too many arguments. Drop the
|
11627 |
|
|
ones we don't need. The same is true for specializations. */
|
11628 |
|
|
args = get_innermost_template_args
|
11629 |
|
|
(gen_args, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td)));
|
11630 |
|
|
else
|
11631 |
|
|
args = gen_args;
|
11632 |
|
|
|
11633 |
|
|
if (TREE_CODE (d) == FUNCTION_DECL)
|
11634 |
|
|
pattern_defined = (DECL_SAVED_TREE (code_pattern) != NULL_TREE);
|
11635 |
|
|
else
|
11636 |
|
|
pattern_defined = ! DECL_IN_AGGR_P (code_pattern);
|
11637 |
|
|
|
11638 |
|
|
/* We may be in the middle of deferred access check. Disable it now. */
|
11639 |
|
|
push_deferring_access_checks (dk_no_deferred);
|
11640 |
|
|
|
11641 |
|
|
/* Unless an explicit instantiation directive has already determined
|
11642 |
|
|
the linkage of D, remember that a definition is available for
|
11643 |
|
|
this entity. */
|
11644 |
|
|
if (pattern_defined
|
11645 |
|
|
&& !DECL_INTERFACE_KNOWN (d)
|
11646 |
|
|
&& !DECL_NOT_REALLY_EXTERN (d))
|
11647 |
|
|
mark_definable (d);
|
11648 |
|
|
|
11649 |
|
|
input_location = DECL_SOURCE_LOCATION (d);
|
11650 |
|
|
|
11651 |
|
|
/* If D is a member of an explicitly instantiated class template,
|
11652 |
|
|
and no definition is available, treat it like an implicit
|
11653 |
|
|
instantiation. */
|
11654 |
|
|
if (!pattern_defined && expl_inst_class_mem_p
|
11655 |
|
|
&& DECL_EXPLICIT_INSTANTIATION (d))
|
11656 |
|
|
{
|
11657 |
|
|
DECL_NOT_REALLY_EXTERN (d) = 0;
|
11658 |
|
|
DECL_INTERFACE_KNOWN (d) = 0;
|
11659 |
|
|
SET_DECL_IMPLICIT_INSTANTIATION (d);
|
11660 |
|
|
}
|
11661 |
|
|
|
11662 |
|
|
if (!defer_ok)
|
11663 |
|
|
{
|
11664 |
|
|
/* Recheck the substitutions to obtain any warning messages
|
11665 |
|
|
about ignoring cv qualifiers. */
|
11666 |
|
|
tree gen = DECL_TEMPLATE_RESULT (gen_tmpl);
|
11667 |
|
|
tree type = TREE_TYPE (gen);
|
11668 |
|
|
|
11669 |
|
|
/* Make sure that we can see identifiers, and compute access
|
11670 |
|
|
correctly. D is already the target FUNCTION_DECL with the
|
11671 |
|
|
right context. */
|
11672 |
|
|
push_access_scope (d);
|
11673 |
|
|
|
11674 |
|
|
if (TREE_CODE (gen) == FUNCTION_DECL)
|
11675 |
|
|
{
|
11676 |
|
|
tsubst (DECL_ARGUMENTS (gen), gen_args, tf_error | tf_warning, d);
|
11677 |
|
|
tsubst (TYPE_RAISES_EXCEPTIONS (type), gen_args,
|
11678 |
|
|
tf_error | tf_warning, d);
|
11679 |
|
|
/* Don't simply tsubst the function type, as that will give
|
11680 |
|
|
duplicate warnings about poor parameter qualifications.
|
11681 |
|
|
The function arguments are the same as the decl_arguments
|
11682 |
|
|
without the top level cv qualifiers. */
|
11683 |
|
|
type = TREE_TYPE (type);
|
11684 |
|
|
}
|
11685 |
|
|
tsubst (type, gen_args, tf_error | tf_warning, d);
|
11686 |
|
|
|
11687 |
|
|
pop_access_scope (d);
|
11688 |
|
|
}
|
11689 |
|
|
|
11690 |
|
|
/* Check to see whether we know that this template will be
|
11691 |
|
|
instantiated in some other file, as with "extern template"
|
11692 |
|
|
extension. */
|
11693 |
|
|
external_p = (DECL_INTERFACE_KNOWN (d) && DECL_REALLY_EXTERN (d));
|
11694 |
|
|
/* In general, we do not instantiate such templates... */
|
11695 |
|
|
if (external_p
|
11696 |
|
|
/* ... but we instantiate inline functions so that we can inline
|
11697 |
|
|
them and ... */
|
11698 |
|
|
&& ! (TREE_CODE (d) == FUNCTION_DECL && DECL_INLINE (d))
|
11699 |
|
|
/* ... we instantiate static data members whose values are
|
11700 |
|
|
needed in integral constant expressions. */
|
11701 |
|
|
&& ! (TREE_CODE (d) == VAR_DECL
|
11702 |
|
|
&& DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (d)))
|
11703 |
|
|
goto out;
|
11704 |
|
|
/* Defer all other templates, unless we have been explicitly
|
11705 |
|
|
forbidden from doing so. */
|
11706 |
|
|
if (/* If there is no definition, we cannot instantiate the
|
11707 |
|
|
template. */
|
11708 |
|
|
! pattern_defined
|
11709 |
|
|
/* If it's OK to postpone instantiation, do so. */
|
11710 |
|
|
|| defer_ok
|
11711 |
|
|
/* If this is a static data member that will be defined
|
11712 |
|
|
elsewhere, we don't want to instantiate the entire data
|
11713 |
|
|
member, but we do want to instantiate the initializer so that
|
11714 |
|
|
we can substitute that elsewhere. */
|
11715 |
|
|
|| (external_p && TREE_CODE (d) == VAR_DECL))
|
11716 |
|
|
{
|
11717 |
|
|
/* The definition of the static data member is now required so
|
11718 |
|
|
we must substitute the initializer. */
|
11719 |
|
|
if (TREE_CODE (d) == VAR_DECL
|
11720 |
|
|
&& !DECL_INITIAL (d)
|
11721 |
|
|
&& DECL_INITIAL (code_pattern))
|
11722 |
|
|
{
|
11723 |
|
|
tree ns;
|
11724 |
|
|
tree init;
|
11725 |
|
|
|
11726 |
|
|
ns = decl_namespace_context (d);
|
11727 |
|
|
push_nested_namespace (ns);
|
11728 |
|
|
push_nested_class (DECL_CONTEXT (d));
|
11729 |
|
|
init = tsubst_expr (DECL_INITIAL (code_pattern),
|
11730 |
|
|
args,
|
11731 |
|
|
tf_error | tf_warning, NULL_TREE);
|
11732 |
|
|
DECL_INITIAL (d) = init;
|
11733 |
|
|
cp_finish_decl (d, init, /*init_const_expr_p=*/false,
|
11734 |
|
|
/*asmspec_tree=*/NULL_TREE,
|
11735 |
|
|
LOOKUP_ONLYCONVERTING);
|
11736 |
|
|
pop_nested_class ();
|
11737 |
|
|
pop_nested_namespace (ns);
|
11738 |
|
|
}
|
11739 |
|
|
|
11740 |
|
|
/* We restore the source position here because it's used by
|
11741 |
|
|
add_pending_template. */
|
11742 |
|
|
input_location = saved_loc;
|
11743 |
|
|
|
11744 |
|
|
if (at_eof && !pattern_defined
|
11745 |
|
|
&& DECL_EXPLICIT_INSTANTIATION (d))
|
11746 |
|
|
/* [temp.explicit]
|
11747 |
|
|
|
11748 |
|
|
The definition of a non-exported function template, a
|
11749 |
|
|
non-exported member function template, or a non-exported
|
11750 |
|
|
member function or static data member of a class template
|
11751 |
|
|
shall be present in every translation unit in which it is
|
11752 |
|
|
explicitly instantiated. */
|
11753 |
|
|
pedwarn
|
11754 |
|
|
("explicit instantiation of %qD but no definition available", d);
|
11755 |
|
|
|
11756 |
|
|
/* ??? Historically, we have instantiated inline functions, even
|
11757 |
|
|
when marked as "extern template". */
|
11758 |
|
|
if (!(external_p && TREE_CODE (d) == VAR_DECL))
|
11759 |
|
|
add_pending_template (d);
|
11760 |
|
|
goto out;
|
11761 |
|
|
}
|
11762 |
|
|
/* Tell the repository that D is available in this translation unit
|
11763 |
|
|
-- and see if it is supposed to be instantiated here. */
|
11764 |
|
|
if (TREE_PUBLIC (d) && !DECL_REALLY_EXTERN (d) && !repo_emit_p (d))
|
11765 |
|
|
{
|
11766 |
|
|
/* In a PCH file, despite the fact that the repository hasn't
|
11767 |
|
|
requested instantiation in the PCH it is still possible that
|
11768 |
|
|
an instantiation will be required in a file that includes the
|
11769 |
|
|
PCH. */
|
11770 |
|
|
if (pch_file)
|
11771 |
|
|
add_pending_template (d);
|
11772 |
|
|
/* Instantiate inline functions so that the inliner can do its
|
11773 |
|
|
job, even though we'll not be emitting a copy of this
|
11774 |
|
|
function. */
|
11775 |
|
|
if (!(TREE_CODE (d) == FUNCTION_DECL
|
11776 |
|
|
&& flag_inline_trees
|
11777 |
|
|
&& DECL_DECLARED_INLINE_P (d)))
|
11778 |
|
|
goto out;
|
11779 |
|
|
}
|
11780 |
|
|
|
11781 |
|
|
need_push = !cfun || !global_bindings_p ();
|
11782 |
|
|
if (need_push)
|
11783 |
|
|
push_to_top_level ();
|
11784 |
|
|
|
11785 |
|
|
/* Mark D as instantiated so that recursive calls to
|
11786 |
|
|
instantiate_decl do not try to instantiate it again. */
|
11787 |
|
|
DECL_TEMPLATE_INSTANTIATED (d) = 1;
|
11788 |
|
|
|
11789 |
|
|
/* Regenerate the declaration in case the template has been modified
|
11790 |
|
|
by a subsequent redeclaration. */
|
11791 |
|
|
regenerate_decl_from_template (d, td);
|
11792 |
|
|
|
11793 |
|
|
/* We already set the file and line above. Reset them now in case
|
11794 |
|
|
they changed as a result of calling regenerate_decl_from_template. */
|
11795 |
|
|
input_location = DECL_SOURCE_LOCATION (d);
|
11796 |
|
|
|
11797 |
|
|
if (TREE_CODE (d) == VAR_DECL)
|
11798 |
|
|
{
|
11799 |
|
|
/* Clear out DECL_RTL; whatever was there before may not be right
|
11800 |
|
|
since we've reset the type of the declaration. */
|
11801 |
|
|
SET_DECL_RTL (d, NULL_RTX);
|
11802 |
|
|
DECL_IN_AGGR_P (d) = 0;
|
11803 |
|
|
|
11804 |
|
|
/* Clear DECL_EXTERNAL so that cp_finish_decl will process the
|
11805 |
|
|
initializer. That function will defer actual emission until
|
11806 |
|
|
we have a chance to determine linkage. */
|
11807 |
|
|
DECL_EXTERNAL (d) = 0;
|
11808 |
|
|
|
11809 |
|
|
/* Enter the scope of D so that access-checking works correctly. */
|
11810 |
|
|
push_nested_class (DECL_CONTEXT (d));
|
11811 |
|
|
finish_decl (d, DECL_INITIAL (d), NULL_TREE);
|
11812 |
|
|
pop_nested_class ();
|
11813 |
|
|
}
|
11814 |
|
|
else if (TREE_CODE (d) == FUNCTION_DECL)
|
11815 |
|
|
{
|
11816 |
|
|
htab_t saved_local_specializations;
|
11817 |
|
|
tree subst_decl;
|
11818 |
|
|
tree tmpl_parm;
|
11819 |
|
|
tree spec_parm;
|
11820 |
|
|
|
11821 |
|
|
/* Save away the current list, in case we are instantiating one
|
11822 |
|
|
template from within the body of another. */
|
11823 |
|
|
saved_local_specializations = local_specializations;
|
11824 |
|
|
|
11825 |
|
|
/* Set up the list of local specializations. */
|
11826 |
|
|
local_specializations = htab_create (37,
|
11827 |
|
|
hash_local_specialization,
|
11828 |
|
|
eq_local_specializations,
|
11829 |
|
|
NULL);
|
11830 |
|
|
|
11831 |
|
|
/* Set up context. */
|
11832 |
|
|
start_preparsed_function (d, NULL_TREE, SF_PRE_PARSED);
|
11833 |
|
|
|
11834 |
|
|
/* Create substitution entries for the parameters. */
|
11835 |
|
|
subst_decl = DECL_TEMPLATE_RESULT (template_for_substitution (d));
|
11836 |
|
|
tmpl_parm = DECL_ARGUMENTS (subst_decl);
|
11837 |
|
|
spec_parm = DECL_ARGUMENTS (d);
|
11838 |
|
|
if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d))
|
11839 |
|
|
{
|
11840 |
|
|
register_local_specialization (spec_parm, tmpl_parm);
|
11841 |
|
|
spec_parm = skip_artificial_parms_for (d, spec_parm);
|
11842 |
|
|
tmpl_parm = skip_artificial_parms_for (subst_decl, tmpl_parm);
|
11843 |
|
|
}
|
11844 |
|
|
while (tmpl_parm)
|
11845 |
|
|
{
|
11846 |
|
|
register_local_specialization (spec_parm, tmpl_parm);
|
11847 |
|
|
tmpl_parm = TREE_CHAIN (tmpl_parm);
|
11848 |
|
|
spec_parm = TREE_CHAIN (spec_parm);
|
11849 |
|
|
}
|
11850 |
|
|
gcc_assert (!spec_parm);
|
11851 |
|
|
|
11852 |
|
|
/* Substitute into the body of the function. */
|
11853 |
|
|
tsubst_expr (DECL_SAVED_TREE (code_pattern), args,
|
11854 |
|
|
tf_error | tf_warning, tmpl);
|
11855 |
|
|
|
11856 |
|
|
/* We don't need the local specializations any more. */
|
11857 |
|
|
htab_delete (local_specializations);
|
11858 |
|
|
local_specializations = saved_local_specializations;
|
11859 |
|
|
|
11860 |
|
|
/* Finish the function. */
|
11861 |
|
|
d = finish_function (0);
|
11862 |
|
|
expand_or_defer_fn (d);
|
11863 |
|
|
}
|
11864 |
|
|
|
11865 |
|
|
/* We're not deferring instantiation any more. */
|
11866 |
|
|
TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d)) = 0;
|
11867 |
|
|
|
11868 |
|
|
if (need_push)
|
11869 |
|
|
pop_from_top_level ();
|
11870 |
|
|
|
11871 |
|
|
out:
|
11872 |
|
|
input_location = saved_loc;
|
11873 |
|
|
pop_deferring_access_checks ();
|
11874 |
|
|
pop_tinst_level ();
|
11875 |
|
|
|
11876 |
|
|
timevar_pop (TV_PARSE);
|
11877 |
|
|
|
11878 |
|
|
return d;
|
11879 |
|
|
}
|
11880 |
|
|
|
11881 |
|
|
/* Run through the list of templates that we wish we could
|
11882 |
|
|
instantiate, and instantiate any we can. RETRIES is the
|
11883 |
|
|
number of times we retry pending template instantiation. */
|
11884 |
|
|
|
11885 |
|
|
void
|
11886 |
|
|
instantiate_pending_templates (int retries)
|
11887 |
|
|
{
|
11888 |
|
|
tree *t;
|
11889 |
|
|
tree last = NULL_TREE;
|
11890 |
|
|
int reconsider;
|
11891 |
|
|
location_t saved_loc = input_location;
|
11892 |
|
|
int saved_in_system_header = in_system_header;
|
11893 |
|
|
|
11894 |
|
|
/* Instantiating templates may trigger vtable generation. This in turn
|
11895 |
|
|
may require further template instantiations. We place a limit here
|
11896 |
|
|
to avoid infinite loop. */
|
11897 |
|
|
if (pending_templates && retries >= max_tinst_depth)
|
11898 |
|
|
{
|
11899 |
|
|
tree decl = TREE_VALUE (pending_templates);
|
11900 |
|
|
|
11901 |
|
|
error ("template instantiation depth exceeds maximum of %d"
|
11902 |
|
|
" instantiating %q+D, possibly from virtual table generation"
|
11903 |
|
|
" (use -ftemplate-depth-NN to increase the maximum)",
|
11904 |
|
|
max_tinst_depth, decl);
|
11905 |
|
|
if (TREE_CODE (decl) == FUNCTION_DECL)
|
11906 |
|
|
/* Pretend that we defined it. */
|
11907 |
|
|
DECL_INITIAL (decl) = error_mark_node;
|
11908 |
|
|
return;
|
11909 |
|
|
}
|
11910 |
|
|
|
11911 |
|
|
do
|
11912 |
|
|
{
|
11913 |
|
|
reconsider = 0;
|
11914 |
|
|
|
11915 |
|
|
t = &pending_templates;
|
11916 |
|
|
while (*t)
|
11917 |
|
|
{
|
11918 |
|
|
tree instantiation = TREE_VALUE (*t);
|
11919 |
|
|
|
11920 |
|
|
reopen_tinst_level (TREE_PURPOSE (*t));
|
11921 |
|
|
|
11922 |
|
|
if (TYPE_P (instantiation))
|
11923 |
|
|
{
|
11924 |
|
|
tree fn;
|
11925 |
|
|
|
11926 |
|
|
if (!COMPLETE_TYPE_P (instantiation))
|
11927 |
|
|
{
|
11928 |
|
|
instantiate_class_template (instantiation);
|
11929 |
|
|
if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation))
|
11930 |
|
|
for (fn = TYPE_METHODS (instantiation);
|
11931 |
|
|
fn;
|
11932 |
|
|
fn = TREE_CHAIN (fn))
|
11933 |
|
|
if (! DECL_ARTIFICIAL (fn))
|
11934 |
|
|
instantiate_decl (fn,
|
11935 |
|
|
/*defer_ok=*/0,
|
11936 |
|
|
/*expl_inst_class_mem_p=*/false);
|
11937 |
|
|
if (COMPLETE_TYPE_P (instantiation))
|
11938 |
|
|
reconsider = 1;
|
11939 |
|
|
}
|
11940 |
|
|
|
11941 |
|
|
if (COMPLETE_TYPE_P (instantiation))
|
11942 |
|
|
/* If INSTANTIATION has been instantiated, then we don't
|
11943 |
|
|
need to consider it again in the future. */
|
11944 |
|
|
*t = TREE_CHAIN (*t);
|
11945 |
|
|
else
|
11946 |
|
|
{
|
11947 |
|
|
last = *t;
|
11948 |
|
|
t = &TREE_CHAIN (*t);
|
11949 |
|
|
}
|
11950 |
|
|
}
|
11951 |
|
|
else
|
11952 |
|
|
{
|
11953 |
|
|
if (!DECL_TEMPLATE_SPECIALIZATION (instantiation)
|
11954 |
|
|
&& !DECL_TEMPLATE_INSTANTIATED (instantiation))
|
11955 |
|
|
{
|
11956 |
|
|
instantiation
|
11957 |
|
|
= instantiate_decl (instantiation,
|
11958 |
|
|
/*defer_ok=*/0,
|
11959 |
|
|
/*expl_inst_class_mem_p=*/false);
|
11960 |
|
|
if (DECL_TEMPLATE_INSTANTIATED (instantiation))
|
11961 |
|
|
reconsider = 1;
|
11962 |
|
|
}
|
11963 |
|
|
|
11964 |
|
|
if (DECL_TEMPLATE_SPECIALIZATION (instantiation)
|
11965 |
|
|
|| DECL_TEMPLATE_INSTANTIATED (instantiation))
|
11966 |
|
|
/* If INSTANTIATION has been instantiated, then we don't
|
11967 |
|
|
need to consider it again in the future. */
|
11968 |
|
|
*t = TREE_CHAIN (*t);
|
11969 |
|
|
else
|
11970 |
|
|
{
|
11971 |
|
|
last = *t;
|
11972 |
|
|
t = &TREE_CHAIN (*t);
|
11973 |
|
|
}
|
11974 |
|
|
}
|
11975 |
|
|
tinst_depth = 0;
|
11976 |
|
|
current_tinst_level = NULL_TREE;
|
11977 |
|
|
}
|
11978 |
|
|
last_pending_template = last;
|
11979 |
|
|
}
|
11980 |
|
|
while (reconsider);
|
11981 |
|
|
|
11982 |
|
|
input_location = saved_loc;
|
11983 |
|
|
in_system_header = saved_in_system_header;
|
11984 |
|
|
}
|
11985 |
|
|
|
11986 |
|
|
/* Substitute ARGVEC into T, which is a list of initializers for
|
11987 |
|
|
either base class or a non-static data member. The TREE_PURPOSEs
|
11988 |
|
|
are DECLs, and the TREE_VALUEs are the initializer values. Used by
|
11989 |
|
|
instantiate_decl. */
|
11990 |
|
|
|
11991 |
|
|
static tree
|
11992 |
|
|
tsubst_initializer_list (tree t, tree argvec)
|
11993 |
|
|
{
|
11994 |
|
|
tree inits = NULL_TREE;
|
11995 |
|
|
|
11996 |
|
|
for (; t; t = TREE_CHAIN (t))
|
11997 |
|
|
{
|
11998 |
|
|
tree decl;
|
11999 |
|
|
tree init;
|
12000 |
|
|
|
12001 |
|
|
decl = tsubst_copy (TREE_PURPOSE (t), argvec, tf_error | tf_warning,
|
12002 |
|
|
NULL_TREE);
|
12003 |
|
|
decl = expand_member_init (decl);
|
12004 |
|
|
if (decl && !DECL_P (decl))
|
12005 |
|
|
in_base_initializer = 1;
|
12006 |
|
|
|
12007 |
|
|
init = tsubst_expr (TREE_VALUE (t), argvec, tf_error | tf_warning,
|
12008 |
|
|
NULL_TREE);
|
12009 |
|
|
in_base_initializer = 0;
|
12010 |
|
|
|
12011 |
|
|
if (decl)
|
12012 |
|
|
{
|
12013 |
|
|
init = build_tree_list (decl, init);
|
12014 |
|
|
TREE_CHAIN (init) = inits;
|
12015 |
|
|
inits = init;
|
12016 |
|
|
}
|
12017 |
|
|
}
|
12018 |
|
|
return inits;
|
12019 |
|
|
}
|
12020 |
|
|
|
12021 |
|
|
/* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
|
12022 |
|
|
|
12023 |
|
|
static void
|
12024 |
|
|
set_current_access_from_decl (tree decl)
|
12025 |
|
|
{
|
12026 |
|
|
if (TREE_PRIVATE (decl))
|
12027 |
|
|
current_access_specifier = access_private_node;
|
12028 |
|
|
else if (TREE_PROTECTED (decl))
|
12029 |
|
|
current_access_specifier = access_protected_node;
|
12030 |
|
|
else
|
12031 |
|
|
current_access_specifier = access_public_node;
|
12032 |
|
|
}
|
12033 |
|
|
|
12034 |
|
|
/* Instantiate an enumerated type. TAG is the template type, NEWTAG
|
12035 |
|
|
is the instantiation (which should have been created with
|
12036 |
|
|
start_enum) and ARGS are the template arguments to use. */
|
12037 |
|
|
|
12038 |
|
|
static void
|
12039 |
|
|
tsubst_enum (tree tag, tree newtag, tree args)
|
12040 |
|
|
{
|
12041 |
|
|
tree e;
|
12042 |
|
|
|
12043 |
|
|
for (e = TYPE_VALUES (tag); e; e = TREE_CHAIN (e))
|
12044 |
|
|
{
|
12045 |
|
|
tree value;
|
12046 |
|
|
tree decl;
|
12047 |
|
|
|
12048 |
|
|
decl = TREE_VALUE (e);
|
12049 |
|
|
/* Note that in a template enum, the TREE_VALUE is the
|
12050 |
|
|
CONST_DECL, not the corresponding INTEGER_CST. */
|
12051 |
|
|
value = tsubst_expr (DECL_INITIAL (decl),
|
12052 |
|
|
args, tf_error | tf_warning,
|
12053 |
|
|
NULL_TREE);
|
12054 |
|
|
|
12055 |
|
|
/* Give this enumeration constant the correct access. */
|
12056 |
|
|
set_current_access_from_decl (decl);
|
12057 |
|
|
|
12058 |
|
|
/* Actually build the enumerator itself. */
|
12059 |
|
|
build_enumerator (DECL_NAME (decl), value, newtag);
|
12060 |
|
|
}
|
12061 |
|
|
|
12062 |
|
|
finish_enum (newtag);
|
12063 |
|
|
DECL_SOURCE_LOCATION (TYPE_NAME (newtag))
|
12064 |
|
|
= DECL_SOURCE_LOCATION (TYPE_NAME (tag));
|
12065 |
|
|
}
|
12066 |
|
|
|
12067 |
|
|
/* DECL is a FUNCTION_DECL that is a template specialization. Return
|
12068 |
|
|
its type -- but without substituting the innermost set of template
|
12069 |
|
|
arguments. So, innermost set of template parameters will appear in
|
12070 |
|
|
the type. */
|
12071 |
|
|
|
12072 |
|
|
tree
|
12073 |
|
|
get_mostly_instantiated_function_type (tree decl)
|
12074 |
|
|
{
|
12075 |
|
|
tree fn_type;
|
12076 |
|
|
tree tmpl;
|
12077 |
|
|
tree targs;
|
12078 |
|
|
tree tparms;
|
12079 |
|
|
int parm_depth;
|
12080 |
|
|
|
12081 |
|
|
tmpl = most_general_template (DECL_TI_TEMPLATE (decl));
|
12082 |
|
|
targs = DECL_TI_ARGS (decl);
|
12083 |
|
|
tparms = DECL_TEMPLATE_PARMS (tmpl);
|
12084 |
|
|
parm_depth = TMPL_PARMS_DEPTH (tparms);
|
12085 |
|
|
|
12086 |
|
|
/* There should be as many levels of arguments as there are levels
|
12087 |
|
|
of parameters. */
|
12088 |
|
|
gcc_assert (parm_depth == TMPL_ARGS_DEPTH (targs));
|
12089 |
|
|
|
12090 |
|
|
fn_type = TREE_TYPE (tmpl);
|
12091 |
|
|
|
12092 |
|
|
if (parm_depth == 1)
|
12093 |
|
|
/* No substitution is necessary. */
|
12094 |
|
|
;
|
12095 |
|
|
else
|
12096 |
|
|
{
|
12097 |
|
|
int i, save_access_control;
|
12098 |
|
|
tree partial_args;
|
12099 |
|
|
|
12100 |
|
|
/* Replace the innermost level of the TARGS with NULL_TREEs to
|
12101 |
|
|
let tsubst know not to substitute for those parameters. */
|
12102 |
|
|
partial_args = make_tree_vec (TREE_VEC_LENGTH (targs));
|
12103 |
|
|
for (i = 1; i < TMPL_ARGS_DEPTH (targs); ++i)
|
12104 |
|
|
SET_TMPL_ARGS_LEVEL (partial_args, i,
|
12105 |
|
|
TMPL_ARGS_LEVEL (targs, i));
|
12106 |
|
|
SET_TMPL_ARGS_LEVEL (partial_args,
|
12107 |
|
|
TMPL_ARGS_DEPTH (targs),
|
12108 |
|
|
make_tree_vec (DECL_NTPARMS (tmpl)));
|
12109 |
|
|
|
12110 |
|
|
/* Disable access control as this function is used only during
|
12111 |
|
|
name-mangling. */
|
12112 |
|
|
save_access_control = flag_access_control;
|
12113 |
|
|
flag_access_control = 0;
|
12114 |
|
|
|
12115 |
|
|
++processing_template_decl;
|
12116 |
|
|
/* Now, do the (partial) substitution to figure out the
|
12117 |
|
|
appropriate function type. */
|
12118 |
|
|
fn_type = tsubst (fn_type, partial_args, tf_error, NULL_TREE);
|
12119 |
|
|
--processing_template_decl;
|
12120 |
|
|
|
12121 |
|
|
/* Substitute into the template parameters to obtain the real
|
12122 |
|
|
innermost set of parameters. This step is important if the
|
12123 |
|
|
innermost set of template parameters contains value
|
12124 |
|
|
parameters whose types depend on outer template parameters. */
|
12125 |
|
|
TREE_VEC_LENGTH (partial_args)--;
|
12126 |
|
|
tparms = tsubst_template_parms (tparms, partial_args, tf_error);
|
12127 |
|
|
|
12128 |
|
|
flag_access_control = save_access_control;
|
12129 |
|
|
}
|
12130 |
|
|
|
12131 |
|
|
return fn_type;
|
12132 |
|
|
}
|
12133 |
|
|
|
12134 |
|
|
/* Return truthvalue if we're processing a template different from
|
12135 |
|
|
the last one involved in diagnostics. */
|
12136 |
|
|
int
|
12137 |
|
|
problematic_instantiation_changed (void)
|
12138 |
|
|
{
|
12139 |
|
|
return last_template_error_tick != tinst_level_tick;
|
12140 |
|
|
}
|
12141 |
|
|
|
12142 |
|
|
/* Remember current template involved in diagnostics. */
|
12143 |
|
|
void
|
12144 |
|
|
record_last_problematic_instantiation (void)
|
12145 |
|
|
{
|
12146 |
|
|
last_template_error_tick = tinst_level_tick;
|
12147 |
|
|
}
|
12148 |
|
|
|
12149 |
|
|
tree
|
12150 |
|
|
current_instantiation (void)
|
12151 |
|
|
{
|
12152 |
|
|
return current_tinst_level;
|
12153 |
|
|
}
|
12154 |
|
|
|
12155 |
|
|
/* [temp.param] Check that template non-type parm TYPE is of an allowable
|
12156 |
|
|
type. Return zero for ok, nonzero for disallowed. Issue error and
|
12157 |
|
|
warning messages under control of COMPLAIN. */
|
12158 |
|
|
|
12159 |
|
|
static int
|
12160 |
|
|
invalid_nontype_parm_type_p (tree type, tsubst_flags_t complain)
|
12161 |
|
|
{
|
12162 |
|
|
if (INTEGRAL_TYPE_P (type))
|
12163 |
|
|
return 0;
|
12164 |
|
|
else if (POINTER_TYPE_P (type))
|
12165 |
|
|
return 0;
|
12166 |
|
|
else if (TYPE_PTR_TO_MEMBER_P (type))
|
12167 |
|
|
return 0;
|
12168 |
|
|
else if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
|
12169 |
|
|
return 0;
|
12170 |
|
|
else if (TREE_CODE (type) == TYPENAME_TYPE)
|
12171 |
|
|
return 0;
|
12172 |
|
|
|
12173 |
|
|
if (complain & tf_error)
|
12174 |
|
|
error ("%q#T is not a valid type for a template constant parameter", type);
|
12175 |
|
|
return 1;
|
12176 |
|
|
}
|
12177 |
|
|
|
12178 |
|
|
/* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
|
12179 |
|
|
Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
|
12180 |
|
|
|
12181 |
|
|
static bool
|
12182 |
|
|
dependent_type_p_r (tree type)
|
12183 |
|
|
{
|
12184 |
|
|
tree scope;
|
12185 |
|
|
|
12186 |
|
|
/* [temp.dep.type]
|
12187 |
|
|
|
12188 |
|
|
A type is dependent if it is:
|
12189 |
|
|
|
12190 |
|
|
-- a template parameter. Template template parameters are types
|
12191 |
|
|
for us (since TYPE_P holds true for them) so we handle
|
12192 |
|
|
them here. */
|
12193 |
|
|
if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
|
12194 |
|
|
|| TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM)
|
12195 |
|
|
return true;
|
12196 |
|
|
/* -- a qualified-id with a nested-name-specifier which contains a
|
12197 |
|
|
class-name that names a dependent type or whose unqualified-id
|
12198 |
|
|
names a dependent type. */
|
12199 |
|
|
if (TREE_CODE (type) == TYPENAME_TYPE)
|
12200 |
|
|
return true;
|
12201 |
|
|
/* -- a cv-qualified type where the cv-unqualified type is
|
12202 |
|
|
dependent. */
|
12203 |
|
|
type = TYPE_MAIN_VARIANT (type);
|
12204 |
|
|
/* -- a compound type constructed from any dependent type. */
|
12205 |
|
|
if (TYPE_PTR_TO_MEMBER_P (type))
|
12206 |
|
|
return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type))
|
12207 |
|
|
|| dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
|
12208 |
|
|
(type)));
|
12209 |
|
|
else if (TREE_CODE (type) == POINTER_TYPE
|
12210 |
|
|
|| TREE_CODE (type) == REFERENCE_TYPE)
|
12211 |
|
|
return dependent_type_p (TREE_TYPE (type));
|
12212 |
|
|
else if (TREE_CODE (type) == FUNCTION_TYPE
|
12213 |
|
|
|| TREE_CODE (type) == METHOD_TYPE)
|
12214 |
|
|
{
|
12215 |
|
|
tree arg_type;
|
12216 |
|
|
|
12217 |
|
|
if (dependent_type_p (TREE_TYPE (type)))
|
12218 |
|
|
return true;
|
12219 |
|
|
for (arg_type = TYPE_ARG_TYPES (type);
|
12220 |
|
|
arg_type;
|
12221 |
|
|
arg_type = TREE_CHAIN (arg_type))
|
12222 |
|
|
if (dependent_type_p (TREE_VALUE (arg_type)))
|
12223 |
|
|
return true;
|
12224 |
|
|
return false;
|
12225 |
|
|
}
|
12226 |
|
|
/* -- an array type constructed from any dependent type or whose
|
12227 |
|
|
size is specified by a constant expression that is
|
12228 |
|
|
value-dependent. */
|
12229 |
|
|
if (TREE_CODE (type) == ARRAY_TYPE)
|
12230 |
|
|
{
|
12231 |
|
|
if (TYPE_DOMAIN (type)
|
12232 |
|
|
&& ((value_dependent_expression_p
|
12233 |
|
|
(TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
|
12234 |
|
|
|| (type_dependent_expression_p
|
12235 |
|
|
(TYPE_MAX_VALUE (TYPE_DOMAIN (type))))))
|
12236 |
|
|
return true;
|
12237 |
|
|
return dependent_type_p (TREE_TYPE (type));
|
12238 |
|
|
}
|
12239 |
|
|
|
12240 |
|
|
/* -- a template-id in which either the template name is a template
|
12241 |
|
|
parameter ... */
|
12242 |
|
|
if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
|
12243 |
|
|
return true;
|
12244 |
|
|
/* ... or any of the template arguments is a dependent type or
|
12245 |
|
|
an expression that is type-dependent or value-dependent. */
|
12246 |
|
|
else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INFO (type)
|
12247 |
|
|
&& (any_dependent_template_arguments_p
|
12248 |
|
|
(INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type)))))
|
12249 |
|
|
return true;
|
12250 |
|
|
|
12251 |
|
|
/* All TYPEOF_TYPEs are dependent; if the argument of the `typeof'
|
12252 |
|
|
expression is not type-dependent, then it should already been
|
12253 |
|
|
have resolved. */
|
12254 |
|
|
if (TREE_CODE (type) == TYPEOF_TYPE)
|
12255 |
|
|
return true;
|
12256 |
|
|
|
12257 |
|
|
/* The standard does not specifically mention types that are local
|
12258 |
|
|
to template functions or local classes, but they should be
|
12259 |
|
|
considered dependent too. For example:
|
12260 |
|
|
|
12261 |
|
|
template <int I> void f() {
|
12262 |
|
|
enum E { a = I };
|
12263 |
|
|
S<sizeof (E)> s;
|
12264 |
|
|
}
|
12265 |
|
|
|
12266 |
|
|
The size of `E' cannot be known until the value of `I' has been
|
12267 |
|
|
determined. Therefore, `E' must be considered dependent. */
|
12268 |
|
|
scope = TYPE_CONTEXT (type);
|
12269 |
|
|
if (scope && TYPE_P (scope))
|
12270 |
|
|
return dependent_type_p (scope);
|
12271 |
|
|
else if (scope && TREE_CODE (scope) == FUNCTION_DECL)
|
12272 |
|
|
return type_dependent_expression_p (scope);
|
12273 |
|
|
|
12274 |
|
|
/* Other types are non-dependent. */
|
12275 |
|
|
return false;
|
12276 |
|
|
}
|
12277 |
|
|
|
12278 |
|
|
/* Returns TRUE if TYPE is dependent, in the sense of
|
12279 |
|
|
[temp.dep.type]. */
|
12280 |
|
|
|
12281 |
|
|
bool
|
12282 |
|
|
dependent_type_p (tree type)
|
12283 |
|
|
{
|
12284 |
|
|
/* If there are no template parameters in scope, then there can't be
|
12285 |
|
|
any dependent types. */
|
12286 |
|
|
if (!processing_template_decl)
|
12287 |
|
|
return false;
|
12288 |
|
|
|
12289 |
|
|
/* If the type is NULL, we have not computed a type for the entity
|
12290 |
|
|
in question; in that case, the type is dependent. */
|
12291 |
|
|
if (!type)
|
12292 |
|
|
return true;
|
12293 |
|
|
|
12294 |
|
|
/* Erroneous types can be considered non-dependent. */
|
12295 |
|
|
if (type == error_mark_node)
|
12296 |
|
|
return false;
|
12297 |
|
|
|
12298 |
|
|
/* If we have not already computed the appropriate value for TYPE,
|
12299 |
|
|
do so now. */
|
12300 |
|
|
if (!TYPE_DEPENDENT_P_VALID (type))
|
12301 |
|
|
{
|
12302 |
|
|
TYPE_DEPENDENT_P (type) = dependent_type_p_r (type);
|
12303 |
|
|
TYPE_DEPENDENT_P_VALID (type) = 1;
|
12304 |
|
|
}
|
12305 |
|
|
|
12306 |
|
|
return TYPE_DEPENDENT_P (type);
|
12307 |
|
|
}
|
12308 |
|
|
|
12309 |
|
|
/* Returns TRUE if EXPRESSION is dependent, according to CRITERION. */
|
12310 |
|
|
|
12311 |
|
|
static bool
|
12312 |
|
|
dependent_scope_ref_p (tree expression, bool criterion (tree))
|
12313 |
|
|
{
|
12314 |
|
|
tree scope;
|
12315 |
|
|
tree name;
|
12316 |
|
|
|
12317 |
|
|
gcc_assert (TREE_CODE (expression) == SCOPE_REF);
|
12318 |
|
|
|
12319 |
|
|
if (!TYPE_P (TREE_OPERAND (expression, 0)))
|
12320 |
|
|
return true;
|
12321 |
|
|
|
12322 |
|
|
scope = TREE_OPERAND (expression, 0);
|
12323 |
|
|
name = TREE_OPERAND (expression, 1);
|
12324 |
|
|
|
12325 |
|
|
/* [temp.dep.expr]
|
12326 |
|
|
|
12327 |
|
|
An id-expression is type-dependent if it contains a
|
12328 |
|
|
nested-name-specifier that contains a class-name that names a
|
12329 |
|
|
dependent type. */
|
12330 |
|
|
/* The suggested resolution to Core Issue 2 implies that if the
|
12331 |
|
|
qualifying type is the current class, then we must peek
|
12332 |
|
|
inside it. */
|
12333 |
|
|
if (DECL_P (name)
|
12334 |
|
|
&& currently_open_class (scope)
|
12335 |
|
|
&& !criterion (name))
|
12336 |
|
|
return false;
|
12337 |
|
|
if (dependent_type_p (scope))
|
12338 |
|
|
return true;
|
12339 |
|
|
|
12340 |
|
|
return false;
|
12341 |
|
|
}
|
12342 |
|
|
|
12343 |
|
|
/* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
|
12344 |
|
|
[temp.dep.constexpr] */
|
12345 |
|
|
|
12346 |
|
|
bool
|
12347 |
|
|
value_dependent_expression_p (tree expression)
|
12348 |
|
|
{
|
12349 |
|
|
if (!processing_template_decl)
|
12350 |
|
|
return false;
|
12351 |
|
|
|
12352 |
|
|
/* A name declared with a dependent type. */
|
12353 |
|
|
if (DECL_P (expression) && type_dependent_expression_p (expression))
|
12354 |
|
|
return true;
|
12355 |
|
|
|
12356 |
|
|
switch (TREE_CODE (expression))
|
12357 |
|
|
{
|
12358 |
|
|
case IDENTIFIER_NODE:
|
12359 |
|
|
/* A name that has not been looked up -- must be dependent. */
|
12360 |
|
|
return true;
|
12361 |
|
|
|
12362 |
|
|
case TEMPLATE_PARM_INDEX:
|
12363 |
|
|
/* A non-type template parm. */
|
12364 |
|
|
return true;
|
12365 |
|
|
|
12366 |
|
|
case CONST_DECL:
|
12367 |
|
|
/* A non-type template parm. */
|
12368 |
|
|
if (DECL_TEMPLATE_PARM_P (expression))
|
12369 |
|
|
return true;
|
12370 |
|
|
return false;
|
12371 |
|
|
|
12372 |
|
|
case VAR_DECL:
|
12373 |
|
|
/* A constant with integral or enumeration type and is initialized
|
12374 |
|
|
with an expression that is value-dependent. */
|
12375 |
|
|
if (DECL_INITIAL (expression)
|
12376 |
|
|
&& INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (expression))
|
12377 |
|
|
&& value_dependent_expression_p (DECL_INITIAL (expression)))
|
12378 |
|
|
return true;
|
12379 |
|
|
return false;
|
12380 |
|
|
|
12381 |
|
|
case DYNAMIC_CAST_EXPR:
|
12382 |
|
|
case STATIC_CAST_EXPR:
|
12383 |
|
|
case CONST_CAST_EXPR:
|
12384 |
|
|
case REINTERPRET_CAST_EXPR:
|
12385 |
|
|
case CAST_EXPR:
|
12386 |
|
|
/* These expressions are value-dependent if the type to which
|
12387 |
|
|
the cast occurs is dependent or the expression being casted
|
12388 |
|
|
is value-dependent. */
|
12389 |
|
|
{
|
12390 |
|
|
tree type = TREE_TYPE (expression);
|
12391 |
|
|
|
12392 |
|
|
if (dependent_type_p (type))
|
12393 |
|
|
return true;
|
12394 |
|
|
|
12395 |
|
|
/* A functional cast has a list of operands. */
|
12396 |
|
|
expression = TREE_OPERAND (expression, 0);
|
12397 |
|
|
if (!expression)
|
12398 |
|
|
{
|
12399 |
|
|
/* If there are no operands, it must be an expression such
|
12400 |
|
|
as "int()". This should not happen for aggregate types
|
12401 |
|
|
because it would form non-constant expressions. */
|
12402 |
|
|
gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type));
|
12403 |
|
|
|
12404 |
|
|
return false;
|
12405 |
|
|
}
|
12406 |
|
|
|
12407 |
|
|
if (TREE_CODE (expression) == TREE_LIST)
|
12408 |
|
|
{
|
12409 |
|
|
for (; expression; expression = TREE_CHAIN (expression))
|
12410 |
|
|
if (value_dependent_expression_p (TREE_VALUE (expression)))
|
12411 |
|
|
return true;
|
12412 |
|
|
return false;
|
12413 |
|
|
}
|
12414 |
|
|
|
12415 |
|
|
return value_dependent_expression_p (expression);
|
12416 |
|
|
}
|
12417 |
|
|
|
12418 |
|
|
case SIZEOF_EXPR:
|
12419 |
|
|
case ALIGNOF_EXPR:
|
12420 |
|
|
/* A `sizeof' expression is value-dependent if the operand is
|
12421 |
|
|
type-dependent. */
|
12422 |
|
|
expression = TREE_OPERAND (expression, 0);
|
12423 |
|
|
if (TYPE_P (expression))
|
12424 |
|
|
return dependent_type_p (expression);
|
12425 |
|
|
return type_dependent_expression_p (expression);
|
12426 |
|
|
|
12427 |
|
|
case SCOPE_REF:
|
12428 |
|
|
return dependent_scope_ref_p (expression, value_dependent_expression_p);
|
12429 |
|
|
|
12430 |
|
|
case COMPONENT_REF:
|
12431 |
|
|
return (value_dependent_expression_p (TREE_OPERAND (expression, 0))
|
12432 |
|
|
|| value_dependent_expression_p (TREE_OPERAND (expression, 1)));
|
12433 |
|
|
|
12434 |
|
|
case CALL_EXPR:
|
12435 |
|
|
/* A CALL_EXPR is value-dependent if any argument is
|
12436 |
|
|
value-dependent. Why do we have to handle CALL_EXPRs in this
|
12437 |
|
|
function at all? First, some function calls, those for which
|
12438 |
|
|
value_dependent_expression_p is true, man appear in constant
|
12439 |
|
|
expressions. Second, there appear to be bugs which result in
|
12440 |
|
|
other CALL_EXPRs reaching this point. */
|
12441 |
|
|
{
|
12442 |
|
|
tree function = TREE_OPERAND (expression, 0);
|
12443 |
|
|
tree args = TREE_OPERAND (expression, 1);
|
12444 |
|
|
|
12445 |
|
|
if (value_dependent_expression_p (function))
|
12446 |
|
|
return true;
|
12447 |
|
|
|
12448 |
|
|
if (! args)
|
12449 |
|
|
return false;
|
12450 |
|
|
|
12451 |
|
|
if (TREE_CODE (args) == TREE_LIST)
|
12452 |
|
|
{
|
12453 |
|
|
for (; args; args = TREE_CHAIN (args))
|
12454 |
|
|
if (value_dependent_expression_p (TREE_VALUE (args)))
|
12455 |
|
|
return true;
|
12456 |
|
|
return false;
|
12457 |
|
|
}
|
12458 |
|
|
|
12459 |
|
|
return value_dependent_expression_p (args);
|
12460 |
|
|
}
|
12461 |
|
|
|
12462 |
|
|
default:
|
12463 |
|
|
/* A constant expression is value-dependent if any subexpression is
|
12464 |
|
|
value-dependent. */
|
12465 |
|
|
switch (TREE_CODE_CLASS (TREE_CODE (expression)))
|
12466 |
|
|
{
|
12467 |
|
|
case tcc_reference:
|
12468 |
|
|
case tcc_unary:
|
12469 |
|
|
return (value_dependent_expression_p
|
12470 |
|
|
(TREE_OPERAND (expression, 0)));
|
12471 |
|
|
|
12472 |
|
|
case tcc_comparison:
|
12473 |
|
|
case tcc_binary:
|
12474 |
|
|
return ((value_dependent_expression_p
|
12475 |
|
|
(TREE_OPERAND (expression, 0)))
|
12476 |
|
|
|| (value_dependent_expression_p
|
12477 |
|
|
(TREE_OPERAND (expression, 1))));
|
12478 |
|
|
|
12479 |
|
|
case tcc_expression:
|
12480 |
|
|
{
|
12481 |
|
|
int i;
|
12482 |
|
|
for (i = 0; i < TREE_CODE_LENGTH (TREE_CODE (expression)); ++i)
|
12483 |
|
|
/* In some cases, some of the operands may be missing.
|
12484 |
|
|
(For example, in the case of PREDECREMENT_EXPR, the
|
12485 |
|
|
amount to increment by may be missing.) That doesn't
|
12486 |
|
|
make the expression dependent. */
|
12487 |
|
|
if (TREE_OPERAND (expression, i)
|
12488 |
|
|
&& (value_dependent_expression_p
|
12489 |
|
|
(TREE_OPERAND (expression, i))))
|
12490 |
|
|
return true;
|
12491 |
|
|
return false;
|
12492 |
|
|
}
|
12493 |
|
|
|
12494 |
|
|
default:
|
12495 |
|
|
break;
|
12496 |
|
|
}
|
12497 |
|
|
}
|
12498 |
|
|
|
12499 |
|
|
/* The expression is not value-dependent. */
|
12500 |
|
|
return false;
|
12501 |
|
|
}
|
12502 |
|
|
|
12503 |
|
|
/* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
|
12504 |
|
|
[temp.dep.expr]. */
|
12505 |
|
|
|
12506 |
|
|
bool
|
12507 |
|
|
type_dependent_expression_p (tree expression)
|
12508 |
|
|
{
|
12509 |
|
|
if (!processing_template_decl)
|
12510 |
|
|
return false;
|
12511 |
|
|
|
12512 |
|
|
if (expression == error_mark_node)
|
12513 |
|
|
return false;
|
12514 |
|
|
|
12515 |
|
|
/* An unresolved name is always dependent. */
|
12516 |
|
|
if (TREE_CODE (expression) == IDENTIFIER_NODE)
|
12517 |
|
|
return true;
|
12518 |
|
|
|
12519 |
|
|
/* Some expression forms are never type-dependent. */
|
12520 |
|
|
if (TREE_CODE (expression) == PSEUDO_DTOR_EXPR
|
12521 |
|
|
|| TREE_CODE (expression) == SIZEOF_EXPR
|
12522 |
|
|
|| TREE_CODE (expression) == ALIGNOF_EXPR
|
12523 |
|
|
|| TREE_CODE (expression) == TYPEID_EXPR
|
12524 |
|
|
|| TREE_CODE (expression) == DELETE_EXPR
|
12525 |
|
|
|| TREE_CODE (expression) == VEC_DELETE_EXPR
|
12526 |
|
|
|| TREE_CODE (expression) == THROW_EXPR)
|
12527 |
|
|
return false;
|
12528 |
|
|
|
12529 |
|
|
/* The types of these expressions depends only on the type to which
|
12530 |
|
|
the cast occurs. */
|
12531 |
|
|
if (TREE_CODE (expression) == DYNAMIC_CAST_EXPR
|
12532 |
|
|
|| TREE_CODE (expression) == STATIC_CAST_EXPR
|
12533 |
|
|
|| TREE_CODE (expression) == CONST_CAST_EXPR
|
12534 |
|
|
|| TREE_CODE (expression) == REINTERPRET_CAST_EXPR
|
12535 |
|
|
|| TREE_CODE (expression) == CAST_EXPR)
|
12536 |
|
|
return dependent_type_p (TREE_TYPE (expression));
|
12537 |
|
|
|
12538 |
|
|
/* The types of these expressions depends only on the type created
|
12539 |
|
|
by the expression. */
|
12540 |
|
|
if (TREE_CODE (expression) == NEW_EXPR
|
12541 |
|
|
|| TREE_CODE (expression) == VEC_NEW_EXPR)
|
12542 |
|
|
{
|
12543 |
|
|
/* For NEW_EXPR tree nodes created inside a template, either
|
12544 |
|
|
the object type itself or a TREE_LIST may appear as the
|
12545 |
|
|
operand 1. */
|
12546 |
|
|
tree type = TREE_OPERAND (expression, 1);
|
12547 |
|
|
if (TREE_CODE (type) == TREE_LIST)
|
12548 |
|
|
/* This is an array type. We need to check array dimensions
|
12549 |
|
|
as well. */
|
12550 |
|
|
return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type)))
|
12551 |
|
|
|| value_dependent_expression_p
|
12552 |
|
|
(TREE_OPERAND (TREE_VALUE (type), 1));
|
12553 |
|
|
else
|
12554 |
|
|
return dependent_type_p (type);
|
12555 |
|
|
}
|
12556 |
|
|
|
12557 |
|
|
if (TREE_CODE (expression) == SCOPE_REF
|
12558 |
|
|
&& dependent_scope_ref_p (expression,
|
12559 |
|
|
type_dependent_expression_p))
|
12560 |
|
|
return true;
|
12561 |
|
|
|
12562 |
|
|
if (TREE_CODE (expression) == FUNCTION_DECL
|
12563 |
|
|
&& DECL_LANG_SPECIFIC (expression)
|
12564 |
|
|
&& DECL_TEMPLATE_INFO (expression)
|
12565 |
|
|
&& (any_dependent_template_arguments_p
|
12566 |
|
|
(INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression)))))
|
12567 |
|
|
return true;
|
12568 |
|
|
|
12569 |
|
|
if (TREE_CODE (expression) == TEMPLATE_DECL
|
12570 |
|
|
&& !DECL_TEMPLATE_TEMPLATE_PARM_P (expression))
|
12571 |
|
|
return false;
|
12572 |
|
|
|
12573 |
|
|
if (TREE_TYPE (expression) == unknown_type_node)
|
12574 |
|
|
{
|
12575 |
|
|
if (TREE_CODE (expression) == ADDR_EXPR)
|
12576 |
|
|
return type_dependent_expression_p (TREE_OPERAND (expression, 0));
|
12577 |
|
|
if (TREE_CODE (expression) == COMPONENT_REF
|
12578 |
|
|
|| TREE_CODE (expression) == OFFSET_REF)
|
12579 |
|
|
{
|
12580 |
|
|
if (type_dependent_expression_p (TREE_OPERAND (expression, 0)))
|
12581 |
|
|
return true;
|
12582 |
|
|
expression = TREE_OPERAND (expression, 1);
|
12583 |
|
|
if (TREE_CODE (expression) == IDENTIFIER_NODE)
|
12584 |
|
|
return false;
|
12585 |
|
|
}
|
12586 |
|
|
/* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
|
12587 |
|
|
if (TREE_CODE (expression) == SCOPE_REF)
|
12588 |
|
|
return false;
|
12589 |
|
|
|
12590 |
|
|
if (TREE_CODE (expression) == BASELINK)
|
12591 |
|
|
expression = BASELINK_FUNCTIONS (expression);
|
12592 |
|
|
|
12593 |
|
|
if (TREE_CODE (expression) == TEMPLATE_ID_EXPR)
|
12594 |
|
|
{
|
12595 |
|
|
if (any_dependent_template_arguments_p
|
12596 |
|
|
(TREE_OPERAND (expression, 1)))
|
12597 |
|
|
return true;
|
12598 |
|
|
expression = TREE_OPERAND (expression, 0);
|
12599 |
|
|
}
|
12600 |
|
|
gcc_assert (TREE_CODE (expression) == OVERLOAD
|
12601 |
|
|
|| TREE_CODE (expression) == FUNCTION_DECL);
|
12602 |
|
|
|
12603 |
|
|
while (expression)
|
12604 |
|
|
{
|
12605 |
|
|
if (type_dependent_expression_p (OVL_CURRENT (expression)))
|
12606 |
|
|
return true;
|
12607 |
|
|
expression = OVL_NEXT (expression);
|
12608 |
|
|
}
|
12609 |
|
|
return false;
|
12610 |
|
|
}
|
12611 |
|
|
|
12612 |
|
|
gcc_assert (TREE_CODE (expression) != TYPE_DECL);
|
12613 |
|
|
|
12614 |
|
|
return (dependent_type_p (TREE_TYPE (expression)));
|
12615 |
|
|
}
|
12616 |
|
|
|
12617 |
|
|
/* Returns TRUE if ARGS (a TREE_LIST of arguments to a function call)
|
12618 |
|
|
contains a type-dependent expression. */
|
12619 |
|
|
|
12620 |
|
|
bool
|
12621 |
|
|
any_type_dependent_arguments_p (tree args)
|
12622 |
|
|
{
|
12623 |
|
|
while (args)
|
12624 |
|
|
{
|
12625 |
|
|
tree arg = TREE_VALUE (args);
|
12626 |
|
|
|
12627 |
|
|
if (type_dependent_expression_p (arg))
|
12628 |
|
|
return true;
|
12629 |
|
|
args = TREE_CHAIN (args);
|
12630 |
|
|
}
|
12631 |
|
|
return false;
|
12632 |
|
|
}
|
12633 |
|
|
|
12634 |
|
|
/* Returns TRUE if the ARG (a template argument) is dependent. */
|
12635 |
|
|
|
12636 |
|
|
static bool
|
12637 |
|
|
dependent_template_arg_p (tree arg)
|
12638 |
|
|
{
|
12639 |
|
|
if (!processing_template_decl)
|
12640 |
|
|
return false;
|
12641 |
|
|
|
12642 |
|
|
if (TREE_CODE (arg) == TEMPLATE_DECL
|
12643 |
|
|
|| TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
|
12644 |
|
|
return dependent_template_p (arg);
|
12645 |
|
|
else if (TYPE_P (arg))
|
12646 |
|
|
return dependent_type_p (arg);
|
12647 |
|
|
else
|
12648 |
|
|
return (type_dependent_expression_p (arg)
|
12649 |
|
|
|| value_dependent_expression_p (arg));
|
12650 |
|
|
}
|
12651 |
|
|
|
12652 |
|
|
/* Returns true if ARGS (a collection of template arguments) contains
|
12653 |
|
|
any dependent arguments. */
|
12654 |
|
|
|
12655 |
|
|
bool
|
12656 |
|
|
any_dependent_template_arguments_p (tree args)
|
12657 |
|
|
{
|
12658 |
|
|
int i;
|
12659 |
|
|
int j;
|
12660 |
|
|
|
12661 |
|
|
if (!args)
|
12662 |
|
|
return false;
|
12663 |
|
|
if (args == error_mark_node)
|
12664 |
|
|
return true;
|
12665 |
|
|
|
12666 |
|
|
for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i)
|
12667 |
|
|
{
|
12668 |
|
|
tree level = TMPL_ARGS_LEVEL (args, i + 1);
|
12669 |
|
|
for (j = 0; j < TREE_VEC_LENGTH (level); ++j)
|
12670 |
|
|
if (dependent_template_arg_p (TREE_VEC_ELT (level, j)))
|
12671 |
|
|
return true;
|
12672 |
|
|
}
|
12673 |
|
|
|
12674 |
|
|
return false;
|
12675 |
|
|
}
|
12676 |
|
|
|
12677 |
|
|
/* Returns TRUE if the template TMPL is dependent. */
|
12678 |
|
|
|
12679 |
|
|
bool
|
12680 |
|
|
dependent_template_p (tree tmpl)
|
12681 |
|
|
{
|
12682 |
|
|
if (TREE_CODE (tmpl) == OVERLOAD)
|
12683 |
|
|
{
|
12684 |
|
|
while (tmpl)
|
12685 |
|
|
{
|
12686 |
|
|
if (dependent_template_p (OVL_FUNCTION (tmpl)))
|
12687 |
|
|
return true;
|
12688 |
|
|
tmpl = OVL_CHAIN (tmpl);
|
12689 |
|
|
}
|
12690 |
|
|
return false;
|
12691 |
|
|
}
|
12692 |
|
|
|
12693 |
|
|
/* Template template parameters are dependent. */
|
12694 |
|
|
if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl)
|
12695 |
|
|
|| TREE_CODE (tmpl) == TEMPLATE_TEMPLATE_PARM)
|
12696 |
|
|
return true;
|
12697 |
|
|
/* So are names that have not been looked up. */
|
12698 |
|
|
if (TREE_CODE (tmpl) == SCOPE_REF
|
12699 |
|
|
|| TREE_CODE (tmpl) == IDENTIFIER_NODE)
|
12700 |
|
|
return true;
|
12701 |
|
|
/* So are member templates of dependent classes. */
|
12702 |
|
|
if (TYPE_P (CP_DECL_CONTEXT (tmpl)))
|
12703 |
|
|
return dependent_type_p (DECL_CONTEXT (tmpl));
|
12704 |
|
|
return false;
|
12705 |
|
|
}
|
12706 |
|
|
|
12707 |
|
|
/* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
|
12708 |
|
|
|
12709 |
|
|
bool
|
12710 |
|
|
dependent_template_id_p (tree tmpl, tree args)
|
12711 |
|
|
{
|
12712 |
|
|
return (dependent_template_p (tmpl)
|
12713 |
|
|
|| any_dependent_template_arguments_p (args));
|
12714 |
|
|
}
|
12715 |
|
|
|
12716 |
|
|
/* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
|
12717 |
|
|
TYPENAME_TYPE corresponds. Returns ERROR_MARK_NODE if no such TYPE
|
12718 |
|
|
can be found. Note that this function peers inside uninstantiated
|
12719 |
|
|
templates and therefore should be used only in extremely limited
|
12720 |
|
|
situations. ONLY_CURRENT_P restricts this peering to the currently
|
12721 |
|
|
open classes hierarchy (which is required when comparing types). */
|
12722 |
|
|
|
12723 |
|
|
tree
|
12724 |
|
|
resolve_typename_type (tree type, bool only_current_p)
|
12725 |
|
|
{
|
12726 |
|
|
tree scope;
|
12727 |
|
|
tree name;
|
12728 |
|
|
tree decl;
|
12729 |
|
|
int quals;
|
12730 |
|
|
tree pushed_scope;
|
12731 |
|
|
|
12732 |
|
|
gcc_assert (TREE_CODE (type) == TYPENAME_TYPE);
|
12733 |
|
|
|
12734 |
|
|
scope = TYPE_CONTEXT (type);
|
12735 |
|
|
name = TYPE_IDENTIFIER (type);
|
12736 |
|
|
|
12737 |
|
|
/* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
|
12738 |
|
|
it first before we can figure out what NAME refers to. */
|
12739 |
|
|
if (TREE_CODE (scope) == TYPENAME_TYPE)
|
12740 |
|
|
scope = resolve_typename_type (scope, only_current_p);
|
12741 |
|
|
/* If we don't know what SCOPE refers to, then we cannot resolve the
|
12742 |
|
|
TYPENAME_TYPE. */
|
12743 |
|
|
if (scope == error_mark_node || TREE_CODE (scope) == TYPENAME_TYPE)
|
12744 |
|
|
return error_mark_node;
|
12745 |
|
|
/* If the SCOPE is a template type parameter, we have no way of
|
12746 |
|
|
resolving the name. */
|
12747 |
|
|
if (TREE_CODE (scope) == TEMPLATE_TYPE_PARM)
|
12748 |
|
|
return type;
|
12749 |
|
|
/* If the SCOPE is not the current instantiation, there's no reason
|
12750 |
|
|
to look inside it. */
|
12751 |
|
|
if (only_current_p && !currently_open_class (scope))
|
12752 |
|
|
return error_mark_node;
|
12753 |
|
|
/* If SCOPE is a partial instantiation, it will not have a valid
|
12754 |
|
|
TYPE_FIELDS list, so use the original template. */
|
12755 |
|
|
scope = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope);
|
12756 |
|
|
/* Enter the SCOPE so that name lookup will be resolved as if we
|
12757 |
|
|
were in the class definition. In particular, SCOPE will no
|
12758 |
|
|
longer be considered a dependent type. */
|
12759 |
|
|
pushed_scope = push_scope (scope);
|
12760 |
|
|
/* Look up the declaration. */
|
12761 |
|
|
decl = lookup_member (scope, name, /*protect=*/0, /*want_type=*/true);
|
12762 |
|
|
/* Obtain the set of qualifiers applied to the TYPE. */
|
12763 |
|
|
quals = cp_type_quals (type);
|
12764 |
|
|
/* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
|
12765 |
|
|
find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
|
12766 |
|
|
if (!decl)
|
12767 |
|
|
type = error_mark_node;
|
12768 |
|
|
else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == IDENTIFIER_NODE
|
12769 |
|
|
&& TREE_CODE (decl) == TYPE_DECL)
|
12770 |
|
|
type = TREE_TYPE (decl);
|
12771 |
|
|
else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == TEMPLATE_ID_EXPR
|
12772 |
|
|
&& DECL_CLASS_TEMPLATE_P (decl))
|
12773 |
|
|
{
|
12774 |
|
|
tree tmpl;
|
12775 |
|
|
tree args;
|
12776 |
|
|
/* Obtain the template and the arguments. */
|
12777 |
|
|
tmpl = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 0);
|
12778 |
|
|
args = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 1);
|
12779 |
|
|
/* Instantiate the template. */
|
12780 |
|
|
type = lookup_template_class (tmpl, args, NULL_TREE, NULL_TREE,
|
12781 |
|
|
/*entering_scope=*/0, tf_error | tf_user);
|
12782 |
|
|
}
|
12783 |
|
|
else
|
12784 |
|
|
type = error_mark_node;
|
12785 |
|
|
/* Qualify the resulting type. */
|
12786 |
|
|
if (type != error_mark_node && quals)
|
12787 |
|
|
type = cp_build_qualified_type (type, quals);
|
12788 |
|
|
/* Leave the SCOPE. */
|
12789 |
|
|
if (pushed_scope)
|
12790 |
|
|
pop_scope (pushed_scope);
|
12791 |
|
|
|
12792 |
|
|
return type;
|
12793 |
|
|
}
|
12794 |
|
|
|
12795 |
|
|
/* EXPR is an expression which is not type-dependent. Return a proxy
|
12796 |
|
|
for EXPR that can be used to compute the types of larger
|
12797 |
|
|
expressions containing EXPR. */
|
12798 |
|
|
|
12799 |
|
|
tree
|
12800 |
|
|
build_non_dependent_expr (tree expr)
|
12801 |
|
|
{
|
12802 |
|
|
tree inner_expr;
|
12803 |
|
|
|
12804 |
|
|
/* Preserve null pointer constants so that the type of things like
|
12805 |
|
|
"p == 0" where "p" is a pointer can be determined. */
|
12806 |
|
|
if (null_ptr_cst_p (expr))
|
12807 |
|
|
return expr;
|
12808 |
|
|
/* Preserve OVERLOADs; the functions must be available to resolve
|
12809 |
|
|
types. */
|
12810 |
|
|
inner_expr = (TREE_CODE (expr) == ADDR_EXPR ?
|
12811 |
|
|
TREE_OPERAND (expr, 0) :
|
12812 |
|
|
TREE_CODE (expr) == COMPONENT_REF ?
|
12813 |
|
|
TREE_OPERAND (expr, 1) : expr);
|
12814 |
|
|
if (is_overloaded_fn (inner_expr)
|
12815 |
|
|
|| TREE_CODE (inner_expr) == OFFSET_REF)
|
12816 |
|
|
return expr;
|
12817 |
|
|
/* There is no need to return a proxy for a variable. */
|
12818 |
|
|
if (TREE_CODE (expr) == VAR_DECL)
|
12819 |
|
|
return expr;
|
12820 |
|
|
/* Preserve string constants; conversions from string constants to
|
12821 |
|
|
"char *" are allowed, even though normally a "const char *"
|
12822 |
|
|
cannot be used to initialize a "char *". */
|
12823 |
|
|
if (TREE_CODE (expr) == STRING_CST)
|
12824 |
|
|
return expr;
|
12825 |
|
|
/* Preserve arithmetic constants, as an optimization -- there is no
|
12826 |
|
|
reason to create a new node. */
|
12827 |
|
|
if (TREE_CODE (expr) == INTEGER_CST || TREE_CODE (expr) == REAL_CST)
|
12828 |
|
|
return expr;
|
12829 |
|
|
/* Preserve THROW_EXPRs -- all throw-expressions have type "void".
|
12830 |
|
|
There is at least one place where we want to know that a
|
12831 |
|
|
particular expression is a throw-expression: when checking a ?:
|
12832 |
|
|
expression, there are special rules if the second or third
|
12833 |
|
|
argument is a throw-expression. */
|
12834 |
|
|
if (TREE_CODE (expr) == THROW_EXPR)
|
12835 |
|
|
return expr;
|
12836 |
|
|
|
12837 |
|
|
if (TREE_CODE (expr) == COND_EXPR)
|
12838 |
|
|
return build3 (COND_EXPR,
|
12839 |
|
|
TREE_TYPE (expr),
|
12840 |
|
|
TREE_OPERAND (expr, 0),
|
12841 |
|
|
(TREE_OPERAND (expr, 1)
|
12842 |
|
|
? build_non_dependent_expr (TREE_OPERAND (expr, 1))
|
12843 |
|
|
: build_non_dependent_expr (TREE_OPERAND (expr, 0))),
|
12844 |
|
|
build_non_dependent_expr (TREE_OPERAND (expr, 2)));
|
12845 |
|
|
if (TREE_CODE (expr) == COMPOUND_EXPR
|
12846 |
|
|
&& !COMPOUND_EXPR_OVERLOADED (expr))
|
12847 |
|
|
return build2 (COMPOUND_EXPR,
|
12848 |
|
|
TREE_TYPE (expr),
|
12849 |
|
|
TREE_OPERAND (expr, 0),
|
12850 |
|
|
build_non_dependent_expr (TREE_OPERAND (expr, 1)));
|
12851 |
|
|
|
12852 |
|
|
/* If the type is unknown, it can't really be non-dependent */
|
12853 |
|
|
gcc_assert (TREE_TYPE (expr) != unknown_type_node);
|
12854 |
|
|
|
12855 |
|
|
/* Otherwise, build a NON_DEPENDENT_EXPR.
|
12856 |
|
|
|
12857 |
|
|
REFERENCE_TYPEs are not stripped for expressions in templates
|
12858 |
|
|
because doing so would play havoc with mangling. Consider, for
|
12859 |
|
|
example:
|
12860 |
|
|
|
12861 |
|
|
template <typename T> void f<T& g>() { g(); }
|
12862 |
|
|
|
12863 |
|
|
In the body of "f", the expression for "g" will have
|
12864 |
|
|
REFERENCE_TYPE, even though the standard says that it should
|
12865 |
|
|
not. The reason is that we must preserve the syntactic form of
|
12866 |
|
|
the expression so that mangling (say) "f<g>" inside the body of
|
12867 |
|
|
"f" works out correctly. Therefore, the REFERENCE_TYPE is
|
12868 |
|
|
stripped here. */
|
12869 |
|
|
return build1 (NON_DEPENDENT_EXPR, non_reference (TREE_TYPE (expr)), expr);
|
12870 |
|
|
}
|
12871 |
|
|
|
12872 |
|
|
/* ARGS is a TREE_LIST of expressions as arguments to a function call.
|
12873 |
|
|
Return a new TREE_LIST with the various arguments replaced with
|
12874 |
|
|
equivalent non-dependent expressions. */
|
12875 |
|
|
|
12876 |
|
|
tree
|
12877 |
|
|
build_non_dependent_args (tree args)
|
12878 |
|
|
{
|
12879 |
|
|
tree a;
|
12880 |
|
|
tree new_args;
|
12881 |
|
|
|
12882 |
|
|
new_args = NULL_TREE;
|
12883 |
|
|
for (a = args; a; a = TREE_CHAIN (a))
|
12884 |
|
|
new_args = tree_cons (NULL_TREE,
|
12885 |
|
|
build_non_dependent_expr (TREE_VALUE (a)),
|
12886 |
|
|
new_args);
|
12887 |
|
|
return nreverse (new_args);
|
12888 |
|
|
}
|
12889 |
|
|
|
12890 |
|
|
#include "gt-cp-pt.h"
|