gcc/cp/tree.c

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