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