gcc/cp/tree.c

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