gcc/cp/tree.c

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