gcc/cp/tree.c

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