gcc/cp/tree.c

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