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