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