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     case VECTOR_TYPE:
2174       return no_linkage_check (TREE_TYPE (t), relaxed_p);
2175
2176     case OFFSET_TYPE:
2177     ptrmem:
2178       r = no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t),
2179                             relaxed_p);
2180       if (r)
2181         return r;
2182       return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t), relaxed_p);
2183
2184     case METHOD_TYPE:
2185       r = no_linkage_check (TYPE_METHOD_BASETYPE (t), relaxed_p);
2186       if (r)
2187         return r;
2188       /* Fall through.  */
2189     case FUNCTION_TYPE:
2190       {
2191         tree parm;
2192         for (parm = TYPE_ARG_TYPES (t);
2193              parm && parm != void_list_node;
2194              parm = TREE_CHAIN (parm))
2195           {
2196             r = no_linkage_check (TREE_VALUE (parm), relaxed_p);
2197             if (r)
2198               return r;
2199           }
2200         return no_linkage_check (TREE_TYPE (t), relaxed_p);
2201       }
2202
2203     default:
2204       return NULL_TREE;
2205     }
2206 }
2207
2208 extern int depth_reached;
2209
2210 void
2211 cxx_print_statistics (void)
2212 {
2213   print_search_statistics ();
2214   print_class_statistics ();
2215   print_template_statistics ();
2216   if (GATHER_STATISTICS)
2217     fprintf (stderr, "maximum template instantiation depth reached: %d\n",
2218              depth_reached);
2219 }
2220
2221 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2222    (which is an ARRAY_TYPE).  This counts only elements of the top
2223    array.  */
2224
2225 tree
2226 array_type_nelts_top (tree type)
2227 {
2228   return fold_build2_loc (input_location,
2229                       PLUS_EXPR, sizetype,
2230                       array_type_nelts (type),
2231                       size_one_node);
2232 }
2233
2234 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2235    (which is an ARRAY_TYPE).  This one is a recursive count of all
2236    ARRAY_TYPEs that are clumped together.  */
2237
2238 tree
2239 array_type_nelts_total (tree type)
2240 {
2241   tree sz = array_type_nelts_top (type);
2242   type = TREE_TYPE (type);
2243   while (TREE_CODE (type) == ARRAY_TYPE)
2244     {
2245       tree n = array_type_nelts_top (type);
2246       sz = fold_build2_loc (input_location,
2247                         MULT_EXPR, sizetype, sz, n);
2248       type = TREE_TYPE (type);
2249     }
2250   return sz;
2251 }
2252
2253 /* Called from break_out_target_exprs via mapcar.  */
2254
2255 static tree
2256 bot_manip (tree* tp, int* walk_subtrees, void* data)
2257 {
2258   splay_tree target_remap = ((splay_tree) data);
2259   tree t = *tp;
2260
2261   if (!TYPE_P (t) && TREE_CONSTANT (t) && !TREE_SIDE_EFFECTS (t))
2262     {
2263       /* There can't be any TARGET_EXPRs or their slot variables below this
2264          point.  But we must make a copy, in case subsequent processing
2265          alters any part of it.  For example, during gimplification a cast
2266          of the form (T) &X::f (where "f" is a member function) will lead
2267          to replacing the PTRMEM_CST for &X::f with a VAR_DECL.  */
2268       *walk_subtrees = 0;
2269       *tp = unshare_expr (t);
2270       return NULL_TREE;
2271     }
2272   if (TREE_CODE (t) == TARGET_EXPR)
2273     {
2274       tree u;
2275
2276       if (TREE_CODE (TREE_OPERAND (t, 1)) == AGGR_INIT_EXPR)
2277         {
2278           u = build_cplus_new (TREE_TYPE (t), TREE_OPERAND (t, 1),
2279                                tf_warning_or_error);
2280           if (AGGR_INIT_ZERO_FIRST (TREE_OPERAND (t, 1)))
2281             AGGR_INIT_ZERO_FIRST (TREE_OPERAND (u, 1)) = true;
2282         }
2283       else
2284         u = build_target_expr_with_type (TREE_OPERAND (t, 1), TREE_TYPE (t),
2285                                          tf_warning_or_error);
2286
2287       TARGET_EXPR_IMPLICIT_P (u) = TARGET_EXPR_IMPLICIT_P (t);
2288       TARGET_EXPR_LIST_INIT_P (u) = TARGET_EXPR_LIST_INIT_P (t);
2289       TARGET_EXPR_DIRECT_INIT_P (u) = TARGET_EXPR_DIRECT_INIT_P (t);
2290
2291       /* Map the old variable to the new one.  */
2292       splay_tree_insert (target_remap,
2293                          (splay_tree_key) TREE_OPERAND (t, 0),
2294                          (splay_tree_value) TREE_OPERAND (u, 0));
2295
2296       TREE_OPERAND (u, 1) = break_out_target_exprs (TREE_OPERAND (u, 1));
2297
2298       /* Replace the old expression with the new version.  */
2299       *tp = u;
2300       /* We don't have to go below this point; the recursive call to
2301          break_out_target_exprs will have handled anything below this
2302          point.  */
2303       *walk_subtrees = 0;
2304       return NULL_TREE;
2305     }
2306
2307   /* Make a copy of this node.  */
2308   t = copy_tree_r (tp, walk_subtrees, NULL);
2309   if (TREE_CODE (*tp) == CALL_EXPR)
2310     {
2311       set_flags_from_callee (*tp);
2312
2313       /* builtin_LINE and builtin_FILE get the location where the default
2314          argument is expanded, not where the call was written.  */
2315       tree callee = get_callee_fndecl (*tp);
2316       if (callee && DECL_BUILT_IN (callee))
2317         switch (DECL_FUNCTION_CODE (callee))
2318           {
2319           case BUILT_IN_FILE:
2320           case BUILT_IN_LINE:
2321             SET_EXPR_LOCATION (*tp, input_location);
2322           }
2323     }
2324   return t;
2325 }
2326
2327 /* Replace all remapped VAR_DECLs in T with their new equivalents.
2328    DATA is really a splay-tree mapping old variables to new
2329    variables.  */
2330
2331 static tree
2332 bot_replace (tree* t, int* /*walk_subtrees*/, void* data)
2333 {
2334   splay_tree target_remap = ((splay_tree) data);
2335
2336   if (VAR_P (*t))
2337     {
2338       splay_tree_node n = splay_tree_lookup (target_remap,
2339                                              (splay_tree_key) *t);
2340       if (n)
2341         *t = (tree) n->value;
2342     }
2343   else if (TREE_CODE (*t) == PARM_DECL
2344            && DECL_NAME (*t) == this_identifier)
2345     {
2346       /* In an NSDMI we need to replace the 'this' parameter we used for
2347          parsing with the real one for this function.  */
2348       *t = current_class_ptr;
2349     }
2350   else if (TREE_CODE (*t) == CONVERT_EXPR
2351            && CONVERT_EXPR_VBASE_PATH (*t))
2352     {
2353       /* In an NSDMI build_base_path defers building conversions to virtual
2354          bases, and we handle it here.  */
2355       tree basetype = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (*t)));
2356       vec<tree, va_gc> *vbases = CLASSTYPE_VBASECLASSES (current_class_type);
2357       int i; tree binfo;
2358       FOR_EACH_VEC_SAFE_ELT (vbases, i, binfo)
2359         if (BINFO_TYPE (binfo) == basetype)
2360           break;
2361       *t = build_base_path (PLUS_EXPR, TREE_OPERAND (*t, 0), binfo, true,
2362                             tf_warning_or_error);
2363     }
2364
2365   return NULL_TREE;
2366 }
2367
2368 /* When we parse a default argument expression, we may create
2369    temporary variables via TARGET_EXPRs.  When we actually use the
2370    default-argument expression, we make a copy of the expression
2371    and replace the temporaries with appropriate local versions.  */
2372
2373 tree
2374 break_out_target_exprs (tree t)
2375 {
2376   static int target_remap_count;
2377   static splay_tree target_remap;
2378
2379   if (!target_remap_count++)
2380     target_remap = splay_tree_new (splay_tree_compare_pointers,
2381                                    /*splay_tree_delete_key_fn=*/NULL,
2382                                    /*splay_tree_delete_value_fn=*/NULL);
2383   cp_walk_tree (&t, bot_manip, target_remap, NULL);
2384   cp_walk_tree (&t, bot_replace, target_remap, NULL);
2385
2386   if (!--target_remap_count)
2387     {
2388       splay_tree_delete (target_remap);
2389       target_remap = NULL;
2390     }
2391
2392   return t;
2393 }
2394
2395 /* Similar to `build_nt', but for template definitions of dependent
2396    expressions  */
2397
2398 tree
2399 build_min_nt_loc (location_t loc, enum tree_code code, ...)
2400 {
2401   tree t;
2402   int length;
2403   int i;
2404   va_list p;
2405
2406   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
2407
2408   va_start (p, code);
2409
2410   t = make_node (code);
2411   SET_EXPR_LOCATION (t, loc);
2412   length = TREE_CODE_LENGTH (code);
2413
2414   for (i = 0; i < length; i++)
2415     {
2416       tree x = va_arg (p, tree);
2417       TREE_OPERAND (t, i) = x;
2418     }
2419
2420   va_end (p);
2421   return t;
2422 }
2423
2424
2425 /* Similar to `build', but for template definitions.  */
2426
2427 tree
2428 build_min (enum tree_code code, tree tt, ...)
2429 {
2430   tree t;
2431   int length;
2432   int i;
2433   va_list p;
2434
2435   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
2436
2437   va_start (p, tt);
2438
2439   t = make_node (code);
2440   length = TREE_CODE_LENGTH (code);
2441   TREE_TYPE (t) = tt;
2442
2443   for (i = 0; i < length; i++)
2444     {
2445       tree x = va_arg (p, tree);
2446       TREE_OPERAND (t, i) = x;
2447       if (x && !TYPE_P (x) && TREE_SIDE_EFFECTS (x))
2448         TREE_SIDE_EFFECTS (t) = 1;
2449     }
2450
2451   va_end (p);
2452   return t;
2453 }
2454
2455 /* Similar to `build', but for template definitions of non-dependent
2456    expressions. NON_DEP is the non-dependent expression that has been
2457    built.  */
2458
2459 tree
2460 build_min_non_dep (enum tree_code code, tree non_dep, ...)
2461 {
2462   tree t;
2463   int length;
2464   int i;
2465   va_list p;
2466
2467   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
2468
2469   va_start (p, non_dep);
2470
2471   if (REFERENCE_REF_P (non_dep))
2472     non_dep = TREE_OPERAND (non_dep, 0);
2473
2474   t = make_node (code);
2475   length = TREE_CODE_LENGTH (code);
2476   TREE_TYPE (t) = TREE_TYPE (non_dep);
2477   TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (non_dep);
2478
2479   for (i = 0; i < length; i++)
2480     {
2481       tree x = va_arg (p, tree);
2482       TREE_OPERAND (t, i) = x;
2483     }
2484
2485   if (code == COMPOUND_EXPR && TREE_CODE (non_dep) != COMPOUND_EXPR)
2486     /* This should not be considered a COMPOUND_EXPR, because it
2487        resolves to an overload.  */
2488     COMPOUND_EXPR_OVERLOADED (t) = 1;
2489
2490   va_end (p);
2491   return convert_from_reference (t);
2492 }
2493
2494 /* Similar to `build_nt_call_vec', but for template definitions of
2495    non-dependent expressions. NON_DEP is the non-dependent expression
2496    that has been built.  */
2497
2498 tree
2499 build_min_non_dep_call_vec (tree non_dep, tree fn, vec<tree, va_gc> *argvec)
2500 {
2501   tree t = build_nt_call_vec (fn, argvec);
2502   if (REFERENCE_REF_P (non_dep))
2503     non_dep = TREE_OPERAND (non_dep, 0);
2504   TREE_TYPE (t) = TREE_TYPE (non_dep);
2505   TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (non_dep);
2506   return convert_from_reference (t);
2507 }
2508
2509 tree
2510 get_type_decl (tree t)
2511 {
2512   if (TREE_CODE (t) == TYPE_DECL)
2513     return t;
2514   if (TYPE_P (t))
2515     return TYPE_STUB_DECL (t);
2516   gcc_assert (t == error_mark_node);
2517   return t;
2518 }
2519
2520 /* Returns the namespace that contains DECL, whether directly or
2521    indirectly.  */
2522
2523 tree
2524 decl_namespace_context (tree decl)
2525 {
2526   while (1)
2527     {
2528       if (TREE_CODE (decl) == NAMESPACE_DECL)
2529         return decl;
2530       else if (TYPE_P (decl))
2531         decl = CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl));
2532       else
2533         decl = CP_DECL_CONTEXT (decl);
2534     }
2535 }
2536
2537 /* Returns true if decl is within an anonymous namespace, however deeply
2538    nested, or false otherwise.  */
2539
2540 bool
2541 decl_anon_ns_mem_p (const_tree decl)
2542 {
2543   while (1)
2544     {
2545       if (decl == NULL_TREE || decl == error_mark_node)
2546         return false;
2547       if (TREE_CODE (decl) == NAMESPACE_DECL
2548           && DECL_NAME (decl) == NULL_TREE)
2549         return true;
2550       /* Classes and namespaces inside anonymous namespaces have
2551          TREE_PUBLIC == 0, so we can shortcut the search.  */
2552       else if (TYPE_P (decl))
2553         return (TREE_PUBLIC (TYPE_MAIN_DECL (decl)) == 0);
2554       else if (TREE_CODE (decl) == NAMESPACE_DECL)
2555         return (TREE_PUBLIC (decl) == 0);
2556       else
2557         decl = DECL_CONTEXT (decl);
2558     }
2559 }
2560
2561 /* Subroutine of cp_tree_equal: t1 and t2 are the CALL_EXPR_FNs of two
2562    CALL_EXPRS.  Return whether they are equivalent.  */
2563
2564 static bool
2565 called_fns_equal (tree t1, tree t2)
2566 {
2567   /* Core 1321: dependent names are equivalent even if the overload sets
2568      are different.  But do compare explicit template arguments.  */
2569   tree name1 = dependent_name (t1);
2570   tree name2 = dependent_name (t2);
2571   if (name1 || name2)
2572     {
2573       tree targs1 = NULL_TREE, targs2 = NULL_TREE;
2574
2575       if (name1 != name2)
2576         return false;
2577
2578       if (TREE_CODE (t1) == TEMPLATE_ID_EXPR)
2579         targs1 = TREE_OPERAND (t1, 1);
2580       if (TREE_CODE (t2) == TEMPLATE_ID_EXPR)
2581         targs2 = TREE_OPERAND (t2, 1);
2582       return cp_tree_equal (targs1, targs2);
2583     }
2584   else
2585     return cp_tree_equal (t1, t2);
2586 }
2587
2588 /* Return truthvalue of whether T1 is the same tree structure as T2.
2589    Return 1 if they are the same. Return 0 if they are different.  */
2590
2591 bool
2592 cp_tree_equal (tree t1, tree t2)
2593 {
2594   enum tree_code code1, code2;
2595
2596   if (t1 == t2)
2597     return true;
2598   if (!t1 || !t2)
2599     return false;
2600
2601   for (code1 = TREE_CODE (t1);
2602        CONVERT_EXPR_CODE_P (code1)
2603          || code1 == NON_LVALUE_EXPR;
2604        code1 = TREE_CODE (t1))
2605     t1 = TREE_OPERAND (t1, 0);
2606   for (code2 = TREE_CODE (t2);
2607        CONVERT_EXPR_CODE_P (code2)
2608          || code2 == NON_LVALUE_EXPR;
2609        code2 = TREE_CODE (t2))
2610     t2 = TREE_OPERAND (t2, 0);
2611
2612   /* They might have become equal now.  */
2613   if (t1 == t2)
2614     return true;
2615
2616   if (code1 != code2)
2617     return false;
2618
2619   switch (code1)
2620     {
2621     case INTEGER_CST:
2622       return TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
2623         && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2);
2624
2625     case REAL_CST:
2626       return REAL_VALUES_EQUAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
2627
2628     case STRING_CST:
2629       return TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
2630         && !memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
2631                     TREE_STRING_LENGTH (t1));
2632
2633     case FIXED_CST:
2634       return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1),
2635                                      TREE_FIXED_CST (t2));
2636
2637     case COMPLEX_CST:
2638       return cp_tree_equal (TREE_REALPART (t1), TREE_REALPART (t2))
2639         && cp_tree_equal (TREE_IMAGPART (t1), TREE_IMAGPART (t2));
2640
2641     case VECTOR_CST:
2642       return operand_equal_p (t1, t2, OEP_ONLY_CONST);
2643
2644     case CONSTRUCTOR:
2645       /* We need to do this when determining whether or not two
2646          non-type pointer to member function template arguments
2647          are the same.  */
2648       if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
2649           || CONSTRUCTOR_NELTS (t1) != CONSTRUCTOR_NELTS (t2))
2650         return false;
2651       {
2652         tree field, value;
2653         unsigned int i;
2654         FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1), i, field, value)
2655           {
2656             constructor_elt *elt2 = CONSTRUCTOR_ELT (t2, i);
2657             if (!cp_tree_equal (field, elt2->index)
2658                 || !cp_tree_equal (value, elt2->value))
2659               return false;
2660           }
2661       }
2662       return true;
2663
2664     case TREE_LIST:
2665       if (!cp_tree_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2)))
2666         return false;
2667       if (!cp_tree_equal (TREE_VALUE (t1), TREE_VALUE (t2)))
2668         return false;
2669       return cp_tree_equal (TREE_CHAIN (t1), TREE_CHAIN (t2));
2670
2671     case SAVE_EXPR:
2672       return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2673
2674     case CALL_EXPR:
2675       {
2676         tree arg1, arg2;
2677         call_expr_arg_iterator iter1, iter2;
2678         if (!called_fns_equal (CALL_EXPR_FN (t1), CALL_EXPR_FN (t2)))
2679           return false;
2680         for (arg1 = first_call_expr_arg (t1, &iter1),
2681                arg2 = first_call_expr_arg (t2, &iter2);
2682              arg1 && arg2;
2683              arg1 = next_call_expr_arg (&iter1),
2684                arg2 = next_call_expr_arg (&iter2))
2685           if (!cp_tree_equal (arg1, arg2))
2686             return false;
2687         if (arg1 || arg2)
2688           return false;
2689         return true;
2690       }
2691
2692     case TARGET_EXPR:
2693       {
2694         tree o1 = TREE_OPERAND (t1, 0);
2695         tree o2 = TREE_OPERAND (t2, 0);
2696
2697         /* Special case: if either target is an unallocated VAR_DECL,
2698            it means that it's going to be unified with whatever the
2699            TARGET_EXPR is really supposed to initialize, so treat it
2700            as being equivalent to anything.  */
2701         if (VAR_P (o1) && DECL_NAME (o1) == NULL_TREE
2702             && !DECL_RTL_SET_P (o1))
2703           /*Nop*/;
2704         else if (VAR_P (o2) && DECL_NAME (o2) == NULL_TREE
2705                  && !DECL_RTL_SET_P (o2))
2706           /*Nop*/;
2707         else if (!cp_tree_equal (o1, o2))
2708           return false;
2709
2710         return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
2711       }
2712
2713     case WITH_CLEANUP_EXPR:
2714       if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
2715         return false;
2716       return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
2717
2718     case COMPONENT_REF:
2719       if (TREE_OPERAND (t1, 1) != TREE_OPERAND (t2, 1))
2720         return false;
2721       return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2722
2723     case PARM_DECL:
2724       /* For comparing uses of parameters in late-specified return types
2725          with an out-of-class definition of the function, but can also come
2726          up for expressions that involve 'this' in a member function
2727          template.  */
2728
2729       if (comparing_specializations)
2730         /* When comparing hash table entries, only an exact match is
2731            good enough; we don't want to replace 'this' with the
2732            version from another function.  */
2733         return false;
2734
2735       if (same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
2736         {
2737           if (DECL_ARTIFICIAL (t1) ^ DECL_ARTIFICIAL (t2))
2738             return false;
2739           if (DECL_ARTIFICIAL (t1)
2740               || (DECL_PARM_LEVEL (t1) == DECL_PARM_LEVEL (t2)
2741                   && DECL_PARM_INDEX (t1) == DECL_PARM_INDEX (t2)))
2742             return true;
2743         }
2744       return false;
2745
2746     case VAR_DECL:
2747     case CONST_DECL:
2748     case FIELD_DECL:
2749     case FUNCTION_DECL:
2750     case TEMPLATE_DECL:
2751     case IDENTIFIER_NODE:
2752     case SSA_NAME:
2753       return false;
2754
2755     case BASELINK:
2756       return (BASELINK_BINFO (t1) == BASELINK_BINFO (t2)
2757               && BASELINK_ACCESS_BINFO (t1) == BASELINK_ACCESS_BINFO (t2)
2758               && BASELINK_QUALIFIED_P (t1) == BASELINK_QUALIFIED_P (t2)
2759               && cp_tree_equal (BASELINK_FUNCTIONS (t1),
2760                                 BASELINK_FUNCTIONS (t2)));
2761
2762     case TEMPLATE_PARM_INDEX:
2763       return (TEMPLATE_PARM_IDX (t1) == TEMPLATE_PARM_IDX (t2)
2764               && TEMPLATE_PARM_LEVEL (t1) == TEMPLATE_PARM_LEVEL (t2)
2765               && (TEMPLATE_PARM_PARAMETER_PACK (t1)
2766                   == TEMPLATE_PARM_PARAMETER_PACK (t2))
2767               && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1)),
2768                               TREE_TYPE (TEMPLATE_PARM_DECL (t2))));
2769
2770     case TEMPLATE_ID_EXPR:
2771       return (cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0))
2772               && cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1)));
2773
2774     case TREE_VEC:
2775       {
2776         unsigned ix;
2777         if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2))
2778           return false;
2779         for (ix = TREE_VEC_LENGTH (t1); ix--;)
2780           if (!cp_tree_equal (TREE_VEC_ELT (t1, ix),
2781                               TREE_VEC_ELT (t2, ix)))
2782             return false;
2783         return true;
2784       }
2785
2786     case SIZEOF_EXPR:
2787     case ALIGNOF_EXPR:
2788       {
2789         tree o1 = TREE_OPERAND (t1, 0);
2790         tree o2 = TREE_OPERAND (t2, 0);
2791
2792         if (code1 == SIZEOF_EXPR)
2793           {
2794             if (SIZEOF_EXPR_TYPE_P (t1))
2795               o1 = TREE_TYPE (o1);
2796             if (SIZEOF_EXPR_TYPE_P (t2))
2797               o2 = TREE_TYPE (o2);
2798           }
2799         if (TREE_CODE (o1) != TREE_CODE (o2))
2800           return false;
2801         if (TYPE_P (o1))
2802           return same_type_p (o1, o2);
2803         else
2804           return cp_tree_equal (o1, o2);
2805       }
2806
2807     case MODOP_EXPR:
2808       {
2809         tree t1_op1, t2_op1;
2810
2811         if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
2812           return false;
2813
2814         t1_op1 = TREE_OPERAND (t1, 1);
2815         t2_op1 = TREE_OPERAND (t2, 1);
2816         if (TREE_CODE (t1_op1) != TREE_CODE (t2_op1))
2817           return false;
2818
2819         return cp_tree_equal (TREE_OPERAND (t1, 2), TREE_OPERAND (t2, 2));
2820       }
2821
2822     case PTRMEM_CST:
2823       /* Two pointer-to-members are the same if they point to the same
2824          field or function in the same class.  */
2825       if (PTRMEM_CST_MEMBER (t1) != PTRMEM_CST_MEMBER (t2))
2826         return false;
2827
2828       return same_type_p (PTRMEM_CST_CLASS (t1), PTRMEM_CST_CLASS (t2));
2829
2830     case OVERLOAD:
2831       if (OVL_FUNCTION (t1) != OVL_FUNCTION (t2))
2832         return false;
2833       return cp_tree_equal (OVL_CHAIN (t1), OVL_CHAIN (t2));
2834
2835     case TRAIT_EXPR:
2836       if (TRAIT_EXPR_KIND (t1) != TRAIT_EXPR_KIND (t2))
2837         return false;
2838       return same_type_p (TRAIT_EXPR_TYPE1 (t1), TRAIT_EXPR_TYPE1 (t2))
2839         && same_type_p (TRAIT_EXPR_TYPE2 (t1), TRAIT_EXPR_TYPE2 (t2));
2840
2841     case CAST_EXPR:
2842     case STATIC_CAST_EXPR:
2843     case REINTERPRET_CAST_EXPR:
2844     case CONST_CAST_EXPR:
2845     case DYNAMIC_CAST_EXPR:
2846     case IMPLICIT_CONV_EXPR:
2847     case NEW_EXPR:
2848       if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
2849         return false;
2850       /* Now compare operands as usual.  */
2851       break;
2852
2853     case DEFERRED_NOEXCEPT:
2854       return (cp_tree_equal (DEFERRED_NOEXCEPT_PATTERN (t1),
2855                              DEFERRED_NOEXCEPT_PATTERN (t2))
2856               && comp_template_args (DEFERRED_NOEXCEPT_ARGS (t1),
2857                                      DEFERRED_NOEXCEPT_ARGS (t2)));
2858       break;
2859
2860     default:
2861       break;
2862     }
2863
2864   switch (TREE_CODE_CLASS (code1))
2865     {
2866     case tcc_unary:
2867     case tcc_binary:
2868     case tcc_comparison:
2869     case tcc_expression:
2870     case tcc_vl_exp:
2871     case tcc_reference:
2872     case tcc_statement:
2873       {
2874         int i, n;
2875
2876         n = cp_tree_operand_length (t1);
2877         if (TREE_CODE_CLASS (code1) == tcc_vl_exp
2878             && n != TREE_OPERAND_LENGTH (t2))
2879           return false;
2880
2881         for (i = 0; i < n; ++i)
2882           if (!cp_tree_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i)))
2883             return false;
2884
2885         return true;
2886       }
2887
2888     case tcc_type:
2889       return same_type_p (t1, t2);
2890     default:
2891       gcc_unreachable ();
2892     }
2893   /* We can get here with --disable-checking.  */
2894   return false;
2895 }
2896
2897 /* The type of ARG when used as an lvalue.  */
2898
2899 tree
2900 lvalue_type (tree arg)
2901 {
2902   tree type = TREE_TYPE (arg);
2903   return type;
2904 }
2905
2906 /* The type of ARG for printing error messages; denote lvalues with
2907    reference types.  */
2908
2909 tree
2910 error_type (tree arg)
2911 {
2912   tree type = TREE_TYPE (arg);
2913
2914   if (TREE_CODE (type) == ARRAY_TYPE)
2915     ;
2916   else if (TREE_CODE (type) == ERROR_MARK)
2917     ;
2918   else if (real_lvalue_p (arg))
2919     type = build_reference_type (lvalue_type (arg));
2920   else if (MAYBE_CLASS_TYPE_P (type))
2921     type = lvalue_type (arg);
2922
2923   return type;
2924 }
2925
2926 /* Does FUNCTION use a variable-length argument list?  */
2927
2928 int
2929 varargs_function_p (const_tree function)
2930 {
2931   return stdarg_p (TREE_TYPE (function));
2932 }
2933
2934 /* Returns 1 if decl is a member of a class.  */
2935
2936 int
2937 member_p (const_tree decl)
2938 {
2939   const_tree const ctx = DECL_CONTEXT (decl);
2940   return (ctx && TYPE_P (ctx));
2941 }
2942
2943 /* Create a placeholder for member access where we don't actually have an
2944    object that the access is against.  */
2945
2946 tree
2947 build_dummy_object (tree type)
2948 {
2949   tree decl = build1 (NOP_EXPR, build_pointer_type (type), void_zero_node);
2950   return cp_build_indirect_ref (decl, RO_NULL, tf_warning_or_error);
2951 }
2952
2953 /* We've gotten a reference to a member of TYPE.  Return *this if appropriate,
2954    or a dummy object otherwise.  If BINFOP is non-0, it is filled with the
2955    binfo path from current_class_type to TYPE, or 0.  */
2956
2957 tree
2958 maybe_dummy_object (tree type, tree* binfop)
2959 {
2960   tree decl, context;
2961   tree binfo;
2962   tree current = current_nonlambda_class_type ();
2963
2964   if (current
2965       && (binfo = lookup_base (current, type, ba_any, NULL,
2966                                tf_warning_or_error)))
2967     context = current;
2968   else
2969     {
2970       /* Reference from a nested class member function.  */
2971       context = type;
2972       binfo = TYPE_BINFO (type);
2973     }
2974
2975   if (binfop)
2976     *binfop = binfo;
2977
2978   if (current_class_ref
2979       /* current_class_ref might not correspond to current_class_type if
2980          we're in tsubst_default_argument or a lambda-declarator; in either
2981          case, we want to use current_class_ref if it matches CONTEXT.  */
2982       && (same_type_ignoring_top_level_qualifiers_p
2983           (TREE_TYPE (current_class_ref), context)))
2984     decl = current_class_ref;
2985   else
2986     decl = build_dummy_object (context);
2987
2988   return decl;
2989 }
2990
2991 /* Returns 1 if OB is a placeholder object, or a pointer to one.  */
2992
2993 int
2994 is_dummy_object (const_tree ob)
2995 {
2996   if (INDIRECT_REF_P (ob))
2997     ob = TREE_OPERAND (ob, 0);
2998   return (TREE_CODE (ob) == NOP_EXPR
2999           && TREE_OPERAND (ob, 0) == void_zero_node);
3000 }
3001
3002 /* Returns 1 iff type T is something we want to treat as a scalar type for
3003    the purpose of deciding whether it is trivial/POD/standard-layout.  */
3004
3005 bool
3006 scalarish_type_p (const_tree t)
3007 {
3008   if (t == error_mark_node)
3009     return 1;
3010
3011   return (SCALAR_TYPE_P (t)
3012           || TREE_CODE (t) == VECTOR_TYPE);
3013 }
3014
3015 /* Returns true iff T requires non-trivial default initialization.  */
3016
3017 bool
3018 type_has_nontrivial_default_init (const_tree t)
3019 {
3020   t = strip_array_types (CONST_CAST_TREE (t));
3021
3022   if (CLASS_TYPE_P (t))
3023     return TYPE_HAS_COMPLEX_DFLT (t);
3024   else
3025     return 0;
3026 }
3027
3028 /* Returns true iff copying an object of type T (including via move
3029    constructor) is non-trivial.  That is, T has no non-trivial copy
3030    constructors and no non-trivial move constructors.  */
3031
3032 bool
3033 type_has_nontrivial_copy_init (const_tree t)
3034 {
3035   t = strip_array_types (CONST_CAST_TREE (t));
3036
3037   if (CLASS_TYPE_P (t))
3038     {
3039       gcc_assert (COMPLETE_TYPE_P (t));
3040       return ((TYPE_HAS_COPY_CTOR (t)
3041                && TYPE_HAS_COMPLEX_COPY_CTOR (t))
3042               || TYPE_HAS_COMPLEX_MOVE_CTOR (t));
3043     }
3044   else
3045     return 0;
3046 }
3047
3048 /* Returns 1 iff type T is a trivially copyable type, as defined in
3049    [basic.types] and [class].  */
3050
3051 bool
3052 trivially_copyable_p (const_tree t)
3053 {
3054   t = strip_array_types (CONST_CAST_TREE (t));
3055
3056   if (CLASS_TYPE_P (t))
3057     return ((!TYPE_HAS_COPY_CTOR (t)
3058              || !TYPE_HAS_COMPLEX_COPY_CTOR (t))
3059             && !TYPE_HAS_COMPLEX_MOVE_CTOR (t)
3060             && (!TYPE_HAS_COPY_ASSIGN (t)
3061                 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (t))
3062             && !TYPE_HAS_COMPLEX_MOVE_ASSIGN (t)
3063             && TYPE_HAS_TRIVIAL_DESTRUCTOR (t));
3064   else
3065     return scalarish_type_p (t);
3066 }
3067
3068 /* Returns 1 iff type T is a trivial type, as defined in [basic.types] and
3069    [class].  */
3070
3071 bool
3072 trivial_type_p (const_tree t)
3073 {
3074   t = strip_array_types (CONST_CAST_TREE (t));
3075
3076   if (CLASS_TYPE_P (t))
3077     return (TYPE_HAS_TRIVIAL_DFLT (t)
3078             && trivially_copyable_p (t));
3079   else
3080     return scalarish_type_p (t);
3081 }
3082
3083 /* Returns 1 iff type T is a POD type, as defined in [basic.types].  */
3084
3085 bool
3086 pod_type_p (const_tree t)
3087 {
3088   /* This CONST_CAST is okay because strip_array_types returns its
3089      argument unmodified and we assign it to a const_tree.  */
3090   t = strip_array_types (CONST_CAST_TREE(t));
3091
3092   if (!CLASS_TYPE_P (t))
3093     return scalarish_type_p (t);
3094   else if (cxx_dialect > cxx98)
3095     /* [class]/10: A POD struct is a class that is both a trivial class and a
3096        standard-layout class, and has no non-static data members of type
3097        non-POD struct, non-POD union (or array of such types).
3098
3099        We don't need to check individual members because if a member is
3100        non-std-layout or non-trivial, the class will be too.  */
3101     return (std_layout_type_p (t) && trivial_type_p (t));
3102   else
3103     /* The C++98 definition of POD is different.  */
3104     return !CLASSTYPE_NON_LAYOUT_POD_P (t);
3105 }
3106
3107 /* Returns true iff T is POD for the purpose of layout, as defined in the
3108    C++ ABI.  */
3109
3110 bool
3111 layout_pod_type_p (const_tree t)
3112 {
3113   t = strip_array_types (CONST_CAST_TREE (t));
3114
3115   if (CLASS_TYPE_P (t))
3116     return !CLASSTYPE_NON_LAYOUT_POD_P (t);
3117   else
3118     return scalarish_type_p (t);
3119 }
3120
3121 /* Returns true iff T is a standard-layout type, as defined in
3122    [basic.types].  */
3123
3124 bool
3125 std_layout_type_p (const_tree t)
3126 {
3127   t = strip_array_types (CONST_CAST_TREE (t));
3128
3129   if (CLASS_TYPE_P (t))
3130     return !CLASSTYPE_NON_STD_LAYOUT (t);
3131   else
3132     return scalarish_type_p (t);
3133 }
3134
3135 /* Nonzero iff type T is a class template implicit specialization.  */
3136
3137 bool
3138 class_tmpl_impl_spec_p (const_tree t)
3139 {
3140   return CLASS_TYPE_P (t) && CLASSTYPE_TEMPLATE_INSTANTIATION (t);
3141 }
3142
3143 /* Returns 1 iff zero initialization of type T means actually storing
3144    zeros in it.  */
3145
3146 int
3147 zero_init_p (const_tree t)
3148 {
3149   /* This CONST_CAST is okay because strip_array_types returns its
3150      argument unmodified and we assign it to a const_tree.  */
3151   t = strip_array_types (CONST_CAST_TREE(t));
3152
3153   if (t == error_mark_node)
3154     return 1;
3155
3156   /* NULL pointers to data members are initialized with -1.  */
3157   if (TYPE_PTRDATAMEM_P (t))
3158     return 0;
3159
3160   /* Classes that contain types that can't be zero-initialized, cannot
3161      be zero-initialized themselves.  */
3162   if (CLASS_TYPE_P (t) && CLASSTYPE_NON_ZERO_INIT_P (t))
3163     return 0;
3164
3165   return 1;
3166 }
3167
3168 /* Table of valid C++ attributes.  */
3169 const struct attribute_spec cxx_attribute_table[] =
3170 {
3171   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
3172        affects_type_identity } */
3173   { "java_interface", 0, 0, false, false, false,
3174     handle_java_interface_attribute, false },
3175   { "com_interface",  0, 0, false, false, false,
3176     handle_com_interface_attribute, false },
3177   { "init_priority",  1, 1, true,  false, false,
3178     handle_init_priority_attribute, false },
3179   { "abi_tag", 1, -1, false, false, false,
3180     handle_abi_tag_attribute, true },
3181   { NULL,             0, 0, false, false, false, NULL, false }
3182 };
3183
3184 /* Handle a "java_interface" attribute; arguments as in
3185    struct attribute_spec.handler.  */
3186 static tree
3187 handle_java_interface_attribute (tree* node,
3188                                  tree name,
3189                                  tree /*args*/,
3190                                  int flags,
3191                                  bool* no_add_attrs)
3192 {
3193   if (DECL_P (*node)
3194       || !CLASS_TYPE_P (*node)
3195       || !TYPE_FOR_JAVA (*node))
3196     {
3197       error ("%qE attribute can only be applied to Java class definitions",
3198              name);
3199       *no_add_attrs = true;
3200       return NULL_TREE;
3201     }
3202   if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
3203     *node = build_variant_type_copy (*node);
3204   TYPE_JAVA_INTERFACE (*node) = 1;
3205
3206   return NULL_TREE;
3207 }
3208
3209 /* Handle a "com_interface" attribute; arguments as in
3210    struct attribute_spec.handler.  */
3211 static tree
3212 handle_com_interface_attribute (tree* node,
3213                                 tree name,
3214                                 tree /*args*/,
3215                                 int /*flags*/,
3216                                 bool* no_add_attrs)
3217 {
3218   static int warned;
3219
3220   *no_add_attrs = true;
3221
3222   if (DECL_P (*node)
3223       || !CLASS_TYPE_P (*node)
3224       || *node != TYPE_MAIN_VARIANT (*node))
3225     {
3226       warning (OPT_Wattributes, "%qE attribute can only be applied "
3227                "to class definitions", name);
3228       return NULL_TREE;
3229     }
3230
3231   if (!warned++)
3232     warning (0, "%qE is obsolete; g++ vtables are now COM-compatible by default",
3233              name);
3234
3235   return NULL_TREE;
3236 }
3237
3238 /* Handle an "init_priority" attribute; arguments as in
3239    struct attribute_spec.handler.  */
3240 static tree
3241 handle_init_priority_attribute (tree* node,
3242                                 tree name,
3243                                 tree args,
3244                                 int /*flags*/,
3245                                 bool* no_add_attrs)
3246 {
3247   tree initp_expr = TREE_VALUE (args);
3248   tree decl = *node;
3249   tree type = TREE_TYPE (decl);
3250   int pri;
3251
3252   STRIP_NOPS (initp_expr);
3253   initp_expr = default_conversion (initp_expr);
3254
3255   if (!initp_expr || TREE_CODE (initp_expr) != INTEGER_CST)
3256     {
3257       error ("requested init_priority is not an integer constant");
3258       *no_add_attrs = true;
3259       return NULL_TREE;
3260     }
3261
3262   pri = TREE_INT_CST_LOW (initp_expr);
3263
3264   type = strip_array_types (type);
3265
3266   if (decl == NULL_TREE
3267       || !VAR_P (decl)
3268       || !TREE_STATIC (decl)
3269       || DECL_EXTERNAL (decl)
3270       || (TREE_CODE (type) != RECORD_TYPE
3271           && TREE_CODE (type) != UNION_TYPE)
3272       /* Static objects in functions are initialized the
3273          first time control passes through that
3274          function. This is not precise enough to pin down an
3275          init_priority value, so don't allow it.  */
3276       || current_function_decl)
3277     {
3278       error ("can only use %qE attribute on file-scope definitions "
3279              "of objects of class type", name);
3280       *no_add_attrs = true;
3281       return NULL_TREE;
3282     }
3283
3284   if (pri > MAX_INIT_PRIORITY || pri <= 0)
3285     {
3286       error ("requested init_priority is out of range");
3287       *no_add_attrs = true;
3288       return NULL_TREE;
3289     }
3290
3291   /* Check for init_priorities that are reserved for
3292      language and runtime support implementations.*/
3293   if (pri <= MAX_RESERVED_INIT_PRIORITY)
3294     {
3295       warning
3296         (0, "requested init_priority is reserved for internal use");
3297     }
3298
3299   if (SUPPORTS_INIT_PRIORITY)
3300     {
3301       SET_DECL_INIT_PRIORITY (decl, pri);
3302       DECL_HAS_INIT_PRIORITY_P (decl) = 1;
3303       return NULL_TREE;
3304     }
3305   else
3306     {
3307       error ("%qE attribute is not supported on this platform", name);
3308       *no_add_attrs = true;
3309       return NULL_TREE;
3310     }
3311 }
3312
3313 /* DECL is being redeclared; the old declaration had the abi tags in OLD,
3314    and the new one has the tags in NEW_.  Give an error if there are tags
3315    in NEW_ that weren't in OLD.  */
3316
3317 bool
3318 check_abi_tag_redeclaration (const_tree decl, const_tree old, const_tree new_)
3319 {
3320   if (old && TREE_CODE (TREE_VALUE (old)) == TREE_LIST)
3321     old = TREE_VALUE (old);
3322   if (new_ && TREE_CODE (TREE_VALUE (new_)) == TREE_LIST)
3323     new_ = TREE_VALUE (new_);
3324   bool err = false;
3325   for (const_tree t = new_; t; t = TREE_CHAIN (t))
3326     {
3327       tree str = TREE_VALUE (t);
3328       for (const_tree in = old; in; in = TREE_CHAIN (in))
3329         {
3330           tree ostr = TREE_VALUE (in);
3331           if (cp_tree_equal (str, ostr))
3332             goto found;
3333         }
3334       error ("redeclaration of %qD adds abi tag %E", decl, str);
3335       err = true;
3336     found:;
3337     }
3338   if (err)
3339     {
3340       inform (DECL_SOURCE_LOCATION (decl), "previous declaration here");
3341       return false;
3342     }
3343   return true;
3344 }
3345
3346 /* Handle an "abi_tag" attribute; arguments as in
3347    struct attribute_spec.handler.  */
3348
3349 static tree
3350 handle_abi_tag_attribute (tree* node, tree name, tree args,
3351                           int flags, bool* no_add_attrs)
3352 {
3353   if (TYPE_P (*node))
3354     {
3355       if (!OVERLOAD_TYPE_P (*node))
3356         {
3357           error ("%qE attribute applied to non-class, non-enum type %qT",
3358                  name, *node);
3359           goto fail;
3360         }
3361       else if (!(flags & (int)ATTR_FLAG_TYPE_IN_PLACE))
3362         {
3363           error ("%qE attribute applied to %qT after its definition",
3364                  name, *node);
3365           goto fail;
3366         }
3367
3368       tree attributes = TYPE_ATTRIBUTES (*node);
3369       tree decl = TYPE_NAME (*node);
3370
3371       /* Make sure all declarations have the same abi tags.  */
3372       if (DECL_SOURCE_LOCATION (decl) != input_location)
3373         {
3374           if (!check_abi_tag_redeclaration (decl,
3375                                             lookup_attribute ("abi_tag",
3376                                                               attributes),
3377                                             args))
3378             goto fail;
3379         }
3380     }
3381   else
3382     {
3383       if (TREE_CODE (*node) != FUNCTION_DECL)
3384         {
3385           error ("%qE attribute applied to non-function %qD", name, *node);
3386           goto fail;
3387         }
3388       else if (DECL_LANGUAGE (*node) == lang_c)
3389         {
3390           error ("%qE attribute applied to extern \"C\" function %qD",
3391                  name, *node);
3392           goto fail;
3393         }
3394     }
3395
3396   return NULL_TREE;
3397
3398  fail:
3399   *no_add_attrs = true;
3400   return NULL_TREE;
3401 }
3402
3403 /* Return a new PTRMEM_CST of the indicated TYPE.  The MEMBER is the
3404    thing pointed to by the constant.  */
3405
3406 tree
3407 make_ptrmem_cst (tree type, tree member)
3408 {
3409   tree ptrmem_cst = make_node (PTRMEM_CST);
3410   TREE_TYPE (ptrmem_cst) = type;
3411   PTRMEM_CST_MEMBER (ptrmem_cst) = member;
3412   return ptrmem_cst;
3413 }
3414
3415 /* Build a variant of TYPE that has the indicated ATTRIBUTES.  May
3416    return an existing type if an appropriate type already exists.  */
3417
3418 tree
3419 cp_build_type_attribute_variant (tree type, tree attributes)
3420 {
3421   tree new_type;
3422
3423   new_type = build_type_attribute_variant (type, attributes);
3424   if (TREE_CODE (new_type) == FUNCTION_TYPE
3425       || TREE_CODE (new_type) == METHOD_TYPE)
3426     {
3427       new_type = build_exception_variant (new_type,
3428                                           TYPE_RAISES_EXCEPTIONS (type));
3429       new_type = build_ref_qualified_type (new_type,
3430                                            type_memfn_rqual (type));
3431     }
3432
3433   /* Making a new main variant of a class type is broken.  */
3434   gcc_assert (!CLASS_TYPE_P (type) || new_type == type);
3435
3436   return new_type;
3437 }
3438
3439 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
3440    Called only after doing all language independent checks.  Only
3441    to check TYPE_RAISES_EXCEPTIONS for FUNCTION_TYPE, the rest is already
3442    compared in type_hash_eq.  */
3443
3444 bool
3445 cxx_type_hash_eq (const_tree typea, const_tree typeb)
3446 {
3447   gcc_assert (TREE_CODE (typea) == FUNCTION_TYPE
3448               || TREE_CODE (typea) == METHOD_TYPE);
3449
3450   return comp_except_specs (TYPE_RAISES_EXCEPTIONS (typea),
3451                             TYPE_RAISES_EXCEPTIONS (typeb), ce_exact);
3452 }
3453
3454 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
3455    traversal.  Called from walk_tree.  */
3456
3457 tree
3458 cp_walk_subtrees (tree *tp, int *walk_subtrees_p, walk_tree_fn func,
3459                   void *data, struct pointer_set_t *pset)
3460 {
3461   enum tree_code code = TREE_CODE (*tp);
3462   tree result;
3463
3464 #define WALK_SUBTREE(NODE)                              \
3465   do                                                    \
3466     {                                                   \
3467       result = cp_walk_tree (&(NODE), func, data, pset);        \
3468       if (result) goto out;                             \
3469     }                                                   \
3470   while (0)
3471
3472   /* Not one of the easy cases.  We must explicitly go through the
3473      children.  */
3474   result = NULL_TREE;
3475   switch (code)
3476     {
3477     case DEFAULT_ARG:
3478     case TEMPLATE_TEMPLATE_PARM:
3479     case BOUND_TEMPLATE_TEMPLATE_PARM:
3480     case UNBOUND_CLASS_TEMPLATE:
3481     case TEMPLATE_PARM_INDEX:
3482     case TEMPLATE_TYPE_PARM:
3483     case TYPENAME_TYPE:
3484     case TYPEOF_TYPE:
3485     case UNDERLYING_TYPE:
3486       /* None of these have subtrees other than those already walked
3487          above.  */
3488       *walk_subtrees_p = 0;
3489       break;
3490
3491     case BASELINK:
3492       WALK_SUBTREE (BASELINK_FUNCTIONS (*tp));
3493       *walk_subtrees_p = 0;
3494       break;
3495
3496     case PTRMEM_CST:
3497       WALK_SUBTREE (TREE_TYPE (*tp));
3498       *walk_subtrees_p = 0;
3499       break;
3500
3501     case TREE_LIST:
3502       WALK_SUBTREE (TREE_PURPOSE (*tp));
3503       break;
3504
3505     case OVERLOAD:
3506       WALK_SUBTREE (OVL_FUNCTION (*tp));
3507       WALK_SUBTREE (OVL_CHAIN (*tp));
3508       *walk_subtrees_p = 0;
3509       break;
3510
3511     case USING_DECL:
3512       WALK_SUBTREE (DECL_NAME (*tp));
3513       WALK_SUBTREE (USING_DECL_SCOPE (*tp));
3514       WALK_SUBTREE (USING_DECL_DECLS (*tp));
3515       *walk_subtrees_p = 0;
3516       break;
3517
3518     case RECORD_TYPE:
3519       if (TYPE_PTRMEMFUNC_P (*tp))
3520         WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE (*tp));
3521       break;
3522
3523     case TYPE_ARGUMENT_PACK:
3524     case NONTYPE_ARGUMENT_PACK:
3525       {
3526         tree args = ARGUMENT_PACK_ARGS (*tp);
3527         int i, len = TREE_VEC_LENGTH (args);
3528         for (i = 0; i < len; i++)
3529           WALK_SUBTREE (TREE_VEC_ELT (args, i));
3530       }
3531       break;
3532
3533     case TYPE_PACK_EXPANSION:
3534       WALK_SUBTREE (TREE_TYPE (*tp));
3535       WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp));
3536       *walk_subtrees_p = 0;
3537       break;
3538
3539     case EXPR_PACK_EXPANSION:
3540       WALK_SUBTREE (TREE_OPERAND (*tp, 0));
3541       WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp));
3542       *walk_subtrees_p = 0;
3543       break;
3544
3545     case CAST_EXPR:
3546     case REINTERPRET_CAST_EXPR:
3547     case STATIC_CAST_EXPR:
3548     case CONST_CAST_EXPR:
3549     case DYNAMIC_CAST_EXPR:
3550     case IMPLICIT_CONV_EXPR:
3551       if (TREE_TYPE (*tp))
3552         WALK_SUBTREE (TREE_TYPE (*tp));
3553
3554       {
3555         int i;
3556         for (i = 0; i < TREE_CODE_LENGTH (TREE_CODE (*tp)); ++i)
3557           WALK_SUBTREE (TREE_OPERAND (*tp, i));
3558       }
3559       *walk_subtrees_p = 0;
3560       break;
3561
3562     case TRAIT_EXPR:
3563       WALK_SUBTREE (TRAIT_EXPR_TYPE1 (*tp));
3564       WALK_SUBTREE (TRAIT_EXPR_TYPE2 (*tp));
3565       *walk_subtrees_p = 0;
3566       break;
3567
3568     case DECLTYPE_TYPE:
3569       WALK_SUBTREE (DECLTYPE_TYPE_EXPR (*tp));
3570       *walk_subtrees_p = 0;
3571       break;
3572
3573
3574     default:
3575       return NULL_TREE;
3576     }
3577
3578   /* We didn't find what we were looking for.  */
3579  out:
3580   return result;
3581
3582 #undef WALK_SUBTREE
3583 }
3584
3585 /* Like save_expr, but for C++.  */
3586
3587 tree
3588 cp_save_expr (tree expr)
3589 {
3590   /* There is no reason to create a SAVE_EXPR within a template; if
3591      needed, we can create the SAVE_EXPR when instantiating the
3592      template.  Furthermore, the middle-end cannot handle C++-specific
3593      tree codes.  */
3594   if (processing_template_decl)
3595     return expr;
3596   return save_expr (expr);
3597 }
3598
3599 /* Initialize tree.c.  */
3600
3601 void
3602 init_tree (void)
3603 {
3604   list_hash_table = htab_create_ggc (31, list_hash, list_hash_eq, NULL);
3605 }
3606
3607 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
3608    is.  Note that sfk_none is zero, so this function can be used as a
3609    predicate to test whether or not DECL is a special function.  */
3610
3611 special_function_kind
3612 special_function_p (const_tree decl)
3613 {
3614   /* Rather than doing all this stuff with magic names, we should
3615      probably have a field of type `special_function_kind' in
3616      DECL_LANG_SPECIFIC.  */
3617   if (DECL_INHERITED_CTOR_BASE (decl))
3618     return sfk_inheriting_constructor;
3619   if (DECL_COPY_CONSTRUCTOR_P (decl))
3620     return sfk_copy_constructor;
3621   if (DECL_MOVE_CONSTRUCTOR_P (decl))
3622     return sfk_move_constructor;
3623   if (DECL_CONSTRUCTOR_P (decl))
3624     return sfk_constructor;
3625   if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
3626     {
3627       if (copy_fn_p (decl))
3628         return sfk_copy_assignment;
3629       if (move_fn_p (decl))
3630         return sfk_move_assignment;
3631     }
3632   if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl))
3633     return sfk_destructor;
3634   if (DECL_COMPLETE_DESTRUCTOR_P (decl))
3635     return sfk_complete_destructor;
3636   if (DECL_BASE_DESTRUCTOR_P (decl))
3637     return sfk_base_destructor;
3638   if (DECL_DELETING_DESTRUCTOR_P (decl))
3639     return sfk_deleting_destructor;
3640   if (DECL_CONV_FN_P (decl))
3641     return sfk_conversion;
3642
3643   return sfk_none;
3644 }
3645
3646 /* Returns nonzero if TYPE is a character type, including wchar_t.  */
3647
3648 int
3649 char_type_p (tree type)
3650 {
3651   return (same_type_p (type, char_type_node)
3652           || same_type_p (type, unsigned_char_type_node)
3653           || same_type_p (type, signed_char_type_node)
3654           || same_type_p (type, char16_type_node)
3655           || same_type_p (type, char32_type_node)
3656           || same_type_p (type, wchar_type_node));
3657 }
3658
3659 /* Returns the kind of linkage associated with the indicated DECL.  Th
3660    value returned is as specified by the language standard; it is
3661    independent of implementation details regarding template
3662    instantiation, etc.  For example, it is possible that a declaration
3663    to which this function assigns external linkage would not show up
3664    as a global symbol when you run `nm' on the resulting object file.  */
3665
3666 linkage_kind
3667 decl_linkage (tree decl)
3668 {
3669   /* This function doesn't attempt to calculate the linkage from first
3670      principles as given in [basic.link].  Instead, it makes use of
3671      the fact that we have already set TREE_PUBLIC appropriately, and
3672      then handles a few special cases.  Ideally, we would calculate
3673      linkage first, and then transform that into a concrete
3674      implementation.  */
3675
3676   /* Things that don't have names have no linkage.  */
3677   if (!DECL_NAME (decl))
3678     return lk_none;
3679
3680   /* Fields have no linkage.  */
3681   if (TREE_CODE (decl) == FIELD_DECL)
3682     return lk_none;
3683
3684   /* Things that are TREE_PUBLIC have external linkage.  */
3685   if (TREE_PUBLIC (decl))
3686     return lk_external;
3687
3688   if (TREE_CODE (decl) == NAMESPACE_DECL)
3689     return lk_external;
3690
3691   /* Linkage of a CONST_DECL depends on the linkage of the enumeration
3692      type.  */
3693   if (TREE_CODE (decl) == CONST_DECL)
3694     return decl_linkage (TYPE_NAME (DECL_CONTEXT (decl)));
3695
3696   /* Some things that are not TREE_PUBLIC have external linkage, too.
3697      For example, on targets that don't have weak symbols, we make all
3698      template instantiations have internal linkage (in the object
3699      file), but the symbols should still be treated as having external
3700      linkage from the point of view of the language.  */
3701   if (VAR_OR_FUNCTION_DECL_P (decl)
3702       && DECL_COMDAT (decl))
3703     return lk_external;
3704
3705   /* Things in local scope do not have linkage, if they don't have
3706      TREE_PUBLIC set.  */
3707   if (decl_function_context (decl))
3708     return lk_none;
3709
3710   /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
3711      are considered to have external linkage for language purposes.  DECLs
3712      really meant to have internal linkage have DECL_THIS_STATIC set.  */
3713   if (TREE_CODE (decl) == TYPE_DECL)
3714     return lk_external;
3715   if (VAR_OR_FUNCTION_DECL_P (decl))
3716     {
3717       if (!DECL_THIS_STATIC (decl))
3718         return lk_external;
3719
3720       /* Static data members and static member functions from classes
3721          in anonymous namespace also don't have TREE_PUBLIC set.  */
3722       if (DECL_CLASS_CONTEXT (decl))
3723         return lk_external;
3724     }
3725
3726   /* Everything else has internal linkage.  */
3727   return lk_internal;
3728 }
3729
3730 /* Returns the storage duration of the object or reference associated with
3731    the indicated DECL, which should be a VAR_DECL or PARM_DECL.  */
3732
3733 duration_kind
3734 decl_storage_duration (tree decl)
3735 {
3736   if (TREE_CODE (decl) == PARM_DECL)
3737     return dk_auto;
3738   if (TREE_CODE (decl) == FUNCTION_DECL)
3739     return dk_static;
3740   gcc_assert (VAR_P (decl));
3741   if (!TREE_STATIC (decl)
3742       && !DECL_EXTERNAL (decl))
3743     return dk_auto;
3744   if (DECL_THREAD_LOCAL_P (decl))
3745     return dk_thread;
3746   return dk_static;
3747 }
3748 \f
3749 /* EXP is an expression that we want to pre-evaluate.  Returns (in
3750    *INITP) an expression that will perform the pre-evaluation.  The
3751    value returned by this function is a side-effect free expression
3752    equivalent to the pre-evaluated expression.  Callers must ensure
3753    that *INITP is evaluated before EXP.  */
3754
3755 tree
3756 stabilize_expr (tree exp, tree* initp)
3757 {
3758   tree init_expr;
3759
3760   if (!TREE_SIDE_EFFECTS (exp))
3761     init_expr = NULL_TREE;
3762   else if (VOID_TYPE_P (TREE_TYPE (exp)))
3763     {
3764       init_expr = exp;
3765       exp = void_zero_node;
3766     }
3767   /* There are no expressions with REFERENCE_TYPE, but there can be call
3768      arguments with such a type; just treat it as a pointer.  */
3769   else if (TREE_CODE (TREE_TYPE (exp)) == REFERENCE_TYPE
3770            || SCALAR_TYPE_P (TREE_TYPE (exp))
3771            || !lvalue_or_rvalue_with_address_p (exp))
3772     {
3773       init_expr = get_target_expr (exp);
3774       exp = TARGET_EXPR_SLOT (init_expr);
3775     }
3776   else
3777     {
3778       bool xval = !real_lvalue_p (exp);
3779       exp = cp_build_addr_expr (exp, tf_warning_or_error);
3780       init_expr = get_target_expr (exp);
3781       exp = TARGET_EXPR_SLOT (init_expr);
3782       exp = cp_build_indirect_ref (exp, RO_NULL, tf_warning_or_error);
3783       if (xval)
3784         exp = move (exp);
3785     }
3786   *initp = init_expr;
3787
3788   gcc_assert (!TREE_SIDE_EFFECTS (exp));
3789   return exp;
3790 }
3791
3792 /* Add NEW_EXPR, an expression whose value we don't care about, after the
3793    similar expression ORIG.  */
3794
3795 tree
3796 add_stmt_to_compound (tree orig, tree new_expr)
3797 {
3798   if (!new_expr || !TREE_SIDE_EFFECTS (new_expr))
3799     return orig;
3800   if (!orig || !TREE_SIDE_EFFECTS (orig))
3801     return new_expr;
3802   return build2 (COMPOUND_EXPR, void_type_node, orig, new_expr);
3803 }
3804
3805 /* Like stabilize_expr, but for a call whose arguments we want to
3806    pre-evaluate.  CALL is modified in place to use the pre-evaluated
3807    arguments, while, upon return, *INITP contains an expression to
3808    compute the arguments.  */
3809
3810 void
3811 stabilize_call (tree call, tree *initp)
3812 {
3813   tree inits = NULL_TREE;
3814   int i;
3815   int nargs = call_expr_nargs (call);
3816
3817   if (call == error_mark_node || processing_template_decl)
3818     {
3819       *initp = NULL_TREE;
3820       return;
3821     }
3822
3823   gcc_assert (TREE_CODE (call) == CALL_EXPR);
3824
3825   for (i = 0; i < nargs; i++)
3826     {
3827       tree init;
3828       CALL_EXPR_ARG (call, i) =
3829         stabilize_expr (CALL_EXPR_ARG (call, i), &init);
3830       inits = add_stmt_to_compound (inits, init);
3831     }
3832
3833   *initp = inits;
3834 }
3835
3836 /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
3837    to pre-evaluate.  CALL is modified in place to use the pre-evaluated
3838    arguments, while, upon return, *INITP contains an expression to
3839    compute the arguments.  */
3840
3841 static void
3842 stabilize_aggr_init (tree call, tree *initp)
3843 {
3844   tree inits = NULL_TREE;
3845   int i;
3846   int nargs = aggr_init_expr_nargs (call);
3847
3848   if (call == error_mark_node)
3849     return;
3850
3851   gcc_assert (TREE_CODE (call) == AGGR_INIT_EXPR);
3852
3853   for (i = 0; i < nargs; i++)
3854     {
3855       tree init;
3856       AGGR_INIT_EXPR_ARG (call, i) =
3857         stabilize_expr (AGGR_INIT_EXPR_ARG (call, i), &init);
3858       inits = add_stmt_to_compound (inits, init);
3859     }
3860
3861   *initp = inits;
3862 }
3863
3864 /* Like stabilize_expr, but for an initialization.
3865
3866    If the initialization is for an object of class type, this function
3867    takes care not to introduce additional temporaries.
3868
3869    Returns TRUE iff the expression was successfully pre-evaluated,
3870    i.e., if INIT is now side-effect free, except for, possibly, a
3871    single call to a constructor.  */
3872
3873 bool
3874 stabilize_init (tree init, tree *initp)
3875 {
3876   tree t = init;
3877
3878   *initp = NULL_TREE;
3879
3880   if (t == error_mark_node || processing_template_decl)
3881     return true;
3882
3883   if (TREE_CODE (t) == INIT_EXPR)
3884     t = TREE_OPERAND (t, 1);
3885   if (TREE_CODE (t) == TARGET_EXPR)
3886     t = TARGET_EXPR_INITIAL (t);
3887
3888   /* If the RHS can be stabilized without breaking copy elision, stabilize
3889      it.  We specifically don't stabilize class prvalues here because that
3890      would mean an extra copy, but they might be stabilized below.  */
3891   if (TREE_CODE (init) == INIT_EXPR
3892       && TREE_CODE (t) != CONSTRUCTOR
3893       && TREE_CODE (t) != AGGR_INIT_EXPR
3894       && (SCALAR_TYPE_P (TREE_TYPE (t))
3895           || lvalue_or_rvalue_with_address_p (t)))
3896     {
3897       TREE_OPERAND (init, 1) = stabilize_expr (t, initp);
3898       return true;
3899     }
3900
3901   if (TREE_CODE (t) == COMPOUND_EXPR
3902       && TREE_CODE (init) == INIT_EXPR)
3903     {
3904       tree last = expr_last (t);
3905       /* Handle stabilizing the EMPTY_CLASS_EXPR pattern.  */
3906       if (!TREE_SIDE_EFFECTS (last))
3907         {
3908           *initp = t;
3909           TREE_OPERAND (init, 1) = last;
3910           return true;
3911         }
3912     }
3913
3914   if (TREE_CODE (t) == CONSTRUCTOR)
3915     {
3916       /* Aggregate initialization: stabilize each of the field
3917          initializers.  */
3918       unsigned i;
3919       constructor_elt *ce;
3920       bool good = true;
3921       vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (t);
3922       for (i = 0; vec_safe_iterate (v, i, &ce); ++i)
3923         {
3924           tree type = TREE_TYPE (ce->value);
3925           tree subinit;
3926           if (TREE_CODE (type) == REFERENCE_TYPE
3927               || SCALAR_TYPE_P (type))
3928             ce->value = stabilize_expr (ce->value, &subinit);
3929           else if (!stabilize_init (ce->value, &subinit))
3930             good = false;
3931           *initp = add_stmt_to_compound (*initp, subinit);
3932         }
3933       return good;
3934     }
3935
3936   if (TREE_CODE (t) == CALL_EXPR)
3937     {
3938       stabilize_call (t, initp);
3939       return true;
3940     }
3941
3942   if (TREE_CODE (t) == AGGR_INIT_EXPR)
3943     {
3944       stabilize_aggr_init (t, initp);
3945       return true;
3946     }
3947
3948   /* The initialization is being performed via a bitwise copy -- and
3949      the item copied may have side effects.  */
3950   return !TREE_SIDE_EFFECTS (init);
3951 }
3952
3953 /* Like "fold", but should be used whenever we might be processing the
3954    body of a template.  */
3955
3956 tree
3957 fold_if_not_in_template (tree expr)
3958 {
3959   /* In the body of a template, there is never any need to call
3960      "fold".  We will call fold later when actually instantiating the
3961      template.  Integral constant expressions in templates will be
3962      evaluated via fold_non_dependent_expr, as necessary.  */
3963   if (processing_template_decl)
3964     return expr;
3965
3966   /* Fold C++ front-end specific tree codes.  */
3967   if (TREE_CODE (expr) == UNARY_PLUS_EXPR)
3968     return fold_convert (TREE_TYPE (expr), TREE_OPERAND (expr, 0));
3969
3970   return fold (expr);
3971 }
3972
3973 /* Returns true if a cast to TYPE may appear in an integral constant
3974    expression.  */
3975
3976 bool
3977 cast_valid_in_integral_constant_expression_p (tree type)
3978 {
3979   return (INTEGRAL_OR_ENUMERATION_TYPE_P (type)
3980           || cxx_dialect >= cxx11
3981           || dependent_type_p (type)
3982           || type == error_mark_node);
3983 }
3984
3985 /* Return true if we need to fix linkage information of DECL.  */
3986
3987 static bool
3988 cp_fix_function_decl_p (tree decl)
3989 {
3990   /* Skip if DECL is not externally visible.  */
3991   if (!TREE_PUBLIC (decl))
3992     return false;
3993
3994   /* We need to fix DECL if it a appears to be exported but with no
3995      function body.  Thunks do not have CFGs and we may need to
3996      handle them specially later.   */
3997   if (!gimple_has_body_p (decl)
3998       && !DECL_THUNK_P (decl)
3999       && !DECL_EXTERNAL (decl))
4000     {
4001       struct cgraph_node *node = cgraph_get_node (decl);
4002
4003       /* Don't fix same_body aliases.  Although they don't have their own
4004          CFG, they share it with what they alias to.  */
4005       if (!node || !node->alias
4006           || !vec_safe_length (node->ref_list.references))
4007         return true;
4008     }
4009
4010   return false;
4011 }
4012
4013 /* Clean the C++ specific parts of the tree T. */
4014
4015 void
4016 cp_free_lang_data (tree t)
4017 {
4018   if (TREE_CODE (t) == METHOD_TYPE
4019       || TREE_CODE (t) == FUNCTION_TYPE)
4020     {
4021       /* Default args are not interesting anymore.  */
4022       tree argtypes = TYPE_ARG_TYPES (t);
4023       while (argtypes)
4024         {
4025           TREE_PURPOSE (argtypes) = 0;
4026           argtypes = TREE_CHAIN (argtypes);
4027         }
4028     }
4029   else if (TREE_CODE (t) == FUNCTION_DECL
4030            && cp_fix_function_decl_p (t))
4031     {
4032       /* If T is used in this translation unit at all,  the definition
4033          must exist somewhere else since we have decided to not emit it
4034          in this TU.  So make it an external reference.  */
4035       DECL_EXTERNAL (t) = 1;
4036       TREE_STATIC (t) = 0;
4037     }
4038   if (TREE_CODE (t) == NAMESPACE_DECL)
4039     {
4040       /* The list of users of a namespace isn't useful for the middle-end
4041          or debug generators.  */
4042       DECL_NAMESPACE_USERS (t) = NULL_TREE;
4043       /* Neither do we need the leftover chaining of namespaces
4044          from the binding level.  */
4045       DECL_CHAIN (t) = NULL_TREE;
4046     }
4047 }
4048
4049 /* Stub for c-common.  Please keep in sync with c-decl.c.
4050    FIXME: If address space support is target specific, then this
4051    should be a C target hook.  But currently this is not possible,
4052    because this function is called via REGISTER_TARGET_PRAGMAS.  */
4053 void
4054 c_register_addr_space (const char * /*word*/, addr_space_t /*as*/)
4055 {
4056 }
4057
4058 /* Return the number of operands in T that we care about for things like
4059    mangling.  */
4060
4061 int
4062 cp_tree_operand_length (const_tree t)
4063 {
4064   enum tree_code code = TREE_CODE (t);
4065
4066   switch (code)
4067     {
4068     case PREINCREMENT_EXPR:
4069     case PREDECREMENT_EXPR:
4070     case POSTINCREMENT_EXPR:
4071     case POSTDECREMENT_EXPR:
4072       return 1;
4073
4074     case ARRAY_REF:
4075       return 2;
4076
4077     case EXPR_PACK_EXPANSION:
4078       return 1;
4079
4080     default:
4081       return TREE_OPERAND_LENGTH (t);
4082     }
4083 }
4084
4085 /* Implement -Wzero_as_null_pointer_constant.  Return true if the
4086    conditions for the warning hold, false otherwise.  */
4087 bool
4088 maybe_warn_zero_as_null_pointer_constant (tree expr, location_t loc)
4089 {
4090   if (c_inhibit_evaluation_warnings == 0
4091       && !NULLPTR_TYPE_P (TREE_TYPE (expr)))
4092     {
4093       warning_at (loc, OPT_Wzero_as_null_pointer_constant,
4094                   "zero as null pointer constant");
4095       return true;
4096     }
4097   return false;
4098 }
4099 \f
4100 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
4101 /* Complain that some language-specific thing hanging off a tree
4102    node has been accessed improperly.  */
4103
4104 void
4105 lang_check_failed (const char* file, int line, const char* function)
4106 {
4107   internal_error ("lang_* check: failed in %s, at %s:%d",
4108                   function, trim_filename (file), line);
4109 }
4110 #endif /* ENABLE_TREE_CHECKING */
4111
4112 #include "gt-cp-tree.h"