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