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_class_statistics ();
2835   print_template_statistics ();
2836   if (GATHER_STATISTICS)
2837     fprintf (stderr, "maximum template instantiation depth reached: %d\n",
2838              depth_reached);
2839 }
2840
2841 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2842    (which is an ARRAY_TYPE).  This counts only elements of the top
2843    array.  */
2844
2845 tree
2846 array_type_nelts_top (tree type)
2847 {
2848   return fold_build2_loc (input_location,
2849                       PLUS_EXPR, sizetype,
2850                       array_type_nelts (type),
2851                       size_one_node);
2852 }
2853
2854 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2855    (which is an ARRAY_TYPE).  This one is a recursive count of all
2856    ARRAY_TYPEs that are clumped together.  */
2857
2858 tree
2859 array_type_nelts_total (tree type)
2860 {
2861   tree sz = array_type_nelts_top (type);
2862   type = TREE_TYPE (type);
2863   while (TREE_CODE (type) == ARRAY_TYPE)
2864     {
2865       tree n = array_type_nelts_top (type);
2866       sz = fold_build2_loc (input_location,
2867                         MULT_EXPR, sizetype, sz, n);
2868       type = TREE_TYPE (type);
2869     }
2870   return sz;
2871 }
2872
2873 /* Called from break_out_target_exprs via mapcar.  */
2874
2875 static tree
2876 bot_manip (tree* tp, int* walk_subtrees, void* data)
2877 {
2878   splay_tree target_remap = ((splay_tree) data);
2879   tree t = *tp;
2880
2881   if (!TYPE_P (t) && TREE_CONSTANT (t) && !TREE_SIDE_EFFECTS (t))
2882     {
2883       /* There can't be any TARGET_EXPRs or their slot variables below this
2884          point.  But we must make a copy, in case subsequent processing
2885          alters any part of it.  For example, during gimplification a cast
2886          of the form (T) &X::f (where "f" is a member function) will lead
2887          to replacing the PTRMEM_CST for &X::f with a VAR_DECL.  */
2888       *walk_subtrees = 0;
2889       *tp = unshare_expr (t);
2890       return NULL_TREE;
2891     }
2892   if (TREE_CODE (t) == TARGET_EXPR)
2893     {
2894       tree u;
2895
2896       if (TREE_CODE (TREE_OPERAND (t, 1)) == AGGR_INIT_EXPR)
2897         {
2898           u = build_cplus_new (TREE_TYPE (t), TREE_OPERAND (t, 1),
2899                                tf_warning_or_error);
2900           if (AGGR_INIT_ZERO_FIRST (TREE_OPERAND (t, 1)))
2901             AGGR_INIT_ZERO_FIRST (TREE_OPERAND (u, 1)) = true;
2902         }
2903       else
2904         u = build_target_expr_with_type (TREE_OPERAND (t, 1), TREE_TYPE (t),
2905                                          tf_warning_or_error);
2906
2907       TARGET_EXPR_IMPLICIT_P (u) = TARGET_EXPR_IMPLICIT_P (t);
2908       TARGET_EXPR_LIST_INIT_P (u) = TARGET_EXPR_LIST_INIT_P (t);
2909       TARGET_EXPR_DIRECT_INIT_P (u) = TARGET_EXPR_DIRECT_INIT_P (t);
2910
2911       /* Map the old variable to the new one.  */
2912       splay_tree_insert (target_remap,
2913                          (splay_tree_key) TREE_OPERAND (t, 0),
2914                          (splay_tree_value) TREE_OPERAND (u, 0));
2915
2916       TREE_OPERAND (u, 1) = break_out_target_exprs (TREE_OPERAND (u, 1));
2917
2918       /* Replace the old expression with the new version.  */
2919       *tp = u;
2920       /* We don't have to go below this point; the recursive call to
2921          break_out_target_exprs will have handled anything below this
2922          point.  */
2923       *walk_subtrees = 0;
2924       return NULL_TREE;
2925     }
2926   if (TREE_CODE (*tp) == SAVE_EXPR)
2927     {
2928       t = *tp;
2929       splay_tree_node n = splay_tree_lookup (target_remap,
2930                                              (splay_tree_key) t);
2931       if (n)
2932         {
2933           *tp = (tree)n->value;
2934           *walk_subtrees = 0;
2935         }
2936       else
2937         {
2938           copy_tree_r (tp, walk_subtrees, NULL);
2939           splay_tree_insert (target_remap,
2940                              (splay_tree_key)t,
2941                              (splay_tree_value)*tp);
2942           /* Make sure we don't remap an already-remapped SAVE_EXPR.  */
2943           splay_tree_insert (target_remap,
2944                              (splay_tree_key)*tp,
2945                              (splay_tree_value)*tp);
2946         }
2947       return NULL_TREE;
2948     }
2949
2950   /* Make a copy of this node.  */
2951   t = copy_tree_r (tp, walk_subtrees, NULL);
2952   if (TREE_CODE (*tp) == CALL_EXPR)
2953     {
2954       set_flags_from_callee (*tp);
2955
2956       /* builtin_LINE and builtin_FILE get the location where the default
2957          argument is expanded, not where the call was written.  */
2958       tree callee = get_callee_fndecl (*tp);
2959       if (callee && DECL_BUILT_IN_CLASS (callee) == BUILT_IN_NORMAL)
2960         switch (DECL_FUNCTION_CODE (callee))
2961           {
2962           case BUILT_IN_FILE:
2963           case BUILT_IN_LINE:
2964             SET_EXPR_LOCATION (*tp, input_location);
2965           default:
2966             break;
2967           }
2968     }
2969   return t;
2970 }
2971
2972 /* Replace all remapped VAR_DECLs in T with their new equivalents.
2973    DATA is really a splay-tree mapping old variables to new
2974    variables.  */
2975
2976 static tree
2977 bot_replace (tree* t, int* /*walk_subtrees*/, void* data)
2978 {
2979   splay_tree target_remap = ((splay_tree) data);
2980
2981   if (VAR_P (*t))
2982     {
2983       splay_tree_node n = splay_tree_lookup (target_remap,
2984                                              (splay_tree_key) *t);
2985       if (n)
2986         *t = (tree) n->value;
2987     }
2988   else if (TREE_CODE (*t) == PARM_DECL
2989            && DECL_NAME (*t) == this_identifier
2990            && !DECL_CONTEXT (*t))
2991     {
2992       /* In an NSDMI we need to replace the 'this' parameter we used for
2993          parsing with the real one for this function.  */
2994       *t = current_class_ptr;
2995     }
2996   else if (TREE_CODE (*t) == CONVERT_EXPR
2997            && CONVERT_EXPR_VBASE_PATH (*t))
2998     {
2999       /* In an NSDMI build_base_path defers building conversions to virtual
3000          bases, and we handle it here.  */
3001       tree basetype = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (*t)));
3002       vec<tree, va_gc> *vbases = CLASSTYPE_VBASECLASSES (current_class_type);
3003       int i; tree binfo;
3004       FOR_EACH_VEC_SAFE_ELT (vbases, i, binfo)
3005         if (BINFO_TYPE (binfo) == basetype)
3006           break;
3007       *t = build_base_path (PLUS_EXPR, TREE_OPERAND (*t, 0), binfo, true,
3008                             tf_warning_or_error);
3009     }
3010
3011   return NULL_TREE;
3012 }
3013
3014 /* When we parse a default argument expression, we may create
3015    temporary variables via TARGET_EXPRs.  When we actually use the
3016    default-argument expression, we make a copy of the expression
3017    and replace the temporaries with appropriate local versions.  */
3018
3019 tree
3020 break_out_target_exprs (tree t)
3021 {
3022   static int target_remap_count;
3023   static splay_tree target_remap;
3024
3025   if (!target_remap_count++)
3026     target_remap = splay_tree_new (splay_tree_compare_pointers,
3027                                    /*splay_tree_delete_key_fn=*/NULL,
3028                                    /*splay_tree_delete_value_fn=*/NULL);
3029   cp_walk_tree (&t, bot_manip, target_remap, NULL);
3030   cp_walk_tree (&t, bot_replace, target_remap, NULL);
3031
3032   if (!--target_remap_count)
3033     {
3034       splay_tree_delete (target_remap);
3035       target_remap = NULL;
3036     }
3037
3038   return t;
3039 }
3040
3041 /* Build an expression for the subobject of OBJ at CONSTRUCTOR index INDEX,
3042    which we expect to have type TYPE.  */
3043
3044 tree
3045 build_ctor_subob_ref (tree index, tree type, tree obj)
3046 {
3047   if (index == NULL_TREE)
3048     /* Can't refer to a particular member of a vector.  */
3049     obj = NULL_TREE;
3050   else if (TREE_CODE (index) == INTEGER_CST)
3051     obj = cp_build_array_ref (input_location, obj, index, tf_none);
3052   else
3053     obj = build_class_member_access_expr (obj, index, NULL_TREE,
3054                                           /*reference*/false, tf_none);
3055   if (obj)
3056     {
3057       tree objtype = TREE_TYPE (obj);
3058       if (TREE_CODE (objtype) == ARRAY_TYPE && !TYPE_DOMAIN (objtype))
3059         {
3060           /* When the destination object refers to a flexible array member
3061              verify that it matches the type of the source object except
3062              for its domain and qualifiers.  */
3063           gcc_assert (comptypes (TYPE_MAIN_VARIANT (type),
3064                                  TYPE_MAIN_VARIANT (objtype),
3065                                  COMPARE_REDECLARATION));
3066         }
3067       else
3068         gcc_assert (same_type_ignoring_top_level_qualifiers_p (type, objtype));
3069     }
3070
3071   return obj;
3072 }
3073
3074 struct replace_placeholders_t
3075 {
3076   tree obj;         /* The object to be substituted for a PLACEHOLDER_EXPR.  */
3077   bool seen;        /* Whether we've encountered a PLACEHOLDER_EXPR.  */
3078   hash_set<tree> *pset; /* To avoid walking same trees multiple times.  */
3079 };
3080
3081 /* Like substitute_placeholder_in_expr, but handle C++ tree codes and
3082    build up subexpressions as we go deeper.  */
3083
3084 static tree
3085 replace_placeholders_r (tree* t, int* walk_subtrees, void* data_)
3086 {
3087   replace_placeholders_t *d = static_cast<replace_placeholders_t*>(data_);
3088   tree obj = d->obj;
3089
3090   if (TREE_CONSTANT (*t))
3091     {
3092       *walk_subtrees = false;
3093       return NULL_TREE;
3094     }
3095
3096   switch (TREE_CODE (*t))
3097     {
3098     case PLACEHOLDER_EXPR:
3099       {
3100         tree x = obj;
3101         for (; !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (*t),
3102                                                            TREE_TYPE (x));
3103              x = TREE_OPERAND (x, 0))
3104           gcc_assert (TREE_CODE (x) == COMPONENT_REF);
3105         *t = x;
3106         *walk_subtrees = false;
3107         d->seen = true;
3108       }
3109       break;
3110
3111     case CONSTRUCTOR:
3112       {
3113         constructor_elt *ce;
3114         vec<constructor_elt,va_gc> *v = CONSTRUCTOR_ELTS (*t);
3115         if (d->pset->add (*t))
3116           {
3117             *walk_subtrees = false;
3118             return NULL_TREE;
3119           }
3120         for (unsigned i = 0; vec_safe_iterate (v, i, &ce); ++i)
3121           {
3122             tree *valp = &ce->value;
3123             tree type = TREE_TYPE (*valp);
3124             tree subob = obj;
3125
3126             if (TREE_CODE (*valp) == CONSTRUCTOR
3127                 && AGGREGATE_TYPE_P (type))
3128               {
3129                 /* If we're looking at the initializer for OBJ, then build
3130                    a sub-object reference.  If we're looking at an
3131                    initializer for another object, just pass OBJ down.  */
3132                 if (same_type_ignoring_top_level_qualifiers_p
3133                     (TREE_TYPE (*t), TREE_TYPE (obj)))
3134                   subob = build_ctor_subob_ref (ce->index, type, obj);
3135                 if (TREE_CODE (*valp) == TARGET_EXPR)
3136                   valp = &TARGET_EXPR_INITIAL (*valp);
3137               }
3138             d->obj = subob;
3139             cp_walk_tree (valp, replace_placeholders_r, data_, NULL);
3140             d->obj = obj;
3141           }
3142         *walk_subtrees = false;
3143         break;
3144       }
3145
3146     default:
3147       if (d->pset->add (*t))
3148         *walk_subtrees = false;
3149       break;
3150     }
3151
3152   return NULL_TREE;
3153 }
3154
3155 /* Replace PLACEHOLDER_EXPRs in EXP with object OBJ.  SEEN_P is set if
3156    a PLACEHOLDER_EXPR has been encountered.  */
3157
3158 tree
3159 replace_placeholders (tree exp, tree obj, bool *seen_p)
3160 {
3161   /* This is only relevant for C++14.  */
3162   if (cxx_dialect < cxx14)
3163     return exp;
3164
3165   /* If the object isn't a (member of a) class, do nothing.  */
3166   tree op0 = obj;
3167   while (TREE_CODE (op0) == COMPONENT_REF)
3168     op0 = TREE_OPERAND (op0, 0);
3169   if (!CLASS_TYPE_P (strip_array_types (TREE_TYPE (op0))))
3170     return exp;
3171
3172   tree *tp = &exp;
3173   hash_set<tree> pset;
3174   replace_placeholders_t data = { obj, false, &pset };
3175   if (TREE_CODE (exp) == TARGET_EXPR)
3176     tp = &TARGET_EXPR_INITIAL (exp);
3177   cp_walk_tree (tp, replace_placeholders_r, &data, NULL);
3178   if (seen_p)
3179     *seen_p = data.seen;
3180   return exp;
3181 }
3182
3183 /* Similar to `build_nt', but for template definitions of dependent
3184    expressions  */
3185
3186 tree
3187 build_min_nt_loc (location_t loc, enum tree_code code, ...)
3188 {
3189   tree t;
3190   int length;
3191   int i;
3192   va_list p;
3193
3194   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
3195
3196   va_start (p, code);
3197
3198   t = make_node (code);
3199   SET_EXPR_LOCATION (t, loc);
3200   length = TREE_CODE_LENGTH (code);
3201
3202   for (i = 0; i < length; i++)
3203     {
3204       tree x = va_arg (p, tree);
3205       TREE_OPERAND (t, i) = x;
3206       if (x && TREE_CODE (x) == OVERLOAD)
3207         lookup_keep (x, true);
3208     }
3209
3210   va_end (p);
3211   return t;
3212 }
3213
3214 /* Similar to `build', but for template definitions.  */
3215
3216 tree
3217 build_min (enum tree_code code, tree tt, ...)
3218 {
3219   tree t;
3220   int length;
3221   int i;
3222   va_list p;
3223
3224   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
3225
3226   va_start (p, tt);
3227
3228   t = make_node (code);
3229   length = TREE_CODE_LENGTH (code);
3230   TREE_TYPE (t) = tt;
3231
3232   for (i = 0; i < length; i++)
3233     {
3234       tree x = va_arg (p, tree);
3235       TREE_OPERAND (t, i) = x;
3236       if (x)
3237         {
3238           if (!TYPE_P (x) && TREE_SIDE_EFFECTS (x))
3239             TREE_SIDE_EFFECTS (t) = 1;
3240           if (TREE_CODE (x) == OVERLOAD)
3241             lookup_keep (x, true);
3242         }
3243     }
3244
3245   va_end (p);
3246
3247   if (code == CAST_EXPR)
3248     /* The single operand is a TREE_LIST, which we have to check.  */
3249     for (tree v = TREE_OPERAND (t, 0); v; v = TREE_CHAIN (v))
3250       if (TREE_CODE (TREE_VALUE (v)) == OVERLOAD)
3251         lookup_keep (TREE_VALUE (v), true);
3252
3253   return t;
3254 }
3255
3256 /* Similar to `build', but for template definitions of non-dependent
3257    expressions. NON_DEP is the non-dependent expression that has been
3258    built.  */
3259
3260 tree
3261 build_min_non_dep (enum tree_code code, tree non_dep, ...)
3262 {
3263   tree t;
3264   int length;
3265   int i;
3266   va_list p;
3267
3268   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
3269
3270   va_start (p, non_dep);
3271
3272   if (REFERENCE_REF_P (non_dep))
3273     non_dep = TREE_OPERAND (non_dep, 0);
3274
3275   t = make_node (code);
3276   length = TREE_CODE_LENGTH (code);
3277   TREE_TYPE (t) = unlowered_expr_type (non_dep);
3278   TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (non_dep);
3279
3280   for (i = 0; i < length; i++)
3281     {
3282       tree x = va_arg (p, tree);
3283       TREE_OPERAND (t, i) = x;
3284       if (x && TREE_CODE (x) == OVERLOAD)
3285         lookup_keep (x, true);
3286     }
3287
3288   if (code == COMPOUND_EXPR && TREE_CODE (non_dep) != COMPOUND_EXPR)
3289     /* This should not be considered a COMPOUND_EXPR, because it
3290        resolves to an overload.  */
3291     COMPOUND_EXPR_OVERLOADED (t) = 1;
3292
3293   va_end (p);
3294   return convert_from_reference (t);
3295 }
3296
3297 /* Similar to build_min_nt, but call expressions  */
3298
3299 tree
3300 build_min_nt_call_vec (tree fn, vec<tree, va_gc> *args)
3301 {
3302   tree ret, t;
3303   unsigned int ix;
3304
3305   ret = build_vl_exp (CALL_EXPR, vec_safe_length (args) + 3);
3306   CALL_EXPR_FN (ret) = fn;
3307   CALL_EXPR_STATIC_CHAIN (ret) = NULL_TREE;
3308   FOR_EACH_VEC_SAFE_ELT (args, ix, t)
3309     {
3310       CALL_EXPR_ARG (ret, ix) = t;
3311       if (TREE_CODE (t) == OVERLOAD)
3312         lookup_keep (t, true);
3313     }
3314   return ret;
3315 }
3316
3317 /* Similar to `build_min_nt_call_vec', but for template definitions of
3318    non-dependent expressions. NON_DEP is the non-dependent expression
3319    that has been built.  */
3320
3321 tree
3322 build_min_non_dep_call_vec (tree non_dep, tree fn, vec<tree, va_gc> *argvec)
3323 {
3324   tree t = build_min_nt_call_vec (fn, argvec);
3325   if (REFERENCE_REF_P (non_dep))
3326     non_dep = TREE_OPERAND (non_dep, 0);
3327   TREE_TYPE (t) = TREE_TYPE (non_dep);
3328   TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (non_dep);
3329   return convert_from_reference (t);
3330 }
3331
3332 /* Similar to build_min_non_dep, but for expressions that have been resolved to
3333    a call to an operator overload.  OP is the operator that has been
3334    overloaded.  NON_DEP is the non-dependent expression that's been built,
3335    which should be a CALL_EXPR or an INDIRECT_REF to a CALL_EXPR.  OVERLOAD is
3336    the overload that NON_DEP is calling.  */
3337
3338 tree
3339 build_min_non_dep_op_overload (enum tree_code op,
3340                                tree non_dep,
3341                                tree overload, ...)
3342 {
3343   va_list p;
3344   int nargs, expected_nargs;
3345   tree fn, call;
3346   vec<tree, va_gc> *args;
3347
3348   non_dep = extract_call_expr (non_dep);
3349
3350   nargs = call_expr_nargs (non_dep);
3351
3352   expected_nargs = cp_tree_code_length (op);
3353   if ((op == POSTINCREMENT_EXPR
3354        || op == POSTDECREMENT_EXPR)
3355       /* With -fpermissive non_dep could be operator++().  */
3356       && (!flag_permissive || nargs != expected_nargs))
3357     expected_nargs += 1;
3358   gcc_assert (nargs == expected_nargs);
3359
3360   args = make_tree_vector ();
3361   va_start (p, overload);
3362
3363   if (TREE_CODE (TREE_TYPE (overload)) == FUNCTION_TYPE)
3364     {
3365       fn = overload;
3366       for (int i = 0; i < nargs; i++)
3367         {
3368           tree arg = va_arg (p, tree);
3369           vec_safe_push (args, arg);
3370         }
3371     }
3372   else if (TREE_CODE (TREE_TYPE (overload)) == METHOD_TYPE)
3373     {
3374       tree object = va_arg (p, tree);
3375       tree binfo = TYPE_BINFO (TREE_TYPE (object));
3376       tree method = build_baselink (binfo, binfo, overload, NULL_TREE);
3377       fn = build_min (COMPONENT_REF, TREE_TYPE (overload),
3378                       object, method, NULL_TREE);
3379       for (int i = 1; i < nargs; i++)
3380         {
3381           tree arg = va_arg (p, tree);
3382           vec_safe_push (args, arg);
3383         }
3384     }
3385   else
3386    gcc_unreachable ();
3387
3388   va_end (p);
3389   call = build_min_non_dep_call_vec (non_dep, fn, args);
3390   release_tree_vector (args);
3391
3392   tree call_expr = extract_call_expr (call);
3393   KOENIG_LOOKUP_P (call_expr) = KOENIG_LOOKUP_P (non_dep);
3394   CALL_EXPR_OPERATOR_SYNTAX (call_expr) = true;
3395   CALL_EXPR_ORDERED_ARGS (call_expr) = CALL_EXPR_ORDERED_ARGS (non_dep);
3396   CALL_EXPR_REVERSE_ARGS (call_expr) = CALL_EXPR_REVERSE_ARGS (non_dep);
3397
3398   return call;
3399 }
3400
3401 /* Return a new tree vec copied from VEC, with ELT inserted at index IDX.  */
3402
3403 vec<tree, va_gc> *
3404 vec_copy_and_insert (vec<tree, va_gc> *old_vec, tree elt, unsigned idx)
3405 {
3406   unsigned len = vec_safe_length (old_vec);
3407   gcc_assert (idx <= len);
3408
3409   vec<tree, va_gc> *new_vec = NULL;
3410   vec_alloc (new_vec, len + 1);
3411
3412   unsigned i;
3413   for (i = 0; i < len; ++i)
3414     {
3415       if (i == idx)
3416         new_vec->quick_push (elt);
3417       new_vec->quick_push ((*old_vec)[i]);
3418     }
3419   if (i == idx)
3420     new_vec->quick_push (elt);
3421
3422   return new_vec;
3423 }
3424
3425 tree
3426 get_type_decl (tree t)
3427 {
3428   if (TREE_CODE (t) == TYPE_DECL)
3429     return t;
3430   if (TYPE_P (t))
3431     return TYPE_STUB_DECL (t);
3432   gcc_assert (t == error_mark_node);
3433   return t;
3434 }
3435
3436 /* Returns the namespace that contains DECL, whether directly or
3437    indirectly.  */
3438
3439 tree
3440 decl_namespace_context (tree decl)
3441 {
3442   while (1)
3443     {
3444       if (TREE_CODE (decl) == NAMESPACE_DECL)
3445         return decl;
3446       else if (TYPE_P (decl))
3447         decl = CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl));
3448       else
3449         decl = CP_DECL_CONTEXT (decl);
3450     }
3451 }
3452
3453 /* Returns true if decl is within an anonymous namespace, however deeply
3454    nested, or false otherwise.  */
3455
3456 bool
3457 decl_anon_ns_mem_p (const_tree decl)
3458 {
3459   while (TREE_CODE (decl) != NAMESPACE_DECL)
3460     {
3461       /* Classes inside anonymous namespaces have TREE_PUBLIC == 0.  */
3462       if (TYPE_P (decl))
3463         return !TREE_PUBLIC (TYPE_MAIN_DECL (decl));
3464
3465       decl = CP_DECL_CONTEXT (decl);
3466     }
3467   return !TREE_PUBLIC (decl);
3468 }
3469
3470 /* Subroutine of cp_tree_equal: t1 and t2 are the CALL_EXPR_FNs of two
3471    CALL_EXPRS.  Return whether they are equivalent.  */
3472
3473 static bool
3474 called_fns_equal (tree t1, tree t2)
3475 {
3476   /* Core 1321: dependent names are equivalent even if the overload sets
3477      are different.  But do compare explicit template arguments.  */
3478   tree name1 = dependent_name (t1);
3479   tree name2 = dependent_name (t2);
3480   if (name1 || name2)
3481     {
3482       tree targs1 = NULL_TREE, targs2 = NULL_TREE;
3483
3484       if (name1 != name2)
3485         return false;
3486
3487       if (TREE_CODE (t1) == TEMPLATE_ID_EXPR)
3488         targs1 = TREE_OPERAND (t1, 1);
3489       if (TREE_CODE (t2) == TEMPLATE_ID_EXPR)
3490         targs2 = TREE_OPERAND (t2, 1);
3491       return cp_tree_equal (targs1, targs2);
3492     }
3493   else
3494     return cp_tree_equal (t1, t2);
3495 }
3496
3497 /* Return truthvalue of whether T1 is the same tree structure as T2.
3498    Return 1 if they are the same. Return 0 if they are different.  */
3499
3500 bool
3501 cp_tree_equal (tree t1, tree t2)
3502 {
3503   enum tree_code code1, code2;
3504
3505   if (t1 == t2)
3506     return true;
3507   if (!t1 || !t2)
3508     return false;
3509
3510   code1 = TREE_CODE (t1);
3511   code2 = TREE_CODE (t2);
3512
3513   if (code1 != code2)
3514     return false;
3515
3516   if (CONSTANT_CLASS_P (t1)
3517       && !same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
3518     return false;
3519
3520   switch (code1)
3521     {
3522     case VOID_CST:
3523       /* There's only a single VOID_CST node, so we should never reach
3524          here.  */
3525       gcc_unreachable ();
3526
3527     case INTEGER_CST:
3528       return tree_int_cst_equal (t1, t2);
3529
3530     case REAL_CST:
3531       return real_equal (&TREE_REAL_CST (t1), &TREE_REAL_CST (t2));
3532
3533     case STRING_CST:
3534       return TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
3535         && !memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
3536                     TREE_STRING_LENGTH (t1));
3537
3538     case FIXED_CST:
3539       return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1),
3540                                      TREE_FIXED_CST (t2));
3541
3542     case COMPLEX_CST:
3543       return cp_tree_equal (TREE_REALPART (t1), TREE_REALPART (t2))
3544         && cp_tree_equal (TREE_IMAGPART (t1), TREE_IMAGPART (t2));
3545
3546     case VECTOR_CST:
3547       return operand_equal_p (t1, t2, OEP_ONLY_CONST);
3548
3549     case CONSTRUCTOR:
3550       /* We need to do this when determining whether or not two
3551          non-type pointer to member function template arguments
3552          are the same.  */
3553       if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
3554           || CONSTRUCTOR_NELTS (t1) != CONSTRUCTOR_NELTS (t2))
3555         return false;
3556       {
3557         tree field, value;
3558         unsigned int i;
3559         FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1), i, field, value)
3560           {
3561             constructor_elt *elt2 = CONSTRUCTOR_ELT (t2, i);
3562             if (!cp_tree_equal (field, elt2->index)
3563                 || !cp_tree_equal (value, elt2->value))
3564               return false;
3565           }
3566       }
3567       return true;
3568
3569     case TREE_LIST:
3570       if (!cp_tree_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2)))
3571         return false;
3572       if (!cp_tree_equal (TREE_VALUE (t1), TREE_VALUE (t2)))
3573         return false;
3574       return cp_tree_equal (TREE_CHAIN (t1), TREE_CHAIN (t2));
3575
3576     case SAVE_EXPR:
3577       return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3578
3579     case CALL_EXPR:
3580       {
3581         tree arg1, arg2;
3582         call_expr_arg_iterator iter1, iter2;
3583         if (!called_fns_equal (CALL_EXPR_FN (t1), CALL_EXPR_FN (t2)))
3584           return false;
3585         for (arg1 = first_call_expr_arg (t1, &iter1),
3586                arg2 = first_call_expr_arg (t2, &iter2);
3587              arg1 && arg2;
3588              arg1 = next_call_expr_arg (&iter1),
3589                arg2 = next_call_expr_arg (&iter2))
3590           if (!cp_tree_equal (arg1, arg2))
3591             return false;
3592         if (arg1 || arg2)
3593           return false;
3594         return true;
3595       }
3596
3597     case TARGET_EXPR:
3598       {
3599         tree o1 = TREE_OPERAND (t1, 0);
3600         tree o2 = TREE_OPERAND (t2, 0);
3601
3602         /* Special case: if either target is an unallocated VAR_DECL,
3603            it means that it's going to be unified with whatever the
3604            TARGET_EXPR is really supposed to initialize, so treat it
3605            as being equivalent to anything.  */
3606         if (VAR_P (o1) && DECL_NAME (o1) == NULL_TREE
3607             && !DECL_RTL_SET_P (o1))
3608           /*Nop*/;
3609         else if (VAR_P (o2) && DECL_NAME (o2) == NULL_TREE
3610                  && !DECL_RTL_SET_P (o2))
3611           /*Nop*/;
3612         else if (!cp_tree_equal (o1, o2))
3613           return false;
3614
3615         return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
3616       }
3617
3618     case PARM_DECL:
3619       /* For comparing uses of parameters in late-specified return types
3620          with an out-of-class definition of the function, but can also come
3621          up for expressions that involve 'this' in a member function
3622          template.  */
3623
3624       if (comparing_specializations && !CONSTRAINT_VAR_P (t1))
3625         /* When comparing hash table entries, only an exact match is
3626            good enough; we don't want to replace 'this' with the
3627            version from another function.  But be more flexible
3628            with local parameters in a requires-expression.  */
3629         return false;
3630
3631       if (same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
3632         {
3633           if (DECL_ARTIFICIAL (t1) ^ DECL_ARTIFICIAL (t2))
3634             return false;
3635           if (CONSTRAINT_VAR_P (t1) ^ CONSTRAINT_VAR_P (t2))
3636             return false;
3637           if (DECL_ARTIFICIAL (t1)
3638               || (DECL_PARM_LEVEL (t1) == DECL_PARM_LEVEL (t2)
3639                   && DECL_PARM_INDEX (t1) == DECL_PARM_INDEX (t2)))
3640             return true;
3641         }
3642       return false;
3643
3644     case VAR_DECL:
3645     case CONST_DECL:
3646     case FIELD_DECL:
3647     case FUNCTION_DECL:
3648     case TEMPLATE_DECL:
3649     case IDENTIFIER_NODE:
3650     case SSA_NAME:
3651       return false;
3652
3653     case BASELINK:
3654       return (BASELINK_BINFO (t1) == BASELINK_BINFO (t2)
3655               && BASELINK_ACCESS_BINFO (t1) == BASELINK_ACCESS_BINFO (t2)
3656               && BASELINK_QUALIFIED_P (t1) == BASELINK_QUALIFIED_P (t2)
3657               && cp_tree_equal (BASELINK_FUNCTIONS (t1),
3658                                 BASELINK_FUNCTIONS (t2)));
3659
3660     case TEMPLATE_PARM_INDEX:
3661       return (TEMPLATE_PARM_IDX (t1) == TEMPLATE_PARM_IDX (t2)
3662               && TEMPLATE_PARM_LEVEL (t1) == TEMPLATE_PARM_LEVEL (t2)
3663               && (TEMPLATE_PARM_PARAMETER_PACK (t1)
3664                   == TEMPLATE_PARM_PARAMETER_PACK (t2))
3665               && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1)),
3666                               TREE_TYPE (TEMPLATE_PARM_DECL (t2))));
3667
3668     case TEMPLATE_ID_EXPR:
3669       return (cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0))
3670               && cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1)));
3671
3672     case CONSTRAINT_INFO:
3673       return cp_tree_equal (CI_ASSOCIATED_CONSTRAINTS (t1),
3674                             CI_ASSOCIATED_CONSTRAINTS (t2));
3675
3676     case CHECK_CONSTR:
3677       return (CHECK_CONSTR_CONCEPT (t1) == CHECK_CONSTR_CONCEPT (t2)
3678               && comp_template_args (CHECK_CONSTR_ARGS (t1),
3679                                      CHECK_CONSTR_ARGS (t2)));
3680
3681     case TREE_VEC:
3682       {
3683         unsigned ix;
3684         if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2))
3685           return false;
3686         for (ix = TREE_VEC_LENGTH (t1); ix--;)
3687           if (!cp_tree_equal (TREE_VEC_ELT (t1, ix),
3688                               TREE_VEC_ELT (t2, ix)))
3689             return false;
3690         return true;
3691       }
3692
3693     case SIZEOF_EXPR:
3694     case ALIGNOF_EXPR:
3695       {
3696         tree o1 = TREE_OPERAND (t1, 0);
3697         tree o2 = TREE_OPERAND (t2, 0);
3698
3699         if (code1 == SIZEOF_EXPR)
3700           {
3701             if (SIZEOF_EXPR_TYPE_P (t1))
3702               o1 = TREE_TYPE (o1);
3703             if (SIZEOF_EXPR_TYPE_P (t2))
3704               o2 = TREE_TYPE (o2);
3705           }
3706         if (TREE_CODE (o1) != TREE_CODE (o2))
3707           return false;
3708         if (TYPE_P (o1))
3709           return same_type_p (o1, o2);
3710         else
3711           return cp_tree_equal (o1, o2);
3712       }
3713
3714     case MODOP_EXPR:
3715       {
3716         tree t1_op1, t2_op1;
3717
3718         if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
3719           return false;
3720
3721         t1_op1 = TREE_OPERAND (t1, 1);
3722         t2_op1 = TREE_OPERAND (t2, 1);
3723         if (TREE_CODE (t1_op1) != TREE_CODE (t2_op1))
3724           return false;
3725
3726         return cp_tree_equal (TREE_OPERAND (t1, 2), TREE_OPERAND (t2, 2));
3727       }
3728
3729     case PTRMEM_CST:
3730       /* Two pointer-to-members are the same if they point to the same
3731          field or function in the same class.  */
3732       if (PTRMEM_CST_MEMBER (t1) != PTRMEM_CST_MEMBER (t2))
3733         return false;
3734
3735       return same_type_p (PTRMEM_CST_CLASS (t1), PTRMEM_CST_CLASS (t2));
3736
3737     case OVERLOAD:
3738       {
3739         /* Two overloads. Must be exactly the same set of decls.  */
3740         lkp_iterator first (t1);
3741         lkp_iterator second (t2);
3742
3743         for (; first && second; ++first, ++second)
3744           if (*first != *second)
3745             return false;
3746         return !(first || second);
3747       }
3748
3749     case TRAIT_EXPR:
3750       if (TRAIT_EXPR_KIND (t1) != TRAIT_EXPR_KIND (t2))
3751         return false;
3752       return same_type_p (TRAIT_EXPR_TYPE1 (t1), TRAIT_EXPR_TYPE1 (t2))
3753         && cp_tree_equal (TRAIT_EXPR_TYPE2 (t1), TRAIT_EXPR_TYPE2 (t2));
3754
3755     case CAST_EXPR:
3756     case STATIC_CAST_EXPR:
3757     case REINTERPRET_CAST_EXPR:
3758     case CONST_CAST_EXPR:
3759     case DYNAMIC_CAST_EXPR:
3760     case IMPLICIT_CONV_EXPR:
3761     case NEW_EXPR:
3762     CASE_CONVERT:
3763     case NON_LVALUE_EXPR:
3764     case VIEW_CONVERT_EXPR:
3765       if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
3766         return false;
3767       /* Now compare operands as usual.  */
3768       break;
3769
3770     case DEFERRED_NOEXCEPT:
3771       return (cp_tree_equal (DEFERRED_NOEXCEPT_PATTERN (t1),
3772                              DEFERRED_NOEXCEPT_PATTERN (t2))
3773               && comp_template_args (DEFERRED_NOEXCEPT_ARGS (t1),
3774                                      DEFERRED_NOEXCEPT_ARGS (t2)));
3775       break;
3776
3777     default:
3778       break;
3779     }
3780
3781   switch (TREE_CODE_CLASS (code1))
3782     {
3783     case tcc_unary:
3784     case tcc_binary:
3785     case tcc_comparison:
3786     case tcc_expression:
3787     case tcc_vl_exp:
3788     case tcc_reference:
3789     case tcc_statement:
3790       {
3791         int i, n;
3792
3793         n = cp_tree_operand_length (t1);
3794         if (TREE_CODE_CLASS (code1) == tcc_vl_exp
3795             && n != TREE_OPERAND_LENGTH (t2))
3796           return false;
3797
3798         for (i = 0; i < n; ++i)
3799           if (!cp_tree_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i)))
3800             return false;
3801
3802         return true;
3803       }
3804
3805     case tcc_type:
3806       return same_type_p (t1, t2);
3807     default:
3808       gcc_unreachable ();
3809     }
3810   /* We can get here with --disable-checking.  */
3811   return false;
3812 }
3813
3814 /* The type of ARG when used as an lvalue.  */
3815
3816 tree
3817 lvalue_type (tree arg)
3818 {
3819   tree type = TREE_TYPE (arg);
3820   return type;
3821 }
3822
3823 /* The type of ARG for printing error messages; denote lvalues with
3824    reference types.  */
3825
3826 tree
3827 error_type (tree arg)
3828 {
3829   tree type = TREE_TYPE (arg);
3830
3831   if (TREE_CODE (type) == ARRAY_TYPE)
3832     ;
3833   else if (TREE_CODE (type) == ERROR_MARK)
3834     ;
3835   else if (lvalue_p (arg))
3836     type = build_reference_type (lvalue_type (arg));
3837   else if (MAYBE_CLASS_TYPE_P (type))
3838     type = lvalue_type (arg);
3839
3840   return type;
3841 }
3842
3843 /* Does FUNCTION use a variable-length argument list?  */
3844
3845 int
3846 varargs_function_p (const_tree function)
3847 {
3848   return stdarg_p (TREE_TYPE (function));
3849 }
3850
3851 /* Returns 1 if decl is a member of a class.  */
3852
3853 int
3854 member_p (const_tree decl)
3855 {
3856   const_tree const ctx = DECL_CONTEXT (decl);
3857   return (ctx && TYPE_P (ctx));
3858 }
3859
3860 /* Create a placeholder for member access where we don't actually have an
3861    object that the access is against.  */
3862
3863 tree
3864 build_dummy_object (tree type)
3865 {
3866   tree decl = build1 (CONVERT_EXPR, build_pointer_type (type), void_node);
3867   return cp_build_fold_indirect_ref (decl);
3868 }
3869
3870 /* We've gotten a reference to a member of TYPE.  Return *this if appropriate,
3871    or a dummy object otherwise.  If BINFOP is non-0, it is filled with the
3872    binfo path from current_class_type to TYPE, or 0.  */
3873
3874 tree
3875 maybe_dummy_object (tree type, tree* binfop)
3876 {
3877   tree decl, context;
3878   tree binfo;
3879   tree current = current_nonlambda_class_type ();
3880
3881   if (current
3882       && (binfo = lookup_base (current, type, ba_any, NULL,
3883                                tf_warning_or_error)))
3884     context = current;
3885   else
3886     {
3887       /* Reference from a nested class member function.  */
3888       context = type;
3889       binfo = TYPE_BINFO (type);
3890     }
3891
3892   if (binfop)
3893     *binfop = binfo;
3894
3895   if (current_class_ref
3896       /* current_class_ref might not correspond to current_class_type if
3897          we're in tsubst_default_argument or a lambda-declarator; in either
3898          case, we want to use current_class_ref if it matches CONTEXT.  */
3899       && (same_type_ignoring_top_level_qualifiers_p
3900           (TREE_TYPE (current_class_ref), context)))
3901     decl = current_class_ref;
3902   else
3903     decl = build_dummy_object (context);
3904
3905   return decl;
3906 }
3907
3908 /* Returns 1 if OB is a placeholder object, or a pointer to one.  */
3909
3910 int
3911 is_dummy_object (const_tree ob)
3912 {
3913   if (INDIRECT_REF_P (ob))
3914     ob = TREE_OPERAND (ob, 0);
3915   return (TREE_CODE (ob) == CONVERT_EXPR
3916           && TREE_OPERAND (ob, 0) == void_node);
3917 }
3918
3919 /* Returns 1 iff type T is something we want to treat as a scalar type for
3920    the purpose of deciding whether it is trivial/POD/standard-layout.  */
3921
3922 bool
3923 scalarish_type_p (const_tree t)
3924 {
3925   if (t == error_mark_node)
3926     return 1;
3927
3928   return (SCALAR_TYPE_P (t) || VECTOR_TYPE_P (t));
3929 }
3930
3931 /* Returns true iff T requires non-trivial default initialization.  */
3932
3933 bool
3934 type_has_nontrivial_default_init (const_tree t)
3935 {
3936   t = strip_array_types (CONST_CAST_TREE (t));
3937
3938   if (CLASS_TYPE_P (t))
3939     return TYPE_HAS_COMPLEX_DFLT (t);
3940   else
3941     return 0;
3942 }
3943
3944 /* Track classes with only deleted copy/move constructors so that we can warn
3945    if they are used in call/return by value.  */
3946
3947 static GTY(()) hash_set<tree>* deleted_copy_types;
3948 static void
3949 remember_deleted_copy (const_tree t)
3950 {
3951   if (!deleted_copy_types)
3952     deleted_copy_types = hash_set<tree>::create_ggc(37);
3953   deleted_copy_types->add (CONST_CAST_TREE (t));
3954 }
3955 void
3956 maybe_warn_parm_abi (tree t, location_t loc)
3957 {
3958   if (!deleted_copy_types
3959       || !deleted_copy_types->contains (t))
3960     return;
3961
3962   warning_at (loc, OPT_Wabi, "the calling convention for %qT changes in "
3963               "-fabi-version=12 (GCC 8)", t);
3964   static bool explained = false;
3965   if (!explained)
3966     {
3967       inform (loc, " because all of its copy and move constructors "
3968               "are deleted");
3969       explained = true;
3970     }
3971 }
3972
3973 /* Returns true iff copying an object of type T (including via move
3974    constructor) is non-trivial.  That is, T has no non-trivial copy
3975    constructors and no non-trivial move constructors, and not all copy/move
3976    constructors are deleted.  This function implements the ABI notion of
3977    non-trivial copy, which has diverged from the one in the standard.  */
3978
3979 bool
3980 type_has_nontrivial_copy_init (const_tree type)
3981 {
3982   tree t = strip_array_types (CONST_CAST_TREE (type));
3983
3984   if (CLASS_TYPE_P (t))
3985     {
3986       gcc_assert (COMPLETE_TYPE_P (t));
3987
3988       if (TYPE_HAS_COMPLEX_COPY_CTOR (t)
3989           || TYPE_HAS_COMPLEX_MOVE_CTOR (t))
3990         /* Nontrivial.  */
3991         return true;
3992
3993       if (cxx_dialect < cxx11)
3994         /* No deleted functions before C++11.  */
3995         return false;
3996
3997       /* Before ABI v12 we did a bitwise copy of types with only deleted
3998          copy/move constructors.  */
3999       if (!abi_version_at_least (12)
4000           && !(warn_abi && abi_version_crosses (12)))
4001         return false;
4002
4003       bool saw_copy = false;
4004       bool saw_non_deleted = false;
4005
4006       if (CLASSTYPE_LAZY_MOVE_CTOR (t))
4007         saw_copy = saw_non_deleted = true;
4008       else if (CLASSTYPE_LAZY_COPY_CTOR (t))
4009         {
4010           saw_copy = true;
4011           if (classtype_has_move_assign_or_move_ctor_p (t, true))
4012             /* [class.copy]/8 If the class definition declares a move
4013                constructor or move assignment operator, the implicitly declared
4014                copy constructor is defined as deleted.... */;
4015           else
4016             /* Any other reason the implicitly-declared function would be
4017                deleted would also cause TYPE_HAS_COMPLEX_COPY_CTOR to be
4018                set.  */
4019             saw_non_deleted = true;
4020         }
4021
4022       if (!saw_non_deleted)
4023         for (ovl_iterator iter (CLASSTYPE_CONSTRUCTORS (t)); iter; ++iter)
4024           {
4025             tree fn = *iter;
4026             if (copy_fn_p (fn))
4027               {
4028                 saw_copy = true;
4029                 if (!DECL_DELETED_FN (fn))
4030                   {
4031                     /* Not deleted, therefore trivial.  */
4032                     saw_non_deleted = true;
4033                     break;
4034                   }
4035               }
4036           }
4037
4038       gcc_assert (saw_copy);
4039
4040       if (saw_copy && !saw_non_deleted)
4041         {
4042           if (warn_abi && abi_version_crosses (12))
4043             remember_deleted_copy (t);
4044           if (abi_version_at_least (12))
4045             return true;
4046         }
4047
4048       return false;
4049     }
4050   else
4051     return 0;
4052 }
4053
4054 /* Returns 1 iff type T is a trivially copyable type, as defined in
4055    [basic.types] and [class].  */
4056
4057 bool
4058 trivially_copyable_p (const_tree t)
4059 {
4060   t = strip_array_types (CONST_CAST_TREE (t));
4061
4062   if (CLASS_TYPE_P (t))
4063     return ((!TYPE_HAS_COPY_CTOR (t)
4064              || !TYPE_HAS_COMPLEX_COPY_CTOR (t))
4065             && !TYPE_HAS_COMPLEX_MOVE_CTOR (t)
4066             && (!TYPE_HAS_COPY_ASSIGN (t)
4067                 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (t))
4068             && !TYPE_HAS_COMPLEX_MOVE_ASSIGN (t)
4069             && TYPE_HAS_TRIVIAL_DESTRUCTOR (t));
4070   else
4071     return !CP_TYPE_VOLATILE_P (t) && scalarish_type_p (t);
4072 }
4073
4074 /* Returns 1 iff type T is a trivial type, as defined in [basic.types] and
4075    [class].  */
4076
4077 bool
4078 trivial_type_p (const_tree t)
4079 {
4080   t = strip_array_types (CONST_CAST_TREE (t));
4081
4082   if (CLASS_TYPE_P (t))
4083     return (TYPE_HAS_TRIVIAL_DFLT (t)
4084             && trivially_copyable_p (t));
4085   else
4086     return scalarish_type_p (t);
4087 }
4088
4089 /* Returns 1 iff type T is a POD type, as defined in [basic.types].  */
4090
4091 bool
4092 pod_type_p (const_tree t)
4093 {
4094   /* This CONST_CAST is okay because strip_array_types returns its
4095      argument unmodified and we assign it to a const_tree.  */
4096   t = strip_array_types (CONST_CAST_TREE(t));
4097
4098   if (!CLASS_TYPE_P (t))
4099     return scalarish_type_p (t);
4100   else if (cxx_dialect > cxx98)
4101     /* [class]/10: A POD struct is a class that is both a trivial class and a
4102        standard-layout class, and has no non-static data members of type
4103        non-POD struct, non-POD union (or array of such types).
4104
4105        We don't need to check individual members because if a member is
4106        non-std-layout or non-trivial, the class will be too.  */
4107     return (std_layout_type_p (t) && trivial_type_p (t));
4108   else
4109     /* The C++98 definition of POD is different.  */
4110     return !CLASSTYPE_NON_LAYOUT_POD_P (t);
4111 }
4112
4113 /* Returns true iff T is POD for the purpose of layout, as defined in the
4114    C++ ABI.  */
4115
4116 bool
4117 layout_pod_type_p (const_tree t)
4118 {
4119   t = strip_array_types (CONST_CAST_TREE (t));
4120
4121   if (CLASS_TYPE_P (t))
4122     return !CLASSTYPE_NON_LAYOUT_POD_P (t);
4123   else
4124     return scalarish_type_p (t);
4125 }
4126
4127 /* Returns true iff T is a standard-layout type, as defined in
4128    [basic.types].  */
4129
4130 bool
4131 std_layout_type_p (const_tree t)
4132 {
4133   t = strip_array_types (CONST_CAST_TREE (t));
4134
4135   if (CLASS_TYPE_P (t))
4136     return !CLASSTYPE_NON_STD_LAYOUT (t);
4137   else
4138     return scalarish_type_p (t);
4139 }
4140
4141 static bool record_has_unique_obj_representations (const_tree, const_tree);
4142
4143 /* Returns true iff T satisfies std::has_unique_object_representations<T>,
4144    as defined in [meta.unary.prop].  */
4145
4146 bool
4147 type_has_unique_obj_representations (const_tree t)
4148 {
4149   bool ret;
4150
4151   t = strip_array_types (CONST_CAST_TREE (t));
4152
4153   if (!trivially_copyable_p (t))
4154     return false;
4155
4156   if (CLASS_TYPE_P (t) && CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t))
4157     return CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t);
4158
4159   switch (TREE_CODE (t))
4160     {
4161     case INTEGER_TYPE:
4162     case POINTER_TYPE:
4163     case REFERENCE_TYPE:
4164       /* If some backend has any paddings in these types, we should add
4165          a target hook for this and handle it there.  */
4166       return true;
4167
4168     case BOOLEAN_TYPE:
4169       /* For bool values other than 0 and 1 should only appear with
4170          undefined behavior.  */
4171       return true;
4172
4173     case ENUMERAL_TYPE:
4174       return type_has_unique_obj_representations (ENUM_UNDERLYING_TYPE (t));
4175
4176     case REAL_TYPE:
4177       /* XFmode certainly contains padding on x86, which the CPU doesn't store
4178          when storing long double values, so for that we have to return false.
4179          Other kinds of floating point values are questionable due to +.0/-.0
4180          and NaNs, let's play safe for now.  */
4181       return false;
4182
4183     case FIXED_POINT_TYPE:
4184       return false;
4185
4186     case OFFSET_TYPE:
4187       return true;
4188
4189     case COMPLEX_TYPE:
4190     case VECTOR_TYPE:
4191       return type_has_unique_obj_representations (TREE_TYPE (t));
4192
4193     case RECORD_TYPE:
4194       ret = record_has_unique_obj_representations (t, TYPE_SIZE (t));
4195       if (CLASS_TYPE_P (t))
4196         {
4197           CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t) = 1;
4198           CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t) = ret;
4199         }
4200       return ret;
4201
4202     case UNION_TYPE:
4203       ret = true;
4204       bool any_fields;
4205       any_fields = false;
4206       for (tree field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field))
4207         if (TREE_CODE (field) == FIELD_DECL)
4208           {
4209             any_fields = true;
4210             if (!type_has_unique_obj_representations (TREE_TYPE (field))
4211                 || simple_cst_equal (DECL_SIZE (field), TYPE_SIZE (t)) != 1)
4212               {
4213                 ret = false;
4214                 break;
4215               }
4216           }
4217       if (!any_fields && !integer_zerop (TYPE_SIZE (t)))
4218         ret = false;
4219       if (CLASS_TYPE_P (t))
4220         {
4221           CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t) = 1;
4222           CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t) = ret;
4223         }
4224       return ret;
4225
4226     case NULLPTR_TYPE:
4227       return false;
4228
4229     case ERROR_MARK:
4230       return false;
4231
4232     default:
4233       gcc_unreachable ();
4234     }
4235 }
4236
4237 /* Helper function for type_has_unique_obj_representations.  */
4238
4239 static bool
4240 record_has_unique_obj_representations (const_tree t, const_tree sz)
4241 {
4242   for (tree field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field))
4243     if (TREE_CODE (field) != FIELD_DECL)
4244       ;
4245     /* For bases, can't use type_has_unique_obj_representations here, as in
4246         struct S { int i : 24; S (); };
4247         struct T : public S { int j : 8; T (); };
4248         S doesn't have unique obj representations, but T does.  */
4249     else if (DECL_FIELD_IS_BASE (field))
4250       {
4251         if (!record_has_unique_obj_representations (TREE_TYPE (field),
4252                                                     DECL_SIZE (field)))
4253           return false;
4254       }
4255     else if (DECL_C_BIT_FIELD (field))
4256       {
4257         tree btype = DECL_BIT_FIELD_TYPE (field);
4258         if (!type_has_unique_obj_representations (btype))
4259           return false;
4260       }
4261     else if (!type_has_unique_obj_representations (TREE_TYPE (field)))
4262       return false;
4263
4264   offset_int cur = 0;
4265   for (tree field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field))
4266     if (TREE_CODE (field) == FIELD_DECL)
4267       {
4268         offset_int fld = wi::to_offset (DECL_FIELD_OFFSET (field));
4269         offset_int bitpos = wi::to_offset (DECL_FIELD_BIT_OFFSET (field));
4270         fld = fld * BITS_PER_UNIT + bitpos;
4271         if (cur != fld)
4272           return false;
4273         if (DECL_SIZE (field))
4274           {
4275             offset_int size = wi::to_offset (DECL_SIZE (field));
4276             cur += size;
4277           }
4278       }
4279   if (cur != wi::to_offset (sz))
4280     return false;
4281
4282   return true;
4283 }
4284
4285 /* Nonzero iff type T is a class template implicit specialization.  */
4286
4287 bool
4288 class_tmpl_impl_spec_p (const_tree t)
4289 {
4290   return CLASS_TYPE_P (t) && CLASSTYPE_TEMPLATE_INSTANTIATION (t);
4291 }
4292
4293 /* Returns 1 iff zero initialization of type T means actually storing
4294    zeros in it.  */
4295
4296 int
4297 zero_init_p (const_tree t)
4298 {
4299   /* This CONST_CAST is okay because strip_array_types returns its
4300      argument unmodified and we assign it to a const_tree.  */
4301   t = strip_array_types (CONST_CAST_TREE(t));
4302
4303   if (t == error_mark_node)
4304     return 1;
4305
4306   /* NULL pointers to data members are initialized with -1.  */
4307   if (TYPE_PTRDATAMEM_P (t))
4308     return 0;
4309
4310   /* Classes that contain types that can't be zero-initialized, cannot
4311      be zero-initialized themselves.  */
4312   if (CLASS_TYPE_P (t) && CLASSTYPE_NON_ZERO_INIT_P (t))
4313     return 0;
4314
4315   return 1;
4316 }
4317
4318 /* Handle the C++17 [[nodiscard]] attribute, which is similar to the GNU
4319    warn_unused_result attribute.  */
4320
4321 static tree
4322 handle_nodiscard_attribute (tree *node, tree name, tree /*args*/,
4323                             int /*flags*/, bool *no_add_attrs)
4324 {
4325   if (TREE_CODE (*node) == FUNCTION_DECL)
4326     {
4327       if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
4328         warning (OPT_Wattributes, "%qE attribute applied to %qD with void "
4329                  "return type", name, *node);
4330     }
4331   else if (OVERLOAD_TYPE_P (*node))
4332     /* OK */;
4333   else
4334     {
4335       warning (OPT_Wattributes, "%qE attribute can only be applied to "
4336                "functions or to class or enumeration types", name);
4337       *no_add_attrs = true;
4338     }
4339   return NULL_TREE;
4340 }
4341
4342 /* Table of valid C++ attributes.  */
4343 const struct attribute_spec cxx_attribute_table[] =
4344 {
4345   /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
4346        affects_type_identity, handler, exclude } */
4347   { "init_priority",  1, 1, true,  false, false, false,
4348     handle_init_priority_attribute, NULL },
4349   { "abi_tag", 1, -1, false, false, false, true,
4350     handle_abi_tag_attribute, NULL },
4351   { NULL, 0, 0, false, false, false, false, NULL, NULL }
4352 };
4353
4354 /* Table of C++ standard attributes.  */
4355 const struct attribute_spec std_attribute_table[] =
4356 {
4357   /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
4358        affects_type_identity, handler, exclude } */
4359   { "maybe_unused", 0, 0, false, false, false, false,
4360     handle_unused_attribute, NULL },
4361   { "nodiscard", 0, 0, false, false, false, false,
4362     handle_nodiscard_attribute, NULL },
4363   { NULL, 0, 0, false, false, false, false, NULL, NULL }
4364 };
4365
4366 /* Handle an "init_priority" attribute; arguments as in
4367    struct attribute_spec.handler.  */
4368 static tree
4369 handle_init_priority_attribute (tree* node,
4370                                 tree name,
4371                                 tree args,
4372                                 int /*flags*/,
4373                                 bool* no_add_attrs)
4374 {
4375   tree initp_expr = TREE_VALUE (args);
4376   tree decl = *node;
4377   tree type = TREE_TYPE (decl);
4378   int pri;
4379
4380   STRIP_NOPS (initp_expr);
4381   initp_expr = default_conversion (initp_expr);
4382   if (initp_expr)
4383     initp_expr = maybe_constant_value (initp_expr);
4384
4385   if (!initp_expr || TREE_CODE (initp_expr) != INTEGER_CST)
4386     {
4387       error ("requested init_priority is not an integer constant");
4388       cxx_constant_value (initp_expr);
4389       *no_add_attrs = true;
4390       return NULL_TREE;
4391     }
4392
4393   pri = TREE_INT_CST_LOW (initp_expr);
4394
4395   type = strip_array_types (type);
4396
4397   if (decl == NULL_TREE
4398       || !VAR_P (decl)
4399       || !TREE_STATIC (decl)
4400       || DECL_EXTERNAL (decl)
4401       || (TREE_CODE (type) != RECORD_TYPE
4402           && TREE_CODE (type) != UNION_TYPE)
4403       /* Static objects in functions are initialized the
4404          first time control passes through that
4405          function. This is not precise enough to pin down an
4406          init_priority value, so don't allow it.  */
4407       || current_function_decl)
4408     {
4409       error ("can only use %qE attribute on file-scope definitions "
4410              "of objects of class type", name);
4411       *no_add_attrs = true;
4412       return NULL_TREE;
4413     }
4414
4415   if (pri > MAX_INIT_PRIORITY || pri <= 0)
4416     {
4417       error ("requested init_priority is out of range");
4418       *no_add_attrs = true;
4419       return NULL_TREE;
4420     }
4421
4422   /* Check for init_priorities that are reserved for
4423      language and runtime support implementations.*/
4424   if (pri <= MAX_RESERVED_INIT_PRIORITY)
4425     {
4426       warning
4427         (0, "requested init_priority is reserved for internal use");
4428     }
4429
4430   if (SUPPORTS_INIT_PRIORITY)
4431     {
4432       SET_DECL_INIT_PRIORITY (decl, pri);
4433       DECL_HAS_INIT_PRIORITY_P (decl) = 1;
4434       return NULL_TREE;
4435     }
4436   else
4437     {
4438       error ("%qE attribute is not supported on this platform", name);
4439       *no_add_attrs = true;
4440       return NULL_TREE;
4441     }
4442 }
4443
4444 /* DECL is being redeclared; the old declaration had the abi tags in OLD,
4445    and the new one has the tags in NEW_.  Give an error if there are tags
4446    in NEW_ that weren't in OLD.  */
4447
4448 bool
4449 check_abi_tag_redeclaration (const_tree decl, const_tree old, const_tree new_)
4450 {
4451   if (old && TREE_CODE (TREE_VALUE (old)) == TREE_LIST)
4452     old = TREE_VALUE (old);
4453   if (new_ && TREE_CODE (TREE_VALUE (new_)) == TREE_LIST)
4454     new_ = TREE_VALUE (new_);
4455   bool err = false;
4456   for (const_tree t = new_; t; t = TREE_CHAIN (t))
4457     {
4458       tree str = TREE_VALUE (t);
4459       for (const_tree in = old; in; in = TREE_CHAIN (in))
4460         {
4461           tree ostr = TREE_VALUE (in);
4462           if (cp_tree_equal (str, ostr))
4463             goto found;
4464         }
4465       error ("redeclaration of %qD adds abi tag %qE", decl, str);
4466       err = true;
4467     found:;
4468     }
4469   if (err)
4470     {
4471       inform (DECL_SOURCE_LOCATION (decl), "previous declaration here");
4472       return false;
4473     }
4474   return true;
4475 }
4476
4477 /* The abi_tag attribute with the name NAME was given ARGS.  If they are
4478    ill-formed, give an error and return false; otherwise, return true.  */
4479
4480 bool
4481 check_abi_tag_args (tree args, tree name)
4482 {
4483   if (!args)
4484     {
4485       error ("the %qE attribute requires arguments", name);
4486       return false;
4487     }
4488   for (tree arg = args; arg; arg = TREE_CHAIN (arg))
4489     {
4490       tree elt = TREE_VALUE (arg);
4491       if (TREE_CODE (elt) != STRING_CST
4492           || (!same_type_ignoring_top_level_qualifiers_p
4493               (strip_array_types (TREE_TYPE (elt)),
4494                char_type_node)))
4495         {
4496           error ("arguments to the %qE attribute must be narrow string "
4497                  "literals", name);
4498           return false;
4499         }
4500       const char *begin = TREE_STRING_POINTER (elt);
4501       const char *end = begin + TREE_STRING_LENGTH (elt);
4502       for (const char *p = begin; p != end; ++p)
4503         {
4504           char c = *p;
4505           if (p == begin)
4506             {
4507               if (!ISALPHA (c) && c != '_')
4508                 {
4509                   error ("arguments to the %qE attribute must contain valid "
4510                          "identifiers", name);
4511                   inform (input_location, "%<%c%> is not a valid first "
4512                           "character for an identifier", c);
4513                   return false;
4514                 }
4515             }
4516           else if (p == end - 1)
4517             gcc_assert (c == 0);
4518           else
4519             {
4520               if (!ISALNUM (c) && c != '_')
4521                 {
4522                   error ("arguments to the %qE attribute must contain valid "
4523                          "identifiers", name);
4524                   inform (input_location, "%<%c%> is not a valid character "
4525                           "in an identifier", c);
4526                   return false;
4527                 }
4528             }
4529         }
4530     }
4531   return true;
4532 }
4533
4534 /* Handle an "abi_tag" attribute; arguments as in
4535    struct attribute_spec.handler.  */
4536
4537 static tree
4538 handle_abi_tag_attribute (tree* node, tree name, tree args,
4539                           int flags, bool* no_add_attrs)
4540 {
4541   if (!check_abi_tag_args (args, name))
4542     goto fail;
4543
4544   if (TYPE_P (*node))
4545     {
4546       if (!OVERLOAD_TYPE_P (*node))
4547         {
4548           error ("%qE attribute applied to non-class, non-enum type %qT",
4549                  name, *node);
4550           goto fail;
4551         }
4552       else if (!(flags & (int)ATTR_FLAG_TYPE_IN_PLACE))
4553         {
4554           error ("%qE attribute applied to %qT after its definition",
4555                  name, *node);
4556           goto fail;
4557         }
4558       else if (CLASS_TYPE_P (*node)
4559                && CLASSTYPE_TEMPLATE_INSTANTIATION (*node))
4560         {
4561           warning (OPT_Wattributes, "ignoring %qE attribute applied to "
4562                    "template instantiation %qT", name, *node);
4563           goto fail;
4564         }
4565       else if (CLASS_TYPE_P (*node)
4566                && CLASSTYPE_TEMPLATE_SPECIALIZATION (*node))
4567         {
4568           warning (OPT_Wattributes, "ignoring %qE attribute applied to "
4569                    "template specialization %qT", name, *node);
4570           goto fail;
4571         }
4572
4573       tree attributes = TYPE_ATTRIBUTES (*node);
4574       tree decl = TYPE_NAME (*node);
4575
4576       /* Make sure all declarations have the same abi tags.  */
4577       if (DECL_SOURCE_LOCATION (decl) != input_location)
4578         {
4579           if (!check_abi_tag_redeclaration (decl,
4580                                             lookup_attribute ("abi_tag",
4581                                                               attributes),
4582                                             args))
4583             goto fail;
4584         }
4585     }
4586   else
4587     {
4588       if (!VAR_OR_FUNCTION_DECL_P (*node))
4589         {
4590           error ("%qE attribute applied to non-function, non-variable %qD",
4591                  name, *node);
4592           goto fail;
4593         }
4594       else if (DECL_LANGUAGE (*node) == lang_c)
4595         {
4596           error ("%qE attribute applied to extern \"C\" declaration %qD",
4597                  name, *node);
4598           goto fail;
4599         }
4600     }
4601
4602   return NULL_TREE;
4603
4604  fail:
4605   *no_add_attrs = true;
4606   return NULL_TREE;
4607 }
4608
4609 /* Return a new PTRMEM_CST of the indicated TYPE.  The MEMBER is the
4610    thing pointed to by the constant.  */
4611
4612 tree
4613 make_ptrmem_cst (tree type, tree member)
4614 {
4615   tree ptrmem_cst = make_node (PTRMEM_CST);
4616   TREE_TYPE (ptrmem_cst) = type;
4617   PTRMEM_CST_MEMBER (ptrmem_cst) = member;
4618   return ptrmem_cst;
4619 }
4620
4621 /* Build a variant of TYPE that has the indicated ATTRIBUTES.  May
4622    return an existing type if an appropriate type already exists.  */
4623
4624 tree
4625 cp_build_type_attribute_variant (tree type, tree attributes)
4626 {
4627   tree new_type;
4628
4629   new_type = build_type_attribute_variant (type, attributes);
4630   if (TREE_CODE (new_type) == FUNCTION_TYPE
4631       || TREE_CODE (new_type) == METHOD_TYPE)
4632     {
4633       new_type = build_exception_variant (new_type,
4634                                           TYPE_RAISES_EXCEPTIONS (type));
4635       new_type = build_ref_qualified_type (new_type,
4636                                            type_memfn_rqual (type));
4637     }
4638
4639   /* Making a new main variant of a class type is broken.  */
4640   gcc_assert (!CLASS_TYPE_P (type) || new_type == type);
4641
4642   return new_type;
4643 }
4644
4645 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
4646    Called only after doing all language independent checks.  */
4647
4648 bool
4649 cxx_type_hash_eq (const_tree typea, const_tree typeb)
4650 {
4651   gcc_assert (TREE_CODE (typea) == FUNCTION_TYPE
4652               || TREE_CODE (typea) == METHOD_TYPE);
4653
4654   if (type_memfn_rqual (typea) != type_memfn_rqual (typeb))
4655     return false;
4656   return comp_except_specs (TYPE_RAISES_EXCEPTIONS (typea),
4657                             TYPE_RAISES_EXCEPTIONS (typeb), ce_exact);
4658 }
4659
4660 /* Copy the language-specific type variant modifiers from TYPEB to TYPEA.  For
4661    C++, these are the exception-specifier and ref-qualifier.  */
4662
4663 tree
4664 cxx_copy_lang_qualifiers (const_tree typea, const_tree typeb)
4665 {
4666   tree type = CONST_CAST_TREE (typea);
4667   if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
4668     {
4669       type = build_exception_variant (type, TYPE_RAISES_EXCEPTIONS (typeb));
4670       type = build_ref_qualified_type (type, type_memfn_rqual (typeb));
4671     }
4672   return type;
4673 }
4674
4675 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
4676    traversal.  Called from walk_tree.  */
4677
4678 tree
4679 cp_walk_subtrees (tree *tp, int *walk_subtrees_p, walk_tree_fn func,
4680                   void *data, hash_set<tree> *pset)
4681 {
4682   enum tree_code code = TREE_CODE (*tp);
4683   tree result;
4684
4685 #define WALK_SUBTREE(NODE)                              \
4686   do                                                    \
4687     {                                                   \
4688       result = cp_walk_tree (&(NODE), func, data, pset);        \
4689       if (result) goto out;                             \
4690     }                                                   \
4691   while (0)
4692
4693   /* Not one of the easy cases.  We must explicitly go through the
4694      children.  */
4695   result = NULL_TREE;
4696   switch (code)
4697     {
4698     case DEFAULT_ARG:
4699     case TEMPLATE_TEMPLATE_PARM:
4700     case BOUND_TEMPLATE_TEMPLATE_PARM:
4701     case UNBOUND_CLASS_TEMPLATE:
4702     case TEMPLATE_PARM_INDEX:
4703     case TEMPLATE_TYPE_PARM:
4704     case TYPENAME_TYPE:
4705     case TYPEOF_TYPE:
4706     case UNDERLYING_TYPE:
4707       /* None of these have subtrees other than those already walked
4708          above.  */
4709       *walk_subtrees_p = 0;
4710       break;
4711
4712     case BASELINK:
4713       if (BASELINK_QUALIFIED_P (*tp))
4714         WALK_SUBTREE (BINFO_TYPE (BASELINK_ACCESS_BINFO (*tp)));
4715       WALK_SUBTREE (BASELINK_FUNCTIONS (*tp));
4716       *walk_subtrees_p = 0;
4717       break;
4718
4719     case PTRMEM_CST:
4720       WALK_SUBTREE (TREE_TYPE (*tp));
4721       *walk_subtrees_p = 0;
4722       break;
4723
4724     case TREE_LIST:
4725       WALK_SUBTREE (TREE_PURPOSE (*tp));
4726       break;
4727
4728     case OVERLOAD:
4729       WALK_SUBTREE (OVL_FUNCTION (*tp));
4730       WALK_SUBTREE (OVL_CHAIN (*tp));
4731       *walk_subtrees_p = 0;
4732       break;
4733
4734     case USING_DECL:
4735       WALK_SUBTREE (DECL_NAME (*tp));
4736       WALK_SUBTREE (USING_DECL_SCOPE (*tp));
4737       WALK_SUBTREE (USING_DECL_DECLS (*tp));
4738       *walk_subtrees_p = 0;
4739       break;
4740
4741     case RECORD_TYPE:
4742       if (TYPE_PTRMEMFUNC_P (*tp))
4743         WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE_RAW (*tp));
4744       break;
4745
4746     case TYPE_ARGUMENT_PACK:
4747     case NONTYPE_ARGUMENT_PACK:
4748       {
4749         tree args = ARGUMENT_PACK_ARGS (*tp);
4750         int i, len = TREE_VEC_LENGTH (args);
4751         for (i = 0; i < len; i++)
4752           WALK_SUBTREE (TREE_VEC_ELT (args, i));
4753       }
4754       break;
4755
4756     case TYPE_PACK_EXPANSION:
4757       WALK_SUBTREE (TREE_TYPE (*tp));
4758       WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp));
4759       *walk_subtrees_p = 0;
4760       break;
4761
4762     case EXPR_PACK_EXPANSION:
4763       WALK_SUBTREE (TREE_OPERAND (*tp, 0));
4764       WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp));
4765       *walk_subtrees_p = 0;
4766       break;
4767
4768     case CAST_EXPR:
4769     case REINTERPRET_CAST_EXPR:
4770     case STATIC_CAST_EXPR:
4771     case CONST_CAST_EXPR:
4772     case DYNAMIC_CAST_EXPR:
4773     case IMPLICIT_CONV_EXPR:
4774       if (TREE_TYPE (*tp))
4775         WALK_SUBTREE (TREE_TYPE (*tp));
4776
4777       {
4778         int i;
4779         for (i = 0; i < TREE_CODE_LENGTH (TREE_CODE (*tp)); ++i)
4780           WALK_SUBTREE (TREE_OPERAND (*tp, i));
4781       }
4782       *walk_subtrees_p = 0;
4783       break;
4784
4785     case TRAIT_EXPR:
4786       WALK_SUBTREE (TRAIT_EXPR_TYPE1 (*tp));
4787       WALK_SUBTREE (TRAIT_EXPR_TYPE2 (*tp));
4788       *walk_subtrees_p = 0;
4789       break;
4790
4791     case DECLTYPE_TYPE:
4792       WALK_SUBTREE (DECLTYPE_TYPE_EXPR (*tp));
4793       *walk_subtrees_p = 0;
4794       break;
4795
4796     case REQUIRES_EXPR:
4797       // Only recurse through the nested expression. Do not
4798       // walk the parameter list. Doing so causes false
4799       // positives in the pack expansion checker since the
4800       // requires parameters are introduced as pack expansions.
4801       WALK_SUBTREE (TREE_OPERAND (*tp, 1));
4802       *walk_subtrees_p = 0;
4803       break;
4804
4805     case DECL_EXPR:
4806       /* User variables should be mentioned in BIND_EXPR_VARS
4807          and their initializers and sizes walked when walking
4808          the containing BIND_EXPR.  Compiler temporaries are
4809          handled here.  */
4810       if (VAR_P (TREE_OPERAND (*tp, 0))
4811           && DECL_ARTIFICIAL (TREE_OPERAND (*tp, 0))
4812           && !TREE_STATIC (TREE_OPERAND (*tp, 0)))
4813         {
4814           tree decl = TREE_OPERAND (*tp, 0);
4815           WALK_SUBTREE (DECL_INITIAL (decl));
4816           WALK_SUBTREE (DECL_SIZE (decl));
4817           WALK_SUBTREE (DECL_SIZE_UNIT (decl));
4818         }
4819       break;
4820
4821     default:
4822       return NULL_TREE;
4823     }
4824
4825   /* We didn't find what we were looking for.  */
4826  out:
4827   return result;
4828
4829 #undef WALK_SUBTREE
4830 }
4831
4832 /* Like save_expr, but for C++.  */
4833
4834 tree
4835 cp_save_expr (tree expr)
4836 {
4837   /* There is no reason to create a SAVE_EXPR within a template; if
4838      needed, we can create the SAVE_EXPR when instantiating the
4839      template.  Furthermore, the middle-end cannot handle C++-specific
4840      tree codes.  */
4841   if (processing_template_decl)
4842     return expr;
4843   return save_expr (expr);
4844 }
4845
4846 /* Initialize tree.c.  */
4847
4848 void
4849 init_tree (void)
4850 {
4851   list_hash_table = hash_table<list_hasher>::create_ggc (61);
4852   register_scoped_attributes (std_attribute_table, NULL);
4853 }
4854
4855 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
4856    is.  Note that sfk_none is zero, so this function can be used as a
4857    predicate to test whether or not DECL is a special function.  */
4858
4859 special_function_kind
4860 special_function_p (const_tree decl)
4861 {
4862   /* Rather than doing all this stuff with magic names, we should
4863      probably have a field of type `special_function_kind' in
4864      DECL_LANG_SPECIFIC.  */
4865   if (DECL_INHERITED_CTOR (decl))
4866     return sfk_inheriting_constructor;
4867   if (DECL_COPY_CONSTRUCTOR_P (decl))
4868     return sfk_copy_constructor;
4869   if (DECL_MOVE_CONSTRUCTOR_P (decl))
4870     return sfk_move_constructor;
4871   if (DECL_CONSTRUCTOR_P (decl))
4872     return sfk_constructor;
4873   if (DECL_ASSIGNMENT_OPERATOR_P (decl)
4874       && DECL_OVERLOADED_OPERATOR_IS (decl, NOP_EXPR))
4875     {
4876       if (copy_fn_p (decl))
4877         return sfk_copy_assignment;
4878       if (move_fn_p (decl))
4879         return sfk_move_assignment;
4880     }
4881   if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl))
4882     return sfk_destructor;
4883   if (DECL_COMPLETE_DESTRUCTOR_P (decl))
4884     return sfk_complete_destructor;
4885   if (DECL_BASE_DESTRUCTOR_P (decl))
4886     return sfk_base_destructor;
4887   if (DECL_DELETING_DESTRUCTOR_P (decl))
4888     return sfk_deleting_destructor;
4889   if (DECL_CONV_FN_P (decl))
4890     return sfk_conversion;
4891   if (deduction_guide_p (decl))
4892     return sfk_deduction_guide;
4893
4894   return sfk_none;
4895 }
4896
4897 /* Returns nonzero if TYPE is a character type, including wchar_t.  */
4898
4899 int
4900 char_type_p (tree type)
4901 {
4902   return (same_type_p (type, char_type_node)
4903           || same_type_p (type, unsigned_char_type_node)
4904           || same_type_p (type, signed_char_type_node)
4905           || same_type_p (type, char16_type_node)
4906           || same_type_p (type, char32_type_node)
4907           || same_type_p (type, wchar_type_node));
4908 }
4909
4910 /* Returns the kind of linkage associated with the indicated DECL.  Th
4911    value returned is as specified by the language standard; it is
4912    independent of implementation details regarding template
4913    instantiation, etc.  For example, it is possible that a declaration
4914    to which this function assigns external linkage would not show up
4915    as a global symbol when you run `nm' on the resulting object file.  */
4916
4917 linkage_kind
4918 decl_linkage (tree decl)
4919 {
4920   /* This function doesn't attempt to calculate the linkage from first
4921      principles as given in [basic.link].  Instead, it makes use of
4922      the fact that we have already set TREE_PUBLIC appropriately, and
4923      then handles a few special cases.  Ideally, we would calculate
4924      linkage first, and then transform that into a concrete
4925      implementation.  */
4926
4927   /* Things that don't have names have no linkage.  */
4928   if (!DECL_NAME (decl))
4929     return lk_none;
4930
4931   /* Fields have no linkage.  */
4932   if (TREE_CODE (decl) == FIELD_DECL)
4933     return lk_none;
4934
4935   /* Things that are TREE_PUBLIC have external linkage.  */
4936   if (TREE_PUBLIC (decl))
4937     return lk_external;
4938
4939   /* maybe_thunk_body clears TREE_PUBLIC on the maybe-in-charge 'tor variants,
4940      check one of the "clones" for the real linkage.  */
4941   if ((DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl)
4942        || DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl))
4943       && DECL_CHAIN (decl)
4944       && DECL_CLONED_FUNCTION (DECL_CHAIN (decl)))
4945     return decl_linkage (DECL_CHAIN (decl));
4946
4947   if (TREE_CODE (decl) == NAMESPACE_DECL)
4948     return lk_external;
4949
4950   /* Linkage of a CONST_DECL depends on the linkage of the enumeration
4951      type.  */
4952   if (TREE_CODE (decl) == CONST_DECL)
4953     return decl_linkage (TYPE_NAME (DECL_CONTEXT (decl)));
4954
4955   /* Things in local scope do not have linkage, if they don't have
4956      TREE_PUBLIC set.  */
4957   if (decl_function_context (decl))
4958     return lk_none;
4959
4960   /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
4961      are considered to have external linkage for language purposes, as do
4962      template instantiations on targets without weak symbols.  DECLs really
4963      meant to have internal linkage have DECL_THIS_STATIC set.  */
4964   if (TREE_CODE (decl) == TYPE_DECL)
4965     return lk_external;
4966   if (VAR_OR_FUNCTION_DECL_P (decl))
4967     {
4968       if (!DECL_THIS_STATIC (decl))
4969         return lk_external;
4970
4971       /* Static data members and static member functions from classes
4972          in anonymous namespace also don't have TREE_PUBLIC set.  */
4973       if (DECL_CLASS_CONTEXT (decl))
4974         return lk_external;
4975     }
4976
4977   /* Everything else has internal linkage.  */
4978   return lk_internal;
4979 }
4980
4981 /* Returns the storage duration of the object or reference associated with
4982    the indicated DECL, which should be a VAR_DECL or PARM_DECL.  */
4983
4984 duration_kind
4985 decl_storage_duration (tree decl)
4986 {
4987   if (TREE_CODE (decl) == PARM_DECL)
4988     return dk_auto;
4989   if (TREE_CODE (decl) == FUNCTION_DECL)
4990     return dk_static;
4991   gcc_assert (VAR_P (decl));
4992   if (!TREE_STATIC (decl)
4993       && !DECL_EXTERNAL (decl))
4994     return dk_auto;
4995   if (CP_DECL_THREAD_LOCAL_P (decl))
4996     return dk_thread;
4997   return dk_static;
4998 }
4999 \f
5000 /* EXP is an expression that we want to pre-evaluate.  Returns (in
5001    *INITP) an expression that will perform the pre-evaluation.  The
5002    value returned by this function is a side-effect free expression
5003    equivalent to the pre-evaluated expression.  Callers must ensure
5004    that *INITP is evaluated before EXP.  */
5005
5006 tree
5007 stabilize_expr (tree exp, tree* initp)
5008 {
5009   tree init_expr;
5010
5011   if (!TREE_SIDE_EFFECTS (exp))
5012     init_expr = NULL_TREE;
5013   else if (VOID_TYPE_P (TREE_TYPE (exp)))
5014     {
5015       init_expr = exp;
5016       exp = void_node;
5017     }
5018   /* There are no expressions with REFERENCE_TYPE, but there can be call
5019      arguments with such a type; just treat it as a pointer.  */
5020   else if (TREE_CODE (TREE_TYPE (exp)) == REFERENCE_TYPE
5021            || SCALAR_TYPE_P (TREE_TYPE (exp))
5022            || !glvalue_p (exp))
5023     {
5024       init_expr = get_target_expr (exp);
5025       exp = TARGET_EXPR_SLOT (init_expr);
5026       if (CLASS_TYPE_P (TREE_TYPE (exp)))
5027         exp = move (exp);
5028       else
5029         exp = rvalue (exp);
5030     }
5031   else
5032     {
5033       bool xval = !lvalue_p (exp);
5034       exp = cp_build_addr_expr (exp, tf_warning_or_error);
5035       init_expr = get_target_expr (exp);
5036       exp = TARGET_EXPR_SLOT (init_expr);
5037       exp = cp_build_fold_indirect_ref (exp);
5038       if (xval)
5039         exp = move (exp);
5040     }
5041   *initp = init_expr;
5042
5043   gcc_assert (!TREE_SIDE_EFFECTS (exp));
5044   return exp;
5045 }
5046
5047 /* Add NEW_EXPR, an expression whose value we don't care about, after the
5048    similar expression ORIG.  */
5049
5050 tree
5051 add_stmt_to_compound (tree orig, tree new_expr)
5052 {
5053   if (!new_expr || !TREE_SIDE_EFFECTS (new_expr))
5054     return orig;
5055   if (!orig || !TREE_SIDE_EFFECTS (orig))
5056     return new_expr;
5057   return build2 (COMPOUND_EXPR, void_type_node, orig, new_expr);
5058 }
5059
5060 /* Like stabilize_expr, but for a call whose arguments we want to
5061    pre-evaluate.  CALL is modified in place to use the pre-evaluated
5062    arguments, while, upon return, *INITP contains an expression to
5063    compute the arguments.  */
5064
5065 void
5066 stabilize_call (tree call, tree *initp)
5067 {
5068   tree inits = NULL_TREE;
5069   int i;
5070   int nargs = call_expr_nargs (call);
5071
5072   if (call == error_mark_node || processing_template_decl)
5073     {
5074       *initp = NULL_TREE;
5075       return;
5076     }
5077
5078   gcc_assert (TREE_CODE (call) == CALL_EXPR);
5079
5080   for (i = 0; i < nargs; i++)
5081     {
5082       tree init;
5083       CALL_EXPR_ARG (call, i) =
5084         stabilize_expr (CALL_EXPR_ARG (call, i), &init);
5085       inits = add_stmt_to_compound (inits, init);
5086     }
5087
5088   *initp = inits;
5089 }
5090
5091 /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
5092    to pre-evaluate.  CALL is modified in place to use the pre-evaluated
5093    arguments, while, upon return, *INITP contains an expression to
5094    compute the arguments.  */
5095
5096 static void
5097 stabilize_aggr_init (tree call, tree *initp)
5098 {
5099   tree inits = NULL_TREE;
5100   int i;
5101   int nargs = aggr_init_expr_nargs (call);
5102
5103   if (call == error_mark_node)
5104     return;
5105
5106   gcc_assert (TREE_CODE (call) == AGGR_INIT_EXPR);
5107
5108   for (i = 0; i < nargs; i++)
5109     {
5110       tree init;
5111       AGGR_INIT_EXPR_ARG (call, i) =
5112         stabilize_expr (AGGR_INIT_EXPR_ARG (call, i), &init);
5113       inits = add_stmt_to_compound (inits, init);
5114     }
5115
5116   *initp = inits;
5117 }
5118
5119 /* Like stabilize_expr, but for an initialization.
5120
5121    If the initialization is for an object of class type, this function
5122    takes care not to introduce additional temporaries.
5123
5124    Returns TRUE iff the expression was successfully pre-evaluated,
5125    i.e., if INIT is now side-effect free, except for, possibly, a
5126    single call to a constructor.  */
5127
5128 bool
5129 stabilize_init (tree init, tree *initp)
5130 {
5131   tree t = init;
5132
5133   *initp = NULL_TREE;
5134
5135   if (t == error_mark_node || processing_template_decl)
5136     return true;
5137
5138   if (TREE_CODE (t) == INIT_EXPR)
5139     t = TREE_OPERAND (t, 1);
5140   if (TREE_CODE (t) == TARGET_EXPR)
5141     t = TARGET_EXPR_INITIAL (t);
5142
5143   /* If the RHS can be stabilized without breaking copy elision, stabilize
5144      it.  We specifically don't stabilize class prvalues here because that
5145      would mean an extra copy, but they might be stabilized below.  */
5146   if (TREE_CODE (init) == INIT_EXPR
5147       && TREE_CODE (t) != CONSTRUCTOR
5148       && TREE_CODE (t) != AGGR_INIT_EXPR
5149       && (SCALAR_TYPE_P (TREE_TYPE (t))
5150           || glvalue_p (t)))
5151     {
5152       TREE_OPERAND (init, 1) = stabilize_expr (t, initp);
5153       return true;
5154     }
5155
5156   if (TREE_CODE (t) == COMPOUND_EXPR
5157       && TREE_CODE (init) == INIT_EXPR)
5158     {
5159       tree last = expr_last (t);
5160       /* Handle stabilizing the EMPTY_CLASS_EXPR pattern.  */
5161       if (!TREE_SIDE_EFFECTS (last))
5162         {
5163           *initp = t;
5164           TREE_OPERAND (init, 1) = last;
5165           return true;
5166         }
5167     }
5168
5169   if (TREE_CODE (t) == CONSTRUCTOR)
5170     {
5171       /* Aggregate initialization: stabilize each of the field
5172          initializers.  */
5173       unsigned i;
5174       constructor_elt *ce;
5175       bool good = true;
5176       vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (t);
5177       for (i = 0; vec_safe_iterate (v, i, &ce); ++i)
5178         {
5179           tree type = TREE_TYPE (ce->value);
5180           tree subinit;
5181           if (TREE_CODE (type) == REFERENCE_TYPE
5182               || SCALAR_TYPE_P (type))
5183             ce->value = stabilize_expr (ce->value, &subinit);
5184           else if (!stabilize_init (ce->value, &subinit))
5185             good = false;
5186           *initp = add_stmt_to_compound (*initp, subinit);
5187         }
5188       return good;
5189     }
5190
5191   if (TREE_CODE (t) == CALL_EXPR)
5192     {
5193       stabilize_call (t, initp);
5194       return true;
5195     }
5196
5197   if (TREE_CODE (t) == AGGR_INIT_EXPR)
5198     {
5199       stabilize_aggr_init (t, initp);
5200       return true;
5201     }
5202
5203   /* The initialization is being performed via a bitwise copy -- and
5204      the item copied may have side effects.  */
5205   return !TREE_SIDE_EFFECTS (init);
5206 }
5207
5208 /* Returns true if a cast to TYPE may appear in an integral constant
5209    expression.  */
5210
5211 bool
5212 cast_valid_in_integral_constant_expression_p (tree type)
5213 {
5214   return (INTEGRAL_OR_ENUMERATION_TYPE_P (type)
5215           || cxx_dialect >= cxx11
5216           || dependent_type_p (type)
5217           || type == error_mark_node);
5218 }
5219
5220 /* Return true if we need to fix linkage information of DECL.  */
5221
5222 static bool
5223 cp_fix_function_decl_p (tree decl)
5224 {
5225   /* Skip if DECL is not externally visible.  */
5226   if (!TREE_PUBLIC (decl))
5227     return false;
5228
5229   /* We need to fix DECL if it a appears to be exported but with no
5230      function body.  Thunks do not have CFGs and we may need to
5231      handle them specially later.   */
5232   if (!gimple_has_body_p (decl)
5233       && !DECL_THUNK_P (decl)
5234       && !DECL_EXTERNAL (decl))
5235     {
5236       struct cgraph_node *node = cgraph_node::get (decl);
5237
5238       /* Don't fix same_body aliases.  Although they don't have their own
5239          CFG, they share it with what they alias to.  */
5240       if (!node || !node->alias
5241           || !vec_safe_length (node->ref_list.references))
5242         return true;
5243     }
5244
5245   return false;
5246 }
5247
5248 /* Clean the C++ specific parts of the tree T. */
5249
5250 void
5251 cp_free_lang_data (tree t)
5252 {
5253   if (TREE_CODE (t) == METHOD_TYPE
5254       || TREE_CODE (t) == FUNCTION_TYPE)
5255     {
5256       /* Default args are not interesting anymore.  */
5257       tree argtypes = TYPE_ARG_TYPES (t);
5258       while (argtypes)
5259         {
5260           TREE_PURPOSE (argtypes) = 0;
5261           argtypes = TREE_CHAIN (argtypes);
5262         }
5263     }
5264   else if (TREE_CODE (t) == FUNCTION_DECL
5265            && cp_fix_function_decl_p (t))
5266     {
5267       /* If T is used in this translation unit at all,  the definition
5268          must exist somewhere else since we have decided to not emit it
5269          in this TU.  So make it an external reference.  */
5270       DECL_EXTERNAL (t) = 1;
5271       TREE_STATIC (t) = 0;
5272     }
5273   if (TREE_CODE (t) == NAMESPACE_DECL)
5274     /* We do not need the leftover chaining of namespaces from the
5275        binding level.  */
5276     DECL_CHAIN (t) = NULL_TREE;
5277   /* Set DECL_VALUE_EXPRs of OpenMP privatized member artificial
5278      decls to error_mark_node.  These are DECL_IGNORED_P and after
5279      OpenMP lowering they aren't useful anymore.  Clearing DECL_VALUE_EXPR
5280      doesn't work, as expansion could then consider them as something
5281      to be expanded.  */
5282   if (VAR_P (t)
5283       && DECL_LANG_SPECIFIC (t)
5284       && DECL_OMP_PRIVATIZED_MEMBER (t)
5285       && DECL_IGNORED_P (t))
5286     SET_DECL_VALUE_EXPR (t, error_mark_node);
5287 }
5288
5289 /* Stub for c-common.  Please keep in sync with c-decl.c.
5290    FIXME: If address space support is target specific, then this
5291    should be a C target hook.  But currently this is not possible,
5292    because this function is called via REGISTER_TARGET_PRAGMAS.  */
5293 void
5294 c_register_addr_space (const char * /*word*/, addr_space_t /*as*/)
5295 {
5296 }
5297
5298 /* Return the number of operands in T that we care about for things like
5299    mangling.  */
5300
5301 int
5302 cp_tree_operand_length (const_tree t)
5303 {
5304   enum tree_code code = TREE_CODE (t);
5305
5306   if (TREE_CODE_CLASS (code) == tcc_vl_exp)
5307     return VL_EXP_OPERAND_LENGTH (t);
5308
5309   return cp_tree_code_length (code);
5310 }
5311
5312 /* Like cp_tree_operand_length, but takes a tree_code CODE.  */
5313
5314 int
5315 cp_tree_code_length (enum tree_code code)
5316 {
5317   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
5318
5319   switch (code)
5320     {
5321     case PREINCREMENT_EXPR:
5322     case PREDECREMENT_EXPR:
5323     case POSTINCREMENT_EXPR:
5324     case POSTDECREMENT_EXPR:
5325       return 1;
5326
5327     case ARRAY_REF:
5328       return 2;
5329
5330     case EXPR_PACK_EXPANSION:
5331       return 1;
5332
5333     default:
5334       return TREE_CODE_LENGTH (code);
5335     }
5336 }
5337
5338 /* Implement -Wzero_as_null_pointer_constant.  Return true if the
5339    conditions for the warning hold, false otherwise.  */
5340 bool
5341 maybe_warn_zero_as_null_pointer_constant (tree expr, location_t loc)
5342 {
5343   if (c_inhibit_evaluation_warnings == 0
5344       && !NULLPTR_TYPE_P (TREE_TYPE (expr)))
5345     {
5346       warning_at (loc, OPT_Wzero_as_null_pointer_constant,
5347                   "zero as null pointer constant");
5348       return true;
5349     }
5350   return false;
5351 }
5352 \f
5353 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
5354 /* Complain that some language-specific thing hanging off a tree
5355    node has been accessed improperly.  */
5356
5357 void
5358 lang_check_failed (const char* file, int line, const char* function)
5359 {
5360   internal_error ("lang_* check: failed in %s, at %s:%d",
5361                   function, trim_filename (file), line);
5362 }
5363 #endif /* ENABLE_TREE_CHECKING */
5364
5365 #if CHECKING_P
5366
5367 namespace selftest {
5368
5369 /* Verify that lvalue_kind () works, for various expressions,
5370    and that location wrappers don't affect the results.  */
5371
5372 static void
5373 test_lvalue_kind ()
5374 {
5375   location_t loc = BUILTINS_LOCATION;
5376
5377   /* Verify constants and parameters, without and with
5378      location wrappers.  */
5379   tree int_cst = build_int_cst (integer_type_node, 42);
5380   ASSERT_EQ (clk_none, lvalue_kind (int_cst));
5381
5382   tree wrapped_int_cst = maybe_wrap_with_location (int_cst, loc);
5383   ASSERT_TRUE (location_wrapper_p (wrapped_int_cst));
5384   ASSERT_EQ (clk_none, lvalue_kind (wrapped_int_cst));
5385
5386   tree string_lit = build_string (4, "foo");
5387   TREE_TYPE (string_lit) = char_array_type_node;
5388   string_lit = fix_string_type (string_lit);
5389   ASSERT_EQ (clk_ordinary, lvalue_kind (string_lit));
5390
5391   tree wrapped_string_lit = maybe_wrap_with_location (string_lit, loc);
5392   ASSERT_TRUE (location_wrapper_p (wrapped_string_lit));
5393   ASSERT_EQ (clk_ordinary, lvalue_kind (wrapped_string_lit));
5394
5395   tree parm = build_decl (UNKNOWN_LOCATION, PARM_DECL,
5396                           get_identifier ("some_parm"),
5397                           integer_type_node);
5398   ASSERT_EQ (clk_ordinary, lvalue_kind (parm));
5399
5400   tree wrapped_parm = maybe_wrap_with_location (parm, loc);
5401   ASSERT_TRUE (location_wrapper_p (wrapped_parm));
5402   ASSERT_EQ (clk_ordinary, lvalue_kind (wrapped_parm));
5403
5404   /* Verify that lvalue_kind of std::move on a parm isn't
5405      affected by location wrappers.  */
5406   tree rvalue_ref_of_parm = move (parm);
5407   ASSERT_EQ (clk_rvalueref, lvalue_kind (rvalue_ref_of_parm));
5408   tree rvalue_ref_of_wrapped_parm = move (wrapped_parm);
5409   ASSERT_EQ (clk_rvalueref, lvalue_kind (rvalue_ref_of_wrapped_parm));
5410 }
5411
5412 /* Run all of the selftests within this file.  */
5413
5414 void
5415 cp_tree_c_tests ()
5416 {
5417   test_lvalue_kind ();
5418 }
5419
5420 } // namespace selftest
5421
5422 #endif /* #if CHECKING_P */
5423
5424
5425 #include "gt-cp-tree.h"