gcc/cp/tree.c

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