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