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