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 COMPLEX_CST:
1674       return cp_tree_equal (TREE_REALPART (t1), TREE_REALPART (t2))
1675         && cp_tree_equal (TREE_IMAGPART (t1), TREE_IMAGPART (t2));
1676
1677     case CONSTRUCTOR:
1678       /* We need to do this when determining whether or not two
1679          non-type pointer to member function template arguments
1680          are the same.  */
1681       if (!(same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
1682             /* The first operand is RTL.  */
1683             && TREE_OPERAND (t1, 0) == TREE_OPERAND (t2, 0)))
1684         return false;
1685       return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
1686
1687     case TREE_LIST:
1688       if (!cp_tree_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2)))
1689         return false;
1690       if (!cp_tree_equal (TREE_VALUE (t1), TREE_VALUE (t2)))
1691         return false;
1692       return cp_tree_equal (TREE_CHAIN (t1), TREE_CHAIN (t2));
1693
1694     case SAVE_EXPR:
1695       return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
1696
1697     case CALL_EXPR:
1698       {
1699         tree arg1, arg2;
1700         call_expr_arg_iterator iter1, iter2;
1701         if (!cp_tree_equal (CALL_EXPR_FN (t1), CALL_EXPR_FN (t2)))
1702           return false;
1703         for (arg1 = first_call_expr_arg (t1, &iter1),
1704                arg2 = first_call_expr_arg (t2, &iter2);
1705              arg1 && arg2;
1706              arg1 = next_call_expr_arg (&iter1),
1707                arg2 = next_call_expr_arg (&iter2))
1708           if (!cp_tree_equal (arg1, arg2))
1709             return false;
1710         return (arg1 || arg2);
1711       }
1712
1713     case TARGET_EXPR:
1714       {
1715         tree o1 = TREE_OPERAND (t1, 0);
1716         tree o2 = TREE_OPERAND (t2, 0);
1717
1718         /* Special case: if either target is an unallocated VAR_DECL,
1719            it means that it's going to be unified with whatever the
1720            TARGET_EXPR is really supposed to initialize, so treat it
1721            as being equivalent to anything.  */
1722         if (TREE_CODE (o1) == VAR_DECL && DECL_NAME (o1) == NULL_TREE
1723             && !DECL_RTL_SET_P (o1))
1724           /*Nop*/;
1725         else if (TREE_CODE (o2) == VAR_DECL && DECL_NAME (o2) == NULL_TREE
1726                  && !DECL_RTL_SET_P (o2))
1727           /*Nop*/;
1728         else if (!cp_tree_equal (o1, o2))
1729           return false;
1730
1731         return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
1732       }
1733
1734     case WITH_CLEANUP_EXPR:
1735       if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
1736         return false;
1737       return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
1738
1739     case COMPONENT_REF:
1740       if (TREE_OPERAND (t1, 1) != TREE_OPERAND (t2, 1))
1741         return false;
1742       return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
1743
1744     case VAR_DECL:
1745     case PARM_DECL:
1746     case CONST_DECL:
1747     case FUNCTION_DECL:
1748     case TEMPLATE_DECL:
1749     case IDENTIFIER_NODE:
1750     case SSA_NAME:
1751       return false;
1752
1753     case BASELINK:
1754       return (BASELINK_BINFO (t1) == BASELINK_BINFO (t2)
1755               && BASELINK_ACCESS_BINFO (t1) == BASELINK_ACCESS_BINFO (t2)
1756               && cp_tree_equal (BASELINK_FUNCTIONS (t1),
1757                                 BASELINK_FUNCTIONS (t2)));
1758
1759     case TEMPLATE_PARM_INDEX:
1760       return (TEMPLATE_PARM_IDX (t1) == TEMPLATE_PARM_IDX (t2)
1761               && TEMPLATE_PARM_LEVEL (t1) == TEMPLATE_PARM_LEVEL (t2)
1762               && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1)),
1763                               TREE_TYPE (TEMPLATE_PARM_DECL (t2))));
1764
1765     case TEMPLATE_ID_EXPR:
1766       {
1767         unsigned ix;
1768         tree vec1, vec2;
1769
1770         if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
1771           return false;
1772         vec1 = TREE_OPERAND (t1, 1);
1773         vec2 = TREE_OPERAND (t2, 1);
1774
1775         if (!vec1 || !vec2)
1776           return !vec1 && !vec2;
1777
1778         if (TREE_VEC_LENGTH (vec1) != TREE_VEC_LENGTH (vec2))
1779           return false;
1780
1781         for (ix = TREE_VEC_LENGTH (vec1); ix--;)
1782           if (!cp_tree_equal (TREE_VEC_ELT (vec1, ix),
1783                               TREE_VEC_ELT (vec2, ix)))
1784             return false;
1785
1786         return true;
1787       }
1788
1789     case SIZEOF_EXPR:
1790     case ALIGNOF_EXPR:
1791       {
1792         tree o1 = TREE_OPERAND (t1, 0);
1793         tree o2 = TREE_OPERAND (t2, 0);
1794
1795         if (TREE_CODE (o1) != TREE_CODE (o2))
1796           return false;
1797         if (TYPE_P (o1))
1798           return same_type_p (o1, o2);
1799         else
1800           return cp_tree_equal (o1, o2);
1801       }
1802
1803     case MODOP_EXPR:
1804       {
1805         tree t1_op1, t2_op1;
1806
1807         if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
1808           return false;
1809
1810         t1_op1 = TREE_OPERAND (t1, 1);
1811         t2_op1 = TREE_OPERAND (t2, 1);
1812         if (TREE_CODE (t1_op1) != TREE_CODE (t2_op1))
1813           return false;
1814
1815         return cp_tree_equal (TREE_OPERAND (t1, 2), TREE_OPERAND (t2, 2));
1816       }
1817
1818     case PTRMEM_CST:
1819       /* Two pointer-to-members are the same if they point to the same
1820          field or function in the same class.  */
1821       if (PTRMEM_CST_MEMBER (t1) != PTRMEM_CST_MEMBER (t2))
1822         return false;
1823
1824       return same_type_p (PTRMEM_CST_CLASS (t1), PTRMEM_CST_CLASS (t2));
1825
1826     case OVERLOAD:
1827       if (OVL_FUNCTION (t1) != OVL_FUNCTION (t2))
1828         return false;
1829       return cp_tree_equal (OVL_CHAIN (t1), OVL_CHAIN (t2));
1830
1831     default:
1832       break;
1833     }
1834
1835   switch (TREE_CODE_CLASS (code1))
1836     {
1837     case tcc_unary:
1838     case tcc_binary:
1839     case tcc_comparison:
1840     case tcc_expression:
1841     case tcc_vl_exp:
1842     case tcc_reference:
1843     case tcc_statement:
1844       {
1845         int i, n;
1846
1847         n = TREE_OPERAND_LENGTH (t1);
1848         if (TREE_CODE_CLASS (code1) == tcc_vl_exp
1849             && n != TREE_OPERAND_LENGTH (t2))
1850           return false;
1851
1852         for (i = 0; i < n; ++i)
1853           if (!cp_tree_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i)))
1854             return false;
1855
1856         return true;
1857       }
1858
1859     case tcc_type:
1860       return same_type_p (t1, t2);
1861     default:
1862       gcc_unreachable ();
1863     }
1864   /* We can get here with --disable-checking.  */
1865   return false;
1866 }
1867
1868 /* The type of ARG when used as an lvalue.  */
1869
1870 tree
1871 lvalue_type (tree arg)
1872 {
1873   tree type = TREE_TYPE (arg);
1874   return type;
1875 }
1876
1877 /* The type of ARG for printing error messages; denote lvalues with
1878    reference types.  */
1879
1880 tree
1881 error_type (tree arg)
1882 {
1883   tree type = TREE_TYPE (arg);
1884
1885   if (TREE_CODE (type) == ARRAY_TYPE)
1886     ;
1887   else if (TREE_CODE (type) == ERROR_MARK)
1888     ;
1889   else if (real_lvalue_p (arg))
1890     type = build_reference_type (lvalue_type (arg));
1891   else if (IS_AGGR_TYPE (type))
1892     type = lvalue_type (arg);
1893
1894   return type;
1895 }
1896
1897 /* Does FUNCTION use a variable-length argument list?  */
1898
1899 int
1900 varargs_function_p (tree function)
1901 {
1902   tree parm = TYPE_ARG_TYPES (TREE_TYPE (function));
1903   for (; parm; parm = TREE_CHAIN (parm))
1904     if (TREE_VALUE (parm) == void_type_node)
1905       return 0;
1906   return 1;
1907 }
1908
1909 /* Returns 1 if decl is a member of a class.  */
1910
1911 int
1912 member_p (tree decl)
1913 {
1914   const tree ctx = DECL_CONTEXT (decl);
1915   return (ctx && TYPE_P (ctx));
1916 }
1917
1918 /* Create a placeholder for member access where we don't actually have an
1919    object that the access is against.  */
1920
1921 tree
1922 build_dummy_object (tree type)
1923 {
1924   tree decl = build1 (NOP_EXPR, build_pointer_type (type), void_zero_node);
1925   return build_indirect_ref (decl, NULL);
1926 }
1927
1928 /* We've gotten a reference to a member of TYPE.  Return *this if appropriate,
1929    or a dummy object otherwise.  If BINFOP is non-0, it is filled with the
1930    binfo path from current_class_type to TYPE, or 0.  */
1931
1932 tree
1933 maybe_dummy_object (tree type, tree* binfop)
1934 {
1935   tree decl, context;
1936   tree binfo;
1937
1938   if (current_class_type
1939       && (binfo = lookup_base (current_class_type, type,
1940                                ba_unique | ba_quiet, NULL)))
1941     context = current_class_type;
1942   else
1943     {
1944       /* Reference from a nested class member function.  */
1945       context = type;
1946       binfo = TYPE_BINFO (type);
1947     }
1948
1949   if (binfop)
1950     *binfop = binfo;
1951
1952   if (current_class_ref && context == current_class_type
1953       /* Kludge: Make sure that current_class_type is actually
1954          correct.  It might not be if we're in the middle of
1955          tsubst_default_argument.  */
1956       && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (current_class_ref)),
1957                       current_class_type))
1958     decl = current_class_ref;
1959   else
1960     decl = build_dummy_object (context);
1961
1962   return decl;
1963 }
1964
1965 /* Returns 1 if OB is a placeholder object, or a pointer to one.  */
1966
1967 int
1968 is_dummy_object (tree ob)
1969 {
1970   if (TREE_CODE (ob) == INDIRECT_REF)
1971     ob = TREE_OPERAND (ob, 0);
1972   return (TREE_CODE (ob) == NOP_EXPR
1973           && TREE_OPERAND (ob, 0) == void_zero_node);
1974 }
1975
1976 /* Returns 1 iff type T is a POD type, as defined in [basic.types].  */
1977
1978 int
1979 pod_type_p (tree t)
1980 {
1981   t = strip_array_types (t);
1982
1983   if (t == error_mark_node)
1984     return 1;
1985   if (INTEGRAL_TYPE_P (t))
1986     return 1;  /* integral, character or enumeral type */
1987   if (FLOAT_TYPE_P (t))
1988     return 1;
1989   if (TYPE_PTR_P (t))
1990     return 1; /* pointer to non-member */
1991   if (TYPE_PTR_TO_MEMBER_P (t))
1992     return 1; /* pointer to member */
1993
1994   if (TREE_CODE (t) == VECTOR_TYPE)
1995     return 1; /* vectors are (small) arrays of scalars */
1996
1997   if (! CLASS_TYPE_P (t))
1998     return 0; /* other non-class type (reference or function) */
1999   if (CLASSTYPE_NON_POD_P (t))
2000     return 0;
2001   return 1;
2002 }
2003
2004 /* Returns 1 iff zero initialization of type T means actually storing
2005    zeros in it.  */
2006
2007 int
2008 zero_init_p (tree t)
2009 {
2010   t = strip_array_types (t);
2011
2012   if (t == error_mark_node)
2013     return 1;
2014
2015   /* NULL pointers to data members are initialized with -1.  */
2016   if (TYPE_PTRMEM_P (t))
2017     return 0;
2018
2019   /* Classes that contain types that can't be zero-initialized, cannot
2020      be zero-initialized themselves.  */
2021   if (CLASS_TYPE_P (t) && CLASSTYPE_NON_ZERO_INIT_P (t))
2022     return 0;
2023
2024   return 1;
2025 }
2026
2027 /* Table of valid C++ attributes.  */
2028 const struct attribute_spec cxx_attribute_table[] =
2029 {
2030   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
2031   { "java_interface", 0, 0, false, false, false, handle_java_interface_attribute },
2032   { "com_interface",  0, 0, false, false, false, handle_com_interface_attribute },
2033   { "init_priority",  1, 1, true,  false, false, handle_init_priority_attribute },
2034   { NULL,             0, 0, false, false, false, NULL }
2035 };
2036
2037 /* Handle a "java_interface" attribute; arguments as in
2038    struct attribute_spec.handler.  */
2039 static tree
2040 handle_java_interface_attribute (tree* node,
2041                                  tree name,
2042                                  tree args ATTRIBUTE_UNUSED ,
2043                                  int flags,
2044                                  bool* no_add_attrs)
2045 {
2046   if (DECL_P (*node)
2047       || !CLASS_TYPE_P (*node)
2048       || !TYPE_FOR_JAVA (*node))
2049     {
2050       error ("%qE attribute can only be applied to Java class definitions",
2051              name);
2052       *no_add_attrs = true;
2053       return NULL_TREE;
2054     }
2055   if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
2056     *node = build_variant_type_copy (*node);
2057   TYPE_JAVA_INTERFACE (*node) = 1;
2058
2059   return NULL_TREE;
2060 }
2061
2062 /* Handle a "com_interface" attribute; arguments as in
2063    struct attribute_spec.handler.  */
2064 static tree
2065 handle_com_interface_attribute (tree* node,
2066                                 tree name,
2067                                 tree args ATTRIBUTE_UNUSED ,
2068                                 int flags ATTRIBUTE_UNUSED ,
2069                                 bool* no_add_attrs)
2070 {
2071   static int warned;
2072
2073   *no_add_attrs = true;
2074
2075   if (DECL_P (*node)
2076       || !CLASS_TYPE_P (*node)
2077       || *node != TYPE_MAIN_VARIANT (*node))
2078     {
2079       warning (OPT_Wattributes, "%qE attribute can only be applied "
2080                "to class definitions", name);
2081       return NULL_TREE;
2082     }
2083
2084   if (!warned++)
2085     warning (0, "%qE is obsolete; g++ vtables are now COM-compatible by default",
2086              name);
2087
2088   return NULL_TREE;
2089 }
2090
2091 /* Handle an "init_priority" attribute; arguments as in
2092    struct attribute_spec.handler.  */
2093 static tree
2094 handle_init_priority_attribute (tree* node,
2095                                 tree name,
2096                                 tree args,
2097                                 int flags ATTRIBUTE_UNUSED ,
2098                                 bool* no_add_attrs)
2099 {
2100   tree initp_expr = TREE_VALUE (args);
2101   tree decl = *node;
2102   tree type = TREE_TYPE (decl);
2103   int pri;
2104
2105   STRIP_NOPS (initp_expr);
2106
2107   if (!initp_expr || TREE_CODE (initp_expr) != INTEGER_CST)
2108     {
2109       error ("requested init_priority is not an integer constant");
2110       *no_add_attrs = true;
2111       return NULL_TREE;
2112     }
2113
2114   pri = TREE_INT_CST_LOW (initp_expr);
2115
2116   type = strip_array_types (type);
2117
2118   if (decl == NULL_TREE
2119       || TREE_CODE (decl) != VAR_DECL
2120       || !TREE_STATIC (decl)
2121       || DECL_EXTERNAL (decl)
2122       || (TREE_CODE (type) != RECORD_TYPE
2123           && TREE_CODE (type) != UNION_TYPE)
2124       /* Static objects in functions are initialized the
2125          first time control passes through that
2126          function. This is not precise enough to pin down an
2127          init_priority value, so don't allow it.  */
2128       || current_function_decl)
2129     {
2130       error ("can only use %qE attribute on file-scope definitions "
2131              "of objects of class type", name);
2132       *no_add_attrs = true;
2133       return NULL_TREE;
2134     }
2135
2136   if (pri > MAX_INIT_PRIORITY || pri <= 0)
2137     {
2138       error ("requested init_priority is out of range");
2139       *no_add_attrs = true;
2140       return NULL_TREE;
2141     }
2142
2143   /* Check for init_priorities that are reserved for
2144      language and runtime support implementations.*/
2145   if (pri <= MAX_RESERVED_INIT_PRIORITY)
2146     {
2147       warning
2148         (0, "requested init_priority is reserved for internal use");
2149     }
2150
2151   if (SUPPORTS_INIT_PRIORITY)
2152     {
2153       SET_DECL_INIT_PRIORITY (decl, pri);
2154       DECL_HAS_INIT_PRIORITY_P (decl) = 1;
2155       return NULL_TREE;
2156     }
2157   else
2158     {
2159       error ("%qE attribute is not supported on this platform", name);
2160       *no_add_attrs = true;
2161       return NULL_TREE;
2162     }
2163 }
2164
2165 /* Return a new PTRMEM_CST of the indicated TYPE.  The MEMBER is the
2166    thing pointed to by the constant.  */
2167
2168 tree
2169 make_ptrmem_cst (tree type, tree member)
2170 {
2171   tree ptrmem_cst = make_node (PTRMEM_CST);
2172   TREE_TYPE (ptrmem_cst) = type;
2173   PTRMEM_CST_MEMBER (ptrmem_cst) = member;
2174   return ptrmem_cst;
2175 }
2176
2177 /* Build a variant of TYPE that has the indicated ATTRIBUTES.  May
2178    return an existing type of an appropriate type already exists.  */
2179
2180 tree
2181 cp_build_type_attribute_variant (tree type, tree attributes)
2182 {
2183   tree new_type;
2184
2185   new_type = build_type_attribute_variant (type, attributes);
2186   if (TREE_CODE (new_type) == FUNCTION_TYPE
2187       && (TYPE_RAISES_EXCEPTIONS (new_type)
2188           != TYPE_RAISES_EXCEPTIONS (type)))
2189     new_type = build_exception_variant (new_type,
2190                                         TYPE_RAISES_EXCEPTIONS (type));
2191
2192   /* Making a new main variant of a class type is broken.  */
2193   gcc_assert (!CLASS_TYPE_P (type) || new_type == type);
2194
2195   return new_type;
2196 }
2197
2198 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
2199    traversal.  Called from walk_tree.  */
2200
2201 tree
2202 cp_walk_subtrees (tree *tp, int *walk_subtrees_p, walk_tree_fn func,
2203                   void *data, struct pointer_set_t *pset)
2204 {
2205   enum tree_code code = TREE_CODE (*tp);
2206   tree result;
2207
2208 #define WALK_SUBTREE(NODE)                              \
2209   do                                                    \
2210     {                                                   \
2211       result = walk_tree (&(NODE), func, data, pset);   \
2212       if (result) goto out;                             \
2213     }                                                   \
2214   while (0)
2215
2216   /* Not one of the easy cases.  We must explicitly go through the
2217      children.  */
2218   result = NULL_TREE;
2219   switch (code)
2220     {
2221     case DEFAULT_ARG:
2222     case TEMPLATE_TEMPLATE_PARM:
2223     case BOUND_TEMPLATE_TEMPLATE_PARM:
2224     case UNBOUND_CLASS_TEMPLATE:
2225     case TEMPLATE_PARM_INDEX:
2226     case TEMPLATE_TYPE_PARM:
2227     case TYPENAME_TYPE:
2228     case TYPEOF_TYPE:
2229       /* None of these have subtrees other than those already walked
2230          above.  */
2231       *walk_subtrees_p = 0;
2232       break;
2233
2234     case BASELINK:
2235       WALK_SUBTREE (BASELINK_FUNCTIONS (*tp));
2236       *walk_subtrees_p = 0;
2237       break;
2238
2239     case TINST_LEVEL:
2240       WALK_SUBTREE (TINST_DECL (*tp));
2241       *walk_subtrees_p = 0;
2242       break;
2243
2244     case PTRMEM_CST:
2245       WALK_SUBTREE (TREE_TYPE (*tp));
2246       *walk_subtrees_p = 0;
2247       break;
2248
2249     case TREE_LIST:
2250       WALK_SUBTREE (TREE_PURPOSE (*tp));
2251       break;
2252
2253     case OVERLOAD:
2254       WALK_SUBTREE (OVL_FUNCTION (*tp));
2255       WALK_SUBTREE (OVL_CHAIN (*tp));
2256       *walk_subtrees_p = 0;
2257       break;
2258
2259     case RECORD_TYPE:
2260       if (TYPE_PTRMEMFUNC_P (*tp))
2261         WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE (*tp));
2262       break;
2263
2264     case TYPE_ARGUMENT_PACK:
2265     case NONTYPE_ARGUMENT_PACK:
2266       {
2267         tree args = ARGUMENT_PACK_ARGS (*tp);
2268         int i, len = TREE_VEC_LENGTH (args);
2269         for (i = 0; i < len; i++)
2270           WALK_SUBTREE (TREE_VEC_ELT (args, i));
2271       }
2272       break;
2273
2274     case TYPE_PACK_EXPANSION:
2275       WALK_SUBTREE (TREE_TYPE (*tp));
2276       *walk_subtrees_p = 0;
2277       break;
2278
2279     case EXPR_PACK_EXPANSION:
2280       WALK_SUBTREE (TREE_OPERAND (*tp, 0));
2281       *walk_subtrees_p = 0;
2282       break;
2283
2284     case CAST_EXPR:
2285       if (TREE_TYPE (*tp))
2286         WALK_SUBTREE (TREE_TYPE (*tp));
2287
2288       {
2289         int i;
2290         for (i = 0; i < TREE_CODE_LENGTH (TREE_CODE (*tp)); ++i)
2291           WALK_SUBTREE (TREE_OPERAND (*tp, i));
2292       }
2293       *walk_subtrees_p = 0;
2294       break;
2295
2296     case TRAIT_EXPR:
2297       WALK_SUBTREE (TRAIT_EXPR_TYPE1 (*tp));
2298       WALK_SUBTREE (TRAIT_EXPR_TYPE2 (*tp));
2299       *walk_subtrees_p = 0;
2300       break;
2301
2302     default:
2303       return NULL_TREE;
2304     }
2305
2306   /* We didn't find what we were looking for.  */
2307  out:
2308   return result;
2309
2310 #undef WALK_SUBTREE
2311 }
2312
2313 /* Decide whether there are language-specific reasons to not inline a
2314    function as a tree.  */
2315
2316 int
2317 cp_cannot_inline_tree_fn (tree* fnp)
2318 {
2319   tree fn = *fnp;
2320
2321   /* We can inline a template instantiation only if it's fully
2322      instantiated.  */
2323   if (DECL_TEMPLATE_INFO (fn)
2324       && TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (fn)))
2325     {
2326       /* Don't instantiate functions that are not going to be
2327          inlined.  */
2328       if (!DECL_INLINE (DECL_TEMPLATE_RESULT
2329                         (template_for_substitution (fn))))
2330         return 1;
2331
2332       fn = *fnp = instantiate_decl (fn, /*defer_ok=*/0, /*undefined_ok=*/0);
2333
2334       if (TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (fn)))
2335         return 1;
2336     }
2337
2338   if (flag_really_no_inline
2339       && lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) == NULL)
2340     return 1;
2341
2342   /* Don't auto-inline functions that might be replaced at link-time
2343      with an alternative definition.  */
2344   if (!DECL_DECLARED_INLINE_P (fn) && DECL_REPLACEABLE_P (fn))
2345     {
2346       DECL_UNINLINABLE (fn) = 1;
2347       return 1;
2348     }
2349
2350   if (varargs_function_p (fn))
2351     {
2352       DECL_UNINLINABLE (fn) = 1;
2353       return 1;
2354     }
2355
2356   if (! function_attribute_inlinable_p (fn))
2357     {
2358       DECL_UNINLINABLE (fn) = 1;
2359       return 1;
2360     }
2361
2362   return 0;
2363 }
2364
2365 /* Determine whether VAR is a declaration of an automatic variable in
2366    function FN.  */
2367
2368 int
2369 cp_auto_var_in_fn_p (tree var, tree fn)
2370 {
2371   return (DECL_P (var) && DECL_CONTEXT (var) == fn
2372           && nonstatic_local_decl_p (var));
2373 }
2374
2375 /* Like save_expr, but for C++.  */
2376
2377 tree
2378 cp_save_expr (tree expr)
2379 {
2380   /* There is no reason to create a SAVE_EXPR within a template; if
2381      needed, we can create the SAVE_EXPR when instantiating the
2382      template.  Furthermore, the middle-end cannot handle C++-specific
2383      tree codes.  */
2384   if (processing_template_decl)
2385     return expr;
2386   return save_expr (expr);
2387 }
2388
2389 /* Initialize tree.c.  */
2390
2391 void
2392 init_tree (void)
2393 {
2394   list_hash_table = htab_create_ggc (31, list_hash, list_hash_eq, NULL);
2395 }
2396
2397 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
2398    is.  Note that sfk_none is zero, so this function can be used as a
2399    predicate to test whether or not DECL is a special function.  */
2400
2401 special_function_kind
2402 special_function_p (tree decl)
2403 {
2404   /* Rather than doing all this stuff with magic names, we should
2405      probably have a field of type `special_function_kind' in
2406      DECL_LANG_SPECIFIC.  */
2407   if (DECL_COPY_CONSTRUCTOR_P (decl))
2408     return sfk_copy_constructor;
2409   if (DECL_CONSTRUCTOR_P (decl))
2410     return sfk_constructor;
2411   if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
2412     return sfk_assignment_operator;
2413   if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl))
2414     return sfk_destructor;
2415   if (DECL_COMPLETE_DESTRUCTOR_P (decl))
2416     return sfk_complete_destructor;
2417   if (DECL_BASE_DESTRUCTOR_P (decl))
2418     return sfk_base_destructor;
2419   if (DECL_DELETING_DESTRUCTOR_P (decl))
2420     return sfk_deleting_destructor;
2421   if (DECL_CONV_FN_P (decl))
2422     return sfk_conversion;
2423
2424   return sfk_none;
2425 }
2426
2427 /* Returns nonzero if TYPE is a character type, including wchar_t.  */
2428
2429 int
2430 char_type_p (tree type)
2431 {
2432   return (same_type_p (type, char_type_node)
2433           || same_type_p (type, unsigned_char_type_node)
2434           || same_type_p (type, signed_char_type_node)
2435           || same_type_p (type, wchar_type_node));
2436 }
2437
2438 /* Returns the kind of linkage associated with the indicated DECL.  Th
2439    value returned is as specified by the language standard; it is
2440    independent of implementation details regarding template
2441    instantiation, etc.  For example, it is possible that a declaration
2442    to which this function assigns external linkage would not show up
2443    as a global symbol when you run `nm' on the resulting object file.  */
2444
2445 linkage_kind
2446 decl_linkage (tree decl)
2447 {
2448   /* This function doesn't attempt to calculate the linkage from first
2449      principles as given in [basic.link].  Instead, it makes use of
2450      the fact that we have already set TREE_PUBLIC appropriately, and
2451      then handles a few special cases.  Ideally, we would calculate
2452      linkage first, and then transform that into a concrete
2453      implementation.  */
2454
2455   /* Things that don't have names have no linkage.  */
2456   if (!DECL_NAME (decl))
2457     return lk_none;
2458
2459   /* Things that are TREE_PUBLIC have external linkage.  */
2460   if (TREE_PUBLIC (decl))
2461     return lk_external;
2462
2463   if (TREE_CODE (decl) == NAMESPACE_DECL)
2464     return lk_external;
2465
2466   /* Linkage of a CONST_DECL depends on the linkage of the enumeration
2467      type.  */
2468   if (TREE_CODE (decl) == CONST_DECL)
2469     return decl_linkage (TYPE_NAME (TREE_TYPE (decl)));
2470
2471   /* Some things that are not TREE_PUBLIC have external linkage, too.
2472      For example, on targets that don't have weak symbols, we make all
2473      template instantiations have internal linkage (in the object
2474      file), but the symbols should still be treated as having external
2475      linkage from the point of view of the language.  */
2476   if (TREE_CODE (decl) != TYPE_DECL && DECL_LANG_SPECIFIC (decl)
2477       && DECL_COMDAT (decl))
2478     return lk_external;
2479
2480   /* Things in local scope do not have linkage, if they don't have
2481      TREE_PUBLIC set.  */
2482   if (decl_function_context (decl))
2483     return lk_none;
2484
2485   /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
2486      are considered to have external linkage for language purposes.  DECLs
2487      really meant to have internal linkage have DECL_THIS_STATIC set.  */
2488   if (TREE_CODE (decl) == TYPE_DECL
2489       || ((TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
2490           && !DECL_THIS_STATIC (decl)))
2491     return lk_external;
2492
2493   /* Everything else has internal linkage.  */
2494   return lk_internal;
2495 }
2496 \f
2497 /* EXP is an expression that we want to pre-evaluate.  Returns (in
2498    *INITP) an expression that will perform the pre-evaluation.  The
2499    value returned by this function is a side-effect free expression
2500    equivalent to the pre-evaluated expression.  Callers must ensure
2501    that *INITP is evaluated before EXP.  */
2502
2503 tree
2504 stabilize_expr (tree exp, tree* initp)
2505 {
2506   tree init_expr;
2507
2508   if (!TREE_SIDE_EFFECTS (exp))
2509     init_expr = NULL_TREE;
2510   else if (!real_lvalue_p (exp)
2511            || !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (exp)))
2512     {
2513       init_expr = get_target_expr (exp);
2514       exp = TARGET_EXPR_SLOT (init_expr);
2515     }
2516   else
2517     {
2518       exp = build_unary_op (ADDR_EXPR, exp, 1);
2519       init_expr = get_target_expr (exp);
2520       exp = TARGET_EXPR_SLOT (init_expr);
2521       exp = build_indirect_ref (exp, 0);
2522     }
2523   *initp = init_expr;
2524
2525   gcc_assert (!TREE_SIDE_EFFECTS (exp));
2526   return exp;
2527 }
2528
2529 /* Add NEW, an expression whose value we don't care about, after the
2530    similar expression ORIG.  */
2531
2532 tree
2533 add_stmt_to_compound (tree orig, tree new)
2534 {
2535   if (!new || !TREE_SIDE_EFFECTS (new))
2536     return orig;
2537   if (!orig || !TREE_SIDE_EFFECTS (orig))
2538     return new;
2539   return build2 (COMPOUND_EXPR, void_type_node, orig, new);
2540 }
2541
2542 /* Like stabilize_expr, but for a call whose arguments we want to
2543    pre-evaluate.  CALL is modified in place to use the pre-evaluated
2544    arguments, while, upon return, *INITP contains an expression to
2545    compute the arguments.  */
2546
2547 void
2548 stabilize_call (tree call, tree *initp)
2549 {
2550   tree inits = NULL_TREE;
2551   int i;
2552   int nargs = call_expr_nargs (call);
2553
2554   if (call == error_mark_node)
2555     return;
2556
2557   gcc_assert (TREE_CODE (call) == CALL_EXPR);
2558
2559   for (i = 0; i < nargs; i++)
2560     {
2561       tree init;
2562       CALL_EXPR_ARG (call, i) =
2563         stabilize_expr (CALL_EXPR_ARG (call, i), &init);
2564       inits = add_stmt_to_compound (inits, init);
2565     }
2566
2567   *initp = inits;
2568 }
2569
2570 /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
2571    to pre-evaluate.  CALL is modified in place to use the pre-evaluated
2572    arguments, while, upon return, *INITP contains an expression to
2573    compute the arguments.  */
2574
2575 void
2576 stabilize_aggr_init (tree call, tree *initp)
2577 {
2578   tree inits = NULL_TREE;
2579   int i;
2580   int nargs = aggr_init_expr_nargs (call);
2581
2582   if (call == error_mark_node)
2583     return;
2584
2585   gcc_assert (TREE_CODE (call) == AGGR_INIT_EXPR);
2586
2587   for (i = 0; i < nargs; i++)
2588     {
2589       tree init;
2590       AGGR_INIT_EXPR_ARG (call, i) =
2591         stabilize_expr (AGGR_INIT_EXPR_ARG (call, i), &init);
2592       inits = add_stmt_to_compound (inits, init);
2593     }
2594
2595   *initp = inits;
2596 }
2597
2598 /* Like stabilize_expr, but for an initialization.
2599
2600    If the initialization is for an object of class type, this function
2601    takes care not to introduce additional temporaries.
2602
2603    Returns TRUE iff the expression was successfully pre-evaluated,
2604    i.e., if INIT is now side-effect free, except for, possible, a
2605    single call to a constructor.  */
2606
2607 bool
2608 stabilize_init (tree init, tree *initp)
2609 {
2610   tree t = init;
2611
2612   *initp = NULL_TREE;
2613
2614   if (t == error_mark_node)
2615     return true;
2616
2617   if (TREE_CODE (t) == INIT_EXPR
2618       && TREE_CODE (TREE_OPERAND (t, 1)) != TARGET_EXPR)
2619     {
2620       TREE_OPERAND (t, 1) = stabilize_expr (TREE_OPERAND (t, 1), initp);
2621       return true;
2622     }
2623
2624   if (TREE_CODE (t) == INIT_EXPR)
2625     t = TREE_OPERAND (t, 1);
2626   if (TREE_CODE (t) == TARGET_EXPR)
2627     t = TARGET_EXPR_INITIAL (t);
2628   if (TREE_CODE (t) == COMPOUND_EXPR)
2629     t = expr_last (t);
2630   if (TREE_CODE (t) == CONSTRUCTOR
2631       && EMPTY_CONSTRUCTOR_P (t))
2632     /* Default-initialization.  */
2633     return true;
2634
2635   /* If the initializer is a COND_EXPR, we can't preevaluate
2636      anything.  */
2637   if (TREE_CODE (t) == COND_EXPR)
2638     return false;
2639
2640   if (TREE_CODE (t) == CALL_EXPR)
2641     {
2642       stabilize_call (t, initp);
2643       return true;
2644     }
2645
2646   if (TREE_CODE (t) == AGGR_INIT_EXPR)
2647     {
2648       stabilize_aggr_init (t, initp);
2649       return true;
2650     }
2651
2652   /* The initialization is being performed via a bitwise copy -- and
2653      the item copied may have side effects.  */
2654   return TREE_SIDE_EFFECTS (init);
2655 }
2656
2657 /* Like "fold", but should be used whenever we might be processing the
2658    body of a template.  */
2659
2660 tree
2661 fold_if_not_in_template (tree expr)
2662 {
2663   /* In the body of a template, there is never any need to call
2664      "fold".  We will call fold later when actually instantiating the
2665      template.  Integral constant expressions in templates will be
2666      evaluated via fold_non_dependent_expr, as necessary.  */
2667   if (processing_template_decl)
2668     return expr;
2669
2670   /* Fold C++ front-end specific tree codes.  */
2671   if (TREE_CODE (expr) == UNARY_PLUS_EXPR)
2672     return fold_convert (TREE_TYPE (expr), TREE_OPERAND (expr, 0));
2673
2674   return fold (expr);
2675 }
2676
2677 /* Returns true if a cast to TYPE may appear in an integral constant
2678    expression.  */
2679
2680 bool
2681 cast_valid_in_integral_constant_expression_p (tree type)
2682 {
2683   return (INTEGRAL_OR_ENUMERATION_TYPE_P (type)
2684           || dependent_type_p (type)
2685           || type == error_mark_node);
2686 }
2687
2688 \f
2689 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
2690 /* Complain that some language-specific thing hanging off a tree
2691    node has been accessed improperly.  */
2692
2693 void
2694 lang_check_failed (const char* file, int line, const char* function)
2695 {
2696   internal_error ("lang_* check: failed in %s, at %s:%d",
2697                   function, trim_filename (file), line);
2698 }
2699 #endif /* ENABLE_TREE_CHECKING */
2700
2701 #include "gt-cp-tree.h"