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