contrib/gcc-4.7/gcc/cp/tree.c

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