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