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 SIZEOF_EXPR:
1591     case ALIGNOF_EXPR:
1592       {
1593         tree o1 = TREE_OPERAND (t1, 0);
1594         tree o2 = TREE_OPERAND (t2, 0);
1595
1596         if (TREE_CODE (o1) != TREE_CODE (o2))
1597           return false;
1598         if (TYPE_P (o1))
1599           return same_type_p (o1, o2);
1600         else
1601           return cp_tree_equal (o1, o2);
1602       }
1603
1604     case PTRMEM_CST:
1605       /* Two pointer-to-members are the same if they point to the same
1606          field or function in the same class.  */
1607       if (PTRMEM_CST_MEMBER (t1) != PTRMEM_CST_MEMBER (t2))
1608         return false;
1609
1610       return same_type_p (PTRMEM_CST_CLASS (t1), PTRMEM_CST_CLASS (t2));
1611
1612     default:
1613       break;
1614     }
1615
1616   switch (TREE_CODE_CLASS (code1))
1617     {
1618     case '1':
1619     case '2':
1620     case '<':
1621     case 'e':
1622     case 'r':
1623     case 's':
1624       {
1625         int i;
1626
1627         for (i = 0; i < TREE_CODE_LENGTH (code1); ++i)
1628           if (!cp_tree_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i)))
1629             return false;
1630
1631         return true;
1632       }
1633
1634     case 't':
1635       return same_type_p (t1, t2);
1636     }
1637
1638   my_friendly_assert (0, 20030617);
1639   return false;
1640 }
1641
1642 /* Build a wrapper around a 'struct z_candidate' so we can use it as a
1643    tree.  */
1644
1645 tree
1646 build_zc_wrapper (struct z_candidate* ptr)
1647 {
1648   tree t = make_node (WRAPPER);
1649   WRAPPER_ZC (t) = ptr;
1650   return t;
1651 }
1652
1653 /* The type of ARG when used as an lvalue.  */
1654
1655 tree
1656 lvalue_type (tree arg)
1657 {
1658   tree type = TREE_TYPE (arg);
1659   if (TREE_CODE (arg) == OVERLOAD)
1660     type = unknown_type_node;
1661   return type;
1662 }
1663
1664 /* The type of ARG for printing error messages; denote lvalues with
1665    reference types.  */
1666
1667 tree
1668 error_type (tree arg)
1669 {
1670   tree type = TREE_TYPE (arg);
1671
1672   if (TREE_CODE (type) == ARRAY_TYPE)
1673     ;
1674   else if (TREE_CODE (type) == ERROR_MARK)
1675     ;
1676   else if (real_lvalue_p (arg))
1677     type = build_reference_type (lvalue_type (arg));
1678   else if (IS_AGGR_TYPE (type))
1679     type = lvalue_type (arg);
1680
1681   return type;
1682 }
1683
1684 /* Does FUNCTION use a variable-length argument list?  */
1685
1686 int
1687 varargs_function_p (tree function)
1688 {
1689   tree parm = TYPE_ARG_TYPES (TREE_TYPE (function));
1690   for (; parm; parm = TREE_CHAIN (parm))
1691     if (TREE_VALUE (parm) == void_type_node)
1692       return 0;
1693   return 1;
1694 }
1695
1696 /* Returns 1 if decl is a member of a class.  */
1697
1698 int
1699 member_p (tree decl)
1700 {
1701   const tree ctx = DECL_CONTEXT (decl);
1702   return (ctx && TYPE_P (ctx));
1703 }
1704
1705 /* Create a placeholder for member access where we don't actually have an
1706    object that the access is against.  */
1707
1708 tree
1709 build_dummy_object (tree type)
1710 {
1711   tree decl = build1 (NOP_EXPR, build_pointer_type (type), void_zero_node);
1712   return build_indirect_ref (decl, NULL);
1713 }
1714
1715 /* We've gotten a reference to a member of TYPE.  Return *this if appropriate,
1716    or a dummy object otherwise.  If BINFOP is non-0, it is filled with the
1717    binfo path from current_class_type to TYPE, or 0.  */
1718
1719 tree
1720 maybe_dummy_object (tree type, tree* binfop)
1721 {
1722   tree decl, context;
1723   tree binfo;
1724
1725   if (current_class_type
1726       && (binfo = lookup_base (current_class_type, type,
1727                                ba_ignore | ba_quiet, NULL)))
1728     context = current_class_type;
1729   else
1730     {
1731       /* Reference from a nested class member function.  */
1732       context = type;
1733       binfo = TYPE_BINFO (type);
1734     }
1735
1736   if (binfop)
1737     *binfop = binfo;
1738
1739   if (current_class_ref && context == current_class_type
1740       /* Kludge: Make sure that current_class_type is actually
1741          correct.  It might not be if we're in the middle of
1742          tsubst_default_argument.  */
1743       && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (current_class_ref)),
1744                       current_class_type))
1745     decl = current_class_ref;
1746   else
1747     decl = build_dummy_object (context);
1748
1749   return decl;
1750 }
1751
1752 /* Returns 1 if OB is a placeholder object, or a pointer to one.  */
1753
1754 int
1755 is_dummy_object (tree ob)
1756 {
1757   if (TREE_CODE (ob) == INDIRECT_REF)
1758     ob = TREE_OPERAND (ob, 0);
1759   return (TREE_CODE (ob) == NOP_EXPR
1760           && TREE_OPERAND (ob, 0) == void_zero_node);
1761 }
1762
1763 /* Returns 1 iff type T is a POD type, as defined in [basic.types].  */
1764
1765 int
1766 pod_type_p (tree t)
1767 {
1768   t = strip_array_types (t);
1769
1770   if (t == error_mark_node)
1771     return 1;
1772   if (INTEGRAL_TYPE_P (t))
1773     return 1;  /* integral, character or enumeral type */
1774   if (FLOAT_TYPE_P (t))
1775     return 1;
1776   if (TYPE_PTR_P (t))
1777     return 1; /* pointer to non-member */
1778   if (TYPE_PTRMEM_P (t))
1779     return 1; /* pointer to member object */
1780   if (TYPE_PTRMEMFUNC_P (t))
1781     return 1; /* pointer to member function */
1782
1783   if (! CLASS_TYPE_P (t))
1784     return 0; /* other non-class type (reference or function) */
1785   if (CLASSTYPE_NON_POD_P (t))
1786     return 0;
1787   return 1;
1788 }
1789
1790 /* Returns 1 iff zero initialization of type T means actually storing
1791    zeros in it.  */
1792
1793 int
1794 zero_init_p (tree t)
1795 {
1796   t = strip_array_types (t);
1797
1798   if (t == error_mark_node)
1799     return 1;
1800
1801   /* NULL pointers to data members are initialized with -1.  */
1802   if (TYPE_PTRMEM_P (t))
1803     return 0;
1804
1805   /* Classes that contain types that can't be zero-initialized, cannot
1806      be zero-initialized themselves.  */
1807   if (CLASS_TYPE_P (t) && CLASSTYPE_NON_ZERO_INIT_P (t))
1808     return 0;
1809
1810   return 1;
1811 }
1812
1813 /* Table of valid C++ attributes.  */
1814 const struct attribute_spec cxx_attribute_table[] =
1815 {
1816   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
1817   { "java_interface", 0, 0, false, false, false, handle_java_interface_attribute },
1818   { "com_interface",  0, 0, false, false, false, handle_com_interface_attribute },
1819   { "init_priority",  1, 1, true,  false, false, handle_init_priority_attribute },
1820   { NULL,             0, 0, false, false, false, NULL }
1821 };
1822
1823 /* Handle a "java_interface" attribute; arguments as in
1824    struct attribute_spec.handler.  */
1825 static tree
1826 handle_java_interface_attribute (tree* node,
1827                                  tree name,
1828                                  tree args ATTRIBUTE_UNUSED ,
1829                                  int flags,
1830                                  bool* no_add_attrs)
1831 {
1832   if (DECL_P (*node)
1833       || !CLASS_TYPE_P (*node)
1834       || !TYPE_FOR_JAVA (*node))
1835     {
1836       error ("`%s' attribute can only be applied to Java class definitions",
1837              IDENTIFIER_POINTER (name));
1838       *no_add_attrs = true;
1839       return NULL_TREE;
1840     }
1841   if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
1842     *node = build_type_copy (*node);
1843   TYPE_JAVA_INTERFACE (*node) = 1;
1844
1845   return NULL_TREE;
1846 }
1847
1848 /* Handle a "com_interface" attribute; arguments as in
1849    struct attribute_spec.handler.  */
1850 static tree
1851 handle_com_interface_attribute (tree* node,
1852                                 tree name,
1853                                 tree args ATTRIBUTE_UNUSED ,
1854                                 int flags ATTRIBUTE_UNUSED ,
1855                                 bool* no_add_attrs)
1856 {
1857   static int warned;
1858
1859   *no_add_attrs = true;
1860
1861   if (DECL_P (*node)
1862       || !CLASS_TYPE_P (*node)
1863       || *node != TYPE_MAIN_VARIANT (*node))
1864     {
1865       warning ("`%s' attribute can only be applied to class definitions",
1866                IDENTIFIER_POINTER (name));
1867       return NULL_TREE;
1868     }
1869
1870   if (!warned++)
1871     warning ("`%s' is obsolete; g++ vtables are now COM-compatible by default",
1872              IDENTIFIER_POINTER (name));
1873
1874   return NULL_TREE;
1875 }
1876
1877 /* Handle an "init_priority" attribute; arguments as in
1878    struct attribute_spec.handler.  */
1879 static tree
1880 handle_init_priority_attribute (tree* node,
1881                                 tree name,
1882                                 tree args,
1883                                 int flags ATTRIBUTE_UNUSED ,
1884                                 bool* no_add_attrs)
1885 {
1886   tree initp_expr = TREE_VALUE (args);
1887   tree decl = *node;
1888   tree type = TREE_TYPE (decl);
1889   int pri;
1890
1891   STRIP_NOPS (initp_expr);
1892
1893   if (!initp_expr || TREE_CODE (initp_expr) != INTEGER_CST)
1894     {
1895       error ("requested init_priority is not an integer constant");
1896       *no_add_attrs = true;
1897       return NULL_TREE;
1898     }
1899
1900   pri = TREE_INT_CST_LOW (initp_expr);
1901
1902   type = strip_array_types (type);
1903
1904   if (decl == NULL_TREE
1905       || TREE_CODE (decl) != VAR_DECL
1906       || !TREE_STATIC (decl)
1907       || DECL_EXTERNAL (decl)
1908       || (TREE_CODE (type) != RECORD_TYPE
1909           && TREE_CODE (type) != UNION_TYPE)
1910       /* Static objects in functions are initialized the
1911          first time control passes through that
1912          function. This is not precise enough to pin down an
1913          init_priority value, so don't allow it.  */
1914       || current_function_decl)
1915     {
1916       error ("can only use `%s' attribute on file-scope definitions of objects of class type",
1917              IDENTIFIER_POINTER (name));
1918       *no_add_attrs = true;
1919       return NULL_TREE;
1920     }
1921
1922   if (pri > MAX_INIT_PRIORITY || pri <= 0)
1923     {
1924       error ("requested init_priority is out of range");
1925       *no_add_attrs = true;
1926       return NULL_TREE;
1927     }
1928
1929   /* Check for init_priorities that are reserved for
1930      language and runtime support implementations.*/
1931   if (pri <= MAX_RESERVED_INIT_PRIORITY)
1932     {
1933       warning
1934         ("requested init_priority is reserved for internal use");
1935     }
1936
1937   if (SUPPORTS_INIT_PRIORITY)
1938     {
1939       DECL_INIT_PRIORITY (decl) = pri;
1940       return NULL_TREE;
1941     }
1942   else
1943     {
1944       error ("`%s' attribute is not supported on this platform",
1945              IDENTIFIER_POINTER (name));
1946       *no_add_attrs = true;
1947       return NULL_TREE;
1948     }
1949 }
1950
1951 /* Return a new PTRMEM_CST of the indicated TYPE.  The MEMBER is the
1952    thing pointed to by the constant.  */
1953
1954 tree
1955 make_ptrmem_cst (tree type, tree member)
1956 {
1957   tree ptrmem_cst = make_node (PTRMEM_CST);
1958   /* If would seem a great convenience if make_node would set
1959      TREE_CONSTANT for things of class `c', but it does not.  */
1960   TREE_CONSTANT (ptrmem_cst) = 1;
1961   TREE_TYPE (ptrmem_cst) = type;
1962   PTRMEM_CST_MEMBER (ptrmem_cst) = member;
1963   return ptrmem_cst;
1964 }
1965
1966 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
1967    traversal.  Called from walk_tree().  */
1968
1969 tree
1970 cp_walk_subtrees (tree* tp,
1971                   int* walk_subtrees_p,
1972                   walk_tree_fn func,
1973                   void* data,
1974                   void* htab)
1975 {
1976   enum tree_code code = TREE_CODE (*tp);
1977   tree result;
1978
1979 #define WALK_SUBTREE(NODE)                              \
1980   do                                                    \
1981     {                                                   \
1982       result = walk_tree (&(NODE), func, data, htab);   \
1983       if (result)                                       \
1984         return result;                                  \
1985     }                                                   \
1986   while (0)
1987
1988   /* Not one of the easy cases.  We must explicitly go through the
1989      children.  */
1990   switch (code)
1991     {
1992     case DEFAULT_ARG:
1993     case TEMPLATE_TEMPLATE_PARM:
1994     case BOUND_TEMPLATE_TEMPLATE_PARM:
1995     case UNBOUND_CLASS_TEMPLATE:
1996     case TEMPLATE_PARM_INDEX:
1997     case TEMPLATE_TYPE_PARM:
1998     case TYPENAME_TYPE:
1999     case TYPEOF_TYPE:
2000     case BASELINK:
2001       /* None of thse have subtrees other than those already walked
2002          above.  */
2003       *walk_subtrees_p = 0;
2004       break;
2005
2006     case PTRMEM_CST:
2007       WALK_SUBTREE (TREE_TYPE (*tp));
2008       *walk_subtrees_p = 0;
2009       break;
2010
2011     case TREE_LIST:
2012       WALK_SUBTREE (TREE_PURPOSE (*tp));
2013       break;
2014
2015     case OVERLOAD:
2016       WALK_SUBTREE (OVL_FUNCTION (*tp));
2017       WALK_SUBTREE (OVL_CHAIN (*tp));
2018       *walk_subtrees_p = 0;
2019       break;
2020
2021     case RECORD_TYPE:
2022       if (TYPE_PTRMEMFUNC_P (*tp))
2023         WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE (*tp));
2024       break;
2025
2026     default:
2027       break;
2028     }
2029
2030   /* We didn't find what we were looking for.  */
2031   return NULL_TREE;
2032
2033 #undef WALK_SUBTREE
2034 }
2035
2036 /* Decide whether there are language-specific reasons to not inline a
2037    function as a tree.  */
2038
2039 int
2040 cp_cannot_inline_tree_fn (tree* fnp)
2041 {
2042   tree fn = *fnp;
2043
2044   /* We can inline a template instantiation only if it's fully
2045      instantiated.  */
2046   if (DECL_TEMPLATE_INFO (fn)
2047       && TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (fn)))
2048     {
2049       /* Don't instantiate functions that are not going to be
2050          inlined.  */
2051       if (!DECL_INLINE (DECL_TEMPLATE_RESULT
2052                         (template_for_substitution (fn))))
2053         return 1;
2054       fn = *fnp = instantiate_decl (fn, /*defer_ok=*/0);
2055       if (TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (fn)))
2056         return 1;
2057     }
2058
2059   if (flag_really_no_inline
2060       && lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) == NULL)
2061     return 1;
2062
2063   /* Don't auto-inline anything that might not be bound within
2064      this unit of translation.  */
2065   if (!DECL_DECLARED_INLINE_P (fn) && !(*targetm.binds_local_p) (fn))
2066     {
2067       DECL_UNINLINABLE (fn) = 1;
2068       return 1;
2069     }
2070
2071   if (varargs_function_p (fn))
2072     {
2073       DECL_UNINLINABLE (fn) = 1;
2074       return 1;
2075     }
2076
2077   if (! function_attribute_inlinable_p (fn))
2078     {
2079       DECL_UNINLINABLE (fn) = 1;
2080       return 1;
2081     }
2082
2083   return 0;
2084 }
2085
2086 /* Add any pending functions other than the current function (already
2087    handled by the caller), that thus cannot be inlined, to FNS_P, then
2088    return the latest function added to the array, PREV_FN.  */
2089
2090 tree
2091 cp_add_pending_fn_decls (void* fns_p, tree prev_fn)
2092 {
2093   varray_type *fnsp = (varray_type *)fns_p;
2094   struct saved_scope *s;
2095
2096   for (s = scope_chain; s; s = s->prev)
2097     if (s->function_decl && s->function_decl != prev_fn)
2098       {
2099         VARRAY_PUSH_TREE (*fnsp, s->function_decl);
2100         prev_fn = s->function_decl;
2101       }
2102
2103   return prev_fn;
2104 }
2105
2106 /* Determine whether a tree node is an OVERLOAD node.  Used to decide
2107    whether to copy a node or to preserve its chain when inlining a
2108    function.  */
2109
2110 int
2111 cp_is_overload_p (tree t)
2112 {
2113   return TREE_CODE (t) == OVERLOAD;
2114 }
2115
2116 /* Determine whether VAR is a declaration of an automatic variable in
2117    function FN.  */
2118
2119 int
2120 cp_auto_var_in_fn_p (tree var, tree fn)
2121 {
2122   return (DECL_P (var) && DECL_CONTEXT (var) == fn
2123           && nonstatic_local_decl_p (var));
2124 }
2125
2126 /* Tell whether a declaration is needed for the RESULT of a function
2127    FN being inlined into CALLER or if the top node of target_exprs is
2128    to be used.  */
2129
2130 tree
2131 cp_copy_res_decl_for_inlining (tree result,
2132                                tree fn,
2133                                tree caller,
2134                                void* decl_map_,
2135                                int* need_decl,
2136                                tree return_slot_addr)
2137 {
2138   splay_tree decl_map = (splay_tree)decl_map_;
2139   tree var;
2140
2141   /* If FN returns an aggregate then the caller will always pass the
2142      address of the return slot explicitly.  If we were just to
2143      create a new VAR_DECL here, then the result of this function
2144      would be copied (bitwise) into the variable initialized by the
2145      TARGET_EXPR.  That's incorrect, so we must transform any
2146      references to the RESULT into references to the target.  */
2147
2148   /* We should have an explicit return slot iff the return type is
2149      TREE_ADDRESSABLE.  See simplify_aggr_init_expr.  */
2150   if (TREE_ADDRESSABLE (TREE_TYPE (result))
2151       != (return_slot_addr != NULL_TREE))
2152     abort ();
2153
2154   *need_decl = !return_slot_addr;
2155   if (return_slot_addr)
2156     {
2157       var = build_indirect_ref (return_slot_addr, "");
2158       if (! same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (var),
2159                                                        TREE_TYPE (result)))
2160         abort ();
2161     }
2162   /* Otherwise, make an appropriate copy.  */
2163   else
2164     var = copy_decl_for_inlining (result, fn, caller);
2165
2166   if (DECL_SAVED_FUNCTION_DATA (fn))
2167     {
2168       tree nrv = DECL_SAVED_FUNCTION_DATA (fn)->x_return_value;
2169       if (nrv)
2170         {
2171           /* We have a named return value; copy the name and source
2172              position so we can get reasonable debugging information, and
2173              register the return variable as its equivalent.  */
2174           if (TREE_CODE (var) == VAR_DECL)
2175             {
2176               DECL_NAME (var) = DECL_NAME (nrv);
2177               DECL_SOURCE_LOCATION (var) = DECL_SOURCE_LOCATION (nrv);
2178               DECL_ABSTRACT_ORIGIN (var) = DECL_ORIGIN (nrv);
2179               /* Don't lose initialization info.  */
2180               DECL_INITIAL (var) = DECL_INITIAL (nrv);
2181               /* Don't forget that it needs to go in the stack.  */
2182               TREE_ADDRESSABLE (var) = TREE_ADDRESSABLE (nrv);
2183             }
2184
2185           splay_tree_insert (decl_map,
2186                              (splay_tree_key) nrv,
2187                              (splay_tree_value) var);
2188         }
2189     }
2190
2191   return var;
2192 }
2193
2194 /* Record that we're about to start inlining FN, and return nonzero if
2195    that's OK.  Used for lang_hooks.tree_inlining.start_inlining.  */
2196
2197 int
2198 cp_start_inlining (tree fn)
2199 {
2200   if (DECL_TEMPLATE_INSTANTIATION (fn))
2201     return push_tinst_level (fn);
2202   else
2203     return 1;
2204 }
2205
2206 /* Record that we're done inlining FN.  Used for
2207    lang_hooks.tree_inlining.end_inlining.  */
2208
2209 void
2210 cp_end_inlining (tree fn ATTRIBUTE_UNUSED )
2211 {
2212   if (DECL_TEMPLATE_INSTANTIATION (fn))
2213     pop_tinst_level ();
2214 }
2215
2216 /* Initialize tree.c.  */
2217
2218 void
2219 init_tree (void)
2220 {
2221   list_hash_table = htab_create_ggc (31, list_hash, list_hash_eq, NULL);
2222 }
2223
2224 /* Called via walk_tree.  If *TP points to a DECL_STMT for a local
2225    declaration, copies the declaration and enters it in the splay_tree
2226    pointed to by DATA (which is really a `splay_tree *').  */
2227
2228 static tree
2229 mark_local_for_remap_r (tree* tp,
2230                         int* walk_subtrees ATTRIBUTE_UNUSED ,
2231                         void* data)
2232 {
2233   tree t = *tp;
2234   splay_tree st = (splay_tree) data;
2235   tree decl;
2236
2237
2238   if (TREE_CODE (t) == DECL_STMT
2239       && nonstatic_local_decl_p (DECL_STMT_DECL (t)))
2240     decl = DECL_STMT_DECL (t);
2241   else if (TREE_CODE (t) == LABEL_STMT)
2242     decl = LABEL_STMT_LABEL (t);
2243   else if (TREE_CODE (t) == TARGET_EXPR
2244            && nonstatic_local_decl_p (TREE_OPERAND (t, 0)))
2245     decl = TREE_OPERAND (t, 0);
2246   else if (TREE_CODE (t) == CASE_LABEL)
2247     decl = CASE_LABEL_DECL (t);
2248   else
2249     decl = NULL_TREE;
2250
2251   if (decl)
2252     {
2253       tree copy;
2254
2255       /* Make a copy.  */
2256       copy = copy_decl_for_inlining (decl,
2257                                      DECL_CONTEXT (decl),
2258                                      DECL_CONTEXT (decl));
2259
2260       /* Remember the copy.  */
2261       splay_tree_insert (st,
2262                          (splay_tree_key) decl,
2263                          (splay_tree_value) copy);
2264     }
2265
2266   return NULL_TREE;
2267 }
2268
2269 /* Called via walk_tree when an expression is unsaved.  Using the
2270    splay_tree pointed to by ST (which is really a `splay_tree'),
2271    remaps all local declarations to appropriate replacements.  */
2272
2273 static tree
2274 cp_unsave_r (tree* tp,
2275              int* walk_subtrees,
2276              void* data)
2277 {
2278   splay_tree st = (splay_tree) data;
2279   splay_tree_node n;
2280
2281   /* Only a local declaration (variable or label).  */
2282   if (nonstatic_local_decl_p (*tp))
2283     {
2284       /* Lookup the declaration.  */
2285       n = splay_tree_lookup (st, (splay_tree_key) *tp);
2286
2287       /* If it's there, remap it.  */
2288       if (n)
2289         *tp = (tree) n->value;
2290     }
2291   else if (TREE_CODE (*tp) == SAVE_EXPR)
2292     remap_save_expr (tp, st, current_function_decl, walk_subtrees);
2293   else
2294     {
2295       copy_tree_r (tp, walk_subtrees, NULL);
2296
2297       /* Do whatever unsaving is required.  */
2298       unsave_expr_1 (*tp);
2299     }
2300
2301   /* Keep iterating.  */
2302   return NULL_TREE;
2303 }
2304
2305 /* Called whenever an expression needs to be unsaved.  */
2306
2307 tree
2308 cxx_unsave_expr_now (tree tp)
2309 {
2310   splay_tree st;
2311
2312   /* Create a splay-tree to map old local variable declarations to new
2313      ones.  */
2314   st = splay_tree_new (splay_tree_compare_pointers, NULL, NULL);
2315
2316   /* Walk the tree once figuring out what needs to be remapped.  */
2317   walk_tree (&tp, mark_local_for_remap_r, st, NULL);
2318
2319   /* Walk the tree again, copying, remapping, and unsaving.  */
2320   walk_tree (&tp, cp_unsave_r, st, NULL);
2321
2322   /* Clean up.  */
2323   splay_tree_delete (st);
2324
2325   return tp;
2326 }
2327
2328 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
2329    is.  Note that sfk_none is zero, so this function can be used as a
2330    predicate to test whether or not DECL is a special function.  */
2331
2332 special_function_kind
2333 special_function_p (tree decl)
2334 {
2335   /* Rather than doing all this stuff with magic names, we should
2336      probably have a field of type `special_function_kind' in
2337      DECL_LANG_SPECIFIC.  */
2338   if (DECL_COPY_CONSTRUCTOR_P (decl))
2339     return sfk_copy_constructor;
2340   if (DECL_CONSTRUCTOR_P (decl))
2341     return sfk_constructor;
2342   if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
2343     return sfk_assignment_operator;
2344   if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl))
2345     return sfk_destructor;
2346   if (DECL_COMPLETE_DESTRUCTOR_P (decl))
2347     return sfk_complete_destructor;
2348   if (DECL_BASE_DESTRUCTOR_P (decl))
2349     return sfk_base_destructor;
2350   if (DECL_DELETING_DESTRUCTOR_P (decl))
2351     return sfk_deleting_destructor;
2352   if (DECL_CONV_FN_P (decl))
2353     return sfk_conversion;
2354
2355   return sfk_none;
2356 }
2357
2358 /* Returns true if and only if NODE is a name, i.e., a node created
2359    by the parser when processing an id-expression.  */
2360
2361 bool
2362 name_p (tree node)
2363 {
2364   if (TREE_CODE (node) == TEMPLATE_ID_EXPR)
2365     node = TREE_OPERAND (node, 0);
2366   return (/* An ordinary unqualified name.  */
2367           TREE_CODE (node) == IDENTIFIER_NODE
2368           /* A destructor name.  */
2369           || TREE_CODE (node) == BIT_NOT_EXPR
2370           /* A qualified name.  */
2371           || TREE_CODE (node) == SCOPE_REF);
2372 }
2373
2374 /* Returns nonzero if TYPE is a character type, including wchar_t.  */
2375
2376 int
2377 char_type_p (tree type)
2378 {
2379   return (same_type_p (type, char_type_node)
2380           || same_type_p (type, unsigned_char_type_node)
2381           || same_type_p (type, signed_char_type_node)
2382           || same_type_p (type, wchar_type_node));
2383 }
2384
2385 /* Returns the kind of linkage associated with the indicated DECL.  Th
2386    value returned is as specified by the language standard; it is
2387    independent of implementation details regarding template
2388    instantiation, etc.  For example, it is possible that a declaration
2389    to which this function assigns external linkage would not show up
2390    as a global symbol when you run `nm' on the resulting object file.  */
2391
2392 linkage_kind
2393 decl_linkage (tree decl)
2394 {
2395   /* This function doesn't attempt to calculate the linkage from first
2396      principles as given in [basic.link].  Instead, it makes use of
2397      the fact that we have already set TREE_PUBLIC appropriately, and
2398      then handles a few special cases.  Ideally, we would calculate
2399      linkage first, and then transform that into a concrete
2400      implementation.  */
2401
2402   /* Things that don't have names have no linkage.  */
2403   if (!DECL_NAME (decl))
2404     return lk_none;
2405
2406   /* Things that are TREE_PUBLIC have external linkage.  */
2407   if (TREE_PUBLIC (decl))
2408     return lk_external;
2409
2410   /* Some things that are not TREE_PUBLIC have external linkage, too.
2411      For example, on targets that don't have weak symbols, we make all
2412      template instantiations have internal linkage (in the object
2413      file), but the symbols should still be treated as having external
2414      linkage from the point of view of the language.  */
2415   if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
2416     return lk_external;
2417
2418   /* Things in local scope do not have linkage, if they don't have
2419      TREE_PUBLIC set.  */
2420   if (decl_function_context (decl))
2421     return lk_none;
2422
2423   /* Everything else has internal linkage.  */
2424   return lk_internal;
2425 }
2426 \f
2427 /* EXP is an expression that we want to pre-evaluate.  Returns via INITP an
2428    expression to perform the pre-evaluation, and returns directly an
2429    expression to use the precalculated result.  */
2430
2431 tree
2432 stabilize_expr (tree exp, tree* initp)
2433 {
2434   tree init_expr;
2435
2436   if (!TREE_SIDE_EFFECTS (exp))
2437     {
2438       init_expr = void_zero_node;
2439     }
2440   else if (!real_lvalue_p (exp)
2441            || !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (exp)))
2442     {
2443       init_expr = get_target_expr (exp);
2444       exp = TARGET_EXPR_SLOT (init_expr);
2445     }
2446   else
2447     {
2448       exp = build_unary_op (ADDR_EXPR, exp, 1);
2449       init_expr = get_target_expr (exp);
2450       exp = TARGET_EXPR_SLOT (init_expr);
2451       exp = build_indirect_ref (exp, 0);
2452     }
2453
2454   *initp = init_expr;
2455   return exp;
2456 }
2457 \f
2458 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
2459 /* Complain that some language-specific thing hanging off a tree
2460    node has been accessed improperly.  */
2461
2462 void
2463 lang_check_failed (const char* file, int line, const char* function)
2464 {
2465   internal_error ("lang_* check: failed in %s, at %s:%d",
2466                   function, trim_filename (file), line);
2467 }
2468 #endif /* ENABLE_TREE_CHECKING */
2469
2470 #include "gt-cp-tree.h"