gcc/cp/tree.c

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