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