pt.c revision 161651
1164190Sjkoshy/* Handle parameterized types (templates) for GNU C++. 2164190Sjkoshy Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 3164190Sjkoshy 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. 4164190Sjkoshy Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing. 5164190Sjkoshy Rewritten by Jason Merrill (jason@cygnus.com). 6164190Sjkoshy 7164190SjkoshyThis file is part of GCC. 8164190Sjkoshy 9164190SjkoshyGCC is free software; you can redistribute it and/or modify 10164190Sjkoshyit under the terms of the GNU General Public License as published by 11164190Sjkoshythe Free Software Foundation; either version 2, or (at your option) 12164190Sjkoshyany later version. 13164190Sjkoshy 14164190SjkoshyGCC is distributed in the hope that it will be useful, 15164190Sjkoshybut WITHOUT ANY WARRANTY; without even the implied warranty of 16164190SjkoshyMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17164190SjkoshyGNU General Public License for more details. 18164190Sjkoshy 19164190SjkoshyYou should have received a copy of the GNU General Public License 20164190Sjkoshyalong with GCC; see the file COPYING. If not, write to 21165535Sjkoshythe Free Software Foundation, 59 Temple Place - Suite 330, 22164190SjkoshyBoston, MA 02111-1307, USA. */ 23164190Sjkoshy 24164190Sjkoshy/* Known bugs or deficiencies include: 25164190Sjkoshy 26164190Sjkoshy all methods must be provided in header files; can't use a source 27164190Sjkoshy file that contains only the method templates and "just win". */ 28165317Sjkoshy 29164190Sjkoshy#include "config.h" 30164190Sjkoshy#include "system.h" 31164190Sjkoshy#include "coretypes.h" 32165317Sjkoshy#include "tm.h" 33165317Sjkoshy#include "obstack.h" 34165317Sjkoshy#include "tree.h" 35164190Sjkoshy#include "flags.h" 36164190Sjkoshy#include "cp-tree.h" 37164190Sjkoshy#include "tree-inline.h" 38164190Sjkoshy#include "decl.h" 39164190Sjkoshy#include "lex.h" 40165317Sjkoshy#include "output.h" 41164190Sjkoshy#include "except.h" 42164190Sjkoshy#include "toplev.h" 43164190Sjkoshy#include "rtl.h" 44164190Sjkoshy#include "timevar.h" 45164190Sjkoshy 46164190Sjkoshy/* The type of functions taking a tree, and some additional data, and 47164190Sjkoshy returning an int. */ 48164190Sjkoshytypedef int (*tree_fn_t) (tree, void*); 49164190Sjkoshy 50165535Sjkoshy/* The PENDING_TEMPLATES is a TREE_LIST of templates whose 51164190Sjkoshy instantiations have been deferred, either because their definitions 52164190Sjkoshy were not yet available, or because we were putting off doing the work. 53164225Sjkoshy The TREE_PURPOSE of each entry is either a DECL (for a function or 54164225Sjkoshy static data member), or a TYPE (for a class) indicating what we are 55164190Sjkoshy hoping to instantiate. The TREE_VALUE is not used. */ 56164190Sjkoshystatic GTY(()) tree pending_templates; 57164577Srustatic GTY(()) tree last_pending_template; 58164577Sru 59164225Sjkoshyint processing_template_parmlist; 60164190Sjkoshystatic int template_header_count; 61164190Sjkoshy 62164190Sjkoshystatic GTY(()) tree saved_trees; 63164190Sjkoshystatic GTY(()) varray_type inline_parm_levels; 64164190Sjkoshystatic size_t inline_parm_levels_used; 65164190Sjkoshy 66164190Sjkoshystatic GTY(()) tree current_tinst_level; 67164190Sjkoshy 68164190Sjkoshystatic GTY(()) tree saved_access_scope; 69164190Sjkoshy 70164190Sjkoshy/* A map from local variable declarations in the body of the template 71164190Sjkoshy presently being instantiated to the corresponding instantiated 72164190Sjkoshy local variables. */ 73164190Sjkoshystatic htab_t local_specializations; 74164190Sjkoshy 75164190Sjkoshy#define UNIFY_ALLOW_NONE 0 76164190Sjkoshy#define UNIFY_ALLOW_MORE_CV_QUAL 1 77165535Sjkoshy#define UNIFY_ALLOW_LESS_CV_QUAL 2 78164190Sjkoshy#define UNIFY_ALLOW_DERIVED 4 79164190Sjkoshy#define UNIFY_ALLOW_INTEGER 8 80164190Sjkoshy#define UNIFY_ALLOW_OUTER_LEVEL 16 81164190Sjkoshy#define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32 82164190Sjkoshy#define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64 83164190Sjkoshy#define UNIFY_ALLOW_MAX_CORRECTION 128 84164190Sjkoshy 85164190Sjkoshy#define GTB_VIA_VIRTUAL 1 /* The base class we are examining is 86164190Sjkoshy virtual, or a base class of a virtual 87164190Sjkoshy base. */ 88164190Sjkoshy#define GTB_IGNORE_TYPE 2 /* We don't need to try to unify the current 89164190Sjkoshy type with the desired type. */ 90164190Sjkoshy 91164190Sjkoshystatic void push_access_scope (tree); 92164190Sjkoshystatic void pop_access_scope (tree); 93164190Sjkoshystatic int resolve_overloaded_unification (tree, tree, tree, tree, 94164190Sjkoshy unification_kind_t, int); 95164190Sjkoshystatic int try_one_overload (tree, tree, tree, tree, tree, 96164190Sjkoshy unification_kind_t, int, bool); 97164190Sjkoshystatic int unify (tree, tree, tree, tree, int); 98164190Sjkoshystatic void add_pending_template (tree); 99164190Sjkoshystatic void reopen_tinst_level (tree); 100164190Sjkoshystatic tree classtype_mangled_name (tree); 101164190Sjkoshystatic char* mangle_class_name_for_template (const char *, tree, tree); 102164190Sjkoshystatic tree tsubst_initializer_list (tree, tree); 103164190Sjkoshystatic tree get_class_bindings (tree, tree, tree); 104164190Sjkoshystatic tree coerce_template_parms (tree, tree, tree, tsubst_flags_t, int); 105164190Sjkoshystatic void tsubst_enum (tree, tree, tree); 106164190Sjkoshystatic tree add_to_template_args (tree, tree); 107164190Sjkoshystatic tree add_outermost_template_args (tree, tree); 108164190Sjkoshystatic bool check_instantiated_args (tree, tree, tsubst_flags_t); 109164190Sjkoshystatic int maybe_adjust_types_for_deduction (unification_kind_t, tree*, tree*); 110164190Sjkoshystatic int type_unification_real (tree, tree, tree, tree, 111164190Sjkoshy int, unification_kind_t, int, int); 112164190Sjkoshystatic void note_template_header (int); 113164190Sjkoshystatic tree convert_nontype_argument (tree, tree); 114164190Sjkoshystatic tree convert_template_argument (tree, tree, tree, 115164190Sjkoshy tsubst_flags_t, int, tree); 116164190Sjkoshystatic tree get_bindings_overload (tree, tree, tree); 117164190Sjkoshystatic int for_each_template_parm (tree, tree_fn_t, void*, htab_t); 118164190Sjkoshystatic tree build_template_parm_index (int, int, int, tree, tree); 119164190Sjkoshystatic int inline_needs_template_parms (tree); 120164190Sjkoshystatic void push_inline_template_parms_recursive (tree, int); 121164190Sjkoshystatic tree retrieve_specialization (tree, tree); 122164190Sjkoshystatic tree retrieve_local_specialization (tree); 123164190Sjkoshystatic tree register_specialization (tree, tree, tree); 124164190Sjkoshystatic void register_local_specialization (tree, tree); 125164190Sjkoshystatic tree reduce_template_parm_level (tree, tree, int); 126164190Sjkoshystatic tree build_template_decl (tree, tree); 127164190Sjkoshystatic int mark_template_parm (tree, void *); 128164190Sjkoshystatic int template_parm_this_level_p (tree, void *); 129164190Sjkoshystatic tree tsubst_friend_function (tree, tree); 130164190Sjkoshystatic tree tsubst_friend_class (tree, tree); 131164190Sjkoshystatic int can_complete_type_without_circularity (tree); 132164190Sjkoshystatic tree get_bindings (tree, tree, tree); 133164190Sjkoshystatic tree get_bindings_real (tree, tree, tree, int, int, int); 134164190Sjkoshystatic int template_decl_level (tree); 135164190Sjkoshystatic int check_cv_quals_for_unify (int, tree, tree); 136164190Sjkoshystatic tree tsubst_template_arg (tree, tree, tsubst_flags_t, tree); 137164190Sjkoshystatic tree tsubst_template_args (tree, tree, tsubst_flags_t, tree); 138164190Sjkoshystatic tree tsubst_template_parms (tree, tree, tsubst_flags_t); 139164190Sjkoshystatic void regenerate_decl_from_template (tree, tree); 140164190Sjkoshystatic tree most_specialized (tree, tree, tree); 141164190Sjkoshystatic tree most_specialized_class (tree, tree); 142164190Sjkoshystatic int template_class_depth_real (tree, int); 143164190Sjkoshystatic tree tsubst_aggr_type (tree, tree, tsubst_flags_t, tree, int); 144164190Sjkoshystatic tree tsubst_decl (tree, tree, tree, tsubst_flags_t); 145164190Sjkoshystatic tree tsubst_arg_types (tree, tree, tsubst_flags_t, tree); 146164190Sjkoshystatic tree tsubst_function_type (tree, tree, tsubst_flags_t, tree); 147164190Sjkoshystatic void check_specialization_scope (void); 148164190Sjkoshystatic tree process_partial_specialization (tree); 149164190Sjkoshystatic void set_current_access_from_decl (tree); 150164190Sjkoshystatic void check_default_tmpl_args (tree, tree, int, int); 151164190Sjkoshystatic tree tsubst_call_declarator_parms (tree, tree, tsubst_flags_t, tree); 152164190Sjkoshystatic tree get_template_base_recursive (tree, tree, tree, tree, tree, int); 153164190Sjkoshystatic tree get_template_base (tree, tree, tree, tree); 154164190Sjkoshystatic int verify_class_unification (tree, tree, tree); 155164190Sjkoshystatic tree try_class_unification (tree, tree, tree, tree); 156164190Sjkoshystatic int coerce_template_template_parms (tree, tree, tsubst_flags_t, 157164190Sjkoshy tree, tree); 158164190Sjkoshystatic tree determine_specialization (tree, tree, tree *, int); 159164190Sjkoshystatic int template_args_equal (tree, tree); 160164225Sjkoshystatic void tsubst_default_arguments (tree); 161164190Sjkoshystatic tree for_each_template_parm_r (tree *, int *, void *); 162164190Sjkoshystatic tree copy_default_args_to_explicit_spec_1 (tree, tree); 163165317Sjkoshystatic void copy_default_args_to_explicit_spec (tree); 164static int invalid_nontype_parm_type_p (tree, tsubst_flags_t); 165static int eq_local_specializations (const void *, const void *); 166static bool dependent_type_p_r (tree); 167static tree tsubst (tree, tree, tsubst_flags_t, tree); 168static tree tsubst_expr (tree, tree, tsubst_flags_t, tree); 169static tree tsubst_copy (tree, tree, tsubst_flags_t, tree); 170 171/* Make the current scope suitable for access checking when we are 172 processing T. T can be FUNCTION_DECL for instantiated function 173 template, or VAR_DECL for static member variable (need by 174 instantiate_decl). */ 175 176static void 177push_access_scope (tree t) 178{ 179 my_friendly_assert (TREE_CODE (t) == FUNCTION_DECL 180 || TREE_CODE (t) == VAR_DECL, 181 0); 182 183 if (DECL_FRIEND_CONTEXT (t)) 184 push_nested_class (DECL_FRIEND_CONTEXT (t)); 185 else if (DECL_CLASS_SCOPE_P (t)) 186 push_nested_class (DECL_CONTEXT (t)); 187 else 188 push_to_top_level (); 189 190 if (TREE_CODE (t) == FUNCTION_DECL) 191 { 192 saved_access_scope = tree_cons 193 (NULL_TREE, current_function_decl, saved_access_scope); 194 current_function_decl = t; 195 } 196} 197 198/* Restore the scope set up by push_access_scope. T is the node we 199 are processing. */ 200 201static void 202pop_access_scope (tree t) 203{ 204 if (TREE_CODE (t) == FUNCTION_DECL) 205 { 206 current_function_decl = TREE_VALUE (saved_access_scope); 207 saved_access_scope = TREE_CHAIN (saved_access_scope); 208 } 209 210 if (DECL_FRIEND_CONTEXT (t) || DECL_CLASS_SCOPE_P (t)) 211 pop_nested_class (); 212 else 213 pop_from_top_level (); 214} 215 216/* Do any processing required when DECL (a member template 217 declaration) is finished. Returns the TEMPLATE_DECL corresponding 218 to DECL, unless it is a specialization, in which case the DECL 219 itself is returned. */ 220 221tree 222finish_member_template_decl (tree decl) 223{ 224 if (decl == error_mark_node) 225 return error_mark_node; 226 227 my_friendly_assert (DECL_P (decl), 20020812); 228 229 if (TREE_CODE (decl) == TYPE_DECL) 230 { 231 tree type; 232 233 type = TREE_TYPE (decl); 234 if (IS_AGGR_TYPE (type) 235 && CLASSTYPE_TEMPLATE_INFO (type) 236 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (type)) 237 { 238 tree tmpl = CLASSTYPE_TI_TEMPLATE (type); 239 check_member_template (tmpl); 240 return tmpl; 241 } 242 return NULL_TREE; 243 } 244 else if (TREE_CODE (decl) == FIELD_DECL) 245 error ("data member `%D' cannot be a member template", decl); 246 else if (DECL_TEMPLATE_INFO (decl)) 247 { 248 if (!DECL_TEMPLATE_SPECIALIZATION (decl)) 249 { 250 check_member_template (DECL_TI_TEMPLATE (decl)); 251 return DECL_TI_TEMPLATE (decl); 252 } 253 else 254 return decl; 255 } 256 else 257 error ("invalid member template declaration `%D'", decl); 258 259 return error_mark_node; 260} 261 262/* Returns the template nesting level of the indicated class TYPE. 263 264 For example, in: 265 template <class T> 266 struct A 267 { 268 template <class U> 269 struct B {}; 270 }; 271 272 A<T>::B<U> has depth two, while A<T> has depth one. 273 Both A<T>::B<int> and A<int>::B<U> have depth one, if 274 COUNT_SPECIALIZATIONS is 0 or if they are instantiations, not 275 specializations. 276 277 This function is guaranteed to return 0 if passed NULL_TREE so 278 that, for example, `template_class_depth (current_class_type)' is 279 always safe. */ 280 281static int 282template_class_depth_real (tree type, int count_specializations) 283{ 284 int depth; 285 286 for (depth = 0; 287 type && TREE_CODE (type) != NAMESPACE_DECL; 288 type = (TREE_CODE (type) == FUNCTION_DECL) 289 ? CP_DECL_CONTEXT (type) : TYPE_CONTEXT (type)) 290 { 291 if (TREE_CODE (type) != FUNCTION_DECL) 292 { 293 if (CLASSTYPE_TEMPLATE_INFO (type) 294 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)) 295 && ((count_specializations 296 && CLASSTYPE_TEMPLATE_SPECIALIZATION (type)) 297 || uses_template_parms (CLASSTYPE_TI_ARGS (type)))) 298 ++depth; 299 } 300 else 301 { 302 if (DECL_TEMPLATE_INFO (type) 303 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (type)) 304 && ((count_specializations 305 && DECL_TEMPLATE_SPECIALIZATION (type)) 306 || uses_template_parms (DECL_TI_ARGS (type)))) 307 ++depth; 308 } 309 } 310 311 return depth; 312} 313 314/* Returns the template nesting level of the indicated class TYPE. 315 Like template_class_depth_real, but instantiations do not count in 316 the depth. */ 317 318int 319template_class_depth (tree type) 320{ 321 return template_class_depth_real (type, /*count_specializations=*/0); 322} 323 324/* Returns 1 if processing DECL as part of do_pending_inlines 325 needs us to push template parms. */ 326 327static int 328inline_needs_template_parms (tree decl) 329{ 330 if (! DECL_TEMPLATE_INFO (decl)) 331 return 0; 332 333 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl))) 334 > (processing_template_decl + DECL_TEMPLATE_SPECIALIZATION (decl))); 335} 336 337/* Subroutine of maybe_begin_member_template_processing. 338 Push the template parms in PARMS, starting from LEVELS steps into the 339 chain, and ending at the beginning, since template parms are listed 340 innermost first. */ 341 342static void 343push_inline_template_parms_recursive (tree parmlist, int levels) 344{ 345 tree parms = TREE_VALUE (parmlist); 346 int i; 347 348 if (levels > 1) 349 push_inline_template_parms_recursive (TREE_CHAIN (parmlist), levels - 1); 350 351 ++processing_template_decl; 352 current_template_parms 353 = tree_cons (size_int (processing_template_decl), 354 parms, current_template_parms); 355 TEMPLATE_PARMS_FOR_INLINE (current_template_parms) = 1; 356 357 begin_scope (TREE_VEC_LENGTH (parms) ? sk_template_parms : sk_template_spec, 358 NULL); 359 for (i = 0; i < TREE_VEC_LENGTH (parms); ++i) 360 { 361 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i)); 362 my_friendly_assert (DECL_P (parm), 0); 363 364 switch (TREE_CODE (parm)) 365 { 366 case TYPE_DECL: 367 case TEMPLATE_DECL: 368 pushdecl (parm); 369 break; 370 371 case PARM_DECL: 372 { 373 /* Make a CONST_DECL as is done in process_template_parm. 374 It is ugly that we recreate this here; the original 375 version built in process_template_parm is no longer 376 available. */ 377 tree decl = build_decl (CONST_DECL, DECL_NAME (parm), 378 TREE_TYPE (parm)); 379 DECL_ARTIFICIAL (decl) = 1; 380 TREE_CONSTANT (decl) = TREE_READONLY (decl) = 1; 381 DECL_INITIAL (decl) = DECL_INITIAL (parm); 382 SET_DECL_TEMPLATE_PARM_P (decl); 383 pushdecl (decl); 384 } 385 break; 386 387 default: 388 abort (); 389 } 390 } 391} 392 393/* Restore the template parameter context for a member template or 394 a friend template defined in a class definition. */ 395 396void 397maybe_begin_member_template_processing (tree decl) 398{ 399 tree parms; 400 int levels = 0; 401 402 if (inline_needs_template_parms (decl)) 403 { 404 parms = DECL_TEMPLATE_PARMS (most_general_template (decl)); 405 levels = TMPL_PARMS_DEPTH (parms) - processing_template_decl; 406 407 if (DECL_TEMPLATE_SPECIALIZATION (decl)) 408 { 409 --levels; 410 parms = TREE_CHAIN (parms); 411 } 412 413 push_inline_template_parms_recursive (parms, levels); 414 } 415 416 /* Remember how many levels of template parameters we pushed so that 417 we can pop them later. */ 418 if (!inline_parm_levels) 419 VARRAY_INT_INIT (inline_parm_levels, 4, "inline_parm_levels"); 420 if (inline_parm_levels_used == inline_parm_levels->num_elements) 421 VARRAY_GROW (inline_parm_levels, 2 * inline_parm_levels_used); 422 VARRAY_INT (inline_parm_levels, inline_parm_levels_used) = levels; 423 ++inline_parm_levels_used; 424} 425 426/* Undo the effects of begin_member_template_processing. */ 427 428void 429maybe_end_member_template_processing (void) 430{ 431 int i; 432 433 if (!inline_parm_levels_used) 434 return; 435 436 --inline_parm_levels_used; 437 for (i = 0; 438 i < VARRAY_INT (inline_parm_levels, inline_parm_levels_used); 439 ++i) 440 { 441 --processing_template_decl; 442 current_template_parms = TREE_CHAIN (current_template_parms); 443 poplevel (0, 0, 0); 444 } 445} 446 447/* Returns nonzero iff T is a member template function. We must be 448 careful as in 449 450 template <class T> class C { void f(); } 451 452 Here, f is a template function, and a member, but not a member 453 template. This function does not concern itself with the origin of 454 T, only its present state. So if we have 455 456 template <class T> class C { template <class U> void f(U); } 457 458 then neither C<int>::f<char> nor C<T>::f<double> is considered 459 to be a member template. But, `template <class U> void 460 C<int>::f(U)' is considered a member template. */ 461 462int 463is_member_template (tree t) 464{ 465 if (!DECL_FUNCTION_TEMPLATE_P (t)) 466 /* Anything that isn't a function or a template function is 467 certainly not a member template. */ 468 return 0; 469 470 /* A local class can't have member templates. */ 471 if (decl_function_context (t)) 472 return 0; 473 474 return (DECL_FUNCTION_MEMBER_P (DECL_TEMPLATE_RESULT (t)) 475 /* If there are more levels of template parameters than 476 there are template classes surrounding the declaration, 477 then we have a member template. */ 478 && (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (t)) > 479 template_class_depth (DECL_CONTEXT (t)))); 480} 481 482#if 0 /* UNUSED */ 483/* Returns nonzero iff T is a member template class. See 484 is_member_template for a description of what precisely constitutes 485 a member template. */ 486 487int 488is_member_template_class (tree t) 489{ 490 if (!DECL_CLASS_TEMPLATE_P (t)) 491 /* Anything that isn't a class template, is certainly not a member 492 template. */ 493 return 0; 494 495 if (!DECL_CLASS_SCOPE_P (t)) 496 /* Anything whose context isn't a class type is surely not a 497 member template. */ 498 return 0; 499 500 /* If there are more levels of template parameters than there are 501 template classes surrounding the declaration, then we have a 502 member template. */ 503 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (t)) > 504 template_class_depth (DECL_CONTEXT (t))); 505} 506#endif 507 508/* Return a new template argument vector which contains all of ARGS, 509 but has as its innermost set of arguments the EXTRA_ARGS. */ 510 511static tree 512add_to_template_args (tree args, tree extra_args) 513{ 514 tree new_args; 515 int extra_depth; 516 int i; 517 int j; 518 519 extra_depth = TMPL_ARGS_DEPTH (extra_args); 520 new_args = make_tree_vec (TMPL_ARGS_DEPTH (args) + extra_depth); 521 522 for (i = 1; i <= TMPL_ARGS_DEPTH (args); ++i) 523 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (args, i)); 524 525 for (j = 1; j <= extra_depth; ++j, ++i) 526 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (extra_args, j)); 527 528 return new_args; 529} 530 531/* Like add_to_template_args, but only the outermost ARGS are added to 532 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH 533 (EXTRA_ARGS) levels are added. This function is used to combine 534 the template arguments from a partial instantiation with the 535 template arguments used to attain the full instantiation from the 536 partial instantiation. */ 537 538static tree 539add_outermost_template_args (tree args, tree extra_args) 540{ 541 tree new_args; 542 543 /* If there are more levels of EXTRA_ARGS than there are ARGS, 544 something very fishy is going on. */ 545 my_friendly_assert (TMPL_ARGS_DEPTH (args) >= TMPL_ARGS_DEPTH (extra_args), 546 0); 547 548 /* If *all* the new arguments will be the EXTRA_ARGS, just return 549 them. */ 550 if (TMPL_ARGS_DEPTH (args) == TMPL_ARGS_DEPTH (extra_args)) 551 return extra_args; 552 553 /* For the moment, we make ARGS look like it contains fewer levels. */ 554 TREE_VEC_LENGTH (args) -= TMPL_ARGS_DEPTH (extra_args); 555 556 new_args = add_to_template_args (args, extra_args); 557 558 /* Now, we restore ARGS to its full dimensions. */ 559 TREE_VEC_LENGTH (args) += TMPL_ARGS_DEPTH (extra_args); 560 561 return new_args; 562} 563 564/* Return the N levels of innermost template arguments from the ARGS. */ 565 566tree 567get_innermost_template_args (tree args, int n) 568{ 569 tree new_args; 570 int extra_levels; 571 int i; 572 573 my_friendly_assert (n >= 0, 20000603); 574 575 /* If N is 1, just return the innermost set of template arguments. */ 576 if (n == 1) 577 return TMPL_ARGS_LEVEL (args, TMPL_ARGS_DEPTH (args)); 578 579 /* If we're not removing anything, just return the arguments we were 580 given. */ 581 extra_levels = TMPL_ARGS_DEPTH (args) - n; 582 my_friendly_assert (extra_levels >= 0, 20000603); 583 if (extra_levels == 0) 584 return args; 585 586 /* Make a new set of arguments, not containing the outer arguments. */ 587 new_args = make_tree_vec (n); 588 for (i = 1; i <= n; ++i) 589 SET_TMPL_ARGS_LEVEL (new_args, i, 590 TMPL_ARGS_LEVEL (args, i + extra_levels)); 591 592 return new_args; 593} 594 595/* We've got a template header coming up; push to a new level for storing 596 the parms. */ 597 598void 599begin_template_parm_list (void) 600{ 601 /* We use a non-tag-transparent scope here, which causes pushtag to 602 put tags in this scope, rather than in the enclosing class or 603 namespace scope. This is the right thing, since we want 604 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a 605 global template class, push_template_decl handles putting the 606 TEMPLATE_DECL into top-level scope. For a nested template class, 607 e.g.: 608 609 template <class T> struct S1 { 610 template <class T> struct S2 {}; 611 }; 612 613 pushtag contains special code to call pushdecl_with_scope on the 614 TEMPLATE_DECL for S2. */ 615 begin_scope (sk_template_parms, NULL); 616 ++processing_template_decl; 617 ++processing_template_parmlist; 618 note_template_header (0); 619} 620 621/* This routine is called when a specialization is declared. If it is 622 invalid to declare a specialization here, an error is reported. */ 623 624static void 625check_specialization_scope (void) 626{ 627 tree scope = current_scope (); 628 629 /* [temp.expl.spec] 630 631 An explicit specialization shall be declared in the namespace of 632 which the template is a member, or, for member templates, in the 633 namespace of which the enclosing class or enclosing class 634 template is a member. An explicit specialization of a member 635 function, member class or static data member of a class template 636 shall be declared in the namespace of which the class template 637 is a member. */ 638 if (scope && TREE_CODE (scope) != NAMESPACE_DECL) 639 error ("explicit specialization in non-namespace scope `%D'", 640 scope); 641 642 /* [temp.expl.spec] 643 644 In an explicit specialization declaration for a member of a class 645 template or a member template that appears in namespace scope, 646 the member template and some of its enclosing class templates may 647 remain unspecialized, except that the declaration shall not 648 explicitly specialize a class member template if its enclosing 649 class templates are not explicitly specialized as well. */ 650 if (current_template_parms) 651 error ("enclosing class templates are not explicitly specialized"); 652} 653 654/* We've just seen template <>. */ 655 656void 657begin_specialization (void) 658{ 659 begin_scope (sk_template_spec, NULL); 660 note_template_header (1); 661 check_specialization_scope (); 662} 663 664/* Called at then end of processing a declaration preceded by 665 template<>. */ 666 667void 668end_specialization (void) 669{ 670 finish_scope (); 671 reset_specialization (); 672} 673 674/* Any template <>'s that we have seen thus far are not referring to a 675 function specialization. */ 676 677void 678reset_specialization (void) 679{ 680 processing_specialization = 0; 681 template_header_count = 0; 682} 683 684/* We've just seen a template header. If SPECIALIZATION is nonzero, 685 it was of the form template <>. */ 686 687static void 688note_template_header (int specialization) 689{ 690 processing_specialization = specialization; 691 template_header_count++; 692} 693 694/* We're beginning an explicit instantiation. */ 695 696void 697begin_explicit_instantiation (void) 698{ 699 my_friendly_assert (!processing_explicit_instantiation, 20020913); 700 processing_explicit_instantiation = true; 701} 702 703 704void 705end_explicit_instantiation (void) 706{ 707 my_friendly_assert(processing_explicit_instantiation, 20020913); 708 processing_explicit_instantiation = false; 709} 710 711/* A explicit specialization or partial specialization TMPL is being 712 declared. Check that the namespace in which the specialization is 713 occurring is permissible. Returns false iff it is invalid to 714 specialize TMPL in the current namespace. */ 715 716static bool 717check_specialization_namespace (tree tmpl) 718{ 719 tree tpl_ns = decl_namespace_context (tmpl); 720 721 /* [tmpl.expl.spec] 722 723 An explicit specialization shall be declared in the namespace of 724 which the template is a member, or, for member templates, in the 725 namespace of which the enclosing class or enclosing class 726 template is a member. An explicit specialization of a member 727 function, member class or static data member of a class template 728 shall be declared in the namespace of which the class template is 729 a member. */ 730 if (is_associated_namespace (current_namespace, tpl_ns)) 731 /* Same or super-using namespace. */ 732 return true; 733 else 734 { 735 pedwarn ("specialization of `%D' in different namespace", tmpl); 736 cp_pedwarn_at (" from definition of `%#D'", tmpl); 737 return false; 738 } 739} 740 741/* The TYPE is being declared. If it is a template type, that means it 742 is a partial specialization. Do appropriate error-checking. */ 743 744void 745maybe_process_partial_specialization (tree type) 746{ 747 tree context; 748 749 if (type == error_mark_node) 750 return; 751 752 context = TYPE_CONTEXT (type); 753 754 if (CLASS_TYPE_P (type) && CLASSTYPE_USE_TEMPLATE (type)) 755 { 756 /* This is for ordinary explicit specialization and partial 757 specialization of a template class such as: 758 759 template <> class C<int>; 760 761 or: 762 763 template <class T> class C<T*>; 764 765 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */ 766 767 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type) 768 && !COMPLETE_TYPE_P (type)) 769 { 770 check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (type)); 771 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type); 772 if (processing_template_decl) 773 push_template_decl (TYPE_MAIN_DECL (type)); 774 } 775 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type)) 776 error ("specialization of `%T' after instantiation", type); 777 } 778 else if (CLASS_TYPE_P (type) 779 && !CLASSTYPE_USE_TEMPLATE (type) 780 && CLASSTYPE_TEMPLATE_INFO (type) 781 && context && CLASS_TYPE_P (context) 782 && CLASSTYPE_TEMPLATE_INFO (context)) 783 { 784 /* This is for an explicit specialization of member class 785 template according to [temp.expl.spec/18]: 786 787 template <> template <class U> class C<int>::D; 788 789 The context `C<int>' must be an implicit instantiation. 790 Otherwise this is just a member class template declared 791 earlier like: 792 793 template <> class C<int> { template <class U> class D; }; 794 template <> template <class U> class C<int>::D; 795 796 In the first case, `C<int>::D' is a specialization of `C<T>::D' 797 while in the second case, `C<int>::D' is a primary template 798 and `C<T>::D' may not exist. */ 799 800 if (CLASSTYPE_IMPLICIT_INSTANTIATION (context) 801 && !COMPLETE_TYPE_P (type)) 802 { 803 tree t; 804 805 if (current_namespace 806 != decl_namespace_context (CLASSTYPE_TI_TEMPLATE (type))) 807 { 808 pedwarn ("specializing `%#T' in different namespace", type); 809 cp_pedwarn_at (" from definition of `%#D'", 810 CLASSTYPE_TI_TEMPLATE (type)); 811 } 812 813 /* Check for invalid specialization after instantiation: 814 815 template <> template <> class C<int>::D<int>; 816 template <> template <class U> class C<int>::D; */ 817 818 for (t = DECL_TEMPLATE_INSTANTIATIONS 819 (most_general_template (CLASSTYPE_TI_TEMPLATE (type))); 820 t; t = TREE_CHAIN (t)) 821 if (TREE_VALUE (t) != type 822 && TYPE_CONTEXT (TREE_VALUE (t)) == context) 823 error ("specialization `%T' after instantiation `%T'", 824 type, TREE_VALUE (t)); 825 826 /* Mark TYPE as a specialization. And as a result, we only 827 have one level of template argument for the innermost 828 class template. */ 829 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type); 830 CLASSTYPE_TI_ARGS (type) 831 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type)); 832 } 833 } 834 else if (processing_specialization) 835 error ("explicit specialization of non-template `%T'", type); 836} 837 838/* Retrieve the specialization (in the sense of [temp.spec] - a 839 specialization is either an instantiation or an explicit 840 specialization) of TMPL for the given template ARGS. If there is 841 no such specialization, return NULL_TREE. The ARGS are a vector of 842 arguments, or a vector of vectors of arguments, in the case of 843 templates with more than one level of parameters. */ 844 845static tree 846retrieve_specialization (tree tmpl, tree args) 847{ 848 tree s; 849 850 my_friendly_assert (TREE_CODE (tmpl) == TEMPLATE_DECL, 0); 851 852 /* There should be as many levels of arguments as there are 853 levels of parameters. */ 854 my_friendly_assert (TMPL_ARGS_DEPTH (args) 855 == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)), 856 0); 857 858 for (s = DECL_TEMPLATE_SPECIALIZATIONS (tmpl); 859 s != NULL_TREE; 860 s = TREE_CHAIN (s)) 861 if (comp_template_args (TREE_PURPOSE (s), args)) 862 return TREE_VALUE (s); 863 864 return NULL_TREE; 865} 866 867/* Like retrieve_specialization, but for local declarations. */ 868 869static tree 870retrieve_local_specialization (tree tmpl) 871{ 872 tree spec = htab_find_with_hash (local_specializations, tmpl, 873 htab_hash_pointer (tmpl)); 874 return spec ? TREE_PURPOSE (spec) : NULL_TREE; 875} 876 877/* Returns nonzero iff DECL is a specialization of TMPL. */ 878 879int 880is_specialization_of (tree decl, tree tmpl) 881{ 882 tree t; 883 884 if (TREE_CODE (decl) == FUNCTION_DECL) 885 { 886 for (t = decl; 887 t != NULL_TREE; 888 t = DECL_TEMPLATE_INFO (t) ? DECL_TI_TEMPLATE (t) : NULL_TREE) 889 if (t == tmpl) 890 return 1; 891 } 892 else 893 { 894 my_friendly_assert (TREE_CODE (decl) == TYPE_DECL, 0); 895 896 for (t = TREE_TYPE (decl); 897 t != NULL_TREE; 898 t = CLASSTYPE_USE_TEMPLATE (t) 899 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t)) : NULL_TREE) 900 if (same_type_ignoring_top_level_qualifiers_p (t, TREE_TYPE (tmpl))) 901 return 1; 902 } 903 904 return 0; 905} 906 907/* Returns nonzero iff DECL is a specialization of friend declaration 908 FRIEND according to [temp.friend]. */ 909 910bool 911is_specialization_of_friend (tree decl, tree friend) 912{ 913 bool need_template = true; 914 int template_depth; 915 916 my_friendly_assert (TREE_CODE (decl) == FUNCTION_DECL, 0); 917 918 /* For [temp.friend/6] when FRIEND is an ordinary member function 919 of a template class, we want to check if DECL is a specialization 920 if this. */ 921 if (TREE_CODE (friend) == FUNCTION_DECL 922 && DECL_TEMPLATE_INFO (friend) 923 && !DECL_USE_TEMPLATE (friend)) 924 { 925 friend = DECL_TI_TEMPLATE (friend); 926 need_template = false; 927 } 928 929 /* There is nothing to do if this is not a template friend. */ 930 if (TREE_CODE (friend) != TEMPLATE_DECL) 931 return 0; 932 933 if (is_specialization_of (decl, friend)) 934 return 1; 935 936 /* [temp.friend/6] 937 A member of a class template may be declared to be a friend of a 938 non-template class. In this case, the corresponding member of 939 every specialization of the class template is a friend of the 940 class granting friendship. 941 942 For example, given a template friend declaration 943 944 template <class T> friend void A<T>::f(); 945 946 the member function below is considered a friend 947 948 template <> struct A<int> { 949 void f(); 950 }; 951 952 For this type of template friend, TEMPLATE_DEPTH below will be 953 nonzero. To determine if DECL is a friend of FRIEND, we first 954 check if the enclosing class is a specialization of another. */ 955 956 template_depth = template_class_depth (DECL_CONTEXT (friend)); 957 if (template_depth 958 && DECL_CLASS_SCOPE_P (decl) 959 && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl)), 960 CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend)))) 961 { 962 /* Next, we check the members themselves. In order to handle 963 a few tricky cases like 964 965 template <class T> friend void A<T>::g(T t); 966 template <class T> template <T t> friend void A<T>::h(); 967 968 we need to figure out what ARGS is (corresponding to `T' in above 969 examples) from DECL for later processing. */ 970 971 tree context = DECL_CONTEXT (decl); 972 tree args = NULL_TREE; 973 int current_depth = 0; 974 while (current_depth < template_depth) 975 { 976 if (CLASSTYPE_TEMPLATE_INFO (context)) 977 { 978 if (current_depth == 0) 979 args = TYPE_TI_ARGS (context); 980 else 981 args = add_to_template_args (TYPE_TI_ARGS (context), args); 982 current_depth++; 983 } 984 context = TYPE_CONTEXT (context); 985 } 986 987 if (TREE_CODE (decl) == FUNCTION_DECL) 988 { 989 bool is_template; 990 tree friend_type; 991 tree decl_type; 992 tree friend_args_type; 993 tree decl_args_type; 994 995 /* Make sure that both DECL and FRIEND are templates or 996 non-templates. */ 997 is_template = DECL_TEMPLATE_INFO (decl) 998 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl)); 999 if (need_template ^ is_template) 1000 return 0; 1001 else if (is_template) 1002 { 1003 /* If both are templates, check template parameter list. */ 1004 tree friend_parms 1005 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend), 1006 args, tf_none); 1007 if (!comp_template_parms 1008 (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl)), 1009 friend_parms)) 1010 return 0; 1011 1012 decl_type = TREE_TYPE (DECL_TI_TEMPLATE (decl)); 1013 } 1014 else 1015 decl_type = TREE_TYPE (decl); 1016 1017 friend_type = tsubst_function_type (TREE_TYPE (friend), args, 1018 tf_none, NULL_TREE); 1019 if (friend_type == error_mark_node) 1020 return 0; 1021 1022 /* Check if return types match. */ 1023 if (!same_type_p (TREE_TYPE (decl_type), TREE_TYPE (friend_type))) 1024 return 0; 1025 1026 /* Check if function parameter types match, ignoring the 1027 `this' parameter. */ 1028 friend_args_type = TYPE_ARG_TYPES (friend_type); 1029 decl_args_type = TYPE_ARG_TYPES (decl_type); 1030 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend)) 1031 friend_args_type = TREE_CHAIN (friend_args_type); 1032 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)) 1033 decl_args_type = TREE_CHAIN (decl_args_type); 1034 if (compparms (decl_args_type, friend_args_type)) 1035 return 1; 1036 } 1037 } 1038 return 0; 1039} 1040 1041/* Register the specialization SPEC as a specialization of TMPL with 1042 the indicated ARGS. Returns SPEC, or an equivalent prior 1043 declaration, if available. */ 1044 1045static tree 1046register_specialization (tree spec, tree tmpl, tree args) 1047{ 1048 tree s; 1049 1050 my_friendly_assert (TREE_CODE (tmpl) == TEMPLATE_DECL, 0); 1051 1052 if (TREE_CODE (spec) == FUNCTION_DECL 1053 && uses_template_parms (DECL_TI_ARGS (spec))) 1054 /* This is the FUNCTION_DECL for a partial instantiation. Don't 1055 register it; we want the corresponding TEMPLATE_DECL instead. 1056 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than 1057 the more obvious `uses_template_parms (spec)' to avoid problems 1058 with default function arguments. In particular, given 1059 something like this: 1060 1061 template <class T> void f(T t1, T t = T()) 1062 1063 the default argument expression is not substituted for in an 1064 instantiation unless and until it is actually needed. */ 1065 return spec; 1066 1067 /* There should be as many levels of arguments as there are 1068 levels of parameters. */ 1069 my_friendly_assert (TMPL_ARGS_DEPTH (args) 1070 == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)), 1071 0); 1072 1073 for (s = DECL_TEMPLATE_SPECIALIZATIONS (tmpl); 1074 s != NULL_TREE; 1075 s = TREE_CHAIN (s)) 1076 { 1077 tree fn = TREE_VALUE (s); 1078 1079 /* We can sometimes try to re-register a specialization that we've 1080 already got. In particular, regenerate_decl_from_template 1081 calls duplicate_decls which will update the specialization 1082 list. But, we'll still get called again here anyhow. It's 1083 more convenient to simply allow this than to try to prevent it. */ 1084 if (fn == spec) 1085 return spec; 1086 else if (comp_template_args (TREE_PURPOSE (s), args)) 1087 { 1088 if (DECL_TEMPLATE_SPECIALIZATION (spec)) 1089 { 1090 if (DECL_TEMPLATE_INSTANTIATION (fn)) 1091 { 1092 if (TREE_USED (fn) 1093 || DECL_EXPLICIT_INSTANTIATION (fn)) 1094 { 1095 error ("specialization of %D after instantiation", 1096 fn); 1097 return spec; 1098 } 1099 else 1100 { 1101 /* This situation should occur only if the first 1102 specialization is an implicit instantiation, 1103 the second is an explicit specialization, and 1104 the implicit instantiation has not yet been 1105 used. That situation can occur if we have 1106 implicitly instantiated a member function and 1107 then specialized it later. 1108 1109 We can also wind up here if a friend 1110 declaration that looked like an instantiation 1111 turns out to be a specialization: 1112 1113 template <class T> void foo(T); 1114 class S { friend void foo<>(int) }; 1115 template <> void foo(int); 1116 1117 We transform the existing DECL in place so that 1118 any pointers to it become pointers to the 1119 updated declaration. 1120 1121 If there was a definition for the template, but 1122 not for the specialization, we want this to 1123 look as if there is no definition, and vice 1124 versa. */ 1125 DECL_INITIAL (fn) = NULL_TREE; 1126 duplicate_decls (spec, fn); 1127 1128 return fn; 1129 } 1130 } 1131 else if (DECL_TEMPLATE_SPECIALIZATION (fn)) 1132 { 1133 if (!duplicate_decls (spec, fn) && DECL_INITIAL (spec)) 1134 /* Dup decl failed, but this is a new 1135 definition. Set the line number so any errors 1136 match this new definition. */ 1137 DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (spec); 1138 1139 return fn; 1140 } 1141 } 1142 } 1143 } 1144 1145 /* A specialization must be declared in the same namespace as the 1146 template it is specializing. */ 1147 if (DECL_TEMPLATE_SPECIALIZATION (spec) 1148 && !check_specialization_namespace (tmpl)) 1149 DECL_CONTEXT (spec) = decl_namespace_context (tmpl); 1150 1151 DECL_TEMPLATE_SPECIALIZATIONS (tmpl) 1152 = tree_cons (args, spec, DECL_TEMPLATE_SPECIALIZATIONS (tmpl)); 1153 1154 return spec; 1155} 1156 1157/* Unregister the specialization SPEC as a specialization of TMPL. 1158 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true 1159 if the SPEC was listed as a specialization of TMPL. */ 1160 1161bool 1162reregister_specialization (tree spec, tree tmpl, tree new_spec) 1163{ 1164 tree* s; 1165 1166 for (s = &DECL_TEMPLATE_SPECIALIZATIONS (tmpl); 1167 *s != NULL_TREE; 1168 s = &TREE_CHAIN (*s)) 1169 if (TREE_VALUE (*s) == spec) 1170 { 1171 if (!new_spec) 1172 *s = TREE_CHAIN (*s); 1173 else 1174 TREE_VALUE (*s) = new_spec; 1175 return 1; 1176 } 1177 1178 return 0; 1179} 1180 1181/* Compare an entry in the local specializations hash table P1 (which 1182 is really a pointer to a TREE_LIST) with P2 (which is really a 1183 DECL). */ 1184 1185static int 1186eq_local_specializations (const void *p1, const void *p2) 1187{ 1188 return TREE_VALUE ((tree) p1) == (tree) p2; 1189} 1190 1191/* Hash P1, an entry in the local specializations table. */ 1192 1193static hashval_t 1194hash_local_specialization (const void* p1) 1195{ 1196 return htab_hash_pointer (TREE_VALUE ((tree) p1)); 1197} 1198 1199/* Like register_specialization, but for local declarations. We are 1200 registering SPEC, an instantiation of TMPL. */ 1201 1202static void 1203register_local_specialization (tree spec, tree tmpl) 1204{ 1205 void **slot; 1206 1207 slot = htab_find_slot_with_hash (local_specializations, tmpl, 1208 htab_hash_pointer (tmpl), INSERT); 1209 *slot = build_tree_list (spec, tmpl); 1210} 1211 1212/* Print the list of candidate FNS in an error message. */ 1213 1214void 1215print_candidates (tree fns) 1216{ 1217 tree fn; 1218 1219 const char *str = "candidates are:"; 1220 1221 for (fn = fns; fn != NULL_TREE; fn = TREE_CHAIN (fn)) 1222 { 1223 tree f; 1224 1225 for (f = TREE_VALUE (fn); f; f = OVL_NEXT (f)) 1226 cp_error_at ("%s %+#D", str, OVL_CURRENT (f)); 1227 str = " "; 1228 } 1229} 1230 1231/* Returns the template (one of the functions given by TEMPLATE_ID) 1232 which can be specialized to match the indicated DECL with the 1233 explicit template args given in TEMPLATE_ID. The DECL may be 1234 NULL_TREE if none is available. In that case, the functions in 1235 TEMPLATE_ID are non-members. 1236 1237 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a 1238 specialization of a member template. 1239 1240 The template args (those explicitly specified and those deduced) 1241 are output in a newly created vector *TARGS_OUT. 1242 1243 If it is impossible to determine the result, an error message is 1244 issued. The error_mark_node is returned to indicate failure. */ 1245 1246static tree 1247determine_specialization (tree template_id, 1248 tree decl, 1249 tree* targs_out, 1250 int need_member_template) 1251{ 1252 tree fns; 1253 tree targs; 1254 tree explicit_targs; 1255 tree candidates = NULL_TREE; 1256 tree templates = NULL_TREE; 1257 1258 *targs_out = NULL_TREE; 1259 1260 if (template_id == error_mark_node) 1261 return error_mark_node; 1262 1263 fns = TREE_OPERAND (template_id, 0); 1264 explicit_targs = TREE_OPERAND (template_id, 1); 1265 1266 if (fns == error_mark_node) 1267 return error_mark_node; 1268 1269 /* Check for baselinks. */ 1270 if (BASELINK_P (fns)) 1271 fns = BASELINK_FUNCTIONS (fns); 1272 1273 if (!is_overloaded_fn (fns)) 1274 { 1275 error ("`%D' is not a function template", fns); 1276 return error_mark_node; 1277 } 1278 1279 for (; fns; fns = OVL_NEXT (fns)) 1280 { 1281 tree fn = OVL_CURRENT (fns); 1282 1283 if (TREE_CODE (fn) == TEMPLATE_DECL) 1284 { 1285 tree decl_arg_types; 1286 tree fn_arg_types; 1287 1288 /* DECL might be a specialization of FN. */ 1289 1290 /* Adjust the type of DECL in case FN is a static member. */ 1291 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl)); 1292 if (DECL_STATIC_FUNCTION_P (fn) 1293 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)) 1294 decl_arg_types = TREE_CHAIN (decl_arg_types); 1295 1296 /* Check that the number of function parameters matches. 1297 For example, 1298 template <class T> void f(int i = 0); 1299 template <> void f<int>(); 1300 The specialization f<int> is invalid but is not caught 1301 by get_bindings below. */ 1302 1303 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn)); 1304 if (list_length (fn_arg_types) != list_length (decl_arg_types)) 1305 continue; 1306 1307 /* For a non-static member function, we need to make sure that 1308 the const qualification is the same. This can be done by 1309 checking the 'this' in the argument list. */ 1310 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn) 1311 && !same_type_p (TREE_VALUE (fn_arg_types), 1312 TREE_VALUE (decl_arg_types))) 1313 continue; 1314 1315 /* See whether this function might be a specialization of this 1316 template. */ 1317 targs = get_bindings (fn, decl, explicit_targs); 1318 1319 if (!targs) 1320 /* We cannot deduce template arguments that when used to 1321 specialize TMPL will produce DECL. */ 1322 continue; 1323 1324 /* Save this template, and the arguments deduced. */ 1325 templates = tree_cons (targs, fn, templates); 1326 } 1327 else if (need_member_template) 1328 /* FN is an ordinary member function, and we need a 1329 specialization of a member template. */ 1330 ; 1331 else if (TREE_CODE (fn) != FUNCTION_DECL) 1332 /* We can get IDENTIFIER_NODEs here in certain erroneous 1333 cases. */ 1334 ; 1335 else if (!DECL_FUNCTION_MEMBER_P (fn)) 1336 /* This is just an ordinary non-member function. Nothing can 1337 be a specialization of that. */ 1338 ; 1339 else if (DECL_ARTIFICIAL (fn)) 1340 /* Cannot specialize functions that are created implicitly. */ 1341 ; 1342 else 1343 { 1344 tree decl_arg_types; 1345 1346 /* This is an ordinary member function. However, since 1347 we're here, we can assume it's enclosing class is a 1348 template class. For example, 1349 1350 template <typename T> struct S { void f(); }; 1351 template <> void S<int>::f() {} 1352 1353 Here, S<int>::f is a non-template, but S<int> is a 1354 template class. If FN has the same type as DECL, we 1355 might be in business. */ 1356 1357 if (!DECL_TEMPLATE_INFO (fn)) 1358 /* Its enclosing class is an explicit specialization 1359 of a template class. This is not a candidate. */ 1360 continue; 1361 1362 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)), 1363 TREE_TYPE (TREE_TYPE (fn)))) 1364 /* The return types differ. */ 1365 continue; 1366 1367 /* Adjust the type of DECL in case FN is a static member. */ 1368 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl)); 1369 if (DECL_STATIC_FUNCTION_P (fn) 1370 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)) 1371 decl_arg_types = TREE_CHAIN (decl_arg_types); 1372 1373 if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)), 1374 decl_arg_types)) 1375 /* They match! */ 1376 candidates = tree_cons (NULL_TREE, fn, candidates); 1377 } 1378 } 1379 1380 if (templates && TREE_CHAIN (templates)) 1381 { 1382 /* We have: 1383 1384 [temp.expl.spec] 1385 1386 It is possible for a specialization with a given function 1387 signature to be instantiated from more than one function 1388 template. In such cases, explicit specification of the 1389 template arguments must be used to uniquely identify the 1390 function template specialization being specialized. 1391 1392 Note that here, there's no suggestion that we're supposed to 1393 determine which of the candidate templates is most 1394 specialized. However, we, also have: 1395 1396 [temp.func.order] 1397 1398 Partial ordering of overloaded function template 1399 declarations is used in the following contexts to select 1400 the function template to which a function template 1401 specialization refers: 1402 1403 -- when an explicit specialization refers to a function 1404 template. 1405 1406 So, we do use the partial ordering rules, at least for now. 1407 This extension can only serve to make invalid programs valid, 1408 so it's safe. And, there is strong anecdotal evidence that 1409 the committee intended the partial ordering rules to apply; 1410 the EDG front-end has that behavior, and John Spicer claims 1411 that the committee simply forgot to delete the wording in 1412 [temp.expl.spec]. */ 1413 tree tmpl = most_specialized (templates, decl, explicit_targs); 1414 if (tmpl && tmpl != error_mark_node) 1415 { 1416 targs = get_bindings (tmpl, decl, explicit_targs); 1417 templates = tree_cons (targs, tmpl, NULL_TREE); 1418 } 1419 } 1420 1421 if (templates == NULL_TREE && candidates == NULL_TREE) 1422 { 1423 cp_error_at ("template-id `%D' for `%+D' does not match any template declaration", 1424 template_id, decl); 1425 return error_mark_node; 1426 } 1427 else if ((templates && TREE_CHAIN (templates)) 1428 || (candidates && TREE_CHAIN (candidates)) 1429 || (templates && candidates)) 1430 { 1431 cp_error_at ("ambiguous template specialization `%D' for `%+D'", 1432 template_id, decl); 1433 chainon (candidates, templates); 1434 print_candidates (candidates); 1435 return error_mark_node; 1436 } 1437 1438 /* We have one, and exactly one, match. */ 1439 if (candidates) 1440 { 1441 /* It was a specialization of an ordinary member function in a 1442 template class. */ 1443 *targs_out = copy_node (DECL_TI_ARGS (TREE_VALUE (candidates))); 1444 return DECL_TI_TEMPLATE (TREE_VALUE (candidates)); 1445 } 1446 1447 /* It was a specialization of a template. */ 1448 targs = DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates))); 1449 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs)) 1450 { 1451 *targs_out = copy_node (targs); 1452 SET_TMPL_ARGS_LEVEL (*targs_out, 1453 TMPL_ARGS_DEPTH (*targs_out), 1454 TREE_PURPOSE (templates)); 1455 } 1456 else 1457 *targs_out = TREE_PURPOSE (templates); 1458 return TREE_VALUE (templates); 1459} 1460 1461/* Returns a chain of parameter types, exactly like the SPEC_TYPES, 1462 but with the default argument values filled in from those in the 1463 TMPL_TYPES. */ 1464 1465static tree 1466copy_default_args_to_explicit_spec_1 (tree spec_types, 1467 tree tmpl_types) 1468{ 1469 tree new_spec_types; 1470 1471 if (!spec_types) 1472 return NULL_TREE; 1473 1474 if (spec_types == void_list_node) 1475 return void_list_node; 1476 1477 /* Substitute into the rest of the list. */ 1478 new_spec_types = 1479 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types), 1480 TREE_CHAIN (tmpl_types)); 1481 1482 /* Add the default argument for this parameter. */ 1483 return hash_tree_cons (TREE_PURPOSE (tmpl_types), 1484 TREE_VALUE (spec_types), 1485 new_spec_types); 1486} 1487 1488/* DECL is an explicit specialization. Replicate default arguments 1489 from the template it specializes. (That way, code like: 1490 1491 template <class T> void f(T = 3); 1492 template <> void f(double); 1493 void g () { f (); } 1494 1495 works, as required.) An alternative approach would be to look up 1496 the correct default arguments at the call-site, but this approach 1497 is consistent with how implicit instantiations are handled. */ 1498 1499static void 1500copy_default_args_to_explicit_spec (tree decl) 1501{ 1502 tree tmpl; 1503 tree spec_types; 1504 tree tmpl_types; 1505 tree new_spec_types; 1506 tree old_type; 1507 tree new_type; 1508 tree t; 1509 tree object_type = NULL_TREE; 1510 tree in_charge = NULL_TREE; 1511 tree vtt = NULL_TREE; 1512 1513 /* See if there's anything we need to do. */ 1514 tmpl = DECL_TI_TEMPLATE (decl); 1515 tmpl_types = TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl))); 1516 for (t = tmpl_types; t; t = TREE_CHAIN (t)) 1517 if (TREE_PURPOSE (t)) 1518 break; 1519 if (!t) 1520 return; 1521 1522 old_type = TREE_TYPE (decl); 1523 spec_types = TYPE_ARG_TYPES (old_type); 1524 1525 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)) 1526 { 1527 /* Remove the this pointer, but remember the object's type for 1528 CV quals. */ 1529 object_type = TREE_TYPE (TREE_VALUE (spec_types)); 1530 spec_types = TREE_CHAIN (spec_types); 1531 tmpl_types = TREE_CHAIN (tmpl_types); 1532 1533 if (DECL_HAS_IN_CHARGE_PARM_P (decl)) 1534 { 1535 /* DECL may contain more parameters than TMPL due to the extra 1536 in-charge parameter in constructors and destructors. */ 1537 in_charge = spec_types; 1538 spec_types = TREE_CHAIN (spec_types); 1539 } 1540 if (DECL_HAS_VTT_PARM_P (decl)) 1541 { 1542 vtt = spec_types; 1543 spec_types = TREE_CHAIN (spec_types); 1544 } 1545 } 1546 1547 /* Compute the merged default arguments. */ 1548 new_spec_types = 1549 copy_default_args_to_explicit_spec_1 (spec_types, tmpl_types); 1550 1551 /* Compute the new FUNCTION_TYPE. */ 1552 if (object_type) 1553 { 1554 if (vtt) 1555 new_spec_types = hash_tree_cons (TREE_PURPOSE (vtt), 1556 TREE_VALUE (vtt), 1557 new_spec_types); 1558 1559 if (in_charge) 1560 /* Put the in-charge parameter back. */ 1561 new_spec_types = hash_tree_cons (TREE_PURPOSE (in_charge), 1562 TREE_VALUE (in_charge), 1563 new_spec_types); 1564 1565 new_type = build_method_type_directly (object_type, 1566 TREE_TYPE (old_type), 1567 new_spec_types); 1568 } 1569 else 1570 new_type = build_function_type (TREE_TYPE (old_type), 1571 new_spec_types); 1572 new_type = cp_build_type_attribute_variant (new_type, 1573 TYPE_ATTRIBUTES (old_type)); 1574 new_type = build_exception_variant (new_type, 1575 TYPE_RAISES_EXCEPTIONS (old_type)); 1576 TREE_TYPE (decl) = new_type; 1577} 1578 1579/* Check to see if the function just declared, as indicated in 1580 DECLARATOR, and in DECL, is a specialization of a function 1581 template. We may also discover that the declaration is an explicit 1582 instantiation at this point. 1583 1584 Returns DECL, or an equivalent declaration that should be used 1585 instead if all goes well. Issues an error message if something is 1586 amiss. Returns error_mark_node if the error is not easily 1587 recoverable. 1588 1589 FLAGS is a bitmask consisting of the following flags: 1590 1591 2: The function has a definition. 1592 4: The function is a friend. 1593 1594 The TEMPLATE_COUNT is the number of references to qualifying 1595 template classes that appeared in the name of the function. For 1596 example, in 1597 1598 template <class T> struct S { void f(); }; 1599 void S<int>::f(); 1600 1601 the TEMPLATE_COUNT would be 1. However, explicitly specialized 1602 classes are not counted in the TEMPLATE_COUNT, so that in 1603 1604 template <class T> struct S {}; 1605 template <> struct S<int> { void f(); } 1606 template <> void S<int>::f(); 1607 1608 the TEMPLATE_COUNT would be 0. (Note that this declaration is 1609 invalid; there should be no template <>.) 1610 1611 If the function is a specialization, it is marked as such via 1612 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO 1613 is set up correctly, and it is added to the list of specializations 1614 for that template. */ 1615 1616tree 1617check_explicit_specialization (tree declarator, 1618 tree decl, 1619 int template_count, 1620 int flags) 1621{ 1622 int have_def = flags & 2; 1623 int is_friend = flags & 4; 1624 int specialization = 0; 1625 int explicit_instantiation = 0; 1626 int member_specialization = 0; 1627 tree ctype = DECL_CLASS_CONTEXT (decl); 1628 tree dname = DECL_NAME (decl); 1629 tmpl_spec_kind tsk; 1630 1631 tsk = current_tmpl_spec_kind (template_count); 1632 1633 switch (tsk) 1634 { 1635 case tsk_none: 1636 if (processing_specialization) 1637 { 1638 specialization = 1; 1639 SET_DECL_TEMPLATE_SPECIALIZATION (decl); 1640 } 1641 else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR) 1642 { 1643 if (is_friend) 1644 /* This could be something like: 1645 1646 template <class T> void f(T); 1647 class S { friend void f<>(int); } */ 1648 specialization = 1; 1649 else 1650 { 1651 /* This case handles bogus declarations like template <> 1652 template <class T> void f<int>(); */ 1653 1654 error ("template-id `%D' in declaration of primary template", 1655 declarator); 1656 return decl; 1657 } 1658 } 1659 break; 1660 1661 case tsk_invalid_member_spec: 1662 /* The error has already been reported in 1663 check_specialization_scope. */ 1664 return error_mark_node; 1665 1666 case tsk_invalid_expl_inst: 1667 error ("template parameter list used in explicit instantiation"); 1668 1669 /* Fall through. */ 1670 1671 case tsk_expl_inst: 1672 if (have_def) 1673 error ("definition provided for explicit instantiation"); 1674 1675 explicit_instantiation = 1; 1676 break; 1677 1678 case tsk_excessive_parms: 1679 error ("too many template parameter lists in declaration of `%D'", 1680 decl); 1681 return error_mark_node; 1682 1683 /* Fall through. */ 1684 case tsk_expl_spec: 1685 SET_DECL_TEMPLATE_SPECIALIZATION (decl); 1686 if (ctype) 1687 member_specialization = 1; 1688 else 1689 specialization = 1; 1690 break; 1691 1692 case tsk_insufficient_parms: 1693 if (template_header_count) 1694 { 1695 error("too few template parameter lists in declaration of `%D'", 1696 decl); 1697 return decl; 1698 } 1699 else if (ctype != NULL_TREE 1700 && !TYPE_BEING_DEFINED (ctype) 1701 && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype) 1702 && !is_friend) 1703 { 1704 /* For backwards compatibility, we accept: 1705 1706 template <class T> struct S { void f(); }; 1707 void S<int>::f() {} // Missing template <> 1708 1709 That used to be valid C++. */ 1710 if (pedantic) 1711 pedwarn 1712 ("explicit specialization not preceded by `template <>'"); 1713 specialization = 1; 1714 SET_DECL_TEMPLATE_SPECIALIZATION (decl); 1715 } 1716 break; 1717 1718 case tsk_template: 1719 if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR) 1720 { 1721 /* This case handles bogus declarations like template <> 1722 template <class T> void f<int>(); */ 1723 1724 if (uses_template_parms (declarator)) 1725 error ("partial specialization `%D' of function template", 1726 declarator); 1727 else 1728 error ("template-id `%D' in declaration of primary template", 1729 declarator); 1730 return decl; 1731 } 1732 1733 if (ctype && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype)) 1734 /* This is a specialization of a member template, without 1735 specialization the containing class. Something like: 1736 1737 template <class T> struct S { 1738 template <class U> void f (U); 1739 }; 1740 template <> template <class U> void S<int>::f(U) {} 1741 1742 That's a specialization -- but of the entire template. */ 1743 specialization = 1; 1744 break; 1745 1746 default: 1747 abort (); 1748 } 1749 1750 if (specialization || member_specialization) 1751 { 1752 tree t = TYPE_ARG_TYPES (TREE_TYPE (decl)); 1753 for (; t; t = TREE_CHAIN (t)) 1754 if (TREE_PURPOSE (t)) 1755 { 1756 pedwarn 1757 ("default argument specified in explicit specialization"); 1758 break; 1759 } 1760 if (current_lang_name == lang_name_c) 1761 error ("template specialization with C linkage"); 1762 } 1763 1764 if (specialization || member_specialization || explicit_instantiation) 1765 { 1766 tree tmpl = NULL_TREE; 1767 tree targs = NULL_TREE; 1768 1769 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */ 1770 if (TREE_CODE (declarator) != TEMPLATE_ID_EXPR) 1771 { 1772 tree fns; 1773 1774 my_friendly_assert (TREE_CODE (declarator) == IDENTIFIER_NODE, 0); 1775 if (ctype) 1776 fns = dname; 1777 else 1778 { 1779 /* If there is no class context, the explicit instantiation 1780 must be at namespace scope. */ 1781 my_friendly_assert (DECL_NAMESPACE_SCOPE_P (decl), 20030625); 1782 1783 /* Find the namespace binding, using the declaration 1784 context. */ 1785 fns = namespace_binding (dname, CP_DECL_CONTEXT (decl)); 1786 if (!fns || !is_overloaded_fn (fns)) 1787 { 1788 error ("`%D' is not a template function", dname); 1789 fns = error_mark_node; 1790 } 1791 } 1792 1793 declarator = lookup_template_function (fns, NULL_TREE); 1794 } 1795 1796 if (declarator == error_mark_node) 1797 return error_mark_node; 1798 1799 if (ctype != NULL_TREE && TYPE_BEING_DEFINED (ctype)) 1800 { 1801 if (!explicit_instantiation) 1802 /* A specialization in class scope. This is invalid, 1803 but the error will already have been flagged by 1804 check_specialization_scope. */ 1805 return error_mark_node; 1806 else 1807 { 1808 /* It's not valid to write an explicit instantiation in 1809 class scope, e.g.: 1810 1811 class C { template void f(); } 1812 1813 This case is caught by the parser. However, on 1814 something like: 1815 1816 template class C { void f(); }; 1817 1818 (which is invalid) we can get here. The error will be 1819 issued later. */ 1820 ; 1821 } 1822 1823 return decl; 1824 } 1825 else if (ctype != NULL_TREE 1826 && (TREE_CODE (TREE_OPERAND (declarator, 0)) == 1827 IDENTIFIER_NODE)) 1828 { 1829 /* Find the list of functions in ctype that have the same 1830 name as the declared function. */ 1831 tree name = TREE_OPERAND (declarator, 0); 1832 tree fns = NULL_TREE; 1833 int idx; 1834 1835 if (constructor_name_p (name, ctype)) 1836 { 1837 int is_constructor = DECL_CONSTRUCTOR_P (decl); 1838 1839 if (is_constructor ? !TYPE_HAS_CONSTRUCTOR (ctype) 1840 : !TYPE_HAS_DESTRUCTOR (ctype)) 1841 { 1842 /* From [temp.expl.spec]: 1843 1844 If such an explicit specialization for the member 1845 of a class template names an implicitly-declared 1846 special member function (clause _special_), the 1847 program is ill-formed. 1848 1849 Similar language is found in [temp.explicit]. */ 1850 error ("specialization of implicitly-declared special member function"); 1851 return error_mark_node; 1852 } 1853 1854 name = is_constructor ? ctor_identifier : dtor_identifier; 1855 } 1856 1857 if (!DECL_CONV_FN_P (decl)) 1858 { 1859 idx = lookup_fnfields_1 (ctype, name); 1860 if (idx >= 0) 1861 fns = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (ctype), idx); 1862 } 1863 else 1864 { 1865 tree methods; 1866 1867 /* For a type-conversion operator, we cannot do a 1868 name-based lookup. We might be looking for `operator 1869 int' which will be a specialization of `operator T'. 1870 So, we find *all* the conversion operators, and then 1871 select from them. */ 1872 fns = NULL_TREE; 1873 1874 methods = CLASSTYPE_METHOD_VEC (ctype); 1875 if (methods) 1876 for (idx = CLASSTYPE_FIRST_CONVERSION_SLOT; 1877 idx < TREE_VEC_LENGTH (methods); ++idx) 1878 { 1879 tree ovl = TREE_VEC_ELT (methods, idx); 1880 1881 if (!ovl || !DECL_CONV_FN_P (OVL_CURRENT (ovl))) 1882 /* There are no more conversion functions. */ 1883 break; 1884 1885 /* Glue all these conversion functions together 1886 with those we already have. */ 1887 for (; ovl; ovl = OVL_NEXT (ovl)) 1888 fns = ovl_cons (OVL_CURRENT (ovl), fns); 1889 } 1890 } 1891 1892 if (fns == NULL_TREE) 1893 { 1894 error ("no member function `%D' declared in `%T'", 1895 name, ctype); 1896 return error_mark_node; 1897 } 1898 else 1899 TREE_OPERAND (declarator, 0) = fns; 1900 } 1901 1902 /* Figure out what exactly is being specialized at this point. 1903 Note that for an explicit instantiation, even one for a 1904 member function, we cannot tell apriori whether the 1905 instantiation is for a member template, or just a member 1906 function of a template class. Even if a member template is 1907 being instantiated, the member template arguments may be 1908 elided if they can be deduced from the rest of the 1909 declaration. */ 1910 tmpl = determine_specialization (declarator, decl, 1911 &targs, 1912 member_specialization); 1913 1914 if (!tmpl || tmpl == error_mark_node) 1915 /* We couldn't figure out what this declaration was 1916 specializing. */ 1917 return error_mark_node; 1918 else 1919 { 1920 tree gen_tmpl = most_general_template (tmpl); 1921 1922 if (explicit_instantiation) 1923 { 1924 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that 1925 is done by do_decl_instantiation later. */ 1926 1927 int arg_depth = TMPL_ARGS_DEPTH (targs); 1928 int parm_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)); 1929 1930 if (arg_depth > parm_depth) 1931 { 1932 /* If TMPL is not the most general template (for 1933 example, if TMPL is a friend template that is 1934 injected into namespace scope), then there will 1935 be too many levels of TARGS. Remove some of them 1936 here. */ 1937 int i; 1938 tree new_targs; 1939 1940 new_targs = make_tree_vec (parm_depth); 1941 for (i = arg_depth - parm_depth; i < arg_depth; ++i) 1942 TREE_VEC_ELT (new_targs, i - (arg_depth - parm_depth)) 1943 = TREE_VEC_ELT (targs, i); 1944 targs = new_targs; 1945 } 1946 1947 return instantiate_template (tmpl, targs, tf_error); 1948 } 1949 1950 /* If we thought that the DECL was a member function, but it 1951 turns out to be specializing a static member function, 1952 make DECL a static member function as well. */ 1953 if (DECL_STATIC_FUNCTION_P (tmpl) 1954 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)) 1955 revert_static_member_fn (decl); 1956 1957 /* If this is a specialization of a member template of a 1958 template class. In we want to return the TEMPLATE_DECL, 1959 not the specialization of it. */ 1960 if (tsk == tsk_template) 1961 { 1962 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl); 1963 DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl)) = NULL_TREE; 1964 if (have_def) 1965 { 1966 DECL_SOURCE_LOCATION (tmpl) = DECL_SOURCE_LOCATION (decl); 1967 DECL_SOURCE_LOCATION (DECL_TEMPLATE_RESULT (tmpl)) 1968 = DECL_SOURCE_LOCATION (decl); 1969 /* We want to use the argument list specified in the 1970 definition, not in the original declaration. */ 1971 DECL_ARGUMENTS (DECL_TEMPLATE_RESULT (tmpl)) 1972 = DECL_ARGUMENTS (decl); 1973 } 1974 return tmpl; 1975 } 1976 1977 /* Set up the DECL_TEMPLATE_INFO for DECL. */ 1978 DECL_TEMPLATE_INFO (decl) = tree_cons (tmpl, targs, NULL_TREE); 1979 1980 /* Inherit default function arguments from the template 1981 DECL is specializing. */ 1982 copy_default_args_to_explicit_spec (decl); 1983 1984 /* This specialization has the same protection as the 1985 template it specializes. */ 1986 TREE_PRIVATE (decl) = TREE_PRIVATE (gen_tmpl); 1987 TREE_PROTECTED (decl) = TREE_PROTECTED (gen_tmpl); 1988 1989 if (is_friend && !have_def) 1990 /* This is not really a declaration of a specialization. 1991 It's just the name of an instantiation. But, it's not 1992 a request for an instantiation, either. */ 1993 SET_DECL_IMPLICIT_INSTANTIATION (decl); 1994 else if (DECL_CONSTRUCTOR_P (decl) || DECL_DESTRUCTOR_P (decl)) 1995 /* This is indeed a specialization. In case of constructors 1996 and destructors, we need in-charge and not-in-charge 1997 versions in V3 ABI. */ 1998 clone_function_decl (decl, /*update_method_vec_p=*/0); 1999 2000 /* Register this specialization so that we can find it 2001 again. */ 2002 decl = register_specialization (decl, gen_tmpl, targs); 2003 } 2004 } 2005 2006 return decl; 2007} 2008 2009/* Returns 1 iff PARMS1 and PARMS2 are identical sets of template 2010 parameters. These are represented in the same format used for 2011 DECL_TEMPLATE_PARMS. */ 2012 2013int comp_template_parms (tree parms1, tree parms2) 2014{ 2015 tree p1; 2016 tree p2; 2017 2018 if (parms1 == parms2) 2019 return 1; 2020 2021 for (p1 = parms1, p2 = parms2; 2022 p1 != NULL_TREE && p2 != NULL_TREE; 2023 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2)) 2024 { 2025 tree t1 = TREE_VALUE (p1); 2026 tree t2 = TREE_VALUE (p2); 2027 int i; 2028 2029 my_friendly_assert (TREE_CODE (t1) == TREE_VEC, 0); 2030 my_friendly_assert (TREE_CODE (t2) == TREE_VEC, 0); 2031 2032 if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2)) 2033 return 0; 2034 2035 for (i = 0; i < TREE_VEC_LENGTH (t2); ++i) 2036 { 2037 tree parm1 = TREE_VALUE (TREE_VEC_ELT (t1, i)); 2038 tree parm2 = TREE_VALUE (TREE_VEC_ELT (t2, i)); 2039 2040 if (TREE_CODE (parm1) != TREE_CODE (parm2)) 2041 return 0; 2042 2043 if (TREE_CODE (parm1) == TEMPLATE_TYPE_PARM) 2044 continue; 2045 else if (!same_type_p (TREE_TYPE (parm1), TREE_TYPE (parm2))) 2046 return 0; 2047 } 2048 } 2049 2050 if ((p1 != NULL_TREE) != (p2 != NULL_TREE)) 2051 /* One set of parameters has more parameters lists than the 2052 other. */ 2053 return 0; 2054 2055 return 1; 2056} 2057 2058/* Complain if DECL shadows a template parameter. 2059 2060 [temp.local]: A template-parameter shall not be redeclared within its 2061 scope (including nested scopes). */ 2062 2063void 2064check_template_shadow (tree decl) 2065{ 2066 tree olddecl; 2067 2068 /* If we're not in a template, we can't possibly shadow a template 2069 parameter. */ 2070 if (!current_template_parms) 2071 return; 2072 2073 /* Figure out what we're shadowing. */ 2074 if (TREE_CODE (decl) == OVERLOAD) 2075 decl = OVL_CURRENT (decl); 2076 olddecl = IDENTIFIER_VALUE (DECL_NAME (decl)); 2077 2078 /* If there's no previous binding for this name, we're not shadowing 2079 anything, let alone a template parameter. */ 2080 if (!olddecl) 2081 return; 2082 2083 /* If we're not shadowing a template parameter, we're done. Note 2084 that OLDDECL might be an OVERLOAD (or perhaps even an 2085 ERROR_MARK), so we can't just blithely assume it to be a _DECL 2086 node. */ 2087 if (!DECL_P (olddecl) || !DECL_TEMPLATE_PARM_P (olddecl)) 2088 return; 2089 2090 /* We check for decl != olddecl to avoid bogus errors for using a 2091 name inside a class. We check TPFI to avoid duplicate errors for 2092 inline member templates. */ 2093 if (decl == olddecl 2094 || TEMPLATE_PARMS_FOR_INLINE (current_template_parms)) 2095 return; 2096 2097 cp_error_at ("declaration of `%#D'", decl); 2098 cp_error_at (" shadows template parm `%#D'", olddecl); 2099} 2100 2101/* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL, 2102 ORIG_LEVEL, DECL, and TYPE. */ 2103 2104static tree 2105build_template_parm_index (int index, 2106 int level, 2107 int orig_level, 2108 tree decl, 2109 tree type) 2110{ 2111 tree t = make_node (TEMPLATE_PARM_INDEX); 2112 TEMPLATE_PARM_IDX (t) = index; 2113 TEMPLATE_PARM_LEVEL (t) = level; 2114 TEMPLATE_PARM_ORIG_LEVEL (t) = orig_level; 2115 TEMPLATE_PARM_DECL (t) = decl; 2116 TREE_TYPE (t) = type; 2117 TREE_CONSTANT (t) = TREE_CONSTANT (decl); 2118 TREE_READONLY (t) = TREE_READONLY (decl); 2119 2120 return t; 2121} 2122 2123/* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose 2124 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a 2125 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a 2126 new one is created. */ 2127 2128static tree 2129reduce_template_parm_level (tree index, tree type, int levels) 2130{ 2131 if (TEMPLATE_PARM_DESCENDANTS (index) == NULL_TREE 2132 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index)) 2133 != TEMPLATE_PARM_LEVEL (index) - levels)) 2134 { 2135 tree orig_decl = TEMPLATE_PARM_DECL (index); 2136 tree decl, t; 2137 2138 decl = build_decl (TREE_CODE (orig_decl), DECL_NAME (orig_decl), type); 2139 TREE_CONSTANT (decl) = TREE_CONSTANT (orig_decl); 2140 TREE_READONLY (decl) = TREE_READONLY (orig_decl); 2141 DECL_ARTIFICIAL (decl) = 1; 2142 SET_DECL_TEMPLATE_PARM_P (decl); 2143 2144 t = build_template_parm_index (TEMPLATE_PARM_IDX (index), 2145 TEMPLATE_PARM_LEVEL (index) - levels, 2146 TEMPLATE_PARM_ORIG_LEVEL (index), 2147 decl, type); 2148 TEMPLATE_PARM_DESCENDANTS (index) = t; 2149 2150 /* Template template parameters need this. */ 2151 DECL_TEMPLATE_PARMS (decl) 2152 = DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index)); 2153 } 2154 2155 return TEMPLATE_PARM_DESCENDANTS (index); 2156} 2157 2158/* Process information from new template parameter NEXT and append it to the 2159 LIST being built. */ 2160 2161tree 2162process_template_parm (tree list, tree next) 2163{ 2164 tree parm; 2165 tree decl = 0; 2166 tree defval; 2167 int is_type, idx; 2168 2169 parm = next; 2170 my_friendly_assert (TREE_CODE (parm) == TREE_LIST, 259); 2171 defval = TREE_PURPOSE (parm); 2172 parm = TREE_VALUE (parm); 2173 is_type = TREE_PURPOSE (parm) == class_type_node; 2174 2175 if (list) 2176 { 2177 tree p = TREE_VALUE (tree_last (list)); 2178 2179 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL) 2180 idx = TEMPLATE_TYPE_IDX (TREE_TYPE (p)); 2181 else 2182 idx = TEMPLATE_PARM_IDX (DECL_INITIAL (p)); 2183 ++idx; 2184 } 2185 else 2186 idx = 0; 2187 2188 if (!is_type) 2189 { 2190 my_friendly_assert (TREE_CODE (TREE_PURPOSE (parm)) == TREE_LIST, 260); 2191 /* is a const-param */ 2192 parm = grokdeclarator (TREE_VALUE (parm), TREE_PURPOSE (parm), 2193 PARM, 0, NULL); 2194 SET_DECL_TEMPLATE_PARM_P (parm); 2195 2196 /* [temp.param] 2197 2198 The top-level cv-qualifiers on the template-parameter are 2199 ignored when determining its type. */ 2200 TREE_TYPE (parm) = TYPE_MAIN_VARIANT (TREE_TYPE (parm)); 2201 2202 /* A template parameter is not modifiable. */ 2203 TREE_READONLY (parm) = TREE_CONSTANT (parm) = 1; 2204 if (invalid_nontype_parm_type_p (TREE_TYPE (parm), 1)) 2205 TREE_TYPE (parm) = void_type_node; 2206 decl = build_decl (CONST_DECL, DECL_NAME (parm), TREE_TYPE (parm)); 2207 TREE_CONSTANT (decl) = TREE_READONLY (decl) = 1; 2208 DECL_INITIAL (parm) = DECL_INITIAL (decl) 2209 = build_template_parm_index (idx, processing_template_decl, 2210 processing_template_decl, 2211 decl, TREE_TYPE (parm)); 2212 } 2213 else 2214 { 2215 tree t; 2216 parm = TREE_VALUE (parm); 2217 2218 if (parm && TREE_CODE (parm) == TEMPLATE_DECL) 2219 { 2220 t = make_aggr_type (TEMPLATE_TEMPLATE_PARM); 2221 /* This is for distinguishing between real templates and template 2222 template parameters */ 2223 TREE_TYPE (parm) = t; 2224 TREE_TYPE (DECL_TEMPLATE_RESULT (parm)) = t; 2225 decl = parm; 2226 } 2227 else 2228 { 2229 t = make_aggr_type (TEMPLATE_TYPE_PARM); 2230 /* parm is either IDENTIFIER_NODE or NULL_TREE. */ 2231 decl = build_decl (TYPE_DECL, parm, t); 2232 } 2233 2234 TYPE_NAME (t) = decl; 2235 TYPE_STUB_DECL (t) = decl; 2236 parm = decl; 2237 TEMPLATE_TYPE_PARM_INDEX (t) 2238 = build_template_parm_index (idx, processing_template_decl, 2239 processing_template_decl, 2240 decl, TREE_TYPE (parm)); 2241 } 2242 DECL_ARTIFICIAL (decl) = 1; 2243 SET_DECL_TEMPLATE_PARM_P (decl); 2244 pushdecl (decl); 2245 parm = build_tree_list (defval, parm); 2246 return chainon (list, parm); 2247} 2248 2249/* The end of a template parameter list has been reached. Process the 2250 tree list into a parameter vector, converting each parameter into a more 2251 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others 2252 as PARM_DECLs. */ 2253 2254tree 2255end_template_parm_list (tree parms) 2256{ 2257 int nparms; 2258 tree parm, next; 2259 tree saved_parmlist = make_tree_vec (list_length (parms)); 2260 2261 current_template_parms 2262 = tree_cons (size_int (processing_template_decl), 2263 saved_parmlist, current_template_parms); 2264 2265 for (parm = parms, nparms = 0; parm; parm = next, nparms++) 2266 { 2267 next = TREE_CHAIN (parm); 2268 TREE_VEC_ELT (saved_parmlist, nparms) = parm; 2269 TREE_CHAIN (parm) = NULL_TREE; 2270 } 2271 2272 --processing_template_parmlist; 2273 2274 return saved_parmlist; 2275} 2276 2277/* end_template_decl is called after a template declaration is seen. */ 2278 2279void 2280end_template_decl (void) 2281{ 2282 reset_specialization (); 2283 2284 if (! processing_template_decl) 2285 return; 2286 2287 /* This matches the pushlevel in begin_template_parm_list. */ 2288 finish_scope (); 2289 2290 --processing_template_decl; 2291 current_template_parms = TREE_CHAIN (current_template_parms); 2292} 2293 2294/* Given a template argument vector containing the template PARMS. 2295 The innermost PARMS are given first. */ 2296 2297tree 2298current_template_args (void) 2299{ 2300 tree header; 2301 tree args = NULL_TREE; 2302 int length = TMPL_PARMS_DEPTH (current_template_parms); 2303 int l = length; 2304 2305 /* If there is only one level of template parameters, we do not 2306 create a TREE_VEC of TREE_VECs. Instead, we return a single 2307 TREE_VEC containing the arguments. */ 2308 if (length > 1) 2309 args = make_tree_vec (length); 2310 2311 for (header = current_template_parms; header; header = TREE_CHAIN (header)) 2312 { 2313 tree a = copy_node (TREE_VALUE (header)); 2314 int i; 2315 2316 TREE_TYPE (a) = NULL_TREE; 2317 for (i = TREE_VEC_LENGTH (a) - 1; i >= 0; --i) 2318 { 2319 tree t = TREE_VEC_ELT (a, i); 2320 2321 /* T will be a list if we are called from within a 2322 begin/end_template_parm_list pair, but a vector directly 2323 if within a begin/end_member_template_processing pair. */ 2324 if (TREE_CODE (t) == TREE_LIST) 2325 { 2326 t = TREE_VALUE (t); 2327 2328 if (TREE_CODE (t) == TYPE_DECL 2329 || TREE_CODE (t) == TEMPLATE_DECL) 2330 t = TREE_TYPE (t); 2331 else 2332 t = DECL_INITIAL (t); 2333 TREE_VEC_ELT (a, i) = t; 2334 } 2335 } 2336 2337 if (length > 1) 2338 TREE_VEC_ELT (args, --l) = a; 2339 else 2340 args = a; 2341 } 2342 2343 return args; 2344} 2345 2346/* Return a TEMPLATE_DECL corresponding to DECL, using the indicated 2347 template PARMS. Used by push_template_decl below. */ 2348 2349static tree 2350build_template_decl (tree decl, tree parms) 2351{ 2352 tree tmpl = build_lang_decl (TEMPLATE_DECL, DECL_NAME (decl), NULL_TREE); 2353 DECL_TEMPLATE_PARMS (tmpl) = parms; 2354 DECL_CONTEXT (tmpl) = DECL_CONTEXT (decl); 2355 if (DECL_LANG_SPECIFIC (decl)) 2356 { 2357 DECL_STATIC_FUNCTION_P (tmpl) = DECL_STATIC_FUNCTION_P (decl); 2358 DECL_CONSTRUCTOR_P (tmpl) = DECL_CONSTRUCTOR_P (decl); 2359 DECL_DESTRUCTOR_P (tmpl) = DECL_DESTRUCTOR_P (decl); 2360 DECL_NONCONVERTING_P (tmpl) = DECL_NONCONVERTING_P (decl); 2361 DECL_ASSIGNMENT_OPERATOR_P (tmpl) = DECL_ASSIGNMENT_OPERATOR_P (decl); 2362 if (DECL_OVERLOADED_OPERATOR_P (decl)) 2363 SET_OVERLOADED_OPERATOR_CODE (tmpl, 2364 DECL_OVERLOADED_OPERATOR_P (decl)); 2365 } 2366 2367 return tmpl; 2368} 2369 2370struct template_parm_data 2371{ 2372 /* The level of the template parameters we are currently 2373 processing. */ 2374 int level; 2375 2376 /* The index of the specialization argument we are currently 2377 processing. */ 2378 int current_arg; 2379 2380 /* An array whose size is the number of template parameters. The 2381 elements are nonzero if the parameter has been used in any one 2382 of the arguments processed so far. */ 2383 int* parms; 2384 2385 /* An array whose size is the number of template arguments. The 2386 elements are nonzero if the argument makes use of template 2387 parameters of this level. */ 2388 int* arg_uses_template_parms; 2389}; 2390 2391/* Subroutine of push_template_decl used to see if each template 2392 parameter in a partial specialization is used in the explicit 2393 argument list. If T is of the LEVEL given in DATA (which is 2394 treated as a template_parm_data*), then DATA->PARMS is marked 2395 appropriately. */ 2396 2397static int 2398mark_template_parm (tree t, void* data) 2399{ 2400 int level; 2401 int idx; 2402 struct template_parm_data* tpd = (struct template_parm_data*) data; 2403 2404 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX) 2405 { 2406 level = TEMPLATE_PARM_LEVEL (t); 2407 idx = TEMPLATE_PARM_IDX (t); 2408 } 2409 else 2410 { 2411 level = TEMPLATE_TYPE_LEVEL (t); 2412 idx = TEMPLATE_TYPE_IDX (t); 2413 } 2414 2415 if (level == tpd->level) 2416 { 2417 tpd->parms[idx] = 1; 2418 tpd->arg_uses_template_parms[tpd->current_arg] = 1; 2419 } 2420 2421 /* Return zero so that for_each_template_parm will continue the 2422 traversal of the tree; we want to mark *every* template parm. */ 2423 return 0; 2424} 2425 2426/* Process the partial specialization DECL. */ 2427 2428static tree 2429process_partial_specialization (tree decl) 2430{ 2431 tree type = TREE_TYPE (decl); 2432 tree maintmpl = CLASSTYPE_TI_TEMPLATE (type); 2433 tree specargs = CLASSTYPE_TI_ARGS (type); 2434 tree inner_args = INNERMOST_TEMPLATE_ARGS (specargs); 2435 tree inner_parms = INNERMOST_TEMPLATE_PARMS (current_template_parms); 2436 tree main_inner_parms = DECL_INNERMOST_TEMPLATE_PARMS (maintmpl); 2437 int nargs = TREE_VEC_LENGTH (inner_args); 2438 int ntparms = TREE_VEC_LENGTH (inner_parms); 2439 int i; 2440 int did_error_intro = 0; 2441 struct template_parm_data tpd; 2442 struct template_parm_data tpd2; 2443 2444 /* We check that each of the template parameters given in the 2445 partial specialization is used in the argument list to the 2446 specialization. For example: 2447 2448 template <class T> struct S; 2449 template <class T> struct S<T*>; 2450 2451 The second declaration is OK because `T*' uses the template 2452 parameter T, whereas 2453 2454 template <class T> struct S<int>; 2455 2456 is no good. Even trickier is: 2457 2458 template <class T> 2459 struct S1 2460 { 2461 template <class U> 2462 struct S2; 2463 template <class U> 2464 struct S2<T>; 2465 }; 2466 2467 The S2<T> declaration is actually invalid; it is a 2468 full-specialization. Of course, 2469 2470 template <class U> 2471 struct S2<T (*)(U)>; 2472 2473 or some such would have been OK. */ 2474 tpd.level = TMPL_PARMS_DEPTH (current_template_parms); 2475 tpd.parms = alloca (sizeof (int) * ntparms); 2476 memset (tpd.parms, 0, sizeof (int) * ntparms); 2477 2478 tpd.arg_uses_template_parms = alloca (sizeof (int) * nargs); 2479 memset (tpd.arg_uses_template_parms, 0, sizeof (int) * nargs); 2480 for (i = 0; i < nargs; ++i) 2481 { 2482 tpd.current_arg = i; 2483 for_each_template_parm (TREE_VEC_ELT (inner_args, i), 2484 &mark_template_parm, 2485 &tpd, 2486 NULL); 2487 } 2488 for (i = 0; i < ntparms; ++i) 2489 if (tpd.parms[i] == 0) 2490 { 2491 /* One of the template parms was not used in the 2492 specialization. */ 2493 if (!did_error_intro) 2494 { 2495 error ("template parameters not used in partial specialization:"); 2496 did_error_intro = 1; 2497 } 2498 2499 error (" `%D'", 2500 TREE_VALUE (TREE_VEC_ELT (inner_parms, i))); 2501 } 2502 2503 /* [temp.class.spec] 2504 2505 The argument list of the specialization shall not be identical to 2506 the implicit argument list of the primary template. */ 2507 if (comp_template_args 2508 (inner_args, 2509 INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE 2510 (maintmpl))))) 2511 error ("partial specialization `%T' does not specialize any template arguments", type); 2512 2513 /* [temp.class.spec] 2514 2515 A partially specialized non-type argument expression shall not 2516 involve template parameters of the partial specialization except 2517 when the argument expression is a simple identifier. 2518 2519 The type of a template parameter corresponding to a specialized 2520 non-type argument shall not be dependent on a parameter of the 2521 specialization. */ 2522 my_friendly_assert (nargs == DECL_NTPARMS (maintmpl), 0); 2523 tpd2.parms = 0; 2524 for (i = 0; i < nargs; ++i) 2525 { 2526 tree arg = TREE_VEC_ELT (inner_args, i); 2527 if (/* These first two lines are the `non-type' bit. */ 2528 !TYPE_P (arg) 2529 && TREE_CODE (arg) != TEMPLATE_DECL 2530 /* This next line is the `argument expression is not just a 2531 simple identifier' condition and also the `specialized 2532 non-type argument' bit. */ 2533 && TREE_CODE (arg) != TEMPLATE_PARM_INDEX) 2534 { 2535 if (tpd.arg_uses_template_parms[i]) 2536 error ("template argument `%E' involves template parameter(s)", arg); 2537 else 2538 { 2539 /* Look at the corresponding template parameter, 2540 marking which template parameters its type depends 2541 upon. */ 2542 tree type = 2543 TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (main_inner_parms, 2544 i))); 2545 2546 if (!tpd2.parms) 2547 { 2548 /* We haven't yet initialized TPD2. Do so now. */ 2549 tpd2.arg_uses_template_parms 2550 = alloca (sizeof (int) * nargs); 2551 /* The number of parameters here is the number in the 2552 main template, which, as checked in the assertion 2553 above, is NARGS. */ 2554 tpd2.parms = alloca (sizeof (int) * nargs); 2555 tpd2.level = 2556 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl)); 2557 } 2558 2559 /* Mark the template parameters. But this time, we're 2560 looking for the template parameters of the main 2561 template, not in the specialization. */ 2562 tpd2.current_arg = i; 2563 tpd2.arg_uses_template_parms[i] = 0; 2564 memset (tpd2.parms, 0, sizeof (int) * nargs); 2565 for_each_template_parm (type, 2566 &mark_template_parm, 2567 &tpd2, 2568 NULL); 2569 2570 if (tpd2.arg_uses_template_parms [i]) 2571 { 2572 /* The type depended on some template parameters. 2573 If they are fully specialized in the 2574 specialization, that's OK. */ 2575 int j; 2576 for (j = 0; j < nargs; ++j) 2577 if (tpd2.parms[j] != 0 2578 && tpd.arg_uses_template_parms [j]) 2579 { 2580 error ("type `%T' of template argument `%E' depends on template parameter(s)", 2581 type, 2582 arg); 2583 break; 2584 } 2585 } 2586 } 2587 } 2588 } 2589 2590 if (retrieve_specialization (maintmpl, specargs)) 2591 /* We've already got this specialization. */ 2592 return decl; 2593 2594 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl) 2595 = tree_cons (inner_args, inner_parms, 2596 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)); 2597 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)) = type; 2598 return decl; 2599} 2600 2601/* Check that a template declaration's use of default arguments is not 2602 invalid. Here, PARMS are the template parameters. IS_PRIMARY is 2603 nonzero if DECL is the thing declared by a primary template. 2604 IS_PARTIAL is nonzero if DECL is a partial specialization. */ 2605 2606static void 2607check_default_tmpl_args (tree decl, tree parms, int is_primary, int is_partial) 2608{ 2609 const char *msg; 2610 int last_level_to_check; 2611 tree parm_level; 2612 2613 /* [temp.param] 2614 2615 A default template-argument shall not be specified in a 2616 function template declaration or a function template definition, nor 2617 in the template-parameter-list of the definition of a member of a 2618 class template. */ 2619 2620 if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL) 2621 /* You can't have a function template declaration in a local 2622 scope, nor you can you define a member of a class template in a 2623 local scope. */ 2624 return; 2625 2626 if (current_class_type 2627 && !TYPE_BEING_DEFINED (current_class_type) 2628 && DECL_LANG_SPECIFIC (decl) 2629 /* If this is either a friend defined in the scope of the class 2630 or a member function. */ 2631 && (DECL_FUNCTION_MEMBER_P (decl) 2632 ? same_type_p (DECL_CONTEXT (decl), current_class_type) 2633 : DECL_FRIEND_CONTEXT (decl) 2634 ? same_type_p (DECL_FRIEND_CONTEXT (decl), current_class_type) 2635 : false) 2636 /* And, if it was a member function, it really was defined in 2637 the scope of the class. */ 2638 && (!DECL_FUNCTION_MEMBER_P (decl) 2639 || DECL_INITIALIZED_IN_CLASS_P (decl))) 2640 /* We already checked these parameters when the template was 2641 declared, so there's no need to do it again now. This function 2642 was defined in class scope, but we're processing it's body now 2643 that the class is complete. */ 2644 return; 2645 2646 /* [temp.param] 2647 2648 If a template-parameter has a default template-argument, all 2649 subsequent template-parameters shall have a default 2650 template-argument supplied. */ 2651 for (parm_level = parms; parm_level; parm_level = TREE_CHAIN (parm_level)) 2652 { 2653 tree inner_parms = TREE_VALUE (parm_level); 2654 int ntparms = TREE_VEC_LENGTH (inner_parms); 2655 int seen_def_arg_p = 0; 2656 int i; 2657 2658 for (i = 0; i < ntparms; ++i) 2659 { 2660 tree parm = TREE_VEC_ELT (inner_parms, i); 2661 if (TREE_PURPOSE (parm)) 2662 seen_def_arg_p = 1; 2663 else if (seen_def_arg_p) 2664 { 2665 error ("no default argument for `%D'", TREE_VALUE (parm)); 2666 /* For better subsequent error-recovery, we indicate that 2667 there should have been a default argument. */ 2668 TREE_PURPOSE (parm) = error_mark_node; 2669 } 2670 } 2671 } 2672 2673 if (TREE_CODE (decl) != TYPE_DECL || is_partial || !is_primary) 2674 /* For an ordinary class template, default template arguments are 2675 allowed at the innermost level, e.g.: 2676 template <class T = int> 2677 struct S {}; 2678 but, in a partial specialization, they're not allowed even 2679 there, as we have in [temp.class.spec]: 2680 2681 The template parameter list of a specialization shall not 2682 contain default template argument values. 2683 2684 So, for a partial specialization, or for a function template, 2685 we look at all of them. */ 2686 ; 2687 else 2688 /* But, for a primary class template that is not a partial 2689 specialization we look at all template parameters except the 2690 innermost ones. */ 2691 parms = TREE_CHAIN (parms); 2692 2693 /* Figure out what error message to issue. */ 2694 if (TREE_CODE (decl) == FUNCTION_DECL) 2695 msg = "default template arguments may not be used in function templates"; 2696 else if (is_partial) 2697 msg = "default template arguments may not be used in partial specializations"; 2698 else 2699 msg = "default argument for template parameter for class enclosing `%D'"; 2700 2701 if (current_class_type && TYPE_BEING_DEFINED (current_class_type)) 2702 /* If we're inside a class definition, there's no need to 2703 examine the parameters to the class itself. On the one 2704 hand, they will be checked when the class is defined, and, 2705 on the other, default arguments are valid in things like: 2706 template <class T = double> 2707 struct S { template <class U> void f(U); }; 2708 Here the default argument for `S' has no bearing on the 2709 declaration of `f'. */ 2710 last_level_to_check = template_class_depth (current_class_type) + 1; 2711 else 2712 /* Check everything. */ 2713 last_level_to_check = 0; 2714 2715 for (parm_level = parms; 2716 parm_level && TMPL_PARMS_DEPTH (parm_level) >= last_level_to_check; 2717 parm_level = TREE_CHAIN (parm_level)) 2718 { 2719 tree inner_parms = TREE_VALUE (parm_level); 2720 int i; 2721 int ntparms; 2722 2723 ntparms = TREE_VEC_LENGTH (inner_parms); 2724 for (i = 0; i < ntparms; ++i) 2725 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i))) 2726 { 2727 if (msg) 2728 { 2729 error (msg, decl); 2730 msg = 0; 2731 } 2732 2733 /* Clear out the default argument so that we are not 2734 confused later. */ 2735 TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)) = NULL_TREE; 2736 } 2737 2738 /* At this point, if we're still interested in issuing messages, 2739 they must apply to classes surrounding the object declared. */ 2740 if (msg) 2741 msg = "default argument for template parameter for class enclosing `%D'"; 2742 } 2743} 2744 2745/* Worker for push_template_decl_real, called via 2746 for_each_template_parm. DATA is really an int, indicating the 2747 level of the parameters we are interested in. If T is a template 2748 parameter of that level, return nonzero. */ 2749 2750static int 2751template_parm_this_level_p (tree t, void* data) 2752{ 2753 int this_level = *(int *)data; 2754 int level; 2755 2756 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX) 2757 level = TEMPLATE_PARM_LEVEL (t); 2758 else 2759 level = TEMPLATE_TYPE_LEVEL (t); 2760 return level == this_level; 2761} 2762 2763/* Creates a TEMPLATE_DECL for the indicated DECL using the template 2764 parameters given by current_template_args, or reuses a 2765 previously existing one, if appropriate. Returns the DECL, or an 2766 equivalent one, if it is replaced via a call to duplicate_decls. 2767 2768 If IS_FRIEND is nonzero, DECL is a friend declaration. */ 2769 2770tree 2771push_template_decl_real (tree decl, int is_friend) 2772{ 2773 tree tmpl; 2774 tree args; 2775 tree info; 2776 tree ctx; 2777 int primary; 2778 int is_partial; 2779 int new_template_p = 0; 2780 2781 /* See if this is a partial specialization. */ 2782 is_partial = (DECL_IMPLICIT_TYPEDEF_P (decl) 2783 && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE 2784 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl))); 2785 2786 is_friend |= (TREE_CODE (decl) == FUNCTION_DECL && DECL_FRIEND_P (decl)); 2787 2788 if (is_friend) 2789 /* For a friend, we want the context of the friend function, not 2790 the type of which it is a friend. */ 2791 ctx = DECL_CONTEXT (decl); 2792 else if (CP_DECL_CONTEXT (decl) 2793 && TREE_CODE (CP_DECL_CONTEXT (decl)) != NAMESPACE_DECL) 2794 /* In the case of a virtual function, we want the class in which 2795 it is defined. */ 2796 ctx = CP_DECL_CONTEXT (decl); 2797 else 2798 /* Otherwise, if we're currently defining some class, the DECL 2799 is assumed to be a member of the class. */ 2800 ctx = current_scope (); 2801 2802 if (ctx && TREE_CODE (ctx) == NAMESPACE_DECL) 2803 ctx = NULL_TREE; 2804 2805 if (!DECL_CONTEXT (decl)) 2806 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace); 2807 2808 /* See if this is a primary template. */ 2809 primary = template_parm_scope_p (); 2810 2811 if (primary) 2812 { 2813 if (current_lang_name == lang_name_c) 2814 error ("template with C linkage"); 2815 else if (TREE_CODE (decl) == TYPE_DECL 2816 && ANON_AGGRNAME_P (DECL_NAME (decl))) 2817 error ("template class without a name"); 2818 else if (TREE_CODE (decl) == FUNCTION_DECL) 2819 { 2820 if (DECL_DESTRUCTOR_P (decl)) 2821 { 2822 /* [temp.mem] 2823 2824 A destructor shall not be a member template. */ 2825 error ("destructor `%D' declared as member template", decl); 2826 return error_mark_node; 2827 } 2828 if (NEW_DELETE_OPNAME_P (DECL_NAME (decl)) 2829 && (!TYPE_ARG_TYPES (TREE_TYPE (decl)) 2830 || TYPE_ARG_TYPES (TREE_TYPE (decl)) == void_list_node 2831 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl))) 2832 || (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl)))) 2833 == void_list_node))) 2834 { 2835 /* [basic.stc.dynamic.allocation] 2836 2837 An allocation function can be a function 2838 template. ... Template allocation functions shall 2839 have two or more parameters. */ 2840 error ("invalid template declaration of `%D'", decl); 2841 return decl; 2842 } 2843 } 2844 else if (DECL_IMPLICIT_TYPEDEF_P (decl) 2845 && CLASS_TYPE_P (TREE_TYPE (decl))) 2846 /* OK */; 2847 else 2848 { 2849 error ("template declaration of `%#D'", decl); 2850 return error_mark_node; 2851 } 2852 } 2853 2854 /* Check to see that the rules regarding the use of default 2855 arguments are not being violated. */ 2856 check_default_tmpl_args (decl, current_template_parms, 2857 primary, is_partial); 2858 2859 if (is_partial) 2860 return process_partial_specialization (decl); 2861 2862 args = current_template_args (); 2863 2864 if (!ctx 2865 || TREE_CODE (ctx) == FUNCTION_DECL 2866 || (CLASS_TYPE_P (ctx) && TYPE_BEING_DEFINED (ctx)) 2867 || (is_friend && !DECL_TEMPLATE_INFO (decl))) 2868 { 2869 if (DECL_LANG_SPECIFIC (decl) 2870 && DECL_TEMPLATE_INFO (decl) 2871 && DECL_TI_TEMPLATE (decl)) 2872 tmpl = DECL_TI_TEMPLATE (decl); 2873 /* If DECL is a TYPE_DECL for a class-template, then there won't 2874 be DECL_LANG_SPECIFIC. The information equivalent to 2875 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */ 2876 else if (DECL_IMPLICIT_TYPEDEF_P (decl) 2877 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl)) 2878 && TYPE_TI_TEMPLATE (TREE_TYPE (decl))) 2879 { 2880 /* Since a template declaration already existed for this 2881 class-type, we must be redeclaring it here. Make sure 2882 that the redeclaration is valid. */ 2883 redeclare_class_template (TREE_TYPE (decl), 2884 current_template_parms); 2885 /* We don't need to create a new TEMPLATE_DECL; just use the 2886 one we already had. */ 2887 tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl)); 2888 } 2889 else 2890 { 2891 tmpl = build_template_decl (decl, current_template_parms); 2892 new_template_p = 1; 2893 2894 if (DECL_LANG_SPECIFIC (decl) 2895 && DECL_TEMPLATE_SPECIALIZATION (decl)) 2896 { 2897 /* A specialization of a member template of a template 2898 class. */ 2899 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl); 2900 DECL_TEMPLATE_INFO (tmpl) = DECL_TEMPLATE_INFO (decl); 2901 DECL_TEMPLATE_INFO (decl) = NULL_TREE; 2902 } 2903 } 2904 } 2905 else 2906 { 2907 tree a, t, current, parms; 2908 int i; 2909 2910 if (TREE_CODE (decl) == TYPE_DECL) 2911 { 2912 if ((IS_AGGR_TYPE_CODE (TREE_CODE (TREE_TYPE (decl))) 2913 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE) 2914 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl)) 2915 && TYPE_TI_TEMPLATE (TREE_TYPE (decl))) 2916 tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl)); 2917 else 2918 { 2919 error ("`%D' does not declare a template type", decl); 2920 return decl; 2921 } 2922 } 2923 else if (!DECL_LANG_SPECIFIC (decl) || !DECL_TEMPLATE_INFO (decl)) 2924 { 2925 error ("template definition of non-template `%#D'", decl); 2926 return decl; 2927 } 2928 else 2929 tmpl = DECL_TI_TEMPLATE (decl); 2930 2931 if (DECL_FUNCTION_TEMPLATE_P (tmpl) 2932 && DECL_TEMPLATE_INFO (decl) && DECL_TI_ARGS (decl) 2933 && DECL_TEMPLATE_SPECIALIZATION (decl) 2934 && is_member_template (tmpl)) 2935 { 2936 tree new_tmpl; 2937 2938 /* The declaration is a specialization of a member 2939 template, declared outside the class. Therefore, the 2940 innermost template arguments will be NULL, so we 2941 replace them with the arguments determined by the 2942 earlier call to check_explicit_specialization. */ 2943 args = DECL_TI_ARGS (decl); 2944 2945 new_tmpl 2946 = build_template_decl (decl, current_template_parms); 2947 DECL_TEMPLATE_RESULT (new_tmpl) = decl; 2948 TREE_TYPE (new_tmpl) = TREE_TYPE (decl); 2949 DECL_TI_TEMPLATE (decl) = new_tmpl; 2950 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl); 2951 DECL_TEMPLATE_INFO (new_tmpl) 2952 = tree_cons (tmpl, args, NULL_TREE); 2953 2954 register_specialization (new_tmpl, 2955 most_general_template (tmpl), 2956 args); 2957 return decl; 2958 } 2959 2960 /* Make sure the template headers we got make sense. */ 2961 2962 parms = DECL_TEMPLATE_PARMS (tmpl); 2963 i = TMPL_PARMS_DEPTH (parms); 2964 if (TMPL_ARGS_DEPTH (args) != i) 2965 { 2966 error ("expected %d levels of template parms for `%#D', got %d", 2967 i, decl, TMPL_ARGS_DEPTH (args)); 2968 } 2969 else 2970 for (current = decl; i > 0; --i, parms = TREE_CHAIN (parms)) 2971 { 2972 a = TMPL_ARGS_LEVEL (args, i); 2973 t = INNERMOST_TEMPLATE_PARMS (parms); 2974 2975 if (TREE_VEC_LENGTH (t) != TREE_VEC_LENGTH (a)) 2976 { 2977 if (current == decl) 2978 error ("got %d template parameters for `%#D'", 2979 TREE_VEC_LENGTH (a), decl); 2980 else 2981 error ("got %d template parameters for `%#T'", 2982 TREE_VEC_LENGTH (a), current); 2983 error (" but %d required", TREE_VEC_LENGTH (t)); 2984 return error_mark_node; 2985 } 2986 2987 /* Perhaps we should also check that the parms are used in the 2988 appropriate qualifying scopes in the declarator? */ 2989 2990 if (current == decl) 2991 current = ctx; 2992 else 2993 current = TYPE_CONTEXT (current); 2994 } 2995 } 2996 2997 DECL_TEMPLATE_RESULT (tmpl) = decl; 2998 TREE_TYPE (tmpl) = TREE_TYPE (decl); 2999 3000 /* Push template declarations for global functions and types. Note 3001 that we do not try to push a global template friend declared in a 3002 template class; such a thing may well depend on the template 3003 parameters of the class. */ 3004 if (new_template_p && !ctx 3005 && !(is_friend && template_class_depth (current_class_type) > 0)) 3006 tmpl = pushdecl_namespace_level (tmpl); 3007 3008 if (primary) 3009 { 3010 DECL_PRIMARY_TEMPLATE (tmpl) = tmpl; 3011 if (DECL_CONV_FN_P (tmpl)) 3012 { 3013 int depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)); 3014 3015 /* It is a conversion operator. See if the type converted to 3016 depends on innermost template operands. */ 3017 3018 if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl)), 3019 depth)) 3020 DECL_TEMPLATE_CONV_FN_P (tmpl) = 1; 3021 } 3022 } 3023 3024 /* The DECL_TI_ARGS of DECL contains full set of arguments refering 3025 back to its most general template. If TMPL is a specialization, 3026 ARGS may only have the innermost set of arguments. Add the missing 3027 argument levels if necessary. */ 3028 if (DECL_TEMPLATE_INFO (tmpl)) 3029 args = add_outermost_template_args (DECL_TI_ARGS (tmpl), args); 3030 3031 info = tree_cons (tmpl, args, NULL_TREE); 3032 3033 if (DECL_IMPLICIT_TYPEDEF_P (decl)) 3034 { 3035 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl), info); 3036 if ((!ctx || TREE_CODE (ctx) != FUNCTION_DECL) 3037 && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE 3038 /* Don't change the name if we've already set it up. */ 3039 && !IDENTIFIER_TEMPLATE (DECL_NAME (decl))) 3040 DECL_NAME (decl) = classtype_mangled_name (TREE_TYPE (decl)); 3041 } 3042 else if (DECL_LANG_SPECIFIC (decl)) 3043 DECL_TEMPLATE_INFO (decl) = info; 3044 3045 return DECL_TEMPLATE_RESULT (tmpl); 3046} 3047 3048tree 3049push_template_decl (tree decl) 3050{ 3051 return push_template_decl_real (decl, 0); 3052} 3053 3054/* Called when a class template TYPE is redeclared with the indicated 3055 template PARMS, e.g.: 3056 3057 template <class T> struct S; 3058 template <class T> struct S {}; */ 3059 3060void 3061redeclare_class_template (tree type, tree parms) 3062{ 3063 tree tmpl; 3064 tree tmpl_parms; 3065 int i; 3066 3067 if (!TYPE_TEMPLATE_INFO (type)) 3068 { 3069 error ("`%T' is not a template type", type); 3070 return; 3071 } 3072 3073 tmpl = TYPE_TI_TEMPLATE (type); 3074 if (!PRIMARY_TEMPLATE_P (tmpl)) 3075 /* The type is nested in some template class. Nothing to worry 3076 about here; there are no new template parameters for the nested 3077 type. */ 3078 return; 3079 3080 parms = INNERMOST_TEMPLATE_PARMS (parms); 3081 tmpl_parms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl); 3082 3083 if (TREE_VEC_LENGTH (parms) != TREE_VEC_LENGTH (tmpl_parms)) 3084 { 3085 cp_error_at ("previous declaration `%D'", tmpl); 3086 error ("used %d template parameter(s) instead of %d", 3087 TREE_VEC_LENGTH (tmpl_parms), 3088 TREE_VEC_LENGTH (parms)); 3089 return; 3090 } 3091 3092 for (i = 0; i < TREE_VEC_LENGTH (tmpl_parms); ++i) 3093 { 3094 tree tmpl_parm = TREE_VALUE (TREE_VEC_ELT (tmpl_parms, i)); 3095 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i)); 3096 tree tmpl_default = TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i)); 3097 tree parm_default = TREE_PURPOSE (TREE_VEC_ELT (parms, i)); 3098 3099 if (TREE_CODE (tmpl_parm) != TREE_CODE (parm)) 3100 { 3101 cp_error_at ("template parameter `%#D'", tmpl_parm); 3102 error ("redeclared here as `%#D'", parm); 3103 return; 3104 } 3105 3106 if (tmpl_default != NULL_TREE && parm_default != NULL_TREE) 3107 { 3108 /* We have in [temp.param]: 3109 3110 A template-parameter may not be given default arguments 3111 by two different declarations in the same scope. */ 3112 error ("redefinition of default argument for `%#D'", parm); 3113 error ("%J original definition appeared here", tmpl_parm); 3114 return; 3115 } 3116 3117 if (parm_default != NULL_TREE) 3118 /* Update the previous template parameters (which are the ones 3119 that will really count) with the new default value. */ 3120 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i)) = parm_default; 3121 else if (tmpl_default != NULL_TREE) 3122 /* Update the new parameters, too; they'll be used as the 3123 parameters for any members. */ 3124 TREE_PURPOSE (TREE_VEC_ELT (parms, i)) = tmpl_default; 3125 } 3126} 3127 3128/* Simplify EXPR if it is a non-dependent expression. Returns the 3129 (possibly simplified) expression. */ 3130 3131tree 3132fold_non_dependent_expr (tree expr) 3133{ 3134 /* If we're in a template, but EXPR isn't value dependent, simplify 3135 it. We're supposed to treat: 3136 3137 template <typename T> void f(T[1 + 1]); 3138 template <typename T> void f(T[2]); 3139 3140 as two declarations of the same function, for example. */ 3141 if (processing_template_decl 3142 && !type_dependent_expression_p (expr) 3143 && !value_dependent_expression_p (expr)) 3144 { 3145 HOST_WIDE_INT saved_processing_template_decl; 3146 3147 saved_processing_template_decl = processing_template_decl; 3148 processing_template_decl = 0; 3149 expr = tsubst_copy_and_build (expr, 3150 /*args=*/NULL_TREE, 3151 tf_error, 3152 /*in_decl=*/NULL_TREE, 3153 /*function_p=*/false); 3154 processing_template_decl = saved_processing_template_decl; 3155 } 3156 return expr; 3157} 3158 3159/* Attempt to convert the non-type template parameter EXPR to the 3160 indicated TYPE. If the conversion is successful, return the 3161 converted value. If the conversion is unsuccessful, return 3162 NULL_TREE if we issued an error message, or error_mark_node if we 3163 did not. We issue error messages for out-and-out bad template 3164 parameters, but not simply because the conversion failed, since we 3165 might be just trying to do argument deduction. Both TYPE and EXPR 3166 must be non-dependent. */ 3167 3168static tree 3169convert_nontype_argument (tree type, tree expr) 3170{ 3171 tree expr_type; 3172 3173 /* If we are in a template, EXPR may be non-dependent, but still 3174 have a syntactic, rather than semantic, form. For example, EXPR 3175 might be a SCOPE_REF, rather than the VAR_DECL to which the 3176 SCOPE_REF refers. Preserving the qualifying scope is necessary 3177 so that access checking can be performed when the template is 3178 instantiated -- but here we need the resolved form so that we can 3179 convert the argument. */ 3180 expr = fold_non_dependent_expr (expr); 3181 expr_type = TREE_TYPE (expr); 3182 3183 /* A template-argument for a non-type, non-template 3184 template-parameter shall be one of: 3185 3186 --an integral constant-expression of integral or enumeration 3187 type; or 3188 3189 --the name of a non-type template-parameter; or 3190 3191 --the name of an object or function with external linkage, 3192 including function templates and function template-ids but 3193 excluding non-static class members, expressed as id-expression; 3194 or 3195 3196 --the address of an object or function with external linkage, 3197 including function templates and function template-ids but 3198 excluding non-static class members, expressed as & id-expression 3199 where the & is optional if the name refers to a function or 3200 array; or 3201 3202 --a pointer to member expressed as described in _expr.unary.op_. */ 3203 3204 /* An integral constant-expression can include const variables or 3205. enumerators. Simplify things by folding them to their values, 3206 unless we're about to bind the declaration to a reference 3207 parameter. */ 3208 if (INTEGRAL_TYPE_P (expr_type) && TREE_CODE (type) != REFERENCE_TYPE) 3209 while (true) 3210 { 3211 tree const_expr = decl_constant_value (expr); 3212 /* In a template, the initializer for a VAR_DECL may not be 3213 marked as TREE_CONSTANT, in which case decl_constant_value 3214 will not return the initializer. Handle that special case 3215 here. */ 3216 if (expr == const_expr 3217 && DECL_INTEGRAL_CONSTANT_VAR_P (expr) 3218 /* DECL_INITIAL can be NULL if we are processing a 3219 variable initialized to an expression involving itself. 3220 We know it is initialized to a constant -- but not what 3221 constant, yet. */ 3222 && DECL_INITIAL (expr)) 3223 const_expr = DECL_INITIAL (expr); 3224 if (expr == const_expr) 3225 break; 3226 expr = fold_non_dependent_expr (const_expr); 3227 } 3228 3229 if (is_overloaded_fn (expr)) 3230 /* OK for now. We'll check that it has external linkage later. 3231 Check this first since if expr_type is the unknown_type_node 3232 we would otherwise complain below. */ 3233 ; 3234 else if (TYPE_PTR_TO_MEMBER_P (expr_type)) 3235 { 3236 if (TREE_CODE (expr) != PTRMEM_CST) 3237 goto bad_argument; 3238 } 3239 else if (TYPE_PTR_P (expr_type) 3240 || TREE_CODE (expr_type) == ARRAY_TYPE 3241 || TREE_CODE (type) == REFERENCE_TYPE 3242 /* If expr is the address of an overloaded function, we 3243 will get the unknown_type_node at this point. */ 3244 || expr_type == unknown_type_node) 3245 { 3246 tree referent; 3247 tree e = expr; 3248 STRIP_NOPS (e); 3249 3250 if (TREE_CODE (expr_type) == ARRAY_TYPE 3251 || (TREE_CODE (type) == REFERENCE_TYPE 3252 && TREE_CODE (e) != ADDR_EXPR)) 3253 referent = e; 3254 else 3255 { 3256 if (TREE_CODE (e) != ADDR_EXPR) 3257 { 3258 bad_argument: 3259 error ("`%E' is not a valid template argument", expr); 3260 if (TYPE_PTR_P (expr_type)) 3261 { 3262 if (TREE_CODE (TREE_TYPE (expr_type)) == FUNCTION_TYPE) 3263 error ("it must be the address of a function with external linkage"); 3264 else 3265 error ("it must be the address of an object with external linkage"); 3266 } 3267 else if (TYPE_PTR_TO_MEMBER_P (expr_type)) 3268 error ("it must be a pointer-to-member of the form `&X::Y'"); 3269 3270 return NULL_TREE; 3271 } 3272 3273 referent = TREE_OPERAND (e, 0); 3274 STRIP_NOPS (referent); 3275 } 3276 3277 if (TREE_CODE (referent) == STRING_CST) 3278 { 3279 error ("string literal %E is not a valid template argument because it is the address of an object with static linkage", 3280 referent); 3281 return NULL_TREE; 3282 } 3283 3284 if (TREE_CODE (referent) == SCOPE_REF) 3285 referent = TREE_OPERAND (referent, 1); 3286 3287 if (is_overloaded_fn (referent)) 3288 /* We'll check that it has external linkage later. */ 3289 ; 3290 else if (TREE_CODE (referent) != VAR_DECL) 3291 goto bad_argument; 3292 else if (!DECL_EXTERNAL_LINKAGE_P (referent)) 3293 { 3294 error ("address of non-extern `%E' cannot be used as template argument", referent); 3295 return error_mark_node; 3296 } 3297 } 3298 else if (INTEGRAL_TYPE_P (expr_type) || TYPE_PTR_TO_MEMBER_P (expr_type)) 3299 { 3300 if (! TREE_CONSTANT (expr)) 3301 { 3302 non_constant: 3303 error ("non-constant `%E' cannot be used as template argument", 3304 expr); 3305 return NULL_TREE; 3306 } 3307 } 3308 else 3309 { 3310 if (TYPE_P (expr)) 3311 error ("type '%T' cannot be used as a value for a non-type " 3312 "template-parameter", expr); 3313 else if (DECL_P (expr)) 3314 error ("invalid use of '%D' as a non-type template-argument", expr); 3315 else 3316 error ("invalid use of '%E' as a non-type template-argument", expr); 3317 3318 return NULL_TREE; 3319 } 3320 3321 switch (TREE_CODE (type)) 3322 { 3323 case INTEGER_TYPE: 3324 case BOOLEAN_TYPE: 3325 case ENUMERAL_TYPE: 3326 /* For a non-type template-parameter of integral or enumeration 3327 type, integral promotions (_conv.prom_) and integral 3328 conversions (_conv.integral_) are applied. */ 3329 if (!INTEGRAL_TYPE_P (expr_type)) 3330 return error_mark_node; 3331 3332 /* It's safe to call digest_init in this case; we know we're 3333 just converting one integral constant expression to another. */ 3334 expr = digest_init (type, expr, (tree*) 0); 3335 3336 if (TREE_CODE (expr) != INTEGER_CST) 3337 /* Curiously, some TREE_CONSTANT integral expressions do not 3338 simplify to integer constants. For example, `3 % 0', 3339 remains a TRUNC_MOD_EXPR. */ 3340 goto non_constant; 3341 3342 return expr; 3343 3344 case OFFSET_TYPE: 3345 { 3346 tree e; 3347 3348 /* For a non-type template-parameter of type pointer to data 3349 member, qualification conversions (_conv.qual_) are 3350 applied. */ 3351 e = perform_qualification_conversions (type, expr); 3352 if (TREE_CODE (e) == NOP_EXPR) 3353 /* The call to perform_qualification_conversions will 3354 insert a NOP_EXPR over EXPR to do express conversion, 3355 if necessary. But, that will confuse us if we use 3356 this (converted) template parameter to instantiate 3357 another template; then the thing will not look like a 3358 valid template argument. So, just make a new 3359 constant, of the appropriate type. */ 3360 e = make_ptrmem_cst (type, PTRMEM_CST_MEMBER (expr)); 3361 return e; 3362 } 3363 3364 case POINTER_TYPE: 3365 { 3366 tree type_pointed_to = TREE_TYPE (type); 3367 3368 if (TREE_CODE (type_pointed_to) == FUNCTION_TYPE) 3369 { 3370 /* For a non-type template-parameter of type pointer to 3371 function, only the function-to-pointer conversion 3372 (_conv.func_) is applied. If the template-argument 3373 represents a set of overloaded functions (or a pointer to 3374 such), the matching function is selected from the set 3375 (_over.over_). */ 3376 tree fns; 3377 tree fn; 3378 3379 if (TREE_CODE (expr) == ADDR_EXPR) 3380 fns = TREE_OPERAND (expr, 0); 3381 else 3382 fns = expr; 3383 3384 fn = instantiate_type (type_pointed_to, fns, tf_none); 3385 3386 if (fn == error_mark_node) 3387 return error_mark_node; 3388 3389 if (!DECL_EXTERNAL_LINKAGE_P (fn)) 3390 { 3391 if (really_overloaded_fn (fns)) 3392 return error_mark_node; 3393 else 3394 goto bad_argument; 3395 } 3396 3397 expr = build_unary_op (ADDR_EXPR, fn, 0); 3398 3399 my_friendly_assert (same_type_p (type, TREE_TYPE (expr)), 3400 0); 3401 return expr; 3402 } 3403 else 3404 { 3405 /* For a non-type template-parameter of type pointer to 3406 object, qualification conversions (_conv.qual_) and the 3407 array-to-pointer conversion (_conv.array_) are applied. 3408 [Note: In particular, neither the null pointer conversion 3409 (_conv.ptr_) nor the derived-to-base conversion 3410 (_conv.ptr_) are applied. Although 0 is a valid 3411 template-argument for a non-type template-parameter of 3412 integral type, it is not a valid template-argument for a 3413 non-type template-parameter of pointer type.] 3414 3415 The call to decay_conversion performs the 3416 array-to-pointer conversion, if appropriate. */ 3417 expr = decay_conversion (expr); 3418 3419 if (expr == error_mark_node) 3420 return error_mark_node; 3421 else 3422 return perform_qualification_conversions (type, expr); 3423 } 3424 } 3425 break; 3426 3427 case REFERENCE_TYPE: 3428 { 3429 tree type_referred_to = TREE_TYPE (type); 3430 3431 /* If this expression already has reference type, get the 3432 underlying object. */ 3433 if (TREE_CODE (expr_type) == REFERENCE_TYPE) 3434 { 3435 if (TREE_CODE (expr) == NOP_EXPR 3436 && TREE_CODE (TREE_OPERAND (expr, 0)) == ADDR_EXPR) 3437 STRIP_NOPS (expr); 3438 my_friendly_assert (TREE_CODE (expr) == ADDR_EXPR, 20000604); 3439 expr = TREE_OPERAND (expr, 0); 3440 expr_type = TREE_TYPE (expr); 3441 } 3442 3443 if (TREE_CODE (type_referred_to) == FUNCTION_TYPE) 3444 { 3445 /* For a non-type template-parameter of type reference to 3446 function, no conversions apply. If the 3447 template-argument represents a set of overloaded 3448 functions, the matching function is selected from the 3449 set (_over.over_). */ 3450 tree fn; 3451 3452 fn = instantiate_type (type_referred_to, expr, tf_none); 3453 3454 if (fn == error_mark_node) 3455 return error_mark_node; 3456 3457 if (!DECL_EXTERNAL_LINKAGE_P (fn)) 3458 { 3459 if (really_overloaded_fn (expr)) 3460 /* Don't issue an error here; we might get a different 3461 function if the overloading had worked out 3462 differently. */ 3463 return error_mark_node; 3464 else 3465 goto bad_argument; 3466 } 3467 3468 my_friendly_assert (same_type_p (type_referred_to, 3469 TREE_TYPE (fn)), 3470 0); 3471 3472 expr = fn; 3473 } 3474 else 3475 { 3476 /* For a non-type template-parameter of type reference to 3477 object, no conversions apply. The type referred to by the 3478 reference may be more cv-qualified than the (otherwise 3479 identical) type of the template-argument. The 3480 template-parameter is bound directly to the 3481 template-argument, which must be an lvalue. */ 3482 if (!same_type_p (TYPE_MAIN_VARIANT (expr_type), 3483 TYPE_MAIN_VARIANT (type_referred_to)) 3484 || !at_least_as_qualified_p (type_referred_to, 3485 expr_type) 3486 || !real_lvalue_p (expr)) 3487 return error_mark_node; 3488 } 3489 3490 cxx_mark_addressable (expr); 3491 return build_nop (type, build_address (expr)); 3492 } 3493 break; 3494 3495 case RECORD_TYPE: 3496 { 3497 my_friendly_assert (TYPE_PTRMEMFUNC_P (type), 20010112); 3498 3499 /* For a non-type template-parameter of type pointer to member 3500 function, no conversions apply. If the template-argument 3501 represents a set of overloaded member functions, the 3502 matching member function is selected from the set 3503 (_over.over_). */ 3504 3505 if (!TYPE_PTRMEMFUNC_P (expr_type) && 3506 expr_type != unknown_type_node) 3507 return error_mark_node; 3508 3509 if (TREE_CODE (expr) == PTRMEM_CST) 3510 { 3511 /* A ptr-to-member constant. */ 3512 if (!same_type_p (type, expr_type)) 3513 return error_mark_node; 3514 else 3515 return expr; 3516 } 3517 3518 if (TREE_CODE (expr) != ADDR_EXPR) 3519 return error_mark_node; 3520 3521 expr = instantiate_type (type, expr, tf_none); 3522 3523 if (expr == error_mark_node) 3524 return error_mark_node; 3525 3526 if (!same_type_p (type, TREE_TYPE (expr))) 3527 return error_mark_node; 3528 3529 return expr; 3530 } 3531 break; 3532 3533 default: 3534 /* All non-type parameters must have one of these types. */ 3535 abort (); 3536 break; 3537 } 3538 3539 return error_mark_node; 3540} 3541 3542/* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for 3543 template template parameters. Both PARM_PARMS and ARG_PARMS are 3544 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL 3545 or PARM_DECL. 3546 3547 ARG_PARMS may contain more parameters than PARM_PARMS. If this is 3548 the case, then extra parameters must have default arguments. 3549 3550 Consider the example: 3551 template <class T, class Allocator = allocator> class vector; 3552 template<template <class U> class TT> class C; 3553 3554 C<vector> is a valid instantiation. PARM_PARMS for the above code 3555 contains a TYPE_DECL (for U), ARG_PARMS contains two TYPE_DECLs (for 3556 T and Allocator) and OUTER_ARGS contains the argument that is used to 3557 substitute the TT parameter. */ 3558 3559static int 3560coerce_template_template_parms (tree parm_parms, 3561 tree arg_parms, 3562 tsubst_flags_t complain, 3563 tree in_decl, 3564 tree outer_args) 3565{ 3566 int nparms, nargs, i; 3567 tree parm, arg; 3568 3569 my_friendly_assert (TREE_CODE (parm_parms) == TREE_VEC, 0); 3570 my_friendly_assert (TREE_CODE (arg_parms) == TREE_VEC, 0); 3571 3572 nparms = TREE_VEC_LENGTH (parm_parms); 3573 nargs = TREE_VEC_LENGTH (arg_parms); 3574 3575 /* The rule here is opposite of coerce_template_parms. */ 3576 if (nargs < nparms 3577 || (nargs > nparms 3578 && TREE_PURPOSE (TREE_VEC_ELT (arg_parms, nparms)) == NULL_TREE)) 3579 return 0; 3580 3581 for (i = 0; i < nparms; ++i) 3582 { 3583 parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, i)); 3584 arg = TREE_VALUE (TREE_VEC_ELT (arg_parms, i)); 3585 3586 if (arg == NULL_TREE || arg == error_mark_node 3587 || parm == NULL_TREE || parm == error_mark_node) 3588 return 0; 3589 3590 if (TREE_CODE (arg) != TREE_CODE (parm)) 3591 return 0; 3592 3593 switch (TREE_CODE (parm)) 3594 { 3595 case TYPE_DECL: 3596 break; 3597 3598 case TEMPLATE_DECL: 3599 /* We encounter instantiations of templates like 3600 template <template <template <class> class> class TT> 3601 class C; */ 3602 { 3603 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm); 3604 tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg); 3605 3606 if (!coerce_template_template_parms 3607 (parmparm, argparm, complain, in_decl, outer_args)) 3608 return 0; 3609 } 3610 break; 3611 3612 case PARM_DECL: 3613 /* The tsubst call is used to handle cases such as 3614 template <class T, template <T> class TT> class D; 3615 i.e. the parameter list of TT depends on earlier parameters. */ 3616 if (!same_type_p 3617 (tsubst (TREE_TYPE (parm), outer_args, complain, in_decl), 3618 TREE_TYPE (arg))) 3619 return 0; 3620 break; 3621 3622 default: 3623 abort (); 3624 } 3625 } 3626 return 1; 3627} 3628 3629/* Convert the indicated template ARG as necessary to match the 3630 indicated template PARM. Returns the converted ARG, or 3631 error_mark_node if the conversion was unsuccessful. Error and 3632 warning messages are issued under control of COMPLAIN. This 3633 conversion is for the Ith parameter in the parameter list. ARGS is 3634 the full set of template arguments deduced so far. */ 3635 3636static tree 3637convert_template_argument (tree parm, 3638 tree arg, 3639 tree args, 3640 tsubst_flags_t complain, 3641 int i, 3642 tree in_decl) 3643{ 3644 tree val; 3645 tree inner_args; 3646 int is_type, requires_type, is_tmpl_type, requires_tmpl_type; 3647 3648 inner_args = INNERMOST_TEMPLATE_ARGS (args); 3649 3650 if (TREE_CODE (arg) == TREE_LIST 3651 && TREE_CODE (TREE_VALUE (arg)) == OFFSET_REF) 3652 { 3653 /* The template argument was the name of some 3654 member function. That's usually 3655 invalid, but static members are OK. In any 3656 case, grab the underlying fields/functions 3657 and issue an error later if required. */ 3658 arg = TREE_VALUE (arg); 3659 TREE_TYPE (arg) = unknown_type_node; 3660 } 3661 3662 requires_tmpl_type = TREE_CODE (parm) == TEMPLATE_DECL; 3663 requires_type = (TREE_CODE (parm) == TYPE_DECL 3664 || requires_tmpl_type); 3665 3666 is_tmpl_type = ((TREE_CODE (arg) == TEMPLATE_DECL 3667 && TREE_CODE (DECL_TEMPLATE_RESULT (arg)) == TYPE_DECL) 3668 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM 3669 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE); 3670 3671 if (is_tmpl_type 3672 && (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM 3673 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)) 3674 arg = TYPE_STUB_DECL (arg); 3675 3676 is_type = TYPE_P (arg) || is_tmpl_type; 3677 3678 if (requires_type && ! is_type && TREE_CODE (arg) == SCOPE_REF 3679 && TREE_CODE (TREE_OPERAND (arg, 0)) == TEMPLATE_TYPE_PARM) 3680 { 3681 pedwarn ("to refer to a type member of a template parameter, use `typename %E'", arg); 3682 3683 arg = make_typename_type (TREE_OPERAND (arg, 0), 3684 TREE_OPERAND (arg, 1), 3685 complain & tf_error); 3686 is_type = 1; 3687 } 3688 if (is_type != requires_type) 3689 { 3690 if (in_decl) 3691 { 3692 if (complain & tf_error) 3693 { 3694 error ("type/value mismatch at argument %d in template parameter list for `%D'", 3695 i + 1, in_decl); 3696 if (is_type) 3697 error (" expected a constant of type `%T', got `%T'", 3698 TREE_TYPE (parm), 3699 (is_tmpl_type ? DECL_NAME (arg) : arg)); 3700 else if (requires_tmpl_type) 3701 error (" expected a class template, got `%E'", arg); 3702 else 3703 error (" expected a type, got `%E'", arg); 3704 } 3705 } 3706 return error_mark_node; 3707 } 3708 if (is_tmpl_type ^ requires_tmpl_type) 3709 { 3710 if (in_decl && (complain & tf_error)) 3711 { 3712 error ("type/value mismatch at argument %d in template parameter list for `%D'", 3713 i + 1, in_decl); 3714 if (is_tmpl_type) 3715 error (" expected a type, got `%T'", DECL_NAME (arg)); 3716 else 3717 error (" expected a class template, got `%T'", arg); 3718 } 3719 return error_mark_node; 3720 } 3721 3722 if (is_type) 3723 { 3724 if (requires_tmpl_type) 3725 { 3726 if (TREE_CODE (TREE_TYPE (arg)) == UNBOUND_CLASS_TEMPLATE) 3727 /* The number of argument required is not known yet. 3728 Just accept it for now. */ 3729 val = TREE_TYPE (arg); 3730 else 3731 { 3732 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm); 3733 tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg); 3734 3735 if (coerce_template_template_parms (parmparm, argparm, 3736 complain, in_decl, 3737 inner_args)) 3738 { 3739 val = arg; 3740 3741 /* TEMPLATE_TEMPLATE_PARM node is preferred over 3742 TEMPLATE_DECL. */ 3743 if (val != error_mark_node 3744 && DECL_TEMPLATE_TEMPLATE_PARM_P (val)) 3745 val = TREE_TYPE (val); 3746 } 3747 else 3748 { 3749 if (in_decl && (complain & tf_error)) 3750 { 3751 error ("type/value mismatch at argument %d in template parameter list for `%D'", 3752 i + 1, in_decl); 3753 error (" expected a template of type `%D', got `%D'", parm, arg); 3754 } 3755 3756 val = error_mark_node; 3757 } 3758 } 3759 } 3760 else 3761 val = groktypename (arg); 3762 } 3763 else 3764 { 3765 tree t = tsubst (TREE_TYPE (parm), args, complain, in_decl); 3766 3767 if (invalid_nontype_parm_type_p (t, complain)) 3768 return error_mark_node; 3769 3770 if (!uses_template_parms (arg) && !uses_template_parms (t)) 3771 /* We used to call digest_init here. However, digest_init 3772 will report errors, which we don't want when complain 3773 is zero. More importantly, digest_init will try too 3774 hard to convert things: for example, `0' should not be 3775 converted to pointer type at this point according to 3776 the standard. Accepting this is not merely an 3777 extension, since deciding whether or not these 3778 conversions can occur is part of determining which 3779 function template to call, or whether a given explicit 3780 argument specification is valid. */ 3781 val = convert_nontype_argument (t, arg); 3782 else 3783 val = arg; 3784 3785 if (val == NULL_TREE) 3786 val = error_mark_node; 3787 else if (val == error_mark_node && (complain & tf_error)) 3788 error ("could not convert template argument `%E' to `%T'", 3789 arg, t); 3790 } 3791 3792 return val; 3793} 3794 3795/* Convert all template arguments to their appropriate types, and 3796 return a vector containing the innermost resulting template 3797 arguments. If any error occurs, return error_mark_node. Error and 3798 warning messages are issued under control of COMPLAIN. 3799 3800 If REQUIRE_ALL_ARGUMENTS is nonzero, all arguments must be 3801 provided in ARGLIST, or else trailing parameters must have default 3802 values. If REQUIRE_ALL_ARGUMENTS is zero, we will attempt argument 3803 deduction for any unspecified trailing arguments. */ 3804 3805static tree 3806coerce_template_parms (tree parms, 3807 tree args, 3808 tree in_decl, 3809 tsubst_flags_t complain, 3810 int require_all_arguments) 3811{ 3812 int nparms, nargs, i, lost = 0; 3813 tree inner_args; 3814 tree new_args; 3815 tree new_inner_args; 3816 3817 inner_args = INNERMOST_TEMPLATE_ARGS (args); 3818 nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0; 3819 nparms = TREE_VEC_LENGTH (parms); 3820 3821 if (nargs > nparms 3822 || (nargs < nparms 3823 && require_all_arguments 3824 && TREE_PURPOSE (TREE_VEC_ELT (parms, nargs)) == NULL_TREE)) 3825 { 3826 if (complain & tf_error) 3827 { 3828 error ("wrong number of template arguments (%d, should be %d)", 3829 nargs, nparms); 3830 3831 if (in_decl) 3832 cp_error_at ("provided for `%D'", in_decl); 3833 } 3834 3835 return error_mark_node; 3836 } 3837 3838 new_inner_args = make_tree_vec (nparms); 3839 new_args = add_outermost_template_args (args, new_inner_args); 3840 for (i = 0; i < nparms; i++) 3841 { 3842 tree arg; 3843 tree parm; 3844 3845 /* Get the Ith template parameter. */ 3846 parm = TREE_VEC_ELT (parms, i); 3847 3848 /* Calculate the Ith argument. */ 3849 if (i < nargs) 3850 arg = TREE_VEC_ELT (inner_args, i); 3851 else if (require_all_arguments) 3852 /* There must be a default arg in this case. */ 3853 arg = tsubst_template_arg (TREE_PURPOSE (parm), new_args, 3854 complain, in_decl); 3855 else 3856 break; 3857 3858 my_friendly_assert (arg, 20030727); 3859 if (arg == error_mark_node) 3860 error ("template argument %d is invalid", i + 1); 3861 else 3862 arg = convert_template_argument (TREE_VALUE (parm), 3863 arg, new_args, complain, i, 3864 in_decl); 3865 3866 if (arg == error_mark_node) 3867 lost++; 3868 TREE_VEC_ELT (new_inner_args, i) = arg; 3869 } 3870 3871 if (lost) 3872 return error_mark_node; 3873 3874 return new_inner_args; 3875} 3876 3877/* Returns 1 if template args OT and NT are equivalent. */ 3878 3879static int 3880template_args_equal (tree ot, tree nt) 3881{ 3882 if (nt == ot) 3883 return 1; 3884 3885 if (TREE_CODE (nt) == TREE_VEC) 3886 /* For member templates */ 3887 return TREE_CODE (ot) == TREE_VEC && comp_template_args (ot, nt); 3888 else if (TYPE_P (nt)) 3889 return TYPE_P (ot) && same_type_p (ot, nt); 3890 else if (TREE_CODE (ot) == TREE_VEC || TYPE_P (ot)) 3891 return 0; 3892 else 3893 return cp_tree_equal (ot, nt); 3894} 3895 3896/* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets 3897 of template arguments. Returns 0 otherwise. */ 3898 3899int 3900comp_template_args (tree oldargs, tree newargs) 3901{ 3902 int i; 3903 3904 if (TREE_VEC_LENGTH (oldargs) != TREE_VEC_LENGTH (newargs)) 3905 return 0; 3906 3907 for (i = 0; i < TREE_VEC_LENGTH (oldargs); ++i) 3908 { 3909 tree nt = TREE_VEC_ELT (newargs, i); 3910 tree ot = TREE_VEC_ELT (oldargs, i); 3911 3912 if (! template_args_equal (ot, nt)) 3913 return 0; 3914 } 3915 return 1; 3916} 3917 3918/* Given class template name and parameter list, produce a user-friendly name 3919 for the instantiation. */ 3920 3921static char * 3922mangle_class_name_for_template (const char* name, tree parms, tree arglist) 3923{ 3924 static struct obstack scratch_obstack; 3925 static char *scratch_firstobj; 3926 int i, nparms; 3927 3928 if (!scratch_firstobj) 3929 gcc_obstack_init (&scratch_obstack); 3930 else 3931 obstack_free (&scratch_obstack, scratch_firstobj); 3932 scratch_firstobj = obstack_alloc (&scratch_obstack, 1); 3933 3934#define ccat(C) obstack_1grow (&scratch_obstack, (C)); 3935#define cat(S) obstack_grow (&scratch_obstack, (S), strlen (S)) 3936 3937 cat (name); 3938 ccat ('<'); 3939 nparms = TREE_VEC_LENGTH (parms); 3940 arglist = INNERMOST_TEMPLATE_ARGS (arglist); 3941 my_friendly_assert (nparms == TREE_VEC_LENGTH (arglist), 268); 3942 for (i = 0; i < nparms; i++) 3943 { 3944 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i)); 3945 tree arg = TREE_VEC_ELT (arglist, i); 3946 3947 if (i) 3948 ccat (','); 3949 3950 if (TREE_CODE (parm) == TYPE_DECL) 3951 { 3952 cat (type_as_string (arg, TFF_CHASE_TYPEDEF)); 3953 continue; 3954 } 3955 else if (TREE_CODE (parm) == TEMPLATE_DECL) 3956 { 3957 if (TREE_CODE (arg) == TEMPLATE_DECL) 3958 { 3959 /* Already substituted with real template. Just output 3960 the template name here */ 3961 tree context = DECL_CONTEXT (arg); 3962 if (context) 3963 { 3964 /* The template may be defined in a namespace, or 3965 may be a member template. */ 3966 my_friendly_assert (TREE_CODE (context) == NAMESPACE_DECL 3967 || CLASS_TYPE_P (context), 3968 980422); 3969 cat(decl_as_string (DECL_CONTEXT (arg), TFF_PLAIN_IDENTIFIER)); 3970 cat("::"); 3971 } 3972 cat (IDENTIFIER_POINTER (DECL_NAME (arg))); 3973 } 3974 else 3975 /* Output the parameter declaration. */ 3976 cat (type_as_string (arg, TFF_CHASE_TYPEDEF)); 3977 continue; 3978 } 3979 else 3980 my_friendly_assert (TREE_CODE (parm) == PARM_DECL, 269); 3981 3982 /* No need to check arglist against parmlist here; we did that 3983 in coerce_template_parms, called from lookup_template_class. */ 3984 cat (expr_as_string (arg, TFF_PLAIN_IDENTIFIER)); 3985 } 3986 { 3987 char *bufp = obstack_next_free (&scratch_obstack); 3988 int offset = 0; 3989 while (bufp[offset - 1] == ' ') 3990 offset--; 3991 obstack_blank_fast (&scratch_obstack, offset); 3992 3993 /* B<C<char> >, not B<C<char>> */ 3994 if (bufp[offset - 1] == '>') 3995 ccat (' '); 3996 } 3997 ccat ('>'); 3998 ccat ('\0'); 3999 return (char *) obstack_base (&scratch_obstack); 4000} 4001 4002static tree 4003classtype_mangled_name (tree t) 4004{ 4005 if (CLASSTYPE_TEMPLATE_INFO (t) 4006 /* Specializations have already had their names set up in 4007 lookup_template_class. */ 4008 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (t)) 4009 { 4010 tree tmpl = most_general_template (CLASSTYPE_TI_TEMPLATE (t)); 4011 4012 /* For non-primary templates, the template parameters are 4013 implicit from their surrounding context. */ 4014 if (PRIMARY_TEMPLATE_P (tmpl)) 4015 { 4016 tree name = DECL_NAME (tmpl); 4017 char *mangled_name = mangle_class_name_for_template 4018 (IDENTIFIER_POINTER (name), 4019 DECL_INNERMOST_TEMPLATE_PARMS (tmpl), 4020 CLASSTYPE_TI_ARGS (t)); 4021 tree id = get_identifier (mangled_name); 4022 IDENTIFIER_TEMPLATE (id) = name; 4023 return id; 4024 } 4025 } 4026 4027 return TYPE_IDENTIFIER (t); 4028} 4029 4030static void 4031add_pending_template (tree d) 4032{ 4033 tree ti = (TYPE_P (d) 4034 ? CLASSTYPE_TEMPLATE_INFO (d) 4035 : DECL_TEMPLATE_INFO (d)); 4036 tree pt; 4037 int level; 4038 4039 if (TI_PENDING_TEMPLATE_FLAG (ti)) 4040 return; 4041 4042 /* We are called both from instantiate_decl, where we've already had a 4043 tinst_level pushed, and instantiate_template, where we haven't. 4044 Compensate. */ 4045 level = !(current_tinst_level && TINST_DECL (current_tinst_level) == d); 4046 4047 if (level) 4048 push_tinst_level (d); 4049 4050 pt = tree_cons (current_tinst_level, d, NULL_TREE); 4051 if (last_pending_template) 4052 TREE_CHAIN (last_pending_template) = pt; 4053 else 4054 pending_templates = pt; 4055 4056 last_pending_template = pt; 4057 4058 TI_PENDING_TEMPLATE_FLAG (ti) = 1; 4059 4060 if (level) 4061 pop_tinst_level (); 4062} 4063 4064 4065/* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and 4066 ARGLIST. Valid choices for FNS are given in the cp-tree.def 4067 documentation for TEMPLATE_ID_EXPR. */ 4068 4069tree 4070lookup_template_function (tree fns, tree arglist) 4071{ 4072 tree type; 4073 4074 if (fns == error_mark_node || arglist == error_mark_node) 4075 return error_mark_node; 4076 4077 my_friendly_assert (!arglist || TREE_CODE (arglist) == TREE_VEC, 20030726); 4078 my_friendly_assert (fns && (is_overloaded_fn (fns) 4079 || TREE_CODE (fns) == IDENTIFIER_NODE), 4080 20050608); 4081 4082 if (BASELINK_P (fns)) 4083 { 4084 BASELINK_FUNCTIONS (fns) = build (TEMPLATE_ID_EXPR, 4085 unknown_type_node, 4086 BASELINK_FUNCTIONS (fns), 4087 arglist); 4088 return fns; 4089 } 4090 4091 type = TREE_TYPE (fns); 4092 if (TREE_CODE (fns) == OVERLOAD || !type) 4093 type = unknown_type_node; 4094 4095 return build (TEMPLATE_ID_EXPR, type, fns, arglist); 4096} 4097 4098/* Within the scope of a template class S<T>, the name S gets bound 4099 (in build_self_reference) to a TYPE_DECL for the class, not a 4100 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type, 4101 or one of its enclosing classes, and that type is a template, 4102 return the associated TEMPLATE_DECL. Otherwise, the original 4103 DECL is returned. */ 4104 4105tree 4106maybe_get_template_decl_from_type_decl (tree decl) 4107{ 4108 return (decl != NULL_TREE 4109 && TREE_CODE (decl) == TYPE_DECL 4110 && DECL_ARTIFICIAL (decl) 4111 && CLASS_TYPE_P (TREE_TYPE (decl)) 4112 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl))) 4113 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl)) : decl; 4114} 4115 4116/* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of 4117 parameters, find the desired type. 4118 4119 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments. 4120 4121 IN_DECL, if non-NULL, is the template declaration we are trying to 4122 instantiate. 4123 4124 If ENTERING_SCOPE is nonzero, we are about to enter the scope of 4125 the class we are looking up. 4126 4127 Issue error and warning messages under control of COMPLAIN. 4128 4129 If the template class is really a local class in a template 4130 function, then the FUNCTION_CONTEXT is the function in which it is 4131 being instantiated. */ 4132 4133tree 4134lookup_template_class (tree d1, 4135 tree arglist, 4136 tree in_decl, 4137 tree context, 4138 int entering_scope, 4139 tsubst_flags_t complain) 4140{ 4141 tree template = NULL_TREE, parmlist; 4142 tree t; 4143 4144 timevar_push (TV_NAME_LOOKUP); 4145 4146 if (TREE_CODE (d1) == IDENTIFIER_NODE) 4147 { 4148 if (IDENTIFIER_VALUE (d1) 4149 && DECL_TEMPLATE_TEMPLATE_PARM_P (IDENTIFIER_VALUE (d1))) 4150 template = IDENTIFIER_VALUE (d1); 4151 else 4152 { 4153 if (context) 4154 push_decl_namespace (context); 4155 template = lookup_name (d1, /*prefer_type=*/0); 4156 template = maybe_get_template_decl_from_type_decl (template); 4157 if (context) 4158 pop_decl_namespace (); 4159 } 4160 if (template) 4161 context = DECL_CONTEXT (template); 4162 } 4163 else if (TREE_CODE (d1) == TYPE_DECL && IS_AGGR_TYPE (TREE_TYPE (d1))) 4164 { 4165 tree type = TREE_TYPE (d1); 4166 4167 /* If we are declaring a constructor, say A<T>::A<T>, we will get 4168 an implicit typename for the second A. Deal with it. */ 4169 if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type)) 4170 type = TREE_TYPE (type); 4171 4172 if (CLASSTYPE_TEMPLATE_INFO (type)) 4173 { 4174 template = CLASSTYPE_TI_TEMPLATE (type); 4175 d1 = DECL_NAME (template); 4176 } 4177 } 4178 else if (TREE_CODE (d1) == ENUMERAL_TYPE 4179 || (TYPE_P (d1) && IS_AGGR_TYPE (d1))) 4180 { 4181 template = TYPE_TI_TEMPLATE (d1); 4182 d1 = DECL_NAME (template); 4183 } 4184 else if (TREE_CODE (d1) == TEMPLATE_DECL 4185 && TREE_CODE (DECL_TEMPLATE_RESULT (d1)) == TYPE_DECL) 4186 { 4187 template = d1; 4188 d1 = DECL_NAME (template); 4189 context = DECL_CONTEXT (template); 4190 } 4191 4192 /* With something like `template <class T> class X class X { ... };' 4193 we could end up with D1 having nothing but an IDENTIFIER_VALUE. 4194 We don't want to do that, but we have to deal with the situation, 4195 so let's give them some syntax errors to chew on instead of a 4196 crash. Alternatively D1 might not be a template type at all. */ 4197 if (! template) 4198 { 4199 if (complain & tf_error) 4200 error ("`%T' is not a template", d1); 4201 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node); 4202 } 4203 4204 if (TREE_CODE (template) != TEMPLATE_DECL 4205 /* Make sure it's a user visible template, if it was named by 4206 the user. */ 4207 || ((complain & tf_user) && !DECL_TEMPLATE_PARM_P (template) 4208 && !PRIMARY_TEMPLATE_P (template))) 4209 { 4210 if (complain & tf_error) 4211 { 4212 error ("non-template type `%T' used as a template", d1); 4213 if (in_decl) 4214 cp_error_at ("for template declaration `%D'", in_decl); 4215 } 4216 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node); 4217 } 4218 4219 complain &= ~tf_user; 4220 4221 if (DECL_TEMPLATE_TEMPLATE_PARM_P (template)) 4222 { 4223 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store 4224 template arguments */ 4225 4226 tree parm; 4227 tree arglist2; 4228 4229 parmlist = DECL_INNERMOST_TEMPLATE_PARMS (template); 4230 4231 /* Consider an example where a template template parameter declared as 4232 4233 template <class T, class U = std::allocator<T> > class TT 4234 4235 The template parameter level of T and U are one level larger than 4236 of TT. To proper process the default argument of U, say when an 4237 instantiation `TT<int>' is seen, we need to build the full 4238 arguments containing {int} as the innermost level. Outer levels, 4239 available when not appearing as default template argument, can be 4240 obtained from `current_template_args ()'. 4241 4242 Suppose that TT is later substituted with std::vector. The above 4243 instantiation is `TT<int, std::allocator<T> >' with TT at 4244 level 1, and T at level 2, while the template arguments at level 1 4245 becomes {std::vector} and the inner level 2 is {int}. */ 4246 4247 if (current_template_parms) 4248 arglist = add_to_template_args (current_template_args (), arglist); 4249 4250 arglist2 = coerce_template_parms (parmlist, arglist, template, 4251 complain, /*require_all_args=*/1); 4252 if (arglist2 == error_mark_node 4253 || (!uses_template_parms (arglist2) 4254 && check_instantiated_args (template, arglist2, complain))) 4255 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node); 4256 4257 parm = bind_template_template_parm (TREE_TYPE (template), arglist2); 4258 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, parm); 4259 } 4260 else 4261 { 4262 tree template_type = TREE_TYPE (template); 4263 tree gen_tmpl; 4264 tree type_decl; 4265 tree found = NULL_TREE; 4266 tree *tp; 4267 int arg_depth; 4268 int parm_depth; 4269 int is_partial_instantiation; 4270 4271 gen_tmpl = most_general_template (template); 4272 parmlist = DECL_TEMPLATE_PARMS (gen_tmpl); 4273 parm_depth = TMPL_PARMS_DEPTH (parmlist); 4274 arg_depth = TMPL_ARGS_DEPTH (arglist); 4275 4276 if (arg_depth == 1 && parm_depth > 1) 4277 { 4278 /* We've been given an incomplete set of template arguments. 4279 For example, given: 4280 4281 template <class T> struct S1 { 4282 template <class U> struct S2 {}; 4283 template <class U> struct S2<U*> {}; 4284 }; 4285 4286 we will be called with an ARGLIST of `U*', but the 4287 TEMPLATE will be `template <class T> template 4288 <class U> struct S1<T>::S2'. We must fill in the missing 4289 arguments. */ 4290 arglist 4291 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (template)), 4292 arglist); 4293 arg_depth = TMPL_ARGS_DEPTH (arglist); 4294 } 4295 4296 /* Now we should have enough arguments. */ 4297 my_friendly_assert (parm_depth == arg_depth, 0); 4298 4299 /* From here on, we're only interested in the most general 4300 template. */ 4301 template = gen_tmpl; 4302 4303 /* Calculate the BOUND_ARGS. These will be the args that are 4304 actually tsubst'd into the definition to create the 4305 instantiation. */ 4306 if (parm_depth > 1) 4307 { 4308 /* We have multiple levels of arguments to coerce, at once. */ 4309 int i; 4310 int saved_depth = TMPL_ARGS_DEPTH (arglist); 4311 4312 tree bound_args = make_tree_vec (parm_depth); 4313 4314 for (i = saved_depth, 4315 t = DECL_TEMPLATE_PARMS (template); 4316 i > 0 && t != NULL_TREE; 4317 --i, t = TREE_CHAIN (t)) 4318 { 4319 tree a = coerce_template_parms (TREE_VALUE (t), 4320 arglist, template, 4321 complain, /*require_all_args=*/1); 4322 4323 /* Don't process further if one of the levels fails. */ 4324 if (a == error_mark_node) 4325 { 4326 /* Restore the ARGLIST to its full size. */ 4327 TREE_VEC_LENGTH (arglist) = saved_depth; 4328 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node); 4329 } 4330 4331 SET_TMPL_ARGS_LEVEL (bound_args, i, a); 4332 4333 /* We temporarily reduce the length of the ARGLIST so 4334 that coerce_template_parms will see only the arguments 4335 corresponding to the template parameters it is 4336 examining. */ 4337 TREE_VEC_LENGTH (arglist)--; 4338 } 4339 4340 /* Restore the ARGLIST to its full size. */ 4341 TREE_VEC_LENGTH (arglist) = saved_depth; 4342 4343 arglist = bound_args; 4344 } 4345 else 4346 arglist 4347 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist), 4348 INNERMOST_TEMPLATE_ARGS (arglist), 4349 template, 4350 complain, /*require_all_args=*/1); 4351 4352 if (arglist == error_mark_node) 4353 /* We were unable to bind the arguments. */ 4354 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node); 4355 4356 /* In the scope of a template class, explicit references to the 4357 template class refer to the type of the template, not any 4358 instantiation of it. For example, in: 4359 4360 template <class T> class C { void f(C<T>); } 4361 4362 the `C<T>' is just the same as `C'. Outside of the 4363 class, however, such a reference is an instantiation. */ 4364 if (comp_template_args (TYPE_TI_ARGS (template_type), 4365 arglist)) 4366 { 4367 found = template_type; 4368 4369 if (!entering_scope && PRIMARY_TEMPLATE_P (template)) 4370 { 4371 tree ctx; 4372 4373 for (ctx = current_class_type; 4374 ctx && TREE_CODE (ctx) != NAMESPACE_DECL; 4375 ctx = (TYPE_P (ctx) 4376 ? TYPE_CONTEXT (ctx) 4377 : DECL_CONTEXT (ctx))) 4378 if (TYPE_P (ctx) && same_type_p (ctx, template_type)) 4379 goto found_ctx; 4380 4381 /* We're not in the scope of the class, so the 4382 TEMPLATE_TYPE is not the type we want after all. */ 4383 found = NULL_TREE; 4384 found_ctx:; 4385 } 4386 } 4387 if (found) 4388 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found); 4389 4390 for (tp = &DECL_TEMPLATE_INSTANTIATIONS (template); 4391 *tp; 4392 tp = &TREE_CHAIN (*tp)) 4393 if (comp_template_args (TREE_PURPOSE (*tp), arglist)) 4394 { 4395 found = *tp; 4396 4397 /* Use the move-to-front heuristic to speed up future 4398 searches. */ 4399 *tp = TREE_CHAIN (*tp); 4400 TREE_CHAIN (found) 4401 = DECL_TEMPLATE_INSTANTIATIONS (template); 4402 DECL_TEMPLATE_INSTANTIATIONS (template) = found; 4403 4404 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, TREE_VALUE (found)); 4405 } 4406 4407 /* This type is a "partial instantiation" if any of the template 4408 arguments still involve template parameters. Note that we set 4409 IS_PARTIAL_INSTANTIATION for partial specializations as 4410 well. */ 4411 is_partial_instantiation = uses_template_parms (arglist); 4412 4413 /* If the deduced arguments are invalid, then the binding 4414 failed. */ 4415 if (!is_partial_instantiation 4416 && check_instantiated_args (template, 4417 INNERMOST_TEMPLATE_ARGS (arglist), 4418 complain)) 4419 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node); 4420 4421 if (!is_partial_instantiation 4422 && !PRIMARY_TEMPLATE_P (template) 4423 && TREE_CODE (CP_DECL_CONTEXT (template)) == NAMESPACE_DECL) 4424 { 4425 found = xref_tag_from_type (TREE_TYPE (template), 4426 DECL_NAME (template), 4427 /*globalize=*/1); 4428 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found); 4429 } 4430 4431 context = tsubst (DECL_CONTEXT (template), arglist, 4432 complain, in_decl); 4433 if (!context) 4434 context = global_namespace; 4435 4436 /* Create the type. */ 4437 if (TREE_CODE (template_type) == ENUMERAL_TYPE) 4438 { 4439 if (!is_partial_instantiation) 4440 { 4441 set_current_access_from_decl (TYPE_NAME (template_type)); 4442 t = start_enum (TYPE_IDENTIFIER (template_type)); 4443 } 4444 else 4445 /* We don't want to call start_enum for this type, since 4446 the values for the enumeration constants may involve 4447 template parameters. And, no one should be interested 4448 in the enumeration constants for such a type. */ 4449 t = make_node (ENUMERAL_TYPE); 4450 } 4451 else 4452 { 4453 t = make_aggr_type (TREE_CODE (template_type)); 4454 CLASSTYPE_DECLARED_CLASS (t) 4455 = CLASSTYPE_DECLARED_CLASS (template_type); 4456 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t); 4457 TYPE_FOR_JAVA (t) = TYPE_FOR_JAVA (template_type); 4458 4459 /* A local class. Make sure the decl gets registered properly. */ 4460 if (context == current_function_decl) 4461 pushtag (DECL_NAME (template), t, 0); 4462 } 4463 4464 /* If we called start_enum or pushtag above, this information 4465 will already be set up. */ 4466 if (!TYPE_NAME (t)) 4467 { 4468 TYPE_CONTEXT (t) = FROB_CONTEXT (context); 4469 4470 type_decl = create_implicit_typedef (DECL_NAME (template), t); 4471 DECL_CONTEXT (type_decl) = TYPE_CONTEXT (t); 4472 TYPE_STUB_DECL (t) = type_decl; 4473 DECL_SOURCE_LOCATION (type_decl) 4474 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type)); 4475 } 4476 else 4477 type_decl = TYPE_NAME (t); 4478 4479 TREE_PRIVATE (type_decl) 4480 = TREE_PRIVATE (TYPE_STUB_DECL (template_type)); 4481 TREE_PROTECTED (type_decl) 4482 = TREE_PROTECTED (TYPE_STUB_DECL (template_type)); 4483 4484 /* Set up the template information. We have to figure out which 4485 template is the immediate parent if this is a full 4486 instantiation. */ 4487 if (parm_depth == 1 || is_partial_instantiation 4488 || !PRIMARY_TEMPLATE_P (template)) 4489 /* This case is easy; there are no member templates involved. */ 4490 found = template; 4491 else 4492 { 4493 /* This is a full instantiation of a member template. Look 4494 for a partial instantiation of which this is an instance. */ 4495 4496 for (found = DECL_TEMPLATE_INSTANTIATIONS (template); 4497 found; found = TREE_CHAIN (found)) 4498 { 4499 int success; 4500 tree tmpl = CLASSTYPE_TI_TEMPLATE (TREE_VALUE (found)); 4501 4502 /* We only want partial instantiations, here, not 4503 specializations or full instantiations. */ 4504 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_VALUE (found)) 4505 || !uses_template_parms (TREE_VALUE (found))) 4506 continue; 4507 4508 /* Temporarily reduce by one the number of levels in the 4509 ARGLIST and in FOUND so as to avoid comparing the 4510 last set of arguments. */ 4511 TREE_VEC_LENGTH (arglist)--; 4512 TREE_VEC_LENGTH (TREE_PURPOSE (found)) --; 4513 4514 /* See if the arguments match. If they do, then TMPL is 4515 the partial instantiation we want. */ 4516 success = comp_template_args (TREE_PURPOSE (found), arglist); 4517 4518 /* Restore the argument vectors to their full size. */ 4519 TREE_VEC_LENGTH (arglist)++; 4520 TREE_VEC_LENGTH (TREE_PURPOSE (found))++; 4521 4522 if (success) 4523 { 4524 found = tmpl; 4525 break; 4526 } 4527 } 4528 4529 if (!found) 4530 { 4531 /* There was no partial instantiation. This happens 4532 where C<T> is a member template of A<T> and it's used 4533 in something like 4534 4535 template <typename T> struct B { A<T>::C<int> m; }; 4536 B<float>; 4537 4538 Create the partial instantiation. 4539 */ 4540 TREE_VEC_LENGTH (arglist)--; 4541 found = tsubst (template, arglist, complain, NULL_TREE); 4542 TREE_VEC_LENGTH (arglist)++; 4543 } 4544 } 4545 4546 SET_TYPE_TEMPLATE_INFO (t, tree_cons (found, arglist, NULL_TREE)); 4547 DECL_TEMPLATE_INSTANTIATIONS (template) 4548 = tree_cons (arglist, t, 4549 DECL_TEMPLATE_INSTANTIATIONS (template)); 4550 4551 if (TREE_CODE (t) == ENUMERAL_TYPE 4552 && !is_partial_instantiation) 4553 /* Now that the type has been registered on the instantiations 4554 list, we set up the enumerators. Because the enumeration 4555 constants may involve the enumeration type itself, we make 4556 sure to register the type first, and then create the 4557 constants. That way, doing tsubst_expr for the enumeration 4558 constants won't result in recursive calls here; we'll find 4559 the instantiation and exit above. */ 4560 tsubst_enum (template_type, t, arglist); 4561 4562 /* Reset the name of the type, now that CLASSTYPE_TEMPLATE_INFO 4563 is set up. */ 4564 if (TREE_CODE (t) != ENUMERAL_TYPE) 4565 DECL_NAME (type_decl) = classtype_mangled_name (t); 4566 if (is_partial_instantiation) 4567 /* If the type makes use of template parameters, the 4568 code that generates debugging information will crash. */ 4569 DECL_IGNORED_P (TYPE_STUB_DECL (t)) = 1; 4570 4571 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t); 4572 } 4573 timevar_pop (TV_NAME_LOOKUP); 4574} 4575 4576struct pair_fn_data 4577{ 4578 tree_fn_t fn; 4579 void *data; 4580 htab_t visited; 4581}; 4582 4583/* Called from for_each_template_parm via walk_tree. */ 4584 4585static tree 4586for_each_template_parm_r (tree* tp, int* walk_subtrees, void* d) 4587{ 4588 tree t = *tp; 4589 struct pair_fn_data *pfd = (struct pair_fn_data *) d; 4590 tree_fn_t fn = pfd->fn; 4591 void *data = pfd->data; 4592 4593 if (TYPE_P (t) 4594 && for_each_template_parm (TYPE_CONTEXT (t), fn, data, pfd->visited)) 4595 return error_mark_node; 4596 4597 switch (TREE_CODE (t)) 4598 { 4599 case RECORD_TYPE: 4600 if (TYPE_PTRMEMFUNC_P (t)) 4601 break; 4602 /* Fall through. */ 4603 4604 case UNION_TYPE: 4605 case ENUMERAL_TYPE: 4606 if (!TYPE_TEMPLATE_INFO (t)) 4607 *walk_subtrees = 0; 4608 else if (for_each_template_parm (TREE_VALUE (TYPE_TEMPLATE_INFO (t)), 4609 fn, data, pfd->visited)) 4610 return error_mark_node; 4611 break; 4612 4613 case METHOD_TYPE: 4614 /* Since we're not going to walk subtrees, we have to do this 4615 explicitly here. */ 4616 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t), fn, data, 4617 pfd->visited)) 4618 return error_mark_node; 4619 /* Fall through. */ 4620 4621 case FUNCTION_TYPE: 4622 /* Check the return type. */ 4623 if (for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited)) 4624 return error_mark_node; 4625 4626 /* Check the parameter types. Since default arguments are not 4627 instantiated until they are needed, the TYPE_ARG_TYPES may 4628 contain expressions that involve template parameters. But, 4629 no-one should be looking at them yet. And, once they're 4630 instantiated, they don't contain template parameters, so 4631 there's no point in looking at them then, either. */ 4632 { 4633 tree parm; 4634 4635 for (parm = TYPE_ARG_TYPES (t); parm; parm = TREE_CHAIN (parm)) 4636 if (for_each_template_parm (TREE_VALUE (parm), fn, data, 4637 pfd->visited)) 4638 return error_mark_node; 4639 4640 /* Since we've already handled the TYPE_ARG_TYPES, we don't 4641 want walk_tree walking into them itself. */ 4642 *walk_subtrees = 0; 4643 } 4644 break; 4645 4646 case TYPEOF_TYPE: 4647 if (for_each_template_parm (TYPE_FIELDS (t), fn, data, 4648 pfd->visited)) 4649 return error_mark_node; 4650 break; 4651 4652 case FUNCTION_DECL: 4653 case VAR_DECL: 4654 if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t) 4655 && for_each_template_parm (DECL_TI_ARGS (t), fn, data, 4656 pfd->visited)) 4657 return error_mark_node; 4658 /* Fall through. */ 4659 4660 case PARM_DECL: 4661 case CONST_DECL: 4662 if (TREE_CODE (t) == CONST_DECL && DECL_TEMPLATE_PARM_P (t) 4663 && for_each_template_parm (DECL_INITIAL (t), fn, data, 4664 pfd->visited)) 4665 return error_mark_node; 4666 if (DECL_CONTEXT (t) 4667 && for_each_template_parm (DECL_CONTEXT (t), fn, data, 4668 pfd->visited)) 4669 return error_mark_node; 4670 break; 4671 4672 case BOUND_TEMPLATE_TEMPLATE_PARM: 4673 /* Record template parameters such as `T' inside `TT<T>'. */ 4674 if (for_each_template_parm (TYPE_TI_ARGS (t), fn, data, pfd->visited)) 4675 return error_mark_node; 4676 /* Fall through. */ 4677 4678 case TEMPLATE_TEMPLATE_PARM: 4679 case TEMPLATE_TYPE_PARM: 4680 case TEMPLATE_PARM_INDEX: 4681 if (fn && (*fn)(t, data)) 4682 return error_mark_node; 4683 else if (!fn) 4684 return error_mark_node; 4685 break; 4686 4687 case TEMPLATE_DECL: 4688 /* A template template parameter is encountered. */ 4689 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t) 4690 && for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited)) 4691 return error_mark_node; 4692 4693 /* Already substituted template template parameter */ 4694 *walk_subtrees = 0; 4695 break; 4696 4697 case TYPENAME_TYPE: 4698 if (!fn 4699 || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t), fn, 4700 data, pfd->visited)) 4701 return error_mark_node; 4702 break; 4703 4704 case CONSTRUCTOR: 4705 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)) 4706 && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE 4707 (TREE_TYPE (t)), fn, data, 4708 pfd->visited)) 4709 return error_mark_node; 4710 break; 4711 4712 case INDIRECT_REF: 4713 case COMPONENT_REF: 4714 /* If there's no type, then this thing must be some expression 4715 involving template parameters. */ 4716 if (!fn && !TREE_TYPE (t)) 4717 return error_mark_node; 4718 break; 4719 4720 case MODOP_EXPR: 4721 case CAST_EXPR: 4722 case REINTERPRET_CAST_EXPR: 4723 case CONST_CAST_EXPR: 4724 case STATIC_CAST_EXPR: 4725 case DYNAMIC_CAST_EXPR: 4726 case ARROW_EXPR: 4727 case DOTSTAR_EXPR: 4728 case TYPEID_EXPR: 4729 case PSEUDO_DTOR_EXPR: 4730 if (!fn) 4731 return error_mark_node; 4732 break; 4733 4734 case BASELINK: 4735 /* If we do not handle this case specially, we end up walking 4736 the BINFO hierarchy, which is circular, and therefore 4737 confuses walk_tree. */ 4738 *walk_subtrees = 0; 4739 if (for_each_template_parm (BASELINK_FUNCTIONS (*tp), fn, data, 4740 pfd->visited)) 4741 return error_mark_node; 4742 break; 4743 4744 default: 4745 break; 4746 } 4747 4748 /* We didn't find any template parameters we liked. */ 4749 return NULL_TREE; 4750} 4751 4752/* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM, 4753 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T, 4754 call FN with the parameter and the DATA. 4755 If FN returns nonzero, the iteration is terminated, and 4756 for_each_template_parm returns 1. Otherwise, the iteration 4757 continues. If FN never returns a nonzero value, the value 4758 returned by for_each_template_parm is 0. If FN is NULL, it is 4759 considered to be the function which always returns 1. */ 4760 4761static int 4762for_each_template_parm (tree t, tree_fn_t fn, void* data, htab_t visited) 4763{ 4764 struct pair_fn_data pfd; 4765 int result; 4766 4767 /* Set up. */ 4768 pfd.fn = fn; 4769 pfd.data = data; 4770 4771 /* Walk the tree. (Conceptually, we would like to walk without 4772 duplicates, but for_each_template_parm_r recursively calls 4773 for_each_template_parm, so we would need to reorganize a fair 4774 bit to use walk_tree_without_duplicates, so we keep our own 4775 visited list.) */ 4776 if (visited) 4777 pfd.visited = visited; 4778 else 4779 pfd.visited = htab_create (37, htab_hash_pointer, htab_eq_pointer, 4780 NULL); 4781 result = walk_tree (&t, 4782 for_each_template_parm_r, 4783 &pfd, 4784 pfd.visited) != NULL_TREE; 4785 4786 /* Clean up. */ 4787 if (!visited) 4788 htab_delete (pfd.visited); 4789 4790 return result; 4791} 4792 4793/* Returns true if T depends on any template parameter. */ 4794 4795int 4796uses_template_parms (tree t) 4797{ 4798 bool dependent_p; 4799 int saved_processing_template_decl; 4800 4801 saved_processing_template_decl = processing_template_decl; 4802 if (!saved_processing_template_decl) 4803 processing_template_decl = 1; 4804 if (TYPE_P (t)) 4805 dependent_p = dependent_type_p (t); 4806 else if (TREE_CODE (t) == TREE_VEC) 4807 dependent_p = any_dependent_template_arguments_p (t); 4808 else if (TREE_CODE (t) == TREE_LIST) 4809 dependent_p = (uses_template_parms (TREE_VALUE (t)) 4810 || uses_template_parms (TREE_CHAIN (t))); 4811 else if (TREE_CODE (t) == TYPE_DECL) 4812 dependent_p = dependent_type_p (TREE_TYPE (t)); 4813 else if (DECL_P (t) 4814 || EXPR_P (t) 4815 || TREE_CODE (t) == TEMPLATE_PARM_INDEX 4816 || TREE_CODE (t) == OVERLOAD 4817 || TREE_CODE (t) == BASELINK 4818 || TREE_CODE (t) == IDENTIFIER_NODE 4819 || TREE_CODE_CLASS (TREE_CODE (t)) == 'c') 4820 dependent_p = (type_dependent_expression_p (t) 4821 || value_dependent_expression_p (t)); 4822 else if (t == error_mark_node) 4823 dependent_p = false; 4824 else 4825 abort (); 4826 processing_template_decl = saved_processing_template_decl; 4827 4828 return dependent_p; 4829} 4830 4831/* Returns true if T depends on any template parameter with level LEVEL. */ 4832 4833int 4834uses_template_parms_level (tree t, int level) 4835{ 4836 return for_each_template_parm (t, template_parm_this_level_p, &level, NULL); 4837} 4838 4839static int tinst_depth; 4840extern int max_tinst_depth; 4841#ifdef GATHER_STATISTICS 4842int depth_reached; 4843#endif 4844static int tinst_level_tick; 4845static int last_template_error_tick; 4846 4847/* We're starting to instantiate D; record the template instantiation context 4848 for diagnostics and to restore it later. */ 4849 4850int 4851push_tinst_level (tree d) 4852{ 4853 tree new; 4854 4855 if (tinst_depth >= max_tinst_depth) 4856 { 4857 /* If the instantiation in question still has unbound template parms, 4858 we don't really care if we can't instantiate it, so just return. 4859 This happens with base instantiation for implicit `typename'. */ 4860 if (uses_template_parms (d)) 4861 return 0; 4862 4863 last_template_error_tick = tinst_level_tick; 4864 error ("template instantiation depth exceeds maximum of %d (use -ftemplate-depth-NN to increase the maximum) instantiating `%D'", 4865 max_tinst_depth, d); 4866 4867 print_instantiation_context (); 4868 4869 return 0; 4870 } 4871 4872 new = build_expr_wfl (d, input_filename, input_line, 0); 4873 TREE_CHAIN (new) = current_tinst_level; 4874 current_tinst_level = new; 4875 4876 ++tinst_depth; 4877#ifdef GATHER_STATISTICS 4878 if (tinst_depth > depth_reached) 4879 depth_reached = tinst_depth; 4880#endif 4881 4882 ++tinst_level_tick; 4883 return 1; 4884} 4885 4886/* We're done instantiating this template; return to the instantiation 4887 context. */ 4888 4889void 4890pop_tinst_level (void) 4891{ 4892 tree old = current_tinst_level; 4893 4894 /* Restore the filename and line number stashed away when we started 4895 this instantiation. */ 4896 input_line = TINST_LINE (old); 4897 input_filename = TINST_FILE (old); 4898 extract_interface_info (); 4899 4900 current_tinst_level = TREE_CHAIN (old); 4901 --tinst_depth; 4902 ++tinst_level_tick; 4903} 4904 4905/* We're instantiating a deferred template; restore the template 4906 instantiation context in which the instantiation was requested, which 4907 is one step out from LEVEL. */ 4908 4909static void 4910reopen_tinst_level (tree level) 4911{ 4912 tree t; 4913 4914 tinst_depth = 0; 4915 for (t = level; t; t = TREE_CHAIN (t)) 4916 ++tinst_depth; 4917 4918 current_tinst_level = level; 4919 pop_tinst_level (); 4920} 4921 4922/* Return the outermost template instantiation context, for use with 4923 -falt-external-templates. */ 4924 4925tree 4926tinst_for_decl (void) 4927{ 4928 tree p = current_tinst_level; 4929 4930 if (p) 4931 for (; TREE_CHAIN (p) ; p = TREE_CHAIN (p)) 4932 ; 4933 return p; 4934} 4935 4936/* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the 4937 vector of template arguments, as for tsubst. 4938 4939 Returns an appropriate tsubst'd friend declaration. */ 4940 4941static tree 4942tsubst_friend_function (tree decl, tree args) 4943{ 4944 tree new_friend; 4945 location_t saved_loc = input_location; 4946 4947 input_location = DECL_SOURCE_LOCATION (decl); 4948 4949 if (TREE_CODE (decl) == FUNCTION_DECL 4950 && DECL_TEMPLATE_INSTANTIATION (decl) 4951 && TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL) 4952 /* This was a friend declared with an explicit template 4953 argument list, e.g.: 4954 4955 friend void f<>(T); 4956 4957 to indicate that f was a template instantiation, not a new 4958 function declaration. Now, we have to figure out what 4959 instantiation of what template. */ 4960 { 4961 tree template_id, arglist, fns; 4962 tree new_args; 4963 tree tmpl; 4964 tree ns = decl_namespace_context (TYPE_MAIN_DECL (current_class_type)); 4965 4966 /* Friend functions are looked up in the containing namespace scope. 4967 We must enter that scope, to avoid finding member functions of the 4968 current cless with same name. */ 4969 push_nested_namespace (ns); 4970 fns = tsubst_expr (DECL_TI_TEMPLATE (decl), args, 4971 tf_error | tf_warning, NULL_TREE); 4972 pop_nested_namespace (ns); 4973 arglist = tsubst (DECL_TI_ARGS (decl), args, 4974 tf_error | tf_warning, NULL_TREE); 4975 template_id = lookup_template_function (fns, arglist); 4976 4977 new_friend = tsubst (decl, args, tf_error | tf_warning, NULL_TREE); 4978 tmpl = determine_specialization (template_id, new_friend, 4979 &new_args, 4980 /*need_member_template=*/0); 4981 new_friend = instantiate_template (tmpl, new_args, tf_error); 4982 goto done; 4983 } 4984 4985 new_friend = tsubst (decl, args, tf_error | tf_warning, NULL_TREE); 4986 4987 /* The NEW_FRIEND will look like an instantiation, to the 4988 compiler, but is not an instantiation from the point of view of 4989 the language. For example, we might have had: 4990 4991 template <class T> struct S { 4992 template <class U> friend void f(T, U); 4993 }; 4994 4995 Then, in S<int>, template <class U> void f(int, U) is not an 4996 instantiation of anything. */ 4997 if (new_friend == error_mark_node) 4998 return error_mark_node; 4999 5000 DECL_USE_TEMPLATE (new_friend) = 0; 5001 if (TREE_CODE (decl) == TEMPLATE_DECL) 5002 { 5003 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend)) = 0; 5004 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend)) 5005 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl)); 5006 } 5007 5008 /* The mangled name for the NEW_FRIEND is incorrect. The function 5009 is not a template instantiation and should not be mangled like 5010 one. Therefore, we forget the mangling here; we'll recompute it 5011 later if we need it. */ 5012 if (TREE_CODE (new_friend) != TEMPLATE_DECL) 5013 { 5014 SET_DECL_RTL (new_friend, NULL_RTX); 5015 SET_DECL_ASSEMBLER_NAME (new_friend, NULL_TREE); 5016 } 5017 5018 if (DECL_NAMESPACE_SCOPE_P (new_friend)) 5019 { 5020 tree old_decl; 5021 tree new_friend_template_info; 5022 tree new_friend_result_template_info; 5023 tree ns; 5024 int new_friend_is_defn; 5025 5026 /* We must save some information from NEW_FRIEND before calling 5027 duplicate decls since that function will free NEW_FRIEND if 5028 possible. */ 5029 new_friend_template_info = DECL_TEMPLATE_INFO (new_friend); 5030 new_friend_is_defn = 5031 (DECL_INITIAL (DECL_TEMPLATE_RESULT 5032 (template_for_substitution (new_friend))) 5033 != NULL_TREE); 5034 if (TREE_CODE (new_friend) == TEMPLATE_DECL) 5035 { 5036 /* This declaration is a `primary' template. */ 5037 DECL_PRIMARY_TEMPLATE (new_friend) = new_friend; 5038 5039 new_friend_result_template_info 5040 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend)); 5041 } 5042 else 5043 new_friend_result_template_info = NULL_TREE; 5044 5045 /* Inside pushdecl_namespace_level, we will push into the 5046 current namespace. However, the friend function should go 5047 into the namespace of the template. */ 5048 ns = decl_namespace_context (new_friend); 5049 push_nested_namespace (ns); 5050 old_decl = pushdecl_namespace_level (new_friend); 5051 pop_nested_namespace (ns); 5052 5053 if (old_decl != new_friend) 5054 { 5055 /* This new friend declaration matched an existing 5056 declaration. For example, given: 5057 5058 template <class T> void f(T); 5059 template <class U> class C { 5060 template <class T> friend void f(T) {} 5061 }; 5062 5063 the friend declaration actually provides the definition 5064 of `f', once C has been instantiated for some type. So, 5065 old_decl will be the out-of-class template declaration, 5066 while new_friend is the in-class definition. 5067 5068 But, if `f' was called before this point, the 5069 instantiation of `f' will have DECL_TI_ARGS corresponding 5070 to `T' but not to `U', references to which might appear 5071 in the definition of `f'. Previously, the most general 5072 template for an instantiation of `f' was the out-of-class 5073 version; now it is the in-class version. Therefore, we 5074 run through all specialization of `f', adding to their 5075 DECL_TI_ARGS appropriately. In particular, they need a 5076 new set of outer arguments, corresponding to the 5077 arguments for this class instantiation. 5078 5079 The same situation can arise with something like this: 5080 5081 friend void f(int); 5082 template <class T> class C { 5083 friend void f(T) {} 5084 }; 5085 5086 when `C<int>' is instantiated. Now, `f(int)' is defined 5087 in the class. */ 5088 5089 if (!new_friend_is_defn) 5090 /* On the other hand, if the in-class declaration does 5091 *not* provide a definition, then we don't want to alter 5092 existing definitions. We can just leave everything 5093 alone. */ 5094 ; 5095 else 5096 { 5097 /* Overwrite whatever template info was there before, if 5098 any, with the new template information pertaining to 5099 the declaration. */ 5100 DECL_TEMPLATE_INFO (old_decl) = new_friend_template_info; 5101 5102 if (TREE_CODE (old_decl) != TEMPLATE_DECL) 5103 reregister_specialization (new_friend, 5104 most_general_template (old_decl), 5105 old_decl); 5106 else 5107 { 5108 tree t; 5109 tree new_friend_args; 5110 5111 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl)) 5112 = new_friend_result_template_info; 5113 5114 new_friend_args = TI_ARGS (new_friend_template_info); 5115 for (t = DECL_TEMPLATE_SPECIALIZATIONS (old_decl); 5116 t != NULL_TREE; 5117 t = TREE_CHAIN (t)) 5118 { 5119 tree spec = TREE_VALUE (t); 5120 5121 DECL_TI_ARGS (spec) 5122 = add_outermost_template_args (new_friend_args, 5123 DECL_TI_ARGS (spec)); 5124 } 5125 5126 /* Now, since specializations are always supposed to 5127 hang off of the most general template, we must move 5128 them. */ 5129 t = most_general_template (old_decl); 5130 if (t != old_decl) 5131 { 5132 DECL_TEMPLATE_SPECIALIZATIONS (t) 5133 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (t), 5134 DECL_TEMPLATE_SPECIALIZATIONS (old_decl)); 5135 DECL_TEMPLATE_SPECIALIZATIONS (old_decl) = NULL_TREE; 5136 } 5137 } 5138 } 5139 5140 /* The information from NEW_FRIEND has been merged into OLD_DECL 5141 by duplicate_decls. */ 5142 new_friend = old_decl; 5143 } 5144 } 5145 else if (COMPLETE_TYPE_P (DECL_CONTEXT (new_friend))) 5146 { 5147 /* Check to see that the declaration is really present, and, 5148 possibly obtain an improved declaration. */ 5149 tree fn = check_classfn (DECL_CONTEXT (new_friend), 5150 new_friend, false); 5151 5152 if (fn) 5153 new_friend = fn; 5154 } 5155 5156 done: 5157 input_location = saved_loc; 5158 return new_friend; 5159} 5160 5161/* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of 5162 template arguments, as for tsubst. 5163 5164 Returns an appropriate tsubst'd friend type or error_mark_node on 5165 failure. */ 5166 5167static tree 5168tsubst_friend_class (tree friend_tmpl, tree args) 5169{ 5170 tree friend_type; 5171 tree tmpl; 5172 tree context; 5173 5174 context = DECL_CONTEXT (friend_tmpl); 5175 5176 if (context) 5177 { 5178 if (TREE_CODE (context) == NAMESPACE_DECL) 5179 push_nested_namespace (context); 5180 else 5181 push_nested_class (tsubst (context, args, tf_none, NULL_TREE)); 5182 } 5183 5184 /* First, we look for a class template. */ 5185 tmpl = lookup_name (DECL_NAME (friend_tmpl), /*prefer_type=*/0); 5186 5187 /* But, if we don't find one, it might be because we're in a 5188 situation like this: 5189 5190 template <class T> 5191 struct S { 5192 template <class U> 5193 friend struct S; 5194 }; 5195 5196 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL 5197 for `S<int>', not the TEMPLATE_DECL. */ 5198 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl)) 5199 { 5200 tmpl = lookup_name (DECL_NAME (friend_tmpl), /*prefer_type=*/1); 5201 tmpl = maybe_get_template_decl_from_type_decl (tmpl); 5202 } 5203 5204 if (tmpl && DECL_CLASS_TEMPLATE_P (tmpl)) 5205 { 5206 /* The friend template has already been declared. Just 5207 check to see that the declarations match, and install any new 5208 default parameters. We must tsubst the default parameters, 5209 of course. We only need the innermost template parameters 5210 because that is all that redeclare_class_template will look 5211 at. */ 5212 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl)) 5213 > TMPL_ARGS_DEPTH (args)) 5214 { 5215 tree parms; 5216 parms = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl), 5217 args, tf_error | tf_warning); 5218 redeclare_class_template (TREE_TYPE (tmpl), parms); 5219 } 5220 5221 friend_type = TREE_TYPE (tmpl); 5222 } 5223 else 5224 { 5225 /* The friend template has not already been declared. In this 5226 case, the instantiation of the template class will cause the 5227 injection of this template into the global scope. */ 5228 tmpl = tsubst (friend_tmpl, args, tf_error | tf_warning, NULL_TREE); 5229 5230 /* The new TMPL is not an instantiation of anything, so we 5231 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for 5232 the new type because that is supposed to be the corresponding 5233 template decl, i.e., TMPL. */ 5234 DECL_USE_TEMPLATE (tmpl) = 0; 5235 DECL_TEMPLATE_INFO (tmpl) = NULL_TREE; 5236 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl)) = 0; 5237 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl)) 5238 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl))); 5239 5240 /* Inject this template into the global scope. */ 5241 friend_type = TREE_TYPE (pushdecl_top_level (tmpl)); 5242 } 5243 5244 if (context) 5245 { 5246 if (TREE_CODE (context) == NAMESPACE_DECL) 5247 pop_nested_namespace (context); 5248 else 5249 pop_nested_class (); 5250 } 5251 5252 return friend_type; 5253} 5254 5255/* Returns zero if TYPE cannot be completed later due to circularity. 5256 Otherwise returns one. */ 5257 5258static int 5259can_complete_type_without_circularity (tree type) 5260{ 5261 if (type == NULL_TREE || type == error_mark_node) 5262 return 0; 5263 else if (COMPLETE_TYPE_P (type)) 5264 return 1; 5265 else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type)) 5266 return can_complete_type_without_circularity (TREE_TYPE (type)); 5267 else if (CLASS_TYPE_P (type) 5268 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type))) 5269 return 0; 5270 else 5271 return 1; 5272} 5273 5274tree 5275instantiate_class_template (tree type) 5276{ 5277 tree template, args, pattern, t, member; 5278 tree typedecl; 5279 tree pbinfo; 5280 5281 if (type == error_mark_node) 5282 return error_mark_node; 5283 5284 if (TYPE_BEING_DEFINED (type) 5285 || COMPLETE_TYPE_P (type) 5286 || dependent_type_p (type)) 5287 return type; 5288 5289 /* Figure out which template is being instantiated. */ 5290 template = most_general_template (CLASSTYPE_TI_TEMPLATE (type)); 5291 my_friendly_assert (TREE_CODE (template) == TEMPLATE_DECL, 279); 5292 5293 /* Figure out which arguments are being used to do the 5294 instantiation. */ 5295 args = CLASSTYPE_TI_ARGS (type); 5296 5297 /* Determine what specialization of the original template to 5298 instantiate. */ 5299 t = most_specialized_class (template, args); 5300 if (t == error_mark_node) 5301 { 5302 const char *str = "candidates are:"; 5303 error ("ambiguous class template instantiation for `%#T'", type); 5304 for (t = DECL_TEMPLATE_SPECIALIZATIONS (template); t; 5305 t = TREE_CHAIN (t)) 5306 { 5307 if (get_class_bindings (TREE_VALUE (t), TREE_PURPOSE (t), args)) 5308 { 5309 cp_error_at ("%s %+#T", str, TREE_TYPE (t)); 5310 str = " "; 5311 } 5312 } 5313 TYPE_BEING_DEFINED (type) = 1; 5314 return error_mark_node; 5315 } 5316 5317 if (t) 5318 pattern = TREE_TYPE (t); 5319 else 5320 pattern = TREE_TYPE (template); 5321 5322 /* If the template we're instantiating is incomplete, then clearly 5323 there's nothing we can do. */ 5324 if (!COMPLETE_TYPE_P (pattern)) 5325 return type; 5326 5327 /* If we've recursively instantiated too many templates, stop. */ 5328 if (! push_tinst_level (type)) 5329 return type; 5330 5331 /* Now we're really doing the instantiation. Mark the type as in 5332 the process of being defined. */ 5333 TYPE_BEING_DEFINED (type) = 1; 5334 5335 /* We may be in the middle of deferred access check. Disable 5336 it now. */ 5337 push_deferring_access_checks (dk_no_deferred); 5338 5339 push_to_top_level (); 5340 5341 if (t) 5342 { 5343 /* This TYPE is actually an instantiation of a partial 5344 specialization. We replace the innermost set of ARGS with 5345 the arguments appropriate for substitution. For example, 5346 given: 5347 5348 template <class T> struct S {}; 5349 template <class T> struct S<T*> {}; 5350 5351 and supposing that we are instantiating S<int*>, ARGS will 5352 present be {int*} but we need {int}. */ 5353 tree inner_args 5354 = get_class_bindings (TREE_VALUE (t), TREE_PURPOSE (t), 5355 args); 5356 5357 /* If there were multiple levels in ARGS, replacing the 5358 innermost level would alter CLASSTYPE_TI_ARGS, which we don't 5359 want, so we make a copy first. */ 5360 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args)) 5361 { 5362 args = copy_node (args); 5363 SET_TMPL_ARGS_LEVEL (args, TMPL_ARGS_DEPTH (args), inner_args); 5364 } 5365 else 5366 args = inner_args; 5367 } 5368 5369 SET_CLASSTYPE_INTERFACE_UNKNOWN (type); 5370 5371 /* Set the input location to the template definition. This is needed 5372 if tsubsting causes an error. */ 5373 input_location = DECL_SOURCE_LOCATION (TYPE_NAME (pattern)); 5374 5375 TYPE_HAS_CONSTRUCTOR (type) = TYPE_HAS_CONSTRUCTOR (pattern); 5376 TYPE_HAS_DESTRUCTOR (type) = TYPE_HAS_DESTRUCTOR (pattern); 5377 TYPE_HAS_NEW_OPERATOR (type) = TYPE_HAS_NEW_OPERATOR (pattern); 5378 TYPE_HAS_ARRAY_NEW_OPERATOR (type) = TYPE_HAS_ARRAY_NEW_OPERATOR (pattern); 5379 TYPE_GETS_DELETE (type) = TYPE_GETS_DELETE (pattern); 5380 TYPE_HAS_ASSIGN_REF (type) = TYPE_HAS_ASSIGN_REF (pattern); 5381 TYPE_HAS_CONST_ASSIGN_REF (type) = TYPE_HAS_CONST_ASSIGN_REF (pattern); 5382 TYPE_HAS_ABSTRACT_ASSIGN_REF (type) = TYPE_HAS_ABSTRACT_ASSIGN_REF (pattern); 5383 TYPE_HAS_INIT_REF (type) = TYPE_HAS_INIT_REF (pattern); 5384 TYPE_HAS_CONST_INIT_REF (type) = TYPE_HAS_CONST_INIT_REF (pattern); 5385 TYPE_HAS_DEFAULT_CONSTRUCTOR (type) = TYPE_HAS_DEFAULT_CONSTRUCTOR (pattern); 5386 TYPE_HAS_CONVERSION (type) = TYPE_HAS_CONVERSION (pattern); 5387 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (type) 5388 = TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (pattern); 5389 TYPE_USES_MULTIPLE_INHERITANCE (type) 5390 = TYPE_USES_MULTIPLE_INHERITANCE (pattern); 5391 TYPE_USES_VIRTUAL_BASECLASSES (type) 5392 = TYPE_USES_VIRTUAL_BASECLASSES (pattern); 5393 TYPE_PACKED (type) = TYPE_PACKED (pattern); 5394 TYPE_ALIGN (type) = TYPE_ALIGN (pattern); 5395 TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (pattern); 5396 TYPE_FOR_JAVA (type) = TYPE_FOR_JAVA (pattern); /* For libjava's JArray<T> */ 5397 if (ANON_AGGR_TYPE_P (pattern)) 5398 SET_ANON_AGGR_TYPE_P (type); 5399 5400 pbinfo = TYPE_BINFO (pattern); 5401 5402#ifdef ENABLE_CHECKING 5403 if (DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern)) 5404 && ! COMPLETE_TYPE_P (TYPE_CONTEXT (type)) 5405 && ! TYPE_BEING_DEFINED (TYPE_CONTEXT (type))) 5406 /* We should never instantiate a nested class before its enclosing 5407 class; we need to look up the nested class by name before we can 5408 instantiate it, and that lookup should instantiate the enclosing 5409 class. */ 5410 abort (); 5411#endif 5412 5413 if (BINFO_BASETYPES (pbinfo)) 5414 { 5415 tree base_list = NULL_TREE; 5416 tree pbases = BINFO_BASETYPES (pbinfo); 5417 tree paccesses = BINFO_BASEACCESSES (pbinfo); 5418 tree context = TYPE_CONTEXT (type); 5419 bool pop_p; 5420 int i; 5421 5422 /* We must enter the scope containing the type, as that is where 5423 the accessibility of types named in dependent bases are 5424 looked up from. */ 5425 pop_p = push_scope (context ? context : global_namespace); 5426 5427 /* Substitute into each of the bases to determine the actual 5428 basetypes. */ 5429 for (i = 0; i < TREE_VEC_LENGTH (pbases); ++i) 5430 { 5431 tree base; 5432 tree access; 5433 tree pbase; 5434 5435 pbase = TREE_VEC_ELT (pbases, i); 5436 access = TREE_VEC_ELT (paccesses, i); 5437 5438 /* Substitute to figure out the base class. */ 5439 base = tsubst (BINFO_TYPE (pbase), args, tf_error, NULL_TREE); 5440 if (base == error_mark_node) 5441 continue; 5442 5443 base_list = tree_cons (access, base, base_list); 5444 TREE_VIA_VIRTUAL (base_list) = TREE_VIA_VIRTUAL (pbase); 5445 } 5446 5447 /* The list is now in reverse order; correct that. */ 5448 base_list = nreverse (base_list); 5449 5450 /* Now call xref_basetypes to set up all the base-class 5451 information. */ 5452 xref_basetypes (type, base_list); 5453 5454 if (pop_p) 5455 pop_scope (context ? context : global_namespace); 5456 } 5457 5458 /* Now that our base classes are set up, enter the scope of the 5459 class, so that name lookups into base classes, etc. will work 5460 correctly. This is precisely analogous to what we do in 5461 begin_class_definition when defining an ordinary non-template 5462 class. */ 5463 pushclass (type); 5464 5465 /* Now members are processed in the order of declaration. */ 5466 for (member = CLASSTYPE_DECL_LIST (pattern); 5467 member; member = TREE_CHAIN (member)) 5468 { 5469 tree t = TREE_VALUE (member); 5470 5471 if (TREE_PURPOSE (member)) 5472 { 5473 if (TYPE_P (t)) 5474 { 5475 /* Build new CLASSTYPE_NESTED_UTDS. */ 5476 5477 tree tag = t; 5478 tree name = TYPE_IDENTIFIER (tag); 5479 tree newtag; 5480 bool class_template_p; 5481 5482 class_template_p = (TREE_CODE (tag) != ENUMERAL_TYPE 5483 && TYPE_LANG_SPECIFIC (tag) 5484 && CLASSTYPE_IS_TEMPLATE (tag)); 5485 /* If the member is a class template, then -- even after 5486 substituition -- there may be dependent types in the 5487 template argument list for the class. We increment 5488 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as 5489 that function will assume that no types are dependent 5490 when outside of a template. */ 5491 if (class_template_p) 5492 ++processing_template_decl; 5493 newtag = tsubst (tag, args, tf_error, NULL_TREE); 5494 if (class_template_p) 5495 --processing_template_decl; 5496 if (newtag == error_mark_node) 5497 continue; 5498 5499 if (TREE_CODE (newtag) != ENUMERAL_TYPE) 5500 { 5501 if (class_template_p) 5502 /* Unfortunately, lookup_template_class sets 5503 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial 5504 instantiation (i.e., for the type of a member 5505 template class nested within a template class.) 5506 This behavior is required for 5507 maybe_process_partial_specialization to work 5508 correctly, but is not accurate in this case; 5509 the TAG is not an instantiation of anything. 5510 (The corresponding TEMPLATE_DECL is an 5511 instantiation, but the TYPE is not.) */ 5512 CLASSTYPE_USE_TEMPLATE (newtag) = 0; 5513 5514 /* Now, we call pushtag to put this NEWTAG into the scope of 5515 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid 5516 pushtag calling push_template_decl. We don't have to do 5517 this for enums because it will already have been done in 5518 tsubst_enum. */ 5519 if (name) 5520 SET_IDENTIFIER_TYPE_VALUE (name, newtag); 5521 pushtag (name, newtag, /*globalize=*/0); 5522 } 5523 } 5524 else if (TREE_CODE (t) == FUNCTION_DECL 5525 || DECL_FUNCTION_TEMPLATE_P (t)) 5526 { 5527 /* Build new TYPE_METHODS. */ 5528 tree r; 5529 5530 if (TREE_CODE (t) == TEMPLATE_DECL) 5531 ++processing_template_decl; 5532 r = tsubst (t, args, tf_error, NULL_TREE); 5533 if (TREE_CODE (t) == TEMPLATE_DECL) 5534 --processing_template_decl; 5535 set_current_access_from_decl (r); 5536 grok_special_member_properties (r); 5537 finish_member_declaration (r); 5538 } 5539 else 5540 { 5541 /* Build new TYPE_FIELDS. */ 5542 5543 if (TREE_CODE (t) != CONST_DECL) 5544 { 5545 tree r; 5546 5547 /* The the file and line for this declaration, to 5548 assist in error message reporting. Since we 5549 called push_tinst_level above, we don't need to 5550 restore these. */ 5551 input_location = DECL_SOURCE_LOCATION (t); 5552 5553 if (TREE_CODE (t) == TEMPLATE_DECL) 5554 ++processing_template_decl; 5555 r = tsubst (t, args, tf_error | tf_warning, NULL_TREE); 5556 if (TREE_CODE (t) == TEMPLATE_DECL) 5557 --processing_template_decl; 5558 if (TREE_CODE (r) == VAR_DECL) 5559 { 5560 tree init; 5561 5562 if (DECL_INITIALIZED_IN_CLASS_P (r)) 5563 init = tsubst_expr (DECL_INITIAL (t), args, 5564 tf_error | tf_warning, NULL_TREE); 5565 else 5566 init = NULL_TREE; 5567 5568 finish_static_data_member_decl 5569 (r, init, /*asmspec_tree=*/NULL_TREE, /*flags=*/0); 5570 5571 if (DECL_INITIALIZED_IN_CLASS_P (r)) 5572 check_static_variable_definition (r, TREE_TYPE (r)); 5573 } 5574 else if (TREE_CODE (r) == FIELD_DECL) 5575 { 5576 /* Determine whether R has a valid type and can be 5577 completed later. If R is invalid, then it is 5578 replaced by error_mark_node so that it will not be 5579 added to TYPE_FIELDS. */ 5580 tree rtype = TREE_TYPE (r); 5581 if (can_complete_type_without_circularity (rtype)) 5582 complete_type (rtype); 5583 5584 if (!COMPLETE_TYPE_P (rtype)) 5585 { 5586 cxx_incomplete_type_error (r, rtype); 5587 r = error_mark_node; 5588 } 5589 } 5590 5591 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE, 5592 such a thing will already have been added to the field 5593 list by tsubst_enum in finish_member_declaration in the 5594 CLASSTYPE_NESTED_UTDS case above. */ 5595 if (!(TREE_CODE (r) == TYPE_DECL 5596 && TREE_CODE (TREE_TYPE (r)) == ENUMERAL_TYPE 5597 && DECL_ARTIFICIAL (r))) 5598 { 5599 set_current_access_from_decl (r); 5600 finish_member_declaration (r); 5601 } 5602 } 5603 } 5604 } 5605 else 5606 { 5607 if (TYPE_P (t) || DECL_CLASS_TEMPLATE_P (t)) 5608 { 5609 /* Build new CLASSTYPE_FRIEND_CLASSES. */ 5610 5611 tree friend_type = t; 5612 tree new_friend_type; 5613 5614 if (TREE_CODE (friend_type) == TEMPLATE_DECL) 5615 new_friend_type = tsubst_friend_class (friend_type, args); 5616 else if (uses_template_parms (friend_type)) 5617 new_friend_type = tsubst (friend_type, args, 5618 tf_error | tf_warning, NULL_TREE); 5619 else if (CLASSTYPE_USE_TEMPLATE (friend_type)) 5620 new_friend_type = friend_type; 5621 else 5622 { 5623 tree ns = decl_namespace_context (TYPE_MAIN_DECL (friend_type)); 5624 5625 /* The call to xref_tag_from_type does injection for friend 5626 classes. */ 5627 push_nested_namespace (ns); 5628 new_friend_type = 5629 xref_tag_from_type (friend_type, NULL_TREE, 1); 5630 pop_nested_namespace (ns); 5631 } 5632 5633 if (TREE_CODE (friend_type) == TEMPLATE_DECL) 5634 /* Trick make_friend_class into realizing that the friend 5635 we're adding is a template, not an ordinary class. It's 5636 important that we use make_friend_class since it will 5637 perform some error-checking and output cross-reference 5638 information. */ 5639 ++processing_template_decl; 5640 5641 if (new_friend_type != error_mark_node) 5642 make_friend_class (type, new_friend_type, 5643 /*complain=*/false); 5644 5645 if (TREE_CODE (friend_type) == TEMPLATE_DECL) 5646 --processing_template_decl; 5647 } 5648 else 5649 { 5650 /* Build new DECL_FRIENDLIST. */ 5651 tree r; 5652 5653 if (TREE_CODE (t) == TEMPLATE_DECL) 5654 ++processing_template_decl; 5655 r = tsubst_friend_function (t, args); 5656 if (TREE_CODE (t) == TEMPLATE_DECL) 5657 --processing_template_decl; 5658 add_friend (type, r, /*complain=*/false); 5659 } 5660 } 5661 } 5662 5663 /* Set the file and line number information to whatever is given for 5664 the class itself. This puts error messages involving generated 5665 implicit functions at a predictable point, and the same point 5666 that would be used for non-template classes. */ 5667 typedecl = TYPE_MAIN_DECL (type); 5668 input_location = DECL_SOURCE_LOCATION (typedecl); 5669 5670 unreverse_member_declarations (type); 5671 finish_struct_1 (type); 5672 5673 /* Clear this now so repo_template_used is happy. */ 5674 TYPE_BEING_DEFINED (type) = 0; 5675 repo_template_used (type); 5676 5677 /* Now that the class is complete, instantiate default arguments for 5678 any member functions. We don't do this earlier because the 5679 default arguments may reference members of the class. */ 5680 if (!PRIMARY_TEMPLATE_P (template)) 5681 for (t = TYPE_METHODS (type); t; t = TREE_CHAIN (t)) 5682 if (TREE_CODE (t) == FUNCTION_DECL 5683 /* Implicitly generated member functions will not have template 5684 information; they are not instantiations, but instead are 5685 created "fresh" for each instantiation. */ 5686 && DECL_TEMPLATE_INFO (t)) 5687 tsubst_default_arguments (t); 5688 5689 popclass (); 5690 pop_from_top_level (); 5691 pop_deferring_access_checks (); 5692 pop_tinst_level (); 5693 5694 if (TYPE_CONTAINS_VPTR_P (type)) 5695 keyed_classes = tree_cons (NULL_TREE, type, keyed_classes); 5696 5697 return type; 5698} 5699 5700static tree 5701tsubst_template_arg (tree t, tree args, tsubst_flags_t complain, tree in_decl) 5702{ 5703 tree r; 5704 5705 if (!t) 5706 r = t; 5707 else if (TYPE_P (t)) 5708 r = tsubst (t, args, complain, in_decl); 5709 else 5710 { 5711 r = tsubst_expr (t, args, complain, in_decl); 5712 5713 if (!uses_template_parms (r)) 5714 { 5715 /* Sometimes, one of the args was an expression involving a 5716 template constant parameter, like N - 1. Now that we've 5717 tsubst'd, we might have something like 2 - 1. This will 5718 confuse lookup_template_class, so we do constant folding 5719 here. We have to unset processing_template_decl, to fool 5720 tsubst_copy_and_build() into building an actual tree. */ 5721 5722 /* If the TREE_TYPE of ARG is not NULL_TREE, ARG is already 5723 as simple as it's going to get, and trying to reprocess 5724 the trees will break. Once tsubst_expr et al DTRT for 5725 non-dependent exprs, this code can go away, as the type 5726 will always be set. */ 5727 if (!TREE_TYPE (r)) 5728 { 5729 int saved_processing_template_decl = processing_template_decl; 5730 processing_template_decl = 0; 5731 r = tsubst_copy_and_build (r, /*args=*/NULL_TREE, 5732 tf_error, /*in_decl=*/NULL_TREE, 5733 /*function_p=*/false); 5734 processing_template_decl = saved_processing_template_decl; 5735 } 5736 r = fold (r); 5737 } 5738 } 5739 return r; 5740} 5741 5742/* Substitute ARGS into the vector or list of template arguments T. */ 5743 5744static tree 5745tsubst_template_args (tree t, tree args, tsubst_flags_t complain, tree in_decl) 5746{ 5747 int len = TREE_VEC_LENGTH (t); 5748 int need_new = 0, i; 5749 tree *elts = alloca (len * sizeof (tree)); 5750 5751 for (i = 0; i < len; i++) 5752 { 5753 tree orig_arg = TREE_VEC_ELT (t, i); 5754 tree new_arg; 5755 5756 if (TREE_CODE (orig_arg) == TREE_VEC) 5757 new_arg = tsubst_template_args (orig_arg, args, complain, in_decl); 5758 else 5759 new_arg = tsubst_template_arg (orig_arg, args, complain, in_decl); 5760 5761 if (new_arg == error_mark_node) 5762 return error_mark_node; 5763 5764 elts[i] = new_arg; 5765 if (new_arg != orig_arg) 5766 need_new = 1; 5767 } 5768 5769 if (!need_new) 5770 return t; 5771 5772 t = make_tree_vec (len); 5773 for (i = 0; i < len; i++) 5774 TREE_VEC_ELT (t, i) = elts[i]; 5775 5776 return t; 5777} 5778 5779/* Return the result of substituting ARGS into the template parameters 5780 given by PARMS. If there are m levels of ARGS and m + n levels of 5781 PARMS, then the result will contain n levels of PARMS. For 5782 example, if PARMS is `template <class T> template <class U> 5783 template <T*, U, class V>' and ARGS is {{int}, {double}} then the 5784 result will be `template <int*, double, class V>'. */ 5785 5786static tree 5787tsubst_template_parms (tree parms, tree args, tsubst_flags_t complain) 5788{ 5789 tree r = NULL_TREE; 5790 tree* new_parms; 5791 5792 /* When substituting into a template, we must set 5793 PROCESSING_TEMPLATE_DECL as the template parameters may be 5794 dependent if they are based on one-another, and the dependency 5795 predicates are short-circuit outside of templates. */ 5796 ++processing_template_decl; 5797 5798 for (new_parms = &r; 5799 TMPL_PARMS_DEPTH (parms) > TMPL_ARGS_DEPTH (args); 5800 new_parms = &(TREE_CHAIN (*new_parms)), 5801 parms = TREE_CHAIN (parms)) 5802 { 5803 tree new_vec = 5804 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms))); 5805 int i; 5806 5807 for (i = 0; i < TREE_VEC_LENGTH (new_vec); ++i) 5808 { 5809 tree tuple = TREE_VEC_ELT (TREE_VALUE (parms), i); 5810 tree default_value = TREE_PURPOSE (tuple); 5811 tree parm_decl = TREE_VALUE (tuple); 5812 5813 parm_decl = tsubst (parm_decl, args, complain, NULL_TREE); 5814 default_value = tsubst_template_arg (default_value, args, 5815 complain, NULL_TREE); 5816 5817 tuple = build_tree_list (default_value, parm_decl); 5818 TREE_VEC_ELT (new_vec, i) = tuple; 5819 } 5820 5821 *new_parms = 5822 tree_cons (size_int (TMPL_PARMS_DEPTH (parms) 5823 - TMPL_ARGS_DEPTH (args)), 5824 new_vec, NULL_TREE); 5825 } 5826 5827 --processing_template_decl; 5828 5829 return r; 5830} 5831 5832/* Substitute the ARGS into the indicated aggregate (or enumeration) 5833 type T. If T is not an aggregate or enumeration type, it is 5834 handled as if by tsubst. IN_DECL is as for tsubst. If 5835 ENTERING_SCOPE is nonzero, T is the context for a template which 5836 we are presently tsubst'ing. Return the substituted value. */ 5837 5838static tree 5839tsubst_aggr_type (tree t, 5840 tree args, 5841 tsubst_flags_t complain, 5842 tree in_decl, 5843 int entering_scope) 5844{ 5845 if (t == NULL_TREE) 5846 return NULL_TREE; 5847 5848 switch (TREE_CODE (t)) 5849 { 5850 case RECORD_TYPE: 5851 if (TYPE_PTRMEMFUNC_P (t)) 5852 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t), args, complain, in_decl); 5853 5854 /* Else fall through. */ 5855 case ENUMERAL_TYPE: 5856 case UNION_TYPE: 5857 if (TYPE_TEMPLATE_INFO (t)) 5858 { 5859 tree argvec; 5860 tree context; 5861 tree r; 5862 5863 /* First, determine the context for the type we are looking 5864 up. */ 5865 context = TYPE_CONTEXT (t); 5866 if (context) 5867 context = tsubst_aggr_type (context, args, complain, 5868 in_decl, /*entering_scope=*/1); 5869 5870 /* Then, figure out what arguments are appropriate for the 5871 type we are trying to find. For example, given: 5872 5873 template <class T> struct S; 5874 template <class T, class U> void f(T, U) { S<U> su; } 5875 5876 and supposing that we are instantiating f<int, double>, 5877 then our ARGS will be {int, double}, but, when looking up 5878 S we only want {double}. */ 5879 argvec = tsubst_template_args (TYPE_TI_ARGS (t), args, 5880 complain, in_decl); 5881 if (argvec == error_mark_node) 5882 return error_mark_node; 5883 5884 r = lookup_template_class (t, argvec, in_decl, context, 5885 entering_scope, complain); 5886 5887 return cp_build_qualified_type_real (r, TYPE_QUALS (t), complain); 5888 } 5889 else 5890 /* This is not a template type, so there's nothing to do. */ 5891 return t; 5892 5893 default: 5894 return tsubst (t, args, complain, in_decl); 5895 } 5896} 5897 5898/* Substitute into the default argument ARG (a default argument for 5899 FN), which has the indicated TYPE. */ 5900 5901tree 5902tsubst_default_argument (tree fn, tree type, tree arg) 5903{ 5904 tree saved_class_ptr = NULL_TREE; 5905 tree saved_class_ref = NULL_TREE; 5906 5907 /* This default argument came from a template. Instantiate the 5908 default argument here, not in tsubst. In the case of 5909 something like: 5910 5911 template <class T> 5912 struct S { 5913 static T t(); 5914 void f(T = t()); 5915 }; 5916 5917 we must be careful to do name lookup in the scope of S<T>, 5918 rather than in the current class. */ 5919 push_access_scope (fn); 5920 /* The default argument expression should not be considered to be 5921 within the scope of FN. Since push_access_scope sets 5922 current_function_decl, we must explicitly clear it here. */ 5923 current_function_decl = NULL_TREE; 5924 /* The "this" pointer is not valid in a default argument. */ 5925 if (cfun) 5926 { 5927 saved_class_ptr = current_class_ptr; 5928 cp_function_chain->x_current_class_ptr = NULL_TREE; 5929 saved_class_ref = current_class_ref; 5930 cp_function_chain->x_current_class_ref = NULL_TREE; 5931 } 5932 5933 push_deferring_access_checks(dk_no_deferred); 5934 arg = tsubst_expr (arg, DECL_TI_ARGS (fn), 5935 tf_error | tf_warning, NULL_TREE); 5936 pop_deferring_access_checks(); 5937 5938 /* Restore the "this" pointer. */ 5939 if (cfun) 5940 { 5941 cp_function_chain->x_current_class_ptr = saved_class_ptr; 5942 cp_function_chain->x_current_class_ref = saved_class_ref; 5943 } 5944 5945 pop_access_scope (fn); 5946 5947 /* Make sure the default argument is reasonable. */ 5948 arg = check_default_argument (type, arg); 5949 5950 return arg; 5951} 5952 5953/* Substitute into all the default arguments for FN. */ 5954 5955static void 5956tsubst_default_arguments (tree fn) 5957{ 5958 tree arg; 5959 tree tmpl_args; 5960 5961 tmpl_args = DECL_TI_ARGS (fn); 5962 5963 /* If this function is not yet instantiated, we certainly don't need 5964 its default arguments. */ 5965 if (uses_template_parms (tmpl_args)) 5966 return; 5967 5968 for (arg = TYPE_ARG_TYPES (TREE_TYPE (fn)); 5969 arg; 5970 arg = TREE_CHAIN (arg)) 5971 if (TREE_PURPOSE (arg)) 5972 TREE_PURPOSE (arg) = tsubst_default_argument (fn, 5973 TREE_VALUE (arg), 5974 TREE_PURPOSE (arg)); 5975} 5976 5977/* Substitute the ARGS into the T, which is a _DECL. TYPE is the 5978 (already computed) substitution of ARGS into TREE_TYPE (T), if 5979 appropriate. Return the result of the substitution. Issue error 5980 and warning messages under control of COMPLAIN. */ 5981 5982static tree 5983tsubst_decl (tree t, tree args, tree type, tsubst_flags_t complain) 5984{ 5985 location_t saved_loc; 5986 tree r = NULL_TREE; 5987 tree in_decl = t; 5988 5989 /* Set the filename and linenumber to improve error-reporting. */ 5990 saved_loc = input_location; 5991 input_location = DECL_SOURCE_LOCATION (t); 5992 5993 switch (TREE_CODE (t)) 5994 { 5995 case TEMPLATE_DECL: 5996 { 5997 /* We can get here when processing a member template function 5998 of a template class. */ 5999 tree decl = DECL_TEMPLATE_RESULT (t); 6000 tree spec; 6001 int is_template_template_parm = DECL_TEMPLATE_TEMPLATE_PARM_P (t); 6002 6003 if (!is_template_template_parm) 6004 { 6005 /* We might already have an instance of this template. 6006 The ARGS are for the surrounding class type, so the 6007 full args contain the tsubst'd args for the context, 6008 plus the innermost args from the template decl. */ 6009 tree tmpl_args = DECL_CLASS_TEMPLATE_P (t) 6010 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t)) 6011 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t)); 6012 tree full_args; 6013 6014 /* Because this is a template, the arguments will still be 6015 dependent, even after substitution. If 6016 PROCESSING_TEMPLATE_DECL is not set, the dependency 6017 predicates will short-circuit. */ 6018 ++processing_template_decl; 6019 full_args = tsubst_template_args (tmpl_args, args, 6020 complain, in_decl); 6021 --processing_template_decl; 6022 6023 /* tsubst_template_args doesn't copy the vector if 6024 nothing changed. But, *something* should have 6025 changed. */ 6026 my_friendly_assert (full_args != tmpl_args, 0); 6027 6028 spec = retrieve_specialization (t, full_args); 6029 if (spec != NULL_TREE) 6030 { 6031 r = spec; 6032 break; 6033 } 6034 } 6035 6036 /* Make a new template decl. It will be similar to the 6037 original, but will record the current template arguments. 6038 We also create a new function declaration, which is just 6039 like the old one, but points to this new template, rather 6040 than the old one. */ 6041 r = copy_decl (t); 6042 my_friendly_assert (DECL_LANG_SPECIFIC (r) != 0, 0); 6043 TREE_CHAIN (r) = NULL_TREE; 6044 6045 if (is_template_template_parm) 6046 { 6047 tree new_decl = tsubst (decl, args, complain, in_decl); 6048 DECL_TEMPLATE_RESULT (r) = new_decl; 6049 TREE_TYPE (r) = TREE_TYPE (new_decl); 6050 break; 6051 } 6052 6053 DECL_TEMPLATE_INFO (r) = build_tree_list (t, args); 6054 6055 if (TREE_CODE (decl) == TYPE_DECL) 6056 { 6057 tree new_type; 6058 ++processing_template_decl; 6059 new_type = tsubst (TREE_TYPE (t), args, complain, in_decl); 6060 --processing_template_decl; 6061 if (new_type == error_mark_node) 6062 return error_mark_node; 6063 6064 TREE_TYPE (r) = new_type; 6065 CLASSTYPE_TI_TEMPLATE (new_type) = r; 6066 DECL_TEMPLATE_RESULT (r) = TYPE_MAIN_DECL (new_type); 6067 DECL_TI_ARGS (r) = CLASSTYPE_TI_ARGS (new_type); 6068 DECL_CONTEXT (r) = TYPE_CONTEXT (new_type); 6069 } 6070 else 6071 { 6072 tree new_decl; 6073 ++processing_template_decl; 6074 new_decl = tsubst (decl, args, complain, in_decl); 6075 --processing_template_decl; 6076 if (new_decl == error_mark_node) 6077 return error_mark_node; 6078 6079 DECL_TEMPLATE_RESULT (r) = new_decl; 6080 DECL_TI_TEMPLATE (new_decl) = r; 6081 TREE_TYPE (r) = TREE_TYPE (new_decl); 6082 DECL_TI_ARGS (r) = DECL_TI_ARGS (new_decl); 6083 DECL_CONTEXT (r) = DECL_CONTEXT (new_decl); 6084 } 6085 6086 SET_DECL_IMPLICIT_INSTANTIATION (r); 6087 DECL_TEMPLATE_INSTANTIATIONS (r) = NULL_TREE; 6088 DECL_TEMPLATE_SPECIALIZATIONS (r) = NULL_TREE; 6089 6090 /* The template parameters for this new template are all the 6091 template parameters for the old template, except the 6092 outermost level of parameters. */ 6093 DECL_TEMPLATE_PARMS (r) 6094 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args, 6095 complain); 6096 6097 if (PRIMARY_TEMPLATE_P (t)) 6098 DECL_PRIMARY_TEMPLATE (r) = r; 6099 6100 if (TREE_CODE (decl) != TYPE_DECL) 6101 /* Record this non-type partial instantiation. */ 6102 register_specialization (r, t, 6103 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r))); 6104 } 6105 break; 6106 6107 case FUNCTION_DECL: 6108 { 6109 tree ctx; 6110 tree argvec = NULL_TREE; 6111 tree *friends; 6112 tree gen_tmpl; 6113 int member; 6114 int args_depth; 6115 int parms_depth; 6116 6117 /* Nobody should be tsubst'ing into non-template functions. */ 6118 my_friendly_assert (DECL_TEMPLATE_INFO (t) != NULL_TREE, 0); 6119 6120 if (TREE_CODE (DECL_TI_TEMPLATE (t)) == TEMPLATE_DECL) 6121 { 6122 tree spec; 6123 bool dependent_p; 6124 6125 /* If T is not dependent, just return it. We have to 6126 increment PROCESSING_TEMPLATE_DECL because 6127 value_dependent_expression_p assumes that nothing is 6128 dependent when PROCESSING_TEMPLATE_DECL is zero. */ 6129 ++processing_template_decl; 6130 dependent_p = value_dependent_expression_p (t); 6131 --processing_template_decl; 6132 if (!dependent_p) 6133 return t; 6134 6135 /* Calculate the most general template of which R is a 6136 specialization, and the complete set of arguments used to 6137 specialize R. */ 6138 gen_tmpl = most_general_template (DECL_TI_TEMPLATE (t)); 6139 argvec = tsubst_template_args (DECL_TI_ARGS 6140 (DECL_TEMPLATE_RESULT (gen_tmpl)), 6141 args, complain, in_decl); 6142 6143 /* Check to see if we already have this specialization. */ 6144 spec = retrieve_specialization (gen_tmpl, argvec); 6145 6146 if (spec) 6147 { 6148 r = spec; 6149 break; 6150 } 6151 6152 /* We can see more levels of arguments than parameters if 6153 there was a specialization of a member template, like 6154 this: 6155 6156 template <class T> struct S { template <class U> void f(); } 6157 template <> template <class U> void S<int>::f(U); 6158 6159 Here, we'll be substituting into the specialization, 6160 because that's where we can find the code we actually 6161 want to generate, but we'll have enough arguments for 6162 the most general template. 6163 6164 We also deal with the peculiar case: 6165 6166 template <class T> struct S { 6167 template <class U> friend void f(); 6168 }; 6169 template <class U> void f() {} 6170 template S<int>; 6171 template void f<double>(); 6172 6173 Here, the ARGS for the instantiation of will be {int, 6174 double}. But, we only need as many ARGS as there are 6175 levels of template parameters in CODE_PATTERN. We are 6176 careful not to get fooled into reducing the ARGS in 6177 situations like: 6178 6179 template <class T> struct S { template <class U> void f(U); } 6180 template <class T> template <> void S<T>::f(int) {} 6181 6182 which we can spot because the pattern will be a 6183 specialization in this case. */ 6184 args_depth = TMPL_ARGS_DEPTH (args); 6185 parms_depth = 6186 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t))); 6187 if (args_depth > parms_depth 6188 && !DECL_TEMPLATE_SPECIALIZATION (t)) 6189 args = get_innermost_template_args (args, parms_depth); 6190 } 6191 else 6192 { 6193 /* This special case arises when we have something like this: 6194 6195 template <class T> struct S { 6196 friend void f<int>(int, double); 6197 }; 6198 6199 Here, the DECL_TI_TEMPLATE for the friend declaration 6200 will be an IDENTIFIER_NODE. We are being called from 6201 tsubst_friend_function, and we want only to create a 6202 new decl (R) with appropriate types so that we can call 6203 determine_specialization. */ 6204 gen_tmpl = NULL_TREE; 6205 } 6206 6207 if (DECL_CLASS_SCOPE_P (t)) 6208 { 6209 if (DECL_NAME (t) == constructor_name (DECL_CONTEXT (t))) 6210 member = 2; 6211 else 6212 member = 1; 6213 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args, 6214 complain, t, /*entering_scope=*/1); 6215 } 6216 else 6217 { 6218 member = 0; 6219 ctx = DECL_CONTEXT (t); 6220 } 6221 type = tsubst (type, args, complain, in_decl); 6222 if (type == error_mark_node) 6223 return error_mark_node; 6224 6225 /* We do NOT check for matching decls pushed separately at this 6226 point, as they may not represent instantiations of this 6227 template, and in any case are considered separate under the 6228 discrete model. */ 6229 r = copy_decl (t); 6230 DECL_USE_TEMPLATE (r) = 0; 6231 TREE_TYPE (r) = type; 6232 /* Clear out the mangled name and RTL for the instantiation. */ 6233 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE); 6234 SET_DECL_RTL (r, NULL_RTX); 6235 DECL_INITIAL (r) = NULL_TREE; 6236 DECL_CONTEXT (r) = ctx; 6237 6238 if (member && DECL_CONV_FN_P (r)) 6239 /* Type-conversion operator. Reconstruct the name, in 6240 case it's the name of one of the template's parameters. */ 6241 DECL_NAME (r) = mangle_conv_op_name_for_type (TREE_TYPE (type)); 6242 6243 DECL_ARGUMENTS (r) = tsubst (DECL_ARGUMENTS (t), args, 6244 complain, t); 6245 DECL_RESULT (r) = NULL_TREE; 6246 6247 TREE_STATIC (r) = 0; 6248 TREE_PUBLIC (r) = TREE_PUBLIC (t); 6249 DECL_EXTERNAL (r) = 1; 6250 DECL_INTERFACE_KNOWN (r) = 0; 6251 DECL_DEFER_OUTPUT (r) = 0; 6252 TREE_CHAIN (r) = NULL_TREE; 6253 DECL_PENDING_INLINE_INFO (r) = 0; 6254 DECL_PENDING_INLINE_P (r) = 0; 6255 DECL_SAVED_TREE (r) = NULL_TREE; 6256 TREE_USED (r) = 0; 6257 if (DECL_CLONED_FUNCTION (r)) 6258 { 6259 DECL_CLONED_FUNCTION (r) = tsubst (DECL_CLONED_FUNCTION (t), 6260 args, complain, t); 6261 TREE_CHAIN (r) = TREE_CHAIN (DECL_CLONED_FUNCTION (r)); 6262 TREE_CHAIN (DECL_CLONED_FUNCTION (r)) = r; 6263 } 6264 6265 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do 6266 this in the special friend case mentioned above where 6267 GEN_TMPL is NULL. */ 6268 if (gen_tmpl) 6269 { 6270 DECL_TEMPLATE_INFO (r) 6271 = tree_cons (gen_tmpl, argvec, NULL_TREE); 6272 SET_DECL_IMPLICIT_INSTANTIATION (r); 6273 register_specialization (r, gen_tmpl, argvec); 6274 6275 /* We're not supposed to instantiate default arguments 6276 until they are called, for a template. But, for a 6277 declaration like: 6278 6279 template <class T> void f () 6280 { extern void g(int i = T()); } 6281 6282 we should do the substitution when the template is 6283 instantiated. We handle the member function case in 6284 instantiate_class_template since the default arguments 6285 might refer to other members of the class. */ 6286 if (!member 6287 && !PRIMARY_TEMPLATE_P (gen_tmpl) 6288 && !uses_template_parms (argvec)) 6289 tsubst_default_arguments (r); 6290 } 6291 6292 /* Copy the list of befriending classes. */ 6293 for (friends = &DECL_BEFRIENDING_CLASSES (r); 6294 *friends; 6295 friends = &TREE_CHAIN (*friends)) 6296 { 6297 *friends = copy_node (*friends); 6298 TREE_VALUE (*friends) = tsubst (TREE_VALUE (*friends), 6299 args, complain, 6300 in_decl); 6301 } 6302 6303 if (DECL_CONSTRUCTOR_P (r) || DECL_DESTRUCTOR_P (r)) 6304 { 6305 maybe_retrofit_in_chrg (r); 6306 if (DECL_CONSTRUCTOR_P (r)) 6307 grok_ctor_properties (ctx, r); 6308 /* If this is an instantiation of a member template, clone it. 6309 If it isn't, that'll be handled by 6310 clone_constructors_and_destructors. */ 6311 if (PRIMARY_TEMPLATE_P (gen_tmpl)) 6312 clone_function_decl (r, /*update_method_vec_p=*/0); 6313 } 6314 else if (IDENTIFIER_OPNAME_P (DECL_NAME (r))) 6315 grok_op_properties (r, (complain & tf_error) != 0); 6316 6317 if (DECL_FRIEND_P (t) && DECL_FRIEND_CONTEXT (t)) 6318 SET_DECL_FRIEND_CONTEXT (r, 6319 tsubst (DECL_FRIEND_CONTEXT (t), 6320 args, complain, in_decl)); 6321 } 6322 break; 6323 6324 case PARM_DECL: 6325 { 6326 r = copy_node (t); 6327 if (DECL_TEMPLATE_PARM_P (t)) 6328 SET_DECL_TEMPLATE_PARM_P (r); 6329 6330 TREE_TYPE (r) = type; 6331 c_apply_type_quals_to_decl (cp_type_quals (type), r); 6332 6333 if (DECL_INITIAL (r)) 6334 { 6335 if (TREE_CODE (DECL_INITIAL (r)) != TEMPLATE_PARM_INDEX) 6336 DECL_INITIAL (r) = TREE_TYPE (r); 6337 else 6338 DECL_INITIAL (r) = tsubst (DECL_INITIAL (r), args, 6339 complain, in_decl); 6340 } 6341 6342 DECL_CONTEXT (r) = NULL_TREE; 6343 6344 if (!DECL_TEMPLATE_PARM_P (r)) 6345 DECL_ARG_TYPE (r) = type_passed_as (type); 6346 if (TREE_CHAIN (t)) 6347 TREE_CHAIN (r) = tsubst (TREE_CHAIN (t), args, 6348 complain, TREE_CHAIN (t)); 6349 } 6350 break; 6351 6352 case FIELD_DECL: 6353 { 6354 r = copy_decl (t); 6355 TREE_TYPE (r) = type; 6356 c_apply_type_quals_to_decl (cp_type_quals (type), r); 6357 6358 /* We don't have to set DECL_CONTEXT here; it is set by 6359 finish_member_declaration. */ 6360 DECL_INITIAL (r) = tsubst_expr (DECL_INITIAL (t), args, 6361 complain, in_decl); 6362 TREE_CHAIN (r) = NULL_TREE; 6363 if (VOID_TYPE_P (type)) 6364 cp_error_at ("instantiation of `%D' as type `%T'", r, type); 6365 } 6366 break; 6367 6368 case USING_DECL: 6369 { 6370 r = copy_node (t); 6371 /* It is not a dependent using decl any more. */ 6372 TREE_TYPE (r) = void_type_node; 6373 DECL_INITIAL (r) 6374 = tsubst_copy (DECL_INITIAL (t), args, complain, in_decl); 6375 DECL_NAME (r) 6376 = tsubst_copy (DECL_NAME (t), args, complain, in_decl); 6377 TREE_CHAIN (r) = NULL_TREE; 6378 } 6379 break; 6380 6381 case TYPE_DECL: 6382 if (TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM 6383 || t == TYPE_MAIN_DECL (TREE_TYPE (t))) 6384 { 6385 /* If this is the canonical decl, we don't have to mess with 6386 instantiations, and often we can't (for typename, template 6387 type parms and such). Note that TYPE_NAME is not correct for 6388 the above test if we've copied the type for a typedef. */ 6389 r = TYPE_NAME (type); 6390 break; 6391 } 6392 6393 /* Fall through. */ 6394 6395 case VAR_DECL: 6396 { 6397 tree argvec = NULL_TREE; 6398 tree gen_tmpl = NULL_TREE; 6399 tree spec; 6400 tree tmpl = NULL_TREE; 6401 tree ctx; 6402 int local_p; 6403 6404 /* Assume this is a non-local variable. */ 6405 local_p = 0; 6406 6407 if (TYPE_P (CP_DECL_CONTEXT (t))) 6408 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args, 6409 complain, 6410 in_decl, /*entering_scope=*/1); 6411 else if (DECL_NAMESPACE_SCOPE_P (t)) 6412 ctx = DECL_CONTEXT (t); 6413 else 6414 { 6415 /* Subsequent calls to pushdecl will fill this in. */ 6416 ctx = NULL_TREE; 6417 local_p = 1; 6418 } 6419 6420 /* Check to see if we already have this specialization. */ 6421 if (!local_p) 6422 { 6423 tmpl = DECL_TI_TEMPLATE (t); 6424 gen_tmpl = most_general_template (tmpl); 6425 argvec = tsubst (DECL_TI_ARGS (t), args, complain, in_decl); 6426 spec = retrieve_specialization (gen_tmpl, argvec); 6427 } 6428 else 6429 spec = retrieve_local_specialization (t); 6430 6431 if (spec) 6432 { 6433 r = spec; 6434 break; 6435 } 6436 6437 r = copy_decl (t); 6438 if (TREE_CODE (r) == VAR_DECL) 6439 { 6440 type = complete_type (type); 6441 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r) 6442 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t); 6443 type = check_var_type (DECL_NAME (r), type); 6444 } 6445 else if (DECL_SELF_REFERENCE_P (t)) 6446 SET_DECL_SELF_REFERENCE_P (r); 6447 TREE_TYPE (r) = type; 6448 c_apply_type_quals_to_decl (cp_type_quals (type), r); 6449 DECL_CONTEXT (r) = ctx; 6450 /* Clear out the mangled name and RTL for the instantiation. */ 6451 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE); 6452 SET_DECL_RTL (r, NULL_RTX); 6453 6454 /* Don't try to expand the initializer until someone tries to use 6455 this variable; otherwise we run into circular dependencies. */ 6456 DECL_INITIAL (r) = NULL_TREE; 6457 SET_DECL_RTL (r, NULL_RTX); 6458 DECL_SIZE (r) = DECL_SIZE_UNIT (r) = 0; 6459 6460 /* Even if the original location is out of scope, the newly 6461 substituted one is not. */ 6462 if (TREE_CODE (r) == VAR_DECL) 6463 { 6464 DECL_DEAD_FOR_LOCAL (r) = 0; 6465 DECL_INITIALIZED_P (r) = 0; 6466 } 6467 6468 if (!local_p) 6469 { 6470 /* A static data member declaration is always marked 6471 external when it is declared in-class, even if an 6472 initializer is present. We mimic the non-template 6473 processing here. */ 6474 DECL_EXTERNAL (r) = 1; 6475 6476 register_specialization (r, gen_tmpl, argvec); 6477 DECL_TEMPLATE_INFO (r) = tree_cons (tmpl, argvec, NULL_TREE); 6478 SET_DECL_IMPLICIT_INSTANTIATION (r); 6479 } 6480 else 6481 register_local_specialization (r, t); 6482 6483 TREE_CHAIN (r) = NULL_TREE; 6484 layout_decl (r, 0); 6485 } 6486 break; 6487 6488 default: 6489 abort (); 6490 } 6491 6492 /* Restore the file and line information. */ 6493 input_location = saved_loc; 6494 6495 return r; 6496} 6497 6498/* Substitute into the ARG_TYPES of a function type. */ 6499 6500static tree 6501tsubst_arg_types (tree arg_types, 6502 tree args, 6503 tsubst_flags_t complain, 6504 tree in_decl) 6505{ 6506 tree remaining_arg_types; 6507 tree type; 6508 tree default_arg; 6509 tree result = NULL_TREE; 6510 6511 if (!arg_types || arg_types == void_list_node) 6512 return arg_types; 6513 6514 remaining_arg_types = tsubst_arg_types (TREE_CHAIN (arg_types), 6515 args, complain, in_decl); 6516 if (remaining_arg_types == error_mark_node) 6517 return error_mark_node; 6518 6519 type = tsubst (TREE_VALUE (arg_types), args, complain, in_decl); 6520 if (type == error_mark_node) 6521 return error_mark_node; 6522 if (VOID_TYPE_P (type)) 6523 { 6524 if (complain & tf_error) 6525 { 6526 error ("invalid parameter type `%T'", type); 6527 if (in_decl) 6528 cp_error_at ("in declaration `%D'", in_decl); 6529 } 6530 return error_mark_node; 6531 } 6532 6533 /* Do array-to-pointer, function-to-pointer conversion, and ignore 6534 top-level qualifiers as required. */ 6535 type = TYPE_MAIN_VARIANT (type_decays_to (type)); 6536 6537 /* We do not substitute into default arguments here. The standard 6538 mandates that they be instantiated only when needed, which is 6539 done in build_over_call. */ 6540 default_arg = TREE_PURPOSE (arg_types); 6541 6542 if (default_arg && TREE_CODE (default_arg) == DEFAULT_ARG) 6543 { 6544 /* We've instantiated a template before its default arguments 6545 have been parsed. This can happen for a nested template 6546 class, and is not an error unless we require the default 6547 argument in a call of this function. */ 6548 result = tree_cons (default_arg, type, remaining_arg_types); 6549 TREE_CHAIN (default_arg) = tree_cons (result, NULL_TREE, 6550 TREE_CHAIN (default_arg)); 6551 } 6552 else 6553 result = hash_tree_cons (default_arg, type, remaining_arg_types); 6554 6555 return result; 6556} 6557 6558/* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does 6559 *not* handle the exception-specification for FNTYPE, because the 6560 initial substitution of explicitly provided template parameters 6561 during argument deduction forbids substitution into the 6562 exception-specification: 6563 6564 [temp.deduct] 6565 6566 All references in the function type of the function template to the 6567 corresponding template parameters are replaced by the specified tem- 6568 plate argument values. If a substitution in a template parameter or 6569 in the function type of the function template results in an invalid 6570 type, type deduction fails. [Note: The equivalent substitution in 6571 exception specifications is done only when the function is instanti- 6572 ated, at which point a program is ill-formed if the substitution 6573 results in an invalid type.] */ 6574 6575static tree 6576tsubst_function_type (tree t, 6577 tree args, 6578 tsubst_flags_t complain, 6579 tree in_decl) 6580{ 6581 tree return_type; 6582 tree arg_types; 6583 tree fntype; 6584 6585 /* The TYPE_CONTEXT is not used for function/method types. */ 6586 my_friendly_assert (TYPE_CONTEXT (t) == NULL_TREE, 0); 6587 6588 /* Substitute the return type. */ 6589 return_type = tsubst (TREE_TYPE (t), args, complain, in_decl); 6590 if (return_type == error_mark_node) 6591 return error_mark_node; 6592 6593 /* Substitute the argument types. */ 6594 arg_types = tsubst_arg_types (TYPE_ARG_TYPES (t), args, 6595 complain, in_decl); 6596 if (arg_types == error_mark_node) 6597 return error_mark_node; 6598 6599 /* Construct a new type node and return it. */ 6600 if (TREE_CODE (t) == FUNCTION_TYPE) 6601 fntype = build_function_type (return_type, arg_types); 6602 else 6603 { 6604 tree r = TREE_TYPE (TREE_VALUE (arg_types)); 6605 if (! IS_AGGR_TYPE (r)) 6606 { 6607 /* [temp.deduct] 6608 6609 Type deduction may fail for any of the following 6610 reasons: 6611 6612 -- Attempting to create "pointer to member of T" when T 6613 is not a class type. */ 6614 if (complain & tf_error) 6615 error ("creating pointer to member function of non-class type `%T'", 6616 r); 6617 return error_mark_node; 6618 } 6619 6620 fntype = build_method_type_directly (r, return_type, 6621 TREE_CHAIN (arg_types)); 6622 } 6623 fntype = cp_build_qualified_type_real (fntype, TYPE_QUALS (t), complain); 6624 fntype = cp_build_type_attribute_variant (fntype, TYPE_ATTRIBUTES (t)); 6625 6626 return fntype; 6627} 6628 6629/* Substitute into the PARMS of a call-declarator. */ 6630 6631static tree 6632tsubst_call_declarator_parms (tree parms, 6633 tree args, 6634 tsubst_flags_t complain, 6635 tree in_decl) 6636{ 6637 tree new_parms; 6638 tree type; 6639 tree defarg; 6640 6641 if (!parms || parms == void_list_node) 6642 return parms; 6643 6644 new_parms = tsubst_call_declarator_parms (TREE_CHAIN (parms), 6645 args, complain, in_decl); 6646 6647 /* Figure out the type of this parameter. */ 6648 type = tsubst (TREE_VALUE (parms), args, complain, in_decl); 6649 6650 /* Figure out the default argument as well. Note that we use 6651 tsubst_expr since the default argument is really an expression. */ 6652 defarg = tsubst_expr (TREE_PURPOSE (parms), args, complain, in_decl); 6653 6654 /* Chain this parameter on to the front of those we have already 6655 processed. We don't use hash_tree_cons because that function 6656 doesn't check TREE_PARMLIST. */ 6657 new_parms = tree_cons (defarg, type, new_parms); 6658 6659 /* And note that these are parameters. */ 6660 TREE_PARMLIST (new_parms) = 1; 6661 6662 return new_parms; 6663} 6664 6665/* Take the tree structure T and replace template parameters used 6666 therein with the argument vector ARGS. IN_DECL is an associated 6667 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE. 6668 Issue error and warning messages under control of COMPLAIN. Note 6669 that we must be relatively non-tolerant of extensions here, in 6670 order to preserve conformance; if we allow substitutions that 6671 should not be allowed, we may allow argument deductions that should 6672 not succeed, and therefore report ambiguous overload situations 6673 where there are none. In theory, we could allow the substitution, 6674 but indicate that it should have failed, and allow our caller to 6675 make sure that the right thing happens, but we don't try to do this 6676 yet. 6677 6678 This function is used for dealing with types, decls and the like; 6679 for expressions, use tsubst_expr or tsubst_copy. */ 6680 6681static tree 6682tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl) 6683{ 6684 tree type, r; 6685 6686 if (t == NULL_TREE || t == error_mark_node 6687 || t == integer_type_node 6688 || t == void_type_node 6689 || t == char_type_node 6690 || t == unknown_type_node 6691 || TREE_CODE (t) == NAMESPACE_DECL) 6692 return t; 6693 6694 if (TREE_CODE (t) == IDENTIFIER_NODE) 6695 type = IDENTIFIER_TYPE_VALUE (t); 6696 else 6697 type = TREE_TYPE (t); 6698 6699 my_friendly_assert (type != unknown_type_node, 20030716); 6700 6701 if (type && TREE_CODE (t) != FUNCTION_DECL 6702 && TREE_CODE (t) != TYPENAME_TYPE 6703 && TREE_CODE (t) != TEMPLATE_DECL 6704 && TREE_CODE (t) != IDENTIFIER_NODE 6705 && TREE_CODE (t) != FUNCTION_TYPE 6706 && TREE_CODE (t) != METHOD_TYPE) 6707 type = tsubst (type, args, complain, in_decl); 6708 if (type == error_mark_node) 6709 return error_mark_node; 6710 6711 if (DECL_P (t)) 6712 return tsubst_decl (t, args, type, complain); 6713 6714 switch (TREE_CODE (t)) 6715 { 6716 case RECORD_TYPE: 6717 case UNION_TYPE: 6718 case ENUMERAL_TYPE: 6719 return tsubst_aggr_type (t, args, complain, in_decl, 6720 /*entering_scope=*/0); 6721 6722 case ERROR_MARK: 6723 case IDENTIFIER_NODE: 6724 case VOID_TYPE: 6725 case REAL_TYPE: 6726 case COMPLEX_TYPE: 6727 case VECTOR_TYPE: 6728 case BOOLEAN_TYPE: 6729 case INTEGER_CST: 6730 case REAL_CST: 6731 case STRING_CST: 6732 return t; 6733 6734 case INTEGER_TYPE: 6735 if (t == integer_type_node) 6736 return t; 6737 6738 if (TREE_CODE (TYPE_MIN_VALUE (t)) == INTEGER_CST 6739 && TREE_CODE (TYPE_MAX_VALUE (t)) == INTEGER_CST) 6740 return t; 6741 6742 { 6743 tree max, omax = TREE_OPERAND (TYPE_MAX_VALUE (t), 0); 6744 6745 /* The array dimension behaves like a non-type template arg, 6746 in that we want to fold it as much as possible. */ 6747 max = tsubst_template_arg (omax, args, complain, in_decl); 6748 max = fold_non_dependent_expr (max); 6749 6750 if (integer_zerop (omax)) 6751 { 6752 /* Still allow an explicit array of size zero. */ 6753 if (pedantic) 6754 pedwarn ("creating array with size zero"); 6755 } 6756 else if (integer_zerop (max) 6757 || (TREE_CODE (max) == INTEGER_CST 6758 && INT_CST_LT (max, integer_zero_node))) 6759 { 6760 /* [temp.deduct] 6761 6762 Type deduction may fail for any of the following 6763 reasons: 6764 6765 Attempting to create an array with a size that is 6766 zero or negative. */ 6767 if (complain & tf_error) 6768 error ("creating array with size zero (`%E')", max); 6769 6770 return error_mark_node; 6771 } 6772 6773 return compute_array_index_type (NULL_TREE, max); 6774 } 6775 6776 case TEMPLATE_TYPE_PARM: 6777 case TEMPLATE_TEMPLATE_PARM: 6778 case BOUND_TEMPLATE_TEMPLATE_PARM: 6779 case TEMPLATE_PARM_INDEX: 6780 { 6781 int idx; 6782 int level; 6783 int levels; 6784 6785 r = NULL_TREE; 6786 6787 if (TREE_CODE (t) == TEMPLATE_TYPE_PARM 6788 || TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM 6789 || TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM) 6790 { 6791 idx = TEMPLATE_TYPE_IDX (t); 6792 level = TEMPLATE_TYPE_LEVEL (t); 6793 } 6794 else 6795 { 6796 idx = TEMPLATE_PARM_IDX (t); 6797 level = TEMPLATE_PARM_LEVEL (t); 6798 } 6799 6800 if (TREE_VEC_LENGTH (args) > 0) 6801 { 6802 tree arg = NULL_TREE; 6803 6804 levels = TMPL_ARGS_DEPTH (args); 6805 if (level <= levels) 6806 arg = TMPL_ARG (args, level, idx); 6807 6808 if (arg == error_mark_node) 6809 return error_mark_node; 6810 else if (arg != NULL_TREE) 6811 { 6812 if (TREE_CODE (t) == TEMPLATE_TYPE_PARM) 6813 { 6814 my_friendly_assert (TYPE_P (arg), 0); 6815 return cp_build_qualified_type_real 6816 (arg, cp_type_quals (arg) | cp_type_quals (t), 6817 complain | tf_ignore_bad_quals); 6818 } 6819 else if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM) 6820 { 6821 /* We are processing a type constructed from 6822 a template template parameter. */ 6823 tree argvec = tsubst (TYPE_TI_ARGS (t), 6824 args, complain, in_decl); 6825 if (argvec == error_mark_node) 6826 return error_mark_node; 6827 6828 /* We can get a TEMPLATE_TEMPLATE_PARM here when 6829 we are resolving nested-types in the signature of 6830 a member function templates. 6831 Otherwise ARG is a TEMPLATE_DECL and is the real 6832 template to be instantiated. */ 6833 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM) 6834 arg = TYPE_NAME (arg); 6835 6836 r = lookup_template_class (arg, 6837 argvec, in_decl, 6838 DECL_CONTEXT (arg), 6839 /*entering_scope=*/0, 6840 complain); 6841 return cp_build_qualified_type_real 6842 (r, TYPE_QUALS (t), complain); 6843 } 6844 else 6845 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */ 6846 return arg; 6847 } 6848 } 6849 else 6850 abort (); 6851 6852 if (level == 1) 6853 /* This can happen during the attempted tsubst'ing in 6854 unify. This means that we don't yet have any information 6855 about the template parameter in question. */ 6856 return t; 6857 6858 /* If we get here, we must have been looking at a parm for a 6859 more deeply nested template. Make a new version of this 6860 template parameter, but with a lower level. */ 6861 switch (TREE_CODE (t)) 6862 { 6863 case TEMPLATE_TYPE_PARM: 6864 case TEMPLATE_TEMPLATE_PARM: 6865 case BOUND_TEMPLATE_TEMPLATE_PARM: 6866 if (cp_type_quals (t)) 6867 { 6868 r = tsubst (TYPE_MAIN_VARIANT (t), args, complain, in_decl); 6869 r = cp_build_qualified_type_real 6870 (r, cp_type_quals (t), 6871 complain | (TREE_CODE (t) == TEMPLATE_TYPE_PARM 6872 ? tf_ignore_bad_quals : 0)); 6873 } 6874 else 6875 { 6876 r = copy_type (t); 6877 TEMPLATE_TYPE_PARM_INDEX (r) 6878 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t), 6879 r, levels); 6880 TYPE_STUB_DECL (r) = TYPE_NAME (r) = TEMPLATE_TYPE_DECL (r); 6881 TYPE_MAIN_VARIANT (r) = r; 6882 TYPE_POINTER_TO (r) = NULL_TREE; 6883 TYPE_REFERENCE_TO (r) = NULL_TREE; 6884 6885 if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM) 6886 { 6887 tree argvec = tsubst (TYPE_TI_ARGS (t), args, 6888 complain, in_decl); 6889 if (argvec == error_mark_node) 6890 return error_mark_node; 6891 6892 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r) 6893 = tree_cons (TYPE_TI_TEMPLATE (t), argvec, NULL_TREE); 6894 } 6895 } 6896 break; 6897 6898 case TEMPLATE_PARM_INDEX: 6899 r = reduce_template_parm_level (t, type, levels); 6900 break; 6901 6902 default: 6903 abort (); 6904 } 6905 6906 return r; 6907 } 6908 6909 case TREE_LIST: 6910 { 6911 tree purpose, value, chain, result; 6912 6913 if (t == void_list_node) 6914 return t; 6915 6916 purpose = TREE_PURPOSE (t); 6917 if (purpose) 6918 { 6919 purpose = tsubst (purpose, args, complain, in_decl); 6920 if (purpose == error_mark_node) 6921 return error_mark_node; 6922 } 6923 value = TREE_VALUE (t); 6924 if (value) 6925 { 6926 value = tsubst (value, args, complain, in_decl); 6927 if (value == error_mark_node) 6928 return error_mark_node; 6929 } 6930 chain = TREE_CHAIN (t); 6931 if (chain && chain != void_type_node) 6932 { 6933 chain = tsubst (chain, args, complain, in_decl); 6934 if (chain == error_mark_node) 6935 return error_mark_node; 6936 } 6937 if (purpose == TREE_PURPOSE (t) 6938 && value == TREE_VALUE (t) 6939 && chain == TREE_CHAIN (t)) 6940 return t; 6941 if (TREE_PARMLIST (t)) 6942 { 6943 result = tree_cons (purpose, value, chain); 6944 TREE_PARMLIST (result) = 1; 6945 } 6946 else 6947 result = hash_tree_cons (purpose, value, chain); 6948 return result; 6949 } 6950 case TREE_VEC: 6951 if (type != NULL_TREE) 6952 { 6953 /* A binfo node. We always need to make a copy, of the node 6954 itself and of its BINFO_BASETYPES. */ 6955 6956 t = copy_node (t); 6957 6958 /* Make sure type isn't a typedef copy. */ 6959 type = BINFO_TYPE (TYPE_BINFO (type)); 6960 6961 TREE_TYPE (t) = complete_type (type); 6962 if (IS_AGGR_TYPE (type)) 6963 { 6964 BINFO_VTABLE (t) = TYPE_BINFO_VTABLE (type); 6965 BINFO_VIRTUALS (t) = TYPE_BINFO_VIRTUALS (type); 6966 if (TYPE_BINFO_BASETYPES (type) != NULL_TREE) 6967 BINFO_BASETYPES (t) = copy_node (TYPE_BINFO_BASETYPES (type)); 6968 } 6969 return t; 6970 } 6971 6972 /* Otherwise, a vector of template arguments. */ 6973 return tsubst_template_args (t, args, complain, in_decl); 6974 6975 case POINTER_TYPE: 6976 case REFERENCE_TYPE: 6977 { 6978 enum tree_code code; 6979 6980 if (type == TREE_TYPE (t) && TREE_CODE (type) != METHOD_TYPE) 6981 return t; 6982 6983 code = TREE_CODE (t); 6984 6985 6986 /* [temp.deduct] 6987 6988 Type deduction may fail for any of the following 6989 reasons: 6990 6991 -- Attempting to create a pointer to reference type. 6992 -- Attempting to create a reference to a reference type or 6993 a reference to void. */ 6994 if (TREE_CODE (type) == REFERENCE_TYPE 6995 || (code == REFERENCE_TYPE && TREE_CODE (type) == VOID_TYPE)) 6996 { 6997 static location_t last_loc; 6998 6999 /* We keep track of the last time we issued this error 7000 message to avoid spewing a ton of messages during a 7001 single bad template instantiation. */ 7002 if (complain & tf_error 7003 && (last_loc.line != input_line 7004 || last_loc.file != input_filename)) 7005 { 7006 if (TREE_CODE (type) == VOID_TYPE) 7007 error ("forming reference to void"); 7008 else 7009 error ("forming %s to reference type `%T'", 7010 (code == POINTER_TYPE) ? "pointer" : "reference", 7011 type); 7012 last_loc = input_location; 7013 } 7014 7015 return error_mark_node; 7016 } 7017 else if (code == POINTER_TYPE) 7018 { 7019 r = build_pointer_type (type); 7020 if (TREE_CODE (type) == METHOD_TYPE) 7021 r = build_ptrmemfunc_type (r); 7022 } 7023 else 7024 r = build_reference_type (type); 7025 r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain); 7026 7027 if (r != error_mark_node) 7028 /* Will this ever be needed for TYPE_..._TO values? */ 7029 layout_type (r); 7030 7031 return r; 7032 } 7033 case OFFSET_TYPE: 7034 { 7035 r = tsubst (TYPE_OFFSET_BASETYPE (t), args, complain, in_decl); 7036 if (r == error_mark_node || !IS_AGGR_TYPE (r)) 7037 { 7038 /* [temp.deduct] 7039 7040 Type deduction may fail for any of the following 7041 reasons: 7042 7043 -- Attempting to create "pointer to member of T" when T 7044 is not a class type. */ 7045 if (complain & tf_error) 7046 error ("creating pointer to member of non-class type `%T'", r); 7047 return error_mark_node; 7048 } 7049 if (TREE_CODE (type) == REFERENCE_TYPE) 7050 { 7051 if (complain & tf_error) 7052 error ("creating pointer to member reference type `%T'", type); 7053 7054 return error_mark_node; 7055 } 7056 my_friendly_assert (TREE_CODE (type) != METHOD_TYPE, 20011231); 7057 if (TREE_CODE (type) == FUNCTION_TYPE) 7058 { 7059 /* This is really a method type. The cv qualifiers of the 7060 this pointer should _not_ be determined by the cv 7061 qualifiers of the class type. They should be held 7062 somewhere in the FUNCTION_TYPE, but we don't do that at 7063 the moment. Consider 7064 typedef void (Func) () const; 7065 7066 template <typename T1> void Foo (Func T1::*); 7067 7068 */ 7069 tree method_type; 7070 7071 method_type = build_method_type_directly (TYPE_MAIN_VARIANT (r), 7072 TREE_TYPE (type), 7073 TYPE_ARG_TYPES (type)); 7074 return build_ptrmemfunc_type (build_pointer_type (method_type)); 7075 } 7076 else 7077 return cp_build_qualified_type_real (build_ptrmem_type (r, type), 7078 TYPE_QUALS (t), 7079 complain); 7080 } 7081 case FUNCTION_TYPE: 7082 case METHOD_TYPE: 7083 { 7084 tree fntype; 7085 tree raises; 7086 7087 fntype = tsubst_function_type (t, args, complain, in_decl); 7088 if (fntype == error_mark_node) 7089 return error_mark_node; 7090 7091 /* Substitute the exception specification. */ 7092 raises = TYPE_RAISES_EXCEPTIONS (t); 7093 if (raises) 7094 { 7095 tree list = NULL_TREE; 7096 7097 if (! TREE_VALUE (raises)) 7098 list = raises; 7099 else 7100 for (; raises != NULL_TREE; raises = TREE_CHAIN (raises)) 7101 { 7102 tree spec = TREE_VALUE (raises); 7103 7104 spec = tsubst (spec, args, complain, in_decl); 7105 if (spec == error_mark_node) 7106 return spec; 7107 list = add_exception_specifier (list, spec, complain); 7108 } 7109 fntype = build_exception_variant (fntype, list); 7110 } 7111 return fntype; 7112 } 7113 case ARRAY_TYPE: 7114 { 7115 tree domain = tsubst (TYPE_DOMAIN (t), args, complain, in_decl); 7116 if (domain == error_mark_node) 7117 return error_mark_node; 7118 7119 /* As an optimization, we avoid regenerating the array type if 7120 it will obviously be the same as T. */ 7121 if (type == TREE_TYPE (t) && domain == TYPE_DOMAIN (t)) 7122 return t; 7123 7124 /* These checks should match the ones in grokdeclarator. 7125 7126 [temp.deduct] 7127 7128 The deduction may fail for any of the following reasons: 7129 7130 -- Attempting to create an array with an element type that 7131 is void, a function type, or a reference type, or [DR337] 7132 an abstract class type. */ 7133 if (TREE_CODE (type) == VOID_TYPE 7134 || TREE_CODE (type) == FUNCTION_TYPE 7135 || TREE_CODE (type) == REFERENCE_TYPE) 7136 { 7137 if (complain & tf_error) 7138 error ("creating array of `%T'", type); 7139 return error_mark_node; 7140 } 7141 if (CLASS_TYPE_P (type) && CLASSTYPE_PURE_VIRTUALS (type)) 7142 { 7143 if (complain & tf_error) 7144 error ("creating array of `%T', which is an abstract class type", 7145 type); 7146 return error_mark_node; 7147 } 7148 7149 r = build_cplus_array_type (type, domain); 7150 return r; 7151 } 7152 7153 case PLUS_EXPR: 7154 case MINUS_EXPR: 7155 { 7156 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl); 7157 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl); 7158 7159 if (e1 == error_mark_node || e2 == error_mark_node) 7160 return error_mark_node; 7161 7162 return fold (build (TREE_CODE (t), TREE_TYPE (t), e1, e2)); 7163 } 7164 7165 case NEGATE_EXPR: 7166 case NOP_EXPR: 7167 { 7168 tree e = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl); 7169 if (e == error_mark_node) 7170 return error_mark_node; 7171 7172 return fold (build (TREE_CODE (t), TREE_TYPE (t), e)); 7173 } 7174 7175 case TYPENAME_TYPE: 7176 { 7177 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain, 7178 in_decl, /*entering_scope=*/1); 7179 tree f = tsubst_copy (TYPENAME_TYPE_FULLNAME (t), args, 7180 complain, in_decl); 7181 7182 if (ctx == error_mark_node || f == error_mark_node) 7183 return error_mark_node; 7184 7185 if (!IS_AGGR_TYPE (ctx)) 7186 { 7187 if (complain & tf_error) 7188 error ("`%T' is not a class, struct, or union type", 7189 ctx); 7190 return error_mark_node; 7191 } 7192 else if (!uses_template_parms (ctx) && !TYPE_BEING_DEFINED (ctx)) 7193 { 7194 /* Normally, make_typename_type does not require that the CTX 7195 have complete type in order to allow things like: 7196 7197 template <class T> struct S { typename S<T>::X Y; }; 7198 7199 But, such constructs have already been resolved by this 7200 point, so here CTX really should have complete type, unless 7201 it's a partial instantiation. */ 7202 ctx = complete_type (ctx); 7203 if (!COMPLETE_TYPE_P (ctx)) 7204 { 7205 if (complain & tf_error) 7206 cxx_incomplete_type_error (NULL_TREE, ctx); 7207 return error_mark_node; 7208 } 7209 } 7210 7211 f = make_typename_type (ctx, f, 7212 (complain & tf_error) | tf_keep_type_decl); 7213 if (f == error_mark_node) 7214 return f; 7215 if (TREE_CODE (f) == TYPE_DECL) 7216 { 7217 complain |= tf_ignore_bad_quals; 7218 f = TREE_TYPE (f); 7219 } 7220 7221 return cp_build_qualified_type_real 7222 (f, cp_type_quals (f) | cp_type_quals (t), complain); 7223 } 7224 7225 case UNBOUND_CLASS_TEMPLATE: 7226 { 7227 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain, 7228 in_decl, /*entering_scope=*/1); 7229 tree name = TYPE_IDENTIFIER (t); 7230 7231 if (ctx == error_mark_node || name == error_mark_node) 7232 return error_mark_node; 7233 7234 return make_unbound_class_template (ctx, name, complain); 7235 } 7236 7237 case INDIRECT_REF: 7238 { 7239 tree e = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl); 7240 if (e == error_mark_node) 7241 return error_mark_node; 7242 return make_pointer_declarator (type, e); 7243 } 7244 7245 case ADDR_EXPR: 7246 { 7247 tree e = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl); 7248 if (e == error_mark_node) 7249 return error_mark_node; 7250 return make_reference_declarator (type, e); 7251 } 7252 7253 case ARRAY_REF: 7254 { 7255 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl); 7256 tree e2 = tsubst_expr (TREE_OPERAND (t, 1), args, complain, in_decl); 7257 if (e1 == error_mark_node || e2 == error_mark_node) 7258 return error_mark_node; 7259 7260 return build_nt (ARRAY_REF, e1, e2); 7261 } 7262 7263 case CALL_EXPR: 7264 { 7265 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl); 7266 tree e2 = (tsubst_call_declarator_parms 7267 (CALL_DECLARATOR_PARMS (t), args, complain, in_decl)); 7268 tree e3 = tsubst (CALL_DECLARATOR_EXCEPTION_SPEC (t), args, 7269 complain, in_decl); 7270 7271 if (e1 == error_mark_node || e2 == error_mark_node 7272 || e3 == error_mark_node) 7273 return error_mark_node; 7274 7275 return make_call_declarator (e1, e2, CALL_DECLARATOR_QUALS (t), e3); 7276 } 7277 7278 case SCOPE_REF: 7279 { 7280 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl); 7281 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl); 7282 if (e1 == error_mark_node || e2 == error_mark_node) 7283 return error_mark_node; 7284 7285 return build_nt (TREE_CODE (t), e1, e2); 7286 } 7287 7288 case TYPEOF_TYPE: 7289 { 7290 tree type; 7291 7292 type = finish_typeof (tsubst_expr (TYPE_FIELDS (t), args, complain, 7293 in_decl)); 7294 return cp_build_qualified_type_real (type, 7295 cp_type_quals (t) 7296 | cp_type_quals (type), 7297 complain); 7298 } 7299 7300 default: 7301 sorry ("use of `%s' in template", 7302 tree_code_name [(int) TREE_CODE (t)]); 7303 return error_mark_node; 7304 } 7305} 7306 7307/* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the 7308 type of the expression on the left-hand side of the "." or "->" 7309 operator. */ 7310 7311static tree 7312tsubst_baselink (tree baselink, tree object_type, 7313 tree args, tsubst_flags_t complain, tree in_decl) 7314{ 7315 tree name; 7316 tree qualifying_scope; 7317 tree fns; 7318 tree template_args = 0; 7319 bool template_id_p = false; 7320 7321 /* A baselink indicates a function from a base class. The 7322 BASELINK_ACCESS_BINFO and BASELINK_BINFO are going to have 7323 non-dependent types; otherwise, the lookup could not have 7324 succeeded. However, they may indicate bases of the template 7325 class, rather than the instantiated class. 7326 7327 In addition, lookups that were not ambiguous before may be 7328 ambiguous now. Therefore, we perform the lookup again. */ 7329 qualifying_scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink)); 7330 fns = BASELINK_FUNCTIONS (baselink); 7331 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR) 7332 { 7333 template_id_p = true; 7334 template_args = TREE_OPERAND (fns, 1); 7335 fns = TREE_OPERAND (fns, 0); 7336 if (template_args) 7337 template_args = tsubst_template_args (template_args, args, 7338 complain, in_decl); 7339 } 7340 name = DECL_NAME (get_first_fn (fns)); 7341 baselink = lookup_fnfields (qualifying_scope, name, /*protect=*/1); 7342 if (BASELINK_P (baselink) && template_id_p) 7343 BASELINK_FUNCTIONS (baselink) 7344 = build_nt (TEMPLATE_ID_EXPR, 7345 BASELINK_FUNCTIONS (baselink), 7346 template_args); 7347 if (!object_type) 7348 object_type = current_class_type; 7349 return adjust_result_of_qualified_name_lookup (baselink, 7350 qualifying_scope, 7351 object_type); 7352} 7353 7354/* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is 7355 true if the qualified-id will be a postfix-expression in-and-of 7356 itself; false if more of the postfix-expression follows the 7357 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand 7358 of "&". */ 7359 7360static tree 7361tsubst_qualified_id (tree qualified_id, tree args, 7362 tsubst_flags_t complain, tree in_decl, 7363 bool done, bool address_p) 7364{ 7365 tree expr; 7366 tree scope; 7367 tree name; 7368 bool is_template; 7369 tree template_args; 7370 7371 my_friendly_assert (TREE_CODE (qualified_id) == SCOPE_REF, 20030706); 7372 7373 /* Figure out what name to look up. */ 7374 name = TREE_OPERAND (qualified_id, 1); 7375 if (TREE_CODE (name) == TEMPLATE_ID_EXPR) 7376 { 7377 is_template = true; 7378 template_args = TREE_OPERAND (name, 1); 7379 if (template_args) 7380 template_args = tsubst_template_args (template_args, args, 7381 complain, in_decl); 7382 name = TREE_OPERAND (name, 0); 7383 } 7384 else 7385 { 7386 is_template = false; 7387 template_args = NULL_TREE; 7388 } 7389 7390 /* Substitute into the qualifying scope. When there are no ARGS, we 7391 are just trying to simplify a non-dependent expression. In that 7392 case the qualifying scope may be dependent, and, in any case, 7393 substituting will not help. */ 7394 scope = TREE_OPERAND (qualified_id, 0); 7395 if (args) 7396 { 7397 scope = tsubst (scope, args, complain, in_decl); 7398 expr = tsubst_copy (name, args, complain, in_decl); 7399 } 7400 else 7401 expr = name; 7402 7403 if (dependent_type_p (scope)) 7404 return build_nt (SCOPE_REF, scope, expr); 7405 7406 if (!BASELINK_P (name) && !DECL_P (expr)) 7407 { 7408 expr = lookup_qualified_name (scope, expr, /*is_type_p=*/0, false); 7409 if (TREE_CODE (TREE_CODE (expr) == TEMPLATE_DECL 7410 ? DECL_TEMPLATE_RESULT (expr) : expr) == TYPE_DECL) 7411 { 7412 if (complain & tf_error) 7413 { 7414 error ("dependent-name `%E' is parsed as a non-type, but " 7415 "instantiation yields a type", qualified_id); 7416 inform ("say `typename %E' if a type is meant", qualified_id); 7417 } 7418 return error_mark_node; 7419 } 7420 } 7421 7422 if (DECL_P (expr)) 7423 check_accessibility_of_qualified_id (expr, /*object_type=*/NULL_TREE, 7424 scope); 7425 7426 /* Remember that there was a reference to this entity. */ 7427 if (DECL_P (expr)) 7428 mark_used (expr); 7429 7430 if (is_template) 7431 expr = lookup_template_function (expr, template_args); 7432 7433 if (expr == error_mark_node && complain & tf_error) 7434 qualified_name_lookup_error (scope, TREE_OPERAND (qualified_id, 1)); 7435 else if (TYPE_P (scope)) 7436 { 7437 expr = (adjust_result_of_qualified_name_lookup 7438 (expr, scope, current_class_type)); 7439 expr = finish_qualified_id_expr (scope, expr, done, address_p); 7440 } 7441 7442 return expr; 7443} 7444 7445/* Like tsubst, but deals with expressions. This function just replaces 7446 template parms; to finish processing the resultant expression, use 7447 tsubst_expr. */ 7448 7449static tree 7450tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl) 7451{ 7452 enum tree_code code; 7453 tree r; 7454 7455 if (t == NULL_TREE || t == error_mark_node) 7456 return t; 7457 7458 code = TREE_CODE (t); 7459 7460 switch (code) 7461 { 7462 case PARM_DECL: 7463 r = retrieve_local_specialization (t); 7464 my_friendly_assert (r != NULL, 20020903); 7465 mark_used (r); 7466 return r; 7467 7468 case CONST_DECL: 7469 { 7470 tree enum_type; 7471 tree v; 7472 7473 if (DECL_TEMPLATE_PARM_P (t)) 7474 return tsubst_copy (DECL_INITIAL (t), args, complain, in_decl); 7475 /* There is no need to substitute into namespace-scope 7476 enumerators. */ 7477 if (DECL_NAMESPACE_SCOPE_P (t)) 7478 return t; 7479 /* If ARGS is NULL, then T is known to be non-dependent. */ 7480 if (args == NULL_TREE) 7481 return decl_constant_value (t); 7482 7483 /* Unfortunately, we cannot just call lookup_name here. 7484 Consider: 7485 7486 template <int I> int f() { 7487 enum E { a = I }; 7488 struct S { void g() { E e = a; } }; 7489 }; 7490 7491 When we instantiate f<7>::S::g(), say, lookup_name is not 7492 clever enough to find f<7>::a. */ 7493 enum_type 7494 = tsubst_aggr_type (TREE_TYPE (t), args, complain, in_decl, 7495 /*entering_scope=*/0); 7496 7497 for (v = TYPE_VALUES (enum_type); 7498 v != NULL_TREE; 7499 v = TREE_CHAIN (v)) 7500 if (TREE_PURPOSE (v) == DECL_NAME (t)) 7501 return TREE_VALUE (v); 7502 7503 /* We didn't find the name. That should never happen; if 7504 name-lookup found it during preliminary parsing, we 7505 should find it again here during instantiation. */ 7506 abort (); 7507 } 7508 return t; 7509 7510 case FIELD_DECL: 7511 if (DECL_CONTEXT (t)) 7512 { 7513 tree ctx; 7514 7515 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, in_decl, 7516 /*entering_scope=*/1); 7517 if (ctx != DECL_CONTEXT (t)) 7518 { 7519 tree r = lookup_field (ctx, DECL_NAME (t), 0, false); 7520 if (!r) 7521 { 7522 if (complain & tf_error) 7523 error ("using invalid field `%D'", t); 7524 return error_mark_node; 7525 } 7526 return r; 7527 } 7528 } 7529 return t; 7530 7531 case VAR_DECL: 7532 case FUNCTION_DECL: 7533 if ((DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t)) 7534 || local_variable_p (t)) 7535 t = tsubst (t, args, complain, in_decl); 7536 mark_used (t); 7537 return t; 7538 7539 case BASELINK: 7540 return tsubst_baselink (t, current_class_type, args, complain, in_decl); 7541 7542 case TEMPLATE_DECL: 7543 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t)) 7544 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t)), 7545 args, complain, in_decl); 7546 else if (is_member_template (t)) 7547 return tsubst (t, args, complain, in_decl); 7548 else if (DECL_CLASS_SCOPE_P (t) 7549 && uses_template_parms (DECL_CONTEXT (t))) 7550 { 7551 /* Template template argument like the following example need 7552 special treatment: 7553 7554 template <template <class> class TT> struct C {}; 7555 template <class T> struct D { 7556 template <class U> struct E {}; 7557 C<E> c; // #1 7558 }; 7559 D<int> d; // #2 7560 7561 We are processing the template argument `E' in #1 for 7562 the template instantiation #2. Originally, `E' is a 7563 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we 7564 have to substitute this with one having context `D<int>'. */ 7565 7566 tree context = tsubst (DECL_CONTEXT (t), args, complain, in_decl); 7567 return lookup_field (context, DECL_NAME(t), 0, false); 7568 } 7569 else 7570 /* Ordinary template template argument. */ 7571 return t; 7572 7573 case CAST_EXPR: 7574 case REINTERPRET_CAST_EXPR: 7575 case CONST_CAST_EXPR: 7576 case STATIC_CAST_EXPR: 7577 case DYNAMIC_CAST_EXPR: 7578 case NOP_EXPR: 7579 return build1 7580 (code, tsubst (TREE_TYPE (t), args, complain, in_decl), 7581 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl)); 7582 7583 case INDIRECT_REF: 7584 case NEGATE_EXPR: 7585 case TRUTH_NOT_EXPR: 7586 case BIT_NOT_EXPR: 7587 case ADDR_EXPR: 7588 case CONVERT_EXPR: /* Unary + */ 7589 case SIZEOF_EXPR: 7590 case ALIGNOF_EXPR: 7591 case ARROW_EXPR: 7592 case THROW_EXPR: 7593 case TYPEID_EXPR: 7594 case REALPART_EXPR: 7595 case IMAGPART_EXPR: 7596 return build1 7597 (code, tsubst (TREE_TYPE (t), args, complain, in_decl), 7598 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl)); 7599 7600 case COMPONENT_REF: 7601 { 7602 tree object; 7603 tree name; 7604 7605 object = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl); 7606 name = TREE_OPERAND (t, 1); 7607 if (TREE_CODE (name) == BIT_NOT_EXPR) 7608 { 7609 name = tsubst_copy (TREE_OPERAND (name, 0), args, 7610 complain, in_decl); 7611 name = build1 (BIT_NOT_EXPR, NULL_TREE, name); 7612 } 7613 else if (TREE_CODE (name) == SCOPE_REF 7614 && TREE_CODE (TREE_OPERAND (name, 1)) == BIT_NOT_EXPR) 7615 { 7616 tree base = tsubst_copy (TREE_OPERAND (name, 0), args, 7617 complain, in_decl); 7618 name = TREE_OPERAND (name, 1); 7619 name = tsubst_copy (TREE_OPERAND (name, 0), args, 7620 complain, in_decl); 7621 name = build1 (BIT_NOT_EXPR, NULL_TREE, name); 7622 name = build_nt (SCOPE_REF, base, name); 7623 } 7624 else if (TREE_CODE (name) == BASELINK) 7625 name = tsubst_baselink (name, 7626 non_reference (TREE_TYPE (object)), 7627 args, complain, 7628 in_decl); 7629 else 7630 name = tsubst_copy (name, args, complain, in_decl); 7631 return build_nt (COMPONENT_REF, object, name); 7632 } 7633 7634 case PLUS_EXPR: 7635 case MINUS_EXPR: 7636 case MULT_EXPR: 7637 case TRUNC_DIV_EXPR: 7638 case CEIL_DIV_EXPR: 7639 case FLOOR_DIV_EXPR: 7640 case ROUND_DIV_EXPR: 7641 case EXACT_DIV_EXPR: 7642 case BIT_AND_EXPR: 7643 case BIT_IOR_EXPR: 7644 case BIT_XOR_EXPR: 7645 case TRUNC_MOD_EXPR: 7646 case FLOOR_MOD_EXPR: 7647 case TRUTH_ANDIF_EXPR: 7648 case TRUTH_ORIF_EXPR: 7649 case TRUTH_AND_EXPR: 7650 case TRUTH_OR_EXPR: 7651 case RSHIFT_EXPR: 7652 case LSHIFT_EXPR: 7653 case RROTATE_EXPR: 7654 case LROTATE_EXPR: 7655 case EQ_EXPR: 7656 case NE_EXPR: 7657 case MAX_EXPR: 7658 case MIN_EXPR: 7659 case LE_EXPR: 7660 case GE_EXPR: 7661 case LT_EXPR: 7662 case GT_EXPR: 7663 case ARRAY_REF: 7664 case COMPOUND_EXPR: 7665 case SCOPE_REF: 7666 case DOTSTAR_EXPR: 7667 case MEMBER_REF: 7668 case PREDECREMENT_EXPR: 7669 case PREINCREMENT_EXPR: 7670 case POSTDECREMENT_EXPR: 7671 case POSTINCREMENT_EXPR: 7672 return build_nt 7673 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl), 7674 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl)); 7675 7676 case CALL_EXPR: 7677 return build_nt (code, 7678 tsubst_copy (TREE_OPERAND (t, 0), args, 7679 complain, in_decl), 7680 tsubst_copy (TREE_OPERAND (t, 1), args, complain, 7681 in_decl), 7682 NULL_TREE); 7683 7684 case STMT_EXPR: 7685 /* This processing should really occur in tsubst_expr. However, 7686 tsubst_expr does not recurse into expressions, since it 7687 assumes that there aren't any statements inside them. So, we 7688 need to expand the STMT_EXPR here. */ 7689 if (!processing_template_decl) 7690 { 7691 tree stmt_expr = begin_stmt_expr (); 7692 7693 tsubst_expr (STMT_EXPR_STMT (t), args, 7694 complain | tf_stmt_expr_cmpd, in_decl); 7695 return finish_stmt_expr (stmt_expr, false); 7696 } 7697 7698 return t; 7699 7700 case COND_EXPR: 7701 case MODOP_EXPR: 7702 case PSEUDO_DTOR_EXPR: 7703 { 7704 r = build_nt 7705 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl), 7706 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl), 7707 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl)); 7708 return r; 7709 } 7710 7711 case NEW_EXPR: 7712 { 7713 r = build_nt 7714 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl), 7715 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl), 7716 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl)); 7717 NEW_EXPR_USE_GLOBAL (r) = NEW_EXPR_USE_GLOBAL (t); 7718 return r; 7719 } 7720 7721 case DELETE_EXPR: 7722 { 7723 r = build_nt 7724 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl), 7725 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl)); 7726 DELETE_EXPR_USE_GLOBAL (r) = DELETE_EXPR_USE_GLOBAL (t); 7727 DELETE_EXPR_USE_VEC (r) = DELETE_EXPR_USE_VEC (t); 7728 return r; 7729 } 7730 7731 case TEMPLATE_ID_EXPR: 7732 { 7733 /* Substituted template arguments */ 7734 tree fn = TREE_OPERAND (t, 0); 7735 tree targs = TREE_OPERAND (t, 1); 7736 7737 fn = tsubst_copy (fn, args, complain, in_decl); 7738 if (targs) 7739 targs = tsubst_template_args (targs, args, complain, in_decl); 7740 7741 return lookup_template_function (fn, targs); 7742 } 7743 7744 case TREE_LIST: 7745 { 7746 tree purpose, value, chain; 7747 7748 if (t == void_list_node) 7749 return t; 7750 7751 purpose = TREE_PURPOSE (t); 7752 if (purpose) 7753 purpose = tsubst_copy (purpose, args, complain, in_decl); 7754 value = TREE_VALUE (t); 7755 if (value) 7756 value = tsubst_copy (value, args, complain, in_decl); 7757 chain = TREE_CHAIN (t); 7758 if (chain && chain != void_type_node) 7759 chain = tsubst_copy (chain, args, complain, in_decl); 7760 if (purpose == TREE_PURPOSE (t) 7761 && value == TREE_VALUE (t) 7762 && chain == TREE_CHAIN (t)) 7763 return t; 7764 return tree_cons (purpose, value, chain); 7765 } 7766 7767 case RECORD_TYPE: 7768 case UNION_TYPE: 7769 case ENUMERAL_TYPE: 7770 case INTEGER_TYPE: 7771 case TEMPLATE_TYPE_PARM: 7772 case TEMPLATE_TEMPLATE_PARM: 7773 case BOUND_TEMPLATE_TEMPLATE_PARM: 7774 case TEMPLATE_PARM_INDEX: 7775 case POINTER_TYPE: 7776 case REFERENCE_TYPE: 7777 case OFFSET_TYPE: 7778 case FUNCTION_TYPE: 7779 case METHOD_TYPE: 7780 case ARRAY_TYPE: 7781 case TYPENAME_TYPE: 7782 case UNBOUND_CLASS_TEMPLATE: 7783 case TYPEOF_TYPE: 7784 case TYPE_DECL: 7785 return tsubst (t, args, complain, in_decl); 7786 7787 case IDENTIFIER_NODE: 7788 if (IDENTIFIER_TYPENAME_P (t)) 7789 { 7790 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl); 7791 return mangle_conv_op_name_for_type (new_type); 7792 } 7793 else 7794 return t; 7795 7796 case CONSTRUCTOR: 7797 { 7798 r = build_constructor 7799 (tsubst (TREE_TYPE (t), args, complain, in_decl), 7800 tsubst_copy (CONSTRUCTOR_ELTS (t), args, complain, in_decl)); 7801 TREE_HAS_CONSTRUCTOR (r) = TREE_HAS_CONSTRUCTOR (t); 7802 return r; 7803 } 7804 7805 case VA_ARG_EXPR: 7806 return build_x_va_arg (tsubst_copy (TREE_OPERAND (t, 0), args, complain, 7807 in_decl), 7808 tsubst (TREE_TYPE (t), args, complain, in_decl)); 7809 7810 case OFFSET_REF: 7811 mark_used (TREE_OPERAND (t, 1)); 7812 return t; 7813 7814 default: 7815 return t; 7816 } 7817} 7818 7819/* Like tsubst_copy for expressions, etc. but also does semantic 7820 processing. */ 7821 7822static tree 7823tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl) 7824{ 7825 tree stmt, tmp; 7826 tsubst_flags_t stmt_expr 7827 = complain & (tf_stmt_expr_cmpd | tf_stmt_expr_body); 7828 7829 complain ^= stmt_expr; 7830 if (t == NULL_TREE || t == error_mark_node) 7831 return t; 7832 7833 if (!STATEMENT_CODE_P (TREE_CODE (t))) 7834 return tsubst_copy_and_build (t, args, complain, in_decl, 7835 /*function_p=*/false); 7836 7837 switch (TREE_CODE (t)) 7838 { 7839 case CTOR_INITIALIZER: 7840 prep_stmt (t); 7841 finish_mem_initializers (tsubst_initializer_list 7842 (TREE_OPERAND (t, 0), args)); 7843 break; 7844 7845 case RETURN_STMT: 7846 prep_stmt (t); 7847 finish_return_stmt (tsubst_expr (RETURN_STMT_EXPR (t), 7848 args, complain, in_decl)); 7849 break; 7850 7851 case EXPR_STMT: 7852 { 7853 tree r; 7854 7855 prep_stmt (t); 7856 7857 r = tsubst_expr (EXPR_STMT_EXPR (t), args, complain, in_decl); 7858 if (stmt_expr & tf_stmt_expr_body && !TREE_CHAIN (t)) 7859 finish_stmt_expr_expr (r); 7860 else 7861 finish_expr_stmt (r); 7862 break; 7863 } 7864 7865 case USING_STMT: 7866 prep_stmt (t); 7867 do_using_directive (tsubst_expr (USING_STMT_NAMESPACE (t), 7868 args, complain, in_decl)); 7869 break; 7870 7871 case DECL_STMT: 7872 { 7873 tree decl; 7874 tree init; 7875 7876 prep_stmt (t); 7877 decl = DECL_STMT_DECL (t); 7878 if (TREE_CODE (decl) == LABEL_DECL) 7879 finish_label_decl (DECL_NAME (decl)); 7880 else if (TREE_CODE (decl) == USING_DECL) 7881 { 7882 tree scope = DECL_INITIAL (decl); 7883 tree name = DECL_NAME (decl); 7884 tree decl; 7885 7886 scope = tsubst_expr (scope, args, complain, in_decl); 7887 decl = lookup_qualified_name (scope, name, 7888 /*is_type_p=*/false, 7889 /*complain=*/false); 7890 if (decl == error_mark_node) 7891 qualified_name_lookup_error (scope, name); 7892 else 7893 do_local_using_decl (decl, scope, name); 7894 } 7895 else 7896 { 7897 init = DECL_INITIAL (decl); 7898 decl = tsubst (decl, args, complain, in_decl); 7899 if (decl != error_mark_node) 7900 { 7901 if (init) 7902 DECL_INITIAL (decl) = error_mark_node; 7903 /* By marking the declaration as instantiated, we avoid 7904 trying to instantiate it. Since instantiate_decl can't 7905 handle local variables, and since we've already done 7906 all that needs to be done, that's the right thing to 7907 do. */ 7908 if (TREE_CODE (decl) == VAR_DECL) 7909 DECL_TEMPLATE_INSTANTIATED (decl) = 1; 7910 if (TREE_CODE (decl) == VAR_DECL 7911 && ANON_AGGR_TYPE_P (TREE_TYPE (decl))) 7912 /* Anonymous aggregates are a special case. */ 7913 finish_anon_union (decl); 7914 else 7915 { 7916 maybe_push_decl (decl); 7917 if (TREE_CODE (decl) == VAR_DECL 7918 && DECL_PRETTY_FUNCTION_P (decl)) 7919 { 7920 /* For __PRETTY_FUNCTION__ we have to adjust the 7921 initializer. */ 7922 const char *const name 7923 = cxx_printable_name (current_function_decl, 2); 7924 init = cp_fname_init (name, &TREE_TYPE (decl)); 7925 } 7926 else 7927 init = tsubst_expr (init, args, complain, in_decl); 7928 cp_finish_decl (decl, init, NULL_TREE, 0); 7929 } 7930 } 7931 } 7932 7933 /* A DECL_STMT can also be used as an expression, in the condition 7934 clause of an if/for/while construct. If we aren't followed by 7935 another statement, return our decl. */ 7936 if (TREE_CHAIN (t) == NULL_TREE) 7937 return decl; 7938 } 7939 break; 7940 7941 case FOR_STMT: 7942 { 7943 prep_stmt (t); 7944 7945 stmt = begin_for_stmt (); 7946 tsubst_expr (FOR_INIT_STMT (t), args, complain, in_decl); 7947 finish_for_init_stmt (stmt); 7948 finish_for_cond (tsubst_expr (FOR_COND (t), 7949 args, complain, in_decl), 7950 stmt); 7951 tmp = tsubst_expr (FOR_EXPR (t), args, complain, in_decl); 7952 finish_for_expr (tmp, stmt); 7953 tsubst_expr (FOR_BODY (t), args, complain, in_decl); 7954 finish_for_stmt (stmt); 7955 } 7956 break; 7957 7958 case WHILE_STMT: 7959 { 7960 prep_stmt (t); 7961 stmt = begin_while_stmt (); 7962 finish_while_stmt_cond (tsubst_expr (WHILE_COND (t), 7963 args, complain, in_decl), 7964 stmt); 7965 tsubst_expr (WHILE_BODY (t), args, complain, in_decl); 7966 finish_while_stmt (stmt); 7967 } 7968 break; 7969 7970 case DO_STMT: 7971 { 7972 prep_stmt (t); 7973 stmt = begin_do_stmt (); 7974 tsubst_expr (DO_BODY (t), args, complain, in_decl); 7975 finish_do_body (stmt); 7976 finish_do_stmt (tsubst_expr (DO_COND (t), 7977 args, complain, in_decl), 7978 stmt); 7979 } 7980 break; 7981 7982 case IF_STMT: 7983 { 7984 prep_stmt (t); 7985 stmt = begin_if_stmt (); 7986 finish_if_stmt_cond (tsubst_expr (IF_COND (t), 7987 args, complain, in_decl), 7988 stmt); 7989 7990 if (tmp = THEN_CLAUSE (t), tmp) 7991 { 7992 tsubst_expr (tmp, args, complain, in_decl); 7993 finish_then_clause (stmt); 7994 } 7995 7996 if (tmp = ELSE_CLAUSE (t), tmp) 7997 { 7998 begin_else_clause (); 7999 tsubst_expr (tmp, args, complain, in_decl); 8000 finish_else_clause (stmt); 8001 } 8002 8003 finish_if_stmt (); 8004 } 8005 break; 8006 8007 case COMPOUND_STMT: 8008 { 8009 prep_stmt (t); 8010 if (COMPOUND_STMT_BODY_BLOCK (t)) 8011 stmt = begin_function_body (); 8012 else 8013 stmt = begin_compound_stmt (COMPOUND_STMT_NO_SCOPE (t)); 8014 8015 tsubst_expr (COMPOUND_BODY (t), args, 8016 complain | ((stmt_expr & tf_stmt_expr_cmpd) << 1), 8017 in_decl); 8018 8019 if (COMPOUND_STMT_BODY_BLOCK (t)) 8020 finish_function_body (stmt); 8021 else 8022 finish_compound_stmt (stmt); 8023 } 8024 break; 8025 8026 case BREAK_STMT: 8027 prep_stmt (t); 8028 finish_break_stmt (); 8029 break; 8030 8031 case CONTINUE_STMT: 8032 prep_stmt (t); 8033 finish_continue_stmt (); 8034 break; 8035 8036 case SWITCH_STMT: 8037 { 8038 tree val; 8039 8040 prep_stmt (t); 8041 stmt = begin_switch_stmt (); 8042 val = tsubst_expr (SWITCH_COND (t), args, complain, in_decl); 8043 finish_switch_cond (val, stmt); 8044 tsubst_expr (SWITCH_BODY (t), args, complain, in_decl); 8045 finish_switch_stmt (stmt); 8046 } 8047 break; 8048 8049 case CASE_LABEL: 8050 prep_stmt (t); 8051 finish_case_label (tsubst_expr (CASE_LOW (t), args, complain, in_decl), 8052 tsubst_expr (CASE_HIGH (t), args, complain, 8053 in_decl)); 8054 break; 8055 8056 case LABEL_STMT: 8057 input_line = STMT_LINENO (t); 8058 finish_label_stmt (DECL_NAME (LABEL_STMT_LABEL (t))); 8059 break; 8060 8061 case FILE_STMT: 8062 input_filename = FILE_STMT_FILENAME (t); 8063 add_stmt (build_nt (FILE_STMT, FILE_STMT_FILENAME_NODE (t))); 8064 break; 8065 8066 case GOTO_STMT: 8067 prep_stmt (t); 8068 tmp = GOTO_DESTINATION (t); 8069 if (TREE_CODE (tmp) != LABEL_DECL) 8070 /* Computed goto's must be tsubst'd into. On the other hand, 8071 non-computed gotos must not be; the identifier in question 8072 will have no binding. */ 8073 tmp = tsubst_expr (tmp, args, complain, in_decl); 8074 else 8075 tmp = DECL_NAME (tmp); 8076 finish_goto_stmt (tmp); 8077 break; 8078 8079 case ASM_STMT: 8080 prep_stmt (t); 8081 tmp = finish_asm_stmt 8082 (ASM_CV_QUAL (t), 8083 tsubst_expr (ASM_STRING (t), args, complain, in_decl), 8084 tsubst_expr (ASM_OUTPUTS (t), args, complain, in_decl), 8085 tsubst_expr (ASM_INPUTS (t), args, complain, in_decl), 8086 tsubst_expr (ASM_CLOBBERS (t), args, complain, in_decl)); 8087 ASM_INPUT_P (tmp) = ASM_INPUT_P (t); 8088 break; 8089 8090 case TRY_BLOCK: 8091 prep_stmt (t); 8092 if (CLEANUP_P (t)) 8093 { 8094 stmt = begin_try_block (); 8095 tsubst_expr (TRY_STMTS (t), args, complain, in_decl); 8096 finish_cleanup_try_block (stmt); 8097 finish_cleanup (tsubst_expr (TRY_HANDLERS (t), args, 8098 complain, in_decl), 8099 stmt); 8100 } 8101 else 8102 { 8103 if (FN_TRY_BLOCK_P (t)) 8104 stmt = begin_function_try_block (); 8105 else 8106 stmt = begin_try_block (); 8107 8108 tsubst_expr (TRY_STMTS (t), args, complain, in_decl); 8109 8110 if (FN_TRY_BLOCK_P (t)) 8111 finish_function_try_block (stmt); 8112 else 8113 finish_try_block (stmt); 8114 8115 tsubst_expr (TRY_HANDLERS (t), args, complain, in_decl); 8116 if (FN_TRY_BLOCK_P (t)) 8117 finish_function_handler_sequence (stmt); 8118 else 8119 finish_handler_sequence (stmt); 8120 } 8121 break; 8122 8123 case HANDLER: 8124 { 8125 tree decl; 8126 8127 prep_stmt (t); 8128 stmt = begin_handler (); 8129 if (HANDLER_PARMS (t)) 8130 { 8131 decl = DECL_STMT_DECL (HANDLER_PARMS (t)); 8132 decl = tsubst (decl, args, complain, in_decl); 8133 /* Prevent instantiate_decl from trying to instantiate 8134 this variable. We've already done all that needs to be 8135 done. */ 8136 DECL_TEMPLATE_INSTANTIATED (decl) = 1; 8137 } 8138 else 8139 decl = NULL_TREE; 8140 finish_handler_parms (decl, stmt); 8141 tsubst_expr (HANDLER_BODY (t), args, complain, in_decl); 8142 finish_handler (stmt); 8143 } 8144 break; 8145 8146 case TAG_DEFN: 8147 prep_stmt (t); 8148 tsubst (TREE_TYPE (t), args, complain, NULL_TREE); 8149 break; 8150 8151 default: 8152 abort (); 8153 } 8154 8155 return tsubst_expr (TREE_CHAIN (t), args, complain | stmt_expr, in_decl); 8156} 8157 8158/* T is a postfix-expression that is not being used in a function 8159 call. Return the substituted version of T. */ 8160 8161static tree 8162tsubst_non_call_postfix_expression (tree t, tree args, 8163 tsubst_flags_t complain, 8164 tree in_decl) 8165{ 8166 if (TREE_CODE (t) == SCOPE_REF) 8167 t = tsubst_qualified_id (t, args, complain, in_decl, 8168 /*done=*/false, /*address_p=*/false); 8169 else 8170 t = tsubst_copy_and_build (t, args, complain, in_decl, 8171 /*function_p=*/false); 8172 8173 return t; 8174} 8175 8176/* Like tsubst but deals with expressions and performs semantic 8177 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */ 8178 8179tree 8180tsubst_copy_and_build (tree t, 8181 tree args, 8182 tsubst_flags_t complain, 8183 tree in_decl, 8184 bool function_p) 8185{ 8186#define RECUR(NODE) \ 8187 tsubst_copy_and_build (NODE, args, complain, in_decl, /*function_p=*/false) 8188 8189 tree op1; 8190 8191 if (t == NULL_TREE || t == error_mark_node) 8192 return t; 8193 8194 switch (TREE_CODE (t)) 8195 { 8196 case USING_DECL: 8197 t = DECL_NAME (t); 8198 /* Fallthrough. */ 8199 case IDENTIFIER_NODE: 8200 { 8201 tree decl; 8202 cp_id_kind idk; 8203 tree qualifying_class; 8204 bool non_integral_constant_expression_p; 8205 const char *error_msg; 8206 8207 if (IDENTIFIER_TYPENAME_P (t)) 8208 { 8209 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl); 8210 t = mangle_conv_op_name_for_type (new_type); 8211 } 8212 8213 /* Look up the name. */ 8214 decl = lookup_name (t, 0); 8215 8216 /* By convention, expressions use ERROR_MARK_NODE to indicate 8217 failure, not NULL_TREE. */ 8218 if (decl == NULL_TREE) 8219 decl = error_mark_node; 8220 8221 decl = finish_id_expression (t, decl, NULL_TREE, 8222 &idk, 8223 &qualifying_class, 8224 /*integral_constant_expression_p=*/false, 8225 /*allow_non_integral_constant_expression_p=*/false, 8226 &non_integral_constant_expression_p, 8227 &error_msg); 8228 if (error_msg) 8229 error (error_msg); 8230 if (!function_p && TREE_CODE (decl) == IDENTIFIER_NODE) 8231 decl = unqualified_name_lookup_error (decl); 8232 return decl; 8233 } 8234 8235 case TEMPLATE_ID_EXPR: 8236 { 8237 tree object; 8238 tree template = RECUR (TREE_OPERAND (t, 0)); 8239 tree targs = TREE_OPERAND (t, 1); 8240 8241 if (targs) 8242 targs = tsubst_template_args (targs, args, complain, in_decl); 8243 8244 if (TREE_CODE (template) == COMPONENT_REF) 8245 { 8246 object = TREE_OPERAND (template, 0); 8247 template = TREE_OPERAND (template, 1); 8248 } 8249 else 8250 object = NULL_TREE; 8251 template = lookup_template_function (template, targs); 8252 8253 if (object) 8254 return build (COMPONENT_REF, TREE_TYPE (template), 8255 object, template); 8256 else 8257 return template; 8258 } 8259 8260 case INDIRECT_REF: 8261 return build_x_indirect_ref (RECUR (TREE_OPERAND (t, 0)), "unary *"); 8262 8263 case NOP_EXPR: 8264 return build_nop 8265 (tsubst (TREE_TYPE (t), args, complain, in_decl), 8266 RECUR (TREE_OPERAND (t, 0))); 8267 8268 case CAST_EXPR: 8269 return build_functional_cast 8270 (tsubst (TREE_TYPE (t), args, complain, in_decl), 8271 RECUR (TREE_OPERAND (t, 0))); 8272 8273 case REINTERPRET_CAST_EXPR: 8274 return build_reinterpret_cast 8275 (tsubst (TREE_TYPE (t), args, complain, in_decl), 8276 RECUR (TREE_OPERAND (t, 0))); 8277 8278 case CONST_CAST_EXPR: 8279 return build_const_cast 8280 (tsubst (TREE_TYPE (t), args, complain, in_decl), 8281 RECUR (TREE_OPERAND (t, 0))); 8282 8283 case DYNAMIC_CAST_EXPR: 8284 return build_dynamic_cast 8285 (tsubst (TREE_TYPE (t), args, complain, in_decl), 8286 RECUR (TREE_OPERAND (t, 0))); 8287 8288 case STATIC_CAST_EXPR: 8289 return build_static_cast 8290 (tsubst (TREE_TYPE (t), args, complain, in_decl), 8291 RECUR (TREE_OPERAND (t, 0))); 8292 8293 case POSTDECREMENT_EXPR: 8294 case POSTINCREMENT_EXPR: 8295 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0), 8296 args, complain, in_decl); 8297 return build_x_unary_op (TREE_CODE (t), op1); 8298 8299 case PREDECREMENT_EXPR: 8300 case PREINCREMENT_EXPR: 8301 case NEGATE_EXPR: 8302 case BIT_NOT_EXPR: 8303 case ABS_EXPR: 8304 case TRUTH_NOT_EXPR: 8305 case CONVERT_EXPR: /* Unary + */ 8306 case REALPART_EXPR: 8307 case IMAGPART_EXPR: 8308 return build_x_unary_op (TREE_CODE (t), RECUR (TREE_OPERAND (t, 0))); 8309 8310 case ADDR_EXPR: 8311 op1 = TREE_OPERAND (t, 0); 8312 if (TREE_CODE (op1) == SCOPE_REF) 8313 op1 = tsubst_qualified_id (op1, args, complain, in_decl, 8314 /*done=*/true, /*address_p=*/true); 8315 else 8316 op1 = tsubst_non_call_postfix_expression (op1, args, complain, 8317 in_decl); 8318 if (TREE_CODE (op1) == LABEL_DECL) 8319 return finish_label_address_expr (DECL_NAME (op1)); 8320 return build_x_unary_op (ADDR_EXPR, op1); 8321 8322 case PLUS_EXPR: 8323 case MINUS_EXPR: 8324 case MULT_EXPR: 8325 case TRUNC_DIV_EXPR: 8326 case CEIL_DIV_EXPR: 8327 case FLOOR_DIV_EXPR: 8328 case ROUND_DIV_EXPR: 8329 case EXACT_DIV_EXPR: 8330 case BIT_AND_EXPR: 8331 case BIT_IOR_EXPR: 8332 case BIT_XOR_EXPR: 8333 case TRUNC_MOD_EXPR: 8334 case FLOOR_MOD_EXPR: 8335 case TRUTH_ANDIF_EXPR: 8336 case TRUTH_ORIF_EXPR: 8337 case TRUTH_AND_EXPR: 8338 case TRUTH_OR_EXPR: 8339 case RSHIFT_EXPR: 8340 case LSHIFT_EXPR: 8341 case RROTATE_EXPR: 8342 case LROTATE_EXPR: 8343 case EQ_EXPR: 8344 case NE_EXPR: 8345 case MAX_EXPR: 8346 case MIN_EXPR: 8347 case LE_EXPR: 8348 case GE_EXPR: 8349 case LT_EXPR: 8350 case GT_EXPR: 8351 case MEMBER_REF: 8352 case DOTSTAR_EXPR: 8353 return build_x_binary_op 8354 (TREE_CODE (t), 8355 RECUR (TREE_OPERAND (t, 0)), 8356 RECUR (TREE_OPERAND (t, 1)), 8357 /*overloaded_p=*/NULL); 8358 8359 case SCOPE_REF: 8360 return tsubst_qualified_id (t, args, complain, in_decl, /*done=*/true, 8361 /*address_p=*/false); 8362 8363 case ARRAY_REF: 8364 if (tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl) 8365 == NULL_TREE) 8366 /* new-type-id */ 8367 return build_nt (ARRAY_REF, NULL_TREE, RECUR (TREE_OPERAND (t, 1))); 8368 8369 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0), 8370 args, complain, in_decl); 8371 /* Remember that there was a reference to this entity. */ 8372 if (DECL_P (op1)) 8373 mark_used (op1); 8374 return grok_array_decl (op1, RECUR (TREE_OPERAND (t, 1))); 8375 8376 case SIZEOF_EXPR: 8377 case ALIGNOF_EXPR: 8378 op1 = TREE_OPERAND (t, 0); 8379 if (!args) 8380 { 8381 /* When there are no ARGS, we are trying to evaluate a 8382 non-dependent expression from the parser. Trying to do 8383 the substitutions may not work. */ 8384 if (!TYPE_P (op1)) 8385 op1 = TREE_TYPE (op1); 8386 } 8387 else 8388 { 8389 ++skip_evaluation; 8390 op1 = RECUR (op1); 8391 --skip_evaluation; 8392 } 8393 if (TYPE_P (op1)) 8394 return cxx_sizeof_or_alignof_type (op1, TREE_CODE (t), true); 8395 else 8396 return cxx_sizeof_or_alignof_expr (op1, TREE_CODE (t)); 8397 8398 case MODOP_EXPR: 8399 return build_x_modify_expr 8400 (RECUR (TREE_OPERAND (t, 0)), 8401 TREE_CODE (TREE_OPERAND (t, 1)), 8402 RECUR (TREE_OPERAND (t, 2))); 8403 8404 case ARROW_EXPR: 8405 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0), 8406 args, complain, in_decl); 8407 /* Remember that there was a reference to this entity. */ 8408 if (DECL_P (op1)) 8409 mark_used (op1); 8410 return build_x_arrow (op1); 8411 8412 case NEW_EXPR: 8413 return build_new 8414 (RECUR (TREE_OPERAND (t, 0)), 8415 RECUR (TREE_OPERAND (t, 1)), 8416 RECUR (TREE_OPERAND (t, 2)), 8417 NEW_EXPR_USE_GLOBAL (t)); 8418 8419 case DELETE_EXPR: 8420 return delete_sanity 8421 (RECUR (TREE_OPERAND (t, 0)), 8422 RECUR (TREE_OPERAND (t, 1)), 8423 DELETE_EXPR_USE_VEC (t), 8424 DELETE_EXPR_USE_GLOBAL (t)); 8425 8426 case COMPOUND_EXPR: 8427 return build_x_compound_expr (RECUR (TREE_OPERAND (t, 0)), 8428 RECUR (TREE_OPERAND (t, 1))); 8429 8430 case CALL_EXPR: 8431 { 8432 tree function; 8433 tree call_args; 8434 bool qualified_p; 8435 bool koenig_p; 8436 8437 function = TREE_OPERAND (t, 0); 8438 /* When we parsed the expression, we determined whether or 8439 not Koenig lookup should be performed. */ 8440 koenig_p = KOENIG_LOOKUP_P (t); 8441 if (TREE_CODE (function) == SCOPE_REF) 8442 { 8443 qualified_p = true; 8444 function = tsubst_qualified_id (function, args, complain, in_decl, 8445 /*done=*/false, 8446 /*address_p=*/false); 8447 } 8448 else 8449 { 8450 qualified_p = (TREE_CODE (function) == COMPONENT_REF 8451 && (TREE_CODE (TREE_OPERAND (function, 1)) 8452 == SCOPE_REF)); 8453 function = tsubst_copy_and_build (function, args, complain, 8454 in_decl, 8455 !qualified_p); 8456 if (BASELINK_P (function)) 8457 qualified_p = true; 8458 } 8459 8460 call_args = RECUR (TREE_OPERAND (t, 1)); 8461 8462 /* We do not perform argument-dependent lookup if normal 8463 lookup finds a non-function, in accordance with the 8464 expected resolution of DR 218. */ 8465 if (koenig_p 8466 && ((is_overloaded_fn (function) 8467 /* If lookup found a member function, the Koenig lookup is 8468 not appropriate, even if an unqualified-name was used 8469 to denote the function. */ 8470 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function))) 8471 || TREE_CODE (function) == IDENTIFIER_NODE)) 8472 function = perform_koenig_lookup (function, call_args); 8473 8474 if (TREE_CODE (function) == IDENTIFIER_NODE) 8475 { 8476 unqualified_name_lookup_error (function); 8477 return error_mark_node; 8478 } 8479 8480 /* Remember that there was a reference to this entity. */ 8481 if (DECL_P (function)) 8482 mark_used (function); 8483 8484 function = convert_from_reference (function); 8485 8486 if (TREE_CODE (function) == OFFSET_REF) 8487 return build_offset_ref_call_from_tree (function, call_args); 8488 if (TREE_CODE (function) == COMPONENT_REF) 8489 { 8490 if (!BASELINK_P (TREE_OPERAND (function, 1))) 8491 return finish_call_expr (function, call_args, 8492 /*disallow_virtual=*/false, 8493 /*koenig_p=*/false); 8494 else 8495 return (build_new_method_call 8496 (TREE_OPERAND (function, 0), 8497 TREE_OPERAND (function, 1), 8498 call_args, NULL_TREE, 8499 qualified_p ? LOOKUP_NONVIRTUAL : LOOKUP_NORMAL)); 8500 } 8501 return finish_call_expr (function, call_args, 8502 /*disallow_virtual=*/qualified_p, 8503 koenig_p); 8504 } 8505 8506 case COND_EXPR: 8507 return build_x_conditional_expr 8508 (RECUR (TREE_OPERAND (t, 0)), 8509 RECUR (TREE_OPERAND (t, 1)), 8510 RECUR (TREE_OPERAND (t, 2))); 8511 8512 case PSEUDO_DTOR_EXPR: 8513 return finish_pseudo_destructor_expr 8514 (RECUR (TREE_OPERAND (t, 0)), 8515 RECUR (TREE_OPERAND (t, 1)), 8516 RECUR (TREE_OPERAND (t, 2))); 8517 8518 case TREE_LIST: 8519 { 8520 tree purpose, value, chain; 8521 8522 if (t == void_list_node) 8523 return t; 8524 8525 purpose = TREE_PURPOSE (t); 8526 if (purpose) 8527 purpose = RECUR (purpose); 8528 value = TREE_VALUE (t); 8529 if (value) 8530 value = RECUR (value); 8531 chain = TREE_CHAIN (t); 8532 if (chain && chain != void_type_node) 8533 chain = RECUR (chain); 8534 if (purpose == TREE_PURPOSE (t) 8535 && value == TREE_VALUE (t) 8536 && chain == TREE_CHAIN (t)) 8537 return t; 8538 return tree_cons (purpose, value, chain); 8539 } 8540 8541 case COMPONENT_REF: 8542 { 8543 tree object; 8544 tree member; 8545 8546 object = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0), 8547 args, complain, in_decl); 8548 /* Remember that there was a reference to this entity. */ 8549 if (DECL_P (object)) 8550 mark_used (object); 8551 8552 member = TREE_OPERAND (t, 1); 8553 if (BASELINK_P (member)) 8554 member = tsubst_baselink (member, 8555 non_reference (TREE_TYPE (object)), 8556 args, complain, in_decl); 8557 else 8558 member = tsubst_copy (member, args, complain, in_decl); 8559 8560 if (member == error_mark_node) 8561 return error_mark_node; 8562 else if (!CLASS_TYPE_P (TREE_TYPE (object))) 8563 { 8564 if (TREE_CODE (member) == BIT_NOT_EXPR) 8565 return finish_pseudo_destructor_expr (object, 8566 NULL_TREE, 8567 TREE_TYPE (object)); 8568 else if (TREE_CODE (member) == SCOPE_REF 8569 && (TREE_CODE (TREE_OPERAND (member, 1)) == BIT_NOT_EXPR)) 8570 return finish_pseudo_destructor_expr (object, 8571 object, 8572 TREE_TYPE (object)); 8573 } 8574 else if (TREE_CODE (member) == SCOPE_REF 8575 && TREE_CODE (TREE_OPERAND (member, 1)) == TEMPLATE_ID_EXPR) 8576 { 8577 tree tmpl; 8578 tree args; 8579 8580 /* Lookup the template functions now that we know what the 8581 scope is. */ 8582 tmpl = TREE_OPERAND (TREE_OPERAND (member, 1), 0); 8583 args = TREE_OPERAND (TREE_OPERAND (member, 1), 1); 8584 member = lookup_qualified_name (TREE_OPERAND (member, 0), tmpl, 8585 /*is_type_p=*/false, 8586 /*complain=*/false); 8587 if (BASELINK_P (member)) 8588 { 8589 BASELINK_FUNCTIONS (member) 8590 = build_nt (TEMPLATE_ID_EXPR, BASELINK_FUNCTIONS (member), 8591 args); 8592 member = (adjust_result_of_qualified_name_lookup 8593 (member, BINFO_TYPE (BASELINK_BINFO (member)), 8594 TREE_TYPE (object))); 8595 } 8596 else 8597 { 8598 qualified_name_lookup_error (TREE_TYPE (object), tmpl); 8599 return error_mark_node; 8600 } 8601 } 8602 else if (TREE_CODE (member) == SCOPE_REF 8603 && !CLASS_TYPE_P (TREE_OPERAND (member, 0)) 8604 && TREE_CODE (TREE_OPERAND (member, 0)) != NAMESPACE_DECL) 8605 { 8606 if (complain & tf_error) 8607 { 8608 if (TYPE_P (TREE_OPERAND (member, 0))) 8609 error ("`%T' is not a class or namespace", 8610 TREE_OPERAND (member, 0)); 8611 else 8612 error ("`%D' is not a class or namespace", 8613 TREE_OPERAND (member, 0)); 8614 } 8615 return error_mark_node; 8616 } 8617 else if (TREE_CODE (member) == FIELD_DECL) 8618 return finish_non_static_data_member (member, object, NULL_TREE); 8619 8620 return finish_class_member_access_expr (object, member); 8621 } 8622 8623 case THROW_EXPR: 8624 return build_throw 8625 (RECUR (TREE_OPERAND (t, 0))); 8626 8627 case CONSTRUCTOR: 8628 { 8629 tree r; 8630 tree elts; 8631 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl); 8632 bool purpose_p; 8633 8634 /* digest_init will do the wrong thing if we let it. */ 8635 if (type && TYPE_PTRMEMFUNC_P (type)) 8636 return t; 8637 8638 r = NULL_TREE; 8639 /* We do not want to process the purpose of aggregate 8640 initializers as they are identifier nodes which will be 8641 looked up by digest_init. */ 8642 purpose_p = !(type && IS_AGGR_TYPE (type)); 8643 for (elts = CONSTRUCTOR_ELTS (t); 8644 elts; 8645 elts = TREE_CHAIN (elts)) 8646 { 8647 tree purpose = TREE_PURPOSE (elts); 8648 tree value = TREE_VALUE (elts); 8649 8650 if (purpose && purpose_p) 8651 purpose = RECUR (purpose); 8652 value = RECUR (value); 8653 r = tree_cons (purpose, value, r); 8654 } 8655 8656 r = build_constructor (NULL_TREE, nreverse (r)); 8657 TREE_HAS_CONSTRUCTOR (r) = TREE_HAS_CONSTRUCTOR (t); 8658 8659 if (type) 8660 return digest_init (type, r, 0); 8661 return r; 8662 } 8663 8664 case TYPEID_EXPR: 8665 { 8666 tree operand_0 = RECUR (TREE_OPERAND (t, 0)); 8667 if (TYPE_P (operand_0)) 8668 return get_typeid (operand_0); 8669 return build_typeid (operand_0); 8670 } 8671 8672 case PARM_DECL: 8673 return convert_from_reference (tsubst_copy (t, args, complain, in_decl)); 8674 8675 case VAR_DECL: 8676 if (args) 8677 t = tsubst_copy (t, args, complain, in_decl); 8678 return convert_from_reference (t); 8679 8680 case VA_ARG_EXPR: 8681 return build_x_va_arg (RECUR (TREE_OPERAND (t, 0)), 8682 tsubst_copy (TREE_TYPE (t), args, complain, 8683 in_decl)); 8684 8685 case CONST_DECL: 8686 t = tsubst_copy (t, args, complain, in_decl); 8687 /* As in finish_id_expression, we resolve enumeration constants 8688 to their underlying values. */ 8689 if (TREE_CODE (t) == CONST_DECL) 8690 return DECL_INITIAL (t); 8691 return t; 8692 8693 default: 8694 return tsubst_copy (t, args, complain, in_decl); 8695 } 8696 8697#undef RECUR 8698} 8699 8700/* Verify that the instantiated ARGS are valid. For type arguments, 8701 make sure that the type's linkage is ok. For non-type arguments, 8702 make sure they are constants if they are integral or enumerations. 8703 Emit an error under control of COMPLAIN, and return TRUE on error. */ 8704 8705static bool 8706check_instantiated_args (tree tmpl, tree args, tsubst_flags_t complain) 8707{ 8708 int ix, len = DECL_NTPARMS (tmpl); 8709 bool result = false; 8710 8711 for (ix = 0; ix != len; ix++) 8712 { 8713 tree t = TREE_VEC_ELT (args, ix); 8714 8715 if (TYPE_P (t)) 8716 { 8717 /* [basic.link]: A name with no linkage (notably, the name 8718 of a class or enumeration declared in a local scope) 8719 shall not be used to declare an entity with linkage. 8720 This implies that names with no linkage cannot be used as 8721 template arguments. */ 8722 tree nt = no_linkage_check (t); 8723 8724 if (nt) 8725 { 8726 if (!(complain & tf_error)) 8727 /*OK*/; 8728 else if (TYPE_ANONYMOUS_P (nt)) 8729 error ("`%T' uses anonymous type", t); 8730 else 8731 error ("`%T' uses local type `%T'", t, nt); 8732 result = true; 8733 } 8734 /* In order to avoid all sorts of complications, we do not 8735 allow variably-modified types as template arguments. */ 8736 else if (variably_modified_type_p (t)) 8737 { 8738 if (complain & tf_error) 8739 error ("`%T' is a variably modified type", t); 8740 result = true; 8741 } 8742 } 8743 /* A non-type argument of integral or enumerated type must be a 8744 constant. */ 8745 else if (TREE_TYPE (t) 8746 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t)) 8747 && !TREE_CONSTANT (t)) 8748 { 8749 if (complain & tf_error) 8750 error ("integral expression `%E' is not constant", t); 8751 result = true; 8752 } 8753 } 8754 if (result && complain & tf_error) 8755 error (" trying to instantiate `%D'", tmpl); 8756 return result; 8757} 8758 8759/* Instantiate the indicated variable or function template TMPL with 8760 the template arguments in TARG_PTR. */ 8761 8762tree 8763instantiate_template (tree tmpl, tree targ_ptr, tsubst_flags_t complain) 8764{ 8765 tree fndecl; 8766 tree gen_tmpl; 8767 tree spec; 8768 8769 if (tmpl == error_mark_node) 8770 return error_mark_node; 8771 8772 my_friendly_assert (TREE_CODE (tmpl) == TEMPLATE_DECL, 283); 8773 8774 /* If this function is a clone, handle it specially. */ 8775 if (DECL_CLONED_FUNCTION_P (tmpl)) 8776 { 8777 tree spec; 8778 tree clone; 8779 8780 spec = instantiate_template (DECL_CLONED_FUNCTION (tmpl), targ_ptr, 8781 complain); 8782 if (spec == error_mark_node) 8783 return error_mark_node; 8784 8785 /* Look for the clone. */ 8786 for (clone = TREE_CHAIN (spec); 8787 clone && DECL_CLONED_FUNCTION_P (clone); 8788 clone = TREE_CHAIN (clone)) 8789 if (DECL_NAME (clone) == DECL_NAME (tmpl)) 8790 return clone; 8791 /* We should always have found the clone by now. */ 8792 abort (); 8793 return NULL_TREE; 8794 } 8795 8796 /* Check to see if we already have this specialization. */ 8797 spec = retrieve_specialization (tmpl, targ_ptr); 8798 if (spec != NULL_TREE) 8799 return spec; 8800 8801 gen_tmpl = most_general_template (tmpl); 8802 if (tmpl != gen_tmpl) 8803 { 8804 /* The TMPL is a partial instantiation. To get a full set of 8805 arguments we must add the arguments used to perform the 8806 partial instantiation. */ 8807 targ_ptr = add_outermost_template_args (DECL_TI_ARGS (tmpl), 8808 targ_ptr); 8809 8810 /* Check to see if we already have this specialization. */ 8811 spec = retrieve_specialization (gen_tmpl, targ_ptr); 8812 if (spec != NULL_TREE) 8813 return spec; 8814 } 8815 8816 if (check_instantiated_args (gen_tmpl, INNERMOST_TEMPLATE_ARGS (targ_ptr), 8817 complain)) 8818 return error_mark_node; 8819 8820 /* We are building a FUNCTION_DECL, during which the access of its 8821 parameters and return types have to be checked. However this 8822 FUNCTION_DECL which is the desired context for access checking 8823 is not built yet. We solve this chicken-and-egg problem by 8824 deferring all checks until we have the FUNCTION_DECL. */ 8825 push_deferring_access_checks (dk_deferred); 8826 8827 /* Substitute template parameters. */ 8828 fndecl = tsubst (DECL_TEMPLATE_RESULT (gen_tmpl), 8829 targ_ptr, complain, gen_tmpl); 8830 8831 /* Now we know the specialization, compute access previously 8832 deferred. */ 8833 push_access_scope (fndecl); 8834 perform_deferred_access_checks (); 8835 pop_access_scope (fndecl); 8836 pop_deferring_access_checks (); 8837 8838 /* The DECL_TI_TEMPLATE should always be the immediate parent 8839 template, not the most general template. */ 8840 DECL_TI_TEMPLATE (fndecl) = tmpl; 8841 8842 /* If we've just instantiated the main entry point for a function, 8843 instantiate all the alternate entry points as well. We do this 8844 by cloning the instantiation of the main entry point, not by 8845 instantiating the template clones. */ 8846 if (TREE_CHAIN (gen_tmpl) && DECL_CLONED_FUNCTION_P (TREE_CHAIN (gen_tmpl))) 8847 clone_function_decl (fndecl, /*update_method_vec_p=*/0); 8848 8849 return fndecl; 8850} 8851 8852/* The FN is a TEMPLATE_DECL for a function. The ARGS are the 8853 arguments that are being used when calling it. TARGS is a vector 8854 into which the deduced template arguments are placed. 8855 8856 Return zero for success, 2 for an incomplete match that doesn't resolve 8857 all the types, and 1 for complete failure. An error message will be 8858 printed only for an incomplete match. 8859 8860 If FN is a conversion operator, or we are trying to produce a specific 8861 specialization, RETURN_TYPE is the return type desired. 8862 8863 The EXPLICIT_TARGS are explicit template arguments provided via a 8864 template-id. 8865 8866 The parameter STRICT is one of: 8867 8868 DEDUCE_CALL: 8869 We are deducing arguments for a function call, as in 8870 [temp.deduct.call]. 8871 8872 DEDUCE_CONV: 8873 We are deducing arguments for a conversion function, as in 8874 [temp.deduct.conv]. 8875 8876 DEDUCE_EXACT: 8877 We are deducing arguments when doing an explicit instantiation 8878 as in [temp.explicit], when determining an explicit specialization 8879 as in [temp.expl.spec], or when taking the address of a function 8880 template, as in [temp.deduct.funcaddr]. 8881 8882 DEDUCE_ORDER: 8883 We are deducing arguments when calculating the partial 8884 ordering between specializations of function or class 8885 templates, as in [temp.func.order] and [temp.class.order]. 8886 8887 LEN is the number of parms to consider before returning success, or -1 8888 for all. This is used in partial ordering to avoid comparing parms for 8889 which no actual argument was passed, since they are not considered in 8890 overload resolution (and are explicitly excluded from consideration in 8891 partial ordering in [temp.func.order]/6). */ 8892 8893int 8894fn_type_unification (tree fn, 8895 tree explicit_targs, 8896 tree targs, 8897 tree args, 8898 tree return_type, 8899 unification_kind_t strict, 8900 int len) 8901{ 8902 tree parms; 8903 tree fntype; 8904 int result; 8905 8906 my_friendly_assert (TREE_CODE (fn) == TEMPLATE_DECL, 0); 8907 8908 fntype = TREE_TYPE (fn); 8909 if (explicit_targs) 8910 { 8911 /* [temp.deduct] 8912 8913 The specified template arguments must match the template 8914 parameters in kind (i.e., type, nontype, template), and there 8915 must not be more arguments than there are parameters; 8916 otherwise type deduction fails. 8917 8918 Nontype arguments must match the types of the corresponding 8919 nontype template parameters, or must be convertible to the 8920 types of the corresponding nontype parameters as specified in 8921 _temp.arg.nontype_, otherwise type deduction fails. 8922 8923 All references in the function type of the function template 8924 to the corresponding template parameters are replaced by the 8925 specified template argument values. If a substitution in a 8926 template parameter or in the function type of the function 8927 template results in an invalid type, type deduction fails. */ 8928 int i; 8929 tree converted_args; 8930 bool incomplete; 8931 8932 if (explicit_targs == error_mark_node) 8933 return 1; 8934 8935 converted_args 8936 = (coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn), 8937 explicit_targs, NULL_TREE, tf_none, 8938 /*require_all_arguments=*/0)); 8939 if (converted_args == error_mark_node) 8940 return 1; 8941 8942 /* Substitute the explicit args into the function type. This is 8943 necessary so that, for instance, explicitly declared function 8944 arguments can match null pointed constants. If we were given 8945 an incomplete set of explicit args, we must not do semantic 8946 processing during substitution as we could create partial 8947 instantiations. */ 8948 incomplete = NUM_TMPL_ARGS (explicit_targs) != NUM_TMPL_ARGS (targs); 8949 processing_template_decl += incomplete; 8950 fntype = tsubst (fntype, converted_args, tf_none, NULL_TREE); 8951 processing_template_decl -= incomplete; 8952 8953 if (fntype == error_mark_node) 8954 return 1; 8955 8956 /* Place the explicitly specified arguments in TARGS. */ 8957 for (i = NUM_TMPL_ARGS (converted_args); i--;) 8958 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (converted_args, i); 8959 } 8960 8961 parms = TYPE_ARG_TYPES (fntype); 8962 /* Never do unification on the 'this' parameter. */ 8963 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)) 8964 parms = TREE_CHAIN (parms); 8965 8966 if (return_type) 8967 { 8968 /* We've been given a return type to match, prepend it. */ 8969 parms = tree_cons (NULL_TREE, TREE_TYPE (fntype), parms); 8970 args = tree_cons (NULL_TREE, return_type, args); 8971 if (len >= 0) 8972 ++len; 8973 } 8974 8975 /* We allow incomplete unification without an error message here 8976 because the standard doesn't seem to explicitly prohibit it. Our 8977 callers must be ready to deal with unification failures in any 8978 event. */ 8979 result = type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn), 8980 targs, parms, args, /*subr=*/0, 8981 strict, /*allow_incomplete*/1, len); 8982 8983 if (result == 0) 8984 /* All is well so far. Now, check: 8985 8986 [temp.deduct] 8987 8988 When all template arguments have been deduced, all uses of 8989 template parameters in nondeduced contexts are replaced with 8990 the corresponding deduced argument values. If the 8991 substitution results in an invalid type, as described above, 8992 type deduction fails. */ 8993 if (tsubst (TREE_TYPE (fn), targs, tf_none, NULL_TREE) 8994 == error_mark_node) 8995 return 1; 8996 8997 return result; 8998} 8999 9000/* Adjust types before performing type deduction, as described in 9001 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two 9002 sections are symmetric. PARM is the type of a function parameter 9003 or the return type of the conversion function. ARG is the type of 9004 the argument passed to the call, or the type of the value 9005 initialized with the result of the conversion function. */ 9006 9007static int 9008maybe_adjust_types_for_deduction (unification_kind_t strict, 9009 tree* parm, 9010 tree* arg) 9011{ 9012 int result = 0; 9013 9014 switch (strict) 9015 { 9016 case DEDUCE_CALL: 9017 break; 9018 9019 case DEDUCE_CONV: 9020 { 9021 /* Swap PARM and ARG throughout the remainder of this 9022 function; the handling is precisely symmetric since PARM 9023 will initialize ARG rather than vice versa. */ 9024 tree* temp = parm; 9025 parm = arg; 9026 arg = temp; 9027 break; 9028 } 9029 9030 case DEDUCE_EXACT: 9031 /* There is nothing to do in this case. */ 9032 return 0; 9033 9034 case DEDUCE_ORDER: 9035 /* DR 214. [temp.func.order] is underspecified, and leads to no 9036 ordering between things like `T *' and `T const &' for `U *'. 9037 The former has T=U and the latter T=U*. The former looks more 9038 specialized and John Spicer considers it well-formed (the EDG 9039 compiler accepts it). 9040 9041 John also confirms that deduction should proceed as in a function 9042 call. Which implies the usual ARG and PARM conversions as DEDUCE_CALL. 9043 However, in ordering, ARG can have REFERENCE_TYPE, but no argument 9044 to an actual call can have such a type. 9045 9046 If both ARG and PARM are REFERENCE_TYPE, we change neither. 9047 If only ARG is a REFERENCE_TYPE, we look through that and then 9048 proceed as with DEDUCE_CALL (which could further convert it). */ 9049 if (TREE_CODE (*arg) == REFERENCE_TYPE) 9050 { 9051 if (TREE_CODE (*parm) == REFERENCE_TYPE) 9052 return 0; 9053 *arg = TREE_TYPE (*arg); 9054 } 9055 break; 9056 default: 9057 abort (); 9058 } 9059 9060 if (TREE_CODE (*parm) != REFERENCE_TYPE) 9061 { 9062 /* [temp.deduct.call] 9063 9064 If P is not a reference type: 9065 9066 --If A is an array type, the pointer type produced by the 9067 array-to-pointer standard conversion (_conv.array_) is 9068 used in place of A for type deduction; otherwise, 9069 9070 --If A is a function type, the pointer type produced by 9071 the function-to-pointer standard conversion 9072 (_conv.func_) is used in place of A for type deduction; 9073 otherwise, 9074 9075 --If A is a cv-qualified type, the top level 9076 cv-qualifiers of A's type are ignored for type 9077 deduction. */ 9078 if (TREE_CODE (*arg) == ARRAY_TYPE) 9079 *arg = build_pointer_type (TREE_TYPE (*arg)); 9080 else if (TREE_CODE (*arg) == FUNCTION_TYPE) 9081 *arg = build_pointer_type (*arg); 9082 else 9083 *arg = TYPE_MAIN_VARIANT (*arg); 9084 } 9085 9086 /* [temp.deduct.call] 9087 9088 If P is a cv-qualified type, the top level cv-qualifiers 9089 of P's type are ignored for type deduction. If P is a 9090 reference type, the type referred to by P is used for 9091 type deduction. */ 9092 *parm = TYPE_MAIN_VARIANT (*parm); 9093 if (TREE_CODE (*parm) == REFERENCE_TYPE) 9094 { 9095 *parm = TREE_TYPE (*parm); 9096 result |= UNIFY_ALLOW_OUTER_MORE_CV_QUAL; 9097 } 9098 9099 /* DR 322. For conversion deduction, remove a reference type on parm 9100 too (which has been swapped into ARG). */ 9101 if (strict == DEDUCE_CONV && TREE_CODE (*arg) == REFERENCE_TYPE) 9102 *arg = TREE_TYPE (*arg); 9103 9104 return result; 9105} 9106 9107/* Most parms like fn_type_unification. 9108 9109 If SUBR is 1, we're being called recursively (to unify the 9110 arguments of a function or method parameter of a function 9111 template). */ 9112 9113static int 9114type_unification_real (tree tparms, 9115 tree targs, 9116 tree xparms, 9117 tree xargs, 9118 int subr, 9119 unification_kind_t strict, 9120 int allow_incomplete, 9121 int xlen) 9122{ 9123 tree parm, arg; 9124 int i; 9125 int ntparms = TREE_VEC_LENGTH (tparms); 9126 int sub_strict; 9127 int saw_undeduced = 0; 9128 tree parms, args; 9129 int len; 9130 9131 my_friendly_assert (TREE_CODE (tparms) == TREE_VEC, 289); 9132 my_friendly_assert (xparms == NULL_TREE 9133 || TREE_CODE (xparms) == TREE_LIST, 290); 9134 my_friendly_assert (!xargs || TREE_CODE (xargs) == TREE_LIST, 291); 9135 my_friendly_assert (ntparms > 0, 292); 9136 9137 switch (strict) 9138 { 9139 case DEDUCE_CALL: 9140 sub_strict = (UNIFY_ALLOW_OUTER_LEVEL | UNIFY_ALLOW_MORE_CV_QUAL 9141 | UNIFY_ALLOW_DERIVED); 9142 break; 9143 9144 case DEDUCE_CONV: 9145 sub_strict = UNIFY_ALLOW_LESS_CV_QUAL; 9146 break; 9147 9148 case DEDUCE_EXACT: 9149 sub_strict = UNIFY_ALLOW_NONE; 9150 break; 9151 9152 case DEDUCE_ORDER: 9153 sub_strict = UNIFY_ALLOW_NONE; 9154 break; 9155 9156 default: 9157 abort (); 9158 } 9159 9160 if (xlen == 0) 9161 return 0; 9162 9163 again: 9164 parms = xparms; 9165 args = xargs; 9166 len = xlen; 9167 9168 while (parms 9169 && parms != void_list_node 9170 && args 9171 && args != void_list_node) 9172 { 9173 parm = TREE_VALUE (parms); 9174 parms = TREE_CHAIN (parms); 9175 arg = TREE_VALUE (args); 9176 args = TREE_CHAIN (args); 9177 9178 if (arg == error_mark_node) 9179 return 1; 9180 if (arg == unknown_type_node) 9181 /* We can't deduce anything from this, but we might get all the 9182 template args from other function args. */ 9183 continue; 9184 9185 /* Conversions will be performed on a function argument that 9186 corresponds with a function parameter that contains only 9187 non-deducible template parameters and explicitly specified 9188 template parameters. */ 9189 if (!uses_template_parms (parm)) 9190 { 9191 tree type; 9192 9193 if (!TYPE_P (arg)) 9194 type = TREE_TYPE (arg); 9195 else 9196 type = arg; 9197 9198 if (same_type_p (parm, type)) 9199 continue; 9200 if (strict != DEDUCE_EXACT 9201 && can_convert_arg (parm, type, TYPE_P (arg) ? NULL_TREE : arg)) 9202 continue; 9203 9204 return 1; 9205 } 9206 9207 if (!TYPE_P (arg)) 9208 { 9209 my_friendly_assert (TREE_TYPE (arg) != NULL_TREE, 293); 9210 if (type_unknown_p (arg)) 9211 { 9212 /* [temp.deduct.type] A template-argument can be deduced from 9213 a pointer to function or pointer to member function 9214 argument if the set of overloaded functions does not 9215 contain function templates and at most one of a set of 9216 overloaded functions provides a unique match. */ 9217 9218 if (resolve_overloaded_unification 9219 (tparms, targs, parm, arg, strict, sub_strict) 9220 != 0) 9221 return 1; 9222 continue; 9223 } 9224 arg = TREE_TYPE (arg); 9225 if (arg == error_mark_node) 9226 return 1; 9227 } 9228 9229 { 9230 int arg_strict = sub_strict; 9231 9232 if (!subr) 9233 arg_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg); 9234 9235 if (unify (tparms, targs, parm, arg, arg_strict)) 9236 return 1; 9237 } 9238 9239 /* Are we done with the interesting parms? */ 9240 if (--len == 0) 9241 goto done; 9242 } 9243 /* Fail if we've reached the end of the parm list, and more args 9244 are present, and the parm list isn't variadic. */ 9245 if (args && args != void_list_node && parms == void_list_node) 9246 return 1; 9247 /* Fail if parms are left and they don't have default values. */ 9248 if (parms 9249 && parms != void_list_node 9250 && TREE_PURPOSE (parms) == NULL_TREE) 9251 return 1; 9252 9253 done: 9254 if (!subr) 9255 for (i = 0; i < ntparms; i++) 9256 if (TREE_VEC_ELT (targs, i) == NULL_TREE) 9257 { 9258 tree tparm = TREE_VALUE (TREE_VEC_ELT (tparms, i)); 9259 9260 /* If this is an undeduced nontype parameter that depends on 9261 a type parameter, try another pass; its type may have been 9262 deduced from a later argument than the one from which 9263 this parameter can be deduced. */ 9264 if (TREE_CODE (tparm) == PARM_DECL 9265 && uses_template_parms (TREE_TYPE (tparm)) 9266 && !saw_undeduced++) 9267 goto again; 9268 9269 if (!allow_incomplete) 9270 error ("incomplete type unification"); 9271 return 2; 9272 } 9273 return 0; 9274} 9275 9276/* Subroutine of type_unification_real. Args are like the variables at the 9277 call site. ARG is an overloaded function (or template-id); we try 9278 deducing template args from each of the overloads, and if only one 9279 succeeds, we go with that. Modifies TARGS and returns 0 on success. */ 9280 9281static int 9282resolve_overloaded_unification (tree tparms, 9283 tree targs, 9284 tree parm, 9285 tree arg, 9286 unification_kind_t strict, 9287 int sub_strict) 9288{ 9289 tree tempargs = copy_node (targs); 9290 int good = 0; 9291 bool addr_p; 9292 9293 if (TREE_CODE (arg) == ADDR_EXPR) 9294 { 9295 arg = TREE_OPERAND (arg, 0); 9296 addr_p = true; 9297 } 9298 else 9299 addr_p = false; 9300 9301 if (TREE_CODE (arg) == COMPONENT_REF) 9302 /* Handle `&x' where `x' is some static or non-static member 9303 function name. */ 9304 arg = TREE_OPERAND (arg, 1); 9305 9306 if (TREE_CODE (arg) == OFFSET_REF) 9307 arg = TREE_OPERAND (arg, 1); 9308 9309 /* Strip baselink information. */ 9310 if (BASELINK_P (arg)) 9311 arg = BASELINK_FUNCTIONS (arg); 9312 9313 if (TREE_CODE (arg) == TEMPLATE_ID_EXPR) 9314 { 9315 /* If we got some explicit template args, we need to plug them into 9316 the affected templates before we try to unify, in case the 9317 explicit args will completely resolve the templates in question. */ 9318 9319 tree expl_subargs = TREE_OPERAND (arg, 1); 9320 arg = TREE_OPERAND (arg, 0); 9321 9322 for (; arg; arg = OVL_NEXT (arg)) 9323 { 9324 tree fn = OVL_CURRENT (arg); 9325 tree subargs, elem; 9326 9327 if (TREE_CODE (fn) != TEMPLATE_DECL) 9328 continue; 9329 9330 subargs = get_bindings_overload (fn, DECL_TEMPLATE_RESULT (fn), 9331 expl_subargs); 9332 if (subargs) 9333 { 9334 elem = tsubst (TREE_TYPE (fn), subargs, tf_none, NULL_TREE); 9335 good += try_one_overload (tparms, targs, tempargs, parm, 9336 elem, strict, sub_strict, addr_p); 9337 } 9338 } 9339 } 9340 else if (TREE_CODE (arg) == OVERLOAD 9341 || TREE_CODE (arg) == FUNCTION_DECL) 9342 { 9343 for (; arg; arg = OVL_NEXT (arg)) 9344 good += try_one_overload (tparms, targs, tempargs, parm, 9345 TREE_TYPE (OVL_CURRENT (arg)), 9346 strict, sub_strict, addr_p); 9347 } 9348 else 9349 abort (); 9350 9351 /* [temp.deduct.type] A template-argument can be deduced from a pointer 9352 to function or pointer to member function argument if the set of 9353 overloaded functions does not contain function templates and at most 9354 one of a set of overloaded functions provides a unique match. 9355 9356 So if we found multiple possibilities, we return success but don't 9357 deduce anything. */ 9358 9359 if (good == 1) 9360 { 9361 int i = TREE_VEC_LENGTH (targs); 9362 for (; i--; ) 9363 if (TREE_VEC_ELT (tempargs, i)) 9364 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (tempargs, i); 9365 } 9366 if (good) 9367 return 0; 9368 9369 return 1; 9370} 9371 9372/* Subroutine of resolve_overloaded_unification; does deduction for a single 9373 overload. Fills TARGS with any deduced arguments, or error_mark_node if 9374 different overloads deduce different arguments for a given parm. 9375 ADDR_P is true if the expression for which deduction is being 9376 performed was of the form "& fn" rather than simply "fn". 9377 9378 Returns 1 on success. */ 9379 9380static int 9381try_one_overload (tree tparms, 9382 tree orig_targs, 9383 tree targs, 9384 tree parm, 9385 tree arg, 9386 unification_kind_t strict, 9387 int sub_strict, 9388 bool addr_p) 9389{ 9390 int nargs; 9391 tree tempargs; 9392 int i; 9393 9394 /* [temp.deduct.type] A template-argument can be deduced from a pointer 9395 to function or pointer to member function argument if the set of 9396 overloaded functions does not contain function templates and at most 9397 one of a set of overloaded functions provides a unique match. 9398 9399 So if this is a template, just return success. */ 9400 9401 if (uses_template_parms (arg)) 9402 return 1; 9403 9404 if (TREE_CODE (arg) == METHOD_TYPE) 9405 arg = build_ptrmemfunc_type (build_pointer_type (arg)); 9406 else if (addr_p) 9407 arg = build_pointer_type (arg); 9408 9409 sub_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg); 9410 9411 /* We don't copy orig_targs for this because if we have already deduced 9412 some template args from previous args, unify would complain when we 9413 try to deduce a template parameter for the same argument, even though 9414 there isn't really a conflict. */ 9415 nargs = TREE_VEC_LENGTH (targs); 9416 tempargs = make_tree_vec (nargs); 9417 9418 if (unify (tparms, tempargs, parm, arg, sub_strict) != 0) 9419 return 0; 9420 9421 /* First make sure we didn't deduce anything that conflicts with 9422 explicitly specified args. */ 9423 for (i = nargs; i--; ) 9424 { 9425 tree elt = TREE_VEC_ELT (tempargs, i); 9426 tree oldelt = TREE_VEC_ELT (orig_targs, i); 9427 9428 if (elt == NULL_TREE) 9429 continue; 9430 else if (uses_template_parms (elt)) 9431 { 9432 /* Since we're unifying against ourselves, we will fill in template 9433 args used in the function parm list with our own template parms. 9434 Discard them. */ 9435 TREE_VEC_ELT (tempargs, i) = NULL_TREE; 9436 continue; 9437 } 9438 else if (oldelt && ! template_args_equal (oldelt, elt)) 9439 return 0; 9440 } 9441 9442 for (i = nargs; i--; ) 9443 { 9444 tree elt = TREE_VEC_ELT (tempargs, i); 9445 9446 if (elt) 9447 TREE_VEC_ELT (targs, i) = elt; 9448 } 9449 9450 return 1; 9451} 9452 9453/* Verify that nondeduce template argument agrees with the type 9454 obtained from argument deduction. Return nonzero if the 9455 verification fails. 9456 9457 For example: 9458 9459 struct A { typedef int X; }; 9460 template <class T, class U> struct C {}; 9461 template <class T> struct C<T, typename T::X> {}; 9462 9463 Then with the instantiation `C<A, int>', we can deduce that 9464 `T' is `A' but unify () does not check whether `typename T::X' 9465 is `int'. This function ensure that they agree. 9466 9467 TARGS, PARMS are the same as the arguments of unify. 9468 ARGS contains template arguments from all levels. */ 9469 9470static int 9471verify_class_unification (tree targs, tree parms, tree args) 9472{ 9473 parms = tsubst (parms, add_outermost_template_args (args, targs), 9474 tf_none, NULL_TREE); 9475 if (parms == error_mark_node) 9476 return 1; 9477 9478 return !comp_template_args (parms, INNERMOST_TEMPLATE_ARGS (args)); 9479} 9480 9481/* PARM is a template class (perhaps with unbound template 9482 parameters). ARG is a fully instantiated type. If ARG can be 9483 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and 9484 TARGS are as for unify. */ 9485 9486static tree 9487try_class_unification (tree tparms, tree targs, tree parm, tree arg) 9488{ 9489 tree copy_of_targs; 9490 9491 if (!CLASSTYPE_TEMPLATE_INFO (arg) 9492 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg)) 9493 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm)))) 9494 return NULL_TREE; 9495 9496 /* We need to make a new template argument vector for the call to 9497 unify. If we used TARGS, we'd clutter it up with the result of 9498 the attempted unification, even if this class didn't work out. 9499 We also don't want to commit ourselves to all the unifications 9500 we've already done, since unification is supposed to be done on 9501 an argument-by-argument basis. In other words, consider the 9502 following pathological case: 9503 9504 template <int I, int J, int K> 9505 struct S {}; 9506 9507 template <int I, int J> 9508 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {}; 9509 9510 template <int I, int J, int K> 9511 void f(S<I, J, K>, S<I, I, I>); 9512 9513 void g() { 9514 S<0, 0, 0> s0; 9515 S<0, 1, 2> s2; 9516 9517 f(s0, s2); 9518 } 9519 9520 Now, by the time we consider the unification involving `s2', we 9521 already know that we must have `f<0, 0, 0>'. But, even though 9522 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid 9523 because there are two ways to unify base classes of S<0, 1, 2> 9524 with S<I, I, I>. If we kept the already deduced knowledge, we 9525 would reject the possibility I=1. */ 9526 copy_of_targs = make_tree_vec (TREE_VEC_LENGTH (targs)); 9527 9528 /* If unification failed, we're done. */ 9529 if (unify (tparms, copy_of_targs, CLASSTYPE_TI_ARGS (parm), 9530 CLASSTYPE_TI_ARGS (arg), UNIFY_ALLOW_NONE)) 9531 return NULL_TREE; 9532 9533 return arg; 9534} 9535 9536/* Subroutine of get_template_base. RVAL, if non-NULL, is a base we 9537 have already discovered to be satisfactory. ARG_BINFO is the binfo 9538 for the base class of ARG that we are currently examining. */ 9539 9540static tree 9541get_template_base_recursive (tree tparms, 9542 tree targs, 9543 tree parm, 9544 tree arg_binfo, 9545 tree rval, 9546 int flags) 9547{ 9548 tree binfos; 9549 int i, n_baselinks; 9550 tree arg = BINFO_TYPE (arg_binfo); 9551 9552 if (!(flags & GTB_IGNORE_TYPE)) 9553 { 9554 tree r = try_class_unification (tparms, targs, 9555 parm, arg); 9556 9557 /* If there is more than one satisfactory baseclass, then: 9558 9559 [temp.deduct.call] 9560 9561 If they yield more than one possible deduced A, the type 9562 deduction fails. 9563 9564 applies. */ 9565 if (r && rval && !same_type_p (r, rval)) 9566 return error_mark_node; 9567 else if (r) 9568 rval = r; 9569 } 9570 9571 binfos = BINFO_BASETYPES (arg_binfo); 9572 n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0; 9573 9574 /* Process base types. */ 9575 for (i = 0; i < n_baselinks; i++) 9576 { 9577 tree base_binfo = TREE_VEC_ELT (binfos, i); 9578 int this_virtual; 9579 9580 /* Skip this base, if we've already seen it. */ 9581 if (BINFO_MARKED (base_binfo)) 9582 continue; 9583 9584 this_virtual = 9585 (flags & GTB_VIA_VIRTUAL) || TREE_VIA_VIRTUAL (base_binfo); 9586 9587 /* When searching for a non-virtual, we cannot mark virtually 9588 found binfos. */ 9589 if (! this_virtual) 9590 BINFO_MARKED (base_binfo) = 1; 9591 9592 rval = get_template_base_recursive (tparms, targs, 9593 parm, 9594 base_binfo, 9595 rval, 9596 GTB_VIA_VIRTUAL * this_virtual); 9597 9598 /* If we discovered more than one matching base class, we can 9599 stop now. */ 9600 if (rval == error_mark_node) 9601 return error_mark_node; 9602 } 9603 9604 return rval; 9605} 9606 9607/* Given a template type PARM and a class type ARG, find the unique 9608 base type in ARG that is an instance of PARM. We do not examine 9609 ARG itself; only its base-classes. If there is no appropriate base 9610 class, return NULL_TREE. If there is more than one, return 9611 error_mark_node. PARM may be the type of a partial specialization, 9612 as well as a plain template type. Used by unify. */ 9613 9614static tree 9615get_template_base (tree tparms, tree targs, tree parm, tree arg) 9616{ 9617 tree rval; 9618 tree arg_binfo; 9619 9620 my_friendly_assert (IS_AGGR_TYPE_CODE (TREE_CODE (arg)), 92); 9621 9622 arg_binfo = TYPE_BINFO (complete_type (arg)); 9623 rval = get_template_base_recursive (tparms, targs, 9624 parm, arg_binfo, 9625 NULL_TREE, 9626 GTB_IGNORE_TYPE); 9627 9628 /* Since get_template_base_recursive marks the bases classes, we 9629 must unmark them here. */ 9630 dfs_walk (arg_binfo, dfs_unmark, markedp, 0); 9631 9632 return rval; 9633} 9634 9635/* Returns the level of DECL, which declares a template parameter. */ 9636 9637static int 9638template_decl_level (tree decl) 9639{ 9640 switch (TREE_CODE (decl)) 9641 { 9642 case TYPE_DECL: 9643 case TEMPLATE_DECL: 9644 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl)); 9645 9646 case PARM_DECL: 9647 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl)); 9648 9649 default: 9650 abort (); 9651 return 0; 9652 } 9653} 9654 9655/* Decide whether ARG can be unified with PARM, considering only the 9656 cv-qualifiers of each type, given STRICT as documented for unify. 9657 Returns nonzero iff the unification is OK on that basis. */ 9658 9659static int 9660check_cv_quals_for_unify (int strict, tree arg, tree parm) 9661{ 9662 int arg_quals = cp_type_quals (arg); 9663 int parm_quals = cp_type_quals (parm); 9664 9665 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM 9666 && !(strict & UNIFY_ALLOW_OUTER_MORE_CV_QUAL)) 9667 { 9668 /* Although a CVR qualifier is ignored when being applied to a 9669 substituted template parameter ([8.3.2]/1 for example), that 9670 does not apply during deduction [14.8.2.4]/1, (even though 9671 that is not explicitly mentioned, [14.8.2.4]/9 indicates 9672 this). Except when we're allowing additional CV qualifiers 9673 at the outer level [14.8.2.1]/3,1st bullet. */ 9674 if ((TREE_CODE (arg) == REFERENCE_TYPE 9675 || TREE_CODE (arg) == FUNCTION_TYPE 9676 || TREE_CODE (arg) == METHOD_TYPE) 9677 && (parm_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE))) 9678 return 0; 9679 9680 if ((!POINTER_TYPE_P (arg) && TREE_CODE (arg) != TEMPLATE_TYPE_PARM) 9681 && (parm_quals & TYPE_QUAL_RESTRICT)) 9682 return 0; 9683 } 9684 9685 if (!(strict & (UNIFY_ALLOW_MORE_CV_QUAL | UNIFY_ALLOW_OUTER_MORE_CV_QUAL)) 9686 && (arg_quals & parm_quals) != parm_quals) 9687 return 0; 9688 9689 if (!(strict & (UNIFY_ALLOW_LESS_CV_QUAL | UNIFY_ALLOW_OUTER_LESS_CV_QUAL)) 9690 && (parm_quals & arg_quals) != arg_quals) 9691 return 0; 9692 9693 return 1; 9694} 9695 9696/* Takes parameters as for type_unification. Returns 0 if the 9697 type deduction succeeds, 1 otherwise. The parameter STRICT is a 9698 bitwise or of the following flags: 9699 9700 UNIFY_ALLOW_NONE: 9701 Require an exact match between PARM and ARG. 9702 UNIFY_ALLOW_MORE_CV_QUAL: 9703 Allow the deduced ARG to be more cv-qualified (by qualification 9704 conversion) than ARG. 9705 UNIFY_ALLOW_LESS_CV_QUAL: 9706 Allow the deduced ARG to be less cv-qualified than ARG. 9707 UNIFY_ALLOW_DERIVED: 9708 Allow the deduced ARG to be a template base class of ARG, 9709 or a pointer to a template base class of the type pointed to by 9710 ARG. 9711 UNIFY_ALLOW_INTEGER: 9712 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX 9713 case for more information. 9714 UNIFY_ALLOW_OUTER_LEVEL: 9715 This is the outermost level of a deduction. Used to determine validity 9716 of qualification conversions. A valid qualification conversion must 9717 have const qualified pointers leading up to the inner type which 9718 requires additional CV quals, except at the outer level, where const 9719 is not required [conv.qual]. It would be normal to set this flag in 9720 addition to setting UNIFY_ALLOW_MORE_CV_QUAL. 9721 UNIFY_ALLOW_OUTER_MORE_CV_QUAL: 9722 This is the outermost level of a deduction, and PARM can be more CV 9723 qualified at this point. 9724 UNIFY_ALLOW_OUTER_LESS_CV_QUAL: 9725 This is the outermost level of a deduction, and PARM can be less CV 9726 qualified at this point. 9727 UNIFY_ALLOW_MAX_CORRECTION: 9728 This is an INTEGER_TYPE's maximum value. Used if the range may 9729 have been derived from a size specification, such as an array size. 9730 If the size was given by a nontype template parameter N, the maximum 9731 value will have the form N-1. The flag says that we can (and indeed 9732 must) unify N with (ARG + 1), an exception to the normal rules on 9733 folding PARM. */ 9734 9735static int 9736unify (tree tparms, tree targs, tree parm, tree arg, int strict) 9737{ 9738 int idx; 9739 tree targ; 9740 tree tparm; 9741 int strict_in = strict; 9742 9743 /* I don't think this will do the right thing with respect to types. 9744 But the only case I've seen it in so far has been array bounds, where 9745 signedness is the only information lost, and I think that will be 9746 okay. */ 9747 while (TREE_CODE (parm) == NOP_EXPR) 9748 parm = TREE_OPERAND (parm, 0); 9749 9750 if (arg == error_mark_node) 9751 return 1; 9752 if (arg == unknown_type_node) 9753 /* We can't deduce anything from this, but we might get all the 9754 template args from other function args. */ 9755 return 0; 9756 9757 /* If PARM uses template parameters, then we can't bail out here, 9758 even if ARG == PARM, since we won't record unifications for the 9759 template parameters. We might need them if we're trying to 9760 figure out which of two things is more specialized. */ 9761 if (arg == parm && !uses_template_parms (parm)) 9762 return 0; 9763 9764 /* Immediately reject some pairs that won't unify because of 9765 cv-qualification mismatches. */ 9766 if (TREE_CODE (arg) == TREE_CODE (parm) 9767 && TYPE_P (arg) 9768 /* It is the elements of the array which hold the cv quals of an array 9769 type, and the elements might be template type parms. We'll check 9770 when we recurse. */ 9771 && TREE_CODE (arg) != ARRAY_TYPE 9772 /* We check the cv-qualifiers when unifying with template type 9773 parameters below. We want to allow ARG `const T' to unify with 9774 PARM `T' for example, when computing which of two templates 9775 is more specialized, for example. */ 9776 && TREE_CODE (arg) != TEMPLATE_TYPE_PARM 9777 && !check_cv_quals_for_unify (strict_in, arg, parm)) 9778 return 1; 9779 9780 if (!(strict & UNIFY_ALLOW_OUTER_LEVEL) 9781 && TYPE_P (parm) && !CP_TYPE_CONST_P (parm)) 9782 strict &= ~UNIFY_ALLOW_MORE_CV_QUAL; 9783 strict &= ~UNIFY_ALLOW_OUTER_LEVEL; 9784 strict &= ~UNIFY_ALLOW_DERIVED; 9785 strict &= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL; 9786 strict &= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL; 9787 strict &= ~UNIFY_ALLOW_MAX_CORRECTION; 9788 9789 switch (TREE_CODE (parm)) 9790 { 9791 case TYPENAME_TYPE: 9792 case SCOPE_REF: 9793 case UNBOUND_CLASS_TEMPLATE: 9794 /* In a type which contains a nested-name-specifier, template 9795 argument values cannot be deduced for template parameters used 9796 within the nested-name-specifier. */ 9797 return 0; 9798 9799 case TEMPLATE_TYPE_PARM: 9800 case TEMPLATE_TEMPLATE_PARM: 9801 case BOUND_TEMPLATE_TEMPLATE_PARM: 9802 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0)); 9803 9804 if (TEMPLATE_TYPE_LEVEL (parm) 9805 != template_decl_level (tparm)) 9806 /* The PARM is not one we're trying to unify. Just check 9807 to see if it matches ARG. */ 9808 return (TREE_CODE (arg) == TREE_CODE (parm) 9809 && same_type_p (parm, arg)) ? 0 : 1; 9810 idx = TEMPLATE_TYPE_IDX (parm); 9811 targ = TREE_VEC_ELT (targs, idx); 9812 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, idx)); 9813 9814 /* Check for mixed types and values. */ 9815 if ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM 9816 && TREE_CODE (tparm) != TYPE_DECL) 9817 || (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM 9818 && TREE_CODE (tparm) != TEMPLATE_DECL)) 9819 return 1; 9820 9821 if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM) 9822 { 9823 /* ARG must be constructed from a template class or a template 9824 template parameter. */ 9825 if (TREE_CODE (arg) != BOUND_TEMPLATE_TEMPLATE_PARM 9826 && (TREE_CODE (arg) != RECORD_TYPE || !CLASSTYPE_TEMPLATE_INFO (arg))) 9827 return 1; 9828 9829 { 9830 tree parmtmpl = TYPE_TI_TEMPLATE (parm); 9831 tree parmvec = TYPE_TI_ARGS (parm); 9832 tree argvec = TYPE_TI_ARGS (arg); 9833 tree argtmplvec 9834 = DECL_INNERMOST_TEMPLATE_PARMS (TYPE_TI_TEMPLATE (arg)); 9835 int i; 9836 9837 /* The parameter and argument roles have to be switched here 9838 in order to handle default arguments properly. For example, 9839 template<template <class> class TT> void f(TT<int>) 9840 should be able to accept vector<int> which comes from 9841 template <class T, class Allocator = allocator> 9842 class vector. */ 9843 9844 if (coerce_template_parms (argtmplvec, parmvec, parmtmpl, 0, 1) 9845 == error_mark_node) 9846 return 1; 9847 9848 /* Deduce arguments T, i from TT<T> or TT<i>. 9849 We check each element of PARMVEC and ARGVEC individually 9850 rather than the whole TREE_VEC since they can have 9851 different number of elements. */ 9852 9853 for (i = 0; i < TREE_VEC_LENGTH (parmvec); ++i) 9854 { 9855 tree t = TREE_VEC_ELT (parmvec, i); 9856 9857 if (unify (tparms, targs, t, 9858 TREE_VEC_ELT (argvec, i), 9859 UNIFY_ALLOW_NONE)) 9860 return 1; 9861 } 9862 } 9863 arg = TYPE_TI_TEMPLATE (arg); 9864 9865 /* Fall through to deduce template name. */ 9866 } 9867 9868 if (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM 9869 || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM) 9870 { 9871 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */ 9872 9873 /* Simple cases: Value already set, does match or doesn't. */ 9874 if (targ != NULL_TREE && template_args_equal (targ, arg)) 9875 return 0; 9876 else if (targ) 9877 return 1; 9878 } 9879 else 9880 { 9881 /* If PARM is `const T' and ARG is only `int', we don't have 9882 a match unless we are allowing additional qualification. 9883 If ARG is `const int' and PARM is just `T' that's OK; 9884 that binds `const int' to `T'. */ 9885 if (!check_cv_quals_for_unify (strict_in | UNIFY_ALLOW_LESS_CV_QUAL, 9886 arg, parm)) 9887 return 1; 9888 9889 /* Consider the case where ARG is `const volatile int' and 9890 PARM is `const T'. Then, T should be `volatile int'. */ 9891 arg = cp_build_qualified_type_real 9892 (arg, cp_type_quals (arg) & ~cp_type_quals (parm), tf_none); 9893 if (arg == error_mark_node) 9894 return 1; 9895 9896 /* Simple cases: Value already set, does match or doesn't. */ 9897 if (targ != NULL_TREE && same_type_p (targ, arg)) 9898 return 0; 9899 else if (targ) 9900 return 1; 9901 9902 /* Make sure that ARG is not a variable-sized array. (Note 9903 that were talking about variable-sized arrays (like 9904 `int[n]'), rather than arrays of unknown size (like 9905 `int[]').) We'll get very confused by such a type since 9906 the bound of the array will not be computable in an 9907 instantiation. Besides, such types are not allowed in 9908 ISO C++, so we can do as we please here. */ 9909 if (variably_modified_type_p (arg)) 9910 return 1; 9911 } 9912 9913 TREE_VEC_ELT (targs, idx) = arg; 9914 return 0; 9915 9916 case TEMPLATE_PARM_INDEX: 9917 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0)); 9918 9919 if (TEMPLATE_PARM_LEVEL (parm) 9920 != template_decl_level (tparm)) 9921 /* The PARM is not one we're trying to unify. Just check 9922 to see if it matches ARG. */ 9923 return !(TREE_CODE (arg) == TREE_CODE (parm) 9924 && cp_tree_equal (parm, arg)); 9925 9926 idx = TEMPLATE_PARM_IDX (parm); 9927 targ = TREE_VEC_ELT (targs, idx); 9928 9929 if (targ) 9930 return !cp_tree_equal (targ, arg); 9931 9932 /* [temp.deduct.type] If, in the declaration of a function template 9933 with a non-type template-parameter, the non-type 9934 template-parameter is used in an expression in the function 9935 parameter-list and, if the corresponding template-argument is 9936 deduced, the template-argument type shall match the type of the 9937 template-parameter exactly, except that a template-argument 9938 deduced from an array bound may be of any integral type. 9939 The non-type parameter might use already deduced type parameters. */ 9940 tparm = tsubst (TREE_TYPE (parm), targs, 0, NULL_TREE); 9941 if (!TREE_TYPE (arg)) 9942 /* Template-parameter dependent expression. Just accept it for now. 9943 It will later be processed in convert_template_argument. */ 9944 ; 9945 else if (same_type_p (TREE_TYPE (arg), tparm)) 9946 /* OK */; 9947 else if ((strict & UNIFY_ALLOW_INTEGER) 9948 && (TREE_CODE (tparm) == INTEGER_TYPE 9949 || TREE_CODE (tparm) == BOOLEAN_TYPE)) 9950 /* Convert the ARG to the type of PARM; the deduced non-type 9951 template argument must exactly match the types of the 9952 corresponding parameter. */ 9953 arg = fold (build_nop (TREE_TYPE (parm), arg)); 9954 else if (uses_template_parms (tparm)) 9955 /* We haven't deduced the type of this parameter yet. Try again 9956 later. */ 9957 return 0; 9958 else 9959 return 1; 9960 9961 TREE_VEC_ELT (targs, idx) = arg; 9962 return 0; 9963 9964 case PTRMEM_CST: 9965 { 9966 /* A pointer-to-member constant can be unified only with 9967 another constant. */ 9968 if (TREE_CODE (arg) != PTRMEM_CST) 9969 return 1; 9970 9971 /* Just unify the class member. It would be useless (and possibly 9972 wrong, depending on the strict flags) to unify also 9973 PTRMEM_CST_CLASS, because we want to be sure that both parm and 9974 arg refer to the same variable, even if through different 9975 classes. For instance: 9976 9977 struct A { int x; }; 9978 struct B : A { }; 9979 9980 Unification of &A::x and &B::x must succeed. */ 9981 return unify (tparms, targs, PTRMEM_CST_MEMBER (parm), 9982 PTRMEM_CST_MEMBER (arg), strict); 9983 } 9984 9985 case POINTER_TYPE: 9986 { 9987 if (TREE_CODE (arg) != POINTER_TYPE) 9988 return 1; 9989 9990 /* [temp.deduct.call] 9991 9992 A can be another pointer or pointer to member type that can 9993 be converted to the deduced A via a qualification 9994 conversion (_conv.qual_). 9995 9996 We pass down STRICT here rather than UNIFY_ALLOW_NONE. 9997 This will allow for additional cv-qualification of the 9998 pointed-to types if appropriate. */ 9999 10000 if (TREE_CODE (TREE_TYPE (arg)) == RECORD_TYPE) 10001 /* The derived-to-base conversion only persists through one 10002 level of pointers. */ 10003 strict |= (strict_in & UNIFY_ALLOW_DERIVED); 10004 10005 return unify (tparms, targs, TREE_TYPE (parm), 10006 TREE_TYPE (arg), strict); 10007 } 10008 10009 case REFERENCE_TYPE: 10010 if (TREE_CODE (arg) != REFERENCE_TYPE) 10011 return 1; 10012 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg), 10013 strict & UNIFY_ALLOW_MORE_CV_QUAL); 10014 10015 case ARRAY_TYPE: 10016 if (TREE_CODE (arg) != ARRAY_TYPE) 10017 return 1; 10018 if ((TYPE_DOMAIN (parm) == NULL_TREE) 10019 != (TYPE_DOMAIN (arg) == NULL_TREE)) 10020 return 1; 10021 if (TYPE_DOMAIN (parm) != NULL_TREE 10022 && unify (tparms, targs, TYPE_DOMAIN (parm), 10023 TYPE_DOMAIN (arg), UNIFY_ALLOW_NONE) != 0) 10024 return 1; 10025 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg), 10026 strict & UNIFY_ALLOW_MORE_CV_QUAL); 10027 10028 case REAL_TYPE: 10029 case COMPLEX_TYPE: 10030 case VECTOR_TYPE: 10031 case INTEGER_TYPE: 10032 case BOOLEAN_TYPE: 10033 case ENUMERAL_TYPE: 10034 case VOID_TYPE: 10035 if (TREE_CODE (arg) != TREE_CODE (parm)) 10036 return 1; 10037 10038 if (TREE_CODE (parm) == INTEGER_TYPE 10039 && TREE_CODE (TYPE_MAX_VALUE (parm)) != INTEGER_CST) 10040 { 10041 if (TYPE_MIN_VALUE (parm) && TYPE_MIN_VALUE (arg) 10042 && unify (tparms, targs, TYPE_MIN_VALUE (parm), 10043 TYPE_MIN_VALUE (arg), UNIFY_ALLOW_INTEGER)) 10044 return 1; 10045 if (TYPE_MAX_VALUE (parm) && TYPE_MAX_VALUE (arg) 10046 && unify (tparms, targs, TYPE_MAX_VALUE (parm), 10047 TYPE_MAX_VALUE (arg), 10048 UNIFY_ALLOW_INTEGER | UNIFY_ALLOW_MAX_CORRECTION)) 10049 return 1; 10050 } 10051 /* We have already checked cv-qualification at the top of the 10052 function. */ 10053 else if (!same_type_ignoring_top_level_qualifiers_p (arg, parm)) 10054 return 1; 10055 10056 /* As far as unification is concerned, this wins. Later checks 10057 will invalidate it if necessary. */ 10058 return 0; 10059 10060 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */ 10061 /* Type INTEGER_CST can come from ordinary constant template args. */ 10062 case INTEGER_CST: 10063 while (TREE_CODE (arg) == NOP_EXPR) 10064 arg = TREE_OPERAND (arg, 0); 10065 10066 if (TREE_CODE (arg) != INTEGER_CST) 10067 return 1; 10068 return !tree_int_cst_equal (parm, arg); 10069 10070 case TREE_VEC: 10071 { 10072 int i; 10073 if (TREE_CODE (arg) != TREE_VEC) 10074 return 1; 10075 if (TREE_VEC_LENGTH (parm) != TREE_VEC_LENGTH (arg)) 10076 return 1; 10077 for (i = 0; i < TREE_VEC_LENGTH (parm); ++i) 10078 if (unify (tparms, targs, 10079 TREE_VEC_ELT (parm, i), TREE_VEC_ELT (arg, i), 10080 UNIFY_ALLOW_NONE)) 10081 return 1; 10082 return 0; 10083 } 10084 10085 case RECORD_TYPE: 10086 case UNION_TYPE: 10087 if (TREE_CODE (arg) != TREE_CODE (parm)) 10088 return 1; 10089 10090 if (TYPE_PTRMEMFUNC_P (parm)) 10091 { 10092 if (!TYPE_PTRMEMFUNC_P (arg)) 10093 return 1; 10094 10095 return unify (tparms, targs, 10096 TYPE_PTRMEMFUNC_FN_TYPE (parm), 10097 TYPE_PTRMEMFUNC_FN_TYPE (arg), 10098 strict); 10099 } 10100 10101 if (CLASSTYPE_TEMPLATE_INFO (parm)) 10102 { 10103 tree t = NULL_TREE; 10104 10105 if (strict_in & UNIFY_ALLOW_DERIVED) 10106 { 10107 /* First, we try to unify the PARM and ARG directly. */ 10108 t = try_class_unification (tparms, targs, 10109 parm, arg); 10110 10111 if (!t) 10112 { 10113 /* Fallback to the special case allowed in 10114 [temp.deduct.call]: 10115 10116 If P is a class, and P has the form 10117 template-id, then A can be a derived class of 10118 the deduced A. Likewise, if P is a pointer to 10119 a class of the form template-id, A can be a 10120 pointer to a derived class pointed to by the 10121 deduced A. */ 10122 t = get_template_base (tparms, targs, 10123 parm, arg); 10124 10125 if (! t || t == error_mark_node) 10126 return 1; 10127 } 10128 } 10129 else if (CLASSTYPE_TEMPLATE_INFO (arg) 10130 && (CLASSTYPE_TI_TEMPLATE (parm) 10131 == CLASSTYPE_TI_TEMPLATE (arg))) 10132 /* Perhaps PARM is something like S<U> and ARG is S<int>. 10133 Then, we should unify `int' and `U'. */ 10134 t = arg; 10135 else 10136 /* There's no chance of unification succeeding. */ 10137 return 1; 10138 10139 return unify (tparms, targs, CLASSTYPE_TI_ARGS (parm), 10140 CLASSTYPE_TI_ARGS (t), UNIFY_ALLOW_NONE); 10141 } 10142 else if (!same_type_ignoring_top_level_qualifiers_p (parm, arg)) 10143 return 1; 10144 return 0; 10145 10146 case METHOD_TYPE: 10147 case FUNCTION_TYPE: 10148 if (TREE_CODE (arg) != TREE_CODE (parm)) 10149 return 1; 10150 10151 if (unify (tparms, targs, TREE_TYPE (parm), 10152 TREE_TYPE (arg), UNIFY_ALLOW_NONE)) 10153 return 1; 10154 return type_unification_real (tparms, targs, TYPE_ARG_TYPES (parm), 10155 TYPE_ARG_TYPES (arg), 1, 10156 DEDUCE_EXACT, 0, -1); 10157 10158 case OFFSET_TYPE: 10159 if (TREE_CODE (arg) != OFFSET_TYPE) 10160 return 1; 10161 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm), 10162 TYPE_OFFSET_BASETYPE (arg), UNIFY_ALLOW_NONE)) 10163 return 1; 10164 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg), 10165 strict); 10166 10167 case CONST_DECL: 10168 if (DECL_TEMPLATE_PARM_P (parm)) 10169 return unify (tparms, targs, DECL_INITIAL (parm), arg, strict); 10170 if (arg != decl_constant_value (parm)) 10171 return 1; 10172 return 0; 10173 10174 case FIELD_DECL: 10175 case TEMPLATE_DECL: 10176 /* Matched cases are handled by the ARG == PARM test above. */ 10177 return 1; 10178 10179 case MINUS_EXPR: 10180 if (tree_int_cst_equal (TREE_OPERAND (parm, 1), integer_one_node) 10181 && (strict_in & UNIFY_ALLOW_MAX_CORRECTION)) 10182 { 10183 /* We handle this case specially, since it comes up with 10184 arrays. In particular, something like: 10185 10186 template <int N> void f(int (&x)[N]); 10187 10188 Here, we are trying to unify the range type, which 10189 looks like [0 ... (N - 1)]. */ 10190 tree t, t1, t2; 10191 t1 = TREE_OPERAND (parm, 0); 10192 t2 = TREE_OPERAND (parm, 1); 10193 10194 t = fold (build (PLUS_EXPR, integer_type_node, arg, t2)); 10195 10196 return unify (tparms, targs, t1, t, strict); 10197 } 10198 /* Else fall through. */ 10199 10200 default: 10201 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (parm)))) 10202 { 10203 10204 /* We're looking at an expression. This can happen with 10205 something like: 10206 10207 template <int I> 10208 void foo(S<I>, S<I + 2>); 10209 10210 This is a "nondeduced context": 10211 10212 [deduct.type] 10213 10214 The nondeduced contexts are: 10215 10216 --A type that is a template-id in which one or more of 10217 the template-arguments is an expression that references 10218 a template-parameter. 10219 10220 In these cases, we assume deduction succeeded, but don't 10221 actually infer any unifications. */ 10222 10223 if (!uses_template_parms (parm) 10224 && !template_args_equal (parm, arg)) 10225 return 1; 10226 else 10227 return 0; 10228 } 10229 sorry ("use of `%s' in template type unification", 10230 tree_code_name [(int) TREE_CODE (parm)]); 10231 return 1; 10232 } 10233} 10234 10235/* Called if RESULT is explicitly instantiated, or is a member of an 10236 explicitly instantiated class, or if using -frepo and the 10237 instantiation of RESULT has been assigned to this file. */ 10238 10239void 10240mark_decl_instantiated (tree result, int extern_p) 10241{ 10242 /* We used to set this unconditionally; we moved that to 10243 do_decl_instantiation so it wouldn't get set on members of 10244 explicit class template instantiations. But we still need to set 10245 it here for the 'extern template' case in order to suppress 10246 implicit instantiations. */ 10247 if (extern_p) 10248 SET_DECL_EXPLICIT_INSTANTIATION (result); 10249 10250 /* If this entity has already been written out, it's too late to 10251 make any modifications. */ 10252 if (TREE_ASM_WRITTEN (result)) 10253 return; 10254 10255 if (TREE_CODE (result) != FUNCTION_DECL) 10256 /* The TREE_PUBLIC flag for function declarations will have been 10257 set correctly by tsubst. */ 10258 TREE_PUBLIC (result) = 1; 10259 10260 /* This might have been set by an earlier implicit instantiation. */ 10261 DECL_COMDAT (result) = 0; 10262 10263 if (! extern_p) 10264 { 10265 DECL_INTERFACE_KNOWN (result) = 1; 10266 DECL_NOT_REALLY_EXTERN (result) = 1; 10267 10268 /* Always make artificials weak. */ 10269 if (DECL_ARTIFICIAL (result) && flag_weak) 10270 comdat_linkage (result); 10271 /* For WIN32 we also want to put explicit instantiations in 10272 linkonce sections. */ 10273 else if (TREE_PUBLIC (result)) 10274 maybe_make_one_only (result); 10275 } 10276 10277 if (TREE_CODE (result) == FUNCTION_DECL) 10278 defer_fn (result); 10279} 10280 10281/* Given two function templates PAT1 and PAT2, return: 10282 10283 DEDUCE should be DEDUCE_EXACT or DEDUCE_ORDER. 10284 10285 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order]. 10286 -1 if PAT2 is more specialized than PAT1. 10287 0 if neither is more specialized. 10288 10289 LEN is passed through to fn_type_unification. */ 10290 10291int 10292more_specialized (tree pat1, tree pat2, int deduce, int len) 10293{ 10294 tree targs; 10295 int winner = 0; 10296 10297 /* If template argument deduction succeeds, we substitute the 10298 resulting arguments into non-deduced contexts. While doing that, 10299 we must be aware that we may encounter dependent types. */ 10300 ++processing_template_decl; 10301 targs = get_bindings_real (pat1, DECL_TEMPLATE_RESULT (pat2), 10302 NULL_TREE, 0, deduce, len); 10303 if (targs) 10304 --winner; 10305 10306 targs = get_bindings_real (pat2, DECL_TEMPLATE_RESULT (pat1), 10307 NULL_TREE, 0, deduce, len); 10308 if (targs) 10309 ++winner; 10310 --processing_template_decl; 10311 10312 return winner; 10313} 10314 10315/* Given two class template specialization list nodes PAT1 and PAT2, return: 10316 10317 1 if PAT1 is more specialized than PAT2 as described in [temp.class.order]. 10318 -1 if PAT2 is more specialized than PAT1. 10319 0 if neither is more specialized. 10320 10321 FULL_ARGS is the full set of template arguments that triggers this 10322 partial ordering. */ 10323 10324int 10325more_specialized_class (tree pat1, tree pat2, tree full_args) 10326{ 10327 tree targs; 10328 int winner = 0; 10329 10330 /* Just like what happens for functions, if we are ordering between 10331 different class template specializations, we may encounter dependent 10332 types in the arguments, and we need our dependency check functions 10333 to behave correctly. */ 10334 ++processing_template_decl; 10335 targs = get_class_bindings (TREE_VALUE (pat1), TREE_PURPOSE (pat1), 10336 add_outermost_template_args (full_args, TREE_PURPOSE (pat2))); 10337 if (targs) 10338 --winner; 10339 10340 targs = get_class_bindings (TREE_VALUE (pat2), TREE_PURPOSE (pat2), 10341 add_outermost_template_args (full_args, TREE_PURPOSE (pat1))); 10342 if (targs) 10343 ++winner; 10344 --processing_template_decl; 10345 10346 return winner; 10347} 10348 10349/* Return the template arguments that will produce the function signature 10350 DECL from the function template FN, with the explicit template 10351 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is 1, the return type must 10352 also match. Return NULL_TREE if no satisfactory arguments could be 10353 found. DEDUCE and LEN are passed through to fn_type_unification. */ 10354 10355static tree 10356get_bindings_real (tree fn, 10357 tree decl, 10358 tree explicit_args, 10359 int check_rettype, 10360 int deduce, 10361 int len) 10362{ 10363 int ntparms = DECL_NTPARMS (fn); 10364 tree targs = make_tree_vec (ntparms); 10365 tree decl_type; 10366 tree decl_arg_types; 10367 int i; 10368 10369 /* Substitute the explicit template arguments into the type of DECL. 10370 The call to fn_type_unification will handle substitution into the 10371 FN. */ 10372 decl_type = TREE_TYPE (decl); 10373 if (explicit_args && uses_template_parms (decl_type)) 10374 { 10375 tree tmpl; 10376 tree converted_args; 10377 10378 if (DECL_TEMPLATE_INFO (decl)) 10379 tmpl = DECL_TI_TEMPLATE (decl); 10380 else 10381 /* We can get here for some invalid specializations. */ 10382 return NULL_TREE; 10383 10384 converted_args 10385 = (coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl), 10386 explicit_args, NULL_TREE, 10387 tf_none, /*require_all_arguments=*/0)); 10388 if (converted_args == error_mark_node) 10389 return NULL_TREE; 10390 10391 decl_type = tsubst (decl_type, converted_args, tf_none, NULL_TREE); 10392 if (decl_type == error_mark_node) 10393 return NULL_TREE; 10394 } 10395 10396 decl_arg_types = TYPE_ARG_TYPES (decl_type); 10397 /* Never do unification on the 'this' parameter. */ 10398 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)) 10399 decl_arg_types = TREE_CHAIN (decl_arg_types); 10400 10401 i = fn_type_unification (fn, explicit_args, targs, 10402 decl_arg_types, 10403 (check_rettype || DECL_CONV_FN_P (fn) 10404 ? TREE_TYPE (decl_type) : NULL_TREE), 10405 deduce, len); 10406 10407 if (i != 0) 10408 return NULL_TREE; 10409 10410 return targs; 10411} 10412 10413/* For most uses, we want to check the return type. */ 10414 10415static tree 10416get_bindings (tree fn, tree decl, tree explicit_args) 10417{ 10418 return get_bindings_real (fn, decl, explicit_args, 1, DEDUCE_EXACT, -1); 10419} 10420 10421/* But for resolve_overloaded_unification, we only care about the parameter 10422 types. */ 10423 10424static tree 10425get_bindings_overload (tree fn, tree decl, tree explicit_args) 10426{ 10427 return get_bindings_real (fn, decl, explicit_args, 0, DEDUCE_EXACT, -1); 10428} 10429 10430/* Return the innermost template arguments that, when applied to a 10431 template specialization whose innermost template parameters are 10432 TPARMS, and whose specialization arguments are PARMS, yield the 10433 ARGS. 10434 10435 For example, suppose we have: 10436 10437 template <class T, class U> struct S {}; 10438 template <class T> struct S<T*, int> {}; 10439 10440 Then, suppose we want to get `S<double*, int>'. The TPARMS will be 10441 {T}, the PARMS will be {T*, int} and the ARGS will be {double*, 10442 int}. The resulting vector will be {double}, indicating that `T' 10443 is bound to `double'. */ 10444 10445static tree 10446get_class_bindings (tree tparms, tree parms, tree args) 10447{ 10448 int i, ntparms = TREE_VEC_LENGTH (tparms); 10449 tree vec = make_tree_vec (ntparms); 10450 10451 if (unify (tparms, vec, parms, INNERMOST_TEMPLATE_ARGS (args), 10452 UNIFY_ALLOW_NONE)) 10453 return NULL_TREE; 10454 10455 for (i = 0; i < ntparms; ++i) 10456 if (! TREE_VEC_ELT (vec, i)) 10457 return NULL_TREE; 10458 10459 if (verify_class_unification (vec, parms, args)) 10460 return NULL_TREE; 10461 10462 return vec; 10463} 10464 10465/* In INSTANTIATIONS is a list of <INSTANTIATION, TEMPLATE> pairs. 10466 Pick the most specialized template, and return the corresponding 10467 instantiation, or if there is no corresponding instantiation, the 10468 template itself. If there is no most specialized template, 10469 error_mark_node is returned. If there are no templates at all, 10470 NULL_TREE is returned. */ 10471 10472tree 10473most_specialized_instantiation (tree instantiations) 10474{ 10475 tree fn, champ; 10476 int fate; 10477 10478 if (!instantiations) 10479 return NULL_TREE; 10480 10481 champ = instantiations; 10482 for (fn = TREE_CHAIN (instantiations); fn; fn = TREE_CHAIN (fn)) 10483 { 10484 fate = more_specialized (TREE_VALUE (champ), TREE_VALUE (fn), 10485 DEDUCE_EXACT, -1); 10486 if (fate == 1) 10487 ; 10488 else 10489 { 10490 if (fate == 0) 10491 { 10492 fn = TREE_CHAIN (fn); 10493 if (! fn) 10494 return error_mark_node; 10495 } 10496 champ = fn; 10497 } 10498 } 10499 10500 for (fn = instantiations; fn && fn != champ; fn = TREE_CHAIN (fn)) 10501 { 10502 fate = more_specialized (TREE_VALUE (champ), TREE_VALUE (fn), 10503 DEDUCE_EXACT, -1); 10504 if (fate != 1) 10505 return error_mark_node; 10506 } 10507 10508 return TREE_PURPOSE (champ) ? TREE_PURPOSE (champ) : TREE_VALUE (champ); 10509} 10510 10511/* Return the most specialized of the list of templates in FNS that can 10512 produce an instantiation matching DECL, given the explicit template 10513 arguments EXPLICIT_ARGS. */ 10514 10515static tree 10516most_specialized (tree fns, tree decl, tree explicit_args) 10517{ 10518 tree candidates = NULL_TREE; 10519 tree fn, args; 10520 10521 for (fn = fns; fn; fn = TREE_CHAIN (fn)) 10522 { 10523 tree candidate = TREE_VALUE (fn); 10524 10525 args = get_bindings (candidate, decl, explicit_args); 10526 if (args) 10527 candidates = tree_cons (NULL_TREE, candidate, candidates); 10528 } 10529 10530 return most_specialized_instantiation (candidates); 10531} 10532 10533/* If DECL is a specialization of some template, return the most 10534 general such template. Otherwise, returns NULL_TREE. 10535 10536 For example, given: 10537 10538 template <class T> struct S { template <class U> void f(U); }; 10539 10540 if TMPL is `template <class U> void S<int>::f(U)' this will return 10541 the full template. This function will not trace past partial 10542 specializations, however. For example, given in addition: 10543 10544 template <class T> struct S<T*> { template <class U> void f(U); }; 10545 10546 if TMPL is `template <class U> void S<int*>::f(U)' this will return 10547 `template <class T> template <class U> S<T*>::f(U)'. */ 10548 10549tree 10550most_general_template (tree decl) 10551{ 10552 /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is 10553 an immediate specialization. */ 10554 if (TREE_CODE (decl) == FUNCTION_DECL) 10555 { 10556 if (DECL_TEMPLATE_INFO (decl)) { 10557 decl = DECL_TI_TEMPLATE (decl); 10558 10559 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a 10560 template friend. */ 10561 if (TREE_CODE (decl) != TEMPLATE_DECL) 10562 return NULL_TREE; 10563 } else 10564 return NULL_TREE; 10565 } 10566 10567 /* Look for more and more general templates. */ 10568 while (DECL_TEMPLATE_INFO (decl)) 10569 { 10570 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases. 10571 (See cp-tree.h for details.) */ 10572 if (TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL) 10573 break; 10574 10575 if (CLASS_TYPE_P (TREE_TYPE (decl)) 10576 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl))) 10577 break; 10578 10579 /* Stop if we run into an explicitly specialized class template. */ 10580 if (!DECL_NAMESPACE_SCOPE_P (decl) 10581 && DECL_CONTEXT (decl) 10582 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl))) 10583 break; 10584 10585 decl = DECL_TI_TEMPLATE (decl); 10586 } 10587 10588 return decl; 10589} 10590 10591/* Return the most specialized of the class template specializations 10592 of TMPL which can produce an instantiation matching ARGS, or 10593 error_mark_node if the choice is ambiguous. */ 10594 10595static tree 10596most_specialized_class (tree tmpl, tree args) 10597{ 10598 tree list = NULL_TREE; 10599 tree t; 10600 tree champ; 10601 int fate; 10602 10603 tmpl = most_general_template (tmpl); 10604 for (t = DECL_TEMPLATE_SPECIALIZATIONS (tmpl); t; t = TREE_CHAIN (t)) 10605 { 10606 tree spec_args 10607 = get_class_bindings (TREE_VALUE (t), TREE_PURPOSE (t), args); 10608 if (spec_args) 10609 { 10610 list = tree_cons (TREE_PURPOSE (t), TREE_VALUE (t), list); 10611 TREE_TYPE (list) = TREE_TYPE (t); 10612 } 10613 } 10614 10615 if (! list) 10616 return NULL_TREE; 10617 10618 t = list; 10619 champ = t; 10620 t = TREE_CHAIN (t); 10621 for (; t; t = TREE_CHAIN (t)) 10622 { 10623 fate = more_specialized_class (champ, t, args); 10624 if (fate == 1) 10625 ; 10626 else 10627 { 10628 if (fate == 0) 10629 { 10630 t = TREE_CHAIN (t); 10631 if (! t) 10632 return error_mark_node; 10633 } 10634 champ = t; 10635 } 10636 } 10637 10638 for (t = list; t && t != champ; t = TREE_CHAIN (t)) 10639 { 10640 fate = more_specialized_class (champ, t, args); 10641 if (fate != 1) 10642 return error_mark_node; 10643 } 10644 10645 return champ; 10646} 10647 10648/* Explicitly instantiate DECL. */ 10649 10650void 10651do_decl_instantiation (tree decl, tree storage) 10652{ 10653 tree result = NULL_TREE; 10654 int extern_p = 0; 10655 10656 if (!decl) 10657 /* An error occurred, for which grokdeclarator has already issued 10658 an appropriate message. */ 10659 return; 10660 else if (! DECL_LANG_SPECIFIC (decl)) 10661 { 10662 error ("explicit instantiation of non-template `%#D'", decl); 10663 return; 10664 } 10665 else if (TREE_CODE (decl) == VAR_DECL) 10666 { 10667 /* There is an asymmetry here in the way VAR_DECLs and 10668 FUNCTION_DECLs are handled by grokdeclarator. In the case of 10669 the latter, the DECL we get back will be marked as a 10670 template instantiation, and the appropriate 10671 DECL_TEMPLATE_INFO will be set up. This does not happen for 10672 VAR_DECLs so we do the lookup here. Probably, grokdeclarator 10673 should handle VAR_DECLs as it currently handles 10674 FUNCTION_DECLs. */ 10675 result = lookup_field (DECL_CONTEXT (decl), DECL_NAME (decl), 0, false); 10676 if (!result || TREE_CODE (result) != VAR_DECL) 10677 { 10678 error ("no matching template for `%D' found", decl); 10679 return; 10680 } 10681 } 10682 else if (TREE_CODE (decl) != FUNCTION_DECL) 10683 { 10684 error ("explicit instantiation of `%#D'", decl); 10685 return; 10686 } 10687 else 10688 result = decl; 10689 10690 /* Check for various error cases. Note that if the explicit 10691 instantiation is valid the RESULT will currently be marked as an 10692 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set 10693 until we get here. */ 10694 10695 if (DECL_TEMPLATE_SPECIALIZATION (result)) 10696 { 10697 /* DR 259 [temp.spec]. 10698 10699 Both an explicit instantiation and a declaration of an explicit 10700 specialization shall not appear in a program unless the explicit 10701 instantiation follows a declaration of the explicit specialization. 10702 10703 For a given set of template parameters, if an explicit 10704 instantiation of a template appears after a declaration of an 10705 explicit specialization for that template, the explicit 10706 instantiation has no effect. */ 10707 return; 10708 } 10709 else if (DECL_EXPLICIT_INSTANTIATION (result)) 10710 { 10711 /* [temp.spec] 10712 10713 No program shall explicitly instantiate any template more 10714 than once. 10715 10716 We check DECL_INTERFACE_KNOWN so as not to complain when the first 10717 instantiation was `extern' and the second is not, and EXTERN_P for 10718 the opposite case. If -frepo, chances are we already got marked 10719 as an explicit instantiation because of the repo file. */ 10720 if (DECL_INTERFACE_KNOWN (result) && !extern_p && !flag_use_repository) 10721 pedwarn ("duplicate explicit instantiation of `%#D'", result); 10722 10723 /* If we've already instantiated the template, just return now. */ 10724 if (DECL_INTERFACE_KNOWN (result)) 10725 return; 10726 } 10727 else if (!DECL_IMPLICIT_INSTANTIATION (result)) 10728 { 10729 error ("no matching template for `%D' found", result); 10730 return; 10731 } 10732 else if (!DECL_TEMPLATE_INFO (result)) 10733 { 10734 pedwarn ("explicit instantiation of non-template `%#D'", result); 10735 return; 10736 } 10737 10738 if (storage == NULL_TREE) 10739 ; 10740 else if (storage == ridpointers[(int) RID_EXTERN]) 10741 { 10742 if (pedantic && !in_system_header) 10743 pedwarn ("ISO C++ forbids the use of `extern' on explicit instantiations"); 10744 extern_p = 1; 10745 } 10746 else 10747 error ("storage class `%D' applied to template instantiation", 10748 storage); 10749 10750 SET_DECL_EXPLICIT_INSTANTIATION (result); 10751 mark_decl_instantiated (result, extern_p); 10752 repo_template_instantiated (result, extern_p); 10753 if (! extern_p) 10754 instantiate_decl (result, /*defer_ok=*/1); 10755} 10756 10757void 10758mark_class_instantiated (tree t, int extern_p) 10759{ 10760 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t); 10761 SET_CLASSTYPE_INTERFACE_KNOWN (t); 10762 CLASSTYPE_INTERFACE_ONLY (t) = extern_p; 10763 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = extern_p; 10764 if (! extern_p) 10765 { 10766 CLASSTYPE_DEBUG_REQUESTED (t) = 1; 10767 rest_of_type_compilation (t, 1); 10768 } 10769} 10770 10771/* Called from do_type_instantiation through binding_table_foreach to 10772 do recursive instantiation for the type bound in ENTRY. */ 10773static void 10774bt_instantiate_type_proc (binding_entry entry, void *data) 10775{ 10776 tree storage = *(tree *) data; 10777 10778 if (IS_AGGR_TYPE (entry->type) 10779 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry->type))) 10780 do_type_instantiation (TYPE_MAIN_DECL (entry->type), storage, 0); 10781} 10782 10783/* Perform an explicit instantiation of template class T. STORAGE, if 10784 non-null, is the RID for extern, inline or static. COMPLAIN is 10785 nonzero if this is called from the parser, zero if called recursively, 10786 since the standard is unclear (as detailed below). */ 10787 10788void 10789do_type_instantiation (tree t, tree storage, tsubst_flags_t complain) 10790{ 10791 int extern_p = 0; 10792 int nomem_p = 0; 10793 int static_p = 0; 10794 10795 if (TREE_CODE (t) == TYPE_DECL) 10796 t = TREE_TYPE (t); 10797 10798 if (! CLASS_TYPE_P (t) || ! CLASSTYPE_TEMPLATE_INFO (t)) 10799 { 10800 error ("explicit instantiation of non-template type `%T'", t); 10801 return; 10802 } 10803 10804 complete_type (t); 10805 10806 if (!COMPLETE_TYPE_P (t)) 10807 { 10808 if (complain & tf_error) 10809 error ("explicit instantiation of `%#T' before definition of template", 10810 t); 10811 return; 10812 } 10813 10814 if (storage != NULL_TREE) 10815 { 10816 if (pedantic && !in_system_header) 10817 pedwarn("ISO C++ forbids the use of `%s' on explicit instantiations", 10818 IDENTIFIER_POINTER (storage)); 10819 10820 if (storage == ridpointers[(int) RID_INLINE]) 10821 nomem_p = 1; 10822 else if (storage == ridpointers[(int) RID_EXTERN]) 10823 extern_p = 1; 10824 else if (storage == ridpointers[(int) RID_STATIC]) 10825 static_p = 1; 10826 else 10827 { 10828 error ("storage class `%D' applied to template instantiation", 10829 storage); 10830 extern_p = 0; 10831 } 10832 } 10833 10834 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t)) 10835 { 10836 /* DR 259 [temp.spec]. 10837 10838 Both an explicit instantiation and a declaration of an explicit 10839 specialization shall not appear in a program unless the explicit 10840 instantiation follows a declaration of the explicit specialization. 10841 10842 For a given set of template parameters, if an explicit 10843 instantiation of a template appears after a declaration of an 10844 explicit specialization for that template, the explicit 10845 instantiation has no effect. */ 10846 return; 10847 } 10848 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t)) 10849 { 10850 /* [temp.spec] 10851 10852 No program shall explicitly instantiate any template more 10853 than once. 10854 10855 If CLASSTYPE_INTERFACE_ONLY, then the first explicit instantiation 10856 was `extern'. If EXTERN_P then the second is. If -frepo, chances 10857 are we already got marked as an explicit instantiation because of the 10858 repo file. All these cases are OK. */ 10859 if (!CLASSTYPE_INTERFACE_ONLY (t) && !extern_p && !flag_use_repository 10860 && (complain & tf_error)) 10861 pedwarn ("duplicate explicit instantiation of `%#T'", t); 10862 10863 /* If we've already instantiated the template, just return now. */ 10864 if (!CLASSTYPE_INTERFACE_ONLY (t)) 10865 return; 10866 } 10867 10868 mark_class_instantiated (t, extern_p); 10869 repo_template_instantiated (t, extern_p); 10870 10871 if (nomem_p) 10872 return; 10873 10874 { 10875 tree tmp; 10876 10877 /* In contrast to implicit instantiation, where only the 10878 declarations, and not the definitions, of members are 10879 instantiated, we have here: 10880 10881 [temp.explicit] 10882 10883 The explicit instantiation of a class template specialization 10884 implies the instantiation of all of its members not 10885 previously explicitly specialized in the translation unit 10886 containing the explicit instantiation. 10887 10888 Of course, we can't instantiate member template classes, since 10889 we don't have any arguments for them. Note that the standard 10890 is unclear on whether the instantiation of the members are 10891 *explicit* instantiations or not. We choose to be generous, 10892 and not set DECL_EXPLICIT_INSTANTIATION. Therefore, we allow 10893 the explicit instantiation of a class where some of the members 10894 have no definition in the current translation unit. */ 10895 10896 if (! static_p) 10897 for (tmp = TYPE_METHODS (t); tmp; tmp = TREE_CHAIN (tmp)) 10898 if (TREE_CODE (tmp) == FUNCTION_DECL 10899 && DECL_TEMPLATE_INSTANTIATION (tmp)) 10900 { 10901 mark_decl_instantiated (tmp, extern_p); 10902 repo_template_instantiated (tmp, extern_p); 10903 if (! extern_p) 10904 instantiate_decl (tmp, /*defer_ok=*/1); 10905 } 10906 10907 for (tmp = TYPE_FIELDS (t); tmp; tmp = TREE_CHAIN (tmp)) 10908 if (TREE_CODE (tmp) == VAR_DECL && DECL_TEMPLATE_INSTANTIATION (tmp)) 10909 { 10910 mark_decl_instantiated (tmp, extern_p); 10911 repo_template_instantiated (tmp, extern_p); 10912 if (! extern_p) 10913 instantiate_decl (tmp, /*defer_ok=*/1); 10914 } 10915 10916 if (CLASSTYPE_NESTED_UTDS (t)) 10917 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t), 10918 bt_instantiate_type_proc, &storage); 10919 } 10920} 10921 10922/* Given a function DECL, which is a specialization of TMPL, modify 10923 DECL to be a re-instantiation of TMPL with the same template 10924 arguments. TMPL should be the template into which tsubst'ing 10925 should occur for DECL, not the most general template. 10926 10927 One reason for doing this is a scenario like this: 10928 10929 template <class T> 10930 void f(const T&, int i); 10931 10932 void g() { f(3, 7); } 10933 10934 template <class T> 10935 void f(const T& t, const int i) { } 10936 10937 Note that when the template is first instantiated, with 10938 instantiate_template, the resulting DECL will have no name for the 10939 first parameter, and the wrong type for the second. So, when we go 10940 to instantiate the DECL, we regenerate it. */ 10941 10942static void 10943regenerate_decl_from_template (tree decl, tree tmpl) 10944{ 10945 /* The most general version of TMPL. */ 10946 tree gen_tmpl; 10947 /* The arguments used to instantiate DECL, from the most general 10948 template. */ 10949 tree args; 10950 tree code_pattern; 10951 tree new_decl; 10952 bool unregistered; 10953 10954 args = DECL_TI_ARGS (decl); 10955 code_pattern = DECL_TEMPLATE_RESULT (tmpl); 10956 10957 /* Unregister the specialization so that when we tsubst we will not 10958 just return DECL. We don't have to unregister DECL from TMPL 10959 because if would only be registered there if it were a partial 10960 instantiation of a specialization, which it isn't: it's a full 10961 instantiation. */ 10962 gen_tmpl = most_general_template (tmpl); 10963 unregistered = reregister_specialization (decl, gen_tmpl, 10964 /*new_spec=*/NULL_TREE); 10965 10966 /* If the DECL was not unregistered then something peculiar is 10967 happening: we created a specialization but did not call 10968 register_specialization for it. */ 10969 my_friendly_assert (unregistered, 0); 10970 10971 /* Make sure that we can see identifiers, and compute access 10972 correctly. */ 10973 push_access_scope (decl); 10974 10975 /* Do the substitution to get the new declaration. */ 10976 new_decl = tsubst (code_pattern, args, tf_error, NULL_TREE); 10977 10978 if (TREE_CODE (decl) == VAR_DECL) 10979 { 10980 /* Set up DECL_INITIAL, since tsubst doesn't. */ 10981 if (!DECL_INITIALIZED_IN_CLASS_P (decl)) 10982 DECL_INITIAL (new_decl) = 10983 tsubst_expr (DECL_INITIAL (code_pattern), args, 10984 tf_error, DECL_TI_TEMPLATE (decl)); 10985 } 10986 else if (TREE_CODE (decl) == FUNCTION_DECL) 10987 { 10988 /* Convince duplicate_decls to use the DECL_ARGUMENTS from the 10989 new decl. */ 10990 DECL_INITIAL (new_decl) = error_mark_node; 10991 /* And don't complain about a duplicate definition. */ 10992 DECL_INITIAL (decl) = NULL_TREE; 10993 } 10994 10995 pop_access_scope (decl); 10996 10997 /* The immediate parent of the new template is still whatever it was 10998 before, even though tsubst sets DECL_TI_TEMPLATE up as the most 10999 general template. We also reset the DECL_ASSEMBLER_NAME since 11000 tsubst always calculates the name as if the function in question 11001 were really a template instance, and sometimes, with friend 11002 functions, this is not so. See tsubst_friend_function for 11003 details. */ 11004 DECL_TI_TEMPLATE (new_decl) = DECL_TI_TEMPLATE (decl); 11005 COPY_DECL_ASSEMBLER_NAME (decl, new_decl); 11006 COPY_DECL_RTL (decl, new_decl); 11007 DECL_USE_TEMPLATE (new_decl) = DECL_USE_TEMPLATE (decl); 11008 11009 /* Call duplicate decls to merge the old and new declarations. */ 11010 duplicate_decls (new_decl, decl); 11011 11012 /* Now, re-register the specialization. */ 11013 register_specialization (decl, gen_tmpl, args); 11014} 11015 11016/* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be 11017 substituted to get DECL. */ 11018 11019tree 11020template_for_substitution (tree decl) 11021{ 11022 tree tmpl = DECL_TI_TEMPLATE (decl); 11023 11024 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern 11025 for the instantiation. This is not always the most general 11026 template. Consider, for example: 11027 11028 template <class T> 11029 struct S { template <class U> void f(); 11030 template <> void f<int>(); }; 11031 11032 and an instantiation of S<double>::f<int>. We want TD to be the 11033 specialization S<T>::f<int>, not the more general S<T>::f<U>. */ 11034 while (/* An instantiation cannot have a definition, so we need a 11035 more general template. */ 11036 DECL_TEMPLATE_INSTANTIATION (tmpl) 11037 /* We must also deal with friend templates. Given: 11038 11039 template <class T> struct S { 11040 template <class U> friend void f() {}; 11041 }; 11042 11043 S<int>::f<U> say, is not an instantiation of S<T>::f<U>, 11044 so far as the language is concerned, but that's still 11045 where we get the pattern for the instantiation from. On 11046 other hand, if the definition comes outside the class, say: 11047 11048 template <class T> struct S { 11049 template <class U> friend void f(); 11050 }; 11051 template <class U> friend void f() {} 11052 11053 we don't need to look any further. That's what the check for 11054 DECL_INITIAL is for. */ 11055 || (TREE_CODE (decl) == FUNCTION_DECL 11056 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl) 11057 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl)))) 11058 { 11059 /* The present template, TD, should not be a definition. If it 11060 were a definition, we should be using it! Note that we 11061 cannot restructure the loop to just keep going until we find 11062 a template with a definition, since that might go too far if 11063 a specialization was declared, but not defined. */ 11064 my_friendly_assert (!(TREE_CODE (decl) == VAR_DECL 11065 && !DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (tmpl))), 11066 0); 11067 11068 /* Fetch the more general template. */ 11069 tmpl = DECL_TI_TEMPLATE (tmpl); 11070 } 11071 11072 return tmpl; 11073} 11074 11075/* Produce the definition of D, a _DECL generated from a template. If 11076 DEFER_OK is nonzero, then we don't have to actually do the 11077 instantiation now; we just have to do it sometime. */ 11078 11079tree 11080instantiate_decl (tree d, int defer_ok) 11081{ 11082 tree tmpl = DECL_TI_TEMPLATE (d); 11083 tree gen_args; 11084 tree args; 11085 tree td; 11086 tree code_pattern; 11087 tree spec; 11088 tree gen_tmpl; 11089 int pattern_defined; 11090 int need_push; 11091 location_t saved_loc = input_location; 11092 11093 /* This function should only be used to instantiate templates for 11094 functions and static member variables. */ 11095 my_friendly_assert (TREE_CODE (d) == FUNCTION_DECL 11096 || TREE_CODE (d) == VAR_DECL, 0); 11097 11098 /* Variables are never deferred; if instantiation is required, they 11099 are instantiated right away. That allows for better code in the 11100 case that an expression refers to the value of the variable -- 11101 if the variable has a constant value the referring expression can 11102 take advantage of that fact. */ 11103 if (TREE_CODE (d) == VAR_DECL) 11104 defer_ok = 0; 11105 11106 /* Don't instantiate cloned functions. Instead, instantiate the 11107 functions they cloned. */ 11108 if (TREE_CODE (d) == FUNCTION_DECL && DECL_CLONED_FUNCTION_P (d)) 11109 d = DECL_CLONED_FUNCTION (d); 11110 11111 if (DECL_TEMPLATE_INSTANTIATED (d)) 11112 /* D has already been instantiated. It might seem reasonable to 11113 check whether or not D is an explicit instantiation, and, if so, 11114 stop here. But when an explicit instantiation is deferred 11115 until the end of the compilation, DECL_EXPLICIT_INSTANTIATION 11116 is set, even though we still need to do the instantiation. */ 11117 return d; 11118 11119 /* If we already have a specialization of this declaration, then 11120 there's no reason to instantiate it. Note that 11121 retrieve_specialization gives us both instantiations and 11122 specializations, so we must explicitly check 11123 DECL_TEMPLATE_SPECIALIZATION. */ 11124 gen_tmpl = most_general_template (tmpl); 11125 gen_args = DECL_TI_ARGS (d); 11126 spec = retrieve_specialization (gen_tmpl, gen_args); 11127 if (spec != NULL_TREE && DECL_TEMPLATE_SPECIALIZATION (spec)) 11128 return spec; 11129 11130 /* This needs to happen before any tsubsting. */ 11131 if (! push_tinst_level (d)) 11132 return d; 11133 11134 timevar_push (TV_PARSE); 11135 11136 /* We may be in the middle of deferred access check. Disable it now. */ 11137 push_deferring_access_checks (dk_no_deferred); 11138 11139 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern 11140 for the instantiation. */ 11141 td = template_for_substitution (d); 11142 code_pattern = DECL_TEMPLATE_RESULT (td); 11143 11144 if ((DECL_NAMESPACE_SCOPE_P (d) && !DECL_INITIALIZED_IN_CLASS_P (d)) 11145 || DECL_TEMPLATE_SPECIALIZATION (td)) 11146 /* In the case of a friend template whose definition is provided 11147 outside the class, we may have too many arguments. Drop the 11148 ones we don't need. The same is true for specializations. */ 11149 args = get_innermost_template_args 11150 (gen_args, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td))); 11151 else 11152 args = gen_args; 11153 11154 if (TREE_CODE (d) == FUNCTION_DECL) 11155 pattern_defined = (DECL_SAVED_TREE (code_pattern) != NULL_TREE); 11156 else 11157 pattern_defined = ! DECL_IN_AGGR_P (code_pattern); 11158 11159 input_location = DECL_SOURCE_LOCATION (d); 11160 11161 if (pattern_defined) 11162 { 11163 /* Let the repository code that this template definition is 11164 available. 11165 11166 The repository doesn't need to know about cloned functions 11167 because they never actually show up in the object file. It 11168 does need to know about the clones; those are the symbols 11169 that the linker will be emitting error messages about. */ 11170 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (d) 11171 || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (d)) 11172 { 11173 tree t; 11174 11175 for (t = TREE_CHAIN (d); 11176 t && DECL_CLONED_FUNCTION_P (t); 11177 t = TREE_CHAIN (t)) 11178 repo_template_used (t); 11179 } 11180 else 11181 repo_template_used (d); 11182 11183 if (at_eof) 11184 import_export_decl (d); 11185 } 11186 11187 if (!defer_ok) 11188 { 11189 /* Recheck the substitutions to obtain any warning messages 11190 about ignoring cv qualifiers. */ 11191 tree gen = DECL_TEMPLATE_RESULT (gen_tmpl); 11192 tree type = TREE_TYPE (gen); 11193 11194 /* Make sure that we can see identifiers, and compute access 11195 correctly. D is already the target FUNCTION_DECL with the 11196 right context. */ 11197 push_access_scope (d); 11198 11199 if (TREE_CODE (gen) == FUNCTION_DECL) 11200 { 11201 tsubst (DECL_ARGUMENTS (gen), gen_args, tf_error | tf_warning, d); 11202 tsubst (TYPE_RAISES_EXCEPTIONS (type), gen_args, 11203 tf_error | tf_warning, d); 11204 /* Don't simply tsubst the function type, as that will give 11205 duplicate warnings about poor parameter qualifications. 11206 The function arguments are the same as the decl_arguments 11207 without the top level cv qualifiers. */ 11208 type = TREE_TYPE (type); 11209 } 11210 tsubst (type, gen_args, tf_error | tf_warning, d); 11211 11212 pop_access_scope (d); 11213 } 11214 11215 if (TREE_CODE (d) == VAR_DECL && DECL_INITIALIZED_IN_CLASS_P (d) 11216 && DECL_INITIAL (d) == NULL_TREE) 11217 /* We should have set up DECL_INITIAL in instantiate_class_template. */ 11218 abort (); 11219 /* Reject all external templates except inline functions. */ 11220 else if (DECL_INTERFACE_KNOWN (d) 11221 && ! DECL_NOT_REALLY_EXTERN (d) 11222 && ! (TREE_CODE (d) == FUNCTION_DECL 11223 && DECL_INLINE (d))) 11224 goto out; 11225 /* Defer all other templates, unless we have been explicitly 11226 forbidden from doing so. We restore the source position here 11227 because it's used by add_pending_template. */ 11228 else if (! pattern_defined || defer_ok) 11229 { 11230 input_location = saved_loc; 11231 11232 if (at_eof && !pattern_defined 11233 && DECL_EXPLICIT_INSTANTIATION (d)) 11234 /* [temp.explicit] 11235 11236 The definition of a non-exported function template, a 11237 non-exported member function template, or a non-exported 11238 member function or static data member of a class template 11239 shall be present in every translation unit in which it is 11240 explicitly instantiated. */ 11241 pedwarn 11242 ("explicit instantiation of `%D' but no definition available", d); 11243 11244 add_pending_template (d); 11245 goto out; 11246 } 11247 11248 need_push = !global_bindings_p (); 11249 if (need_push) 11250 push_to_top_level (); 11251 11252 /* Mark D as instantiated so that recursive calls to 11253 instantiate_decl do not try to instantiate it again. */ 11254 DECL_TEMPLATE_INSTANTIATED (d) = 1; 11255 11256 /* Regenerate the declaration in case the template has been modified 11257 by a subsequent redeclaration. */ 11258 regenerate_decl_from_template (d, td); 11259 11260 /* We already set the file and line above. Reset them now in case 11261 they changed as a result of calling 11262 regenerate_decl_from_template. */ 11263 input_location = DECL_SOURCE_LOCATION (d); 11264 11265 if (TREE_CODE (d) == VAR_DECL) 11266 { 11267 /* Clear out DECL_RTL; whatever was there before may not be right 11268 since we've reset the type of the declaration. */ 11269 SET_DECL_RTL (d, NULL_RTX); 11270 11271 DECL_IN_AGGR_P (d) = 0; 11272 import_export_decl (d); 11273 DECL_EXTERNAL (d) = ! DECL_NOT_REALLY_EXTERN (d); 11274 11275 if (DECL_EXTERNAL (d)) 11276 { 11277 /* The fact that this code is executing indicates that: 11278 11279 (1) D is a template static data member, for which a 11280 definition is available. 11281 11282 (2) An implicit or explicit instantiation has occurred. 11283 11284 (3) We are not going to emit a definition of the static 11285 data member at this time. 11286 11287 This situation is peculiar, but it occurs on platforms 11288 without weak symbols when performing an implicit 11289 instantiation. There, we cannot implicitly instantiate a 11290 defined static data member in more than one translation 11291 unit, so import_export_decl marks the declaration as 11292 external; we must rely on explicit instantiation. 11293 11294 Reset instantiated marker to make sure that later 11295 explicit instantiation will be processed. */ 11296 DECL_TEMPLATE_INSTANTIATED (d) = 0; 11297 } 11298 else 11299 { 11300 /* This is done in analogous to `start_decl'. It is 11301 required for correct access checking. */ 11302 push_nested_class (DECL_CONTEXT (d)); 11303 cp_finish_decl (d, 11304 (!DECL_INITIALIZED_IN_CLASS_P (d) 11305 ? DECL_INITIAL (d) : NULL_TREE), 11306 NULL_TREE, 0); 11307 /* Normally, pop_nested_class is called by cp_finish_decl 11308 above. But when instantiate_decl is triggered during 11309 instantiate_class_template processing, its DECL_CONTEXT 11310 is still not completed yet, and pop_nested_class isn't 11311 called. */ 11312 if (!COMPLETE_TYPE_P (DECL_CONTEXT (d))) 11313 pop_nested_class (); 11314 } 11315 /* We're not deferring instantiation any more. */ 11316 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d)) = 0; 11317 } 11318 else if (TREE_CODE (d) == FUNCTION_DECL) 11319 { 11320 htab_t saved_local_specializations; 11321 tree subst_decl; 11322 tree tmpl_parm; 11323 tree spec_parm; 11324 11325 /* Mark D as instantiated so that recursive calls to 11326 instantiate_decl do not try to instantiate it again. */ 11327 DECL_TEMPLATE_INSTANTIATED (d) = 1; 11328 11329 /* Save away the current list, in case we are instantiating one 11330 template from within the body of another. */ 11331 saved_local_specializations = local_specializations; 11332 11333 /* Set up the list of local specializations. */ 11334 local_specializations = htab_create (37, 11335 hash_local_specialization, 11336 eq_local_specializations, 11337 NULL); 11338 11339 /* Set up context. */ 11340 import_export_decl (d); 11341 start_function (NULL_TREE, d, NULL_TREE, SF_PRE_PARSED); 11342 11343 /* Create substitution entries for the parameters. */ 11344 subst_decl = DECL_TEMPLATE_RESULT (template_for_substitution (d)); 11345 tmpl_parm = DECL_ARGUMENTS (subst_decl); 11346 spec_parm = DECL_ARGUMENTS (d); 11347 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d)) 11348 { 11349 register_local_specialization (spec_parm, tmpl_parm); 11350 spec_parm = skip_artificial_parms_for (d, spec_parm); 11351 tmpl_parm = skip_artificial_parms_for (subst_decl, tmpl_parm); 11352 } 11353 while (tmpl_parm) 11354 { 11355 register_local_specialization (spec_parm, tmpl_parm); 11356 tmpl_parm = TREE_CHAIN (tmpl_parm); 11357 spec_parm = TREE_CHAIN (spec_parm); 11358 } 11359 my_friendly_assert (!spec_parm, 20020813); 11360 11361 /* Substitute into the body of the function. */ 11362 tsubst_expr (DECL_SAVED_TREE (code_pattern), args, 11363 tf_error | tf_warning, tmpl); 11364 11365 /* We don't need the local specializations any more. */ 11366 htab_delete (local_specializations); 11367 local_specializations = saved_local_specializations; 11368 11369 /* We're not deferring instantiation any more. */ 11370 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d)) = 0; 11371 11372 /* Finish the function. */ 11373 d = finish_function (0); 11374 expand_or_defer_fn (d); 11375 } 11376 11377 if (need_push) 11378 pop_from_top_level (); 11379 11380out: 11381 input_location = saved_loc; 11382 pop_deferring_access_checks (); 11383 pop_tinst_level (); 11384 11385 timevar_pop (TV_PARSE); 11386 11387 return d; 11388} 11389 11390/* Run through the list of templates that we wish we could 11391 instantiate, and instantiate any we can. */ 11392 11393int 11394instantiate_pending_templates (void) 11395{ 11396 tree *t; 11397 tree last = NULL_TREE; 11398 int instantiated_something = 0; 11399 int reconsider; 11400 location_t saved_loc = input_location; 11401 11402 do 11403 { 11404 reconsider = 0; 11405 11406 t = &pending_templates; 11407 while (*t) 11408 { 11409 tree instantiation = TREE_VALUE (*t); 11410 11411 reopen_tinst_level (TREE_PURPOSE (*t)); 11412 11413 if (TYPE_P (instantiation)) 11414 { 11415 tree fn; 11416 11417 if (!COMPLETE_TYPE_P (instantiation)) 11418 { 11419 instantiate_class_template (instantiation); 11420 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation)) 11421 for (fn = TYPE_METHODS (instantiation); 11422 fn; 11423 fn = TREE_CHAIN (fn)) 11424 if (! DECL_ARTIFICIAL (fn)) 11425 instantiate_decl (fn, /*defer_ok=*/0); 11426 if (COMPLETE_TYPE_P (instantiation)) 11427 { 11428 instantiated_something = 1; 11429 reconsider = 1; 11430 } 11431 } 11432 11433 if (COMPLETE_TYPE_P (instantiation)) 11434 /* If INSTANTIATION has been instantiated, then we don't 11435 need to consider it again in the future. */ 11436 *t = TREE_CHAIN (*t); 11437 else 11438 { 11439 last = *t; 11440 t = &TREE_CHAIN (*t); 11441 } 11442 } 11443 else 11444 { 11445 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation) 11446 && !DECL_TEMPLATE_INSTANTIATED (instantiation)) 11447 { 11448 instantiation = instantiate_decl (instantiation, 11449 /*defer_ok=*/0); 11450 if (DECL_TEMPLATE_INSTANTIATED (instantiation)) 11451 { 11452 instantiated_something = 1; 11453 reconsider = 1; 11454 } 11455 } 11456 11457 if (DECL_TEMPLATE_SPECIALIZATION (instantiation) 11458 || DECL_TEMPLATE_INSTANTIATED (instantiation)) 11459 /* If INSTANTIATION has been instantiated, then we don't 11460 need to consider it again in the future. */ 11461 *t = TREE_CHAIN (*t); 11462 else 11463 { 11464 last = *t; 11465 t = &TREE_CHAIN (*t); 11466 } 11467 } 11468 tinst_depth = 0; 11469 current_tinst_level = NULL_TREE; 11470 } 11471 last_pending_template = last; 11472 } 11473 while (reconsider); 11474 11475 input_location = saved_loc; 11476 return instantiated_something; 11477} 11478 11479/* Substitute ARGVEC into T, which is a list of initializers for 11480 either base class or a non-static data member. The TREE_PURPOSEs 11481 are DECLs, and the TREE_VALUEs are the initializer values. Used by 11482 instantiate_decl. */ 11483 11484static tree 11485tsubst_initializer_list (tree t, tree argvec) 11486{ 11487 tree inits = NULL_TREE; 11488 11489 for (; t; t = TREE_CHAIN (t)) 11490 { 11491 tree decl; 11492 tree init; 11493 tree val; 11494 11495 decl = tsubst_copy (TREE_PURPOSE (t), argvec, tf_error | tf_warning, 11496 NULL_TREE); 11497 decl = expand_member_init (decl); 11498 if (decl && !DECL_P (decl)) 11499 in_base_initializer = 1; 11500 11501 init = tsubst_expr (TREE_VALUE (t), argvec, tf_error | tf_warning, 11502 NULL_TREE); 11503 if (!init) 11504 ; 11505 else if (TREE_CODE (init) == TREE_LIST) 11506 for (val = init; val; val = TREE_CHAIN (val)) 11507 TREE_VALUE (val) = convert_from_reference (TREE_VALUE (val)); 11508 else if (init != void_type_node) 11509 init = convert_from_reference (init); 11510 11511 in_base_initializer = 0; 11512 11513 if (decl) 11514 { 11515 init = build_tree_list (decl, init); 11516 TREE_CHAIN (init) = inits; 11517 inits = init; 11518 } 11519 } 11520 return inits; 11521} 11522 11523/* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */ 11524 11525static void 11526set_current_access_from_decl (tree decl) 11527{ 11528 if (TREE_PRIVATE (decl)) 11529 current_access_specifier = access_private_node; 11530 else if (TREE_PROTECTED (decl)) 11531 current_access_specifier = access_protected_node; 11532 else 11533 current_access_specifier = access_public_node; 11534} 11535 11536/* Instantiate an enumerated type. TAG is the template type, NEWTAG 11537 is the instantiation (which should have been created with 11538 start_enum) and ARGS are the template arguments to use. */ 11539 11540static void 11541tsubst_enum (tree tag, tree newtag, tree args) 11542{ 11543 tree e; 11544 11545 for (e = TYPE_VALUES (tag); e; e = TREE_CHAIN (e)) 11546 { 11547 tree value; 11548 tree decl; 11549 11550 decl = TREE_VALUE (e); 11551 /* Note that in a template enum, the TREE_VALUE is the 11552 CONST_DECL, not the corresponding INTEGER_CST. */ 11553 value = tsubst_expr (DECL_INITIAL (decl), 11554 args, tf_error | tf_warning, 11555 NULL_TREE); 11556 11557 /* Give this enumeration constant the correct access. */ 11558 set_current_access_from_decl (decl); 11559 11560 /* Actually build the enumerator itself. */ 11561 build_enumerator (DECL_NAME (decl), value, newtag); 11562 } 11563 11564 finish_enum (newtag); 11565 DECL_SOURCE_LOCATION (TYPE_NAME (newtag)) 11566 = DECL_SOURCE_LOCATION (TYPE_NAME (tag)); 11567} 11568 11569/* DECL is a FUNCTION_DECL that is a template specialization. Return 11570 its type -- but without substituting the innermost set of template 11571 arguments. So, innermost set of template parameters will appear in 11572 the type. */ 11573 11574tree 11575get_mostly_instantiated_function_type (tree decl) 11576{ 11577 tree fn_type; 11578 tree tmpl; 11579 tree targs; 11580 tree tparms; 11581 int parm_depth; 11582 11583 tmpl = most_general_template (DECL_TI_TEMPLATE (decl)); 11584 targs = DECL_TI_ARGS (decl); 11585 tparms = DECL_TEMPLATE_PARMS (tmpl); 11586 parm_depth = TMPL_PARMS_DEPTH (tparms); 11587 11588 /* There should be as many levels of arguments as there are levels 11589 of parameters. */ 11590 my_friendly_assert (parm_depth == TMPL_ARGS_DEPTH (targs), 0); 11591 11592 fn_type = TREE_TYPE (tmpl); 11593 11594 if (parm_depth == 1) 11595 /* No substitution is necessary. */ 11596 ; 11597 else 11598 { 11599 int i; 11600 tree partial_args; 11601 11602 /* Replace the innermost level of the TARGS with NULL_TREEs to 11603 let tsubst know not to substitute for those parameters. */ 11604 partial_args = make_tree_vec (TREE_VEC_LENGTH (targs)); 11605 for (i = 1; i < TMPL_ARGS_DEPTH (targs); ++i) 11606 SET_TMPL_ARGS_LEVEL (partial_args, i, 11607 TMPL_ARGS_LEVEL (targs, i)); 11608 SET_TMPL_ARGS_LEVEL (partial_args, 11609 TMPL_ARGS_DEPTH (targs), 11610 make_tree_vec (DECL_NTPARMS (tmpl))); 11611 11612 /* Make sure that we can see identifiers, and compute access 11613 correctly. We can just use the context of DECL for the 11614 partial substitution here. It depends only on outer template 11615 parameters, regardless of whether the innermost level is 11616 specialized or not. */ 11617 push_access_scope (decl); 11618 11619 ++processing_template_decl; 11620 /* Now, do the (partial) substitution to figure out the 11621 appropriate function type. */ 11622 fn_type = tsubst (fn_type, partial_args, tf_error, NULL_TREE); 11623 --processing_template_decl; 11624 11625 /* Substitute into the template parameters to obtain the real 11626 innermost set of parameters. This step is important if the 11627 innermost set of template parameters contains value 11628 parameters whose types depend on outer template parameters. */ 11629 TREE_VEC_LENGTH (partial_args)--; 11630 tparms = tsubst_template_parms (tparms, partial_args, tf_error); 11631 11632 pop_access_scope (decl); 11633 } 11634 11635 return fn_type; 11636} 11637 11638/* Return truthvalue if we're processing a template different from 11639 the last one involved in diagnostics. */ 11640int 11641problematic_instantiation_changed (void) 11642{ 11643 return last_template_error_tick != tinst_level_tick; 11644} 11645 11646/* Remember current template involved in diagnostics. */ 11647void 11648record_last_problematic_instantiation (void) 11649{ 11650 last_template_error_tick = tinst_level_tick; 11651} 11652 11653tree 11654current_instantiation (void) 11655{ 11656 return current_tinst_level; 11657} 11658 11659/* [temp.param] Check that template non-type parm TYPE is of an allowable 11660 type. Return zero for ok, nonzero for disallowed. Issue error and 11661 warning messages under control of COMPLAIN. */ 11662 11663static int 11664invalid_nontype_parm_type_p (tree type, tsubst_flags_t complain) 11665{ 11666 if (INTEGRAL_TYPE_P (type)) 11667 return 0; 11668 else if (POINTER_TYPE_P (type)) 11669 return 0; 11670 else if (TYPE_PTR_TO_MEMBER_P (type)) 11671 return 0; 11672 else if (TREE_CODE (type) == TEMPLATE_TYPE_PARM) 11673 return 0; 11674 else if (TREE_CODE (type) == TYPENAME_TYPE) 11675 return 0; 11676 11677 if (complain & tf_error) 11678 error ("`%#T' is not a valid type for a template constant parameter", 11679 type); 11680 return 1; 11681} 11682 11683/* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type]. 11684 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/ 11685 11686static bool 11687dependent_type_p_r (tree type) 11688{ 11689 tree scope; 11690 11691 /* [temp.dep.type] 11692 11693 A type is dependent if it is: 11694 11695 -- a template parameter. Template template parameters are 11696 types for us (since TYPE_P holds true for them) so we 11697 handle them here. */ 11698 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM 11699 || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM) 11700 return true; 11701 /* -- a qualified-id with a nested-name-specifier which contains a 11702 class-name that names a dependent type or whose unqualified-id 11703 names a dependent type. */ 11704 if (TREE_CODE (type) == TYPENAME_TYPE) 11705 return true; 11706 /* -- a cv-qualified type where the cv-unqualified type is 11707 dependent. */ 11708 type = TYPE_MAIN_VARIANT (type); 11709 /* -- a compound type constructed from any dependent type. */ 11710 if (TYPE_PTR_TO_MEMBER_P (type)) 11711 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type)) 11712 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE 11713 (type))); 11714 else if (TREE_CODE (type) == POINTER_TYPE 11715 || TREE_CODE (type) == REFERENCE_TYPE) 11716 return dependent_type_p (TREE_TYPE (type)); 11717 else if (TREE_CODE (type) == FUNCTION_TYPE 11718 || TREE_CODE (type) == METHOD_TYPE) 11719 { 11720 tree arg_type; 11721 11722 if (dependent_type_p (TREE_TYPE (type))) 11723 return true; 11724 for (arg_type = TYPE_ARG_TYPES (type); 11725 arg_type; 11726 arg_type = TREE_CHAIN (arg_type)) 11727 if (dependent_type_p (TREE_VALUE (arg_type))) 11728 return true; 11729 return false; 11730 } 11731 /* -- an array type constructed from any dependent type or whose 11732 size is specified by a constant expression that is 11733 value-dependent. */ 11734 if (TREE_CODE (type) == ARRAY_TYPE) 11735 { 11736 if (TYPE_DOMAIN (type) 11737 && ((value_dependent_expression_p 11738 (TYPE_MAX_VALUE (TYPE_DOMAIN (type)))) 11739 || (type_dependent_expression_p 11740 (TYPE_MAX_VALUE (TYPE_DOMAIN (type)))))) 11741 return true; 11742 return dependent_type_p (TREE_TYPE (type)); 11743 } 11744 11745 /* -- a template-id in which either the template name is a template 11746 parameter ... */ 11747 if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM) 11748 return true; 11749 /* ... or any of the template arguments is a dependent type or 11750 an expression that is type-dependent or value-dependent. */ 11751 else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INFO (type) 11752 && (any_dependent_template_arguments_p 11753 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type))))) 11754 return true; 11755 11756 /* All TYPEOF_TYPEs are dependent; if the argument of the `typeof' 11757 expression is not type-dependent, then it should already been 11758 have resolved. */ 11759 if (TREE_CODE (type) == TYPEOF_TYPE) 11760 return true; 11761 11762 /* The standard does not specifically mention types that are local 11763 to template functions or local classes, but they should be 11764 considered dependent too. For example: 11765 11766 template <int I> void f() { 11767 enum E { a = I }; 11768 S<sizeof (E)> s; 11769 } 11770 11771 The size of `E' cannot be known until the value of `I' has been 11772 determined. Therefore, `E' must be considered dependent. */ 11773 scope = TYPE_CONTEXT (type); 11774 if (scope && TYPE_P (scope)) 11775 return dependent_type_p (scope); 11776 else if (scope && TREE_CODE (scope) == FUNCTION_DECL) 11777 return type_dependent_expression_p (scope); 11778 11779 /* Other types are non-dependent. */ 11780 return false; 11781} 11782 11783/* Returns TRUE if TYPE is dependent, in the sense of 11784 [temp.dep.type]. */ 11785 11786bool 11787dependent_type_p (tree type) 11788{ 11789 /* If there are no template parameters in scope, then there can't be 11790 any dependent types. */ 11791 if (!processing_template_decl) 11792 return false; 11793 11794 /* If the type is NULL, we have not computed a type for the entity 11795 in question; in that case, the type is dependent. */ 11796 if (!type) 11797 return true; 11798 11799 /* Erroneous types can be considered non-dependent. */ 11800 if (type == error_mark_node) 11801 return false; 11802 11803 /* If we have not already computed the appropriate value for TYPE, 11804 do so now. */ 11805 if (!TYPE_DEPENDENT_P_VALID (type)) 11806 { 11807 TYPE_DEPENDENT_P (type) = dependent_type_p_r (type); 11808 TYPE_DEPENDENT_P_VALID (type) = 1; 11809 } 11810 11811 return TYPE_DEPENDENT_P (type); 11812} 11813 11814/* Returns TRUE if EXPRESSION is dependent, according to CRITERION. */ 11815 11816static bool 11817dependent_scope_ref_p (tree expression, bool criterion (tree)) 11818{ 11819 tree scope; 11820 tree name; 11821 11822 my_friendly_assert (TREE_CODE (expression) == SCOPE_REF, 20030714); 11823 11824 if (!TYPE_P (TREE_OPERAND (expression, 0))) 11825 return true; 11826 11827 scope = TREE_OPERAND (expression, 0); 11828 name = TREE_OPERAND (expression, 1); 11829 11830 /* [temp.dep.expr] 11831 11832 An id-expression is type-dependent if it contains a 11833 nested-name-specifier that contains a class-name that names a 11834 dependent type. */ 11835 /* The suggested resolution to Core Issue 2 implies that if the 11836 qualifying type is the current class, then we must peek 11837 inside it. */ 11838 if (DECL_P (name) 11839 && currently_open_class (scope) 11840 && !criterion (name)) 11841 return false; 11842 if (dependent_type_p (scope)) 11843 return true; 11844 11845 return false; 11846} 11847 11848/* Returns TRUE if the EXPRESSION is value-dependent, in the sense of 11849 [temp.dep.constexpr] */ 11850 11851bool 11852value_dependent_expression_p (tree expression) 11853{ 11854 if (!processing_template_decl) 11855 return false; 11856 11857 /* A name declared with a dependent type. */ 11858 if (TREE_CODE (expression) == IDENTIFIER_NODE 11859 || (DECL_P (expression) 11860 && type_dependent_expression_p (expression))) 11861 return true; 11862 /* A non-type template parameter. */ 11863 if ((TREE_CODE (expression) == CONST_DECL 11864 && DECL_TEMPLATE_PARM_P (expression)) 11865 || TREE_CODE (expression) == TEMPLATE_PARM_INDEX) 11866 return true; 11867 /* A constant with integral or enumeration type and is initialized 11868 with an expression that is value-dependent. */ 11869 if (TREE_CODE (expression) == VAR_DECL 11870 && DECL_INITIAL (expression) 11871 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (expression)) 11872 && value_dependent_expression_p (DECL_INITIAL (expression))) 11873 return true; 11874 /* These expressions are value-dependent if the type to which the 11875 cast occurs is dependent or the expression being casted is 11876 value-dependent. */ 11877 if (TREE_CODE (expression) == DYNAMIC_CAST_EXPR 11878 || TREE_CODE (expression) == STATIC_CAST_EXPR 11879 || TREE_CODE (expression) == CONST_CAST_EXPR 11880 || TREE_CODE (expression) == REINTERPRET_CAST_EXPR 11881 || TREE_CODE (expression) == CAST_EXPR) 11882 { 11883 tree type = TREE_TYPE (expression); 11884 if (dependent_type_p (type)) 11885 return true; 11886 /* A functional cast has a list of operands. */ 11887 expression = TREE_OPERAND (expression, 0); 11888 if (!expression) 11889 { 11890 /* If there are no operands, it must be an expression such 11891 as "int()". This should not happen for aggregate types 11892 because it would form non-constant expressions. */ 11893 my_friendly_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type), 11894 20040318); 11895 11896 return false; 11897 } 11898 if (TREE_CODE (expression) == TREE_LIST) 11899 { 11900 do 11901 { 11902 if (value_dependent_expression_p (TREE_VALUE (expression))) 11903 return true; 11904 expression = TREE_CHAIN (expression); 11905 } 11906 while (expression); 11907 return false; 11908 } 11909 else 11910 return value_dependent_expression_p (expression); 11911 } 11912 /* A `sizeof' expression is value-dependent if the operand is 11913 type-dependent. */ 11914 if (TREE_CODE (expression) == SIZEOF_EXPR 11915 || TREE_CODE (expression) == ALIGNOF_EXPR) 11916 { 11917 expression = TREE_OPERAND (expression, 0); 11918 if (TYPE_P (expression)) 11919 return dependent_type_p (expression); 11920 return type_dependent_expression_p (expression); 11921 } 11922 if (TREE_CODE (expression) == SCOPE_REF) 11923 return dependent_scope_ref_p (expression, value_dependent_expression_p); 11924 if (TREE_CODE (expression) == COMPONENT_REF) 11925 return (value_dependent_expression_p (TREE_OPERAND (expression, 0)) 11926 || value_dependent_expression_p (TREE_OPERAND (expression, 1))); 11927 /* A constant expression is value-dependent if any subexpression is 11928 value-dependent. */ 11929 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (expression)))) 11930 { 11931 switch (TREE_CODE_CLASS (TREE_CODE (expression))) 11932 { 11933 case '1': 11934 return (value_dependent_expression_p 11935 (TREE_OPERAND (expression, 0))); 11936 case '<': 11937 case '2': 11938 return ((value_dependent_expression_p 11939 (TREE_OPERAND (expression, 0))) 11940 || (value_dependent_expression_p 11941 (TREE_OPERAND (expression, 1)))); 11942 case 'e': 11943 { 11944 int i; 11945 for (i = 0; i < first_rtl_op (TREE_CODE (expression)); ++i) 11946 /* In some cases, some of the operands may be missing. 11947 (For example, in the case of PREDECREMENT_EXPR, the 11948 amount to increment by may be missing.) That doesn't 11949 make the expression dependent. */ 11950 if (TREE_OPERAND (expression, i) 11951 && (value_dependent_expression_p 11952 (TREE_OPERAND (expression, i)))) 11953 return true; 11954 return false; 11955 } 11956 } 11957 } 11958 11959 /* The expression is not value-dependent. */ 11960 return false; 11961} 11962 11963/* Returns TRUE if the EXPRESSION is type-dependent, in the sense of 11964 [temp.dep.expr]. */ 11965 11966bool 11967type_dependent_expression_p (tree expression) 11968{ 11969 if (!processing_template_decl) 11970 return false; 11971 11972 if (expression == error_mark_node) 11973 return false; 11974 11975 /* An unresolved name is always dependent. */ 11976 if (TREE_CODE (expression) == IDENTIFIER_NODE) 11977 return true; 11978 11979 /* Some expression forms are never type-dependent. */ 11980 if (TREE_CODE (expression) == PSEUDO_DTOR_EXPR 11981 || TREE_CODE (expression) == SIZEOF_EXPR 11982 || TREE_CODE (expression) == ALIGNOF_EXPR 11983 || TREE_CODE (expression) == TYPEID_EXPR 11984 || TREE_CODE (expression) == DELETE_EXPR 11985 || TREE_CODE (expression) == VEC_DELETE_EXPR 11986 || TREE_CODE (expression) == THROW_EXPR) 11987 return false; 11988 11989 /* The types of these expressions depends only on the type to which 11990 the cast occurs. */ 11991 if (TREE_CODE (expression) == DYNAMIC_CAST_EXPR 11992 || TREE_CODE (expression) == STATIC_CAST_EXPR 11993 || TREE_CODE (expression) == CONST_CAST_EXPR 11994 || TREE_CODE (expression) == REINTERPRET_CAST_EXPR 11995 || TREE_CODE (expression) == CAST_EXPR) 11996 return dependent_type_p (TREE_TYPE (expression)); 11997 11998 /* The types of these expressions depends only on the type created 11999 by the expression. */ 12000 if (TREE_CODE (expression) == NEW_EXPR 12001 || TREE_CODE (expression) == VEC_NEW_EXPR) 12002 { 12003 /* For NEW_EXPR tree nodes created inside a template, either 12004 the object type itself or a TREE_LIST may appear as the 12005 operand 1. */ 12006 tree type = TREE_OPERAND (expression, 1); 12007 if (TREE_CODE (type) == TREE_LIST) 12008 /* This is an array type. We need to check array dimensions 12009 as well. */ 12010 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type))) 12011 || value_dependent_expression_p 12012 (TREE_OPERAND (TREE_VALUE (type), 1)); 12013 else 12014 return dependent_type_p (type); 12015 } 12016 12017 if (TREE_CODE (expression) == SCOPE_REF 12018 && dependent_scope_ref_p (expression, 12019 type_dependent_expression_p)) 12020 return true; 12021 12022 if (TREE_CODE (expression) == FUNCTION_DECL 12023 && DECL_LANG_SPECIFIC (expression) 12024 && DECL_TEMPLATE_INFO (expression) 12025 && (any_dependent_template_arguments_p 12026 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression))))) 12027 return true; 12028 12029 if (TREE_CODE (expression) == TEMPLATE_DECL 12030 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression)) 12031 return false; 12032 12033 if (TREE_TYPE (expression) == unknown_type_node) 12034 { 12035 if (TREE_CODE (expression) == ADDR_EXPR) 12036 return type_dependent_expression_p (TREE_OPERAND (expression, 0)); 12037 if (TREE_CODE (expression) == COMPONENT_REF 12038 || TREE_CODE (expression) == OFFSET_REF) 12039 { 12040 if (type_dependent_expression_p (TREE_OPERAND (expression, 0))) 12041 return true; 12042 expression = TREE_OPERAND (expression, 1); 12043 if (TREE_CODE (expression) == IDENTIFIER_NODE) 12044 return false; 12045 } 12046 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */ 12047 if (TREE_CODE (expression) == SCOPE_REF) 12048 return false; 12049 12050 if (TREE_CODE (expression) == BASELINK) 12051 expression = BASELINK_FUNCTIONS (expression); 12052 if (TREE_CODE (expression) == TEMPLATE_ID_EXPR) 12053 { 12054 if (any_dependent_template_arguments_p 12055 (TREE_OPERAND (expression, 1))) 12056 return true; 12057 expression = TREE_OPERAND (expression, 0); 12058 } 12059 if (TREE_CODE (expression) == OVERLOAD 12060 || TREE_CODE (expression) == FUNCTION_DECL) 12061 { 12062 while (expression) 12063 { 12064 if (type_dependent_expression_p (OVL_CURRENT (expression))) 12065 return true; 12066 expression = OVL_NEXT (expression); 12067 } 12068 return false; 12069 } 12070 abort (); 12071 } 12072 12073 my_friendly_assert (TREE_CODE (expression) != TYPE_DECL, 20051116); 12074 12075 return (dependent_type_p (TREE_TYPE (expression))); 12076} 12077 12078/* Returns TRUE if ARGS (a TREE_LIST of arguments to a function call) 12079 contains a type-dependent expression. */ 12080 12081bool 12082any_type_dependent_arguments_p (tree args) 12083{ 12084 while (args) 12085 { 12086 tree arg = TREE_VALUE (args); 12087 12088 if (type_dependent_expression_p (arg)) 12089 return true; 12090 args = TREE_CHAIN (args); 12091 } 12092 return false; 12093} 12094 12095/* Returns TRUE if the ARG (a template argument) is dependent. */ 12096 12097static bool 12098dependent_template_arg_p (tree arg) 12099{ 12100 if (!processing_template_decl) 12101 return false; 12102 12103 if (TREE_CODE (arg) == TEMPLATE_DECL 12104 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM) 12105 return dependent_template_p (arg); 12106 else if (TYPE_P (arg)) 12107 return dependent_type_p (arg); 12108 else 12109 return (type_dependent_expression_p (arg) 12110 || value_dependent_expression_p (arg)); 12111} 12112 12113/* Returns true if ARGS (a collection of template arguments) contains 12114 any dependent arguments. */ 12115 12116bool 12117any_dependent_template_arguments_p (tree args) 12118{ 12119 int i; 12120 int j; 12121 12122 if (!args) 12123 return false; 12124 12125 for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i) 12126 { 12127 tree level = TMPL_ARGS_LEVEL (args, i + 1); 12128 for (j = 0; j < TREE_VEC_LENGTH (level); ++j) 12129 if (dependent_template_arg_p (TREE_VEC_ELT (level, j))) 12130 return true; 12131 } 12132 12133 return false; 12134} 12135 12136/* Returns TRUE if the template TMPL is dependent. */ 12137 12138bool 12139dependent_template_p (tree tmpl) 12140{ 12141 if (TREE_CODE (tmpl) == OVERLOAD) 12142 { 12143 while (tmpl) 12144 { 12145 if (dependent_template_p (OVL_FUNCTION (tmpl))) 12146 return true; 12147 tmpl = OVL_CHAIN (tmpl); 12148 } 12149 return false; 12150 } 12151 12152 /* Template template parameters are dependent. */ 12153 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl) 12154 || TREE_CODE (tmpl) == TEMPLATE_TEMPLATE_PARM) 12155 return true; 12156 /* So arenames that have not been looked up. */ 12157 if (TREE_CODE (tmpl) == SCOPE_REF 12158 || TREE_CODE (tmpl) == IDENTIFIER_NODE) 12159 return true; 12160 /* So are member templates of dependent classes. */ 12161 if (TYPE_P (CP_DECL_CONTEXT (tmpl))) 12162 return dependent_type_p (DECL_CONTEXT (tmpl)); 12163 return false; 12164} 12165 12166/* Returns TRUE if the specialization TMPL<ARGS> is dependent. */ 12167 12168bool 12169dependent_template_id_p (tree tmpl, tree args) 12170{ 12171 return (dependent_template_p (tmpl) 12172 || any_dependent_template_arguments_p (args)); 12173} 12174 12175/* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the 12176 TYPENAME_TYPE corresponds. Returns ERROR_MARK_NODE if no such TYPE 12177 can be found. Note that this function peers inside uninstantiated 12178 templates and therefore should be used only in extremely limited 12179 situations. */ 12180 12181tree 12182resolve_typename_type (tree type, bool only_current_p) 12183{ 12184 tree scope; 12185 tree name; 12186 tree decl; 12187 int quals; 12188 bool pop_p; 12189 12190 my_friendly_assert (TREE_CODE (type) == TYPENAME_TYPE, 12191 20010702); 12192 12193 scope = TYPE_CONTEXT (type); 12194 name = TYPE_IDENTIFIER (type); 12195 12196 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve 12197 it first before we can figure out what NAME refers to. */ 12198 if (TREE_CODE (scope) == TYPENAME_TYPE) 12199 scope = resolve_typename_type (scope, only_current_p); 12200 /* If we don't know what SCOPE refers to, then we cannot resolve the 12201 TYPENAME_TYPE. */ 12202 if (scope == error_mark_node || TREE_CODE (scope) == TYPENAME_TYPE) 12203 return error_mark_node; 12204 /* If the SCOPE is a template type parameter, we have no way of 12205 resolving the name. */ 12206 if (TREE_CODE (scope) == TEMPLATE_TYPE_PARM) 12207 return type; 12208 /* If the SCOPE is not the current instantiation, there's no reason 12209 to look inside it. */ 12210 if (only_current_p && !currently_open_class (scope)) 12211 return error_mark_node; 12212 /* If SCOPE is a partial instantiation, it will not have a valid 12213 TYPE_FIELDS list, so use the original template. */ 12214 scope = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope); 12215 /* Enter the SCOPE so that name lookup will be resolved as if we 12216 were in the class definition. In particular, SCOPE will no 12217 longer be considered a dependent type. */ 12218 pop_p = push_scope (scope); 12219 /* Look up the declaration. */ 12220 decl = lookup_member (scope, name, /*protect=*/0, /*want_type=*/true); 12221 /* Obtain the set of qualifiers applied to the TYPE. */ 12222 quals = cp_type_quals (type); 12223 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to 12224 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */ 12225 if (!decl) 12226 type = error_mark_node; 12227 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == IDENTIFIER_NODE 12228 && TREE_CODE (decl) == TYPE_DECL) 12229 type = TREE_TYPE (decl); 12230 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == TEMPLATE_ID_EXPR 12231 && DECL_CLASS_TEMPLATE_P (decl)) 12232 { 12233 tree tmpl; 12234 tree args; 12235 /* Obtain the template and the arguments. */ 12236 tmpl = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 0); 12237 args = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 1); 12238 /* Instantiate the template. */ 12239 type = lookup_template_class (tmpl, args, NULL_TREE, NULL_TREE, 12240 /*entering_scope=*/0, tf_error | tf_user); 12241 } 12242 else 12243 type = error_mark_node; 12244 /* Qualify the resulting type. */ 12245 if (type != error_mark_node && quals) 12246 type = cp_build_qualified_type (type, quals); 12247 /* Leave the SCOPE. */ 12248 if (pop_p) 12249 pop_scope (scope); 12250 12251 return type; 12252} 12253 12254/* EXPR is an expression which is not type-dependent. Return a proxy 12255 for EXPR that can be used to compute the types of larger 12256 expressions containing EXPR. */ 12257 12258tree 12259build_non_dependent_expr (tree expr) 12260{ 12261 tree inner_expr; 12262 12263 /* Preserve null pointer constants so that the type of things like 12264 "p == 0" where "p" is a pointer can be determined. */ 12265 if (null_ptr_cst_p (expr)) 12266 return expr; 12267 /* Preserve OVERLOADs; the functions must be available to resolve 12268 types. */ 12269 inner_expr = (TREE_CODE (expr) == ADDR_EXPR ? 12270 TREE_OPERAND (expr, 0) : expr); 12271 if (TREE_CODE (inner_expr) == OVERLOAD 12272 || TREE_CODE (inner_expr) == FUNCTION_DECL 12273 || TREE_CODE (inner_expr) == TEMPLATE_DECL 12274 || TREE_CODE (inner_expr) == TEMPLATE_ID_EXPR 12275 || TREE_CODE (inner_expr) == OFFSET_REF) 12276 return expr; 12277 /* Preserve string constants; conversions from string constants to 12278 "char *" are allowed, even though normally a "const char *" 12279 cannot be used to initialize a "char *". */ 12280 if (TREE_CODE (expr) == STRING_CST) 12281 return expr; 12282 /* Preserve arithmetic constants, as an optimization -- there is no 12283 reason to create a new node. */ 12284 if (TREE_CODE (expr) == INTEGER_CST || TREE_CODE (expr) == REAL_CST) 12285 return expr; 12286 /* Preserve THROW_EXPRs -- all throw-expressions have type "void". 12287 There is at least one place where we want to know that a 12288 particular expression is a throw-expression: when checking a ?: 12289 expression, there are special rules if the second or third 12290 argument is a throw-expresion. */ 12291 if (TREE_CODE (expr) == THROW_EXPR) 12292 return expr; 12293 12294 if (TREE_CODE (expr) == COND_EXPR) 12295 return build (COND_EXPR, 12296 TREE_TYPE (expr), 12297 TREE_OPERAND (expr, 0), 12298 (TREE_OPERAND (expr, 1) 12299 ? build_non_dependent_expr (TREE_OPERAND (expr, 1)) 12300 : build_non_dependent_expr (TREE_OPERAND (expr, 0))), 12301 build_non_dependent_expr (TREE_OPERAND (expr, 2))); 12302 if (TREE_CODE (expr) == COMPOUND_EXPR 12303 && !COMPOUND_EXPR_OVERLOADED (expr)) 12304 return build (COMPOUND_EXPR, 12305 TREE_TYPE (expr), 12306 TREE_OPERAND (expr, 0), 12307 build_non_dependent_expr (TREE_OPERAND (expr, 1))); 12308 12309 /* Otherwise, build a NON_DEPENDENT_EXPR. 12310 12311 REFERENCE_TYPEs are not stripped for expressions in templates 12312 because doing so would play havoc with mangling. Consider, for 12313 example: 12314 12315 template <typename T> void f<T& g>() { g(); } 12316 12317 In the body of "f", the expression for "g" will have 12318 REFERENCE_TYPE, even though the standard says that it should 12319 not. The reason is that we must preserve the syntactic form of 12320 the expression so that mangling (say) "f<g>" inside the body of 12321 "f" works out correctly. Therefore, the REFERENCE_TYPE is 12322 stripped here. */ 12323 return build1 (NON_DEPENDENT_EXPR, non_reference (TREE_TYPE (expr)), expr); 12324} 12325 12326/* ARGS is a TREE_LIST of expressions as arguments to a function call. 12327 Return a new TREE_LIST with the various arguments replaced with 12328 equivalent non-dependent expressions. */ 12329 12330tree 12331build_non_dependent_args (tree args) 12332{ 12333 tree a; 12334 tree new_args; 12335 12336 new_args = NULL_TREE; 12337 for (a = args; a; a = TREE_CHAIN (a)) 12338 new_args = tree_cons (NULL_TREE, 12339 build_non_dependent_expr (TREE_VALUE (a)), 12340 new_args); 12341 return nreverse (new_args); 12342} 12343 12344#include "gt-cp-pt.h" 12345