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