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 Free Software Foundation, Inc.
   4    Hacked by Michael Tiemann (tiemann@cygnus.com)
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2, or (at your option)
  11 any later version.
  12
  13 GCC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING.  If not, write to
  20 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
  21 Boston, MA 02110-1301, USA.  */
  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 "real.h"
  31 #include "rtl.h"
  32 #include "toplev.h"
  33 #include "insn-config.h"
  34 #include "integrate.h"
  35 #include "tree-inline.h"
  36 #include "debug.h"
  37 #include "target.h"
  38 #include "convert.h"
  39
  40 static tree bot_manip (tree *, int *, void *);
  41 static tree bot_replace (tree *, int *, void *);
  42 static tree build_cplus_array_type_1 (tree, tree);
  43 static int list_hash_eq (const void *, const void *);
  44 static hashval_t list_hash_pieces (tree, tree, tree);
  45 static hashval_t list_hash (const void *);
  46 static cp_lvalue_kind lvalue_p_1 (tree, int);
  47 static tree build_target_expr (tree, tree);
  48 static tree count_trees_r (tree *, int *, void *);
  49 static tree verify_stmt_tree_r (tree *, int *, void *);
  50 static tree build_local_temp (tree);
  51
  52 static tree handle_java_interface_attribute (tree *, tree, tree, int, bool *);
  53 static tree handle_com_interface_attribute (tree *, tree, tree, int, bool *);
  54 static tree handle_init_priority_attribute (tree *, tree, tree, int, bool *);
  55
  56 /* If REF is an lvalue, returns the kind of lvalue that REF is.
  57    Otherwise, returns clk_none.  If TREAT_CLASS_RVALUES_AS_LVALUES is
  58    nonzero, rvalues of class type are considered lvalues.  */
  59
  60 static cp_lvalue_kind
  61 lvalue_p_1 (tree ref,
  62             int treat_class_rvalues_as_lvalues)
  63 {
  64   cp_lvalue_kind op1_lvalue_kind = clk_none;
  65   cp_lvalue_kind op2_lvalue_kind = clk_none;
  66
  67   if (TREE_CODE (TREE_TYPE (ref)) == REFERENCE_TYPE)
  68     return clk_ordinary;
  69
  70   if (ref == current_class_ptr)
  71     return clk_none;
  72
  73   switch (TREE_CODE (ref))
  74     {
  75       /* preincrements and predecrements are valid lvals, provided
  76          what they refer to are valid lvals.  */
  77     case PREINCREMENT_EXPR:
  78     case PREDECREMENT_EXPR:
  79     case SAVE_EXPR:
  80     case TRY_CATCH_EXPR:
  81     case WITH_CLEANUP_EXPR:
  82     case REALPART_EXPR:
  83     case IMAGPART_EXPR:
  84       return lvalue_p_1 (TREE_OPERAND (ref, 0),
  85                          treat_class_rvalues_as_lvalues);
  86
  87     case COMPONENT_REF:
  88       op1_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 0),
  89                                     treat_class_rvalues_as_lvalues);
  90       /* Look at the member designator.  */
  91       if (!op1_lvalue_kind
  92           /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some
  93              situations.  */
  94           || TREE_CODE (TREE_OPERAND (ref, 1)) != FIELD_DECL)
  95         ;
  96       else if (DECL_C_BIT_FIELD (TREE_OPERAND (ref, 1)))
  97         {
  98           /* Clear the ordinary bit.  If this object was a class
  99              rvalue we want to preserve that information.  */
 100           op1_lvalue_kind &= ~clk_ordinary;
 101           /* The lvalue is for a bitfield.  */
 102           op1_lvalue_kind |= clk_bitfield;
 103         }
 104       else if (DECL_PACKED (TREE_OPERAND (ref, 1)))
 105         op1_lvalue_kind |= clk_packed;
 106
 107       return op1_lvalue_kind;
 108
 109     case STRING_CST:
 110       return clk_ordinary;
 111
 112     case CONST_DECL:
 113     case VAR_DECL:
 114       if (TREE_READONLY (ref) && ! TREE_STATIC (ref)
 115           && DECL_LANG_SPECIFIC (ref)
 116           && DECL_IN_AGGR_P (ref))
 117         return clk_none;
 118     case INDIRECT_REF:
 119     case ARRAY_REF:
 120     case PARM_DECL:
 121     case RESULT_DECL:
 122       if (TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE)
 123         return clk_ordinary;
 124       break;
 125
 126       /* A currently unresolved scope ref.  */
 127     case SCOPE_REF:
 128       gcc_unreachable ();
 129     case MAX_EXPR:
 130     case MIN_EXPR:
 131       /* Disallow <? and >? as lvalues if either argument side-effects.  */
 132       if (TREE_SIDE_EFFECTS (TREE_OPERAND (ref, 0))
 133           || TREE_SIDE_EFFECTS (TREE_OPERAND (ref, 1)))
 134         return clk_none;
 135       op1_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 0),
 136                                     treat_class_rvalues_as_lvalues);
 137       op2_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 1),
 138                                     treat_class_rvalues_as_lvalues);
 139       break;
 140
 141     case COND_EXPR:
 142       op1_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 1),
 143                                     treat_class_rvalues_as_lvalues);
 144       op2_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 2),
 145                                     treat_class_rvalues_as_lvalues);
 146       break;
 147
 148     case MODIFY_EXPR:
 149       return clk_ordinary;
 150
 151     case COMPOUND_EXPR:
 152       return lvalue_p_1 (TREE_OPERAND (ref, 1),
 153                          treat_class_rvalues_as_lvalues);
 154
 155     case TARGET_EXPR:
 156       return treat_class_rvalues_as_lvalues ? clk_class : clk_none;
 157
 158     case VA_ARG_EXPR:
 159       return (treat_class_rvalues_as_lvalues
 160               && CLASS_TYPE_P (TREE_TYPE (ref))
 161               ? clk_class : clk_none);
 162
 163     case CALL_EXPR:
 164       /* Any class-valued call would be wrapped in a TARGET_EXPR.  */
 165       return clk_none;
 166
 167     case FUNCTION_DECL:
 168       /* All functions (except non-static-member functions) are
 169          lvalues.  */
 170       return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref)
 171               ? clk_none : clk_ordinary);
 172
 173     case NON_DEPENDENT_EXPR:
 174       /* We must consider NON_DEPENDENT_EXPRs to be lvalues so that
 175          things like "&E" where "E" is an expression with a
 176          non-dependent type work. It is safe to be lenient because an
 177          error will be issued when the template is instantiated if "E"
 178          is not an lvalue.  */
 179       return clk_ordinary;
 180
 181     default:
 182       break;
 183     }
 184
 185   /* If one operand is not an lvalue at all, then this expression is
 186      not an lvalue.  */
 187   if (!op1_lvalue_kind || !op2_lvalue_kind)
 188     return clk_none;
 189
 190   /* Otherwise, it's an lvalue, and it has all the odd properties
 191      contributed by either operand.  */
 192   op1_lvalue_kind = op1_lvalue_kind | op2_lvalue_kind;
 193   /* It's not an ordinary lvalue if it involves either a bit-field or
 194      a class rvalue.  */
 195   if ((op1_lvalue_kind & ~clk_ordinary) != clk_none)
 196     op1_lvalue_kind &= ~clk_ordinary;
 197   return op1_lvalue_kind;
 198 }
 199
 200 /* Returns the kind of lvalue that REF is, in the sense of
 201    [basic.lval].  This function should really be named lvalue_p; it
 202    computes the C++ definition of lvalue.  */
 203
 204 cp_lvalue_kind
 205 real_lvalue_p (tree ref)
 206 {
 207   return lvalue_p_1 (ref,
 208                      /*treat_class_rvalues_as_lvalues=*/0);
 209 }
 210
 211 /* This differs from real_lvalue_p in that class rvalues are
 212    considered lvalues.  */
 213
 214 int
 215 lvalue_p (tree ref)
 216 {
 217   return
 218     (lvalue_p_1 (ref, /*class rvalue ok*/ 1) != clk_none);
 219 }
 220
 221 /* Test whether DECL is a builtin that may appear in a
 222    constant-expression. */
 223
 224 bool
 225 builtin_valid_in_constant_expr_p (tree decl)
 226 {
 227   /* At present BUILT_IN_CONSTANT_P is the only builtin we're allowing
 228      in constant-expressions.  We may want to add other builtins later. */
 229   return DECL_IS_BUILTIN_CONSTANT_P (decl);
 230 }
 231
 232 /* Build a TARGET_EXPR, initializing the DECL with the VALUE.  */
 233
 234 static tree
 235 build_target_expr (tree decl, tree value)
 236 {
 237   tree t;
 238
 239   t = build4 (TARGET_EXPR, TREE_TYPE (decl), decl, value,
 240               cxx_maybe_build_cleanup (decl), NULL_TREE);
 241   /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
 242      ignore the TARGET_EXPR.  If there really turn out to be no
 243      side-effects, then the optimizer should be able to get rid of
 244      whatever code is generated anyhow.  */
 245   TREE_SIDE_EFFECTS (t) = 1;
 246
 247   return t;
 248 }
 249
 250 /* Return an undeclared local temporary of type TYPE for use in building a
 251    TARGET_EXPR.  */
 252
 253 static tree
 254 build_local_temp (tree type)
 255 {
 256   tree slot = build_decl (VAR_DECL, NULL_TREE, type);
 257   DECL_ARTIFICIAL (slot) = 1;
 258   DECL_IGNORED_P (slot) = 1;
 259   DECL_CONTEXT (slot) = current_function_decl;
 260   layout_decl (slot, 0);
 261   return slot;
 262 }
 263
 264 /* Set various status flags when building an AGGR_INIT_EXPR object T.  */
 265
 266 static void
 267 process_aggr_init_operands (tree t)
 268 {
 269   bool side_effects;
 270
 271   side_effects = TREE_SIDE_EFFECTS (t);
 272   if (!side_effects)
 273     {
 274       int i, n;
 275       n = TREE_OPERAND_LENGTH (t);
 276       for (i = 1; i < n; i++)
 277         {
 278           tree op = TREE_OPERAND (t, i);
 279           if (op && TREE_SIDE_EFFECTS (op))
 280             {
 281               side_effects = 1;
 282               break;
 283             }
 284         }
 285     }
 286   TREE_SIDE_EFFECTS (t) = side_effects;
 287 }
 288
 289 /* Build an AGGR_INIT_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE,
 290    FN, and SLOT.  NARGS is the number of call arguments which are specified
 291    as a tree array ARGS.  */
 292
 293 static tree
 294 build_aggr_init_array (tree return_type, tree fn, tree slot, int nargs,
 295                        tree *args)
 296 {
 297   tree t;
 298   int i;
 299
 300   t = build_vl_exp (AGGR_INIT_EXPR, nargs + 3);
 301   TREE_TYPE (t) = return_type;
 302   AGGR_INIT_EXPR_FN (t) = fn;
 303   AGGR_INIT_EXPR_SLOT (t) = slot;
 304   for (i = 0; i < nargs; i++)
 305     AGGR_INIT_EXPR_ARG (t, i) = args[i];
 306   process_aggr_init_operands (t);
 307   return t;
 308 }
 309
 310 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
 311    target.  TYPE is the type that this initialization should appear to
 312    have.
 313
 314    Build an encapsulation of the initialization to perform
 315    and return it so that it can be processed by language-independent
 316    and language-specific expression expanders.  */
 317
 318 tree
 319 build_cplus_new (tree type, tree init)
 320 {
 321   tree fn;
 322   tree slot;
 323   tree rval;
 324   int is_ctor;
 325
 326   /* Make sure that we're not trying to create an instance of an
 327      abstract class.  */
 328   abstract_virtuals_error (NULL_TREE, type);
 329
 330   if (TREE_CODE (init) == CALL_EXPR)
 331     fn = CALL_EXPR_FN (init);
 332   else if (TREE_CODE (init) == AGGR_INIT_EXPR)
 333     fn = AGGR_INIT_EXPR_FN (init);
 334   else
 335     return convert (type, init);
 336
 337   is_ctor = (TREE_CODE (fn) == ADDR_EXPR
 338              && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL
 339              && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn, 0)));
 340
 341   slot = build_local_temp (type);
 342
 343   /* We split the CALL_EXPR into its function and its arguments here.
 344      Then, in expand_expr, we put them back together.  The reason for
 345      this is that this expression might be a default argument
 346      expression.  In that case, we need a new temporary every time the
 347      expression is used.  That's what break_out_target_exprs does; it
 348      replaces every AGGR_INIT_EXPR with a copy that uses a fresh
 349      temporary slot.  Then, expand_expr builds up a call-expression
 350      using the new slot.  */
 351
 352   /* If we don't need to use a constructor to create an object of this
 353      type, don't mess with AGGR_INIT_EXPR.  */
 354   if (is_ctor || TREE_ADDRESSABLE (type))
 355     {
 356       if (TREE_CODE(init) == CALL_EXPR)
 357         rval = build_aggr_init_array (void_type_node, fn, slot,
 358                                       call_expr_nargs (init),
 359                                       CALL_EXPR_ARGP (init));
 360       else
 361         rval = build_aggr_init_array (void_type_node, fn, slot,
 362                                       aggr_init_expr_nargs (init),
 363                                       AGGR_INIT_EXPR_ARGP (init));
 364       TREE_SIDE_EFFECTS (rval) = 1;
 365       AGGR_INIT_VIA_CTOR_P (rval) = is_ctor;
 366     }
 367   else
 368     rval = init;
 369
 370   rval = build_target_expr (slot, rval);
 371   TARGET_EXPR_IMPLICIT_P (rval) = 1;
 372
 373   return rval;
 374 }
 375
 376 /* Build a TARGET_EXPR using INIT to initialize a new temporary of the
 377    indicated TYPE.  */
 378
 379 tree
 380 build_target_expr_with_type (tree init, tree type)
 381 {
 382   gcc_assert (!VOID_TYPE_P (type));
 383
 384   if (TREE_CODE (init) == TARGET_EXPR)
 385     return init;
 386   else if (CLASS_TYPE_P (type) && !TYPE_HAS_TRIVIAL_INIT_REF (type)
 387            && TREE_CODE (init) != COND_EXPR
 388            && TREE_CODE (init) != CONSTRUCTOR
 389            && TREE_CODE (init) != VA_ARG_EXPR)
 390     /* We need to build up a copy constructor call.  COND_EXPR is a special
 391        case because we already have copies on the arms and we don't want
 392        another one here.  A CONSTRUCTOR is aggregate initialization, which
 393        is handled separately.  A VA_ARG_EXPR is magic creation of an
 394        aggregate; there's no additional work to be done.  */
 395     return force_rvalue (init);
 396
 397   return force_target_expr (type, init);
 398 }
 399
 400 /* Like the above function, but without the checking.  This function should
 401    only be used by code which is deliberately trying to subvert the type
 402    system, such as call_builtin_trap.  */
 403
 404 tree
 405 force_target_expr (tree type, tree init)
 406 {
 407   tree slot;
 408
 409   gcc_assert (!VOID_TYPE_P (type));
 410
 411   slot = build_local_temp (type);
 412   return build_target_expr (slot, init);
 413 }
 414
 415 /* Like build_target_expr_with_type, but use the type of INIT.  */
 416
 417 tree
 418 get_target_expr (tree init)
 419 {
 420   return build_target_expr_with_type (init, TREE_TYPE (init));
 421 }
 422
 423 /* If EXPR is a bitfield reference, convert it to the declared type of
 424    the bitfield, and return the resulting expression.  Otherwise,
 425    return EXPR itself.  */
 426
 427 tree
 428 convert_bitfield_to_declared_type (tree expr)
 429 {
 430   tree bitfield_type;
 431
 432   bitfield_type = is_bitfield_expr_with_lowered_type (expr);
 433   if (bitfield_type)
 434     expr = convert_to_integer (TYPE_MAIN_VARIANT (bitfield_type),
 435                                expr);
 436   return expr;
 437 }
 438
 439 /* EXPR is being used in an rvalue context.  Return a version of EXPR
 440    that is marked as an rvalue.  */
 441
 442 tree
 443 rvalue (tree expr)
 444 {
 445   tree type;
 446
 447   if (error_operand_p (expr))
 448     return expr;
 449
 450   /* [basic.lval]
 451
 452      Non-class rvalues always have cv-unqualified types.  */
 453   type = TREE_TYPE (expr);
 454   if (!CLASS_TYPE_P (type) && cp_type_quals (type))
 455     type = TYPE_MAIN_VARIANT (type);
 456
 457   if (!processing_template_decl && real_lvalue_p (expr))
 458     expr = build1 (NON_LVALUE_EXPR, type, expr);
 459   else if (type != TREE_TYPE (expr))
 460     expr = build_nop (type, expr);
 461
 462   return expr;
 463 }
 464
 465 \f
 466 /* Hash an ARRAY_TYPE.  K is really of type `tree'.  */
 467
 468 static hashval_t
 469 cplus_array_hash (const void* k)
 470 {
 471   hashval_t hash;
 472   tree t = (tree) k;
 473
 474   hash = (htab_hash_pointer (TREE_TYPE (t))
 475           ^ htab_hash_pointer (TYPE_DOMAIN (t)));
 476
 477   return hash;
 478 }
 479
 480 typedef struct cplus_array_info {
 481   tree type;
 482   tree domain;
 483 } cplus_array_info;
 484
 485 /* Compare two ARRAY_TYPEs.  K1 is really of type `tree', K2 is really
 486    of type `cplus_array_info*'. */
 487
 488 static int
 489 cplus_array_compare (const void * k1, const void * k2)
 490 {
 491   tree t1 = (tree) k1;
 492   const cplus_array_info *t2 = (const cplus_array_info*) k2;
 493
 494   if (!comptypes (TREE_TYPE (t1), t2->type, COMPARE_STRUCTURAL))
 495     return 0;
 496
 497   if (!TYPE_DOMAIN (t1))
 498     return !t2->domain;
 499
 500   if (!t2->domain)
 501     return 0;
 502
 503   return comptypes (TYPE_DOMAIN (t1), t2->domain, COMPARE_STRUCTURAL);
 504 }
 505
 506 static GTY ((param_is (union tree_node))) htab_t cplus_array_htab;
 507
 508
 509 static tree
 510 build_cplus_array_type_1 (tree elt_type, tree index_type)
 511 {
 512   tree t;
 513
 514   if (elt_type == error_mark_node || index_type == error_mark_node)
 515     return error_mark_node;
 516
 517   if (dependent_type_p (elt_type)
 518       || (index_type
 519           && value_dependent_expression_p (TYPE_MAX_VALUE (index_type))))
 520     {
 521       void **e;
 522       cplus_array_info cai;
 523       hashval_t hash;
 524
 525       if (cplus_array_htab == NULL)
 526         cplus_array_htab = htab_create_ggc (61, &cplus_array_hash,
 527                                             &cplus_array_compare, NULL);
 528
 529       hash = (htab_hash_pointer (elt_type)
 530               ^ htab_hash_pointer (index_type));
 531       cai.type = elt_type;
 532       cai.domain = index_type;
 533
 534       e = htab_find_slot_with_hash (cplus_array_htab, &cai, hash, INSERT);
 535       if (*e)
 536         /* We have found the type: we're done. */
 537         return (tree) *e;
 538       else
 539         {
 540           /* Build a new array type. */
 541           t = make_node (ARRAY_TYPE);
 542           TREE_TYPE (t) = elt_type;
 543           TYPE_DOMAIN (t) = index_type;
 544
 545           /* Complete building the array type. */
 546           if (TYPE_STRUCTURAL_EQUALITY_P (elt_type)
 547               || (index_type && TYPE_STRUCTURAL_EQUALITY_P (index_type)))
 548             SET_TYPE_STRUCTURAL_EQUALITY (t);
 549           else if (TYPE_CANONICAL (elt_type) != elt_type
 550                    || (index_type
 551                        && TYPE_CANONICAL (index_type) != index_type))
 552             TYPE_CANONICAL (t)
 553               = TYPE_CANONICAL
 554                   (build_cplus_array_type_1 (TYPE_CANONICAL (elt_type),
 555                                              index_type?
 556                                                TYPE_CANONICAL (index_type)
 557                                                : index_type));
 558
 559           /* Store it in the hash table. */
 560           *e = t;
 561         }
 562     }
 563   else
 564     t = build_array_type (elt_type, index_type);
 565
 566   /* Push these needs up so that initialization takes place
 567      more easily.  */
 568   TYPE_NEEDS_CONSTRUCTING (t)
 569     = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type));
 570   TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
 571     = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type));
 572   return t;
 573 }
 574
 575 tree
 576 build_cplus_array_type (tree elt_type, tree index_type)
 577 {
 578   tree t;
 579   int type_quals = cp_type_quals (elt_type);
 580
 581   if (type_quals != TYPE_UNQUALIFIED)
 582     elt_type = cp_build_qualified_type (elt_type, TYPE_UNQUALIFIED);
 583
 584   t = build_cplus_array_type_1 (elt_type, index_type);
 585
 586   if (type_quals != TYPE_UNQUALIFIED)
 587     t = cp_build_qualified_type (t, type_quals);
 588
 589   return t;
 590 }
 591 \f
 592 /* Make a variant of TYPE, qualified with the TYPE_QUALS.  Handles
 593    arrays correctly.  In particular, if TYPE is an array of T's, and
 594    TYPE_QUALS is non-empty, returns an array of qualified T's.
 595
 596    FLAGS determines how to deal with illformed qualifications. If
 597    tf_ignore_bad_quals is set, then bad qualifications are dropped
 598    (this is permitted if TYPE was introduced via a typedef or template
 599    type parameter). If bad qualifications are dropped and tf_warning
 600    is set, then a warning is issued for non-const qualifications.  If
 601    tf_ignore_bad_quals is not set and tf_error is not set, we
 602    return error_mark_node. Otherwise, we issue an error, and ignore
 603    the qualifications.
 604
 605    Qualification of a reference type is valid when the reference came
 606    via a typedef or template type argument. [dcl.ref] No such
 607    dispensation is provided for qualifying a function type.  [dcl.fct]
 608    DR 295 queries this and the proposed resolution brings it into line
 609    with qualifying a reference.  We implement the DR.  We also behave
 610    in a similar manner for restricting non-pointer types.  */
 611
 612 tree
 613 cp_build_qualified_type_real (tree type,
 614                               int type_quals,
 615                               tsubst_flags_t complain)
 616 {
 617   tree result;
 618   int bad_quals = TYPE_UNQUALIFIED;
 619
 620   if (type == error_mark_node)
 621     return type;
 622
 623   if (type_quals == cp_type_quals (type))
 624     return type;
 625
 626   if (TREE_CODE (type) == ARRAY_TYPE)
 627     {
 628       /* In C++, the qualification really applies to the array element
 629          type.  Obtain the appropriately qualified element type.  */
 630       tree t;
 631       tree element_type
 632         = cp_build_qualified_type_real (TREE_TYPE (type),
 633                                         type_quals,
 634                                         complain);
 635
 636       if (element_type == error_mark_node)
 637         return error_mark_node;
 638
 639       /* See if we already have an identically qualified type.  */
 640       for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
 641         if (cp_type_quals (t) == type_quals
 642             && TYPE_NAME (t) == TYPE_NAME (type)
 643             && TYPE_CONTEXT (t) == TYPE_CONTEXT (type))
 644           break;
 645
 646       if (!t)
 647         {
 648           tree domain = TYPE_DOMAIN (type);
 649
 650           /* Make a new array type, just like the old one, but with the
 651              appropriately qualified element type.  */
 652           t = build_variant_type_copy (type);
 653           TREE_TYPE (t) = element_type;
 654
 655           /* This is a new type. */
 656           TYPE_CANONICAL (t) = t;
 657
 658           if (dependent_type_p (element_type)
 659               || (domain
 660                   && value_dependent_expression_p (TYPE_MAX_VALUE (domain))))
 661             {
 662               /* The new dependent array type we just created might be
 663                  equivalent to an existing dependent array type, so we
 664                  need to keep track of this new array type with a
 665                  lookup into CPLUS_ARRAY_HTAB. Note that we cannot
 666                  directly call build_cplus_array_type (that would
 667                  recurse) or build_cplus_array_type_1 (that would lose
 668                  attributes). */
 669               void **e;
 670               cplus_array_info cai;
 671               hashval_t hash;
 672
 673               if (cplus_array_htab == NULL)
 674                 cplus_array_htab = htab_create_ggc (61, &cplus_array_hash,
 675                                                     &cplus_array_compare,
 676                                                     NULL);
 677
 678               hash = (htab_hash_pointer (element_type)
 679                       ^ htab_hash_pointer (domain));
 680               cai.type = element_type;
 681               cai.domain = domain;
 682
 683               e = htab_find_slot_with_hash (cplus_array_htab, &cai, hash,
 684                                             INSERT);
 685               if (! *e)
 686                 /* Save this new type. */
 687                 *e = t;
 688             }
 689
 690           if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (t))
 691                    || (TYPE_DOMAIN (t)
 692                        && TYPE_STRUCTURAL_EQUALITY_P (TYPE_DOMAIN (t))))
 693             SET_TYPE_STRUCTURAL_EQUALITY (t);
 694           else
 695             TYPE_CANONICAL (t)
 696               = TYPE_CANONICAL
 697                   (build_array_type (TYPE_CANONICAL (TREE_TYPE (t)),
 698                                      TYPE_DOMAIN (t)?
 699                                        TYPE_CANONICAL (TYPE_DOMAIN(t))
 700                                        : TYPE_DOMAIN (t)));
 701         }
 702
 703       /* Even if we already had this variant, we update
 704          TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
 705          they changed since the variant was originally created.
 706
 707          This seems hokey; if there is some way to use a previous
 708          variant *without* coming through here,
 709          TYPE_NEEDS_CONSTRUCTING will never be updated.  */
 710       TYPE_NEEDS_CONSTRUCTING (t)
 711         = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type));
 712       TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
 713         = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type));
 714       return t;
 715     }
 716   else if (TYPE_PTRMEMFUNC_P (type))
 717     {
 718       /* For a pointer-to-member type, we can't just return a
 719          cv-qualified version of the RECORD_TYPE.  If we do, we
 720          haven't changed the field that contains the actual pointer to
 721          a method, and so TYPE_PTRMEMFUNC_FN_TYPE will be wrong.  */
 722       tree t;
 723
 724       t = TYPE_PTRMEMFUNC_FN_TYPE (type);
 725       t = cp_build_qualified_type_real (t, type_quals, complain);
 726       return build_ptrmemfunc_type (t);
 727     }
 728
 729   /* A reference or method type shall not be cv qualified.
 730      [dcl.ref], [dct.fct]  */
 731   if (type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)
 732       && (TREE_CODE (type) == REFERENCE_TYPE
 733           || TREE_CODE (type) == METHOD_TYPE))
 734     {
 735       bad_quals |= type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
 736       type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
 737     }
 738
 739   /* A restrict-qualified type must be a pointer (or reference)
 740      to object or incomplete type, or a function type. */
 741   if ((type_quals & TYPE_QUAL_RESTRICT)
 742       && TREE_CODE (type) != TEMPLATE_TYPE_PARM
 743       && TREE_CODE (type) != TYPENAME_TYPE
 744       && TREE_CODE (type) != FUNCTION_TYPE
 745       && !POINTER_TYPE_P (type))
 746     {
 747       bad_quals |= TYPE_QUAL_RESTRICT;
 748       type_quals &= ~TYPE_QUAL_RESTRICT;
 749     }
 750
 751   if (bad_quals == TYPE_UNQUALIFIED)
 752     /*OK*/;
 753   else if (!(complain & (tf_error | tf_ignore_bad_quals)))
 754     return error_mark_node;
 755   else
 756     {
 757       if (complain & tf_ignore_bad_quals)
 758         /* We're not going to warn about constifying things that can't
 759            be constified.  */
 760         bad_quals &= ~TYPE_QUAL_CONST;
 761       if (bad_quals)
 762         {
 763           tree bad_type = build_qualified_type (ptr_type_node, bad_quals);
 764
 765           if (!(complain & tf_ignore_bad_quals))
 766             error ("%qV qualifiers cannot be applied to %qT",
 767                    bad_type, type);
 768         }
 769     }
 770
 771   /* Retrieve (or create) the appropriately qualified variant.  */
 772   result = build_qualified_type (type, type_quals);
 773
 774   /* If this was a pointer-to-method type, and we just made a copy,
 775      then we need to unshare the record that holds the cached
 776      pointer-to-member-function type, because these will be distinct
 777      between the unqualified and qualified types.  */
 778   if (result != type
 779       && TREE_CODE (type) == POINTER_TYPE
 780       && TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE)
 781     TYPE_LANG_SPECIFIC (result) = NULL;
 782
 783   return result;
 784 }
 785
 786 /* Returns the canonical version of TYPE.  In other words, if TYPE is
 787    a typedef, returns the underlying type.  The cv-qualification of
 788    the type returned matches the type input; they will always be
 789    compatible types.  */
 790
 791 tree
 792 canonical_type_variant (tree t)
 793 {
 794   return cp_build_qualified_type (TYPE_MAIN_VARIANT (t), cp_type_quals (t));
 795 }
 796 \f
 797 /* Makes a copy of BINFO and TYPE, which is to be inherited into a
 798    graph dominated by T.  If BINFO is NULL, TYPE is a dependent base,
 799    and we do a shallow copy.  If BINFO is non-NULL, we do a deep copy.
 800    VIRT indicates whether TYPE is inherited virtually or not.
 801    IGO_PREV points at the previous binfo of the inheritance graph
 802    order chain.  The newly copied binfo's TREE_CHAIN forms this
 803    ordering.
 804
 805    The CLASSTYPE_VBASECLASSES vector of T is constructed in the
 806    correct order. That is in the order the bases themselves should be
 807    constructed in.
 808
 809    The BINFO_INHERITANCE of a virtual base class points to the binfo
 810    of the most derived type. ??? We could probably change this so that
 811    BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence
 812    remove a field.  They currently can only differ for primary virtual
 813    virtual bases.  */
 814
 815 tree
 816 copy_binfo (tree binfo, tree type, tree t, tree *igo_prev, int virt)
 817 {
 818   tree new_binfo;
 819
 820   if (virt)
 821     {
 822       /* See if we've already made this virtual base.  */
 823       new_binfo = binfo_for_vbase (type, t);
 824       if (new_binfo)
 825         return new_binfo;
 826     }
 827
 828   new_binfo = make_tree_binfo (binfo ? BINFO_N_BASE_BINFOS (binfo) : 0);
 829   BINFO_TYPE (new_binfo) = type;
 830
 831   /* Chain it into the inheritance graph.  */
 832   TREE_CHAIN (*igo_prev) = new_binfo;
 833   *igo_prev = new_binfo;
 834
 835   if (binfo)
 836     {
 837       int ix;
 838       tree base_binfo;
 839
 840       gcc_assert (!BINFO_DEPENDENT_BASE_P (binfo));
 841       gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), type));
 842
 843       BINFO_OFFSET (new_binfo) = BINFO_OFFSET (binfo);
 844       BINFO_VIRTUALS (new_binfo) = BINFO_VIRTUALS (binfo);
 845
 846       /* We do not need to copy the accesses, as they are read only.  */
 847       BINFO_BASE_ACCESSES (new_binfo) = BINFO_BASE_ACCESSES (binfo);
 848
 849       /* Recursively copy base binfos of BINFO.  */
 850       for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
 851         {
 852           tree new_base_binfo;
 853
 854           gcc_assert (!BINFO_DEPENDENT_BASE_P (base_binfo));
 855           new_base_binfo = copy_binfo (base_binfo, BINFO_TYPE (base_binfo),
 856                                        t, igo_prev,
 857                                        BINFO_VIRTUAL_P (base_binfo));
 858
 859           if (!BINFO_INHERITANCE_CHAIN (new_base_binfo))
 860             BINFO_INHERITANCE_CHAIN (new_base_binfo) = new_binfo;
 861           BINFO_BASE_APPEND (new_binfo, new_base_binfo);
 862         }
 863     }
 864   else
 865     BINFO_DEPENDENT_BASE_P (new_binfo) = 1;
 866
 867   if (virt)
 868     {
 869       /* Push it onto the list after any virtual bases it contains
 870          will have been pushed.  */
 871       VEC_quick_push (tree, CLASSTYPE_VBASECLASSES (t), new_binfo);
 872       BINFO_VIRTUAL_P (new_binfo) = 1;
 873       BINFO_INHERITANCE_CHAIN (new_binfo) = TYPE_BINFO (t);
 874     }
 875
 876   return new_binfo;
 877 }
 878 \f
 879 /* Hashing of lists so that we don't make duplicates.
 880    The entry point is `list_hash_canon'.  */
 881
 882 /* Now here is the hash table.  When recording a list, it is added
 883    to the slot whose index is the hash code mod the table size.
 884    Note that the hash table is used for several kinds of lists.
 885    While all these live in the same table, they are completely independent,
 886    and the hash code is computed differently for each of these.  */
 887
 888 static GTY ((param_is (union tree_node))) htab_t list_hash_table;
 889
 890 struct list_proxy
 891 {
 892   tree purpose;
 893   tree value;
 894   tree chain;
 895 };
 896
 897 /* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy
 898    for a node we are thinking about adding).  */
 899
 900 static int
 901 list_hash_eq (const void* entry, const void* data)
 902 {
 903   tree t = (tree) entry;
 904   struct list_proxy *proxy = (struct list_proxy *) data;
 905
 906   return (TREE_VALUE (t) == proxy->value
 907           && TREE_PURPOSE (t) == proxy->purpose
 908           && TREE_CHAIN (t) == proxy->chain);
 909 }
 910
 911 /* Compute a hash code for a list (chain of TREE_LIST nodes
 912    with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
 913    TREE_COMMON slots), by adding the hash codes of the individual entries.  */
 914
 915 static hashval_t
 916 list_hash_pieces (tree purpose, tree value, tree chain)
 917 {
 918   hashval_t hashcode = 0;
 919
 920   if (chain)
 921     hashcode += TREE_HASH (chain);
 922
 923   if (value)
 924     hashcode += TREE_HASH (value);
 925   else
 926     hashcode += 1007;
 927   if (purpose)
 928     hashcode += TREE_HASH (purpose);
 929   else
 930     hashcode += 1009;
 931   return hashcode;
 932 }
 933
 934 /* Hash an already existing TREE_LIST.  */
 935
 936 static hashval_t
 937 list_hash (const void* p)
 938 {
 939   tree t = (tree) p;
 940   return list_hash_pieces (TREE_PURPOSE (t),
 941                            TREE_VALUE (t),
 942                            TREE_CHAIN (t));
 943 }
 944
 945 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
 946    object for an identical list if one already exists.  Otherwise, build a
 947    new one, and record it as the canonical object.  */
 948
 949 tree
 950 hash_tree_cons (tree purpose, tree value, tree chain)
 951 {
 952   int hashcode = 0;
 953   void **slot;
 954   struct list_proxy proxy;
 955
 956   /* Hash the list node.  */
 957   hashcode = list_hash_pieces (purpose, value, chain);
 958   /* Create a proxy for the TREE_LIST we would like to create.  We
 959      don't actually create it so as to avoid creating garbage.  */
 960   proxy.purpose = purpose;
 961   proxy.value = value;
 962   proxy.chain = chain;
 963   /* See if it is already in the table.  */
 964   slot = htab_find_slot_with_hash (list_hash_table, &proxy, hashcode,
 965                                    INSERT);
 966   /* If not, create a new node.  */
 967   if (!*slot)
 968     *slot = tree_cons (purpose, value, chain);
 969   return (tree) *slot;
 970 }
 971
 972 /* Constructor for hashed lists.  */
 973
 974 tree
 975 hash_tree_chain (tree value, tree chain)
 976 {
 977   return hash_tree_cons (NULL_TREE, value, chain);
 978 }
 979 \f
 980 void
 981 debug_binfo (tree elem)
 982 {
 983   HOST_WIDE_INT n;
 984   tree virtuals;
 985
 986   fprintf (stderr, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC
 987            "\nvtable type:\n",
 988            TYPE_NAME_STRING (BINFO_TYPE (elem)),
 989            TREE_INT_CST_LOW (BINFO_OFFSET (elem)));
 990   debug_tree (BINFO_TYPE (elem));
 991   if (BINFO_VTABLE (elem))
 992     fprintf (stderr, "vtable decl \"%s\"\n",
 993              IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem))));
 994   else
 995     fprintf (stderr, "no vtable decl yet\n");
 996   fprintf (stderr, "virtuals:\n");
 997   virtuals = BINFO_VIRTUALS (elem);
 998   n = 0;
 999
1000   while (virtuals)
1001     {
1002       tree fndecl = TREE_VALUE (virtuals);
1003       fprintf (stderr, "%s [%ld =? %ld]\n",
1004                IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)),
1005                (long) n, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl)));
1006       ++n;
1007       virtuals = TREE_CHAIN (virtuals);
1008     }
1009 }
1010
1011 /* Build a representation for the qualified name SCOPE::NAME.  TYPE is
1012    the type of the result expression, if known, or NULL_TREE if the
1013    resulting expression is type-dependent.  If TEMPLATE_P is true,
1014    NAME is known to be a template because the user explicitly used the
1015    "template" keyword after the "::".
1016
1017    All SCOPE_REFs should be built by use of this function.  */
1018
1019 tree
1020 build_qualified_name (tree type, tree scope, tree name, bool template_p)
1021 {
1022   tree t;
1023   if (type == error_mark_node
1024       || scope == error_mark_node
1025       || name == error_mark_node)
1026     return error_mark_node;
1027   t = build2 (SCOPE_REF, type, scope, name);
1028   QUALIFIED_NAME_IS_TEMPLATE (t) = template_p;
1029   return t;
1030 }
1031
1032 /* Returns nonzero if X is an expression for a (possibly overloaded)
1033    function.  If "f" is a function or function template, "f", "c->f",
1034    "c.f", "C::f", and "f<int>" will all be considered possibly
1035    overloaded functions.  Returns 2 if the function is actually
1036    overloaded, i.e., if it is impossible to know the type of the
1037    function without performing overload resolution.  */
1038
1039 int
1040 is_overloaded_fn (tree x)
1041 {
1042   /* A baselink is also considered an overloaded function.  */
1043   if (TREE_CODE (x) == OFFSET_REF
1044       || TREE_CODE (x) == COMPONENT_REF)
1045     x = TREE_OPERAND (x, 1);
1046   if (BASELINK_P (x))
1047     x = BASELINK_FUNCTIONS (x);
1048   if (TREE_CODE (x) == TEMPLATE_ID_EXPR
1049       || DECL_FUNCTION_TEMPLATE_P (OVL_CURRENT (x))
1050       || (TREE_CODE (x) == OVERLOAD && OVL_CHAIN (x)))
1051     return 2;
1052   return  (TREE_CODE (x) == FUNCTION_DECL
1053            || TREE_CODE (x) == OVERLOAD);
1054 }
1055
1056 /* Returns true iff X is an expression for an overloaded function
1057    whose type cannot be known without performing overload
1058    resolution.  */
1059
1060 bool
1061 really_overloaded_fn (tree x)
1062 {
1063   return is_overloaded_fn (x) == 2;
1064 }
1065
1066 tree
1067 get_first_fn (tree from)
1068 {
1069   gcc_assert (is_overloaded_fn (from));
1070   /* A baselink is also considered an overloaded function.  */
1071   if (TREE_CODE (from) == COMPONENT_REF)
1072     from = TREE_OPERAND (from, 1);
1073   if (BASELINK_P (from))
1074     from = BASELINK_FUNCTIONS (from);
1075   return OVL_CURRENT (from);
1076 }
1077
1078 /* Return a new OVL node, concatenating it with the old one.  */
1079
1080 tree
1081 ovl_cons (tree decl, tree chain)
1082 {
1083   tree result = make_node (OVERLOAD);
1084   TREE_TYPE (result) = unknown_type_node;
1085   OVL_FUNCTION (result) = decl;
1086   TREE_CHAIN (result) = chain;
1087
1088   return result;
1089 }
1090
1091 /* Build a new overloaded function. If this is the first one,
1092    just return it; otherwise, ovl_cons the _DECLs */
1093
1094 tree
1095 build_overload (tree decl, tree chain)
1096 {
1097   if (! chain && TREE_CODE (decl) != TEMPLATE_DECL)
1098     return decl;
1099   if (chain && TREE_CODE (chain) != OVERLOAD)
1100     chain = ovl_cons (chain, NULL_TREE);
1101   return ovl_cons (decl, chain);
1102 }
1103
1104 \f
1105 #define PRINT_RING_SIZE 4
1106
1107 const char *
1108 cxx_printable_name (tree decl, int v)
1109 {
1110   static tree decl_ring[PRINT_RING_SIZE];
1111   static char *print_ring[PRINT_RING_SIZE];
1112   static int ring_counter;
1113   int i;
1114
1115   /* Only cache functions.  */
1116   if (v < 2
1117       || TREE_CODE (decl) != FUNCTION_DECL
1118       || DECL_LANG_SPECIFIC (decl) == 0)
1119     return lang_decl_name (decl, v);
1120
1121   /* See if this print name is lying around.  */
1122   for (i = 0; i < PRINT_RING_SIZE; i++)
1123     if (decl_ring[i] == decl)
1124       /* yes, so return it.  */
1125       return print_ring[i];
1126
1127   if (++ring_counter == PRINT_RING_SIZE)
1128     ring_counter = 0;
1129
1130   if (current_function_decl != NULL_TREE)
1131     {
1132       if (decl_ring[ring_counter] == current_function_decl)
1133         ring_counter += 1;
1134       if (ring_counter == PRINT_RING_SIZE)
1135         ring_counter = 0;
1136       gcc_assert (decl_ring[ring_counter] != current_function_decl);
1137     }
1138
1139   if (print_ring[ring_counter])
1140     free (print_ring[ring_counter]);
1141
1142   print_ring[ring_counter] = xstrdup (lang_decl_name (decl, v));
1143   decl_ring[ring_counter] = decl;
1144   return print_ring[ring_counter];
1145 }
1146 \f
1147 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
1148    listed in RAISES.  */
1149
1150 tree
1151 build_exception_variant (tree type, tree raises)
1152 {
1153   tree v = TYPE_MAIN_VARIANT (type);
1154   int type_quals = TYPE_QUALS (type);
1155
1156   for (; v; v = TYPE_NEXT_VARIANT (v))
1157     if (check_qualified_type (v, type, type_quals)
1158         && comp_except_specs (raises, TYPE_RAISES_EXCEPTIONS (v), 1))
1159       return v;
1160
1161   /* Need to build a new variant.  */
1162   v = build_variant_type_copy (type);
1163   TYPE_RAISES_EXCEPTIONS (v) = raises;
1164   return v;
1165 }
1166
1167 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new
1168    BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template
1169    arguments.  */
1170
1171 tree
1172 bind_template_template_parm (tree t, tree newargs)
1173 {
1174   tree decl = TYPE_NAME (t);
1175   tree t2;
1176
1177   t2 = make_aggr_type (BOUND_TEMPLATE_TEMPLATE_PARM);
1178   decl = build_decl (TYPE_DECL, DECL_NAME (decl), NULL_TREE);
1179
1180   /* These nodes have to be created to reflect new TYPE_DECL and template
1181      arguments.  */
1182   TEMPLATE_TYPE_PARM_INDEX (t2) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t));
1183   TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2)) = decl;
1184   TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2)
1185     = tree_cons (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t),
1186                  newargs, NULL_TREE);
1187
1188   TREE_TYPE (decl) = t2;
1189   TYPE_NAME (t2) = decl;
1190   TYPE_STUB_DECL (t2) = decl;
1191   TYPE_SIZE (t2) = 0;
1192   SET_TYPE_STRUCTURAL_EQUALITY (t2);
1193
1194   return t2;
1195 }
1196
1197 /* Called from count_trees via walk_tree.  */
1198
1199 static tree
1200 count_trees_r (tree *tp, int *walk_subtrees, void *data)
1201 {
1202   ++*((int *) data);
1203
1204   if (TYPE_P (*tp))
1205     *walk_subtrees = 0;
1206
1207   return NULL_TREE;
1208 }
1209
1210 /* Debugging function for measuring the rough complexity of a tree
1211    representation.  */
1212
1213 int
1214 count_trees (tree t)
1215 {
1216   int n_trees = 0;
1217   walk_tree_without_duplicates (&t, count_trees_r, &n_trees);
1218   return n_trees;
1219 }
1220
1221 /* Called from verify_stmt_tree via walk_tree.  */
1222
1223 static tree
1224 verify_stmt_tree_r (tree* tp,
1225                     int* walk_subtrees ATTRIBUTE_UNUSED ,
1226                     void* data)
1227 {
1228   tree t = *tp;
1229   htab_t *statements = (htab_t *) data;
1230   void **slot;
1231
1232   if (!STATEMENT_CODE_P (TREE_CODE (t)))
1233     return NULL_TREE;
1234
1235   /* If this statement is already present in the hash table, then
1236      there is a circularity in the statement tree.  */
1237   gcc_assert (!htab_find (*statements, t));
1238
1239   slot = htab_find_slot (*statements, t, INSERT);
1240   *slot = t;
1241
1242   return NULL_TREE;
1243 }
1244
1245 /* Debugging function to check that the statement T has not been
1246    corrupted.  For now, this function simply checks that T contains no
1247    circularities.  */
1248
1249 void
1250 verify_stmt_tree (tree t)
1251 {
1252   htab_t statements;
1253   statements = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
1254   walk_tree (&t, verify_stmt_tree_r, &statements, NULL);
1255   htab_delete (statements);
1256 }
1257
1258 /* Check if the type T depends on a type with no linkage and if so, return
1259    it.  If RELAXED_P then do not consider a class type declared within
1260    a TREE_PUBLIC function to have no linkage.  */
1261
1262 tree
1263 no_linkage_check (tree t, bool relaxed_p)
1264 {
1265   tree r;
1266
1267   /* There's no point in checking linkage on template functions; we
1268      can't know their complete types.  */
1269   if (processing_template_decl)
1270     return NULL_TREE;
1271
1272   switch (TREE_CODE (t))
1273     {
1274       tree fn;
1275
1276     case RECORD_TYPE:
1277       if (TYPE_PTRMEMFUNC_P (t))
1278         goto ptrmem;
1279       /* Fall through.  */
1280     case UNION_TYPE:
1281       if (!CLASS_TYPE_P (t))
1282         return NULL_TREE;
1283       /* Fall through.  */
1284     case ENUMERAL_TYPE:
1285       if (TYPE_ANONYMOUS_P (t))
1286         return t;
1287       fn = decl_function_context (TYPE_MAIN_DECL (t));
1288       if (fn && (!relaxed_p || !TREE_PUBLIC (fn)))
1289         return t;
1290       return NULL_TREE;
1291
1292     case ARRAY_TYPE:
1293     case POINTER_TYPE:
1294     case REFERENCE_TYPE:
1295       return no_linkage_check (TREE_TYPE (t), relaxed_p);
1296
1297     case OFFSET_TYPE:
1298     ptrmem:
1299       r = no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t),
1300                             relaxed_p);
1301       if (r)
1302         return r;
1303       return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t), relaxed_p);
1304
1305     case METHOD_TYPE:
1306       r = no_linkage_check (TYPE_METHOD_BASETYPE (t), relaxed_p);
1307       if (r)
1308         return r;
1309       /* Fall through.  */
1310     case FUNCTION_TYPE:
1311       {
1312         tree parm;
1313         for (parm = TYPE_ARG_TYPES (t);
1314              parm && parm != void_list_node;
1315              parm = TREE_CHAIN (parm))
1316           {
1317             r = no_linkage_check (TREE_VALUE (parm), relaxed_p);
1318             if (r)
1319               return r;
1320           }
1321         return no_linkage_check (TREE_TYPE (t), relaxed_p);
1322       }
1323
1324     default:
1325       return NULL_TREE;
1326     }
1327 }
1328
1329 #ifdef GATHER_STATISTICS
1330 extern int depth_reached;
1331 #endif
1332
1333 void
1334 cxx_print_statistics (void)
1335 {
1336   print_search_statistics ();
1337   print_class_statistics ();
1338 #ifdef GATHER_STATISTICS
1339   fprintf (stderr, "maximum template instantiation depth reached: %d\n",
1340            depth_reached);
1341 #endif
1342 }
1343
1344 /* Return, as an INTEGER_CST node, the number of elements for TYPE
1345    (which is an ARRAY_TYPE).  This counts only elements of the top
1346    array.  */
1347
1348 tree
1349 array_type_nelts_top (tree type)
1350 {
1351   return fold_build2 (PLUS_EXPR, sizetype,
1352                       array_type_nelts (type),
1353                       integer_one_node);
1354 }
1355
1356 /* Return, as an INTEGER_CST node, the number of elements for TYPE
1357    (which is an ARRAY_TYPE).  This one is a recursive count of all
1358    ARRAY_TYPEs that are clumped together.  */
1359
1360 tree
1361 array_type_nelts_total (tree type)
1362 {
1363   tree sz = array_type_nelts_top (type);
1364   type = TREE_TYPE (type);
1365   while (TREE_CODE (type) == ARRAY_TYPE)
1366     {
1367       tree n = array_type_nelts_top (type);
1368       sz = fold_build2 (MULT_EXPR, sizetype, sz, n);
1369       type = TREE_TYPE (type);
1370     }
1371   return sz;
1372 }
1373
1374 /* Called from break_out_target_exprs via mapcar.  */
1375
1376 static tree
1377 bot_manip (tree* tp, int* walk_subtrees, void* data)
1378 {
1379   splay_tree target_remap = ((splay_tree) data);
1380   tree t = *tp;
1381
1382   if (!TYPE_P (t) && TREE_CONSTANT (t))
1383     {
1384       /* There can't be any TARGET_EXPRs or their slot variables below
1385          this point.  We used to check !TREE_SIDE_EFFECTS, but then we
1386          failed to copy an ADDR_EXPR of the slot VAR_DECL.  */
1387       *walk_subtrees = 0;
1388       return NULL_TREE;
1389     }
1390   if (TREE_CODE (t) == TARGET_EXPR)
1391     {
1392       tree u;
1393
1394       if (TREE_CODE (TREE_OPERAND (t, 1)) == AGGR_INIT_EXPR)
1395         u = build_cplus_new
1396           (TREE_TYPE (t), break_out_target_exprs (TREE_OPERAND (t, 1)));
1397       else
1398         u = build_target_expr_with_type
1399           (break_out_target_exprs (TREE_OPERAND (t, 1)), TREE_TYPE (t));
1400
1401       /* Map the old variable to the new one.  */
1402       splay_tree_insert (target_remap,
1403                          (splay_tree_key) TREE_OPERAND (t, 0),
1404                          (splay_tree_value) TREE_OPERAND (u, 0));
1405
1406       /* Replace the old expression with the new version.  */
1407       *tp = u;
1408       /* We don't have to go below this point; the recursive call to
1409          break_out_target_exprs will have handled anything below this
1410          point.  */
1411       *walk_subtrees = 0;
1412       return NULL_TREE;
1413     }
1414
1415   /* Make a copy of this node.  */
1416   return copy_tree_r (tp, walk_subtrees, NULL);
1417 }
1418
1419 /* Replace all remapped VAR_DECLs in T with their new equivalents.
1420    DATA is really a splay-tree mapping old variables to new
1421    variables.  */
1422
1423 static tree
1424 bot_replace (tree* t,
1425              int* walk_subtrees ATTRIBUTE_UNUSED ,
1426              void* data)
1427 {
1428   splay_tree target_remap = ((splay_tree) data);
1429
1430   if (TREE_CODE (*t) == VAR_DECL)
1431     {
1432       splay_tree_node n = splay_tree_lookup (target_remap,
1433                                              (splay_tree_key) *t);
1434       if (n)
1435         *t = (tree) n->value;
1436     }
1437
1438   return NULL_TREE;
1439 }
1440
1441 /* When we parse a default argument expression, we may create
1442    temporary variables via TARGET_EXPRs.  When we actually use the
1443    default-argument expression, we make a copy of the expression, but
1444    we must replace the temporaries with appropriate local versions.  */
1445
1446 tree
1447 break_out_target_exprs (tree t)
1448 {
1449   static int target_remap_count;
1450   static splay_tree target_remap;
1451
1452   if (!target_remap_count++)
1453     target_remap = splay_tree_new (splay_tree_compare_pointers,
1454                                    /*splay_tree_delete_key_fn=*/NULL,
1455                                    /*splay_tree_delete_value_fn=*/NULL);
1456   walk_tree (&t, bot_manip, target_remap, NULL);
1457   walk_tree (&t, bot_replace, target_remap, NULL);
1458
1459   if (!--target_remap_count)
1460     {
1461       splay_tree_delete (target_remap);
1462       target_remap = NULL;
1463     }
1464
1465   return t;
1466 }
1467
1468 /* Similar to `build_nt', but for template definitions of dependent
1469    expressions  */
1470
1471 tree
1472 build_min_nt (enum tree_code code, ...)
1473 {
1474   tree t;
1475   int length;
1476   int i;
1477   va_list p;
1478
1479   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
1480
1481   va_start (p, code);
1482
1483   t = make_node (code);
1484   length = TREE_CODE_LENGTH (code);
1485
1486   for (i = 0; i < length; i++)
1487     {
1488       tree x = va_arg (p, tree);
1489       TREE_OPERAND (t, i) = x;
1490     }
1491
1492   va_end (p);
1493   return t;
1494 }
1495
1496
1497 /* Similar to `build', but for template definitions.  */
1498
1499 tree
1500 build_min (enum tree_code code, tree tt, ...)
1501 {
1502   tree t;
1503   int length;
1504   int i;
1505   va_list p;
1506
1507   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
1508
1509   va_start (p, tt);
1510
1511   t = make_node (code);
1512   length = TREE_CODE_LENGTH (code);
1513   TREE_TYPE (t) = tt;
1514
1515   for (i = 0; i < length; i++)
1516     {
1517       tree x = va_arg (p, tree);
1518       TREE_OPERAND (t, i) = x;
1519       if (x && !TYPE_P (x) && TREE_SIDE_EFFECTS (x))
1520         TREE_SIDE_EFFECTS (t) = 1;
1521     }
1522
1523   va_end (p);
1524   return t;
1525 }
1526
1527 /* Similar to `build', but for template definitions of non-dependent
1528    expressions. NON_DEP is the non-dependent expression that has been
1529    built.  */
1530
1531 tree
1532 build_min_non_dep (enum tree_code code, tree non_dep, ...)
1533 {
1534   tree t;
1535   int length;
1536   int i;
1537   va_list p;
1538
1539   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
1540
1541   va_start (p, non_dep);
1542
1543   t = make_node (code);
1544   length = TREE_CODE_LENGTH (code);
1545   TREE_TYPE (t) = TREE_TYPE (non_dep);
1546   TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (non_dep);
1547
1548   for (i = 0; i < length; i++)
1549     {
1550       tree x = va_arg (p, tree);
1551       TREE_OPERAND (t, i) = x;
1552     }
1553
1554   if (code == COMPOUND_EXPR && TREE_CODE (non_dep) != COMPOUND_EXPR)
1555     /* This should not be considered a COMPOUND_EXPR, because it
1556        resolves to an overload.  */
1557     COMPOUND_EXPR_OVERLOADED (t) = 1;
1558
1559   va_end (p);
1560   return t;
1561 }
1562
1563 /* Similar to `build_call_list', but for template definitions of non-dependent
1564    expressions. NON_DEP is the non-dependent expression that has been
1565    built.  */
1566
1567 tree
1568 build_min_non_dep_call_list (tree non_dep, tree fn, tree arglist)
1569 {
1570   tree t = build_nt_call_list (fn, arglist);
1571   TREE_TYPE (t) = TREE_TYPE (non_dep);
1572   TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (non_dep);
1573   return t;
1574 }
1575
1576 tree
1577 get_type_decl (tree t)
1578 {
1579   if (TREE_CODE (t) == TYPE_DECL)
1580     return t;
1581   if (TYPE_P (t))
1582     return TYPE_STUB_DECL (t);
1583   gcc_assert (t == error_mark_node);
1584   return t;
1585 }
1586
1587 /* Returns the namespace that contains DECL, whether directly or
1588    indirectly.  */
1589
1590 tree
1591 decl_namespace_context (tree decl)
1592 {
1593   while (1)
1594     {
1595       if (TREE_CODE (decl) == NAMESPACE_DECL)
1596         return decl;
1597       else if (TYPE_P (decl))
1598         decl = CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl));
1599       else
1600         decl = CP_DECL_CONTEXT (decl);
1601     }
1602 }
1603
1604 /* Returns true if decl is within an anonymous namespace, however deeply
1605    nested, or false otherwise.  */
1606
1607 bool
1608 decl_anon_ns_mem_p (tree decl)
1609 {
1610   while (1)
1611     {
1612       if (decl == NULL_TREE || decl == error_mark_node)
1613         return false;
1614       if (TREE_CODE (decl) == NAMESPACE_DECL
1615           && DECL_NAME (decl) == NULL_TREE)
1616         return true;
1617       /* Classes and namespaces inside anonymous namespaces have
1618          TREE_PUBLIC == 0, so we can shortcut the search.  */
1619       else if (TYPE_P (decl))
1620         return (TREE_PUBLIC (TYPE_NAME (decl)) == 0);
1621       else if (TREE_CODE (decl) == NAMESPACE_DECL)
1622         return (TREE_PUBLIC (decl) == 0);
1623       else
1624         decl = DECL_CONTEXT (decl);
1625     }
1626 }
1627
1628 /* Return truthvalue of whether T1 is the same tree structure as T2.
1629    Return 1 if they are the same. Return 0 if they are different.  */
1630
1631 bool
1632 cp_tree_equal (tree t1, tree t2)
1633 {
1634   enum tree_code code1, code2;
1635
1636   if (t1 == t2)
1637     return true;
1638   if (!t1 || !t2)
1639     return false;
1640
1641   for (code1 = TREE_CODE (t1);
1642        code1 == NOP_EXPR || code1 == CONVERT_EXPR
1643          || code1 == NON_LVALUE_EXPR;
1644        code1 = TREE_CODE (t1))
1645     t1 = TREE_OPERAND (t1, 0);
1646   for (code2 = TREE_CODE (t2);
1647        code2 == NOP_EXPR || code2 == CONVERT_EXPR
1648          || code1 == NON_LVALUE_EXPR;
1649        code2 = TREE_CODE (t2))
1650     t2 = TREE_OPERAND (t2, 0);
1651
1652   /* They might have become equal now.  */
1653   if (t1 == t2)
1654     return true;
1655
1656   if (code1 != code2)
1657     return false;
1658
1659   switch (code1)
1660     {
1661     case INTEGER_CST:
1662       return TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
1663         && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2);
1664
1665     case REAL_CST:
1666       return REAL_VALUES_EQUAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
1667
1668     case STRING_CST:
1669       return TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
1670         && !memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
1671                     TREE_STRING_LENGTH (t1));
1672
1673     case CONSTRUCTOR:
1674       /* We need to do this when determining whether or not two
1675          non-type pointer to member function template arguments
1676          are the same.  */
1677       if (!(same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
1678             /* The first operand is RTL.  */
1679             && TREE_OPERAND (t1, 0) == TREE_OPERAND (t2, 0)))
1680         return false;
1681       return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
1682
1683     case TREE_LIST:
1684       if (!cp_tree_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2)))
1685         return false;
1686       if (!cp_tree_equal (TREE_VALUE (t1), TREE_VALUE (t2)))
1687         return false;
1688       return cp_tree_equal (TREE_CHAIN (t1), TREE_CHAIN (t2));
1689
1690     case SAVE_EXPR:
1691       return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
1692
1693     case CALL_EXPR:
1694       {
1695         tree arg1, arg2;
1696         call_expr_arg_iterator iter1, iter2;
1697         if (!cp_tree_equal (CALL_EXPR_FN (t1), CALL_EXPR_FN (t2)))
1698           return false;
1699         for (arg1 = first_call_expr_arg (t1, &iter1),
1700                arg2 = first_call_expr_arg (t2, &iter2);
1701              arg1 && arg2;
1702              arg1 = next_call_expr_arg (&iter1),
1703                arg2 = next_call_expr_arg (&iter2))
1704           if (!cp_tree_equal (arg1, arg2))
1705             return false;
1706         return (arg1 || arg2);
1707       }
1708
1709     case TARGET_EXPR:
1710       {
1711         tree o1 = TREE_OPERAND (t1, 0);
1712         tree o2 = TREE_OPERAND (t2, 0);
1713
1714         /* Special case: if either target is an unallocated VAR_DECL,
1715            it means that it's going to be unified with whatever the
1716            TARGET_EXPR is really supposed to initialize, so treat it
1717            as being equivalent to anything.  */
1718         if (TREE_CODE (o1) == VAR_DECL && DECL_NAME (o1) == NULL_TREE
1719             && !DECL_RTL_SET_P (o1))
1720           /*Nop*/;
1721         else if (TREE_CODE (o2) == VAR_DECL && DECL_NAME (o2) == NULL_TREE
1722                  && !DECL_RTL_SET_P (o2))
1723           /*Nop*/;
1724         else if (!cp_tree_equal (o1, o2))
1725           return false;
1726
1727         return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
1728       }
1729
1730     case WITH_CLEANUP_EXPR:
1731       if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
1732         return false;
1733       return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
1734
1735     case COMPONENT_REF:
1736       if (TREE_OPERAND (t1, 1) != TREE_OPERAND (t2, 1))
1737         return false;
1738       return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
1739
1740     case VAR_DECL:
1741     case PARM_DECL:
1742     case CONST_DECL:
1743     case FUNCTION_DECL:
1744     case TEMPLATE_DECL:
1745     case IDENTIFIER_NODE:
1746     case SSA_NAME:
1747       return false;
1748
1749     case BASELINK:
1750       return (BASELINK_BINFO (t1) == BASELINK_BINFO (t2)
1751               && BASELINK_ACCESS_BINFO (t1) == BASELINK_ACCESS_BINFO (t2)
1752               && cp_tree_equal (BASELINK_FUNCTIONS (t1),
1753                                 BASELINK_FUNCTIONS (t2)));
1754
1755     case TEMPLATE_PARM_INDEX:
1756       return (TEMPLATE_PARM_IDX (t1) == TEMPLATE_PARM_IDX (t2)
1757               && TEMPLATE_PARM_LEVEL (t1) == TEMPLATE_PARM_LEVEL (t2)
1758               && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1)),
1759                               TREE_TYPE (TEMPLATE_PARM_DECL (t2))));
1760
1761     case TEMPLATE_ID_EXPR:
1762       {
1763         unsigned ix;
1764         tree vec1, vec2;
1765
1766         if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
1767           return false;
1768         vec1 = TREE_OPERAND (t1, 1);
1769         vec2 = TREE_OPERAND (t2, 1);
1770
1771         if (!vec1 || !vec2)
1772           return !vec1 && !vec2;
1773
1774         if (TREE_VEC_LENGTH (vec1) != TREE_VEC_LENGTH (vec2))
1775           return false;
1776
1777         for (ix = TREE_VEC_LENGTH (vec1); ix--;)
1778           if (!cp_tree_equal (TREE_VEC_ELT (vec1, ix),
1779                               TREE_VEC_ELT (vec2, ix)))
1780             return false;
1781
1782         return true;
1783       }
1784
1785     case SIZEOF_EXPR:
1786     case ALIGNOF_EXPR:
1787       {
1788         tree o1 = TREE_OPERAND (t1, 0);
1789         tree o2 = TREE_OPERAND (t2, 0);
1790
1791         if (TREE_CODE (o1) != TREE_CODE (o2))
1792           return false;
1793         if (TYPE_P (o1))
1794           return same_type_p (o1, o2);
1795         else
1796           return cp_tree_equal (o1, o2);
1797       }
1798
1799     case MODOP_EXPR:
1800       {
1801         tree t1_op1, t2_op1;
1802
1803         if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
1804           return false;
1805
1806         t1_op1 = TREE_OPERAND (t1, 1);
1807         t2_op1 = TREE_OPERAND (t2, 1);
1808         if (TREE_CODE (t1_op1) != TREE_CODE (t2_op1))
1809           return false;
1810
1811         return cp_tree_equal (TREE_OPERAND (t1, 2), TREE_OPERAND (t2, 2));
1812       }
1813
1814     case PTRMEM_CST:
1815       /* Two pointer-to-members are the same if they point to the same
1816          field or function in the same class.  */
1817       if (PTRMEM_CST_MEMBER (t1) != PTRMEM_CST_MEMBER (t2))
1818         return false;
1819
1820       return same_type_p (PTRMEM_CST_CLASS (t1), PTRMEM_CST_CLASS (t2));
1821
1822     case OVERLOAD:
1823       if (OVL_FUNCTION (t1) != OVL_FUNCTION (t2))
1824         return false;
1825       return cp_tree_equal (OVL_CHAIN (t1), OVL_CHAIN (t2));
1826
1827     default:
1828       break;
1829     }
1830
1831   switch (TREE_CODE_CLASS (code1))
1832     {
1833     case tcc_unary:
1834     case tcc_binary:
1835     case tcc_comparison:
1836     case tcc_expression:
1837     case tcc_vl_exp:
1838     case tcc_reference:
1839     case tcc_statement:
1840       {
1841         int i, n;
1842
1843         n = TREE_OPERAND_LENGTH (t1);
1844         if (TREE_CODE_CLASS (code1) == tcc_vl_exp
1845             && n != TREE_OPERAND_LENGTH (t2))
1846           return false;
1847
1848         for (i = 0; i < n; ++i)
1849           if (!cp_tree_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i)))
1850             return false;
1851
1852         return true;
1853       }
1854
1855     case tcc_type:
1856       return same_type_p (t1, t2);
1857     default:
1858       gcc_unreachable ();
1859     }
1860   /* We can get here with --disable-checking.  */
1861   return false;
1862 }
1863
1864 /* The type of ARG when used as an lvalue.  */
1865
1866 tree
1867 lvalue_type (tree arg)
1868 {
1869   tree type = TREE_TYPE (arg);
1870   return type;
1871 }
1872
1873 /* The type of ARG for printing error messages; denote lvalues with
1874    reference types.  */
1875
1876 tree
1877 error_type (tree arg)
1878 {
1879   tree type = TREE_TYPE (arg);
1880
1881   if (TREE_CODE (type) == ARRAY_TYPE)
1882     ;
1883   else if (TREE_CODE (type) == ERROR_MARK)
1884     ;
1885   else if (real_lvalue_p (arg))
1886     type = build_reference_type (lvalue_type (arg));
1887   else if (IS_AGGR_TYPE (type))
1888     type = lvalue_type (arg);
1889
1890   return type;
1891 }
1892
1893 /* Does FUNCTION use a variable-length argument list?  */
1894
1895 int
1896 varargs_function_p (tree function)
1897 {
1898   tree parm = TYPE_ARG_TYPES (TREE_TYPE (function));
1899   for (; parm; parm = TREE_CHAIN (parm))
1900     if (TREE_VALUE (parm) == void_type_node)
1901       return 0;
1902   return 1;
1903 }
1904
1905 /* Returns 1 if decl is a member of a class.  */
1906
1907 int
1908 member_p (tree decl)
1909 {
1910   const tree ctx = DECL_CONTEXT (decl);
1911   return (ctx && TYPE_P (ctx));
1912 }
1913
1914 /* Create a placeholder for member access where we don't actually have an
1915    object that the access is against.  */
1916
1917 tree
1918 build_dummy_object (tree type)
1919 {
1920   tree decl = build1 (NOP_EXPR, build_pointer_type (type), void_zero_node);
1921   return build_indirect_ref (decl, NULL);
1922 }
1923
1924 /* We've gotten a reference to a member of TYPE.  Return *this if appropriate,
1925    or a dummy object otherwise.  If BINFOP is non-0, it is filled with the
1926    binfo path from current_class_type to TYPE, or 0.  */
1927
1928 tree
1929 maybe_dummy_object (tree type, tree* binfop)
1930 {
1931   tree decl, context;
1932   tree binfo;
1933
1934   if (current_class_type
1935       && (binfo = lookup_base (current_class_type, type,
1936                                ba_unique | ba_quiet, NULL)))
1937     context = current_class_type;
1938   else
1939     {
1940       /* Reference from a nested class member function.  */
1941       context = type;
1942       binfo = TYPE_BINFO (type);
1943     }
1944
1945   if (binfop)
1946     *binfop = binfo;
1947
1948   if (current_class_ref && context == current_class_type
1949       /* Kludge: Make sure that current_class_type is actually
1950          correct.  It might not be if we're in the middle of
1951          tsubst_default_argument.  */
1952       && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (current_class_ref)),
1953                       current_class_type))
1954     decl = current_class_ref;
1955   else
1956     decl = build_dummy_object (context);
1957
1958   return decl;
1959 }
1960
1961 /* Returns 1 if OB is a placeholder object, or a pointer to one.  */
1962
1963 int
1964 is_dummy_object (tree ob)
1965 {
1966   if (TREE_CODE (ob) == INDIRECT_REF)
1967     ob = TREE_OPERAND (ob, 0);
1968   return (TREE_CODE (ob) == NOP_EXPR
1969           && TREE_OPERAND (ob, 0) == void_zero_node);
1970 }
1971
1972 /* Returns 1 iff type T is a POD type, as defined in [basic.types].  */
1973
1974 int
1975 pod_type_p (tree t)
1976 {
1977   t = strip_array_types (t);
1978
1979   if (t == error_mark_node)
1980     return 1;
1981   if (INTEGRAL_TYPE_P (t))
1982     return 1;  /* integral, character or enumeral type */
1983   if (FLOAT_TYPE_P (t))
1984     return 1;
1985   if (TYPE_PTR_P (t))
1986     return 1; /* pointer to non-member */
1987   if (TYPE_PTR_TO_MEMBER_P (t))
1988     return 1; /* pointer to member */
1989
1990   if (TREE_CODE (t) == VECTOR_TYPE)
1991     return 1; /* vectors are (small) arrays of scalars */
1992
1993   if (! CLASS_TYPE_P (t))
1994     return 0; /* other non-class type (reference or function) */
1995   if (CLASSTYPE_NON_POD_P (t))
1996     return 0;
1997   return 1;
1998 }
1999
2000 /* Returns 1 iff zero initialization of type T means actually storing
2001    zeros in it.  */
2002
2003 int
2004 zero_init_p (tree t)
2005 {
2006   t = strip_array_types (t);
2007
2008   if (t == error_mark_node)
2009     return 1;
2010
2011   /* NULL pointers to data members are initialized with -1.  */
2012   if (TYPE_PTRMEM_P (t))
2013     return 0;
2014
2015   /* Classes that contain types that can't be zero-initialized, cannot
2016      be zero-initialized themselves.  */
2017   if (CLASS_TYPE_P (t) && CLASSTYPE_NON_ZERO_INIT_P (t))
2018     return 0;
2019
2020   return 1;
2021 }
2022
2023 /* Table of valid C++ attributes.  */
2024 const struct attribute_spec cxx_attribute_table[] =
2025 {
2026   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
2027   { "java_interface", 0, 0, false, false, false, handle_java_interface_attribute },
2028   { "com_interface",  0, 0, false, false, false, handle_com_interface_attribute },
2029   { "init_priority",  1, 1, true,  false, false, handle_init_priority_attribute },
2030   { NULL,             0, 0, false, false, false, NULL }
2031 };
2032
2033 /* Handle a "java_interface" attribute; arguments as in
2034    struct attribute_spec.handler.  */
2035 static tree
2036 handle_java_interface_attribute (tree* node,
2037                                  tree name,
2038                                  tree args ATTRIBUTE_UNUSED ,
2039                                  int flags,
2040                                  bool* no_add_attrs)
2041 {
2042   if (DECL_P (*node)
2043       || !CLASS_TYPE_P (*node)
2044       || !TYPE_FOR_JAVA (*node))
2045     {
2046       error ("%qE attribute can only be applied to Java class definitions",
2047              name);
2048       *no_add_attrs = true;
2049       return NULL_TREE;
2050     }
2051   if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
2052     *node = build_variant_type_copy (*node);
2053   TYPE_JAVA_INTERFACE (*node) = 1;
2054
2055   return NULL_TREE;
2056 }
2057
2058 /* Handle a "com_interface" attribute; arguments as in
2059    struct attribute_spec.handler.  */
2060 static tree
2061 handle_com_interface_attribute (tree* node,
2062                                 tree name,
2063                                 tree args ATTRIBUTE_UNUSED ,
2064                                 int flags ATTRIBUTE_UNUSED ,
2065                                 bool* no_add_attrs)
2066 {
2067   static int warned;
2068
2069   *no_add_attrs = true;
2070
2071   if (DECL_P (*node)
2072       || !CLASS_TYPE_P (*node)
2073       || *node != TYPE_MAIN_VARIANT (*node))
2074     {
2075       warning (OPT_Wattributes, "%qE attribute can only be applied "
2076                "to class definitions", name);
2077       return NULL_TREE;
2078     }
2079
2080   if (!warned++)
2081     warning (0, "%qE is obsolete; g++ vtables are now COM-compatible by default",
2082              name);
2083
2084   return NULL_TREE;
2085 }
2086
2087 /* Handle an "init_priority" attribute; arguments as in
2088    struct attribute_spec.handler.  */
2089 static tree
2090 handle_init_priority_attribute (tree* node,
2091                                 tree name,
2092                                 tree args,
2093                                 int flags ATTRIBUTE_UNUSED ,
2094                                 bool* no_add_attrs)
2095 {
2096   tree initp_expr = TREE_VALUE (args);
2097   tree decl = *node;
2098   tree type = TREE_TYPE (decl);
2099   int pri;
2100
2101   STRIP_NOPS (initp_expr);
2102
2103   if (!initp_expr || TREE_CODE (initp_expr) != INTEGER_CST)
2104     {
2105       error ("requested init_priority is not an integer constant");
2106       *no_add_attrs = true;
2107       return NULL_TREE;
2108     }
2109
2110   pri = TREE_INT_CST_LOW (initp_expr);
2111
2112   type = strip_array_types (type);
2113
2114   if (decl == NULL_TREE
2115       || TREE_CODE (decl) != VAR_DECL
2116       || !TREE_STATIC (decl)
2117       || DECL_EXTERNAL (decl)
2118       || (TREE_CODE (type) != RECORD_TYPE
2119           && TREE_CODE (type) != UNION_TYPE)
2120       /* Static objects in functions are initialized the
2121          first time control passes through that
2122          function. This is not precise enough to pin down an
2123          init_priority value, so don't allow it.  */
2124       || current_function_decl)
2125     {
2126       error ("can only use %qE attribute on file-scope definitions "
2127              "of objects of class type", name);
2128       *no_add_attrs = true;
2129       return NULL_TREE;
2130     }
2131
2132   if (pri > MAX_INIT_PRIORITY || pri <= 0)
2133     {
2134       error ("requested init_priority is out of range");
2135       *no_add_attrs = true;
2136       return NULL_TREE;
2137     }
2138
2139   /* Check for init_priorities that are reserved for
2140      language and runtime support implementations.*/
2141   if (pri <= MAX_RESERVED_INIT_PRIORITY)
2142     {
2143       warning
2144         (0, "requested init_priority is reserved for internal use");
2145     }
2146
2147   if (SUPPORTS_INIT_PRIORITY)
2148     {
2149       SET_DECL_INIT_PRIORITY (decl, pri);
2150       DECL_HAS_INIT_PRIORITY_P (decl) = 1;
2151       return NULL_TREE;
2152     }
2153   else
2154     {
2155       error ("%qE attribute is not supported on this platform", name);
2156       *no_add_attrs = true;
2157       return NULL_TREE;
2158     }
2159 }
2160
2161 /* Return a new PTRMEM_CST of the indicated TYPE.  The MEMBER is the
2162    thing pointed to by the constant.  */
2163
2164 tree
2165 make_ptrmem_cst (tree type, tree member)
2166 {
2167   tree ptrmem_cst = make_node (PTRMEM_CST);
2168   TREE_TYPE (ptrmem_cst) = type;
2169   PTRMEM_CST_MEMBER (ptrmem_cst) = member;
2170   return ptrmem_cst;
2171 }
2172
2173 /* Build a variant of TYPE that has the indicated ATTRIBUTES.  May
2174    return an existing type of an appropriate type already exists.  */
2175
2176 tree
2177 cp_build_type_attribute_variant (tree type, tree attributes)
2178 {
2179   tree new_type;
2180
2181   new_type = build_type_attribute_variant (type, attributes);
2182   if (TREE_CODE (new_type) == FUNCTION_TYPE
2183       && (TYPE_RAISES_EXCEPTIONS (new_type)
2184           != TYPE_RAISES_EXCEPTIONS (type)))
2185     new_type = build_exception_variant (new_type,
2186                                         TYPE_RAISES_EXCEPTIONS (type));
2187
2188   /* Making a new main variant of a class type is broken.  */
2189   gcc_assert (!CLASS_TYPE_P (type) || new_type == type);
2190
2191   return new_type;
2192 }
2193
2194 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
2195    traversal.  Called from walk_tree.  */
2196
2197 tree
2198 cp_walk_subtrees (tree *tp, int *walk_subtrees_p, walk_tree_fn func,
2199                   void *data, struct pointer_set_t *pset)
2200 {
2201   enum tree_code code = TREE_CODE (*tp);
2202   location_t save_locus;
2203   tree result;
2204
2205 #define WALK_SUBTREE(NODE)                              \
2206   do                                                    \
2207     {                                                   \
2208       result = walk_tree (&(NODE), func, data, pset);   \
2209       if (result) goto out;                             \
2210     }                                                   \
2211   while (0)
2212
2213   /* Set input_location here so we get the right instantiation context
2214      if we call instantiate_decl from inlinable_function_p.  */
2215   save_locus = input_location;
2216   if (EXPR_HAS_LOCATION (*tp))
2217     input_location = EXPR_LOCATION (*tp);
2218
2219   /* Not one of the easy cases.  We must explicitly go through the
2220      children.  */
2221   result = NULL_TREE;
2222   switch (code)
2223     {
2224     case DEFAULT_ARG:
2225     case TEMPLATE_TEMPLATE_PARM:
2226     case BOUND_TEMPLATE_TEMPLATE_PARM:
2227     case UNBOUND_CLASS_TEMPLATE:
2228     case TEMPLATE_PARM_INDEX:
2229     case TEMPLATE_TYPE_PARM:
2230     case TYPENAME_TYPE:
2231     case TYPEOF_TYPE:
2232     case BASELINK:
2233       /* None of these have subtrees other than those already walked
2234          above.  */
2235       *walk_subtrees_p = 0;
2236       break;
2237
2238     case TINST_LEVEL:
2239       WALK_SUBTREE (TINST_DECL (*tp));
2240       *walk_subtrees_p = 0;
2241       break;
2242
2243     case PTRMEM_CST:
2244       WALK_SUBTREE (TREE_TYPE (*tp));
2245       *walk_subtrees_p = 0;
2246       break;
2247
2248     case TREE_LIST:
2249       WALK_SUBTREE (TREE_PURPOSE (*tp));
2250       break;
2251
2252     case OVERLOAD:
2253       WALK_SUBTREE (OVL_FUNCTION (*tp));
2254       WALK_SUBTREE (OVL_CHAIN (*tp));
2255       *walk_subtrees_p = 0;
2256       break;
2257
2258     case RECORD_TYPE:
2259       if (TYPE_PTRMEMFUNC_P (*tp))
2260         WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE (*tp));
2261       break;
2262
2263     default:
2264       input_location = save_locus;
2265       return NULL_TREE;
2266     }
2267
2268   /* We didn't find what we were looking for.  */
2269  out:
2270   input_location = save_locus;
2271   return result;
2272
2273 #undef WALK_SUBTREE
2274 }
2275
2276 /* Decide whether there are language-specific reasons to not inline a
2277    function as a tree.  */
2278
2279 int
2280 cp_cannot_inline_tree_fn (tree* fnp)
2281 {
2282   tree fn = *fnp;
2283
2284   /* We can inline a template instantiation only if it's fully
2285      instantiated.  */
2286   if (DECL_TEMPLATE_INFO (fn)
2287       && TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (fn)))
2288     {
2289       /* Don't instantiate functions that are not going to be
2290          inlined.  */
2291       if (!DECL_INLINE (DECL_TEMPLATE_RESULT
2292                         (template_for_substitution (fn))))
2293         return 1;
2294
2295       fn = *fnp = instantiate_decl (fn, /*defer_ok=*/0, /*undefined_ok=*/0);
2296
2297       if (TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (fn)))
2298         return 1;
2299     }
2300
2301   if (flag_really_no_inline
2302       && lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) == NULL)
2303     return 1;
2304
2305   /* Don't auto-inline functions that might be replaced at link-time
2306      with an alternative definition.  */
2307   if (!DECL_DECLARED_INLINE_P (fn) && DECL_REPLACEABLE_P (fn))
2308     {
2309       DECL_UNINLINABLE (fn) = 1;
2310       return 1;
2311     }
2312
2313   if (varargs_function_p (fn))
2314     {
2315       DECL_UNINLINABLE (fn) = 1;
2316       return 1;
2317     }
2318
2319   if (! function_attribute_inlinable_p (fn))
2320     {
2321       DECL_UNINLINABLE (fn) = 1;
2322       return 1;
2323     }
2324
2325   return 0;
2326 }
2327
2328 /* Add any pending functions other than the current function (already
2329    handled by the caller), that thus cannot be inlined, to FNS_P, then
2330    return the latest function added to the array, PREV_FN.  */
2331
2332 tree
2333 cp_add_pending_fn_decls (void* fns_p, tree prev_fn)
2334 {
2335   varray_type *fnsp = (varray_type *)fns_p;
2336   struct saved_scope *s;
2337
2338   for (s = scope_chain; s; s = s->prev)
2339     if (s->function_decl && s->function_decl != prev_fn)
2340       {
2341         VARRAY_PUSH_TREE (*fnsp, s->function_decl);
2342         prev_fn = s->function_decl;
2343       }
2344
2345   return prev_fn;
2346 }
2347
2348 /* Determine whether VAR is a declaration of an automatic variable in
2349    function FN.  */
2350
2351 int
2352 cp_auto_var_in_fn_p (tree var, tree fn)
2353 {
2354   return (DECL_P (var) && DECL_CONTEXT (var) == fn
2355           && nonstatic_local_decl_p (var));
2356 }
2357
2358 /* Like save_expr, but for C++.  */
2359
2360 tree
2361 cp_save_expr (tree expr)
2362 {
2363   /* There is no reason to create a SAVE_EXPR within a template; if
2364      needed, we can create the SAVE_EXPR when instantiating the
2365      template.  Furthermore, the middle-end cannot handle C++-specific
2366      tree codes.  */
2367   if (processing_template_decl)
2368     return expr;
2369   return save_expr (expr);
2370 }
2371
2372 /* Initialize tree.c.  */
2373
2374 void
2375 init_tree (void)
2376 {
2377   list_hash_table = htab_create_ggc (31, list_hash, list_hash_eq, NULL);
2378 }
2379
2380 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
2381    is.  Note that sfk_none is zero, so this function can be used as a
2382    predicate to test whether or not DECL is a special function.  */
2383
2384 special_function_kind
2385 special_function_p (tree decl)
2386 {
2387   /* Rather than doing all this stuff with magic names, we should
2388      probably have a field of type `special_function_kind' in
2389      DECL_LANG_SPECIFIC.  */
2390   if (DECL_COPY_CONSTRUCTOR_P (decl))
2391     return sfk_copy_constructor;
2392   if (DECL_CONSTRUCTOR_P (decl))
2393     return sfk_constructor;
2394   if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
2395     return sfk_assignment_operator;
2396   if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl))
2397     return sfk_destructor;
2398   if (DECL_COMPLETE_DESTRUCTOR_P (decl))
2399     return sfk_complete_destructor;
2400   if (DECL_BASE_DESTRUCTOR_P (decl))
2401     return sfk_base_destructor;
2402   if (DECL_DELETING_DESTRUCTOR_P (decl))
2403     return sfk_deleting_destructor;
2404   if (DECL_CONV_FN_P (decl))
2405     return sfk_conversion;
2406
2407   return sfk_none;
2408 }
2409
2410 /* Returns nonzero if TYPE is a character type, including wchar_t.  */
2411
2412 int
2413 char_type_p (tree type)
2414 {
2415   return (same_type_p (type, char_type_node)
2416           || same_type_p (type, unsigned_char_type_node)
2417           || same_type_p (type, signed_char_type_node)
2418           || same_type_p (type, wchar_type_node));
2419 }
2420
2421 /* Returns the kind of linkage associated with the indicated DECL.  Th
2422    value returned is as specified by the language standard; it is
2423    independent of implementation details regarding template
2424    instantiation, etc.  For example, it is possible that a declaration
2425    to which this function assigns external linkage would not show up
2426    as a global symbol when you run `nm' on the resulting object file.  */
2427
2428 linkage_kind
2429 decl_linkage (tree decl)
2430 {
2431   /* This function doesn't attempt to calculate the linkage from first
2432      principles as given in [basic.link].  Instead, it makes use of
2433      the fact that we have already set TREE_PUBLIC appropriately, and
2434      then handles a few special cases.  Ideally, we would calculate
2435      linkage first, and then transform that into a concrete
2436      implementation.  */
2437
2438   /* Things that don't have names have no linkage.  */
2439   if (!DECL_NAME (decl))
2440     return lk_none;
2441
2442   /* Things that are TREE_PUBLIC have external linkage.  */
2443   if (TREE_PUBLIC (decl))
2444     return lk_external;
2445
2446   if (TREE_CODE (decl) == NAMESPACE_DECL)
2447     return lk_external;
2448
2449   /* Linkage of a CONST_DECL depends on the linkage of the enumeration
2450      type.  */
2451   if (TREE_CODE (decl) == CONST_DECL)
2452     return decl_linkage (TYPE_NAME (TREE_TYPE (decl)));
2453
2454   /* Some things that are not TREE_PUBLIC have external linkage, too.
2455      For example, on targets that don't have weak symbols, we make all
2456      template instantiations have internal linkage (in the object
2457      file), but the symbols should still be treated as having external
2458      linkage from the point of view of the language.  */
2459   if (TREE_CODE (decl) != TYPE_DECL && DECL_LANG_SPECIFIC (decl)
2460       && DECL_COMDAT (decl))
2461     return lk_external;
2462
2463   /* Things in local scope do not have linkage, if they don't have
2464      TREE_PUBLIC set.  */
2465   if (decl_function_context (decl))
2466     return lk_none;
2467
2468   /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
2469      are considered to have external linkage for language purposes.  DECLs
2470      really meant to have internal linkage have DECL_THIS_STATIC set.  */
2471   if (TREE_CODE (decl) == TYPE_DECL
2472       || ((TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
2473           && !DECL_THIS_STATIC (decl)))
2474     return lk_external;
2475
2476   /* Everything else has internal linkage.  */
2477   return lk_internal;
2478 }
2479 \f
2480 /* EXP is an expression that we want to pre-evaluate.  Returns (in
2481    *INITP) an expression that will perform the pre-evaluation.  The
2482    value returned by this function is a side-effect free expression
2483    equivalent to the pre-evaluated expression.  Callers must ensure
2484    that *INITP is evaluated before EXP.  */
2485
2486 tree
2487 stabilize_expr (tree exp, tree* initp)
2488 {
2489   tree init_expr;
2490
2491   if (!TREE_SIDE_EFFECTS (exp))
2492     init_expr = NULL_TREE;
2493   else if (!real_lvalue_p (exp)
2494            || !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (exp)))
2495     {
2496       init_expr = get_target_expr (exp);
2497       exp = TARGET_EXPR_SLOT (init_expr);
2498     }
2499   else
2500     {
2501       exp = build_unary_op (ADDR_EXPR, exp, 1);
2502       init_expr = get_target_expr (exp);
2503       exp = TARGET_EXPR_SLOT (init_expr);
2504       exp = build_indirect_ref (exp, 0);
2505     }
2506   *initp = init_expr;
2507
2508   gcc_assert (!TREE_SIDE_EFFECTS (exp));
2509   return exp;
2510 }
2511
2512 /* Add NEW, an expression whose value we don't care about, after the
2513    similar expression ORIG.  */
2514
2515 tree
2516 add_stmt_to_compound (tree orig, tree new)
2517 {
2518   if (!new || !TREE_SIDE_EFFECTS (new))
2519     return orig;
2520   if (!orig || !TREE_SIDE_EFFECTS (orig))
2521     return new;
2522   return build2 (COMPOUND_EXPR, void_type_node, orig, new);
2523 }
2524
2525 /* Like stabilize_expr, but for a call whose arguments we want to
2526    pre-evaluate.  CALL is modified in place to use the pre-evaluated
2527    arguments, while, upon return, *INITP contains an expression to
2528    compute the arguments.  */
2529
2530 void
2531 stabilize_call (tree call, tree *initp)
2532 {
2533   tree inits = NULL_TREE;
2534   int i;
2535   int nargs = call_expr_nargs (call);
2536
2537   if (call == error_mark_node)
2538     return;
2539
2540   gcc_assert (TREE_CODE (call) == CALL_EXPR);
2541
2542   for (i = 0; i < nargs; i++)
2543     {
2544       tree init;
2545       CALL_EXPR_ARG (call, i) =
2546         stabilize_expr (CALL_EXPR_ARG (call, i), &init);
2547       inits = add_stmt_to_compound (inits, init);
2548     }
2549
2550   *initp = inits;
2551 }
2552
2553 /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
2554    to pre-evaluate.  CALL is modified in place to use the pre-evaluated
2555    arguments, while, upon return, *INITP contains an expression to
2556    compute the arguments.  */
2557
2558 void
2559 stabilize_aggr_init (tree call, tree *initp)
2560 {
2561   tree inits = NULL_TREE;
2562   int i;
2563   int nargs = aggr_init_expr_nargs (call);
2564
2565   if (call == error_mark_node)
2566     return;
2567
2568   gcc_assert (TREE_CODE (call) == AGGR_INIT_EXPR);
2569
2570   for (i = 0; i < nargs; i++)
2571     {
2572       tree init;
2573       AGGR_INIT_EXPR_ARG (call, i) =
2574         stabilize_expr (AGGR_INIT_EXPR_ARG (call, i), &init);
2575       inits = add_stmt_to_compound (inits, init);
2576     }
2577
2578   *initp = inits;
2579 }
2580
2581 /* Like stabilize_expr, but for an initialization.
2582
2583    If the initialization is for an object of class type, this function
2584    takes care not to introduce additional temporaries.
2585
2586    Returns TRUE iff the expression was successfully pre-evaluated,
2587    i.e., if INIT is now side-effect free, except for, possible, a
2588    single call to a constructor.  */
2589
2590 bool
2591 stabilize_init (tree init, tree *initp)
2592 {
2593   tree t = init;
2594
2595   *initp = NULL_TREE;
2596
2597   if (t == error_mark_node)
2598     return true;
2599
2600   if (TREE_CODE (t) == INIT_EXPR
2601       && TREE_CODE (TREE_OPERAND (t, 1)) != TARGET_EXPR)
2602     {
2603       TREE_OPERAND (t, 1) = stabilize_expr (TREE_OPERAND (t, 1), initp);
2604       return true;
2605     }
2606
2607   if (TREE_CODE (t) == INIT_EXPR)
2608     t = TREE_OPERAND (t, 1);
2609   if (TREE_CODE (t) == TARGET_EXPR)
2610     t = TARGET_EXPR_INITIAL (t);
2611   if (TREE_CODE (t) == COMPOUND_EXPR)
2612     t = expr_last (t);
2613   if (TREE_CODE (t) == CONSTRUCTOR
2614       && EMPTY_CONSTRUCTOR_P (t))
2615     /* Default-initialization.  */
2616     return true;
2617
2618   /* If the initializer is a COND_EXPR, we can't preevaluate
2619      anything.  */
2620   if (TREE_CODE (t) == COND_EXPR)
2621     return false;
2622
2623   if (TREE_CODE (t) == CALL_EXPR)
2624     {
2625       stabilize_call (t, initp);
2626       return true;
2627     }
2628
2629   if (TREE_CODE (t) == AGGR_INIT_EXPR)
2630     {
2631       stabilize_aggr_init (t, initp);
2632       return true;
2633     }
2634
2635   /* The initialization is being performed via a bitwise copy -- and
2636      the item copied may have side effects.  */
2637   return TREE_SIDE_EFFECTS (init);
2638 }
2639
2640 /* Like "fold", but should be used whenever we might be processing the
2641    body of a template.  */
2642
2643 tree
2644 fold_if_not_in_template (tree expr)
2645 {
2646   /* In the body of a template, there is never any need to call
2647      "fold".  We will call fold later when actually instantiating the
2648      template.  Integral constant expressions in templates will be
2649      evaluated via fold_non_dependent_expr, as necessary.  */
2650   if (processing_template_decl)
2651     return expr;
2652
2653   /* Fold C++ front-end specific tree codes.  */
2654   if (TREE_CODE (expr) == UNARY_PLUS_EXPR)
2655     return fold_convert (TREE_TYPE (expr), TREE_OPERAND (expr, 0));
2656
2657   return fold (expr);
2658 }
2659
2660 /* Returns true if a cast to TYPE may appear in an integral constant
2661    expression.  */
2662
2663 bool
2664 cast_valid_in_integral_constant_expression_p (tree type)
2665 {
2666   return (INTEGRAL_OR_ENUMERATION_TYPE_P (type)
2667           || dependent_type_p (type)
2668           || type == error_mark_node);
2669 }
2670
2671 \f
2672 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
2673 /* Complain that some language-specific thing hanging off a tree
2674    node has been accessed improperly.  */
2675
2676 void
2677 lang_check_failed (const char* file, int line, const char* function)
2678 {
2679   internal_error ("lang_* check: failed in %s, at %s:%d",
2680                   function, trim_filename (file), line);
2681 }
2682 #endif /* ENABLE_TREE_CHECKING */
2683
2684 #include "gt-cp-tree.h"