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