gcc/cp/tree.c

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