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