gcc/cp/tree.c

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