gcc/cp/tree.c

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