gcc/cp/tree.c

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