gcc/cp/tree.c

   1 /* Language-dependent node constructors for parse phase of GNU compiler.
   2    Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011,
   4    2012
   5    Free Software Foundation, Inc.
   6    Hacked by Michael Tiemann (tiemann@cygnus.com)
   7
   8 This file is part of GCC.
   9
  10 GCC is free software; you can redistribute it and/or modify
  11 it under the terms of the GNU General Public License as published by
  12 the Free Software Foundation; either version 3, or (at your option)
  13 any later version.
  14
  15 GCC is distributed in the hope that it will be useful,
  16 but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 GNU General Public License for more details.
  19
  20 You should have received a copy of the GNU General Public License
  21 along with GCC; see the file COPYING3.  If not see
  22 <http://www.gnu.org/licenses/>.  */
  23
  24 #include "config.h"
  25 #include "system.h"
  26 #include "coretypes.h"
  27 #include "tm.h"
  28 #include "tree.h"
  29 #include "cp-tree.h"
  30 #include "flags.h"
  31 #include "tree-inline.h"
  32 #include "debug.h"
  33 #include "convert.h"
  34 #include "cgraph.h"
  35 #include "splay-tree.h"
  36 #include "gimple.h" /* gimple_has_body_p */
  37
  38 static tree bot_manip (tree *, int *, void *);
  39 static tree bot_replace (tree *, int *, void *);
  40 static int list_hash_eq (const void *, const void *);
  41 static hashval_t list_hash_pieces (tree, tree, tree);
  42 static hashval_t list_hash (const void *);
  43 static tree build_target_expr (tree, tree, tsubst_flags_t);
  44 static tree count_trees_r (tree *, int *, void *);
  45 static tree verify_stmt_tree_r (tree *, int *, void *);
  46 static tree build_local_temp (tree);
  47
  48 static tree handle_java_interface_attribute (tree *, tree, tree, int, bool *);
  49 static tree handle_com_interface_attribute (tree *, tree, tree, int, bool *);
  50 static tree handle_init_priority_attribute (tree *, tree, tree, int, bool *);
  51
  52 /* If REF is an lvalue, returns the kind of lvalue that REF is.
  53    Otherwise, returns clk_none.  */
  54
  55 cp_lvalue_kind
  56 lvalue_kind (const_tree ref)
  57 {
  58   cp_lvalue_kind op1_lvalue_kind = clk_none;
  59   cp_lvalue_kind op2_lvalue_kind = clk_none;
  60
  61   /* Expressions of reference type are sometimes wrapped in
  62      INDIRECT_REFs.  INDIRECT_REFs are just internal compiler
  63      representation, not part of the language, so we have to look
  64      through them.  */
  65   if (REFERENCE_REF_P (ref))
  66     return lvalue_kind (TREE_OPERAND (ref, 0));
  67
  68   if (TREE_TYPE (ref)
  69       && TREE_CODE (TREE_TYPE (ref)) == REFERENCE_TYPE)
  70     {
  71       /* unnamed rvalue references are rvalues */
  72       if (TYPE_REF_IS_RVALUE (TREE_TYPE (ref))
  73           && TREE_CODE (ref) != PARM_DECL
  74           && TREE_CODE (ref) != VAR_DECL
  75           && TREE_CODE (ref) != COMPONENT_REF
  76           /* Functions are always lvalues.  */
  77           && TREE_CODE (TREE_TYPE (TREE_TYPE (ref))) != FUNCTION_TYPE)
  78         return clk_rvalueref;
  79
  80       /* lvalue references and named rvalue references are lvalues.  */
  81       return clk_ordinary;
  82     }
  83
  84   if (ref == current_class_ptr)
  85     return clk_none;
  86
  87   switch (TREE_CODE (ref))
  88     {
  89     case SAVE_EXPR:
  90       return clk_none;
  91       /* preincrements and predecrements are valid lvals, provided
  92          what they refer to are valid lvals.  */
  93     case PREINCREMENT_EXPR:
  94     case PREDECREMENT_EXPR:
  95     case TRY_CATCH_EXPR:
  96     case WITH_CLEANUP_EXPR:
  97     case REALPART_EXPR:
  98     case IMAGPART_EXPR:
  99       return lvalue_kind (TREE_OPERAND (ref, 0));
 100
 101     case COMPONENT_REF:
 102       op1_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 0));
 103       /* Look at the member designator.  */
 104       if (!op1_lvalue_kind)
 105         ;
 106       else if (is_overloaded_fn (TREE_OPERAND (ref, 1)))
 107         /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some
 108            situations.  If we're seeing a COMPONENT_REF, it's a non-static
 109            member, so it isn't an lvalue. */
 110         op1_lvalue_kind = clk_none;
 111       else if (TREE_CODE (TREE_OPERAND (ref, 1)) != FIELD_DECL)
 112         /* This can be IDENTIFIER_NODE in a template.  */;
 113       else if (DECL_C_BIT_FIELD (TREE_OPERAND (ref, 1)))
 114         {
 115           /* Clear the ordinary bit.  If this object was a class
 116              rvalue we want to preserve that information.  */
 117           op1_lvalue_kind &= ~clk_ordinary;
 118           /* The lvalue is for a bitfield.  */
 119           op1_lvalue_kind |= clk_bitfield;
 120         }
 121       else if (DECL_PACKED (TREE_OPERAND (ref, 1)))
 122         op1_lvalue_kind |= clk_packed;
 123
 124       return op1_lvalue_kind;
 125
 126     case STRING_CST:
 127     case COMPOUND_LITERAL_EXPR:
 128       return clk_ordinary;
 129
 130     case CONST_DECL:
 131       /* CONST_DECL without TREE_STATIC are enumeration values and
 132          thus not lvalues.  With TREE_STATIC they are used by ObjC++
 133          in objc_build_string_object and need to be considered as
 134          lvalues.  */
 135       if (! TREE_STATIC (ref))
 136         return clk_none;
 137     case VAR_DECL:
 138       if (TREE_READONLY (ref) && ! TREE_STATIC (ref)
 139           && DECL_LANG_SPECIFIC (ref)
 140           && DECL_IN_AGGR_P (ref))
 141         return clk_none;
 142     case INDIRECT_REF:
 143     case ARROW_EXPR:
 144     case ARRAY_REF:
 145     case PARM_DECL:
 146     case RESULT_DECL:
 147       if (TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE)
 148         return clk_ordinary;
 149       break;
 150
 151       /* A scope ref in a template, left as SCOPE_REF to support later
 152          access checking.  */
 153     case SCOPE_REF:
 154       gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE (ref)));
 155       {
 156         tree op = TREE_OPERAND (ref, 1);
 157         if (TREE_CODE (op) == FIELD_DECL)
 158           return (DECL_C_BIT_FIELD (op) ? clk_bitfield : clk_ordinary);
 159         else
 160           return lvalue_kind (op);
 161       }
 162
 163     case MAX_EXPR:
 164     case MIN_EXPR:
 165       /* Disallow <? and >? as lvalues if either argument side-effects.  */
 166       if (TREE_SIDE_EFFECTS (TREE_OPERAND (ref, 0))
 167           || TREE_SIDE_EFFECTS (TREE_OPERAND (ref, 1)))
 168         return clk_none;
 169       op1_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 0));
 170       op2_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 1));
 171       break;
 172
 173     case COND_EXPR:
 174       op1_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 1)
 175                                     ? TREE_OPERAND (ref, 1)
 176                                     : TREE_OPERAND (ref, 0));
 177       op2_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 2));
 178       break;
 179
 180     case MODIFY_EXPR:
 181     case TYPEID_EXPR:
 182       return clk_ordinary;
 183
 184     case COMPOUND_EXPR:
 185       return lvalue_kind (TREE_OPERAND (ref, 1));
 186
 187     case TARGET_EXPR:
 188       return clk_class;
 189
 190     case VA_ARG_EXPR:
 191       return (CLASS_TYPE_P (TREE_TYPE (ref)) ? clk_class : clk_none);
 192
 193     case CALL_EXPR:
 194       /* We can see calls outside of TARGET_EXPR in templates.  */
 195       if (CLASS_TYPE_P (TREE_TYPE (ref)))
 196         return clk_class;
 197       return clk_none;
 198
 199     case FUNCTION_DECL:
 200       /* All functions (except non-static-member functions) are
 201          lvalues.  */
 202       return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref)
 203               ? clk_none : clk_ordinary);
 204
 205     case BASELINK:
 206       /* We now represent a reference to a single static member function
 207          with a BASELINK.  */
 208       /* This CONST_CAST is okay because BASELINK_FUNCTIONS returns
 209          its argument unmodified and we assign it to a const_tree.  */
 210       return lvalue_kind (BASELINK_FUNCTIONS (CONST_CAST_TREE (ref)));
 211
 212     case NON_DEPENDENT_EXPR:
 213       /* We just return clk_ordinary for NON_DEPENDENT_EXPR in C++98, but
 214          in C++11 lvalues don't bind to rvalue references, so we need to
 215          work harder to avoid bogus errors (c++/44870).  */
 216       if (cxx_dialect < cxx0x)
 217         return clk_ordinary;
 218       else
 219         return lvalue_kind (TREE_OPERAND (ref, 0));
 220
 221     default:
 222       if (!TREE_TYPE (ref))
 223         return clk_none;
 224       if (CLASS_TYPE_P (TREE_TYPE (ref)))
 225         return clk_class;
 226       break;
 227     }
 228
 229   /* If one operand is not an lvalue at all, then this expression is
 230      not an lvalue.  */
 231   if (!op1_lvalue_kind || !op2_lvalue_kind)
 232     return clk_none;
 233
 234   /* Otherwise, it's an lvalue, and it has all the odd properties
 235      contributed by either operand.  */
 236   op1_lvalue_kind = op1_lvalue_kind | op2_lvalue_kind;
 237   /* It's not an ordinary lvalue if it involves any other kind.  */
 238   if ((op1_lvalue_kind & ~clk_ordinary) != clk_none)
 239     op1_lvalue_kind &= ~clk_ordinary;
 240   /* It can't be both a pseudo-lvalue and a non-addressable lvalue.
 241      A COND_EXPR of those should be wrapped in a TARGET_EXPR.  */
 242   if ((op1_lvalue_kind & (clk_rvalueref|clk_class))
 243       && (op1_lvalue_kind & (clk_bitfield|clk_packed)))
 244     op1_lvalue_kind = clk_none;
 245   return op1_lvalue_kind;
 246 }
 247
 248 /* Returns the kind of lvalue that REF is, in the sense of
 249    [basic.lval].  This function should really be named lvalue_p; it
 250    computes the C++ definition of lvalue.  */
 251
 252 cp_lvalue_kind
 253 real_lvalue_p (const_tree ref)
 254 {
 255   cp_lvalue_kind kind = lvalue_kind (ref);
 256   if (kind & (clk_rvalueref|clk_class))
 257     return clk_none;
 258   else
 259     return kind;
 260 }
 261
 262 /* This differs from real_lvalue_p in that class rvalues are considered
 263    lvalues.  */
 264
 265 bool
 266 lvalue_p (const_tree ref)
 267 {
 268   return (lvalue_kind (ref) != clk_none);
 269 }
 270
 271 /* This differs from real_lvalue_p in that rvalues formed by dereferencing
 272    rvalue references are considered rvalues.  */
 273
 274 bool
 275 lvalue_or_rvalue_with_address_p (const_tree ref)
 276 {
 277   cp_lvalue_kind kind = lvalue_kind (ref);
 278   if (kind & clk_class)
 279     return false;
 280   else
 281     return (kind != clk_none);
 282 }
 283
 284 /* Returns true if REF is an xvalue, false otherwise.  */
 285
 286 bool
 287 xvalue_p (const_tree ref)
 288 {
 289   return (lvalue_kind (ref) == clk_rvalueref);
 290 }
 291
 292 /* Test whether DECL is a builtin that may appear in a
 293    constant-expression. */
 294
 295 bool
 296 builtin_valid_in_constant_expr_p (const_tree decl)
 297 {
 298   /* At present BUILT_IN_CONSTANT_P is the only builtin we're allowing
 299      in constant-expressions.  We may want to add other builtins later. */
 300   return DECL_IS_BUILTIN_CONSTANT_P (decl);
 301 }
 302
 303 /* Build a TARGET_EXPR, initializing the DECL with the VALUE.  */
 304
 305 static tree
 306 build_target_expr (tree decl, tree value, tsubst_flags_t complain)
 307 {
 308   tree t;
 309   tree type = TREE_TYPE (decl);
 310
 311 #ifdef ENABLE_CHECKING
 312   gcc_assert (VOID_TYPE_P (TREE_TYPE (value))
 313               || TREE_TYPE (decl) == TREE_TYPE (value)
 314               /* On ARM ctors return 'this'.  */
 315               || (TREE_CODE (TREE_TYPE (value)) == POINTER_TYPE
 316                   && TREE_CODE (value) == CALL_EXPR)
 317               || useless_type_conversion_p (TREE_TYPE (decl),
 318                                             TREE_TYPE (value)));
 319 #endif
 320
 321   t = cxx_maybe_build_cleanup (decl, complain);
 322   if (t == error_mark_node)
 323     return error_mark_node;
 324   t = build4 (TARGET_EXPR, type, decl, value, t, NULL_TREE);
 325   /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
 326      ignore the TARGET_EXPR.  If there really turn out to be no
 327      side-effects, then the optimizer should be able to get rid of
 328      whatever code is generated anyhow.  */
 329   TREE_SIDE_EFFECTS (t) = 1;
 330   if (literal_type_p (type))
 331     TREE_CONSTANT (t) = TREE_CONSTANT (value);
 332
 333   return t;
 334 }
 335
 336 /* Return an undeclared local temporary of type TYPE for use in building a
 337    TARGET_EXPR.  */
 338
 339 static tree
 340 build_local_temp (tree type)
 341 {
 342   tree slot = build_decl (input_location,
 343                           VAR_DECL, NULL_TREE, type);
 344   DECL_ARTIFICIAL (slot) = 1;
 345   DECL_IGNORED_P (slot) = 1;
 346   DECL_CONTEXT (slot) = current_function_decl;
 347   layout_decl (slot, 0);
 348   return slot;
 349 }
 350
 351 /* Set various status flags when building an AGGR_INIT_EXPR object T.  */
 352
 353 static void
 354 process_aggr_init_operands (tree t)
 355 {
 356   bool side_effects;
 357
 358   side_effects = TREE_SIDE_EFFECTS (t);
 359   if (!side_effects)
 360     {
 361       int i, n;
 362       n = TREE_OPERAND_LENGTH (t);
 363       for (i = 1; i < n; i++)
 364         {
 365           tree op = TREE_OPERAND (t, i);
 366           if (op && TREE_SIDE_EFFECTS (op))
 367             {
 368               side_effects = 1;
 369               break;
 370             }
 371         }
 372     }
 373   TREE_SIDE_EFFECTS (t) = side_effects;
 374 }
 375
 376 /* Build an AGGR_INIT_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE,
 377    FN, and SLOT.  NARGS is the number of call arguments which are specified
 378    as a tree array ARGS.  */
 379
 380 static tree
 381 build_aggr_init_array (tree return_type, tree fn, tree slot, int nargs,
 382                        tree *args)
 383 {
 384   tree t;
 385   int i;
 386
 387   t = build_vl_exp (AGGR_INIT_EXPR, nargs + 3);
 388   TREE_TYPE (t) = return_type;
 389   AGGR_INIT_EXPR_FN (t) = fn;
 390   AGGR_INIT_EXPR_SLOT (t) = slot;
 391   for (i = 0; i < nargs; i++)
 392     AGGR_INIT_EXPR_ARG (t, i) = args[i];
 393   process_aggr_init_operands (t);
 394   return t;
 395 }
 396
 397 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
 398    target.  TYPE is the type to be initialized.
 399
 400    Build an AGGR_INIT_EXPR to represent the initialization.  This function
 401    differs from build_cplus_new in that an AGGR_INIT_EXPR can only be used
 402    to initialize another object, whereas a TARGET_EXPR can either
 403    initialize another object or create its own temporary object, and as a
 404    result building up a TARGET_EXPR requires that the type's destructor be
 405    callable.  */
 406
 407 tree
 408 build_aggr_init_expr (tree type, tree init, tsubst_flags_t complain)
 409 {
 410   tree fn;
 411   tree slot;
 412   tree rval;
 413   int is_ctor;
 414
 415   /* Make sure that we're not trying to create an instance of an
 416      abstract class.  */
 417   if (abstract_virtuals_error_sfinae (NULL_TREE, type, complain))
 418     return error_mark_node;
 419
 420   if (TREE_CODE (init) == CALL_EXPR)
 421     fn = CALL_EXPR_FN (init);
 422   else if (TREE_CODE (init) == AGGR_INIT_EXPR)
 423     fn = AGGR_INIT_EXPR_FN (init);
 424   else
 425     return convert (type, init);
 426
 427   is_ctor = (TREE_CODE (fn) == ADDR_EXPR
 428              && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL
 429              && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn, 0)));
 430
 431   /* We split the CALL_EXPR into its function and its arguments here.
 432      Then, in expand_expr, we put them back together.  The reason for
 433      this is that this expression might be a default argument
 434      expression.  In that case, we need a new temporary every time the
 435      expression is used.  That's what break_out_target_exprs does; it
 436      replaces every AGGR_INIT_EXPR with a copy that uses a fresh
 437      temporary slot.  Then, expand_expr builds up a call-expression
 438      using the new slot.  */
 439
 440   /* If we don't need to use a constructor to create an object of this
 441      type, don't mess with AGGR_INIT_EXPR.  */
 442   if (is_ctor || TREE_ADDRESSABLE (type))
 443     {
 444       slot = build_local_temp (type);
 445
 446       if (TREE_CODE(init) == CALL_EXPR)
 447         rval = build_aggr_init_array (void_type_node, fn, slot,
 448                                       call_expr_nargs (init),
 449                                       CALL_EXPR_ARGP (init));
 450       else
 451         rval = build_aggr_init_array (void_type_node, fn, slot,
 452                                       aggr_init_expr_nargs (init),
 453                                       AGGR_INIT_EXPR_ARGP (init));
 454       TREE_SIDE_EFFECTS (rval) = 1;
 455       AGGR_INIT_VIA_CTOR_P (rval) = is_ctor;
 456       TREE_NOTHROW (rval) = TREE_NOTHROW (init);
 457     }
 458   else
 459     rval = init;
 460
 461   return rval;
 462 }
 463
 464 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
 465    target.  TYPE is the type that this initialization should appear to
 466    have.
 467
 468    Build an encapsulation of the initialization to perform
 469    and return it so that it can be processed by language-independent
 470    and language-specific expression expanders.  */
 471
 472 tree
 473 build_cplus_new (tree type, tree init, tsubst_flags_t complain)
 474 {
 475   tree rval = build_aggr_init_expr (type, init, complain);
 476   tree slot;
 477
 478   if (TREE_CODE (rval) == AGGR_INIT_EXPR)
 479     slot = AGGR_INIT_EXPR_SLOT (rval);
 480   else if (TREE_CODE (rval) == CALL_EXPR
 481            || TREE_CODE (rval) == CONSTRUCTOR)
 482     slot = build_local_temp (type);
 483   else
 484     return rval;
 485
 486   rval = build_target_expr (slot, rval, complain);
 487
 488   if (rval != error_mark_node)
 489     TARGET_EXPR_IMPLICIT_P (rval) = 1;
 490
 491   return rval;
 492 }
 493
 494 /* Subroutine of build_vec_init_expr: Build up a single element
 495    intialization as a proxy for the full array initialization to get things
 496    marked as used and any appropriate diagnostics.
 497
 498    Since we're deferring building the actual constructor calls until
 499    gimplification time, we need to build one now and throw it away so
 500    that the relevant constructor gets mark_used before cgraph decides
 501    what functions are needed.  Here we assume that init is either
 502    NULL_TREE, void_type_node (indicating value-initialization), or
 503    another array to copy.  */
 504
 505 static tree
 506 build_vec_init_elt (tree type, tree init, tsubst_flags_t complain)
 507 {
 508   tree inner_type = strip_array_types (type);
 509   VEC(tree,gc) *argvec;
 510
 511   if (integer_zerop (array_type_nelts_total (type))
 512       || !CLASS_TYPE_P (inner_type))
 513     /* No interesting initialization to do.  */
 514     return integer_zero_node;
 515   else if (init == void_type_node)
 516     return build_value_init (inner_type, complain);
 517
 518   gcc_assert (init == NULL_TREE
 519               || (same_type_ignoring_top_level_qualifiers_p
 520                   (type, TREE_TYPE (init))));
 521
 522   argvec = make_tree_vector ();
 523   if (init)
 524     {
 525       tree dummy = build_dummy_object (inner_type);
 526       if (!real_lvalue_p (init))
 527         dummy = move (dummy);
 528       VEC_quick_push (tree, argvec, dummy);
 529     }
 530   init = build_special_member_call (NULL_TREE, complete_ctor_identifier,
 531                                     &argvec, inner_type, LOOKUP_NORMAL,
 532                                     complain);
 533   release_tree_vector (argvec);
 534
 535   /* For a trivial constructor, build_over_call creates a TARGET_EXPR.  But
 536      we don't want one here because we aren't creating a temporary.  */
 537   if (TREE_CODE (init) == TARGET_EXPR)
 538     init = TARGET_EXPR_INITIAL (init);
 539
 540   return init;
 541 }
 542
 543 /* Return a TARGET_EXPR which expresses the initialization of an array to
 544    be named later, either default-initialization or copy-initialization
 545    from another array of the same type.  */
 546
 547 tree
 548 build_vec_init_expr (tree type, tree init, tsubst_flags_t complain)
 549 {
 550   tree slot;
 551   bool value_init = false;
 552   tree elt_init = build_vec_init_elt (type, init, complain);
 553
 554   if (init == void_type_node)
 555     {
 556       value_init = true;
 557       init = NULL_TREE;
 558     }
 559
 560   slot = build_local_temp (type);
 561   init = build2 (VEC_INIT_EXPR, type, slot, init);
 562   TREE_SIDE_EFFECTS (init) = true;
 563   SET_EXPR_LOCATION (init, input_location);
 564
 565   if (cxx_dialect >= cxx0x
 566       && potential_constant_expression (elt_init))
 567     VEC_INIT_EXPR_IS_CONSTEXPR (init) = true;
 568   VEC_INIT_EXPR_VALUE_INIT (init) = value_init;
 569
 570   return init;
 571 }
 572
 573 /* Give a helpful diagnostic for a non-constexpr VEC_INIT_EXPR in a context
 574    that requires a constant expression.  */
 575
 576 void
 577 diagnose_non_constexpr_vec_init (tree expr)
 578 {
 579   tree type = TREE_TYPE (VEC_INIT_EXPR_SLOT (expr));
 580   tree init, elt_init;
 581   if (VEC_INIT_EXPR_VALUE_INIT (expr))
 582     init = void_type_node;
 583   else
 584     init = VEC_INIT_EXPR_INIT (expr);
 585
 586   elt_init = build_vec_init_elt (type, init, tf_warning_or_error);
 587   require_potential_constant_expression (elt_init);
 588 }
 589
 590 tree
 591 build_array_copy (tree init)
 592 {
 593   return build_vec_init_expr (TREE_TYPE (init), init, tf_warning_or_error);
 594 }
 595
 596 /* Build a TARGET_EXPR using INIT to initialize a new temporary of the
 597    indicated TYPE.  */
 598
 599 tree
 600 build_target_expr_with_type (tree init, tree type, tsubst_flags_t complain)
 601 {
 602   gcc_assert (!VOID_TYPE_P (type));
 603
 604   if (TREE_CODE (init) == TARGET_EXPR
 605       || init == error_mark_node)
 606     return init;
 607   else if (CLASS_TYPE_P (type) && type_has_nontrivial_copy_init (type)
 608            && !VOID_TYPE_P (TREE_TYPE (init))
 609            && TREE_CODE (init) != COND_EXPR
 610            && TREE_CODE (init) != CONSTRUCTOR
 611            && TREE_CODE (init) != VA_ARG_EXPR)
 612     /* We need to build up a copy constructor call.  A void initializer
 613        means we're being called from bot_manip.  COND_EXPR is a special
 614        case because we already have copies on the arms and we don't want
 615        another one here.  A CONSTRUCTOR is aggregate initialization, which
 616        is handled separately.  A VA_ARG_EXPR is magic creation of an
 617        aggregate; there's no additional work to be done.  */
 618     return force_rvalue (init, complain);
 619
 620   return force_target_expr (type, init, complain);
 621 }
 622
 623 /* Like the above function, but without the checking.  This function should
 624    only be used by code which is deliberately trying to subvert the type
 625    system, such as call_builtin_trap.  Or build_over_call, to avoid
 626    infinite recursion.  */
 627
 628 tree
 629 force_target_expr (tree type, tree init, tsubst_flags_t complain)
 630 {
 631   tree slot;
 632
 633   gcc_assert (!VOID_TYPE_P (type));
 634
 635   slot = build_local_temp (type);
 636   return build_target_expr (slot, init, complain);
 637 }
 638
 639 /* Like build_target_expr_with_type, but use the type of INIT.  */
 640
 641 tree
 642 get_target_expr_sfinae (tree init, tsubst_flags_t complain)
 643 {
 644   if (TREE_CODE (init) == AGGR_INIT_EXPR)
 645     return build_target_expr (AGGR_INIT_EXPR_SLOT (init), init, complain);
 646   else if (TREE_CODE (init) == VEC_INIT_EXPR)
 647     return build_target_expr (VEC_INIT_EXPR_SLOT (init), init, complain);
 648   else
 649     return build_target_expr_with_type (init, TREE_TYPE (init), complain);
 650 }
 651
 652 tree
 653 get_target_expr (tree init)
 654 {
 655   return get_target_expr_sfinae (init, tf_warning_or_error);
 656 }
 657
 658 /* If EXPR is a bitfield reference, convert it to the declared type of
 659    the bitfield, and return the resulting expression.  Otherwise,
 660    return EXPR itself.  */
 661
 662 tree
 663 convert_bitfield_to_declared_type (tree expr)
 664 {
 665   tree bitfield_type;
 666
 667   bitfield_type = is_bitfield_expr_with_lowered_type (expr);
 668   if (bitfield_type)
 669     expr = convert_to_integer (TYPE_MAIN_VARIANT (bitfield_type),
 670                                expr);
 671   return expr;
 672 }
 673
 674 /* EXPR is being used in an rvalue context.  Return a version of EXPR
 675    that is marked as an rvalue.  */
 676
 677 tree
 678 rvalue (tree expr)
 679 {
 680   tree type;
 681
 682   if (error_operand_p (expr))
 683     return expr;
 684
 685   expr = mark_rvalue_use (expr);
 686
 687   /* [basic.lval]
 688
 689      Non-class rvalues always have cv-unqualified types.  */
 690   type = TREE_TYPE (expr);
 691   if (!CLASS_TYPE_P (type) && cv_qualified_p (type))
 692     type = cv_unqualified (type);
 693
 694   /* We need to do this for rvalue refs as well to get the right answer
 695      from decltype; see c++/36628.  */
 696   if (!processing_template_decl && lvalue_or_rvalue_with_address_p (expr))
 697     expr = build1 (NON_LVALUE_EXPR, type, expr);
 698   else if (type != TREE_TYPE (expr))
 699     expr = build_nop (type, expr);
 700
 701   return expr;
 702 }
 703
 704 \f
 705 /* Hash an ARRAY_TYPE.  K is really of type `tree'.  */
 706
 707 static hashval_t
 708 cplus_array_hash (const void* k)
 709 {
 710   hashval_t hash;
 711   const_tree const t = (const_tree) k;
 712
 713   hash = TYPE_UID (TREE_TYPE (t));
 714   if (TYPE_DOMAIN (t))
 715     hash ^= TYPE_UID (TYPE_DOMAIN (t));
 716   return hash;
 717 }
 718
 719 typedef struct cplus_array_info {
 720   tree type;
 721   tree domain;
 722 } cplus_array_info;
 723
 724 /* Compare two ARRAY_TYPEs.  K1 is really of type `tree', K2 is really
 725    of type `cplus_array_info*'. */
 726
 727 static int
 728 cplus_array_compare (const void * k1, const void * k2)
 729 {
 730   const_tree const t1 = (const_tree) k1;
 731   const cplus_array_info *const t2 = (const cplus_array_info*) k2;
 732
 733   return (TREE_TYPE (t1) == t2->type && TYPE_DOMAIN (t1) == t2->domain);
 734 }
 735
 736 /* Hash table containing dependent array types, which are unsuitable for
 737    the language-independent type hash table.  */
 738 static GTY ((param_is (union tree_node))) htab_t cplus_array_htab;
 739
 740 /* Like build_array_type, but handle special C++ semantics.  */
 741
 742 tree
 743 build_cplus_array_type (tree elt_type, tree index_type)
 744 {
 745   tree t;
 746
 747   if (elt_type == error_mark_node || index_type == error_mark_node)
 748     return error_mark_node;
 749
 750   if (processing_template_decl
 751       && (dependent_type_p (elt_type)
 752           || (index_type && !TREE_CONSTANT (TYPE_MAX_VALUE (index_type)))))
 753     {
 754       void **e;
 755       cplus_array_info cai;
 756       hashval_t hash;
 757
 758       if (cplus_array_htab == NULL)
 759         cplus_array_htab = htab_create_ggc (61, &cplus_array_hash,
 760                                             &cplus_array_compare, NULL);
 761
 762       hash = TYPE_UID (elt_type);
 763       if (index_type)
 764         hash ^= TYPE_UID (index_type);
 765       cai.type = elt_type;
 766       cai.domain = index_type;
 767
 768       e = htab_find_slot_with_hash (cplus_array_htab, &cai, hash, INSERT);
 769       if (*e)
 770         /* We have found the type: we're done.  */
 771         return (tree) *e;
 772       else
 773         {
 774           /* Build a new array type.  */
 775           t = cxx_make_type (ARRAY_TYPE);
 776           TREE_TYPE (t) = elt_type;
 777           TYPE_DOMAIN (t) = index_type;
 778
 779           /* Store it in the hash table. */
 780           *e = t;
 781
 782           /* Set the canonical type for this new node.  */
 783           if (TYPE_STRUCTURAL_EQUALITY_P (elt_type)
 784               || (index_type && TYPE_STRUCTURAL_EQUALITY_P (index_type)))
 785             SET_TYPE_STRUCTURAL_EQUALITY (t);
 786           else if (TYPE_CANONICAL (elt_type) != elt_type
 787                    || (index_type
 788                        && TYPE_CANONICAL (index_type) != index_type))
 789             TYPE_CANONICAL (t)
 790                 = build_cplus_array_type
 791                    (TYPE_CANONICAL (elt_type),
 792                     index_type ? TYPE_CANONICAL (index_type) : index_type);
 793           else
 794             TYPE_CANONICAL (t) = t;
 795         }
 796     }
 797   else
 798     {
 799       if (!TYPE_STRUCTURAL_EQUALITY_P (elt_type)
 800           && !(index_type && TYPE_STRUCTURAL_EQUALITY_P (index_type))
 801           && (TYPE_CANONICAL (elt_type) != elt_type
 802               || (index_type && TYPE_CANONICAL (index_type) != index_type)))
 803         /* Make sure that the canonical type is on the appropriate
 804            variants list.  */
 805         build_cplus_array_type
 806           (TYPE_CANONICAL (elt_type),
 807            index_type ? TYPE_CANONICAL (index_type) : index_type);
 808       t = build_array_type (elt_type, index_type);
 809     }
 810
 811   /* We want TYPE_MAIN_VARIANT of an array to strip cv-quals from the
 812      element type as well, so fix it up if needed.  */
 813   if (elt_type != TYPE_MAIN_VARIANT (elt_type))
 814     {
 815       tree m = build_cplus_array_type (TYPE_MAIN_VARIANT (elt_type),
 816                                        index_type);
 817
 818       if (TYPE_MAIN_VARIANT (t) != m)
 819         {
 820           TYPE_MAIN_VARIANT (t) = m;
 821           TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
 822           TYPE_NEXT_VARIANT (m) = t;
 823         }
 824     }
 825
 826   /* Push these needs up so that initialization takes place
 827      more easily.  */
 828   TYPE_NEEDS_CONSTRUCTING (t)
 829     = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type));
 830   TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
 831     = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type));
 832   return t;
 833 }
 834
 835 /* Return an ARRAY_TYPE with element type ELT and length N.  */
 836
 837 tree
 838 build_array_of_n_type (tree elt, int n)
 839 {
 840   return build_cplus_array_type (elt, build_index_type (size_int (n - 1)));
 841 }
 842
 843 /* Return a reference type node referring to TO_TYPE.  If RVAL is
 844    true, return an rvalue reference type, otherwise return an lvalue
 845    reference type.  If a type node exists, reuse it, otherwise create
 846    a new one.  */
 847 tree
 848 cp_build_reference_type (tree to_type, bool rval)
 849 {
 850   tree lvalue_ref, t;
 851   lvalue_ref = build_reference_type (to_type);
 852   if (!rval)
 853     return lvalue_ref;
 854
 855   /* This code to create rvalue reference types is based on and tied
 856      to the code creating lvalue reference types in the middle-end
 857      functions build_reference_type_for_mode and build_reference_type.
 858
 859      It works by putting the rvalue reference type nodes after the
 860      lvalue reference nodes in the TYPE_NEXT_REF_TO linked list, so
 861      they will effectively be ignored by the middle end.  */
 862
 863   for (t = lvalue_ref; (t = TYPE_NEXT_REF_TO (t)); )
 864     if (TYPE_REF_IS_RVALUE (t))
 865       return t;
 866
 867   t = build_distinct_type_copy (lvalue_ref);
 868
 869   TYPE_REF_IS_RVALUE (t) = true;
 870   TYPE_NEXT_REF_TO (t) = TYPE_NEXT_REF_TO (lvalue_ref);
 871   TYPE_NEXT_REF_TO (lvalue_ref) = t;
 872
 873   if (TYPE_STRUCTURAL_EQUALITY_P (to_type))
 874     SET_TYPE_STRUCTURAL_EQUALITY (t);
 875   else if (TYPE_CANONICAL (to_type) != to_type)
 876     TYPE_CANONICAL (t)
 877       = cp_build_reference_type (TYPE_CANONICAL (to_type), rval);
 878   else
 879     TYPE_CANONICAL (t) = t;
 880
 881   layout_type (t);
 882
 883   return t;
 884
 885 }
 886
 887 /* Returns EXPR cast to rvalue reference type, like std::move.  */
 888
 889 tree
 890 move (tree expr)
 891 {
 892   tree type = TREE_TYPE (expr);
 893   gcc_assert (TREE_CODE (type) != REFERENCE_TYPE);
 894   type = cp_build_reference_type (type, /*rval*/true);
 895   return build_static_cast (type, expr, tf_warning_or_error);
 896 }
 897
 898 /* Used by the C++ front end to build qualified array types.  However,
 899    the C version of this function does not properly maintain canonical
 900    types (which are not used in C).  */
 901 tree
 902 c_build_qualified_type (tree type, int type_quals)
 903 {
 904   return cp_build_qualified_type (type, type_quals);
 905 }
 906
 907 \f
 908 /* Make a variant of TYPE, qualified with the TYPE_QUALS.  Handles
 909    arrays correctly.  In particular, if TYPE is an array of T's, and
 910    TYPE_QUALS is non-empty, returns an array of qualified T's.
 911
 912    FLAGS determines how to deal with ill-formed qualifications. If
 913    tf_ignore_bad_quals is set, then bad qualifications are dropped
 914    (this is permitted if TYPE was introduced via a typedef or template
 915    type parameter). If bad qualifications are dropped and tf_warning
 916    is set, then a warning is issued for non-const qualifications.  If
 917    tf_ignore_bad_quals is not set and tf_error is not set, we
 918    return error_mark_node. Otherwise, we issue an error, and ignore
 919    the qualifications.
 920
 921    Qualification of a reference type is valid when the reference came
 922    via a typedef or template type argument. [dcl.ref] No such
 923    dispensation is provided for qualifying a function type.  [dcl.fct]
 924    DR 295 queries this and the proposed resolution brings it into line
 925    with qualifying a reference.  We implement the DR.  We also behave
 926    in a similar manner for restricting non-pointer types.  */
 927
 928 tree
 929 cp_build_qualified_type_real (tree type,
 930                               int type_quals,
 931                               tsubst_flags_t complain)
 932 {
 933   tree result;
 934   int bad_quals = TYPE_UNQUALIFIED;
 935
 936   if (type == error_mark_node)
 937     return type;
 938
 939   if (type_quals == cp_type_quals (type))
 940     return type;
 941
 942   if (TREE_CODE (type) == ARRAY_TYPE)
 943     {
 944       /* In C++, the qualification really applies to the array element
 945          type.  Obtain the appropriately qualified element type.  */
 946       tree t;
 947       tree element_type
 948         = cp_build_qualified_type_real (TREE_TYPE (type),
 949                                         type_quals,
 950                                         complain);
 951
 952       if (element_type == error_mark_node)
 953         return error_mark_node;
 954
 955       /* See if we already have an identically qualified type.  Tests
 956          should be equivalent to those in check_qualified_type.  */
 957       for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
 958         if (TREE_TYPE (t) == element_type
 959             && TYPE_NAME (t) == TYPE_NAME (type)
 960             && TYPE_CONTEXT (t) == TYPE_CONTEXT (type)
 961             && attribute_list_equal (TYPE_ATTRIBUTES (t),
 962                                      TYPE_ATTRIBUTES (type)))
 963           break;
 964
 965       if (!t)
 966         {
 967           t = build_cplus_array_type (element_type, TYPE_DOMAIN (type));
 968
 969           /* Keep the typedef name.  */
 970           if (TYPE_NAME (t) != TYPE_NAME (type))
 971             {
 972               t = build_variant_type_copy (t);
 973               TYPE_NAME (t) = TYPE_NAME (type);
 974             }
 975         }
 976
 977       /* Even if we already had this variant, we update
 978          TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
 979          they changed since the variant was originally created.
 980
 981          This seems hokey; if there is some way to use a previous
 982          variant *without* coming through here,
 983          TYPE_NEEDS_CONSTRUCTING will never be updated.  */
 984       TYPE_NEEDS_CONSTRUCTING (t)
 985         = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type));
 986       TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
 987         = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type));
 988       return t;
 989     }
 990   else if (TYPE_PTRMEMFUNC_P (type))
 991     {
 992       /* For a pointer-to-member type, we can't just return a
 993          cv-qualified version of the RECORD_TYPE.  If we do, we
 994          haven't changed the field that contains the actual pointer to
 995          a method, and so TYPE_PTRMEMFUNC_FN_TYPE will be wrong.  */
 996       tree t;
 997
 998       t = TYPE_PTRMEMFUNC_FN_TYPE (type);
 999       t = cp_build_qualified_type_real (t, type_quals, complain);
1000       return build_ptrmemfunc_type (t);
1001     }
1002   else if (TREE_CODE (type) == TYPE_PACK_EXPANSION)
1003     {
1004       tree t = PACK_EXPANSION_PATTERN (type);
1005
1006       t = cp_build_qualified_type_real (t, type_quals, complain);
1007       return make_pack_expansion (t);
1008     }
1009
1010   /* A reference or method type shall not be cv-qualified.
1011      [dcl.ref], [dcl.fct].  This used to be an error, but as of DR 295
1012      (in CD1) we always ignore extra cv-quals on functions.  */
1013   if (type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)
1014       && (TREE_CODE (type) == REFERENCE_TYPE
1015           || TREE_CODE (type) == FUNCTION_TYPE
1016           || TREE_CODE (type) == METHOD_TYPE))
1017     {
1018       if (TREE_CODE (type) == REFERENCE_TYPE)
1019         bad_quals |= type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
1020       type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
1021     }
1022
1023   /* But preserve any function-cv-quals on a FUNCTION_TYPE.  */
1024   if (TREE_CODE (type) == FUNCTION_TYPE)
1025     type_quals |= type_memfn_quals (type);
1026
1027   /* A restrict-qualified type must be a pointer (or reference)
1028      to object or incomplete type. */
1029   if ((type_quals & TYPE_QUAL_RESTRICT)
1030       && TREE_CODE (type) != TEMPLATE_TYPE_PARM
1031       && TREE_CODE (type) != TYPENAME_TYPE
1032       && !POINTER_TYPE_P (type))
1033     {
1034       bad_quals |= TYPE_QUAL_RESTRICT;
1035       type_quals &= ~TYPE_QUAL_RESTRICT;
1036     }
1037
1038   if (bad_quals == TYPE_UNQUALIFIED
1039       || (complain & tf_ignore_bad_quals))
1040     /*OK*/;
1041   else if (!(complain & tf_error))
1042     return error_mark_node;
1043   else
1044     {
1045       tree bad_type = build_qualified_type (ptr_type_node, bad_quals);
1046       error ("%qV qualifiers cannot be applied to %qT",
1047              bad_type, type);
1048     }
1049
1050   /* Retrieve (or create) the appropriately qualified variant.  */
1051   result = build_qualified_type (type, type_quals);
1052
1053   /* If this was a pointer-to-method type, and we just made a copy,
1054      then we need to unshare the record that holds the cached
1055      pointer-to-member-function type, because these will be distinct
1056      between the unqualified and qualified types.  */
1057   if (result != type
1058       && TREE_CODE (type) == POINTER_TYPE
1059       && TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE
1060       && TYPE_LANG_SPECIFIC (result) == TYPE_LANG_SPECIFIC (type))
1061     TYPE_LANG_SPECIFIC (result) = NULL;
1062
1063   /* We may also have ended up building a new copy of the canonical
1064      type of a pointer-to-method type, which could have the same
1065      sharing problem described above.  */
1066   if (TYPE_CANONICAL (result) != TYPE_CANONICAL (type)
1067       && TREE_CODE (type) == POINTER_TYPE
1068       && TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE
1069       && (TYPE_LANG_SPECIFIC (TYPE_CANONICAL (result))
1070           == TYPE_LANG_SPECIFIC (TYPE_CANONICAL (type))))
1071     TYPE_LANG_SPECIFIC (TYPE_CANONICAL (result)) = NULL;
1072
1073   return result;
1074 }
1075
1076 /* Return TYPE with const and volatile removed.  */
1077
1078 tree
1079 cv_unqualified (tree type)
1080 {
1081   int quals;
1082
1083   if (type == error_mark_node)
1084     return type;
1085
1086   quals = cp_type_quals (type);
1087   quals &= ~(TYPE_QUAL_CONST|TYPE_QUAL_VOLATILE);
1088   return cp_build_qualified_type (type, quals);
1089 }
1090
1091 /* Builds a qualified variant of T that is not a typedef variant.
1092    E.g. consider the following declarations:
1093      typedef const int ConstInt;
1094      typedef ConstInt* PtrConstInt;
1095    If T is PtrConstInt, this function returns a type representing
1096      const int*.
1097    In other words, if T is a typedef, the function returns the underlying type.
1098    The cv-qualification and attributes of the type returned match the
1099    input type.
1100    They will always be compatible types.
1101    The returned type is built so that all of its subtypes
1102    recursively have their typedefs stripped as well.
1103
1104    This is different from just returning TYPE_CANONICAL (T)
1105    Because of several reasons:
1106     * If T is a type that needs structural equality
1107       its TYPE_CANONICAL (T) will be NULL.
1108     * TYPE_CANONICAL (T) desn't carry type attributes
1109       and loses template parameter names.   */
1110
1111 tree
1112 strip_typedefs (tree t)
1113 {
1114   tree result = NULL, type = NULL, t0 = NULL;
1115
1116   if (!t || t == error_mark_node || t == TYPE_CANONICAL (t))
1117     return t;
1118
1119   gcc_assert (TYPE_P (t));
1120
1121   switch (TREE_CODE (t))
1122     {
1123     case POINTER_TYPE:
1124       type = strip_typedefs (TREE_TYPE (t));
1125       result = build_pointer_type (type);
1126       break;
1127     case REFERENCE_TYPE:
1128       type = strip_typedefs (TREE_TYPE (t));
1129       result = cp_build_reference_type (type, TYPE_REF_IS_RVALUE (t));
1130       break;
1131     case OFFSET_TYPE:
1132       t0 = strip_typedefs (TYPE_OFFSET_BASETYPE (t));
1133       type = strip_typedefs (TREE_TYPE (t));
1134       result = build_offset_type (t0, type);
1135       break;
1136     case RECORD_TYPE:
1137       if (TYPE_PTRMEMFUNC_P (t))
1138         {
1139           t0 = strip_typedefs (TYPE_PTRMEMFUNC_FN_TYPE (t));
1140           result = build_ptrmemfunc_type (t0);
1141         }
1142       break;
1143     case ARRAY_TYPE:
1144       type = strip_typedefs (TREE_TYPE (t));
1145       t0  = strip_typedefs (TYPE_DOMAIN (t));;
1146       result = build_cplus_array_type (type, t0);
1147       break;
1148     case FUNCTION_TYPE:
1149     case METHOD_TYPE:
1150       {
1151         tree arg_types = NULL, arg_node, arg_type;
1152         for (arg_node = TYPE_ARG_TYPES (t);
1153              arg_node;
1154              arg_node = TREE_CHAIN (arg_node))
1155           {
1156             if (arg_node == void_list_node)
1157               break;
1158             arg_type = strip_typedefs (TREE_VALUE (arg_node));
1159             gcc_assert (arg_type);
1160
1161             arg_types =
1162               tree_cons (TREE_PURPOSE (arg_node), arg_type, arg_types);
1163           }
1164
1165         if (arg_types)
1166           arg_types = nreverse (arg_types);
1167
1168         /* A list of parameters not ending with an ellipsis
1169            must end with void_list_node.  */
1170         if (arg_node)
1171           arg_types = chainon (arg_types, void_list_node);
1172
1173         type = strip_typedefs (TREE_TYPE (t));
1174         if (TREE_CODE (t) == METHOD_TYPE)
1175           {
1176             tree class_type = TREE_TYPE (TREE_VALUE (arg_types));
1177             gcc_assert (class_type);
1178             result =
1179               build_method_type_directly (class_type, type,
1180                                           TREE_CHAIN (arg_types));
1181           }
1182         else
1183           {
1184             result = build_function_type (type,
1185                                           arg_types);
1186             result = apply_memfn_quals (result, type_memfn_quals (t));
1187           }
1188
1189         if (TYPE_RAISES_EXCEPTIONS (t))
1190           result = build_exception_variant (result,
1191                                             TYPE_RAISES_EXCEPTIONS (t));
1192       }
1193       break;
1194     case TYPENAME_TYPE:
1195       result = make_typename_type (strip_typedefs (TYPE_CONTEXT (t)),
1196                                    TYPENAME_TYPE_FULLNAME (t),
1197                                    typename_type, tf_none);
1198       break;
1199     case DECLTYPE_TYPE:
1200       result = strip_typedefs_expr (DECLTYPE_TYPE_EXPR (t));
1201       if (result == DECLTYPE_TYPE_EXPR (t))
1202         return t;
1203       else
1204         result = (finish_decltype_type
1205                   (result,
1206                    DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t),
1207                    tf_none));
1208       break;
1209     default:
1210       break;
1211     }
1212
1213   if (!result)
1214       result = TYPE_MAIN_VARIANT (t);
1215   if (TYPE_USER_ALIGN (t) != TYPE_USER_ALIGN (result)
1216       || TYPE_ALIGN (t) != TYPE_ALIGN (result))
1217     {
1218       gcc_assert (TYPE_USER_ALIGN (t));
1219       if (TYPE_ALIGN (t) == TYPE_ALIGN (result))
1220         result = build_variant_type_copy (result);
1221       else
1222         result = build_aligned_type (result, TYPE_ALIGN (t));
1223       TYPE_USER_ALIGN (result) = true;
1224     }
1225   if (TYPE_ATTRIBUTES (t))
1226     result = cp_build_type_attribute_variant (result, TYPE_ATTRIBUTES (t));
1227   return cp_build_qualified_type (result, cp_type_quals (t));
1228 }
1229
1230 /* Like strip_typedefs above, but works on expressions, so that in
1231
1232    template<class T> struct A
1233    {
1234      typedef T TT;
1235      B<sizeof(TT)> b;
1236    };
1237
1238    sizeof(TT) is replaced by sizeof(T).  */
1239
1240 tree
1241 strip_typedefs_expr (tree t)
1242 {
1243   unsigned i,n;
1244   tree r, type, *ops;
1245   enum tree_code code;
1246
1247   if (t == NULL_TREE || t == error_mark_node)
1248     return t;
1249
1250   if (DECL_P (t) || CONSTANT_CLASS_P (t))
1251     return t;
1252
1253   /* Some expressions have type operands, so let's handle types here rather
1254      than check TYPE_P in multiple places below.  */
1255   if (TYPE_P (t))
1256     return strip_typedefs (t);
1257
1258   code = TREE_CODE (t);
1259   switch (code)
1260     {
1261     case IDENTIFIER_NODE:
1262     case TEMPLATE_PARM_INDEX:
1263     case OVERLOAD:
1264     case BASELINK:
1265     case ARGUMENT_PACK_SELECT:
1266       return t;
1267
1268     case TRAIT_EXPR:
1269       {
1270         tree type1 = strip_typedefs (TRAIT_EXPR_TYPE1 (t));
1271         tree type2 = strip_typedefs (TRAIT_EXPR_TYPE2 (t));
1272         if (type1 == TRAIT_EXPR_TYPE1 (t)
1273             && type2 == TRAIT_EXPR_TYPE2 (t))
1274           return t;
1275         r = copy_node (t);
1276         TRAIT_EXPR_TYPE1 (t) = type1;
1277         TRAIT_EXPR_TYPE2 (t) = type2;
1278         return r;
1279       }
1280
1281     case TREE_LIST:
1282       {
1283         VEC(tree,gc) *vec = make_tree_vector ();
1284         bool changed = false;
1285         tree it;
1286         for (it = t; it; it = TREE_CHAIN (it))
1287           {
1288             tree val = strip_typedefs_expr (TREE_VALUE (t));
1289             VEC_safe_push (tree, gc, vec, val);
1290             if (val != TREE_VALUE (t))
1291               changed = true;
1292             gcc_assert (TREE_PURPOSE (it) == NULL_TREE);
1293           }
1294         if (changed)
1295           {
1296             r = NULL_TREE;
1297             FOR_EACH_VEC_ELT_REVERSE (tree, vec, i, it)
1298               r = tree_cons (NULL_TREE, it, r);
1299           }
1300         else
1301           r = t;
1302         release_tree_vector (vec);
1303         return r;
1304       }
1305
1306     case TREE_VEC:
1307       {
1308         bool changed = false;
1309         VEC(tree,gc)* vec = make_tree_vector ();
1310         n = TREE_VEC_LENGTH (t);
1311         VEC_reserve (tree, gc, vec, n);
1312         for (i = 0; i < n; ++i)
1313           {
1314             tree op = strip_typedefs_expr (TREE_VEC_ELT (t, i));
1315             VEC_quick_push (tree, vec, op);
1316             if (op != TREE_VEC_ELT (t, i))
1317               changed = true;
1318           }
1319         if (changed)
1320           {
1321             r = copy_node (t);
1322             for (i = 0; i < n; ++i)
1323               TREE_VEC_ELT (r, i) = VEC_index (tree, vec, i);
1324           }
1325         else
1326           r = t;
1327         release_tree_vector (vec);
1328         return r;
1329       }
1330
1331     case CONSTRUCTOR:
1332       {
1333         bool changed = false;
1334         VEC(constructor_elt,gc) *vec
1335           = VEC_copy (constructor_elt, gc, CONSTRUCTOR_ELTS (t));
1336         n = CONSTRUCTOR_NELTS (t);
1337         type = strip_typedefs (TREE_TYPE (t));
1338         for (i = 0; i < n; ++i)
1339           {
1340             constructor_elt *e = VEC_index (constructor_elt, vec, i);
1341             tree op = strip_typedefs_expr (e->value);
1342             if (op != e->value)
1343               {
1344                 changed = true;
1345                 e->value = op;
1346               }
1347             gcc_checking_assert (e->index == strip_typedefs_expr (e->index));
1348           }
1349
1350         if (!changed && type == TREE_TYPE (t))
1351           {
1352             VEC_free (constructor_elt, gc, vec);
1353             return t;
1354           }
1355         else
1356           {
1357             r = copy_node (t);
1358             TREE_TYPE (r) = type;
1359             CONSTRUCTOR_ELTS (r) = vec;
1360             return r;
1361           }
1362       }
1363
1364     case LAMBDA_EXPR:
1365       gcc_unreachable ();
1366
1367     default:
1368       break;
1369     }
1370
1371   gcc_assert (EXPR_P (t));
1372
1373   n = TREE_OPERAND_LENGTH (t);
1374   ops = XALLOCAVEC (tree, n);
1375   type = TREE_TYPE (t);
1376
1377   switch (code)
1378     {
1379     CASE_CONVERT:
1380     case IMPLICIT_CONV_EXPR:
1381     case DYNAMIC_CAST_EXPR:
1382     case STATIC_CAST_EXPR:
1383     case CONST_CAST_EXPR:
1384     case REINTERPRET_CAST_EXPR:
1385     case CAST_EXPR:
1386     case NEW_EXPR:
1387       type = strip_typedefs (type);
1388       /* fallthrough */
1389
1390     default:
1391       for (i = 0; i < n; ++i)
1392         ops[i] = strip_typedefs_expr (TREE_OPERAND (t, i));
1393       break;
1394     }
1395
1396   /* If nothing changed, return t.  */
1397   for (i = 0; i < n; ++i)
1398     if (ops[i] != TREE_OPERAND (t, i))
1399       break;
1400   if (i == n && type == TREE_TYPE (t))
1401     return t;
1402
1403   r = copy_node (t);
1404   TREE_TYPE (r) = type;
1405   for (i = 0; i < n; ++i)
1406     TREE_OPERAND (r, i) = ops[i];
1407   return r;
1408 }
1409
1410 /* Makes a copy of BINFO and TYPE, which is to be inherited into a
1411    graph dominated by T.  If BINFO is NULL, TYPE is a dependent base,
1412    and we do a shallow copy.  If BINFO is non-NULL, we do a deep copy.
1413    VIRT indicates whether TYPE is inherited virtually or not.
1414    IGO_PREV points at the previous binfo of the inheritance graph
1415    order chain.  The newly copied binfo's TREE_CHAIN forms this
1416    ordering.
1417
1418    The CLASSTYPE_VBASECLASSES vector of T is constructed in the
1419    correct order. That is in the order the bases themselves should be
1420    constructed in.
1421
1422    The BINFO_INHERITANCE of a virtual base class points to the binfo
1423    of the most derived type. ??? We could probably change this so that
1424    BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence
1425    remove a field.  They currently can only differ for primary virtual
1426    virtual bases.  */
1427
1428 tree
1429 copy_binfo (tree binfo, tree type, tree t, tree *igo_prev, int virt)
1430 {
1431   tree new_binfo;
1432
1433   if (virt)
1434     {
1435       /* See if we've already made this virtual base.  */
1436       new_binfo = binfo_for_vbase (type, t);
1437       if (new_binfo)
1438         return new_binfo;
1439     }
1440
1441   new_binfo = make_tree_binfo (binfo ? BINFO_N_BASE_BINFOS (binfo) : 0);
1442   BINFO_TYPE (new_binfo) = type;
1443
1444   /* Chain it into the inheritance graph.  */
1445   TREE_CHAIN (*igo_prev) = new_binfo;
1446   *igo_prev = new_binfo;
1447
1448   if (binfo && !BINFO_DEPENDENT_BASE_P (binfo))
1449     {
1450       int ix;
1451       tree base_binfo;
1452
1453       gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), type));
1454
1455       BINFO_OFFSET (new_binfo) = BINFO_OFFSET (binfo);
1456       BINFO_VIRTUALS (new_binfo) = BINFO_VIRTUALS (binfo);
1457
1458       /* We do not need to copy the accesses, as they are read only.  */
1459       BINFO_BASE_ACCESSES (new_binfo) = BINFO_BASE_ACCESSES (binfo);
1460
1461       /* Recursively copy base binfos of BINFO.  */
1462       for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
1463         {
1464           tree new_base_binfo;
1465           new_base_binfo = copy_binfo (base_binfo, BINFO_TYPE (base_binfo),
1466                                        t, igo_prev,
1467                                        BINFO_VIRTUAL_P (base_binfo));
1468
1469           if (!BINFO_INHERITANCE_CHAIN (new_base_binfo))
1470             BINFO_INHERITANCE_CHAIN (new_base_binfo) = new_binfo;
1471           BINFO_BASE_APPEND (new_binfo, new_base_binfo);
1472         }
1473     }
1474   else
1475     BINFO_DEPENDENT_BASE_P (new_binfo) = 1;
1476
1477   if (virt)
1478     {
1479       /* Push it onto the list after any virtual bases it contains
1480          will have been pushed.  */
1481       VEC_quick_push (tree, CLASSTYPE_VBASECLASSES (t), new_binfo);
1482       BINFO_VIRTUAL_P (new_binfo) = 1;
1483       BINFO_INHERITANCE_CHAIN (new_binfo) = TYPE_BINFO (t);
1484     }
1485
1486   return new_binfo;
1487 }
1488 \f
1489 /* Hashing of lists so that we don't make duplicates.
1490    The entry point is `list_hash_canon'.  */
1491
1492 /* Now here is the hash table.  When recording a list, it is added
1493    to the slot whose index is the hash code mod the table size.
1494    Note that the hash table is used for several kinds of lists.
1495    While all these live in the same table, they are completely independent,
1496    and the hash code is computed differently for each of these.  */
1497
1498 static GTY ((param_is (union tree_node))) htab_t list_hash_table;
1499
1500 struct list_proxy
1501 {
1502   tree purpose;
1503   tree value;
1504   tree chain;
1505 };
1506
1507 /* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy
1508    for a node we are thinking about adding).  */
1509
1510 static int
1511 list_hash_eq (const void* entry, const void* data)
1512 {
1513   const_tree const t = (const_tree) entry;
1514   const struct list_proxy *const proxy = (const struct list_proxy *) data;
1515
1516   return (TREE_VALUE (t) == proxy->value
1517           && TREE_PURPOSE (t) == proxy->purpose
1518           && TREE_CHAIN (t) == proxy->chain);
1519 }
1520
1521 /* Compute a hash code for a list (chain of TREE_LIST nodes
1522    with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
1523    TREE_COMMON slots), by adding the hash codes of the individual entries.  */
1524
1525 static hashval_t
1526 list_hash_pieces (tree purpose, tree value, tree chain)
1527 {
1528   hashval_t hashcode = 0;
1529
1530   if (chain)
1531     hashcode += TREE_HASH (chain);
1532
1533   if (value)
1534     hashcode += TREE_HASH (value);
1535   else
1536     hashcode += 1007;
1537   if (purpose)
1538     hashcode += TREE_HASH (purpose);
1539   else
1540     hashcode += 1009;
1541   return hashcode;
1542 }
1543
1544 /* Hash an already existing TREE_LIST.  */
1545
1546 static hashval_t
1547 list_hash (const void* p)
1548 {
1549   const_tree const t = (const_tree) p;
1550   return list_hash_pieces (TREE_PURPOSE (t),
1551                            TREE_VALUE (t),
1552                            TREE_CHAIN (t));
1553 }
1554
1555 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
1556    object for an identical list if one already exists.  Otherwise, build a
1557    new one, and record it as the canonical object.  */
1558
1559 tree
1560 hash_tree_cons (tree purpose, tree value, tree chain)
1561 {
1562   int hashcode = 0;
1563   void **slot;
1564   struct list_proxy proxy;
1565
1566   /* Hash the list node.  */
1567   hashcode = list_hash_pieces (purpose, value, chain);
1568   /* Create a proxy for the TREE_LIST we would like to create.  We
1569      don't actually create it so as to avoid creating garbage.  */
1570   proxy.purpose = purpose;
1571   proxy.value = value;
1572   proxy.chain = chain;
1573   /* See if it is already in the table.  */
1574   slot = htab_find_slot_with_hash (list_hash_table, &proxy, hashcode,
1575                                    INSERT);
1576   /* If not, create a new node.  */
1577   if (!*slot)
1578     *slot = tree_cons (purpose, value, chain);
1579   return (tree) *slot;
1580 }
1581
1582 /* Constructor for hashed lists.  */
1583
1584 tree
1585 hash_tree_chain (tree value, tree chain)
1586 {
1587   return hash_tree_cons (NULL_TREE, value, chain);
1588 }
1589 \f
1590 void
1591 debug_binfo (tree elem)
1592 {
1593   HOST_WIDE_INT n;
1594   tree virtuals;
1595
1596   fprintf (stderr, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC
1597            "\nvtable type:\n",
1598            TYPE_NAME_STRING (BINFO_TYPE (elem)),
1599            TREE_INT_CST_LOW (BINFO_OFFSET (elem)));
1600   debug_tree (BINFO_TYPE (elem));
1601   if (BINFO_VTABLE (elem))
1602     fprintf (stderr, "vtable decl \"%s\"\n",
1603              IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem))));
1604   else
1605     fprintf (stderr, "no vtable decl yet\n");
1606   fprintf (stderr, "virtuals:\n");
1607   virtuals = BINFO_VIRTUALS (elem);
1608   n = 0;
1609
1610   while (virtuals)
1611     {
1612       tree fndecl = TREE_VALUE (virtuals);
1613       fprintf (stderr, "%s [%ld =? %ld]\n",
1614                IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)),
1615                (long) n, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl)));
1616       ++n;
1617       virtuals = TREE_CHAIN (virtuals);
1618     }
1619 }
1620
1621 /* Build a representation for the qualified name SCOPE::NAME.  TYPE is
1622    the type of the result expression, if known, or NULL_TREE if the
1623    resulting expression is type-dependent.  If TEMPLATE_P is true,
1624    NAME is known to be a template because the user explicitly used the
1625    "template" keyword after the "::".
1626
1627    All SCOPE_REFs should be built by use of this function.  */
1628
1629 tree
1630 build_qualified_name (tree type, tree scope, tree name, bool template_p)
1631 {
1632   tree t;
1633   if (type == error_mark_node
1634       || scope == error_mark_node
1635       || name == error_mark_node)
1636     return error_mark_node;
1637   t = build2 (SCOPE_REF, type, scope, name);
1638   QUALIFIED_NAME_IS_TEMPLATE (t) = template_p;
1639   PTRMEM_OK_P (t) = true;
1640   if (type)
1641     t = convert_from_reference (t);
1642   return t;
1643 }
1644
1645 /* Returns nonzero if X is an expression for a (possibly overloaded)
1646    function.  If "f" is a function or function template, "f", "c->f",
1647    "c.f", "C::f", and "f<int>" will all be considered possibly
1648    overloaded functions.  Returns 2 if the function is actually
1649    overloaded, i.e., if it is impossible to know the type of the
1650    function without performing overload resolution.  */
1651
1652 int
1653 is_overloaded_fn (tree x)
1654 {
1655   /* A baselink is also considered an overloaded function.  */
1656   if (TREE_CODE (x) == OFFSET_REF
1657       || TREE_CODE (x) == COMPONENT_REF)
1658     x = TREE_OPERAND (x, 1);
1659   if (BASELINK_P (x))
1660     x = BASELINK_FUNCTIONS (x);
1661   if (TREE_CODE (x) == TEMPLATE_ID_EXPR)
1662     x = TREE_OPERAND (x, 0);
1663   if (DECL_FUNCTION_TEMPLATE_P (OVL_CURRENT (x))
1664       || (TREE_CODE (x) == OVERLOAD && OVL_CHAIN (x)))
1665     return 2;
1666   return  (TREE_CODE (x) == FUNCTION_DECL
1667            || TREE_CODE (x) == OVERLOAD);
1668 }
1669
1670 /* X is the CALL_EXPR_FN of a CALL_EXPR.  If X represents a dependent name
1671    (14.6.2), return the IDENTIFIER_NODE for that name.  Otherwise, return
1672    NULL_TREE.  */
1673
1674 tree
1675 dependent_name (tree x)
1676 {
1677   if (TREE_CODE (x) == IDENTIFIER_NODE)
1678     return x;
1679   if (TREE_CODE (x) != COMPONENT_REF
1680       && TREE_CODE (x) != OFFSET_REF
1681       && TREE_CODE (x) != BASELINK
1682       && is_overloaded_fn (x))
1683     return DECL_NAME (get_first_fn (x));
1684   return NULL_TREE;
1685 }
1686
1687 /* Returns true iff X is an expression for an overloaded function
1688    whose type cannot be known without performing overload
1689    resolution.  */
1690
1691 bool
1692 really_overloaded_fn (tree x)
1693 {
1694   return is_overloaded_fn (x) == 2;
1695 }
1696
1697 tree
1698 get_fns (tree from)
1699 {
1700   gcc_assert (is_overloaded_fn (from));
1701   /* A baselink is also considered an overloaded function.  */
1702   if (TREE_CODE (from) == OFFSET_REF
1703       || TREE_CODE (from) == COMPONENT_REF)
1704     from = TREE_OPERAND (from, 1);
1705   if (BASELINK_P (from))
1706     from = BASELINK_FUNCTIONS (from);
1707   if (TREE_CODE (from) == TEMPLATE_ID_EXPR)
1708     from = TREE_OPERAND (from, 0);
1709   return from;
1710 }
1711
1712 tree
1713 get_first_fn (tree from)
1714 {
1715   return OVL_CURRENT (get_fns (from));
1716 }
1717
1718 /* Return a new OVL node, concatenating it with the old one.  */
1719
1720 tree
1721 ovl_cons (tree decl, tree chain)
1722 {
1723   tree result = make_node (OVERLOAD);
1724   TREE_TYPE (result) = unknown_type_node;
1725   OVL_FUNCTION (result) = decl;
1726   TREE_CHAIN (result) = chain;
1727
1728   return result;
1729 }
1730
1731 /* Build a new overloaded function. If this is the first one,
1732    just return it; otherwise, ovl_cons the _DECLs */
1733
1734 tree
1735 build_overload (tree decl, tree chain)
1736 {
1737   if (! chain && TREE_CODE (decl) != TEMPLATE_DECL)
1738     return decl;
1739   return ovl_cons (decl, chain);
1740 }
1741
1742 /* Return the scope where the overloaded functions OVL were found.  */
1743
1744 tree
1745 ovl_scope (tree ovl)
1746 {
1747   if (TREE_CODE (ovl) == OFFSET_REF
1748       || TREE_CODE (ovl) == COMPONENT_REF)
1749     ovl = TREE_OPERAND (ovl, 1);
1750   if (TREE_CODE (ovl) == BASELINK)
1751     return BINFO_TYPE (BASELINK_BINFO (ovl));
1752   if (TREE_CODE (ovl) == TEMPLATE_ID_EXPR)
1753     ovl = TREE_OPERAND (ovl, 0);
1754   /* Skip using-declarations.  */
1755   while (TREE_CODE (ovl) == OVERLOAD && OVL_USED (ovl) && OVL_CHAIN (ovl))
1756     ovl = OVL_CHAIN (ovl);
1757   return CP_DECL_CONTEXT (OVL_CURRENT (ovl));
1758 }
1759
1760 /* Return TRUE if FN is a non-static member function, FALSE otherwise.
1761    This function looks into BASELINK and OVERLOAD nodes.  */
1762
1763 bool
1764 non_static_member_function_p (tree fn)
1765 {
1766   if (fn == NULL_TREE)
1767     return false;
1768
1769   if (is_overloaded_fn (fn))
1770     fn = get_first_fn (fn);
1771
1772   return (DECL_P (fn)
1773           && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn));
1774 }
1775
1776 \f
1777 #define PRINT_RING_SIZE 4
1778
1779 static const char *
1780 cxx_printable_name_internal (tree decl, int v, bool translate)
1781 {
1782   static unsigned int uid_ring[PRINT_RING_SIZE];
1783   static char *print_ring[PRINT_RING_SIZE];
1784   static bool trans_ring[PRINT_RING_SIZE];
1785   static int ring_counter;
1786   int i;
1787
1788   /* Only cache functions.  */
1789   if (v < 2
1790       || TREE_CODE (decl) != FUNCTION_DECL
1791       || DECL_LANG_SPECIFIC (decl) == 0)
1792     return lang_decl_name (decl, v, translate);
1793
1794   /* See if this print name is lying around.  */
1795   for (i = 0; i < PRINT_RING_SIZE; i++)
1796     if (uid_ring[i] == DECL_UID (decl) && translate == trans_ring[i])
1797       /* yes, so return it.  */
1798       return print_ring[i];
1799
1800   if (++ring_counter == PRINT_RING_SIZE)
1801     ring_counter = 0;
1802
1803   if (current_function_decl != NULL_TREE)
1804     {
1805       /* There may be both translated and untranslated versions of the
1806          name cached.  */
1807       for (i = 0; i < 2; i++)
1808         {
1809           if (uid_ring[ring_counter] == DECL_UID (current_function_decl))
1810             ring_counter += 1;
1811           if (ring_counter == PRINT_RING_SIZE)
1812             ring_counter = 0;
1813         }
1814       gcc_assert (uid_ring[ring_counter] != DECL_UID (current_function_decl));
1815     }
1816
1817   free (print_ring[ring_counter]);
1818
1819   print_ring[ring_counter] = xstrdup (lang_decl_name (decl, v, translate));
1820   uid_ring[ring_counter] = DECL_UID (decl);
1821   trans_ring[ring_counter] = translate;
1822   return print_ring[ring_counter];
1823 }
1824
1825 const char *
1826 cxx_printable_name (tree decl, int v)
1827 {
1828   return cxx_printable_name_internal (decl, v, false);
1829 }
1830
1831 const char *
1832 cxx_printable_name_translate (tree decl, int v)
1833 {
1834   return cxx_printable_name_internal (decl, v, true);
1835 }
1836 \f
1837 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
1838    listed in RAISES.  */
1839
1840 tree
1841 build_exception_variant (tree type, tree raises)
1842 {
1843   tree v;
1844   int type_quals;
1845
1846   if (comp_except_specs (raises, TYPE_RAISES_EXCEPTIONS (type), ce_exact))
1847     return type;
1848
1849   type_quals = TYPE_QUALS (type);
1850   for (v = TYPE_MAIN_VARIANT (type); v; v = TYPE_NEXT_VARIANT (v))
1851     if (check_qualified_type (v, type, type_quals)
1852         && comp_except_specs (raises, TYPE_RAISES_EXCEPTIONS (v), ce_exact))
1853       return v;
1854
1855   /* Need to build a new variant.  */
1856   v = build_variant_type_copy (type);
1857   TYPE_RAISES_EXCEPTIONS (v) = raises;
1858   return v;
1859 }
1860
1861 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new
1862    BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template
1863    arguments.  */
1864
1865 tree
1866 bind_template_template_parm (tree t, tree newargs)
1867 {
1868   tree decl = TYPE_NAME (t);
1869   tree t2;
1870
1871   t2 = cxx_make_type (BOUND_TEMPLATE_TEMPLATE_PARM);
1872   decl = build_decl (input_location,
1873                      TYPE_DECL, DECL_NAME (decl), NULL_TREE);
1874
1875   /* These nodes have to be created to reflect new TYPE_DECL and template
1876      arguments.  */
1877   TEMPLATE_TYPE_PARM_INDEX (t2) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t));
1878   TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2)) = decl;
1879   TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2)
1880     = build_template_info (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t), newargs);
1881
1882   TREE_TYPE (decl) = t2;
1883   TYPE_NAME (t2) = decl;
1884   TYPE_STUB_DECL (t2) = decl;
1885   TYPE_SIZE (t2) = 0;
1886   SET_TYPE_STRUCTURAL_EQUALITY (t2);
1887
1888   return t2;
1889 }
1890
1891 /* Called from count_trees via walk_tree.  */
1892
1893 static tree
1894 count_trees_r (tree *tp, int *walk_subtrees, void *data)
1895 {
1896   ++*((int *) data);
1897
1898   if (TYPE_P (*tp))
1899     *walk_subtrees = 0;
1900
1901   return NULL_TREE;
1902 }
1903
1904 /* Debugging function for measuring the rough complexity of a tree
1905    representation.  */
1906
1907 int
1908 count_trees (tree t)
1909 {
1910   int n_trees = 0;
1911   cp_walk_tree_without_duplicates (&t, count_trees_r, &n_trees);
1912   return n_trees;
1913 }
1914
1915 /* Called from verify_stmt_tree via walk_tree.  */
1916
1917 static tree
1918 verify_stmt_tree_r (tree* tp,
1919                     int* walk_subtrees ATTRIBUTE_UNUSED ,
1920                     void* data)
1921 {
1922   tree t = *tp;
1923   htab_t *statements = (htab_t *) data;
1924   void **slot;
1925
1926   if (!STATEMENT_CODE_P (TREE_CODE (t)))
1927     return NULL_TREE;
1928
1929   /* If this statement is already present in the hash table, then
1930      there is a circularity in the statement tree.  */
1931   gcc_assert (!htab_find (*statements, t));
1932
1933   slot = htab_find_slot (*statements, t, INSERT);
1934   *slot = t;
1935
1936   return NULL_TREE;
1937 }
1938
1939 /* Debugging function to check that the statement T has not been
1940    corrupted.  For now, this function simply checks that T contains no
1941    circularities.  */
1942
1943 void
1944 verify_stmt_tree (tree t)
1945 {
1946   htab_t statements;
1947   statements = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
1948   cp_walk_tree (&t, verify_stmt_tree_r, &statements, NULL);
1949   htab_delete (statements);
1950 }
1951
1952 /* Check if the type T depends on a type with no linkage and if so, return
1953    it.  If RELAXED_P then do not consider a class type declared within
1954    a vague-linkage function to have no linkage.  */
1955
1956 tree
1957 no_linkage_check (tree t, bool relaxed_p)
1958 {
1959   tree r;
1960
1961   /* There's no point in checking linkage on template functions; we
1962      can't know their complete types.  */
1963   if (processing_template_decl)
1964     return NULL_TREE;
1965
1966   switch (TREE_CODE (t))
1967     {
1968     case RECORD_TYPE:
1969       if (TYPE_PTRMEMFUNC_P (t))
1970         goto ptrmem;
1971       /* Lambda types that don't have mangling scope have no linkage.  We
1972          check CLASSTYPE_LAMBDA_EXPR here rather than LAMBDA_TYPE_P because
1973          when we get here from pushtag none of the lambda information is
1974          set up yet, so we want to assume that the lambda has linkage and
1975          fix it up later if not.  */
1976       if (CLASSTYPE_LAMBDA_EXPR (t)
1977           && LAMBDA_TYPE_EXTRA_SCOPE (t) == NULL_TREE)
1978         return t;
1979       /* Fall through.  */
1980     case UNION_TYPE:
1981       if (!CLASS_TYPE_P (t))
1982         return NULL_TREE;
1983       /* Fall through.  */
1984     case ENUMERAL_TYPE:
1985       /* Only treat anonymous types as having no linkage if they're at
1986          namespace scope.  This is core issue 966.  */
1987       if (TYPE_ANONYMOUS_P (t) && TYPE_NAMESPACE_SCOPE_P (t))
1988         return t;
1989
1990       for (r = CP_TYPE_CONTEXT (t); ; )
1991         {
1992           /* If we're a nested type of a !TREE_PUBLIC class, we might not
1993              have linkage, or we might just be in an anonymous namespace.
1994              If we're in a TREE_PUBLIC class, we have linkage.  */
1995           if (TYPE_P (r) && !TREE_PUBLIC (TYPE_NAME (r)))
1996             return no_linkage_check (TYPE_CONTEXT (t), relaxed_p);
1997           else if (TREE_CODE (r) == FUNCTION_DECL)
1998             {
1999               if (!relaxed_p || !vague_linkage_p (r))
2000                 return t;
2001               else
2002                 r = CP_DECL_CONTEXT (r);
2003             }
2004           else
2005             break;
2006         }
2007
2008       return NULL_TREE;
2009
2010     case ARRAY_TYPE:
2011     case POINTER_TYPE:
2012     case REFERENCE_TYPE:
2013       return no_linkage_check (TREE_TYPE (t), relaxed_p);
2014
2015     case OFFSET_TYPE:
2016     ptrmem:
2017       r = no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t),
2018                             relaxed_p);
2019       if (r)
2020         return r;
2021       return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t), relaxed_p);
2022
2023     case METHOD_TYPE:
2024       r = no_linkage_check (TYPE_METHOD_BASETYPE (t), relaxed_p);
2025       if (r)
2026         return r;
2027       /* Fall through.  */
2028     case FUNCTION_TYPE:
2029       {
2030         tree parm;
2031         for (parm = TYPE_ARG_TYPES (t);
2032              parm && parm != void_list_node;
2033              parm = TREE_CHAIN (parm))
2034           {
2035             r = no_linkage_check (TREE_VALUE (parm), relaxed_p);
2036             if (r)
2037               return r;
2038           }
2039         return no_linkage_check (TREE_TYPE (t), relaxed_p);
2040       }
2041
2042     default:
2043       return NULL_TREE;
2044     }
2045 }
2046
2047 #ifdef GATHER_STATISTICS
2048 extern int depth_reached;
2049 #endif
2050
2051 void
2052 cxx_print_statistics (void)
2053 {
2054   print_search_statistics ();
2055   print_class_statistics ();
2056   print_template_statistics ();
2057 #ifdef GATHER_STATISTICS
2058   fprintf (stderr, "maximum template instantiation depth reached: %d\n",
2059            depth_reached);
2060 #endif
2061 }
2062
2063 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2064    (which is an ARRAY_TYPE).  This counts only elements of the top
2065    array.  */
2066
2067 tree
2068 array_type_nelts_top (tree type)
2069 {
2070   return fold_build2_loc (input_location,
2071                       PLUS_EXPR, sizetype,
2072                       array_type_nelts (type),
2073                       size_one_node);
2074 }
2075
2076 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2077    (which is an ARRAY_TYPE).  This one is a recursive count of all
2078    ARRAY_TYPEs that are clumped together.  */
2079
2080 tree
2081 array_type_nelts_total (tree type)
2082 {
2083   tree sz = array_type_nelts_top (type);
2084   type = TREE_TYPE (type);
2085   while (TREE_CODE (type) == ARRAY_TYPE)
2086     {
2087       tree n = array_type_nelts_top (type);
2088       sz = fold_build2_loc (input_location,
2089                         MULT_EXPR, sizetype, sz, n);
2090       type = TREE_TYPE (type);
2091     }
2092   return sz;
2093 }
2094
2095 /* Called from break_out_target_exprs via mapcar.  */
2096
2097 static tree
2098 bot_manip (tree* tp, int* walk_subtrees, void* data)
2099 {
2100   splay_tree target_remap = ((splay_tree) data);
2101   tree t = *tp;
2102
2103   if (!TYPE_P (t) && TREE_CONSTANT (t) && !TREE_SIDE_EFFECTS (t))
2104     {
2105       /* There can't be any TARGET_EXPRs or their slot variables below this
2106          point.  But we must make a copy, in case subsequent processing
2107          alters any part of it.  For example, during gimplification a cast
2108          of the form (T) &X::f (where "f" is a member function) will lead
2109          to replacing the PTRMEM_CST for &X::f with a VAR_DECL.  */
2110       *walk_subtrees = 0;
2111       *tp = unshare_expr (t);
2112       return NULL_TREE;
2113     }
2114   if (TREE_CODE (t) == TARGET_EXPR)
2115     {
2116       tree u;
2117
2118       if (TREE_CODE (TREE_OPERAND (t, 1)) == AGGR_INIT_EXPR)
2119         {
2120           u = build_cplus_new (TREE_TYPE (t), TREE_OPERAND (t, 1),
2121                                tf_warning_or_error);
2122           if (AGGR_INIT_ZERO_FIRST (TREE_OPERAND (t, 1)))
2123             AGGR_INIT_ZERO_FIRST (TREE_OPERAND (u, 1)) = true;
2124         }
2125       else
2126         u = build_target_expr_with_type (TREE_OPERAND (t, 1), TREE_TYPE (t),
2127                                          tf_warning_or_error);
2128
2129       TARGET_EXPR_IMPLICIT_P (u) = TARGET_EXPR_IMPLICIT_P (t);
2130       TARGET_EXPR_LIST_INIT_P (u) = TARGET_EXPR_LIST_INIT_P (t);
2131       TARGET_EXPR_DIRECT_INIT_P (u) = TARGET_EXPR_DIRECT_INIT_P (t);
2132
2133       /* Map the old variable to the new one.  */
2134       splay_tree_insert (target_remap,
2135                          (splay_tree_key) TREE_OPERAND (t, 0),
2136                          (splay_tree_value) TREE_OPERAND (u, 0));
2137
2138       TREE_OPERAND (u, 1) = break_out_target_exprs (TREE_OPERAND (u, 1));
2139
2140       /* Replace the old expression with the new version.  */
2141       *tp = u;
2142       /* We don't have to go below this point; the recursive call to
2143          break_out_target_exprs will have handled anything below this
2144          point.  */
2145       *walk_subtrees = 0;
2146       return NULL_TREE;
2147     }
2148
2149   /* Make a copy of this node.  */
2150   t = copy_tree_r (tp, walk_subtrees, NULL);
2151   if (TREE_CODE (*tp) == CALL_EXPR)
2152     set_flags_from_callee (*tp);
2153   return t;
2154 }
2155
2156 /* Replace all remapped VAR_DECLs in T with their new equivalents.
2157    DATA is really a splay-tree mapping old variables to new
2158    variables.  */
2159
2160 static tree
2161 bot_replace (tree* t,
2162              int* walk_subtrees ATTRIBUTE_UNUSED ,
2163              void* data)
2164 {
2165   splay_tree target_remap = ((splay_tree) data);
2166
2167   if (TREE_CODE (*t) == VAR_DECL)
2168     {
2169       splay_tree_node n = splay_tree_lookup (target_remap,
2170                                              (splay_tree_key) *t);
2171       if (n)
2172         *t = (tree) n->value;
2173     }
2174   else if (TREE_CODE (*t) == PARM_DECL
2175            && DECL_NAME (*t) == this_identifier)
2176     {
2177       /* In an NSDMI we need to replace the 'this' parameter we used for
2178          parsing with the real one for this function.  */
2179       *t = current_class_ptr;
2180     }
2181   else if (TREE_CODE (*t) == CONVERT_EXPR
2182            && CONVERT_EXPR_VBASE_PATH (*t))
2183     {
2184       /* In an NSDMI build_base_path defers building conversions to virtual
2185          bases, and we handle it here.  */
2186       tree basetype = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (*t)));
2187       VEC(tree,gc) *vbases = CLASSTYPE_VBASECLASSES (current_class_type);
2188       int i; tree binfo;
2189       FOR_EACH_VEC_ELT (tree, vbases, i, binfo)
2190         if (BINFO_TYPE (binfo) == basetype)
2191           break;
2192       *t = build_base_path (PLUS_EXPR, TREE_OPERAND (*t, 0), binfo, true,
2193                             tf_warning_or_error);
2194     }
2195
2196   return NULL_TREE;
2197 }
2198
2199 /* When we parse a default argument expression, we may create
2200    temporary variables via TARGET_EXPRs.  When we actually use the
2201    default-argument expression, we make a copy of the expression
2202    and replace the temporaries with appropriate local versions.  */
2203
2204 tree
2205 break_out_target_exprs (tree t)
2206 {
2207   static int target_remap_count;
2208   static splay_tree target_remap;
2209
2210   if (!target_remap_count++)
2211     target_remap = splay_tree_new (splay_tree_compare_pointers,
2212                                    /*splay_tree_delete_key_fn=*/NULL,
2213                                    /*splay_tree_delete_value_fn=*/NULL);
2214   cp_walk_tree (&t, bot_manip, target_remap, NULL);
2215   cp_walk_tree (&t, bot_replace, target_remap, NULL);
2216
2217   if (!--target_remap_count)
2218     {
2219       splay_tree_delete (target_remap);
2220       target_remap = NULL;
2221     }
2222
2223   return t;
2224 }
2225
2226 /* Similar to `build_nt', but for template definitions of dependent
2227    expressions  */
2228
2229 tree
2230 build_min_nt_loc (location_t loc, enum tree_code code, ...)
2231 {
2232   tree t;
2233   int length;
2234   int i;
2235   va_list p;
2236
2237   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
2238
2239   va_start (p, code);
2240
2241   t = make_node (code);
2242   SET_EXPR_LOCATION (t, loc);
2243   length = TREE_CODE_LENGTH (code);
2244
2245   for (i = 0; i < length; i++)
2246     {
2247       tree x = va_arg (p, tree);
2248       TREE_OPERAND (t, i) = x;
2249     }
2250
2251   va_end (p);
2252   return t;
2253 }
2254
2255
2256 /* Similar to `build', but for template definitions.  */
2257
2258 tree
2259 build_min (enum tree_code code, tree tt, ...)
2260 {
2261   tree t;
2262   int length;
2263   int i;
2264   va_list p;
2265
2266   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
2267
2268   va_start (p, tt);
2269
2270   t = make_node (code);
2271   length = TREE_CODE_LENGTH (code);
2272   TREE_TYPE (t) = tt;
2273
2274   for (i = 0; i < length; i++)
2275     {
2276       tree x = va_arg (p, tree);
2277       TREE_OPERAND (t, i) = x;
2278       if (x && !TYPE_P (x) && TREE_SIDE_EFFECTS (x))
2279         TREE_SIDE_EFFECTS (t) = 1;
2280     }
2281
2282   va_end (p);
2283   return t;
2284 }
2285
2286 /* Similar to `build', but for template definitions of non-dependent
2287    expressions. NON_DEP is the non-dependent expression that has been
2288    built.  */
2289
2290 tree
2291 build_min_non_dep (enum tree_code code, tree non_dep, ...)
2292 {
2293   tree t;
2294   int length;
2295   int i;
2296   va_list p;
2297
2298   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
2299
2300   va_start (p, non_dep);
2301
2302   if (REFERENCE_REF_P (non_dep))
2303     non_dep = TREE_OPERAND (non_dep, 0);
2304
2305   t = make_node (code);
2306   length = TREE_CODE_LENGTH (code);
2307   TREE_TYPE (t) = TREE_TYPE (non_dep);
2308   TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (non_dep);
2309
2310   for (i = 0; i < length; i++)
2311     {
2312       tree x = va_arg (p, tree);
2313       TREE_OPERAND (t, i) = x;
2314     }
2315
2316   if (code == COMPOUND_EXPR && TREE_CODE (non_dep) != COMPOUND_EXPR)
2317     /* This should not be considered a COMPOUND_EXPR, because it
2318        resolves to an overload.  */
2319     COMPOUND_EXPR_OVERLOADED (t) = 1;
2320
2321   va_end (p);
2322   return convert_from_reference (t);
2323 }
2324
2325 /* Similar to `build_nt_call_vec', but for template definitions of
2326    non-dependent expressions. NON_DEP is the non-dependent expression
2327    that has been built.  */
2328
2329 tree
2330 build_min_non_dep_call_vec (tree non_dep, tree fn, VEC(tree,gc) *argvec)
2331 {
2332   tree t = build_nt_call_vec (fn, argvec);
2333   if (REFERENCE_REF_P (non_dep))
2334     non_dep = TREE_OPERAND (non_dep, 0);
2335   TREE_TYPE (t) = TREE_TYPE (non_dep);
2336   TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (non_dep);
2337   return convert_from_reference (t);
2338 }
2339
2340 tree
2341 get_type_decl (tree t)
2342 {
2343   if (TREE_CODE (t) == TYPE_DECL)
2344     return t;
2345   if (TYPE_P (t))
2346     return TYPE_STUB_DECL (t);
2347   gcc_assert (t == error_mark_node);
2348   return t;
2349 }
2350
2351 /* Returns the namespace that contains DECL, whether directly or
2352    indirectly.  */
2353
2354 tree
2355 decl_namespace_context (tree decl)
2356 {
2357   while (1)
2358     {
2359       if (TREE_CODE (decl) == NAMESPACE_DECL)
2360         return decl;
2361       else if (TYPE_P (decl))
2362         decl = CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl));
2363       else
2364         decl = CP_DECL_CONTEXT (decl);
2365     }
2366 }
2367
2368 /* Returns true if decl is within an anonymous namespace, however deeply
2369    nested, or false otherwise.  */
2370
2371 bool
2372 decl_anon_ns_mem_p (const_tree decl)
2373 {
2374   while (1)
2375     {
2376       if (decl == NULL_TREE || decl == error_mark_node)
2377         return false;
2378       if (TREE_CODE (decl) == NAMESPACE_DECL
2379           && DECL_NAME (decl) == NULL_TREE)
2380         return true;
2381       /* Classes and namespaces inside anonymous namespaces have
2382          TREE_PUBLIC == 0, so we can shortcut the search.  */
2383       else if (TYPE_P (decl))
2384         return (TREE_PUBLIC (TYPE_NAME (decl)) == 0);
2385       else if (TREE_CODE (decl) == NAMESPACE_DECL)
2386         return (TREE_PUBLIC (decl) == 0);
2387       else
2388         decl = DECL_CONTEXT (decl);
2389     }
2390 }
2391
2392 /* Subroutine of cp_tree_equal: t1 and t2 are the CALL_EXPR_FNs of two
2393    CALL_EXPRS.  Return whether they are equivalent.  */
2394
2395 static bool
2396 called_fns_equal (tree t1, tree t2)
2397 {
2398   /* Core 1321: dependent names are equivalent even if the overload sets
2399      are different.  But do compare explicit template arguments.  */
2400   tree name1 = dependent_name (t1);
2401   tree name2 = dependent_name (t2);
2402   if (name1 || name2)
2403     {
2404       tree targs1 = NULL_TREE, targs2 = NULL_TREE;
2405
2406       if (name1 != name2)
2407         return false;
2408
2409       if (TREE_CODE (t1) == TEMPLATE_ID_EXPR)
2410         targs1 = TREE_OPERAND (t1, 1);
2411       if (TREE_CODE (t2) == TEMPLATE_ID_EXPR)
2412         targs2 = TREE_OPERAND (t2, 1);
2413       return cp_tree_equal (targs1, targs2);
2414     }
2415   else
2416     return cp_tree_equal (t1, t2);
2417 }
2418
2419 /* Return truthvalue of whether T1 is the same tree structure as T2.
2420    Return 1 if they are the same. Return 0 if they are different.  */
2421
2422 bool
2423 cp_tree_equal (tree t1, tree t2)
2424 {
2425   enum tree_code code1, code2;
2426
2427   if (t1 == t2)
2428     return true;
2429   if (!t1 || !t2)
2430     return false;
2431
2432   for (code1 = TREE_CODE (t1);
2433        CONVERT_EXPR_CODE_P (code1)
2434          || code1 == NON_LVALUE_EXPR;
2435        code1 = TREE_CODE (t1))
2436     t1 = TREE_OPERAND (t1, 0);
2437   for (code2 = TREE_CODE (t2);
2438        CONVERT_EXPR_CODE_P (code2)
2439          || code1 == NON_LVALUE_EXPR;
2440        code2 = TREE_CODE (t2))
2441     t2 = TREE_OPERAND (t2, 0);
2442
2443   /* They might have become equal now.  */
2444   if (t1 == t2)
2445     return true;
2446
2447   if (code1 != code2)
2448     return false;
2449
2450   switch (code1)
2451     {
2452     case INTEGER_CST:
2453       return TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
2454         && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2);
2455
2456     case REAL_CST:
2457       return REAL_VALUES_EQUAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
2458
2459     case STRING_CST:
2460       return TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
2461         && !memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
2462                     TREE_STRING_LENGTH (t1));
2463
2464     case FIXED_CST:
2465       return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1),
2466                                      TREE_FIXED_CST (t2));
2467
2468     case COMPLEX_CST:
2469       return cp_tree_equal (TREE_REALPART (t1), TREE_REALPART (t2))
2470         && cp_tree_equal (TREE_IMAGPART (t1), TREE_IMAGPART (t2));
2471
2472     case CONSTRUCTOR:
2473       /* We need to do this when determining whether or not two
2474          non-type pointer to member function template arguments
2475          are the same.  */
2476       if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
2477           || CONSTRUCTOR_NELTS (t1) != CONSTRUCTOR_NELTS (t2))
2478         return false;
2479       {
2480         tree field, value;
2481         unsigned int i;
2482         FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1), i, field, value)
2483           {
2484             constructor_elt *elt2 = CONSTRUCTOR_ELT (t2, i);
2485             if (!cp_tree_equal (field, elt2->index)
2486                 || !cp_tree_equal (value, elt2->value))
2487               return false;
2488           }
2489       }
2490       return true;
2491
2492     case TREE_LIST:
2493       if (!cp_tree_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2)))
2494         return false;
2495       if (!cp_tree_equal (TREE_VALUE (t1), TREE_VALUE (t2)))
2496         return false;
2497       return cp_tree_equal (TREE_CHAIN (t1), TREE_CHAIN (t2));
2498
2499     case SAVE_EXPR:
2500       return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2501
2502     case CALL_EXPR:
2503       {
2504         tree arg1, arg2;
2505         call_expr_arg_iterator iter1, iter2;
2506         if (!called_fns_equal (CALL_EXPR_FN (t1), CALL_EXPR_FN (t2)))
2507           return false;
2508         for (arg1 = first_call_expr_arg (t1, &iter1),
2509                arg2 = first_call_expr_arg (t2, &iter2);
2510              arg1 && arg2;
2511              arg1 = next_call_expr_arg (&iter1),
2512                arg2 = next_call_expr_arg (&iter2))
2513           if (!cp_tree_equal (arg1, arg2))
2514             return false;
2515         if (arg1 || arg2)
2516           return false;
2517         return true;
2518       }
2519
2520     case TARGET_EXPR:
2521       {
2522         tree o1 = TREE_OPERAND (t1, 0);
2523         tree o2 = TREE_OPERAND (t2, 0);
2524
2525         /* Special case: if either target is an unallocated VAR_DECL,
2526            it means that it's going to be unified with whatever the
2527            TARGET_EXPR is really supposed to initialize, so treat it
2528            as being equivalent to anything.  */
2529         if (TREE_CODE (o1) == VAR_DECL && DECL_NAME (o1) == NULL_TREE
2530             && !DECL_RTL_SET_P (o1))
2531           /*Nop*/;
2532         else if (TREE_CODE (o2) == VAR_DECL && DECL_NAME (o2) == NULL_TREE
2533                  && !DECL_RTL_SET_P (o2))
2534           /*Nop*/;
2535         else if (!cp_tree_equal (o1, o2))
2536           return false;
2537
2538         return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
2539       }
2540
2541     case WITH_CLEANUP_EXPR:
2542       if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
2543         return false;
2544       return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
2545
2546     case COMPONENT_REF:
2547       if (TREE_OPERAND (t1, 1) != TREE_OPERAND (t2, 1))
2548         return false;
2549       return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2550
2551     case PARM_DECL:
2552       /* For comparing uses of parameters in late-specified return types
2553          with an out-of-class definition of the function, but can also come
2554          up for expressions that involve 'this' in a member function
2555          template.  */
2556       if (same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
2557         {
2558           if (DECL_ARTIFICIAL (t1) ^ DECL_ARTIFICIAL (t2))
2559             return false;
2560           if (DECL_ARTIFICIAL (t1)
2561               || (DECL_PARM_LEVEL (t1) == DECL_PARM_LEVEL (t2)
2562                   && DECL_PARM_INDEX (t1) == DECL_PARM_INDEX (t2)))
2563             return true;
2564         }
2565       return false;
2566
2567     case VAR_DECL:
2568     case CONST_DECL:
2569     case FUNCTION_DECL:
2570     case TEMPLATE_DECL:
2571     case IDENTIFIER_NODE:
2572     case SSA_NAME:
2573       return false;
2574
2575     case BASELINK:
2576       return (BASELINK_BINFO (t1) == BASELINK_BINFO (t2)
2577               && BASELINK_ACCESS_BINFO (t1) == BASELINK_ACCESS_BINFO (t2)
2578               && BASELINK_QUALIFIED_P (t1) == BASELINK_QUALIFIED_P (t2)
2579               && cp_tree_equal (BASELINK_FUNCTIONS (t1),
2580                                 BASELINK_FUNCTIONS (t2)));
2581
2582     case TEMPLATE_PARM_INDEX:
2583       return (TEMPLATE_PARM_IDX (t1) == TEMPLATE_PARM_IDX (t2)
2584               && TEMPLATE_PARM_LEVEL (t1) == TEMPLATE_PARM_LEVEL (t2)
2585               && (TEMPLATE_PARM_PARAMETER_PACK (t1)
2586                   == TEMPLATE_PARM_PARAMETER_PACK (t2))
2587               && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1)),
2588                               TREE_TYPE (TEMPLATE_PARM_DECL (t2))));
2589
2590     case TEMPLATE_ID_EXPR:
2591       return (cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0))
2592               && cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1)));
2593
2594     case TREE_VEC:
2595       {
2596         unsigned ix;
2597         if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2))
2598           return false;
2599         for (ix = TREE_VEC_LENGTH (t1); ix--;)
2600           if (!cp_tree_equal (TREE_VEC_ELT (t1, ix),
2601                               TREE_VEC_ELT (t2, ix)))
2602             return false;
2603         return true;
2604       }
2605
2606     case SIZEOF_EXPR:
2607     case ALIGNOF_EXPR:
2608       {
2609         tree o1 = TREE_OPERAND (t1, 0);
2610         tree o2 = TREE_OPERAND (t2, 0);
2611
2612         if (TREE_CODE (o1) != TREE_CODE (o2))
2613           return false;
2614         if (TYPE_P (o1))
2615           return same_type_p (o1, o2);
2616         else
2617           return cp_tree_equal (o1, o2);
2618       }
2619
2620     case MODOP_EXPR:
2621       {
2622         tree t1_op1, t2_op1;
2623
2624         if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
2625           return false;
2626
2627         t1_op1 = TREE_OPERAND (t1, 1);
2628         t2_op1 = TREE_OPERAND (t2, 1);
2629         if (TREE_CODE (t1_op1) != TREE_CODE (t2_op1))
2630           return false;
2631
2632         return cp_tree_equal (TREE_OPERAND (t1, 2), TREE_OPERAND (t2, 2));
2633       }
2634
2635     case PTRMEM_CST:
2636       /* Two pointer-to-members are the same if they point to the same
2637          field or function in the same class.  */
2638       if (PTRMEM_CST_MEMBER (t1) != PTRMEM_CST_MEMBER (t2))
2639         return false;
2640
2641       return same_type_p (PTRMEM_CST_CLASS (t1), PTRMEM_CST_CLASS (t2));
2642
2643     case OVERLOAD:
2644       if (OVL_FUNCTION (t1) != OVL_FUNCTION (t2))
2645         return false;
2646       return cp_tree_equal (OVL_CHAIN (t1), OVL_CHAIN (t2));
2647
2648     case TRAIT_EXPR:
2649       if (TRAIT_EXPR_KIND (t1) != TRAIT_EXPR_KIND (t2))
2650         return false;
2651       return same_type_p (TRAIT_EXPR_TYPE1 (t1), TRAIT_EXPR_TYPE1 (t2))
2652         && same_type_p (TRAIT_EXPR_TYPE2 (t1), TRAIT_EXPR_TYPE2 (t2));
2653
2654     case CAST_EXPR:
2655     case STATIC_CAST_EXPR:
2656     case REINTERPRET_CAST_EXPR:
2657     case CONST_CAST_EXPR:
2658     case DYNAMIC_CAST_EXPR:
2659     case IMPLICIT_CONV_EXPR:
2660     case NEW_EXPR:
2661       if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
2662         return false;
2663       /* Now compare operands as usual.  */
2664       break;
2665
2666     case DEFERRED_NOEXCEPT:
2667       return (cp_tree_equal (DEFERRED_NOEXCEPT_PATTERN (t1),
2668                              DEFERRED_NOEXCEPT_PATTERN (t2))
2669               && comp_template_args (DEFERRED_NOEXCEPT_ARGS (t1),
2670                                      DEFERRED_NOEXCEPT_ARGS (t2)));
2671       break;
2672
2673     default:
2674       break;
2675     }
2676
2677   switch (TREE_CODE_CLASS (code1))
2678     {
2679     case tcc_unary:
2680     case tcc_binary:
2681     case tcc_comparison:
2682     case tcc_expression:
2683     case tcc_vl_exp:
2684     case tcc_reference:
2685     case tcc_statement:
2686       {
2687         int i, n;
2688
2689         n = cp_tree_operand_length (t1);
2690         if (TREE_CODE_CLASS (code1) == tcc_vl_exp
2691             && n != TREE_OPERAND_LENGTH (t2))
2692           return false;
2693
2694         for (i = 0; i < n; ++i)
2695           if (!cp_tree_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i)))
2696             return false;
2697
2698         return true;
2699       }
2700
2701     case tcc_type:
2702       return same_type_p (t1, t2);
2703     default:
2704       gcc_unreachable ();
2705     }
2706   /* We can get here with --disable-checking.  */
2707   return false;
2708 }
2709
2710 /* The type of ARG when used as an lvalue.  */
2711
2712 tree
2713 lvalue_type (tree arg)
2714 {
2715   tree type = TREE_TYPE (arg);
2716   return type;
2717 }
2718
2719 /* The type of ARG for printing error messages; denote lvalues with
2720    reference types.  */
2721
2722 tree
2723 error_type (tree arg)
2724 {
2725   tree type = TREE_TYPE (arg);
2726
2727   if (TREE_CODE (type) == ARRAY_TYPE)
2728     ;
2729   else if (TREE_CODE (type) == ERROR_MARK)
2730     ;
2731   else if (real_lvalue_p (arg))
2732     type = build_reference_type (lvalue_type (arg));
2733   else if (MAYBE_CLASS_TYPE_P (type))
2734     type = lvalue_type (arg);
2735
2736   return type;
2737 }
2738
2739 /* Does FUNCTION use a variable-length argument list?  */
2740
2741 int
2742 varargs_function_p (const_tree function)
2743 {
2744   return stdarg_p (TREE_TYPE (function));
2745 }
2746
2747 /* Returns 1 if decl is a member of a class.  */
2748
2749 int
2750 member_p (const_tree decl)
2751 {
2752   const_tree const ctx = DECL_CONTEXT (decl);
2753   return (ctx && TYPE_P (ctx));
2754 }
2755
2756 /* Create a placeholder for member access where we don't actually have an
2757    object that the access is against.  */
2758
2759 tree
2760 build_dummy_object (tree type)
2761 {
2762   tree decl = build1 (NOP_EXPR, build_pointer_type (type), void_zero_node);
2763   return cp_build_indirect_ref (decl, RO_NULL, tf_warning_or_error);
2764 }
2765
2766 /* We've gotten a reference to a member of TYPE.  Return *this if appropriate,
2767    or a dummy object otherwise.  If BINFOP is non-0, it is filled with the
2768    binfo path from current_class_type to TYPE, or 0.  */
2769
2770 tree
2771 maybe_dummy_object (tree type, tree* binfop)
2772 {
2773   tree decl, context;
2774   tree binfo;
2775   tree current = current_nonlambda_class_type ();
2776
2777   if (current
2778       && (binfo = lookup_base (current, type, ba_any, NULL)))
2779     context = current;
2780   else
2781     {
2782       /* Reference from a nested class member function.  */
2783       context = type;
2784       binfo = TYPE_BINFO (type);
2785     }
2786
2787   if (binfop)
2788     *binfop = binfo;
2789
2790   if (current_class_ref
2791       /* current_class_ref might not correspond to current_class_type if
2792          we're in tsubst_default_argument or a lambda-declarator; in either
2793          case, we want to use current_class_ref if it matches CONTEXT.  */
2794       && (same_type_ignoring_top_level_qualifiers_p
2795           (TREE_TYPE (current_class_ref), context)))
2796     decl = current_class_ref;
2797   else if (current != current_class_type
2798            && context == nonlambda_method_basetype ())
2799     /* In a lambda, need to go through 'this' capture.  */
2800     decl = (build_x_indirect_ref
2801             (input_location, (lambda_expr_this_capture
2802                               (CLASSTYPE_LAMBDA_EXPR (current_class_type))),
2803              RO_NULL, tf_warning_or_error));
2804   else
2805     decl = build_dummy_object (context);
2806
2807   return decl;
2808 }
2809
2810 /* Returns 1 if OB is a placeholder object, or a pointer to one.  */
2811
2812 int
2813 is_dummy_object (const_tree ob)
2814 {
2815   if (TREE_CODE (ob) == INDIRECT_REF)
2816     ob = TREE_OPERAND (ob, 0);
2817   return (TREE_CODE (ob) == NOP_EXPR
2818           && TREE_OPERAND (ob, 0) == void_zero_node);
2819 }
2820
2821 /* Returns 1 iff type T is something we want to treat as a scalar type for
2822    the purpose of deciding whether it is trivial/POD/standard-layout.  */
2823
2824 static bool
2825 scalarish_type_p (const_tree t)
2826 {
2827   if (t == error_mark_node)
2828     return 1;
2829
2830   return (SCALAR_TYPE_P (t)
2831           || TREE_CODE (t) == VECTOR_TYPE);
2832 }
2833
2834 /* Returns true iff T requires non-trivial default initialization.  */
2835
2836 bool
2837 type_has_nontrivial_default_init (const_tree t)
2838 {
2839   t = strip_array_types (CONST_CAST_TREE (t));
2840
2841   if (CLASS_TYPE_P (t))
2842     return TYPE_HAS_COMPLEX_DFLT (t);
2843   else
2844     return 0;
2845 }
2846
2847 /* Returns true iff copying an object of type T (including via move
2848    constructor) is non-trivial.  That is, T has no non-trivial copy
2849    constructors and no non-trivial move constructors.  */
2850
2851 bool
2852 type_has_nontrivial_copy_init (const_tree t)
2853 {
2854   t = strip_array_types (CONST_CAST_TREE (t));
2855
2856   if (CLASS_TYPE_P (t))
2857     {
2858       gcc_assert (COMPLETE_TYPE_P (t));
2859       return ((TYPE_HAS_COPY_CTOR (t)
2860                && TYPE_HAS_COMPLEX_COPY_CTOR (t))
2861               || TYPE_HAS_COMPLEX_MOVE_CTOR (t));
2862     }
2863   else
2864     return 0;
2865 }
2866
2867 /* Returns 1 iff type T is a trivially copyable type, as defined in
2868    [basic.types] and [class].  */
2869
2870 bool
2871 trivially_copyable_p (const_tree t)
2872 {
2873   t = strip_array_types (CONST_CAST_TREE (t));
2874
2875   if (CLASS_TYPE_P (t))
2876     return ((!TYPE_HAS_COPY_CTOR (t)
2877              || !TYPE_HAS_COMPLEX_COPY_CTOR (t))
2878             && !TYPE_HAS_COMPLEX_MOVE_CTOR (t)
2879             && (!TYPE_HAS_COPY_ASSIGN (t)
2880                 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (t))
2881             && !TYPE_HAS_COMPLEX_MOVE_ASSIGN (t)
2882             && TYPE_HAS_TRIVIAL_DESTRUCTOR (t));
2883   else
2884     return scalarish_type_p (t);
2885 }
2886
2887 /* Returns 1 iff type T is a trivial type, as defined in [basic.types] and
2888    [class].  */
2889
2890 bool
2891 trivial_type_p (const_tree t)
2892 {
2893   t = strip_array_types (CONST_CAST_TREE (t));
2894
2895   if (CLASS_TYPE_P (t))
2896     return (TYPE_HAS_TRIVIAL_DFLT (t)
2897             && trivially_copyable_p (t));
2898   else
2899     return scalarish_type_p (t);
2900 }
2901
2902 /* Returns 1 iff type T is a POD type, as defined in [basic.types].  */
2903
2904 bool
2905 pod_type_p (const_tree t)
2906 {
2907   /* This CONST_CAST is okay because strip_array_types returns its
2908      argument unmodified and we assign it to a const_tree.  */
2909   t = strip_array_types (CONST_CAST_TREE(t));
2910
2911   if (!CLASS_TYPE_P (t))
2912     return scalarish_type_p (t);
2913   else if (cxx_dialect > cxx98)
2914     /* [class]/10: A POD struct is a class that is both a trivial class and a
2915        standard-layout class, and has no non-static data members of type
2916        non-POD struct, non-POD union (or array of such types).
2917
2918        We don't need to check individual members because if a member is
2919        non-std-layout or non-trivial, the class will be too.  */
2920     return (std_layout_type_p (t) && trivial_type_p (t));
2921   else
2922     /* The C++98 definition of POD is different.  */
2923     return !CLASSTYPE_NON_LAYOUT_POD_P (t);
2924 }
2925
2926 /* Returns true iff T is POD for the purpose of layout, as defined in the
2927    C++ ABI.  */
2928
2929 bool
2930 layout_pod_type_p (const_tree t)
2931 {
2932   t = strip_array_types (CONST_CAST_TREE (t));
2933
2934   if (CLASS_TYPE_P (t))
2935     return !CLASSTYPE_NON_LAYOUT_POD_P (t);
2936   else
2937     return scalarish_type_p (t);
2938 }
2939
2940 /* Returns true iff T is a standard-layout type, as defined in
2941    [basic.types].  */
2942
2943 bool
2944 std_layout_type_p (const_tree t)
2945 {
2946   t = strip_array_types (CONST_CAST_TREE (t));
2947
2948   if (CLASS_TYPE_P (t))
2949     return !CLASSTYPE_NON_STD_LAYOUT (t);
2950   else
2951     return scalarish_type_p (t);
2952 }
2953
2954 /* Nonzero iff type T is a class template implicit specialization.  */
2955
2956 bool
2957 class_tmpl_impl_spec_p (const_tree t)
2958 {
2959   return CLASS_TYPE_P (t) && CLASSTYPE_TEMPLATE_INSTANTIATION (t);
2960 }
2961
2962 /* Returns 1 iff zero initialization of type T means actually storing
2963    zeros in it.  */
2964
2965 int
2966 zero_init_p (const_tree t)
2967 {
2968   /* This CONST_CAST is okay because strip_array_types returns its
2969      argument unmodified and we assign it to a const_tree.  */
2970   t = strip_array_types (CONST_CAST_TREE(t));
2971
2972   if (t == error_mark_node)
2973     return 1;
2974
2975   /* NULL pointers to data members are initialized with -1.  */
2976   if (TYPE_PTRDATAMEM_P (t))
2977     return 0;
2978
2979   /* Classes that contain types that can't be zero-initialized, cannot
2980      be zero-initialized themselves.  */
2981   if (CLASS_TYPE_P (t) && CLASSTYPE_NON_ZERO_INIT_P (t))
2982     return 0;
2983
2984   return 1;
2985 }
2986
2987 /* Table of valid C++ attributes.  */
2988 const struct attribute_spec cxx_attribute_table[] =
2989 {
2990   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
2991        affects_type_identity } */
2992   { "java_interface", 0, 0, false, false, false,
2993     handle_java_interface_attribute, false },
2994   { "com_interface",  0, 0, false, false, false,
2995     handle_com_interface_attribute, false },
2996   { "init_priority",  1, 1, true,  false, false,
2997     handle_init_priority_attribute, false },
2998   { NULL,             0, 0, false, false, false, NULL, false }
2999 };
3000
3001 /* Handle a "java_interface" attribute; arguments as in
3002    struct attribute_spec.handler.  */
3003 static tree
3004 handle_java_interface_attribute (tree* node,
3005                                  tree name,
3006                                  tree args ATTRIBUTE_UNUSED ,
3007                                  int flags,
3008                                  bool* no_add_attrs)
3009 {
3010   if (DECL_P (*node)
3011       || !CLASS_TYPE_P (*node)
3012       || !TYPE_FOR_JAVA (*node))
3013     {
3014       error ("%qE attribute can only be applied to Java class definitions",
3015              name);
3016       *no_add_attrs = true;
3017       return NULL_TREE;
3018     }
3019   if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
3020     *node = build_variant_type_copy (*node);
3021   TYPE_JAVA_INTERFACE (*node) = 1;
3022
3023   return NULL_TREE;
3024 }
3025
3026 /* Handle a "com_interface" attribute; arguments as in
3027    struct attribute_spec.handler.  */
3028 static tree
3029 handle_com_interface_attribute (tree* node,
3030                                 tree name,
3031                                 tree args ATTRIBUTE_UNUSED ,
3032                                 int flags ATTRIBUTE_UNUSED ,
3033                                 bool* no_add_attrs)
3034 {
3035   static int warned;
3036
3037   *no_add_attrs = true;
3038
3039   if (DECL_P (*node)
3040       || !CLASS_TYPE_P (*node)
3041       || *node != TYPE_MAIN_VARIANT (*node))
3042     {
3043       warning (OPT_Wattributes, "%qE attribute can only be applied "
3044                "to class definitions", name);
3045       return NULL_TREE;
3046     }
3047
3048   if (!warned++)
3049     warning (0, "%qE is obsolete; g++ vtables are now COM-compatible by default",
3050              name);
3051
3052   return NULL_TREE;
3053 }
3054
3055 /* Handle an "init_priority" attribute; arguments as in
3056    struct attribute_spec.handler.  */
3057 static tree
3058 handle_init_priority_attribute (tree* node,
3059                                 tree name,
3060                                 tree args,
3061                                 int flags ATTRIBUTE_UNUSED ,
3062                                 bool* no_add_attrs)
3063 {
3064   tree initp_expr = TREE_VALUE (args);
3065   tree decl = *node;
3066   tree type = TREE_TYPE (decl);
3067   int pri;
3068
3069   STRIP_NOPS (initp_expr);
3070
3071   if (!initp_expr || TREE_CODE (initp_expr) != INTEGER_CST)
3072     {
3073       error ("requested init_priority is not an integer constant");
3074       *no_add_attrs = true;
3075       return NULL_TREE;
3076     }
3077
3078   pri = TREE_INT_CST_LOW (initp_expr);
3079
3080   type = strip_array_types (type);
3081
3082   if (decl == NULL_TREE
3083       || TREE_CODE (decl) != VAR_DECL
3084       || !TREE_STATIC (decl)
3085       || DECL_EXTERNAL (decl)
3086       || (TREE_CODE (type) != RECORD_TYPE
3087           && TREE_CODE (type) != UNION_TYPE)
3088       /* Static objects in functions are initialized the
3089          first time control passes through that
3090          function. This is not precise enough to pin down an
3091          init_priority value, so don't allow it.  */
3092       || current_function_decl)
3093     {
3094       error ("can only use %qE attribute on file-scope definitions "
3095              "of objects of class type", name);
3096       *no_add_attrs = true;
3097       return NULL_TREE;
3098     }
3099
3100   if (pri > MAX_INIT_PRIORITY || pri <= 0)
3101     {
3102       error ("requested init_priority is out of range");
3103       *no_add_attrs = true;
3104       return NULL_TREE;
3105     }
3106
3107   /* Check for init_priorities that are reserved for
3108      language and runtime support implementations.*/
3109   if (pri <= MAX_RESERVED_INIT_PRIORITY)
3110     {
3111       warning
3112         (0, "requested init_priority is reserved for internal use");
3113     }
3114
3115   if (SUPPORTS_INIT_PRIORITY)
3116     {
3117       SET_DECL_INIT_PRIORITY (decl, pri);
3118       DECL_HAS_INIT_PRIORITY_P (decl) = 1;
3119       return NULL_TREE;
3120     }
3121   else
3122     {
3123       error ("%qE attribute is not supported on this platform", name);
3124       *no_add_attrs = true;
3125       return NULL_TREE;
3126     }
3127 }
3128
3129 /* Return a new PTRMEM_CST of the indicated TYPE.  The MEMBER is the
3130    thing pointed to by the constant.  */
3131
3132 tree
3133 make_ptrmem_cst (tree type, tree member)
3134 {
3135   tree ptrmem_cst = make_node (PTRMEM_CST);
3136   TREE_TYPE (ptrmem_cst) = type;
3137   PTRMEM_CST_MEMBER (ptrmem_cst) = member;
3138   return ptrmem_cst;
3139 }
3140
3141 /* Build a variant of TYPE that has the indicated ATTRIBUTES.  May
3142    return an existing type if an appropriate type already exists.  */
3143
3144 tree
3145 cp_build_type_attribute_variant (tree type, tree attributes)
3146 {
3147   tree new_type;
3148
3149   new_type = build_type_attribute_variant (type, attributes);
3150   if (TREE_CODE (new_type) == FUNCTION_TYPE
3151       || TREE_CODE (new_type) == METHOD_TYPE)
3152     new_type = build_exception_variant (new_type,
3153                                         TYPE_RAISES_EXCEPTIONS (type));
3154
3155   /* Making a new main variant of a class type is broken.  */
3156   gcc_assert (!CLASS_TYPE_P (type) || new_type == type);
3157
3158   return new_type;
3159 }
3160
3161 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
3162    Called only after doing all language independent checks.  Only
3163    to check TYPE_RAISES_EXCEPTIONS for FUNCTION_TYPE, the rest is already
3164    compared in type_hash_eq.  */
3165
3166 bool
3167 cxx_type_hash_eq (const_tree typea, const_tree typeb)
3168 {
3169   gcc_assert (TREE_CODE (typea) == FUNCTION_TYPE
3170               || TREE_CODE (typea) == METHOD_TYPE);
3171
3172   return comp_except_specs (TYPE_RAISES_EXCEPTIONS (typea),
3173                             TYPE_RAISES_EXCEPTIONS (typeb), ce_exact);
3174 }
3175
3176 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
3177    traversal.  Called from walk_tree.  */
3178
3179 tree
3180 cp_walk_subtrees (tree *tp, int *walk_subtrees_p, walk_tree_fn func,
3181                   void *data, struct pointer_set_t *pset)
3182 {
3183   enum tree_code code = TREE_CODE (*tp);
3184   tree result;
3185
3186 #define WALK_SUBTREE(NODE)                              \
3187   do                                                    \
3188     {                                                   \
3189       result = cp_walk_tree (&(NODE), func, data, pset);        \
3190       if (result) goto out;                             \
3191     }                                                   \
3192   while (0)
3193
3194   /* Not one of the easy cases.  We must explicitly go through the
3195      children.  */
3196   result = NULL_TREE;
3197   switch (code)
3198     {
3199     case DEFAULT_ARG:
3200     case TEMPLATE_TEMPLATE_PARM:
3201     case BOUND_TEMPLATE_TEMPLATE_PARM:
3202     case UNBOUND_CLASS_TEMPLATE:
3203     case TEMPLATE_PARM_INDEX:
3204     case TEMPLATE_TYPE_PARM:
3205     case TYPENAME_TYPE:
3206     case TYPEOF_TYPE:
3207     case UNDERLYING_TYPE:
3208       /* None of these have subtrees other than those already walked
3209          above.  */
3210       *walk_subtrees_p = 0;
3211       break;
3212
3213     case BASELINK:
3214       WALK_SUBTREE (BASELINK_FUNCTIONS (*tp));
3215       *walk_subtrees_p = 0;
3216       break;
3217
3218     case PTRMEM_CST:
3219       WALK_SUBTREE (TREE_TYPE (*tp));
3220       *walk_subtrees_p = 0;
3221       break;
3222
3223     case TREE_LIST:
3224       WALK_SUBTREE (TREE_PURPOSE (*tp));
3225       break;
3226
3227     case OVERLOAD:
3228       WALK_SUBTREE (OVL_FUNCTION (*tp));
3229       WALK_SUBTREE (OVL_CHAIN (*tp));
3230       *walk_subtrees_p = 0;
3231       break;
3232
3233     case USING_DECL:
3234       WALK_SUBTREE (DECL_NAME (*tp));
3235       WALK_SUBTREE (USING_DECL_SCOPE (*tp));
3236       WALK_SUBTREE (USING_DECL_DECLS (*tp));
3237       *walk_subtrees_p = 0;
3238       break;
3239
3240     case RECORD_TYPE:
3241       if (TYPE_PTRMEMFUNC_P (*tp))
3242         WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE (*tp));
3243       break;
3244
3245     case TYPE_ARGUMENT_PACK:
3246     case NONTYPE_ARGUMENT_PACK:
3247       {
3248         tree args = ARGUMENT_PACK_ARGS (*tp);
3249         int i, len = TREE_VEC_LENGTH (args);
3250         for (i = 0; i < len; i++)
3251           WALK_SUBTREE (TREE_VEC_ELT (args, i));
3252       }
3253       break;
3254
3255     case TYPE_PACK_EXPANSION:
3256       WALK_SUBTREE (TREE_TYPE (*tp));
3257       WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp));
3258       *walk_subtrees_p = 0;
3259       break;
3260
3261     case EXPR_PACK_EXPANSION:
3262       WALK_SUBTREE (TREE_OPERAND (*tp, 0));
3263       WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp));
3264       *walk_subtrees_p = 0;
3265       break;
3266
3267     case CAST_EXPR:
3268     case REINTERPRET_CAST_EXPR:
3269     case STATIC_CAST_EXPR:
3270     case CONST_CAST_EXPR:
3271     case DYNAMIC_CAST_EXPR:
3272     case IMPLICIT_CONV_EXPR:
3273       if (TREE_TYPE (*tp))
3274         WALK_SUBTREE (TREE_TYPE (*tp));
3275
3276       {
3277         int i;
3278         for (i = 0; i < TREE_CODE_LENGTH (TREE_CODE (*tp)); ++i)
3279           WALK_SUBTREE (TREE_OPERAND (*tp, i));
3280       }
3281       *walk_subtrees_p = 0;
3282       break;
3283
3284     case TRAIT_EXPR:
3285       WALK_SUBTREE (TRAIT_EXPR_TYPE1 (*tp));
3286       WALK_SUBTREE (TRAIT_EXPR_TYPE2 (*tp));
3287       *walk_subtrees_p = 0;
3288       break;
3289
3290     case DECLTYPE_TYPE:
3291       WALK_SUBTREE (DECLTYPE_TYPE_EXPR (*tp));
3292       *walk_subtrees_p = 0;
3293       break;
3294
3295
3296     default:
3297       return NULL_TREE;
3298     }
3299
3300   /* We didn't find what we were looking for.  */
3301  out:
3302   return result;
3303
3304 #undef WALK_SUBTREE
3305 }
3306
3307 /* Like save_expr, but for C++.  */
3308
3309 tree
3310 cp_save_expr (tree expr)
3311 {
3312   /* There is no reason to create a SAVE_EXPR within a template; if
3313      needed, we can create the SAVE_EXPR when instantiating the
3314      template.  Furthermore, the middle-end cannot handle C++-specific
3315      tree codes.  */
3316   if (processing_template_decl)
3317     return expr;
3318   return save_expr (expr);
3319 }
3320
3321 /* Initialize tree.c.  */
3322
3323 void
3324 init_tree (void)
3325 {
3326   list_hash_table = htab_create_ggc (31, list_hash, list_hash_eq, NULL);
3327 }
3328
3329 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
3330    is.  Note that sfk_none is zero, so this function can be used as a
3331    predicate to test whether or not DECL is a special function.  */
3332
3333 special_function_kind
3334 special_function_p (const_tree decl)
3335 {
3336   /* Rather than doing all this stuff with magic names, we should
3337      probably have a field of type `special_function_kind' in
3338      DECL_LANG_SPECIFIC.  */
3339   if (DECL_COPY_CONSTRUCTOR_P (decl))
3340     return sfk_copy_constructor;
3341   if (DECL_MOVE_CONSTRUCTOR_P (decl))
3342     return sfk_move_constructor;
3343   if (DECL_CONSTRUCTOR_P (decl))
3344     return sfk_constructor;
3345   if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
3346     {
3347       if (copy_fn_p (decl))
3348         return sfk_copy_assignment;
3349       if (move_fn_p (decl))
3350         return sfk_move_assignment;
3351     }
3352   if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl))
3353     return sfk_destructor;
3354   if (DECL_COMPLETE_DESTRUCTOR_P (decl))
3355     return sfk_complete_destructor;
3356   if (DECL_BASE_DESTRUCTOR_P (decl))
3357     return sfk_base_destructor;
3358   if (DECL_DELETING_DESTRUCTOR_P (decl))
3359     return sfk_deleting_destructor;
3360   if (DECL_CONV_FN_P (decl))
3361     return sfk_conversion;
3362
3363   return sfk_none;
3364 }
3365
3366 /* Returns nonzero if TYPE is a character type, including wchar_t.  */
3367
3368 int
3369 char_type_p (tree type)
3370 {
3371   return (same_type_p (type, char_type_node)
3372           || same_type_p (type, unsigned_char_type_node)
3373           || same_type_p (type, signed_char_type_node)
3374           || same_type_p (type, char16_type_node)
3375           || same_type_p (type, char32_type_node)
3376           || same_type_p (type, wchar_type_node));
3377 }
3378
3379 /* Returns the kind of linkage associated with the indicated DECL.  Th
3380    value returned is as specified by the language standard; it is
3381    independent of implementation details regarding template
3382    instantiation, etc.  For example, it is possible that a declaration
3383    to which this function assigns external linkage would not show up
3384    as a global symbol when you run `nm' on the resulting object file.  */
3385
3386 linkage_kind
3387 decl_linkage (tree decl)
3388 {
3389   /* This function doesn't attempt to calculate the linkage from first
3390      principles as given in [basic.link].  Instead, it makes use of
3391      the fact that we have already set TREE_PUBLIC appropriately, and
3392      then handles a few special cases.  Ideally, we would calculate
3393      linkage first, and then transform that into a concrete
3394      implementation.  */
3395
3396   /* Things that don't have names have no linkage.  */
3397   if (!DECL_NAME (decl))
3398     return lk_none;
3399
3400   /* Fields have no linkage.  */
3401   if (TREE_CODE (decl) == FIELD_DECL)
3402     return lk_none;
3403
3404   /* Things that are TREE_PUBLIC have external linkage.  */
3405   if (TREE_PUBLIC (decl))
3406     return lk_external;
3407
3408   if (TREE_CODE (decl) == NAMESPACE_DECL)
3409     return lk_external;
3410
3411   /* Linkage of a CONST_DECL depends on the linkage of the enumeration
3412      type.  */
3413   if (TREE_CODE (decl) == CONST_DECL)
3414     return decl_linkage (TYPE_NAME (DECL_CONTEXT (decl)));
3415
3416   /* Some things that are not TREE_PUBLIC have external linkage, too.
3417      For example, on targets that don't have weak symbols, we make all
3418      template instantiations have internal linkage (in the object
3419      file), but the symbols should still be treated as having external
3420      linkage from the point of view of the language.  */
3421   if ((TREE_CODE (decl) == FUNCTION_DECL
3422        || TREE_CODE (decl) == VAR_DECL)
3423       && DECL_COMDAT (decl))
3424     return lk_external;
3425
3426   /* Things in local scope do not have linkage, if they don't have
3427      TREE_PUBLIC set.  */
3428   if (decl_function_context (decl))
3429     return lk_none;
3430
3431   /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
3432      are considered to have external linkage for language purposes.  DECLs
3433      really meant to have internal linkage have DECL_THIS_STATIC set.  */
3434   if (TREE_CODE (decl) == TYPE_DECL)
3435     return lk_external;
3436   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
3437     {
3438       if (!DECL_THIS_STATIC (decl))
3439         return lk_external;
3440
3441       /* Static data members and static member functions from classes
3442          in anonymous namespace also don't have TREE_PUBLIC set.  */
3443       if (DECL_CLASS_CONTEXT (decl))
3444         return lk_external;
3445     }
3446
3447   /* Everything else has internal linkage.  */
3448   return lk_internal;
3449 }
3450
3451 /* Returns the storage duration of the object or reference associated with
3452    the indicated DECL, which should be a VAR_DECL or PARM_DECL.  */
3453
3454 duration_kind
3455 decl_storage_duration (tree decl)
3456 {
3457   if (TREE_CODE (decl) == PARM_DECL)
3458     return dk_auto;
3459   if (TREE_CODE (decl) == FUNCTION_DECL)
3460     return dk_static;
3461   gcc_assert (TREE_CODE (decl) == VAR_DECL);
3462   if (!TREE_STATIC (decl)
3463       && !DECL_EXTERNAL (decl))
3464     return dk_auto;
3465   if (DECL_THREAD_LOCAL_P (decl))
3466     return dk_thread;
3467   return dk_static;
3468 }
3469 \f
3470 /* EXP is an expression that we want to pre-evaluate.  Returns (in
3471    *INITP) an expression that will perform the pre-evaluation.  The
3472    value returned by this function is a side-effect free expression
3473    equivalent to the pre-evaluated expression.  Callers must ensure
3474    that *INITP is evaluated before EXP.  */
3475
3476 tree
3477 stabilize_expr (tree exp, tree* initp)
3478 {
3479   tree init_expr;
3480
3481   if (!TREE_SIDE_EFFECTS (exp))
3482     init_expr = NULL_TREE;
3483   else if (VOID_TYPE_P (TREE_TYPE (exp)))
3484     {
3485       init_expr = exp;
3486       exp = void_zero_node;
3487     }
3488   /* There are no expressions with REFERENCE_TYPE, but there can be call
3489      arguments with such a type; just treat it as a pointer.  */
3490   else if (TREE_CODE (TREE_TYPE (exp)) == REFERENCE_TYPE
3491            || SCALAR_TYPE_P (TREE_TYPE (exp))
3492            || !lvalue_or_rvalue_with_address_p (exp))
3493     {
3494       init_expr = get_target_expr (exp);
3495       exp = TARGET_EXPR_SLOT (init_expr);
3496     }
3497   else
3498     {
3499       bool xval = !real_lvalue_p (exp);
3500       exp = cp_build_addr_expr (exp, tf_warning_or_error);
3501       init_expr = get_target_expr (exp);
3502       exp = TARGET_EXPR_SLOT (init_expr);
3503       exp = cp_build_indirect_ref (exp, RO_NULL, tf_warning_or_error);
3504       if (xval)
3505         exp = move (exp);
3506     }
3507   *initp = init_expr;
3508
3509   gcc_assert (!TREE_SIDE_EFFECTS (exp));
3510   return exp;
3511 }
3512
3513 /* Add NEW_EXPR, an expression whose value we don't care about, after the
3514    similar expression ORIG.  */
3515
3516 tree
3517 add_stmt_to_compound (tree orig, tree new_expr)
3518 {
3519   if (!new_expr || !TREE_SIDE_EFFECTS (new_expr))
3520     return orig;
3521   if (!orig || !TREE_SIDE_EFFECTS (orig))
3522     return new_expr;
3523   return build2 (COMPOUND_EXPR, void_type_node, orig, new_expr);
3524 }
3525
3526 /* Like stabilize_expr, but for a call whose arguments we want to
3527    pre-evaluate.  CALL is modified in place to use the pre-evaluated
3528    arguments, while, upon return, *INITP contains an expression to
3529    compute the arguments.  */
3530
3531 void
3532 stabilize_call (tree call, tree *initp)
3533 {
3534   tree inits = NULL_TREE;
3535   int i;
3536   int nargs = call_expr_nargs (call);
3537
3538   if (call == error_mark_node || processing_template_decl)
3539     {
3540       *initp = NULL_TREE;
3541       return;
3542     }
3543
3544   gcc_assert (TREE_CODE (call) == CALL_EXPR);
3545
3546   for (i = 0; i < nargs; i++)
3547     {
3548       tree init;
3549       CALL_EXPR_ARG (call, i) =
3550         stabilize_expr (CALL_EXPR_ARG (call, i), &init);
3551       inits = add_stmt_to_compound (inits, init);
3552     }
3553
3554   *initp = inits;
3555 }
3556
3557 /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
3558    to pre-evaluate.  CALL is modified in place to use the pre-evaluated
3559    arguments, while, upon return, *INITP contains an expression to
3560    compute the arguments.  */
3561
3562 void
3563 stabilize_aggr_init (tree call, tree *initp)
3564 {
3565   tree inits = NULL_TREE;
3566   int i;
3567   int nargs = aggr_init_expr_nargs (call);
3568
3569   if (call == error_mark_node)
3570     return;
3571
3572   gcc_assert (TREE_CODE (call) == AGGR_INIT_EXPR);
3573
3574   for (i = 0; i < nargs; i++)
3575     {
3576       tree init;
3577       AGGR_INIT_EXPR_ARG (call, i) =
3578         stabilize_expr (AGGR_INIT_EXPR_ARG (call, i), &init);
3579       inits = add_stmt_to_compound (inits, init);
3580     }
3581
3582   *initp = inits;
3583 }
3584
3585 /* Like stabilize_expr, but for an initialization.
3586
3587    If the initialization is for an object of class type, this function
3588    takes care not to introduce additional temporaries.
3589
3590    Returns TRUE iff the expression was successfully pre-evaluated,
3591    i.e., if INIT is now side-effect free, except for, possibly, a
3592    single call to a constructor.  */
3593
3594 bool
3595 stabilize_init (tree init, tree *initp)
3596 {
3597   tree t = init;
3598
3599   *initp = NULL_TREE;
3600
3601   if (t == error_mark_node || processing_template_decl)
3602     return true;
3603
3604   if (TREE_CODE (t) == INIT_EXPR)
3605     t = TREE_OPERAND (t, 1);
3606   if (TREE_CODE (t) == TARGET_EXPR)
3607     t = TARGET_EXPR_INITIAL (t);
3608
3609   /* If the RHS can be stabilized without breaking copy elision, stabilize
3610      it.  We specifically don't stabilize class prvalues here because that
3611      would mean an extra copy, but they might be stabilized below.  */
3612   if (TREE_CODE (init) == INIT_EXPR
3613       && TREE_CODE (t) != CONSTRUCTOR
3614       && TREE_CODE (t) != AGGR_INIT_EXPR
3615       && (SCALAR_TYPE_P (TREE_TYPE (t))
3616           || lvalue_or_rvalue_with_address_p (t)))
3617     {
3618       TREE_OPERAND (init, 1) = stabilize_expr (t, initp);
3619       return true;
3620     }
3621
3622   if (TREE_CODE (t) == COMPOUND_EXPR
3623       && TREE_CODE (init) == INIT_EXPR)
3624     {
3625       tree last = expr_last (t);
3626       /* Handle stabilizing the EMPTY_CLASS_EXPR pattern.  */
3627       if (!TREE_SIDE_EFFECTS (last))
3628         {
3629           *initp = t;
3630           TREE_OPERAND (init, 1) = last;
3631           return true;
3632         }
3633     }
3634
3635   if (TREE_CODE (t) == CONSTRUCTOR)
3636     {
3637       /* Aggregate initialization: stabilize each of the field
3638          initializers.  */
3639       unsigned i;
3640       constructor_elt *ce;
3641       bool good = true;
3642       VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (t);
3643       for (i = 0; VEC_iterate (constructor_elt, v, i, ce); ++i)
3644         {
3645           tree type = TREE_TYPE (ce->value);
3646           tree subinit;
3647           if (TREE_CODE (type) == REFERENCE_TYPE
3648               || SCALAR_TYPE_P (type))
3649             ce->value = stabilize_expr (ce->value, &subinit);
3650           else if (!stabilize_init (ce->value, &subinit))
3651             good = false;
3652           *initp = add_stmt_to_compound (*initp, subinit);
3653         }
3654       return good;
3655     }
3656
3657   if (TREE_CODE (t) == CALL_EXPR)
3658     {
3659       stabilize_call (t, initp);
3660       return true;
3661     }
3662
3663   if (TREE_CODE (t) == AGGR_INIT_EXPR)
3664     {
3665       stabilize_aggr_init (t, initp);
3666       return true;
3667     }
3668
3669   /* The initialization is being performed via a bitwise copy -- and
3670      the item copied may have side effects.  */
3671   return !TREE_SIDE_EFFECTS (init);
3672 }
3673
3674 /* Like "fold", but should be used whenever we might be processing the
3675    body of a template.  */
3676
3677 tree
3678 fold_if_not_in_template (tree expr)
3679 {
3680   /* In the body of a template, there is never any need to call
3681      "fold".  We will call fold later when actually instantiating the
3682      template.  Integral constant expressions in templates will be
3683      evaluated via fold_non_dependent_expr, as necessary.  */
3684   if (processing_template_decl)
3685     return expr;
3686
3687   /* Fold C++ front-end specific tree codes.  */
3688   if (TREE_CODE (expr) == UNARY_PLUS_EXPR)
3689     return fold_convert (TREE_TYPE (expr), TREE_OPERAND (expr, 0));
3690
3691   return fold (expr);
3692 }
3693
3694 /* Returns true if a cast to TYPE may appear in an integral constant
3695    expression.  */
3696
3697 bool
3698 cast_valid_in_integral_constant_expression_p (tree type)
3699 {
3700   return (INTEGRAL_OR_ENUMERATION_TYPE_P (type)
3701           || cxx_dialect >= cxx0x
3702           || dependent_type_p (type)
3703           || type == error_mark_node);
3704 }
3705
3706 /* Return true if we need to fix linkage information of DECL.  */
3707
3708 static bool
3709 cp_fix_function_decl_p (tree decl)
3710 {
3711   /* Skip if DECL is not externally visible.  */
3712   if (!TREE_PUBLIC (decl))
3713     return false;
3714
3715   /* We need to fix DECL if it a appears to be exported but with no
3716      function body.  Thunks do not have CFGs and we may need to
3717      handle them specially later.   */
3718   if (!gimple_has_body_p (decl)
3719       && !DECL_THUNK_P (decl)
3720       && !DECL_EXTERNAL (decl))
3721     {
3722       struct cgraph_node *node = cgraph_get_node (decl);
3723
3724       /* Don't fix same_body aliases.  Although they don't have their own
3725          CFG, they share it with what they alias to.  */
3726       if (!node || !node->alias
3727           || !VEC_length (ipa_ref_t, node->symbol.ref_list.references))
3728         return true;
3729     }
3730
3731   return false;
3732 }
3733
3734 /* Clean the C++ specific parts of the tree T. */
3735
3736 void
3737 cp_free_lang_data (tree t)
3738 {
3739   if (TREE_CODE (t) == METHOD_TYPE
3740       || TREE_CODE (t) == FUNCTION_TYPE)
3741     {
3742       /* Default args are not interesting anymore.  */
3743       tree argtypes = TYPE_ARG_TYPES (t);
3744       while (argtypes)
3745         {
3746           TREE_PURPOSE (argtypes) = 0;
3747           argtypes = TREE_CHAIN (argtypes);
3748         }
3749     }
3750   else if (TREE_CODE (t) == FUNCTION_DECL
3751            && cp_fix_function_decl_p (t))
3752     {
3753       /* If T is used in this translation unit at all,  the definition
3754          must exist somewhere else since we have decided to not emit it
3755          in this TU.  So make it an external reference.  */
3756       DECL_EXTERNAL (t) = 1;
3757       TREE_STATIC (t) = 0;
3758     }
3759   if (TREE_CODE (t) == NAMESPACE_DECL)
3760     {
3761       /* The list of users of a namespace isn't useful for the middle-end
3762          or debug generators.  */
3763       DECL_NAMESPACE_USERS (t) = NULL_TREE;
3764       /* Neither do we need the leftover chaining of namespaces
3765          from the binding level.  */
3766       DECL_CHAIN (t) = NULL_TREE;
3767     }
3768 }
3769
3770 /* Stub for c-common.  Please keep in sync with c-decl.c.
3771    FIXME: If address space support is target specific, then this
3772    should be a C target hook.  But currently this is not possible,
3773    because this function is called via REGISTER_TARGET_PRAGMAS.  */
3774 void
3775 c_register_addr_space (const char *word ATTRIBUTE_UNUSED,
3776                        addr_space_t as ATTRIBUTE_UNUSED)
3777 {
3778 }
3779
3780 /* Return the number of operands in T that we care about for things like
3781    mangling.  */
3782
3783 int
3784 cp_tree_operand_length (const_tree t)
3785 {
3786   enum tree_code code = TREE_CODE (t);
3787
3788   switch (code)
3789     {
3790     case PREINCREMENT_EXPR:
3791     case PREDECREMENT_EXPR:
3792     case POSTINCREMENT_EXPR:
3793     case POSTDECREMENT_EXPR:
3794       return 1;
3795
3796     case ARRAY_REF:
3797       return 2;
3798
3799     case EXPR_PACK_EXPANSION:
3800       return 1;
3801
3802     default:
3803       return TREE_OPERAND_LENGTH (t);
3804     }
3805 }
3806 \f
3807 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
3808 /* Complain that some language-specific thing hanging off a tree
3809    node has been accessed improperly.  */
3810
3811 void
3812 lang_check_failed (const char* file, int line, const char* function)
3813 {
3814   internal_error ("lang_* check: failed in %s, at %s:%d",
3815                   function, trim_filename (file), line);
3816 }
3817 #endif /* ENABLE_TREE_CHECKING */
3818
3819 #include "gt-cp-tree.h"