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