gcc/cp/tree.c

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