gcc/cp/tree.c

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