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);
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   switch (code1)
3498     {
3499     case VOID_CST:
3500       /* There's only a single VOID_CST node, so we should never reach
3501          here.  */
3502       gcc_unreachable ();
3503
3504     case INTEGER_CST:
3505       return tree_int_cst_equal (t1, t2);
3506
3507     case REAL_CST:
3508       return real_equal (&TREE_REAL_CST (t1), &TREE_REAL_CST (t2));
3509
3510     case STRING_CST:
3511       return TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
3512         && !memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
3513                     TREE_STRING_LENGTH (t1));
3514
3515     case FIXED_CST:
3516       return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1),
3517                                      TREE_FIXED_CST (t2));
3518
3519     case COMPLEX_CST:
3520       return cp_tree_equal (TREE_REALPART (t1), TREE_REALPART (t2))
3521         && cp_tree_equal (TREE_IMAGPART (t1), TREE_IMAGPART (t2));
3522
3523     case VECTOR_CST:
3524       return operand_equal_p (t1, t2, OEP_ONLY_CONST);
3525
3526     case CONSTRUCTOR:
3527       /* We need to do this when determining whether or not two
3528          non-type pointer to member function template arguments
3529          are the same.  */
3530       if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
3531           || CONSTRUCTOR_NELTS (t1) != CONSTRUCTOR_NELTS (t2))
3532         return false;
3533       {
3534         tree field, value;
3535         unsigned int i;
3536         FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1), i, field, value)
3537           {
3538             constructor_elt *elt2 = CONSTRUCTOR_ELT (t2, i);
3539             if (!cp_tree_equal (field, elt2->index)
3540                 || !cp_tree_equal (value, elt2->value))
3541               return false;
3542           }
3543       }
3544       return true;
3545
3546     case TREE_LIST:
3547       if (!cp_tree_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2)))
3548         return false;
3549       if (!cp_tree_equal (TREE_VALUE (t1), TREE_VALUE (t2)))
3550         return false;
3551       return cp_tree_equal (TREE_CHAIN (t1), TREE_CHAIN (t2));
3552
3553     case SAVE_EXPR:
3554       return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3555
3556     case CALL_EXPR:
3557       {
3558         tree arg1, arg2;
3559         call_expr_arg_iterator iter1, iter2;
3560         if (!called_fns_equal (CALL_EXPR_FN (t1), CALL_EXPR_FN (t2)))
3561           return false;
3562         for (arg1 = first_call_expr_arg (t1, &iter1),
3563                arg2 = first_call_expr_arg (t2, &iter2);
3564              arg1 && arg2;
3565              arg1 = next_call_expr_arg (&iter1),
3566                arg2 = next_call_expr_arg (&iter2))
3567           if (!cp_tree_equal (arg1, arg2))
3568             return false;
3569         if (arg1 || arg2)
3570           return false;
3571         return true;
3572       }
3573
3574     case TARGET_EXPR:
3575       {
3576         tree o1 = TREE_OPERAND (t1, 0);
3577         tree o2 = TREE_OPERAND (t2, 0);
3578
3579         /* Special case: if either target is an unallocated VAR_DECL,
3580            it means that it's going to be unified with whatever the
3581            TARGET_EXPR is really supposed to initialize, so treat it
3582            as being equivalent to anything.  */
3583         if (VAR_P (o1) && DECL_NAME (o1) == NULL_TREE
3584             && !DECL_RTL_SET_P (o1))
3585           /*Nop*/;
3586         else if (VAR_P (o2) && DECL_NAME (o2) == NULL_TREE
3587                  && !DECL_RTL_SET_P (o2))
3588           /*Nop*/;
3589         else if (!cp_tree_equal (o1, o2))
3590           return false;
3591
3592         return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
3593       }
3594
3595     case PARM_DECL:
3596       /* For comparing uses of parameters in late-specified return types
3597          with an out-of-class definition of the function, but can also come
3598          up for expressions that involve 'this' in a member function
3599          template.  */
3600
3601       if (comparing_specializations && !CONSTRAINT_VAR_P (t1))
3602         /* When comparing hash table entries, only an exact match is
3603            good enough; we don't want to replace 'this' with the
3604            version from another function.  But be more flexible
3605            with local parameters in a requires-expression.  */
3606         return false;
3607
3608       if (same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
3609         {
3610           if (DECL_ARTIFICIAL (t1) ^ DECL_ARTIFICIAL (t2))
3611             return false;
3612           if (CONSTRAINT_VAR_P (t1) ^ CONSTRAINT_VAR_P (t2))
3613             return false;
3614           if (DECL_ARTIFICIAL (t1)
3615               || (DECL_PARM_LEVEL (t1) == DECL_PARM_LEVEL (t2)
3616                   && DECL_PARM_INDEX (t1) == DECL_PARM_INDEX (t2)))
3617             return true;
3618         }
3619       return false;
3620
3621     case VAR_DECL:
3622     case CONST_DECL:
3623     case FIELD_DECL:
3624     case FUNCTION_DECL:
3625     case TEMPLATE_DECL:
3626     case IDENTIFIER_NODE:
3627     case SSA_NAME:
3628       return false;
3629
3630     case BASELINK:
3631       return (BASELINK_BINFO (t1) == BASELINK_BINFO (t2)
3632               && BASELINK_ACCESS_BINFO (t1) == BASELINK_ACCESS_BINFO (t2)
3633               && BASELINK_QUALIFIED_P (t1) == BASELINK_QUALIFIED_P (t2)
3634               && cp_tree_equal (BASELINK_FUNCTIONS (t1),
3635                                 BASELINK_FUNCTIONS (t2)));
3636
3637     case TEMPLATE_PARM_INDEX:
3638       return (TEMPLATE_PARM_IDX (t1) == TEMPLATE_PARM_IDX (t2)
3639               && TEMPLATE_PARM_LEVEL (t1) == TEMPLATE_PARM_LEVEL (t2)
3640               && (TEMPLATE_PARM_PARAMETER_PACK (t1)
3641                   == TEMPLATE_PARM_PARAMETER_PACK (t2))
3642               && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1)),
3643                               TREE_TYPE (TEMPLATE_PARM_DECL (t2))));
3644
3645     case TEMPLATE_ID_EXPR:
3646       return (cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0))
3647               && cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1)));
3648
3649     case CONSTRAINT_INFO:
3650       return cp_tree_equal (CI_ASSOCIATED_CONSTRAINTS (t1),
3651                             CI_ASSOCIATED_CONSTRAINTS (t2));
3652
3653     case CHECK_CONSTR:
3654       return (CHECK_CONSTR_CONCEPT (t1) == CHECK_CONSTR_CONCEPT (t2)
3655               && comp_template_args (CHECK_CONSTR_ARGS (t1),
3656                                      CHECK_CONSTR_ARGS (t2)));
3657
3658     case TREE_VEC:
3659       {
3660         unsigned ix;
3661         if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2))
3662           return false;
3663         for (ix = TREE_VEC_LENGTH (t1); ix--;)
3664           if (!cp_tree_equal (TREE_VEC_ELT (t1, ix),
3665                               TREE_VEC_ELT (t2, ix)))
3666             return false;
3667         return true;
3668       }
3669
3670     case SIZEOF_EXPR:
3671     case ALIGNOF_EXPR:
3672       {
3673         tree o1 = TREE_OPERAND (t1, 0);
3674         tree o2 = TREE_OPERAND (t2, 0);
3675
3676         if (code1 == SIZEOF_EXPR)
3677           {
3678             if (SIZEOF_EXPR_TYPE_P (t1))
3679               o1 = TREE_TYPE (o1);
3680             if (SIZEOF_EXPR_TYPE_P (t2))
3681               o2 = TREE_TYPE (o2);
3682           }
3683         if (TREE_CODE (o1) != TREE_CODE (o2))
3684           return false;
3685         if (TYPE_P (o1))
3686           return same_type_p (o1, o2);
3687         else
3688           return cp_tree_equal (o1, o2);
3689       }
3690
3691     case MODOP_EXPR:
3692       {
3693         tree t1_op1, t2_op1;
3694
3695         if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
3696           return false;
3697
3698         t1_op1 = TREE_OPERAND (t1, 1);
3699         t2_op1 = TREE_OPERAND (t2, 1);
3700         if (TREE_CODE (t1_op1) != TREE_CODE (t2_op1))
3701           return false;
3702
3703         return cp_tree_equal (TREE_OPERAND (t1, 2), TREE_OPERAND (t2, 2));
3704       }
3705
3706     case PTRMEM_CST:
3707       /* Two pointer-to-members are the same if they point to the same
3708          field or function in the same class.  */
3709       if (PTRMEM_CST_MEMBER (t1) != PTRMEM_CST_MEMBER (t2))
3710         return false;
3711
3712       return same_type_p (PTRMEM_CST_CLASS (t1), PTRMEM_CST_CLASS (t2));
3713
3714     case OVERLOAD:
3715       {
3716         /* Two overloads. Must be exactly the same set of decls.  */
3717         lkp_iterator first (t1);
3718         lkp_iterator second (t2);
3719
3720         for (; first && second; ++first, ++second)
3721           if (*first != *second)
3722             return false;
3723         return !(first || second);
3724       }
3725
3726     case TRAIT_EXPR:
3727       if (TRAIT_EXPR_KIND (t1) != TRAIT_EXPR_KIND (t2))
3728         return false;
3729       return same_type_p (TRAIT_EXPR_TYPE1 (t1), TRAIT_EXPR_TYPE1 (t2))
3730         && cp_tree_equal (TRAIT_EXPR_TYPE2 (t1), TRAIT_EXPR_TYPE2 (t2));
3731
3732     case CAST_EXPR:
3733     case STATIC_CAST_EXPR:
3734     case REINTERPRET_CAST_EXPR:
3735     case CONST_CAST_EXPR:
3736     case DYNAMIC_CAST_EXPR:
3737     case IMPLICIT_CONV_EXPR:
3738     case NEW_EXPR:
3739     CASE_CONVERT:
3740     case NON_LVALUE_EXPR:
3741     case VIEW_CONVERT_EXPR:
3742       if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
3743         return false;
3744       /* Now compare operands as usual.  */
3745       break;
3746
3747     case DEFERRED_NOEXCEPT:
3748       return (cp_tree_equal (DEFERRED_NOEXCEPT_PATTERN (t1),
3749                              DEFERRED_NOEXCEPT_PATTERN (t2))
3750               && comp_template_args (DEFERRED_NOEXCEPT_ARGS (t1),
3751                                      DEFERRED_NOEXCEPT_ARGS (t2)));
3752       break;
3753
3754     default:
3755       break;
3756     }
3757
3758   switch (TREE_CODE_CLASS (code1))
3759     {
3760     case tcc_unary:
3761     case tcc_binary:
3762     case tcc_comparison:
3763     case tcc_expression:
3764     case tcc_vl_exp:
3765     case tcc_reference:
3766     case tcc_statement:
3767       {
3768         int i, n;
3769
3770         n = cp_tree_operand_length (t1);
3771         if (TREE_CODE_CLASS (code1) == tcc_vl_exp
3772             && n != TREE_OPERAND_LENGTH (t2))
3773           return false;
3774
3775         for (i = 0; i < n; ++i)
3776           if (!cp_tree_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i)))
3777             return false;
3778
3779         return true;
3780       }
3781
3782     case tcc_type:
3783       return same_type_p (t1, t2);
3784     default:
3785       gcc_unreachable ();
3786     }
3787   /* We can get here with --disable-checking.  */
3788   return false;
3789 }
3790
3791 /* The type of ARG when used as an lvalue.  */
3792
3793 tree
3794 lvalue_type (tree arg)
3795 {
3796   tree type = TREE_TYPE (arg);
3797   return type;
3798 }
3799
3800 /* The type of ARG for printing error messages; denote lvalues with
3801    reference types.  */
3802
3803 tree
3804 error_type (tree arg)
3805 {
3806   tree type = TREE_TYPE (arg);
3807
3808   if (TREE_CODE (type) == ARRAY_TYPE)
3809     ;
3810   else if (TREE_CODE (type) == ERROR_MARK)
3811     ;
3812   else if (lvalue_p (arg))
3813     type = build_reference_type (lvalue_type (arg));
3814   else if (MAYBE_CLASS_TYPE_P (type))
3815     type = lvalue_type (arg);
3816
3817   return type;
3818 }
3819
3820 /* Does FUNCTION use a variable-length argument list?  */
3821
3822 int
3823 varargs_function_p (const_tree function)
3824 {
3825   return stdarg_p (TREE_TYPE (function));
3826 }
3827
3828 /* Returns 1 if decl is a member of a class.  */
3829
3830 int
3831 member_p (const_tree decl)
3832 {
3833   const_tree const ctx = DECL_CONTEXT (decl);
3834   return (ctx && TYPE_P (ctx));
3835 }
3836
3837 /* Create a placeholder for member access where we don't actually have an
3838    object that the access is against.  */
3839
3840 tree
3841 build_dummy_object (tree type)
3842 {
3843   tree decl = build1 (CONVERT_EXPR, build_pointer_type (type), void_node);
3844   return cp_build_indirect_ref (decl, RO_NULL, tf_warning_or_error);
3845 }
3846
3847 /* We've gotten a reference to a member of TYPE.  Return *this if appropriate,
3848    or a dummy object otherwise.  If BINFOP is non-0, it is filled with the
3849    binfo path from current_class_type to TYPE, or 0.  */
3850
3851 tree
3852 maybe_dummy_object (tree type, tree* binfop)
3853 {
3854   tree decl, context;
3855   tree binfo;
3856   tree current = current_nonlambda_class_type ();
3857
3858   if (current
3859       && (binfo = lookup_base (current, type, ba_any, NULL,
3860                                tf_warning_or_error)))
3861     context = current;
3862   else
3863     {
3864       /* Reference from a nested class member function.  */
3865       context = type;
3866       binfo = TYPE_BINFO (type);
3867     }
3868
3869   if (binfop)
3870     *binfop = binfo;
3871
3872   if (current_class_ref
3873       /* current_class_ref might not correspond to current_class_type if
3874          we're in tsubst_default_argument or a lambda-declarator; in either
3875          case, we want to use current_class_ref if it matches CONTEXT.  */
3876       && (same_type_ignoring_top_level_qualifiers_p
3877           (TREE_TYPE (current_class_ref), context)))
3878     decl = current_class_ref;
3879   else
3880     decl = build_dummy_object (context);
3881
3882   return decl;
3883 }
3884
3885 /* Returns 1 if OB is a placeholder object, or a pointer to one.  */
3886
3887 int
3888 is_dummy_object (const_tree ob)
3889 {
3890   if (INDIRECT_REF_P (ob))
3891     ob = TREE_OPERAND (ob, 0);
3892   return (TREE_CODE (ob) == CONVERT_EXPR
3893           && TREE_OPERAND (ob, 0) == void_node);
3894 }
3895
3896 /* Returns 1 iff type T is something we want to treat as a scalar type for
3897    the purpose of deciding whether it is trivial/POD/standard-layout.  */
3898
3899 bool
3900 scalarish_type_p (const_tree t)
3901 {
3902   if (t == error_mark_node)
3903     return 1;
3904
3905   return (SCALAR_TYPE_P (t) || VECTOR_TYPE_P (t));
3906 }
3907
3908 /* Returns true iff T requires non-trivial default initialization.  */
3909
3910 bool
3911 type_has_nontrivial_default_init (const_tree t)
3912 {
3913   t = strip_array_types (CONST_CAST_TREE (t));
3914
3915   if (CLASS_TYPE_P (t))
3916     return TYPE_HAS_COMPLEX_DFLT (t);
3917   else
3918     return 0;
3919 }
3920
3921 /* Track classes with only deleted copy/move constructors so that we can warn
3922    if they are used in call/return by value.  */
3923
3924 static GTY(()) hash_set<tree>* deleted_copy_types;
3925 static void
3926 remember_deleted_copy (const_tree t)
3927 {
3928   if (!deleted_copy_types)
3929     deleted_copy_types = hash_set<tree>::create_ggc(37);
3930   deleted_copy_types->add (CONST_CAST_TREE (t));
3931 }
3932 void
3933 maybe_warn_parm_abi (tree t, location_t loc)
3934 {
3935   if (!deleted_copy_types
3936       || !deleted_copy_types->contains (t))
3937     return;
3938
3939   warning_at (loc, OPT_Wabi, "the calling convention for %qT changes in "
3940               "-fabi-version=12 (GCC 8)", t);
3941   static bool explained = false;
3942   if (!explained)
3943     {
3944       inform (loc, " because all of its copy and move constructors "
3945               "are deleted");
3946       explained = true;
3947     }
3948 }
3949
3950 /* Returns true iff copying an object of type T (including via move
3951    constructor) is non-trivial.  That is, T has no non-trivial copy
3952    constructors and no non-trivial move constructors, and not all copy/move
3953    constructors are deleted.  This function implements the ABI notion of
3954    non-trivial copy, which has diverged from the one in the standard.  */
3955
3956 bool
3957 type_has_nontrivial_copy_init (const_tree type)
3958 {
3959   tree t = strip_array_types (CONST_CAST_TREE (type));
3960
3961   if (CLASS_TYPE_P (t))
3962     {
3963       gcc_assert (COMPLETE_TYPE_P (t));
3964
3965       if (TYPE_HAS_COMPLEX_COPY_CTOR (t)
3966           || TYPE_HAS_COMPLEX_MOVE_CTOR (t))
3967         /* Nontrivial.  */
3968         return true;
3969
3970       if (cxx_dialect < cxx11)
3971         /* No deleted functions before C++11.  */
3972         return false;
3973
3974       /* Before ABI v12 we did a bitwise copy of types with only deleted
3975          copy/move constructors.  */
3976       if (!abi_version_at_least (12)
3977           && !(warn_abi && abi_version_crosses (12)))
3978         return false;
3979
3980       bool saw_copy = false;
3981       bool saw_non_deleted = false;
3982
3983       if (CLASSTYPE_LAZY_MOVE_CTOR (t))
3984         saw_copy = saw_non_deleted = true;
3985       else if (CLASSTYPE_LAZY_COPY_CTOR (t))
3986         {
3987           saw_copy = true;
3988           if (classtype_has_move_assign_or_move_ctor_p (t, true))
3989             /* [class.copy]/8 If the class definition declares a move
3990                constructor or move assignment operator, the implicitly declared
3991                copy constructor is defined as deleted.... */;
3992           else
3993             /* Any other reason the implicitly-declared function would be
3994                deleted would also cause TYPE_HAS_COMPLEX_COPY_CTOR to be
3995                set.  */
3996             saw_non_deleted = true;
3997         }
3998
3999       if (!saw_non_deleted)
4000         for (ovl_iterator iter (CLASSTYPE_CONSTRUCTORS (t)); iter; ++iter)
4001           {
4002             tree fn = *iter;
4003             if (copy_fn_p (fn))
4004               {
4005                 saw_copy = true;
4006                 if (!DECL_DELETED_FN (fn))
4007                   {
4008                     /* Not deleted, therefore trivial.  */
4009                     saw_non_deleted = true;
4010                     break;
4011                   }
4012               }
4013           }
4014
4015       gcc_assert (saw_copy);
4016
4017       if (saw_copy && !saw_non_deleted)
4018         {
4019           if (warn_abi && abi_version_crosses (12))
4020             remember_deleted_copy (t);
4021           if (abi_version_at_least (12))
4022             return true;
4023         }
4024
4025       return false;
4026     }
4027   else
4028     return 0;
4029 }
4030
4031 /* Returns 1 iff type T is a trivially copyable type, as defined in
4032    [basic.types] and [class].  */
4033
4034 bool
4035 trivially_copyable_p (const_tree t)
4036 {
4037   t = strip_array_types (CONST_CAST_TREE (t));
4038
4039   if (CLASS_TYPE_P (t))
4040     return ((!TYPE_HAS_COPY_CTOR (t)
4041              || !TYPE_HAS_COMPLEX_COPY_CTOR (t))
4042             && !TYPE_HAS_COMPLEX_MOVE_CTOR (t)
4043             && (!TYPE_HAS_COPY_ASSIGN (t)
4044                 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (t))
4045             && !TYPE_HAS_COMPLEX_MOVE_ASSIGN (t)
4046             && TYPE_HAS_TRIVIAL_DESTRUCTOR (t));
4047   else
4048     return !CP_TYPE_VOLATILE_P (t) && scalarish_type_p (t);
4049 }
4050
4051 /* Returns 1 iff type T is a trivial type, as defined in [basic.types] and
4052    [class].  */
4053
4054 bool
4055 trivial_type_p (const_tree t)
4056 {
4057   t = strip_array_types (CONST_CAST_TREE (t));
4058
4059   if (CLASS_TYPE_P (t))
4060     return (TYPE_HAS_TRIVIAL_DFLT (t)
4061             && trivially_copyable_p (t));
4062   else
4063     return scalarish_type_p (t);
4064 }
4065
4066 /* Returns 1 iff type T is a POD type, as defined in [basic.types].  */
4067
4068 bool
4069 pod_type_p (const_tree t)
4070 {
4071   /* This CONST_CAST is okay because strip_array_types returns its
4072      argument unmodified and we assign it to a const_tree.  */
4073   t = strip_array_types (CONST_CAST_TREE(t));
4074
4075   if (!CLASS_TYPE_P (t))
4076     return scalarish_type_p (t);
4077   else if (cxx_dialect > cxx98)
4078     /* [class]/10: A POD struct is a class that is both a trivial class and a
4079        standard-layout class, and has no non-static data members of type
4080        non-POD struct, non-POD union (or array of such types).
4081
4082        We don't need to check individual members because if a member is
4083        non-std-layout or non-trivial, the class will be too.  */
4084     return (std_layout_type_p (t) && trivial_type_p (t));
4085   else
4086     /* The C++98 definition of POD is different.  */
4087     return !CLASSTYPE_NON_LAYOUT_POD_P (t);
4088 }
4089
4090 /* Returns true iff T is POD for the purpose of layout, as defined in the
4091    C++ ABI.  */
4092
4093 bool
4094 layout_pod_type_p (const_tree t)
4095 {
4096   t = strip_array_types (CONST_CAST_TREE (t));
4097
4098   if (CLASS_TYPE_P (t))
4099     return !CLASSTYPE_NON_LAYOUT_POD_P (t);
4100   else
4101     return scalarish_type_p (t);
4102 }
4103
4104 /* Returns true iff T is a standard-layout type, as defined in
4105    [basic.types].  */
4106
4107 bool
4108 std_layout_type_p (const_tree t)
4109 {
4110   t = strip_array_types (CONST_CAST_TREE (t));
4111
4112   if (CLASS_TYPE_P (t))
4113     return !CLASSTYPE_NON_STD_LAYOUT (t);
4114   else
4115     return scalarish_type_p (t);
4116 }
4117
4118 static bool record_has_unique_obj_representations (const_tree, const_tree);
4119
4120 /* Returns true iff T satisfies std::has_unique_object_representations<T>,
4121    as defined in [meta.unary.prop].  */
4122
4123 bool
4124 type_has_unique_obj_representations (const_tree t)
4125 {
4126   bool ret;
4127
4128   t = strip_array_types (CONST_CAST_TREE (t));
4129
4130   if (!trivially_copyable_p (t))
4131     return false;
4132
4133   if (CLASS_TYPE_P (t) && CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t))
4134     return CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t);
4135
4136   switch (TREE_CODE (t))
4137     {
4138     case INTEGER_TYPE:
4139     case POINTER_TYPE:
4140     case REFERENCE_TYPE:
4141       /* If some backend has any paddings in these types, we should add
4142          a target hook for this and handle it there.  */
4143       return true;
4144
4145     case BOOLEAN_TYPE:
4146       /* For bool values other than 0 and 1 should only appear with
4147          undefined behavior.  */
4148       return true;
4149
4150     case ENUMERAL_TYPE:
4151       return type_has_unique_obj_representations (ENUM_UNDERLYING_TYPE (t));
4152
4153     case REAL_TYPE:
4154       /* XFmode certainly contains padding on x86, which the CPU doesn't store
4155          when storing long double values, so for that we have to return false.
4156          Other kinds of floating point values are questionable due to +.0/-.0
4157          and NaNs, let's play safe for now.  */
4158       return false;
4159
4160     case FIXED_POINT_TYPE:
4161       return false;
4162
4163     case OFFSET_TYPE:
4164       return true;
4165
4166     case COMPLEX_TYPE:
4167     case VECTOR_TYPE:
4168       return type_has_unique_obj_representations (TREE_TYPE (t));
4169
4170     case RECORD_TYPE:
4171       ret = record_has_unique_obj_representations (t, TYPE_SIZE (t));
4172       if (CLASS_TYPE_P (t))
4173         {
4174           CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t) = 1;
4175           CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t) = ret;
4176         }
4177       return ret;
4178
4179     case UNION_TYPE:
4180       ret = true;
4181       bool any_fields;
4182       any_fields = false;
4183       for (tree field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field))
4184         if (TREE_CODE (field) == FIELD_DECL)
4185           {
4186             any_fields = true;
4187             if (!type_has_unique_obj_representations (TREE_TYPE (field))
4188                 || simple_cst_equal (DECL_SIZE (field), TYPE_SIZE (t)) != 1)
4189               {
4190                 ret = false;
4191                 break;
4192               }
4193           }
4194       if (!any_fields && !integer_zerop (TYPE_SIZE (t)))
4195         ret = false;
4196       if (CLASS_TYPE_P (t))
4197         {
4198           CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t) = 1;
4199           CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t) = ret;
4200         }
4201       return ret;
4202
4203     case NULLPTR_TYPE:
4204       return false;
4205
4206     case ERROR_MARK:
4207       return false;
4208
4209     default:
4210       gcc_unreachable ();
4211     }
4212 }
4213
4214 /* Helper function for type_has_unique_obj_representations.  */
4215
4216 static bool
4217 record_has_unique_obj_representations (const_tree t, const_tree sz)
4218 {
4219   for (tree field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field))
4220     if (TREE_CODE (field) != FIELD_DECL)
4221       ;
4222     /* For bases, can't use type_has_unique_obj_representations here, as in
4223         struct S { int i : 24; S (); };
4224         struct T : public S { int j : 8; T (); };
4225         S doesn't have unique obj representations, but T does.  */
4226     else if (DECL_FIELD_IS_BASE (field))
4227       {
4228         if (!record_has_unique_obj_representations (TREE_TYPE (field),
4229                                                     DECL_SIZE (field)))
4230           return false;
4231       }
4232     else if (DECL_C_BIT_FIELD (field))
4233       {
4234         tree btype = DECL_BIT_FIELD_TYPE (field);
4235         if (!type_has_unique_obj_representations (btype))
4236           return false;
4237       }
4238     else if (!type_has_unique_obj_representations (TREE_TYPE (field)))
4239       return false;
4240
4241   offset_int cur = 0;
4242   for (tree field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field))
4243     if (TREE_CODE (field) == FIELD_DECL)
4244       {
4245         offset_int fld = wi::to_offset (DECL_FIELD_OFFSET (field));
4246         offset_int bitpos = wi::to_offset (DECL_FIELD_BIT_OFFSET (field));
4247         fld = fld * BITS_PER_UNIT + bitpos;
4248         if (cur != fld)
4249           return false;
4250         if (DECL_SIZE (field))
4251           {
4252             offset_int size = wi::to_offset (DECL_SIZE (field));
4253             cur += size;
4254           }
4255       }
4256   if (cur != wi::to_offset (sz))
4257     return false;
4258
4259   return true;
4260 }
4261
4262 /* Nonzero iff type T is a class template implicit specialization.  */
4263
4264 bool
4265 class_tmpl_impl_spec_p (const_tree t)
4266 {
4267   return CLASS_TYPE_P (t) && CLASSTYPE_TEMPLATE_INSTANTIATION (t);
4268 }
4269
4270 /* Returns 1 iff zero initialization of type T means actually storing
4271    zeros in it.  */
4272
4273 int
4274 zero_init_p (const_tree t)
4275 {
4276   /* This CONST_CAST is okay because strip_array_types returns its
4277      argument unmodified and we assign it to a const_tree.  */
4278   t = strip_array_types (CONST_CAST_TREE(t));
4279
4280   if (t == error_mark_node)
4281     return 1;
4282
4283   /* NULL pointers to data members are initialized with -1.  */
4284   if (TYPE_PTRDATAMEM_P (t))
4285     return 0;
4286
4287   /* Classes that contain types that can't be zero-initialized, cannot
4288      be zero-initialized themselves.  */
4289   if (CLASS_TYPE_P (t) && CLASSTYPE_NON_ZERO_INIT_P (t))
4290     return 0;
4291
4292   return 1;
4293 }
4294
4295 /* Handle the C++17 [[nodiscard]] attribute, which is similar to the GNU
4296    warn_unused_result attribute.  */
4297
4298 static tree
4299 handle_nodiscard_attribute (tree *node, tree name, tree /*args*/,
4300                             int /*flags*/, bool *no_add_attrs)
4301 {
4302   if (TREE_CODE (*node) == FUNCTION_DECL)
4303     {
4304       if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
4305         warning (OPT_Wattributes, "%qE attribute applied to %qD with void "
4306                  "return type", name, *node);
4307     }
4308   else if (OVERLOAD_TYPE_P (*node))
4309     /* OK */;
4310   else
4311     {
4312       warning (OPT_Wattributes, "%qE attribute can only be applied to "
4313                "functions or to class or enumeration types", name);
4314       *no_add_attrs = true;
4315     }
4316   return NULL_TREE;
4317 }
4318
4319 /* Table of valid C++ attributes.  */
4320 const struct attribute_spec cxx_attribute_table[] =
4321 {
4322   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
4323        affects_type_identity } */
4324   { "init_priority",  1, 1, true,  false, false,
4325     handle_init_priority_attribute, false },
4326   { "abi_tag", 1, -1, false, false, false,
4327     handle_abi_tag_attribute, true },
4328   { NULL,             0, 0, false, false, false, NULL, false }
4329 };
4330
4331 /* Table of C++ standard attributes.  */
4332 const struct attribute_spec std_attribute_table[] =
4333 {
4334   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
4335        affects_type_identity } */
4336   { "maybe_unused", 0, 0, false, false, false,
4337     handle_unused_attribute, false },
4338   { "nodiscard", 0, 0, false, false, false,
4339     handle_nodiscard_attribute, false },
4340   { NULL,             0, 0, false, false, false, NULL, false }
4341 };
4342
4343 /* Handle an "init_priority" attribute; arguments as in
4344    struct attribute_spec.handler.  */
4345 static tree
4346 handle_init_priority_attribute (tree* node,
4347                                 tree name,
4348                                 tree args,
4349                                 int /*flags*/,
4350                                 bool* no_add_attrs)
4351 {
4352   tree initp_expr = TREE_VALUE (args);
4353   tree decl = *node;
4354   tree type = TREE_TYPE (decl);
4355   int pri;
4356
4357   STRIP_NOPS (initp_expr);
4358   initp_expr = default_conversion (initp_expr);
4359   if (initp_expr)
4360     initp_expr = maybe_constant_value (initp_expr);
4361
4362   if (!initp_expr || TREE_CODE (initp_expr) != INTEGER_CST)
4363     {
4364       error ("requested init_priority is not an integer constant");
4365       cxx_constant_value (initp_expr);
4366       *no_add_attrs = true;
4367       return NULL_TREE;
4368     }
4369
4370   pri = TREE_INT_CST_LOW (initp_expr);
4371
4372   type = strip_array_types (type);
4373
4374   if (decl == NULL_TREE
4375       || !VAR_P (decl)
4376       || !TREE_STATIC (decl)
4377       || DECL_EXTERNAL (decl)
4378       || (TREE_CODE (type) != RECORD_TYPE
4379           && TREE_CODE (type) != UNION_TYPE)
4380       /* Static objects in functions are initialized the
4381          first time control passes through that
4382          function. This is not precise enough to pin down an
4383          init_priority value, so don't allow it.  */
4384       || current_function_decl)
4385     {
4386       error ("can only use %qE attribute on file-scope definitions "
4387              "of objects of class type", name);
4388       *no_add_attrs = true;
4389       return NULL_TREE;
4390     }
4391
4392   if (pri > MAX_INIT_PRIORITY || pri <= 0)
4393     {
4394       error ("requested init_priority is out of range");
4395       *no_add_attrs = true;
4396       return NULL_TREE;
4397     }
4398
4399   /* Check for init_priorities that are reserved for
4400      language and runtime support implementations.*/
4401   if (pri <= MAX_RESERVED_INIT_PRIORITY)
4402     {
4403       warning
4404         (0, "requested init_priority is reserved for internal use");
4405     }
4406
4407   if (SUPPORTS_INIT_PRIORITY)
4408     {
4409       SET_DECL_INIT_PRIORITY (decl, pri);
4410       DECL_HAS_INIT_PRIORITY_P (decl) = 1;
4411       return NULL_TREE;
4412     }
4413   else
4414     {
4415       error ("%qE attribute is not supported on this platform", name);
4416       *no_add_attrs = true;
4417       return NULL_TREE;
4418     }
4419 }
4420
4421 /* DECL is being redeclared; the old declaration had the abi tags in OLD,
4422    and the new one has the tags in NEW_.  Give an error if there are tags
4423    in NEW_ that weren't in OLD.  */
4424
4425 bool
4426 check_abi_tag_redeclaration (const_tree decl, const_tree old, const_tree new_)
4427 {
4428   if (old && TREE_CODE (TREE_VALUE (old)) == TREE_LIST)
4429     old = TREE_VALUE (old);
4430   if (new_ && TREE_CODE (TREE_VALUE (new_)) == TREE_LIST)
4431     new_ = TREE_VALUE (new_);
4432   bool err = false;
4433   for (const_tree t = new_; t; t = TREE_CHAIN (t))
4434     {
4435       tree str = TREE_VALUE (t);
4436       for (const_tree in = old; in; in = TREE_CHAIN (in))
4437         {
4438           tree ostr = TREE_VALUE (in);
4439           if (cp_tree_equal (str, ostr))
4440             goto found;
4441         }
4442       error ("redeclaration of %qD adds abi tag %qE", decl, str);
4443       err = true;
4444     found:;
4445     }
4446   if (err)
4447     {
4448       inform (DECL_SOURCE_LOCATION (decl), "previous declaration here");
4449       return false;
4450     }
4451   return true;
4452 }
4453
4454 /* The abi_tag attribute with the name NAME was given ARGS.  If they are
4455    ill-formed, give an error and return false; otherwise, return true.  */
4456
4457 bool
4458 check_abi_tag_args (tree args, tree name)
4459 {
4460   if (!args)
4461     {
4462       error ("the %qE attribute requires arguments", name);
4463       return false;
4464     }
4465   for (tree arg = args; arg; arg = TREE_CHAIN (arg))
4466     {
4467       tree elt = TREE_VALUE (arg);
4468       if (TREE_CODE (elt) != STRING_CST
4469           || (!same_type_ignoring_top_level_qualifiers_p
4470               (strip_array_types (TREE_TYPE (elt)),
4471                char_type_node)))
4472         {
4473           error ("arguments to the %qE attribute must be narrow string "
4474                  "literals", name);
4475           return false;
4476         }
4477       const char *begin = TREE_STRING_POINTER (elt);
4478       const char *end = begin + TREE_STRING_LENGTH (elt);
4479       for (const char *p = begin; p != end; ++p)
4480         {
4481           char c = *p;
4482           if (p == begin)
4483             {
4484               if (!ISALPHA (c) && c != '_')
4485                 {
4486                   error ("arguments to the %qE attribute must contain valid "
4487                          "identifiers", name);
4488                   inform (input_location, "%<%c%> is not a valid first "
4489                           "character for an identifier", c);
4490                   return false;
4491                 }
4492             }
4493           else if (p == end - 1)
4494             gcc_assert (c == 0);
4495           else
4496             {
4497               if (!ISALNUM (c) && c != '_')
4498                 {
4499                   error ("arguments to the %qE attribute must contain valid "
4500                          "identifiers", name);
4501                   inform (input_location, "%<%c%> is not a valid character "
4502                           "in an identifier", c);
4503                   return false;
4504                 }
4505             }
4506         }
4507     }
4508   return true;
4509 }
4510
4511 /* Handle an "abi_tag" attribute; arguments as in
4512    struct attribute_spec.handler.  */
4513
4514 static tree
4515 handle_abi_tag_attribute (tree* node, tree name, tree args,
4516                           int flags, bool* no_add_attrs)
4517 {
4518   if (!check_abi_tag_args (args, name))
4519     goto fail;
4520
4521   if (TYPE_P (*node))
4522     {
4523       if (!OVERLOAD_TYPE_P (*node))
4524         {
4525           error ("%qE attribute applied to non-class, non-enum type %qT",
4526                  name, *node);
4527           goto fail;
4528         }
4529       else if (!(flags & (int)ATTR_FLAG_TYPE_IN_PLACE))
4530         {
4531           error ("%qE attribute applied to %qT after its definition",
4532                  name, *node);
4533           goto fail;
4534         }
4535       else if (CLASS_TYPE_P (*node)
4536                && CLASSTYPE_TEMPLATE_INSTANTIATION (*node))
4537         {
4538           warning (OPT_Wattributes, "ignoring %qE attribute applied to "
4539                    "template instantiation %qT", name, *node);
4540           goto fail;
4541         }
4542       else if (CLASS_TYPE_P (*node)
4543                && CLASSTYPE_TEMPLATE_SPECIALIZATION (*node))
4544         {
4545           warning (OPT_Wattributes, "ignoring %qE attribute applied to "
4546                    "template specialization %qT", name, *node);
4547           goto fail;
4548         }
4549
4550       tree attributes = TYPE_ATTRIBUTES (*node);
4551       tree decl = TYPE_NAME (*node);
4552
4553       /* Make sure all declarations have the same abi tags.  */
4554       if (DECL_SOURCE_LOCATION (decl) != input_location)
4555         {
4556           if (!check_abi_tag_redeclaration (decl,
4557                                             lookup_attribute ("abi_tag",
4558                                                               attributes),
4559                                             args))
4560             goto fail;
4561         }
4562     }
4563   else
4564     {
4565       if (!VAR_OR_FUNCTION_DECL_P (*node))
4566         {
4567           error ("%qE attribute applied to non-function, non-variable %qD",
4568                  name, *node);
4569           goto fail;
4570         }
4571       else if (DECL_LANGUAGE (*node) == lang_c)
4572         {
4573           error ("%qE attribute applied to extern \"C\" declaration %qD",
4574                  name, *node);
4575           goto fail;
4576         }
4577     }
4578
4579   return NULL_TREE;
4580
4581  fail:
4582   *no_add_attrs = true;
4583   return NULL_TREE;
4584 }
4585
4586 /* Return a new PTRMEM_CST of the indicated TYPE.  The MEMBER is the
4587    thing pointed to by the constant.  */
4588
4589 tree
4590 make_ptrmem_cst (tree type, tree member)
4591 {
4592   tree ptrmem_cst = make_node (PTRMEM_CST);
4593   TREE_TYPE (ptrmem_cst) = type;
4594   PTRMEM_CST_MEMBER (ptrmem_cst) = member;
4595   return ptrmem_cst;
4596 }
4597
4598 /* Build a variant of TYPE that has the indicated ATTRIBUTES.  May
4599    return an existing type if an appropriate type already exists.  */
4600
4601 tree
4602 cp_build_type_attribute_variant (tree type, tree attributes)
4603 {
4604   tree new_type;
4605
4606   new_type = build_type_attribute_variant (type, attributes);
4607   if (TREE_CODE (new_type) == FUNCTION_TYPE
4608       || TREE_CODE (new_type) == METHOD_TYPE)
4609     {
4610       new_type = build_exception_variant (new_type,
4611                                           TYPE_RAISES_EXCEPTIONS (type));
4612       new_type = build_ref_qualified_type (new_type,
4613                                            type_memfn_rqual (type));
4614     }
4615
4616   /* Making a new main variant of a class type is broken.  */
4617   gcc_assert (!CLASS_TYPE_P (type) || new_type == type);
4618
4619   return new_type;
4620 }
4621
4622 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
4623    Called only after doing all language independent checks.  */
4624
4625 bool
4626 cxx_type_hash_eq (const_tree typea, const_tree typeb)
4627 {
4628   gcc_assert (TREE_CODE (typea) == FUNCTION_TYPE
4629               || TREE_CODE (typea) == METHOD_TYPE);
4630
4631   if (type_memfn_rqual (typea) != type_memfn_rqual (typeb))
4632     return false;
4633   return comp_except_specs (TYPE_RAISES_EXCEPTIONS (typea),
4634                             TYPE_RAISES_EXCEPTIONS (typeb), ce_exact);
4635 }
4636
4637 /* Copy the language-specific type variant modifiers from TYPEB to TYPEA.  For
4638    C++, these are the exception-specifier and ref-qualifier.  */
4639
4640 tree
4641 cxx_copy_lang_qualifiers (const_tree typea, const_tree typeb)
4642 {
4643   tree type = CONST_CAST_TREE (typea);
4644   if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
4645     {
4646       type = build_exception_variant (type, TYPE_RAISES_EXCEPTIONS (typeb));
4647       type = build_ref_qualified_type (type, type_memfn_rqual (typeb));
4648     }
4649   return type;
4650 }
4651
4652 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
4653    traversal.  Called from walk_tree.  */
4654
4655 tree
4656 cp_walk_subtrees (tree *tp, int *walk_subtrees_p, walk_tree_fn func,
4657                   void *data, hash_set<tree> *pset)
4658 {
4659   enum tree_code code = TREE_CODE (*tp);
4660   tree result;
4661
4662 #define WALK_SUBTREE(NODE)                              \
4663   do                                                    \
4664     {                                                   \
4665       result = cp_walk_tree (&(NODE), func, data, pset);        \
4666       if (result) goto out;                             \
4667     }                                                   \
4668   while (0)
4669
4670   /* Not one of the easy cases.  We must explicitly go through the
4671      children.  */
4672   result = NULL_TREE;
4673   switch (code)
4674     {
4675     case DEFAULT_ARG:
4676     case TEMPLATE_TEMPLATE_PARM:
4677     case BOUND_TEMPLATE_TEMPLATE_PARM:
4678     case UNBOUND_CLASS_TEMPLATE:
4679     case TEMPLATE_PARM_INDEX:
4680     case TEMPLATE_TYPE_PARM:
4681     case TYPENAME_TYPE:
4682     case TYPEOF_TYPE:
4683     case UNDERLYING_TYPE:
4684       /* None of these have subtrees other than those already walked
4685          above.  */
4686       *walk_subtrees_p = 0;
4687       break;
4688
4689     case BASELINK:
4690       if (BASELINK_QUALIFIED_P (*tp))
4691         WALK_SUBTREE (BINFO_TYPE (BASELINK_ACCESS_BINFO (*tp)));
4692       WALK_SUBTREE (BASELINK_FUNCTIONS (*tp));
4693       *walk_subtrees_p = 0;
4694       break;
4695
4696     case PTRMEM_CST:
4697       WALK_SUBTREE (TREE_TYPE (*tp));
4698       *walk_subtrees_p = 0;
4699       break;
4700
4701     case TREE_LIST:
4702       WALK_SUBTREE (TREE_PURPOSE (*tp));
4703       break;
4704
4705     case OVERLOAD:
4706       WALK_SUBTREE (OVL_FUNCTION (*tp));
4707       WALK_SUBTREE (OVL_CHAIN (*tp));
4708       *walk_subtrees_p = 0;
4709       break;
4710
4711     case USING_DECL:
4712       WALK_SUBTREE (DECL_NAME (*tp));
4713       WALK_SUBTREE (USING_DECL_SCOPE (*tp));
4714       WALK_SUBTREE (USING_DECL_DECLS (*tp));
4715       *walk_subtrees_p = 0;
4716       break;
4717
4718     case RECORD_TYPE:
4719       if (TYPE_PTRMEMFUNC_P (*tp))
4720         WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE_RAW (*tp));
4721       break;
4722
4723     case TYPE_ARGUMENT_PACK:
4724     case NONTYPE_ARGUMENT_PACK:
4725       {
4726         tree args = ARGUMENT_PACK_ARGS (*tp);
4727         int i, len = TREE_VEC_LENGTH (args);
4728         for (i = 0; i < len; i++)
4729           WALK_SUBTREE (TREE_VEC_ELT (args, i));
4730       }
4731       break;
4732
4733     case TYPE_PACK_EXPANSION:
4734       WALK_SUBTREE (TREE_TYPE (*tp));
4735       WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp));
4736       *walk_subtrees_p = 0;
4737       break;
4738
4739     case EXPR_PACK_EXPANSION:
4740       WALK_SUBTREE (TREE_OPERAND (*tp, 0));
4741       WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp));
4742       *walk_subtrees_p = 0;
4743       break;
4744
4745     case CAST_EXPR:
4746     case REINTERPRET_CAST_EXPR:
4747     case STATIC_CAST_EXPR:
4748     case CONST_CAST_EXPR:
4749     case DYNAMIC_CAST_EXPR:
4750     case IMPLICIT_CONV_EXPR:
4751       if (TREE_TYPE (*tp))
4752         WALK_SUBTREE (TREE_TYPE (*tp));
4753
4754       {
4755         int i;
4756         for (i = 0; i < TREE_CODE_LENGTH (TREE_CODE (*tp)); ++i)
4757           WALK_SUBTREE (TREE_OPERAND (*tp, i));
4758       }
4759       *walk_subtrees_p = 0;
4760       break;
4761
4762     case TRAIT_EXPR:
4763       WALK_SUBTREE (TRAIT_EXPR_TYPE1 (*tp));
4764       WALK_SUBTREE (TRAIT_EXPR_TYPE2 (*tp));
4765       *walk_subtrees_p = 0;
4766       break;
4767
4768     case DECLTYPE_TYPE:
4769       WALK_SUBTREE (DECLTYPE_TYPE_EXPR (*tp));
4770       *walk_subtrees_p = 0;
4771       break;
4772
4773     case REQUIRES_EXPR:
4774       // Only recurse through the nested expression. Do not
4775       // walk the parameter list. Doing so causes false
4776       // positives in the pack expansion checker since the
4777       // requires parameters are introduced as pack expansions.
4778       WALK_SUBTREE (TREE_OPERAND (*tp, 1));
4779       *walk_subtrees_p = 0;
4780       break;
4781
4782     case DECL_EXPR:
4783       /* User variables should be mentioned in BIND_EXPR_VARS
4784          and their initializers and sizes walked when walking
4785          the containing BIND_EXPR.  Compiler temporaries are
4786          handled here.  */
4787       if (VAR_P (TREE_OPERAND (*tp, 0))
4788           && DECL_ARTIFICIAL (TREE_OPERAND (*tp, 0))
4789           && !TREE_STATIC (TREE_OPERAND (*tp, 0)))
4790         {
4791           tree decl = TREE_OPERAND (*tp, 0);
4792           WALK_SUBTREE (DECL_INITIAL (decl));
4793           WALK_SUBTREE (DECL_SIZE (decl));
4794           WALK_SUBTREE (DECL_SIZE_UNIT (decl));
4795         }
4796       break;
4797
4798     default:
4799       return NULL_TREE;
4800     }
4801
4802   /* We didn't find what we were looking for.  */
4803  out:
4804   return result;
4805
4806 #undef WALK_SUBTREE
4807 }
4808
4809 /* Like save_expr, but for C++.  */
4810
4811 tree
4812 cp_save_expr (tree expr)
4813 {
4814   /* There is no reason to create a SAVE_EXPR within a template; if
4815      needed, we can create the SAVE_EXPR when instantiating the
4816      template.  Furthermore, the middle-end cannot handle C++-specific
4817      tree codes.  */
4818   if (processing_template_decl)
4819     return expr;
4820   return save_expr (expr);
4821 }
4822
4823 /* Initialize tree.c.  */
4824
4825 void
4826 init_tree (void)
4827 {
4828   list_hash_table = hash_table<list_hasher>::create_ggc (61);
4829   register_scoped_attributes (std_attribute_table, NULL);
4830 }
4831
4832 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
4833    is.  Note that sfk_none is zero, so this function can be used as a
4834    predicate to test whether or not DECL is a special function.  */
4835
4836 special_function_kind
4837 special_function_p (const_tree decl)
4838 {
4839   /* Rather than doing all this stuff with magic names, we should
4840      probably have a field of type `special_function_kind' in
4841      DECL_LANG_SPECIFIC.  */
4842   if (DECL_INHERITED_CTOR (decl))
4843     return sfk_inheriting_constructor;
4844   if (DECL_COPY_CONSTRUCTOR_P (decl))
4845     return sfk_copy_constructor;
4846   if (DECL_MOVE_CONSTRUCTOR_P (decl))
4847     return sfk_move_constructor;
4848   if (DECL_CONSTRUCTOR_P (decl))
4849     return sfk_constructor;
4850   if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
4851     {
4852       if (copy_fn_p (decl))
4853         return sfk_copy_assignment;
4854       if (move_fn_p (decl))
4855         return sfk_move_assignment;
4856     }
4857   if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl))
4858     return sfk_destructor;
4859   if (DECL_COMPLETE_DESTRUCTOR_P (decl))
4860     return sfk_complete_destructor;
4861   if (DECL_BASE_DESTRUCTOR_P (decl))
4862     return sfk_base_destructor;
4863   if (DECL_DELETING_DESTRUCTOR_P (decl))
4864     return sfk_deleting_destructor;
4865   if (DECL_CONV_FN_P (decl))
4866     return sfk_conversion;
4867   if (deduction_guide_p (decl))
4868     return sfk_deduction_guide;
4869
4870   return sfk_none;
4871 }
4872
4873 /* Returns nonzero if TYPE is a character type, including wchar_t.  */
4874
4875 int
4876 char_type_p (tree type)
4877 {
4878   return (same_type_p (type, char_type_node)
4879           || same_type_p (type, unsigned_char_type_node)
4880           || same_type_p (type, signed_char_type_node)
4881           || same_type_p (type, char16_type_node)
4882           || same_type_p (type, char32_type_node)
4883           || same_type_p (type, wchar_type_node));
4884 }
4885
4886 /* Returns the kind of linkage associated with the indicated DECL.  Th
4887    value returned is as specified by the language standard; it is
4888    independent of implementation details regarding template
4889    instantiation, etc.  For example, it is possible that a declaration
4890    to which this function assigns external linkage would not show up
4891    as a global symbol when you run `nm' on the resulting object file.  */
4892
4893 linkage_kind
4894 decl_linkage (tree decl)
4895 {
4896   /* This function doesn't attempt to calculate the linkage from first
4897      principles as given in [basic.link].  Instead, it makes use of
4898      the fact that we have already set TREE_PUBLIC appropriately, and
4899      then handles a few special cases.  Ideally, we would calculate
4900      linkage first, and then transform that into a concrete
4901      implementation.  */
4902
4903   /* Things that don't have names have no linkage.  */
4904   if (!DECL_NAME (decl))
4905     return lk_none;
4906
4907   /* Fields have no linkage.  */
4908   if (TREE_CODE (decl) == FIELD_DECL)
4909     return lk_none;
4910
4911   /* Things that are TREE_PUBLIC have external linkage.  */
4912   if (TREE_PUBLIC (decl))
4913     return lk_external;
4914
4915   /* maybe_thunk_body clears TREE_PUBLIC on the maybe-in-charge 'tor variants,
4916      check one of the "clones" for the real linkage.  */
4917   if ((DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl)
4918        || DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl))
4919       && DECL_CHAIN (decl)
4920       && DECL_CLONED_FUNCTION (DECL_CHAIN (decl)))
4921     return decl_linkage (DECL_CHAIN (decl));
4922
4923   if (TREE_CODE (decl) == NAMESPACE_DECL)
4924     return lk_external;
4925
4926   /* Linkage of a CONST_DECL depends on the linkage of the enumeration
4927      type.  */
4928   if (TREE_CODE (decl) == CONST_DECL)
4929     return decl_linkage (TYPE_NAME (DECL_CONTEXT (decl)));
4930
4931   /* Things in local scope do not have linkage, if they don't have
4932      TREE_PUBLIC set.  */
4933   if (decl_function_context (decl))
4934     return lk_none;
4935
4936   /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
4937      are considered to have external linkage for language purposes, as do
4938      template instantiations on targets without weak symbols.  DECLs really
4939      meant to have internal linkage have DECL_THIS_STATIC set.  */
4940   if (TREE_CODE (decl) == TYPE_DECL)
4941     return lk_external;
4942   if (VAR_OR_FUNCTION_DECL_P (decl))
4943     {
4944       if (!DECL_THIS_STATIC (decl))
4945         return lk_external;
4946
4947       /* Static data members and static member functions from classes
4948          in anonymous namespace also don't have TREE_PUBLIC set.  */
4949       if (DECL_CLASS_CONTEXT (decl))
4950         return lk_external;
4951     }
4952
4953   /* Everything else has internal linkage.  */
4954   return lk_internal;
4955 }
4956
4957 /* Returns the storage duration of the object or reference associated with
4958    the indicated DECL, which should be a VAR_DECL or PARM_DECL.  */
4959
4960 duration_kind
4961 decl_storage_duration (tree decl)
4962 {
4963   if (TREE_CODE (decl) == PARM_DECL)
4964     return dk_auto;
4965   if (TREE_CODE (decl) == FUNCTION_DECL)
4966     return dk_static;
4967   gcc_assert (VAR_P (decl));
4968   if (!TREE_STATIC (decl)
4969       && !DECL_EXTERNAL (decl))
4970     return dk_auto;
4971   if (CP_DECL_THREAD_LOCAL_P (decl))
4972     return dk_thread;
4973   return dk_static;
4974 }
4975 \f
4976 /* EXP is an expression that we want to pre-evaluate.  Returns (in
4977    *INITP) an expression that will perform the pre-evaluation.  The
4978    value returned by this function is a side-effect free expression
4979    equivalent to the pre-evaluated expression.  Callers must ensure
4980    that *INITP is evaluated before EXP.  */
4981
4982 tree
4983 stabilize_expr (tree exp, tree* initp)
4984 {
4985   tree init_expr;
4986
4987   if (!TREE_SIDE_EFFECTS (exp))
4988     init_expr = NULL_TREE;
4989   else if (VOID_TYPE_P (TREE_TYPE (exp)))
4990     {
4991       init_expr = exp;
4992       exp = void_node;
4993     }
4994   /* There are no expressions with REFERENCE_TYPE, but there can be call
4995      arguments with such a type; just treat it as a pointer.  */
4996   else if (TREE_CODE (TREE_TYPE (exp)) == REFERENCE_TYPE
4997            || SCALAR_TYPE_P (TREE_TYPE (exp))
4998            || !glvalue_p (exp))
4999     {
5000       init_expr = get_target_expr (exp);
5001       exp = TARGET_EXPR_SLOT (init_expr);
5002       if (CLASS_TYPE_P (TREE_TYPE (exp)))
5003         exp = move (exp);
5004       else
5005         exp = rvalue (exp);
5006     }
5007   else
5008     {
5009       bool xval = !lvalue_p (exp);
5010       exp = cp_build_addr_expr (exp, tf_warning_or_error);
5011       init_expr = get_target_expr (exp);
5012       exp = TARGET_EXPR_SLOT (init_expr);
5013       exp = cp_build_indirect_ref (exp, RO_NULL, tf_warning_or_error);
5014       if (xval)
5015         exp = move (exp);
5016     }
5017   *initp = init_expr;
5018
5019   gcc_assert (!TREE_SIDE_EFFECTS (exp));
5020   return exp;
5021 }
5022
5023 /* Add NEW_EXPR, an expression whose value we don't care about, after the
5024    similar expression ORIG.  */
5025
5026 tree
5027 add_stmt_to_compound (tree orig, tree new_expr)
5028 {
5029   if (!new_expr || !TREE_SIDE_EFFECTS (new_expr))
5030     return orig;
5031   if (!orig || !TREE_SIDE_EFFECTS (orig))
5032     return new_expr;
5033   return build2 (COMPOUND_EXPR, void_type_node, orig, new_expr);
5034 }
5035
5036 /* Like stabilize_expr, but for a call whose arguments we want to
5037    pre-evaluate.  CALL is modified in place to use the pre-evaluated
5038    arguments, while, upon return, *INITP contains an expression to
5039    compute the arguments.  */
5040
5041 void
5042 stabilize_call (tree call, tree *initp)
5043 {
5044   tree inits = NULL_TREE;
5045   int i;
5046   int nargs = call_expr_nargs (call);
5047
5048   if (call == error_mark_node || processing_template_decl)
5049     {
5050       *initp = NULL_TREE;
5051       return;
5052     }
5053
5054   gcc_assert (TREE_CODE (call) == CALL_EXPR);
5055
5056   for (i = 0; i < nargs; i++)
5057     {
5058       tree init;
5059       CALL_EXPR_ARG (call, i) =
5060         stabilize_expr (CALL_EXPR_ARG (call, i), &init);
5061       inits = add_stmt_to_compound (inits, init);
5062     }
5063
5064   *initp = inits;
5065 }
5066
5067 /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
5068    to pre-evaluate.  CALL is modified in place to use the pre-evaluated
5069    arguments, while, upon return, *INITP contains an expression to
5070    compute the arguments.  */
5071
5072 static void
5073 stabilize_aggr_init (tree call, tree *initp)
5074 {
5075   tree inits = NULL_TREE;
5076   int i;
5077   int nargs = aggr_init_expr_nargs (call);
5078
5079   if (call == error_mark_node)
5080     return;
5081
5082   gcc_assert (TREE_CODE (call) == AGGR_INIT_EXPR);
5083
5084   for (i = 0; i < nargs; i++)
5085     {
5086       tree init;
5087       AGGR_INIT_EXPR_ARG (call, i) =
5088         stabilize_expr (AGGR_INIT_EXPR_ARG (call, i), &init);
5089       inits = add_stmt_to_compound (inits, init);
5090     }
5091
5092   *initp = inits;
5093 }
5094
5095 /* Like stabilize_expr, but for an initialization.
5096
5097    If the initialization is for an object of class type, this function
5098    takes care not to introduce additional temporaries.
5099
5100    Returns TRUE iff the expression was successfully pre-evaluated,
5101    i.e., if INIT is now side-effect free, except for, possibly, a
5102    single call to a constructor.  */
5103
5104 bool
5105 stabilize_init (tree init, tree *initp)
5106 {
5107   tree t = init;
5108
5109   *initp = NULL_TREE;
5110
5111   if (t == error_mark_node || processing_template_decl)
5112     return true;
5113
5114   if (TREE_CODE (t) == INIT_EXPR)
5115     t = TREE_OPERAND (t, 1);
5116   if (TREE_CODE (t) == TARGET_EXPR)
5117     t = TARGET_EXPR_INITIAL (t);
5118
5119   /* If the RHS can be stabilized without breaking copy elision, stabilize
5120      it.  We specifically don't stabilize class prvalues here because that
5121      would mean an extra copy, but they might be stabilized below.  */
5122   if (TREE_CODE (init) == INIT_EXPR
5123       && TREE_CODE (t) != CONSTRUCTOR
5124       && TREE_CODE (t) != AGGR_INIT_EXPR
5125       && (SCALAR_TYPE_P (TREE_TYPE (t))
5126           || glvalue_p (t)))
5127     {
5128       TREE_OPERAND (init, 1) = stabilize_expr (t, initp);
5129       return true;
5130     }
5131
5132   if (TREE_CODE (t) == COMPOUND_EXPR
5133       && TREE_CODE (init) == INIT_EXPR)
5134     {
5135       tree last = expr_last (t);
5136       /* Handle stabilizing the EMPTY_CLASS_EXPR pattern.  */
5137       if (!TREE_SIDE_EFFECTS (last))
5138         {
5139           *initp = t;
5140           TREE_OPERAND (init, 1) = last;
5141           return true;
5142         }
5143     }
5144
5145   if (TREE_CODE (t) == CONSTRUCTOR)
5146     {
5147       /* Aggregate initialization: stabilize each of the field
5148          initializers.  */
5149       unsigned i;
5150       constructor_elt *ce;
5151       bool good = true;
5152       vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (t);
5153       for (i = 0; vec_safe_iterate (v, i, &ce); ++i)
5154         {
5155           tree type = TREE_TYPE (ce->value);
5156           tree subinit;
5157           if (TREE_CODE (type) == REFERENCE_TYPE
5158               || SCALAR_TYPE_P (type))
5159             ce->value = stabilize_expr (ce->value, &subinit);
5160           else if (!stabilize_init (ce->value, &subinit))
5161             good = false;
5162           *initp = add_stmt_to_compound (*initp, subinit);
5163         }
5164       return good;
5165     }
5166
5167   if (TREE_CODE (t) == CALL_EXPR)
5168     {
5169       stabilize_call (t, initp);
5170       return true;
5171     }
5172
5173   if (TREE_CODE (t) == AGGR_INIT_EXPR)
5174     {
5175       stabilize_aggr_init (t, initp);
5176       return true;
5177     }
5178
5179   /* The initialization is being performed via a bitwise copy -- and
5180      the item copied may have side effects.  */
5181   return !TREE_SIDE_EFFECTS (init);
5182 }
5183
5184 /* Returns true if a cast to TYPE may appear in an integral constant
5185    expression.  */
5186
5187 bool
5188 cast_valid_in_integral_constant_expression_p (tree type)
5189 {
5190   return (INTEGRAL_OR_ENUMERATION_TYPE_P (type)
5191           || cxx_dialect >= cxx11
5192           || dependent_type_p (type)
5193           || type == error_mark_node);
5194 }
5195
5196 /* Return true if we need to fix linkage information of DECL.  */
5197
5198 static bool
5199 cp_fix_function_decl_p (tree decl)
5200 {
5201   /* Skip if DECL is not externally visible.  */
5202   if (!TREE_PUBLIC (decl))
5203     return false;
5204
5205   /* We need to fix DECL if it a appears to be exported but with no
5206      function body.  Thunks do not have CFGs and we may need to
5207      handle them specially later.   */
5208   if (!gimple_has_body_p (decl)
5209       && !DECL_THUNK_P (decl)
5210       && !DECL_EXTERNAL (decl))
5211     {
5212       struct cgraph_node *node = cgraph_node::get (decl);
5213
5214       /* Don't fix same_body aliases.  Although they don't have their own
5215          CFG, they share it with what they alias to.  */
5216       if (!node || !node->alias
5217           || !vec_safe_length (node->ref_list.references))
5218         return true;
5219     }
5220
5221   return false;
5222 }
5223
5224 /* Clean the C++ specific parts of the tree T. */
5225
5226 void
5227 cp_free_lang_data (tree t)
5228 {
5229   if (TREE_CODE (t) == METHOD_TYPE
5230       || TREE_CODE (t) == FUNCTION_TYPE)
5231     {
5232       /* Default args are not interesting anymore.  */
5233       tree argtypes = TYPE_ARG_TYPES (t);
5234       while (argtypes)
5235         {
5236           TREE_PURPOSE (argtypes) = 0;
5237           argtypes = TREE_CHAIN (argtypes);
5238         }
5239     }
5240   else if (TREE_CODE (t) == FUNCTION_DECL
5241            && cp_fix_function_decl_p (t))
5242     {
5243       /* If T is used in this translation unit at all,  the definition
5244          must exist somewhere else since we have decided to not emit it
5245          in this TU.  So make it an external reference.  */
5246       DECL_EXTERNAL (t) = 1;
5247       TREE_STATIC (t) = 0;
5248     }
5249   if (TREE_CODE (t) == NAMESPACE_DECL)
5250     /* We do not need the leftover chaining of namespaces from the
5251        binding level.  */
5252     DECL_CHAIN (t) = NULL_TREE;
5253 }
5254
5255 /* Stub for c-common.  Please keep in sync with c-decl.c.
5256    FIXME: If address space support is target specific, then this
5257    should be a C target hook.  But currently this is not possible,
5258    because this function is called via REGISTER_TARGET_PRAGMAS.  */
5259 void
5260 c_register_addr_space (const char * /*word*/, addr_space_t /*as*/)
5261 {
5262 }
5263
5264 /* Return the number of operands in T that we care about for things like
5265    mangling.  */
5266
5267 int
5268 cp_tree_operand_length (const_tree t)
5269 {
5270   enum tree_code code = TREE_CODE (t);
5271
5272   if (TREE_CODE_CLASS (code) == tcc_vl_exp)
5273     return VL_EXP_OPERAND_LENGTH (t);
5274
5275   return cp_tree_code_length (code);
5276 }
5277
5278 /* Like cp_tree_operand_length, but takes a tree_code CODE.  */
5279
5280 int
5281 cp_tree_code_length (enum tree_code code)
5282 {
5283   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
5284
5285   switch (code)
5286     {
5287     case PREINCREMENT_EXPR:
5288     case PREDECREMENT_EXPR:
5289     case POSTINCREMENT_EXPR:
5290     case POSTDECREMENT_EXPR:
5291       return 1;
5292
5293     case ARRAY_REF:
5294       return 2;
5295
5296     case EXPR_PACK_EXPANSION:
5297       return 1;
5298
5299     default:
5300       return TREE_CODE_LENGTH (code);
5301     }
5302 }
5303
5304 /* Implement -Wzero_as_null_pointer_constant.  Return true if the
5305    conditions for the warning hold, false otherwise.  */
5306 bool
5307 maybe_warn_zero_as_null_pointer_constant (tree expr, location_t loc)
5308 {
5309   if (c_inhibit_evaluation_warnings == 0
5310       && !NULLPTR_TYPE_P (TREE_TYPE (expr)))
5311     {
5312       warning_at (loc, OPT_Wzero_as_null_pointer_constant,
5313                   "zero as null pointer constant");
5314       return true;
5315     }
5316   return false;
5317 }
5318 \f
5319 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
5320 /* Complain that some language-specific thing hanging off a tree
5321    node has been accessed improperly.  */
5322
5323 void
5324 lang_check_failed (const char* file, int line, const char* function)
5325 {
5326   internal_error ("lang_* check: failed in %s, at %s:%d",
5327                   function, trim_filename (file), line);
5328 }
5329 #endif /* ENABLE_TREE_CHECKING */
5330
5331 #include "gt-cp-tree.h"