gcc/cp/tree.c

   1 /* Language-dependent node constructors for parse phase of GNU compiler.
   2    Copyright (C) 1987, 88, 92-98, 1999 Free Software Foundation, Inc.
   3    Hacked by Michael Tiemann (tiemann@cygnus.com)
   4
   5 This file is part of GNU CC.
   6
   7 GNU CC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU CC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU CC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "obstack.h"
  25 #include "tree.h"
  26 #include "cp-tree.h"
  27 #include "flags.h"
  28 #include "rtl.h"
  29 #include "toplev.h"
  30 #include "ggc.h"
  31 #include "splay-tree.h"
  32
  33 static tree bot_manip PROTO((tree));
  34 static tree bot_replace PROTO((tree *));
  35 static tree build_cplus_array_type_1 PROTO((tree, tree));
  36 static void list_hash_add PROTO((int, tree));
  37 static int list_hash PROTO((tree, tree, tree));
  38 static tree list_hash_lookup PROTO((int, tree, tree, tree));
  39 static void propagate_binfo_offsets PROTO((tree, tree));
  40 static int avoid_overlap PROTO((tree, tree));
  41 static cp_lvalue_kind lvalue_p_1 PROTO((tree, int));
  42 static tree no_linkage_helper PROTO((tree *));
  43 static tree build_srcloc PROTO((char *, int));
  44 static void mark_list_hash PROTO ((void *));
  45
  46 #define CEIL(x,y) (((x) + (y) - 1) / (y))
  47
  48 /* If REF is an lvalue, returns the kind of lvalue that REF is.
  49    Otherwise, returns clk_none.  If TREAT_CLASS_RVALUES_AS_LVALUES is
  50    non-zero, rvalues of class type are considered lvalues.  */
  51
  52 static cp_lvalue_kind
  53 lvalue_p_1 (ref, treat_class_rvalues_as_lvalues)
  54      tree ref;
  55      int treat_class_rvalues_as_lvalues;
  56 {
  57   cp_lvalue_kind op1_lvalue_kind = clk_none;
  58   cp_lvalue_kind op2_lvalue_kind = clk_none;
  59
  60   if (TREE_CODE (TREE_TYPE (ref)) == REFERENCE_TYPE)
  61     return clk_ordinary;
  62
  63   if (ref == current_class_ptr && flag_this_is_variable <= 0)
  64     return clk_none;
  65
  66   switch (TREE_CODE (ref))
  67     {
  68       /* preincrements and predecrements are valid lvals, provided
  69          what they refer to are valid lvals.  */
  70     case PREINCREMENT_EXPR:
  71     case PREDECREMENT_EXPR:
  72     case SAVE_EXPR:
  73     case UNSAVE_EXPR:
  74     case TRY_CATCH_EXPR:
  75     case WITH_CLEANUP_EXPR:
  76     case REALPART_EXPR:
  77     case IMAGPART_EXPR:
  78     case NOP_EXPR:
  79       return lvalue_p_1 (TREE_OPERAND (ref, 0),
  80                          treat_class_rvalues_as_lvalues);
  81
  82     case COMPONENT_REF:
  83       op1_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 0),
  84                                     treat_class_rvalues_as_lvalues);
  85       if (op1_lvalue_kind
  86           /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some
  87              situations.  */
  88           && TREE_CODE (TREE_OPERAND (ref, 1)) == FIELD_DECL
  89           && DECL_C_BIT_FIELD (TREE_OPERAND (ref, 1)))
  90         {
  91           /* Clear the ordinary bit.  If this object was a class
  92              rvalue we want to preserve that information.  */
  93           op1_lvalue_kind &= ~clk_ordinary;
  94           /* The lvalue is for a btifield.  */
  95           op1_lvalue_kind |= clk_bitfield;
  96         }
  97       return op1_lvalue_kind;
  98
  99     case STRING_CST:
 100       return clk_ordinary;
 101
 102     case VAR_DECL:
 103       if (TREE_READONLY (ref) && ! TREE_STATIC (ref)
 104           && DECL_LANG_SPECIFIC (ref)
 105           && DECL_IN_AGGR_P (ref))
 106         return clk_none;
 107     case INDIRECT_REF:
 108     case ARRAY_REF:
 109     case PARM_DECL:
 110     case RESULT_DECL:
 111       if (TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE)
 112         return clk_ordinary;
 113       break;
 114
 115       /* A currently unresolved scope ref.  */
 116     case SCOPE_REF:
 117       my_friendly_abort (103);
 118     case OFFSET_REF:
 119       if (TREE_CODE (TREE_OPERAND (ref, 1)) == FUNCTION_DECL)
 120         return clk_ordinary;
 121       /* Fall through.  */
 122     case MAX_EXPR:
 123     case MIN_EXPR:
 124       op1_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 0),
 125                                     treat_class_rvalues_as_lvalues);
 126       op2_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 1),
 127                                     treat_class_rvalues_as_lvalues);
 128       break;
 129
 130     case COND_EXPR:
 131       op1_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 1),
 132                                     treat_class_rvalues_as_lvalues);
 133       op2_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 2),
 134                                     treat_class_rvalues_as_lvalues);
 135       break;
 136
 137     case MODIFY_EXPR:
 138       return clk_ordinary;
 139
 140     case COMPOUND_EXPR:
 141       return lvalue_p_1 (TREE_OPERAND (ref, 1),
 142                          treat_class_rvalues_as_lvalues);
 143
 144     case TARGET_EXPR:
 145       return treat_class_rvalues_as_lvalues ? clk_class : clk_none;
 146
 147     case CALL_EXPR:
 148     case VA_ARG_EXPR:
 149       return ((treat_class_rvalues_as_lvalues
 150                && IS_AGGR_TYPE (TREE_TYPE (ref)))
 151               ? clk_class : clk_none);
 152
 153     case FUNCTION_DECL:
 154       /* All functions (except non-static-member functions) are
 155          lvalues.  */
 156       return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref)
 157               ? clk_none : clk_ordinary);
 158
 159     default:
 160       break;
 161     }
 162
 163   /* If one operand is not an lvalue at all, then this expression is
 164      not an lvalue.  */
 165   if (!op1_lvalue_kind || !op2_lvalue_kind)
 166     return clk_none;
 167
 168   /* Otherwise, it's an lvalue, and it has all the odd properties
 169      contributed by either operand.  */
 170   op1_lvalue_kind = op1_lvalue_kind | op2_lvalue_kind;
 171   /* It's not an ordinary lvalue if it involves either a bit-field or
 172      a class rvalue.  */
 173   if ((op1_lvalue_kind & ~clk_ordinary) != clk_none)
 174     op1_lvalue_kind &= ~clk_ordinary;
 175   return op1_lvalue_kind;
 176 }
 177
 178 /* If REF is an lvalue, returns the kind of lvalue that REF is.
 179    Otherwise, returns clk_none.  Lvalues can be assigned, unless they
 180    have TREE_READONLY, or unless they are FUNCTION_DECLs.  Lvalues can
 181    have their address taken, unless they have DECL_REGISTER.  */
 182
 183 cp_lvalue_kind
 184 real_lvalue_p (ref)
 185      tree ref;
 186 {
 187   return lvalue_p_1 (ref, /*treat_class_rvalues_as_lvalues=*/0);
 188 }
 189
 190 /* This differs from real_lvalue_p in that class rvalues are
 191    considered lvalues.  */
 192
 193 int
 194 lvalue_p (ref)
 195      tree ref;
 196 {
 197   return
 198     (lvalue_p_1 (ref, /*treat_class_rvalues_as_lvalues=*/1) != clk_none);
 199 }
 200
 201 /* Return nonzero if REF is an lvalue valid for this language;
 202    otherwise, print an error message and return zero.  */
 203
 204 int
 205 lvalue_or_else (ref, string)
 206      tree ref;
 207      const char *string;
 208 {
 209   int win = lvalue_p (ref);
 210   if (! win)
 211     error ("non-lvalue in %s", string);
 212   return win;
 213 }
 214
 215 /* INIT is a CALL_EXPR which needs info about its target.
 216    TYPE is the type that this initialization should appear to have.
 217
 218    Build an encapsulation of the initialization to perform
 219    and return it so that it can be processed by language-independent
 220    and language-specific expression expanders.  */
 221
 222 tree
 223 build_cplus_new (type, init)
 224      tree type;
 225      tree init;
 226 {
 227   tree fn;
 228   tree slot;
 229   tree rval;
 230
 231   /* Make sure that we're not trying to create an instance of an
 232      abstract class.  */
 233   abstract_virtuals_error (NULL_TREE, type);
 234
 235   if (TREE_CODE (init) != CALL_EXPR && TREE_CODE (init) != AGGR_INIT_EXPR)
 236     return convert (type, init);
 237
 238   slot = build (VAR_DECL, type);
 239   DECL_ARTIFICIAL (slot) = 1;
 240   layout_decl (slot, 0);
 241
 242   /* We split the CALL_EXPR into its function and its arguments here.
 243      Then, in expand_expr, we put them back together.  The reason for
 244      this is that this expression might be a default argument
 245      expression.  In that case, we need a new temporary every time the
 246      expression is used.  That's what break_out_target_exprs does; it
 247      replaces every AGGR_INIT_EXPR with a copy that uses a fresh
 248      temporary slot.  Then, expand_expr builds up a call-expression
 249      using the new slot.  */
 250   fn = TREE_OPERAND (init, 0);
 251   rval = build (AGGR_INIT_EXPR, type, fn, TREE_OPERAND (init, 1), slot);
 252   TREE_SIDE_EFFECTS (rval) = 1;
 253   AGGR_INIT_VIA_CTOR_P (rval)
 254     = (TREE_CODE (fn) == ADDR_EXPR
 255        && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL
 256        && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn, 0)));
 257   rval = build_target_expr (slot, rval);
 258
 259   return rval;
 260 }
 261
 262 /* Encapsulate the expression INIT in a TARGET_EXPR.  */
 263
 264 tree
 265 get_target_expr (init)
 266      tree init;
 267 {
 268   tree slot;
 269   tree rval;
 270
 271   slot = build (VAR_DECL, TREE_TYPE (init));
 272   DECL_ARTIFICIAL (slot) = 1;
 273   layout_decl (slot, 0);
 274   rval = build_target_expr (slot, init);
 275
 276   return rval;
 277 }
 278
 279 /* Recursively search EXP for CALL_EXPRs that need cleanups and replace
 280    these CALL_EXPRs with tree nodes that will perform the cleanups.  */
 281
 282 tree
 283 break_out_cleanups (exp)
 284      tree exp;
 285 {
 286   tree tmp = exp;
 287
 288   if (TREE_CODE (tmp) == CALL_EXPR
 289       && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (tmp)))
 290     return build_cplus_new (TREE_TYPE (tmp), tmp);
 291
 292   while (TREE_CODE (tmp) == NOP_EXPR
 293          || TREE_CODE (tmp) == CONVERT_EXPR
 294          || TREE_CODE (tmp) == NON_LVALUE_EXPR)
 295     {
 296       if (TREE_CODE (TREE_OPERAND (tmp, 0)) == CALL_EXPR
 297           && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (TREE_OPERAND (tmp, 0))))
 298         {
 299           TREE_OPERAND (tmp, 0)
 300             = build_cplus_new (TREE_TYPE (TREE_OPERAND (tmp, 0)),
 301                                TREE_OPERAND (tmp, 0));
 302           break;
 303         }
 304       else
 305         tmp = TREE_OPERAND (tmp, 0);
 306     }
 307   return exp;
 308 }
 309
 310 /* Recursively perform a preorder search EXP for CALL_EXPRs, making
 311    copies where they are found.  Returns a deep copy all nodes transitively
 312    containing CALL_EXPRs.  */
 313
 314 tree
 315 break_out_calls (exp)
 316      tree exp;
 317 {
 318   register tree t1, t2 = NULL_TREE;
 319   register enum tree_code code;
 320   register int changed = 0;
 321   register int i;
 322
 323   if (exp == NULL_TREE)
 324     return exp;
 325
 326   code = TREE_CODE (exp);
 327
 328   if (code == CALL_EXPR)
 329     return copy_node (exp);
 330
 331   /* Don't try and defeat a save_expr, as it should only be done once.  */
 332     if (code == SAVE_EXPR)
 333        return exp;
 334
 335   switch (TREE_CODE_CLASS (code))
 336     {
 337     default:
 338       abort ();
 339
 340     case 'c':  /* a constant */
 341     case 't':  /* a type node */
 342     case 'x':  /* something random, like an identifier or an ERROR_MARK.  */
 343       return exp;
 344
 345     case 'd':  /* A decl node */
 346 #if 0                               /* This is bogus.  jason 9/21/94 */
 347
 348       t1 = break_out_calls (DECL_INITIAL (exp));
 349       if (t1 != DECL_INITIAL (exp))
 350         {
 351           exp = copy_node (exp);
 352           DECL_INITIAL (exp) = t1;
 353         }
 354 #endif
 355       return exp;
 356
 357     case 'b':  /* A block node */
 358       {
 359         /* Don't know how to handle these correctly yet.   Must do a
 360            break_out_calls on all DECL_INITIAL values for local variables,
 361            and also break_out_calls on all sub-blocks and sub-statements.  */
 362         abort ();
 363       }
 364       return exp;
 365
 366     case 'e':  /* an expression */
 367     case 'r':  /* a reference */
 368     case 's':  /* an expression with side effects */
 369       for (i = tree_code_length[(int) code] - 1; i >= 0; i--)
 370         {
 371           t1 = break_out_calls (TREE_OPERAND (exp, i));
 372           if (t1 != TREE_OPERAND (exp, i))
 373             {
 374               exp = copy_node (exp);
 375               TREE_OPERAND (exp, i) = t1;
 376             }
 377         }
 378       return exp;
 379
 380     case '<':  /* a comparison expression */
 381     case '2':  /* a binary arithmetic expression */
 382       t2 = break_out_calls (TREE_OPERAND (exp, 1));
 383       if (t2 != TREE_OPERAND (exp, 1))
 384         changed = 1;
 385     case '1':  /* a unary arithmetic expression */
 386       t1 = break_out_calls (TREE_OPERAND (exp, 0));
 387       if (t1 != TREE_OPERAND (exp, 0))
 388         changed = 1;
 389       if (changed)
 390         {
 391           if (tree_code_length[(int) code] == 1)
 392             return build1 (code, TREE_TYPE (exp), t1);
 393           else
 394             return build (code, TREE_TYPE (exp), t1, t2);
 395         }
 396       return exp;
 397     }
 398
 399 }
 400 \f
 401 extern struct obstack *current_obstack;
 402 extern struct obstack permanent_obstack;
 403 extern struct obstack *saveable_obstack;
 404 extern struct obstack *expression_obstack;
 405
 406 /* Here is how primitive or already-canonicalized types' hash
 407    codes are made.  MUST BE CONSISTENT WITH tree.c !!! */
 408 #define TYPE_HASH(TYPE) ((HOST_WIDE_INT) (TYPE) & 0777777)
 409
 410 /* Construct, lay out and return the type of methods belonging to class
 411    BASETYPE and whose arguments are described by ARGTYPES and whose values
 412    are described by RETTYPE.  If each type exists already, reuse it.  */
 413
 414 tree
 415 build_cplus_method_type (basetype, rettype, argtypes)
 416      tree basetype, rettype, argtypes;
 417 {
 418   register tree t;
 419   tree ptype;
 420   int hashcode;
 421
 422   /* Make a node of the sort we want.  */
 423   t = make_node (METHOD_TYPE);
 424
 425   TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
 426   TREE_TYPE (t) = rettype;
 427   ptype = build_pointer_type (basetype);
 428
 429   /* The actual arglist for this function includes a "hidden" argument
 430      which is "this".  Put it into the list of argument types.  Make
 431      sure that the new argument list is allocated on the same obstack
 432      as the type.  */
 433   push_obstacks (TYPE_OBSTACK (t), TYPE_OBSTACK (t));
 434   argtypes = tree_cons (NULL_TREE, ptype, argtypes);
 435   TYPE_ARG_TYPES (t) = argtypes;
 436   TREE_SIDE_EFFECTS (argtypes) = 1;  /* Mark first argtype as "artificial".  */
 437   pop_obstacks ();
 438
 439   /* If we already have such a type, use the old one and free this one.
 440      Note that it also frees up the above cons cell if found.  */
 441   hashcode = TYPE_HASH (basetype) + TYPE_HASH (rettype) +
 442     type_hash_list (argtypes);
 443
 444   t = type_hash_canon (hashcode, t);
 445
 446   if (TYPE_SIZE (t) == 0)
 447     layout_type (t);
 448
 449   return t;
 450 }
 451
 452 static tree
 453 build_cplus_array_type_1 (elt_type, index_type)
 454      tree elt_type;
 455      tree index_type;
 456 {
 457   tree t;
 458
 459   if (elt_type == error_mark_node || index_type == error_mark_node)
 460     return error_mark_node;
 461
 462   if (processing_template_decl
 463       || uses_template_parms (elt_type)
 464       || uses_template_parms (index_type))
 465     {
 466       t = make_node (ARRAY_TYPE);
 467       TREE_TYPE (t) = elt_type;
 468       TYPE_DOMAIN (t) = index_type;
 469     }
 470   else
 471     t = build_array_type (elt_type, index_type);
 472
 473   /* Push these needs up so that initialization takes place
 474      more easily.  */
 475   TYPE_NEEDS_CONSTRUCTING (t)
 476     = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type));
 477   TYPE_NEEDS_DESTRUCTOR (t)
 478     = TYPE_NEEDS_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type));
 479   return t;
 480 }
 481
 482 tree
 483 build_cplus_array_type (elt_type, index_type)
 484      tree elt_type;
 485      tree index_type;
 486 {
 487   tree t;
 488   int type_quals = CP_TYPE_QUALS (elt_type);
 489
 490   elt_type = TYPE_MAIN_VARIANT (elt_type);
 491
 492   t = build_cplus_array_type_1 (elt_type, index_type);
 493
 494   if (type_quals != TYPE_UNQUALIFIED)
 495     t = cp_build_qualified_type (t, type_quals);
 496
 497   return t;
 498 }
 499 \f
 500 /* Make a variant of TYPE, qualified with the TYPE_QUALS.  Handles
 501    arrays correctly.  In particular, if TYPE is an array of T's, and
 502    TYPE_QUALS is non-empty, returns an array of qualified T's.  If
 503    at attempt is made to qualify a type illegally, and COMPLAIN is
 504    non-zero, an error is issued.  If COMPLAIN is zero, error_mark_node
 505    is returned.  */
 506
 507 tree
 508 cp_build_qualified_type_real (type, type_quals, complain)
 509      tree type;
 510      int type_quals;
 511      int complain;
 512 {
 513   tree result;
 514
 515   if (type == error_mark_node)
 516     return type;
 517
 518   if (type_quals == TYPE_QUALS (type))
 519     return type;
 520
 521   /* A restrict-qualified pointer type must be a pointer (or reference)
 522      to object or incomplete type.  */
 523   if ((type_quals & TYPE_QUAL_RESTRICT)
 524       && TREE_CODE (type) != TEMPLATE_TYPE_PARM
 525       && (!POINTER_TYPE_P (type)
 526           || TYPE_PTRMEM_P (type)
 527           || TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE))
 528     {
 529       if (complain)
 530         cp_error ("`%T' cannot be `restrict'-qualified", type);
 531       else
 532         return error_mark_node;
 533
 534       type_quals &= ~TYPE_QUAL_RESTRICT;
 535     }
 536
 537   if (type_quals != TYPE_UNQUALIFIED
 538       && TREE_CODE (type) == FUNCTION_TYPE)
 539     {
 540       if (complain)
 541         cp_error ("`%T' cannot be `const'-, `volatile'-, or `restrict'-qualified", type);
 542       else
 543         return error_mark_node;
 544       type_quals = TYPE_UNQUALIFIED;
 545     }
 546   else if (TREE_CODE (type) == ARRAY_TYPE)
 547     {
 548       /* In C++, the qualification really applies to the array element
 549          type.  Obtain the appropriately qualified element type.  */
 550       tree t;
 551       tree element_type
 552         = cp_build_qualified_type_real (TREE_TYPE (type),
 553                                         type_quals,
 554                                         complain);
 555
 556       if (element_type == error_mark_node)
 557         return error_mark_node;
 558
 559       /* See if we already have an identically qualified type.  */
 560       for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
 561         if (CP_TYPE_QUALS (t) == type_quals)
 562           break;
 563
 564       /* If we didn't already have it, create it now.  */
 565       if (!t)
 566         {
 567           /* Make a new array type, just like the old one, but with the
 568              appropriately qualified element type.  */
 569           t = build_type_copy (type);
 570           TREE_TYPE (t) = element_type;
 571         }
 572
 573       /* Even if we already had this variant, we update
 574          TYPE_NEEDS_CONSTRUCTING and TYPE_NEEDS_DESTRUCTOR in case
 575          they changed since the variant was originally created.
 576
 577          This seems hokey; if there is some way to use a previous
 578          variant *without* coming through here,
 579          TYPE_NEEDS_CONSTRUCTING will never be updated.  */
 580       TYPE_NEEDS_CONSTRUCTING (t)
 581         = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type));
 582       TYPE_NEEDS_DESTRUCTOR (t)
 583         = TYPE_NEEDS_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type));
 584       return t;
 585     }
 586   else if (TYPE_PTRMEMFUNC_P (type))
 587     {
 588       /* For a pointer-to-member type, we can't just return a
 589          cv-qualified version of the RECORD_TYPE.  If we do, we
 590          haven't change the field that contains the actual pointer to
 591          a method, and so TYPE_PTRMEMFUNC_FN_TYPE will be wrong.  */
 592       tree t;
 593
 594       t = TYPE_PTRMEMFUNC_FN_TYPE (type);
 595       t = cp_build_qualified_type_real (t, type_quals, complain);
 596       return build_ptrmemfunc_type (t);
 597     }
 598
 599   /* Retrieve (or create) the appropriately qualified variant.  */
 600   result = build_qualified_type (type, type_quals);
 601
 602   /* If this was a pointer-to-method type, and we just made a copy,
 603      then we need to clear the cached associated
 604      pointer-to-member-function type; it is not valid for the new
 605      type.  */
 606   if (result != type
 607       && TREE_CODE (type) == POINTER_TYPE
 608       && TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE)
 609     TYPE_SET_PTRMEMFUNC_TYPE (result, NULL_TREE);
 610
 611   return result;
 612 }
 613
 614 /* Returns the canonical version of TYPE.  In other words, if TYPE is
 615    a typedef, returns the underlying type.  The cv-qualification of
 616    the type returned matches the type input; they will always be
 617    compatible types.  */
 618
 619 tree
 620 canonical_type_variant (t)
 621      tree t;
 622 {
 623   return cp_build_qualified_type (TYPE_MAIN_VARIANT (t), CP_TYPE_QUALS (t));
 624 }
 625 \f
 626 /* Add OFFSET to all base types of T.
 627
 628    OFFSET, which is a type offset, is number of bytes.
 629
 630    Note that we don't have to worry about having two paths to the
 631    same base type, since this type owns its association list.  */
 632
 633 static void
 634 propagate_binfo_offsets (binfo, offset)
 635      tree binfo;
 636      tree offset;
 637 {
 638   tree binfos = BINFO_BASETYPES (binfo);
 639   int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
 640
 641   for (i = 0; i < n_baselinks; /* note increment is done in the loop.  */)
 642     {
 643       tree base_binfo = TREE_VEC_ELT (binfos, i);
 644
 645       if (TREE_VIA_VIRTUAL (base_binfo))
 646         i += 1;
 647       else
 648         {
 649           int j;
 650           tree delta = NULL_TREE;
 651
 652           for (j = i+1; j < n_baselinks; j++)
 653             if (! TREE_VIA_VIRTUAL (TREE_VEC_ELT (binfos, j)))
 654               {
 655                 /* The next basetype offset must take into account the space
 656                    between the classes, not just the size of each class.  */
 657                 delta = size_binop (MINUS_EXPR,
 658                                     BINFO_OFFSET (TREE_VEC_ELT (binfos, j)),
 659                                     BINFO_OFFSET (base_binfo));
 660                 break;
 661               }
 662
 663 #if 0
 664           if (BINFO_OFFSET_ZEROP (base_binfo))
 665             BINFO_OFFSET (base_binfo) = offset;
 666           else
 667             BINFO_OFFSET (base_binfo)
 668               = size_binop (PLUS_EXPR, BINFO_OFFSET (base_binfo), offset);
 669 #else
 670           BINFO_OFFSET (base_binfo) = offset;
 671 #endif
 672
 673           propagate_binfo_offsets (base_binfo, offset);
 674
 675           /* Go to our next class that counts for offset propagation.  */
 676           i = j;
 677           if (i < n_baselinks)
 678             offset = size_binop (PLUS_EXPR, offset, delta);
 679         }
 680     }
 681 }
 682
 683 /* Makes new binfos for the indirect bases under BINFO, and updates
 684    BINFO_OFFSET for them and their bases.  */
 685
 686 void
 687 unshare_base_binfos (binfo)
 688      tree binfo;
 689 {
 690   tree binfos = BINFO_BASETYPES (binfo);
 691   tree new_binfo;
 692   int j;
 693
 694   if (binfos == NULL_TREE)
 695     return;
 696
 697   /* Now unshare the structure beneath BINFO.  */
 698   for (j = TREE_VEC_LENGTH (binfos)-1;
 699        j >= 0; j--)
 700     {
 701       tree base_binfo = TREE_VEC_ELT (binfos, j);
 702       new_binfo = TREE_VEC_ELT (binfos, j)
 703         = make_binfo (BINFO_OFFSET (base_binfo),
 704                       base_binfo,
 705                       BINFO_VTABLE (base_binfo),
 706                       BINFO_VIRTUALS (base_binfo));
 707       TREE_VIA_PUBLIC (new_binfo) = TREE_VIA_PUBLIC (base_binfo);
 708       TREE_VIA_PROTECTED (new_binfo) = TREE_VIA_PROTECTED (base_binfo);
 709       TREE_VIA_VIRTUAL (new_binfo) = TREE_VIA_VIRTUAL (base_binfo);
 710       BINFO_INHERITANCE_CHAIN (new_binfo) = binfo;
 711       unshare_base_binfos (new_binfo);
 712     }
 713 }
 714
 715 /* Finish the work of layout_record, now taking virtual bases into account.
 716    Also compute the actual offsets that our base classes will have.
 717    This must be performed after the fields are laid out, since virtual
 718    baseclasses must lay down at the end of the record.
 719
 720    Returns the maximum number of virtual functions any of the
 721    baseclasses provide.  */
 722
 723 int
 724 layout_basetypes (rec, max)
 725      tree rec;
 726      int max;
 727 {
 728   tree binfos = TYPE_BINFO_BASETYPES (rec);
 729   int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
 730
 731   tree vbase_types;
 732
 733   unsigned int record_align = MAX (BITS_PER_UNIT, TYPE_ALIGN (rec));
 734   unsigned int desired_align;
 735
 736   /* Record size so far is CONST_SIZE bits, where CONST_SIZE is an integer.  */
 737   register unsigned int const_size = 0;
 738   unsigned int nonvirtual_const_size;
 739
 740 #ifdef STRUCTURE_SIZE_BOUNDARY
 741   /* Packed structures don't need to have minimum size.  */
 742   if (! TYPE_PACKED (rec))
 743     record_align = MAX (record_align, STRUCTURE_SIZE_BOUNDARY);
 744 #endif
 745
 746   /* Get all the virtual base types that this type uses.  The
 747      TREE_VALUE slot holds the virtual baseclass type.  Note that
 748      get_vbase_types makes copies of the virtual base BINFOs, so that
 749      the vbase_types are unshared.  */
 750   vbase_types = CLASSTYPE_VBASECLASSES (rec);
 751
 752   my_friendly_assert (TREE_CODE (TYPE_SIZE (rec)) == INTEGER_CST, 19970302);
 753   const_size = TREE_INT_CST_LOW (TYPE_SIZE (rec));
 754
 755   nonvirtual_const_size = const_size;
 756
 757   while (vbase_types)
 758     {
 759       tree basetype = BINFO_TYPE (vbase_types);
 760       tree offset;
 761
 762       desired_align = TYPE_ALIGN (basetype);
 763       record_align = MAX (record_align, desired_align);
 764
 765       if (const_size == 0)
 766         offset = integer_zero_node;
 767       else
 768         {
 769           /* Give each virtual base type the alignment it wants.  */
 770           const_size = CEIL (const_size, desired_align) * desired_align;
 771           offset = size_int (CEIL (const_size, BITS_PER_UNIT));
 772         }
 773
 774       if (CLASSTYPE_VSIZE (basetype) > max)
 775         max = CLASSTYPE_VSIZE (basetype);
 776       BINFO_OFFSET (vbase_types) = offset;
 777
 778       /* Every virtual baseclass takes a least a UNIT, so that we can
 779          take it's address and get something different for each base.  */
 780       const_size += MAX (BITS_PER_UNIT,
 781                          TREE_INT_CST_LOW (CLASSTYPE_SIZE (basetype)));
 782
 783       vbase_types = TREE_CHAIN (vbase_types);
 784     }
 785
 786   if (const_size)
 787     {
 788       /* Because a virtual base might take a single byte above,
 789          we have to re-adjust the total size to make sure it is
 790          a multiple of the alignment.  */
 791       /* Give the whole object the alignment it wants.  */
 792       const_size = CEIL (const_size, record_align) * record_align;
 793     }
 794
 795   /* Set the alignment in the complete type.  We don't set CLASSTYPE_ALIGN
 796    here, as that is for this class, without any virtual base classes.  */
 797   TYPE_ALIGN (rec) = record_align;
 798   if (const_size != nonvirtual_const_size)
 799     {
 800       TYPE_SIZE (rec) = size_int (const_size);
 801       TYPE_SIZE_UNIT (rec) = size_binop (FLOOR_DIV_EXPR, TYPE_SIZE (rec),
 802                                          size_int (BITS_PER_UNIT));
 803     }
 804
 805   /* Now propagate offset information throughout the lattice.  */
 806   for (i = 0; i < n_baseclasses; i++)
 807     {
 808       register tree base_binfo = TREE_VEC_ELT (binfos, i);
 809       register tree basetype = BINFO_TYPE (base_binfo);
 810       tree field = TYPE_FIELDS (rec);
 811
 812       if (TREE_VIA_VIRTUAL (base_binfo))
 813         continue;
 814
 815       my_friendly_assert (TREE_TYPE (field) == basetype, 23897);
 816
 817       if (get_base_distance (basetype, rec, 0, (tree*)0) == -2)
 818         cp_warning ("direct base `%T' inaccessible in `%T' due to ambiguity",
 819                     basetype, rec);
 820
 821       BINFO_OFFSET (base_binfo)
 822         = size_int (CEIL (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field)),
 823                           BITS_PER_UNIT));
 824       propagate_binfo_offsets (base_binfo, BINFO_OFFSET (base_binfo));
 825       TYPE_FIELDS (rec) = TREE_CHAIN (field);
 826     }
 827
 828   for (vbase_types = CLASSTYPE_VBASECLASSES (rec); vbase_types;
 829        vbase_types = TREE_CHAIN (vbase_types))
 830     {
 831       BINFO_INHERITANCE_CHAIN (vbase_types) = TYPE_BINFO (rec);
 832       unshare_base_binfos (vbase_types);
 833       propagate_binfo_offsets (vbase_types, BINFO_OFFSET (vbase_types));
 834
 835       if (extra_warnings)
 836         {
 837           tree basetype = BINFO_TYPE (vbase_types);
 838           if (get_base_distance (basetype, rec, 0, (tree*)0) == -2)
 839             cp_warning ("virtual base `%T' inaccessible in `%T' due to ambiguity",
 840                         basetype, rec);
 841         }
 842     }
 843
 844   return max;
 845 }
 846
 847 /* If the empty base field in DECL overlaps with a base of the same type in
 848    NEWDECL, which is either another base field or the first data field of
 849    the class, pad the base just before NEWDECL and return 1.  Otherwise,
 850    return 0.  */
 851
 852 static int
 853 avoid_overlap (decl, newdecl)
 854      tree decl, newdecl;
 855 {
 856   tree field;
 857
 858   if (newdecl == NULL_TREE
 859       || ! types_overlap_p (TREE_TYPE (decl), TREE_TYPE (newdecl)))
 860     return 0;
 861
 862   for (field = decl; TREE_CHAIN (field) && TREE_CHAIN (field) != newdecl;
 863        field = TREE_CHAIN (field))
 864     ;
 865
 866   DECL_SIZE (field) = integer_one_node;
 867
 868   return 1;
 869 }
 870
 871 /* Returns a list of fields to stand in for the base class subobjects
 872    of REC.  These fields are later removed by layout_basetypes.  */
 873
 874 tree
 875 build_base_fields (rec)
 876      tree rec;
 877 {
 878   /* Chain to hold all the new FIELD_DECLs which stand in for base class
 879      subobjects.  */
 880   tree base_decls = NULL_TREE;
 881   tree binfos = TYPE_BINFO_BASETYPES (rec);
 882   int n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
 883   tree decl, nextdecl;
 884   int i, saw_empty = 0;
 885   unsigned int base_align = 0;
 886
 887   for (i = 0; i < n_baseclasses; ++i)
 888     {
 889       register tree base_binfo = TREE_VEC_ELT (binfos, i);
 890       register tree basetype = BINFO_TYPE (base_binfo);
 891
 892       if (TYPE_SIZE (basetype) == 0)
 893         /* This error is now reported in xref_tag, thus giving better
 894            location information.  */
 895         continue;
 896
 897       if (TREE_VIA_VIRTUAL (base_binfo))
 898         continue;
 899
 900       decl = build_lang_decl (FIELD_DECL, NULL_TREE, basetype);
 901       DECL_ARTIFICIAL (decl) = 1;
 902       DECL_FIELD_CONTEXT (decl) = DECL_CLASS_CONTEXT (decl) = rec;
 903       DECL_SIZE (decl) = CLASSTYPE_SIZE (basetype);
 904       DECL_ALIGN (decl) = CLASSTYPE_ALIGN (basetype);
 905       TREE_CHAIN (decl) = base_decls;
 906       base_decls = decl;
 907
 908       if (! flag_new_abi)
 909         {
 910           /* Brain damage for backwards compatibility.  For no good reason,
 911              the old layout_basetypes made every base at least as large as
 912              the alignment for the bases up to that point, gratuitously
 913              wasting space.  So we do the same thing here.  */
 914           base_align = MAX (base_align, DECL_ALIGN (decl));
 915           DECL_SIZE (decl)
 916             = size_int (MAX (TREE_INT_CST_LOW (DECL_SIZE (decl)),
 917                              (int) base_align));
 918         }
 919       else if (DECL_SIZE (decl) == integer_zero_node)
 920         saw_empty = 1;
 921     }
 922
 923   /* Reverse the list of fields so we allocate the bases in the proper
 924      order.  */
 925   base_decls = nreverse (base_decls);
 926
 927   /* In the presence of empty base classes, we run the risk of allocating
 928      two objects of the same class on top of one another.  Avoid that.  */
 929   if (flag_new_abi && saw_empty)
 930     for (decl = base_decls; decl; decl = TREE_CHAIN (decl))
 931       {
 932         if (DECL_SIZE (decl) == integer_zero_node)
 933           {
 934             /* First step through the following bases until we find
 935                an overlap or a non-empty base.  */
 936             for (nextdecl = TREE_CHAIN (decl); nextdecl;
 937                  nextdecl = TREE_CHAIN (nextdecl))
 938               {
 939                 if (avoid_overlap (decl, nextdecl)
 940                     || DECL_SIZE (nextdecl) != integer_zero_node)
 941                   goto nextbase;
 942               }
 943
 944             /* If we're still looking, also check against the first
 945                field.  */
 946             for (nextdecl = TYPE_FIELDS (rec);
 947                  nextdecl && TREE_CODE (nextdecl) != FIELD_DECL;
 948                  nextdecl = TREE_CHAIN (nextdecl))
 949               /* keep looking */;
 950             avoid_overlap (decl, nextdecl);
 951           }
 952       nextbase:;
 953       }
 954
 955   return base_decls;
 956 }
 957
 958 /* Returns list of virtual base class pointers in a FIELD_DECL chain.  */
 959
 960 tree
 961 build_vbase_pointer_fields (rec)
 962      tree rec;
 963 {
 964   /* Chain to hold all the new FIELD_DECLs which point at virtual
 965      base classes.  */
 966   tree vbase_decls = NULL_TREE;
 967   tree binfos = TYPE_BINFO_BASETYPES (rec);
 968   int n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
 969   tree decl;
 970   int i;
 971
 972   /* Handle basetypes almost like fields, but record their
 973      offsets differently.  */
 974
 975   for (i = 0; i < n_baseclasses; i++)
 976     {
 977       register tree base_binfo = TREE_VEC_ELT (binfos, i);
 978       register tree basetype = BINFO_TYPE (base_binfo);
 979
 980       if (TYPE_SIZE (basetype) == 0)
 981         /* This error is now reported in xref_tag, thus giving better
 982            location information.  */
 983         continue;
 984
 985       /* All basetypes are recorded in the association list of the
 986          derived type.  */
 987
 988       if (TREE_VIA_VIRTUAL (base_binfo))
 989         {
 990           int j;
 991           const char *name;
 992
 993           /* The offset for a virtual base class is only used in computing
 994              virtual function tables and for initializing virtual base
 995              pointers.  It is built once `get_vbase_types' is called.  */
 996
 997           /* If this basetype can come from another vbase pointer
 998              without an additional indirection, we will share
 999              that pointer.  If an indirection is involved, we
1000              make our own pointer.  */
1001           for (j = 0; j < n_baseclasses; j++)
1002             {
1003               tree other_base_binfo = TREE_VEC_ELT (binfos, j);
1004               if (! TREE_VIA_VIRTUAL (other_base_binfo)
1005                   && binfo_member (basetype,
1006                                    CLASSTYPE_VBASECLASSES (BINFO_TYPE
1007                                                            (other_base_binfo))
1008                                    ))
1009                 goto got_it;
1010             }
1011           FORMAT_VBASE_NAME (name, basetype);
1012           decl = build_lang_decl (FIELD_DECL, get_identifier (name),
1013                                   build_pointer_type (basetype));
1014           /* If you change any of the below, take a look at all the
1015              other VFIELD_BASEs and VTABLE_BASEs in the code, and change
1016              them too.  */
1017           DECL_ASSEMBLER_NAME (decl) = get_identifier (VTABLE_BASE);
1018           DECL_VIRTUAL_P (decl) = 1;
1019           DECL_ARTIFICIAL (decl) = 1;
1020           DECL_FIELD_CONTEXT (decl) = rec;
1021           DECL_CLASS_CONTEXT (decl) = rec;
1022           DECL_FCONTEXT (decl) = basetype;
1023           DECL_SAVED_INSNS (decl) = 0;
1024           DECL_FIELD_SIZE (decl) = 0;
1025           DECL_ALIGN (decl) = TYPE_ALIGN (ptr_type_node);
1026           TREE_CHAIN (decl) = vbase_decls;
1027           BINFO_VPTR_FIELD (base_binfo) = decl;
1028           vbase_decls = decl;
1029
1030         got_it:
1031           /* The space this decl occupies has already been accounted for.  */
1032           ;
1033         }
1034     }
1035
1036   return vbase_decls;
1037 }
1038 \f
1039 /* Hashing of lists so that we don't make duplicates.
1040    The entry point is `list_hash_canon'.  */
1041
1042 /* Each hash table slot is a bucket containing a chain
1043    of these structures.  */
1044
1045 struct list_hash
1046 {
1047   struct list_hash *next;       /* Next structure in the bucket.  */
1048   int hashcode;                 /* Hash code of this list.  */
1049   tree list;                    /* The list recorded here.  */
1050 };
1051
1052 /* Now here is the hash table.  When recording a list, it is added
1053    to the slot whose index is the hash code mod the table size.
1054    Note that the hash table is used for several kinds of lists.
1055    While all these live in the same table, they are completely independent,
1056    and the hash code is computed differently for each of these.  */
1057
1058 #define TYPE_HASH_SIZE 59
1059 static struct list_hash *list_hash_table[TYPE_HASH_SIZE];
1060
1061 /* Compute a hash code for a list (chain of TREE_LIST nodes
1062    with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
1063    TREE_COMMON slots), by adding the hash codes of the individual entries.  */
1064
1065 static int
1066 list_hash (purpose, value, chain)
1067      tree purpose, value, chain;
1068 {
1069   register int hashcode = 0;
1070
1071   if (chain)
1072     hashcode += TYPE_HASH (chain);
1073
1074   if (value)
1075     hashcode += TYPE_HASH (value);
1076   else
1077     hashcode += 1007;
1078   if (purpose)
1079     hashcode += TYPE_HASH (purpose);
1080   else
1081     hashcode += 1009;
1082   return hashcode;
1083 }
1084
1085 /* Look in the type hash table for a type isomorphic to TYPE.
1086    If one is found, return it.  Otherwise return 0.  */
1087
1088 static tree
1089 list_hash_lookup (hashcode, purpose, value, chain)
1090      int hashcode;
1091      tree purpose, value, chain;
1092 {
1093   register struct list_hash *h;
1094
1095   for (h = list_hash_table[hashcode % TYPE_HASH_SIZE]; h; h = h->next)
1096     if (h->hashcode == hashcode
1097         && TREE_PURPOSE (h->list) == purpose
1098         && TREE_VALUE (h->list) == value
1099         && TREE_CHAIN (h->list) == chain)
1100       return h->list;
1101   return 0;
1102 }
1103
1104 /* Add an entry to the list-hash-table
1105    for a list TYPE whose hash code is HASHCODE.  */
1106
1107 static void
1108 list_hash_add (hashcode, list)
1109      int hashcode;
1110      tree list;
1111 {
1112   register struct list_hash *h;
1113
1114   h = (struct list_hash *) obstack_alloc (&permanent_obstack, sizeof (struct list_hash));
1115   h->hashcode = hashcode;
1116   h->list = list;
1117   h->next = list_hash_table[hashcode % TYPE_HASH_SIZE];
1118   list_hash_table[hashcode % TYPE_HASH_SIZE] = h;
1119 }
1120
1121 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
1122    object for an identical list if one already exists.  Otherwise, build a
1123    new one, and record it as the canonical object.  */
1124
1125 /* Set to 1 to debug without canonicalization.  Never set by program.  */
1126
1127 static int debug_no_list_hash = 0;
1128
1129 tree
1130 hash_tree_cons (purpose, value, chain)
1131      tree purpose, value, chain;
1132 {
1133   tree t;
1134   int hashcode = 0;
1135
1136   if (! debug_no_list_hash)
1137     {
1138       hashcode = list_hash (purpose, value, chain);
1139       t = list_hash_lookup (hashcode, purpose, value, chain);
1140       if (t)
1141         return t;
1142     }
1143
1144   t = tree_cons (purpose, value, chain);
1145
1146   /* If this is a new list, record it for later reuse.  */
1147   if (! debug_no_list_hash)
1148     list_hash_add (hashcode, t);
1149
1150   return t;
1151 }
1152
1153 /* Constructor for hashed lists.  */
1154
1155 tree
1156 hash_tree_chain (value, chain)
1157      tree value, chain;
1158 {
1159   return hash_tree_cons (NULL_TREE, value, chain);
1160 }
1161
1162 /* Similar, but used for concatenating two lists.  */
1163
1164 tree
1165 hash_chainon (list1, list2)
1166      tree list1, list2;
1167 {
1168   if (list2 == 0)
1169     return list1;
1170   if (list1 == 0)
1171     return list2;
1172   if (TREE_CHAIN (list1) == NULL_TREE)
1173     return hash_tree_chain (TREE_VALUE (list1), list2);
1174   return hash_tree_chain (TREE_VALUE (list1),
1175                           hash_chainon (TREE_CHAIN (list1), list2));
1176 }
1177 \f
1178 /* Build an association between TYPE and some parameters:
1179
1180    OFFSET is the offset added to `this' to convert it to a pointer
1181    of type `TYPE *'
1182
1183    BINFO is the base binfo to use, if we are deriving from one.  This
1184    is necessary, as we want specialized parent binfos from base
1185    classes, so that the VTABLE_NAMEs of bases are for the most derived
1186    type, instead of the simple type.
1187
1188    VTABLE is the virtual function table with which to initialize
1189    sub-objects of type TYPE.
1190
1191    VIRTUALS are the virtual functions sitting in VTABLE.  */
1192
1193 tree
1194 make_binfo (offset, binfo, vtable, virtuals)
1195      tree offset, binfo;
1196      tree vtable, virtuals;
1197 {
1198   tree new_binfo = make_tree_vec (7);
1199   tree type;
1200
1201   if (TREE_CODE (binfo) == TREE_VEC)
1202     type = BINFO_TYPE (binfo);
1203   else
1204     {
1205       type = binfo;
1206       binfo = CLASS_TYPE_P (type) ? TYPE_BINFO (binfo) : NULL_TREE;
1207     }
1208
1209   TREE_TYPE (new_binfo) = TYPE_MAIN_VARIANT (type);
1210   BINFO_OFFSET (new_binfo) = offset;
1211   BINFO_VTABLE (new_binfo) = vtable;
1212   BINFO_VIRTUALS (new_binfo) = virtuals;
1213   BINFO_VPTR_FIELD (new_binfo) = NULL_TREE;
1214
1215   if (binfo && BINFO_BASETYPES (binfo) != NULL_TREE)
1216     BINFO_BASETYPES (new_binfo) = copy_node (BINFO_BASETYPES (binfo));
1217   return new_binfo;
1218 }
1219
1220 /* Return the binfo value for ELEM in TYPE.  */
1221
1222 tree
1223 binfo_value (elem, type)
1224      tree elem;
1225      tree type;
1226 {
1227   if (get_base_distance (elem, type, 0, (tree *)0) == -2)
1228     compiler_error ("base class `%s' ambiguous in binfo_value",
1229                     TYPE_NAME_STRING (elem));
1230   if (elem == type)
1231     return TYPE_BINFO (type);
1232   if (TREE_CODE (elem) == RECORD_TYPE && TYPE_BINFO (elem) == type)
1233     return type;
1234   return get_binfo (elem, type, 0);
1235 }
1236
1237 /* Return a reversed copy of the BINFO-chain given by PATH.  (If the
1238    BINFO_INHERITANCE_CHAIN points from base classes to derived
1239    classes, it will instead point from derived classes to base
1240    classes.)  Returns the first node in the reversed chain.  */
1241
1242 tree
1243 reverse_path (path)
1244      tree path;
1245 {
1246   register tree prev = NULL_TREE, cur;
1247   push_expression_obstack ();
1248   for (cur = path; cur; cur = BINFO_INHERITANCE_CHAIN (cur))
1249     {
1250       tree r = copy_node (cur);
1251       BINFO_INHERITANCE_CHAIN (r) = prev;
1252       prev = r;
1253     }
1254   pop_obstacks ();
1255   return prev;
1256 }
1257
1258 void
1259 debug_binfo (elem)
1260      tree elem;
1261 {
1262   unsigned HOST_WIDE_INT n;
1263   tree virtuals;
1264
1265   fprintf (stderr, "type \"%s\"; offset = %ld\n",
1266            TYPE_NAME_STRING (BINFO_TYPE (elem)),
1267            (long) TREE_INT_CST_LOW (BINFO_OFFSET (elem)));
1268   fprintf (stderr, "vtable type:\n");
1269   debug_tree (BINFO_TYPE (elem));
1270   if (BINFO_VTABLE (elem))
1271     fprintf (stderr, "vtable decl \"%s\"\n", IDENTIFIER_POINTER (DECL_NAME (BINFO_VTABLE (elem))));
1272   else
1273     fprintf (stderr, "no vtable decl yet\n");
1274   fprintf (stderr, "virtuals:\n");
1275   virtuals = BINFO_VIRTUALS (elem);
1276
1277   n = skip_rtti_stuff (&virtuals, BINFO_TYPE (elem));
1278
1279   while (virtuals)
1280     {
1281       tree fndecl = TREE_VALUE (virtuals);
1282       fprintf (stderr, "%s [%ld =? %ld]\n",
1283                IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)),
1284                (long) n, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl)));
1285       ++n;
1286       virtuals = TREE_CHAIN (virtuals);
1287     }
1288 }
1289
1290 int
1291 count_functions (t)
1292      tree t;
1293 {
1294   int i;
1295   if (TREE_CODE (t) == FUNCTION_DECL)
1296     return 1;
1297   else if (TREE_CODE (t) == OVERLOAD)
1298     {
1299       for (i=0; t; t = OVL_CHAIN (t))
1300         i++;
1301       return i;
1302     }
1303
1304   my_friendly_abort (359);
1305   return 0;
1306 }
1307
1308 int
1309 is_overloaded_fn (x)
1310      tree x;
1311 {
1312   /* A baselink is also considered an overloaded function.  */
1313   if (TREE_CODE (x) == OFFSET_REF)
1314     x = TREE_OPERAND (x, 1);
1315   if (BASELINK_P (x))
1316     x = TREE_VALUE (x);
1317   return (TREE_CODE (x) == FUNCTION_DECL
1318           || TREE_CODE (x) == TEMPLATE_ID_EXPR
1319           || DECL_FUNCTION_TEMPLATE_P (x)
1320           || TREE_CODE (x) == OVERLOAD);
1321 }
1322
1323 int
1324 really_overloaded_fn (x)
1325      tree x;
1326 {
1327   /* A baselink is also considered an overloaded function.  */
1328   if (TREE_CODE (x) == OFFSET_REF)
1329     x = TREE_OPERAND (x, 1);
1330   if (BASELINK_P (x))
1331     x = TREE_VALUE (x);
1332   return (TREE_CODE (x) == OVERLOAD
1333           && (TREE_CHAIN (x) != NULL_TREE
1334               || DECL_FUNCTION_TEMPLATE_P (OVL_FUNCTION (x))));
1335 }
1336
1337 tree
1338 get_first_fn (from)
1339      tree from;
1340 {
1341   my_friendly_assert (is_overloaded_fn (from), 9);
1342   /* A baselink is also considered an overloaded function. */
1343   if (BASELINK_P (from))
1344     from = TREE_VALUE (from);
1345   return OVL_CURRENT (from);
1346 }
1347
1348 /* Returns nonzero if T is a ->* or .* expression that refers to a
1349    member function.  */
1350
1351 int
1352 bound_pmf_p (t)
1353      tree t;
1354 {
1355   return (TREE_CODE (t) == OFFSET_REF
1356           && TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (t, 1))));
1357 }
1358
1359 /* Return a new OVL node, concatenating it with the old one. */
1360
1361 tree
1362 ovl_cons (decl, chain)
1363      tree decl;
1364      tree chain;
1365 {
1366   tree result = make_node (OVERLOAD);
1367   TREE_TYPE (result) = unknown_type_node;
1368   OVL_FUNCTION (result) = decl;
1369   TREE_CHAIN (result) = chain;
1370
1371   return result;
1372 }
1373
1374 /* Same as ovl_cons, but on the scratch_obstack. */
1375
1376 tree
1377 scratch_ovl_cons (value, chain)
1378      tree value, chain;
1379 {
1380   register tree node;
1381   register struct obstack *ambient_obstack = current_obstack;
1382   extern struct obstack *expression_obstack;
1383   current_obstack = expression_obstack;
1384   node = ovl_cons (value, chain);
1385   current_obstack = ambient_obstack;
1386   return node;
1387 }
1388
1389 /* Build a new overloaded function. If this is the first one,
1390    just return it; otherwise, ovl_cons the _DECLs */
1391
1392 tree
1393 build_overload (decl, chain)
1394      tree decl;
1395      tree chain;
1396 {
1397   if (! chain && TREE_CODE (decl) != TEMPLATE_DECL)
1398     return decl;
1399   if (chain && TREE_CODE (chain) != OVERLOAD)
1400     chain = ovl_cons (chain, NULL_TREE);
1401   return ovl_cons (decl, chain);
1402 }
1403
1404 /* True if fn is in ovl. */
1405
1406 int
1407 ovl_member (fn, ovl)
1408      tree fn;
1409      tree ovl;
1410 {
1411   if (ovl == NULL_TREE)
1412     return 0;
1413   if (TREE_CODE (ovl) != OVERLOAD)
1414     return ovl == fn;
1415   for (; ovl; ovl = OVL_CHAIN (ovl))
1416     if (OVL_FUNCTION (ovl) == fn)
1417       return 1;
1418   return 0;
1419 }
1420
1421 int
1422 is_aggr_type_2 (t1, t2)
1423      tree t1, t2;
1424 {
1425   if (TREE_CODE (t1) != TREE_CODE (t2))
1426     return 0;
1427   return IS_AGGR_TYPE (t1) && IS_AGGR_TYPE (t2);
1428 }
1429 \f
1430 #define PRINT_RING_SIZE 4
1431
1432 const char *
1433 lang_printable_name (decl, v)
1434      tree decl;
1435      int v;
1436 {
1437   static tree decl_ring[PRINT_RING_SIZE];
1438   static char *print_ring[PRINT_RING_SIZE];
1439   static int ring_counter;
1440   int i;
1441
1442   /* Only cache functions.  */
1443   if (v < 2
1444       || TREE_CODE (decl) != FUNCTION_DECL
1445       || DECL_LANG_SPECIFIC (decl) == 0)
1446     return lang_decl_name (decl, v);
1447
1448   /* See if this print name is lying around.  */
1449   for (i = 0; i < PRINT_RING_SIZE; i++)
1450     if (decl_ring[i] == decl)
1451       /* yes, so return it.  */
1452       return print_ring[i];
1453
1454   if (++ring_counter == PRINT_RING_SIZE)
1455     ring_counter = 0;
1456
1457   if (current_function_decl != NULL_TREE)
1458     {
1459       if (decl_ring[ring_counter] == current_function_decl)
1460         ring_counter += 1;
1461       if (ring_counter == PRINT_RING_SIZE)
1462         ring_counter = 0;
1463       if (decl_ring[ring_counter] == current_function_decl)
1464         my_friendly_abort (106);
1465     }
1466
1467   if (print_ring[ring_counter])
1468     free (print_ring[ring_counter]);
1469
1470   print_ring[ring_counter] = xstrdup (lang_decl_name (decl, v));
1471   decl_ring[ring_counter] = decl;
1472   return print_ring[ring_counter];
1473 }
1474 \f
1475 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
1476    listed in RAISES.  */
1477
1478 tree
1479 build_exception_variant (type, raises)
1480      tree type;
1481      tree raises;
1482 {
1483   tree v = TYPE_MAIN_VARIANT (type);
1484   int type_quals = TYPE_QUALS (type);
1485
1486   for (; v; v = TYPE_NEXT_VARIANT (v))
1487     if (TYPE_QUALS (v) == type_quals
1488         && comp_except_specs (raises, TYPE_RAISES_EXCEPTIONS (v), 1))
1489       return v;
1490
1491   /* Need to build a new variant.  */
1492   v = build_type_copy (type);
1493   TYPE_RAISES_EXCEPTIONS (v) = raises;
1494   return v;
1495 }
1496
1497 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new one together with its
1498    lang_specific field and its corresponding TEMPLATE_DECL node */
1499
1500 tree
1501 copy_template_template_parm (t)
1502      tree t;
1503 {
1504   tree template = TYPE_NAME (t);
1505   tree t2;
1506
1507   /* Make sure these end up on the permanent_obstack.  */
1508   push_permanent_obstack ();
1509
1510   t2 = make_lang_type (TEMPLATE_TEMPLATE_PARM);
1511   template = copy_node (template);
1512   copy_lang_decl (template);
1513
1514   pop_obstacks ();
1515
1516   TREE_TYPE (template) = t2;
1517   TYPE_NAME (t2) = template;
1518   TYPE_STUB_DECL (t2) = template;
1519
1520   /* No need to copy these */
1521   TYPE_FIELDS (t2) = TYPE_FIELDS (t);
1522   TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2)
1523     = TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t);
1524   return t2;
1525 }
1526
1527 /* Walk through the tree structure T, applying func.  If func ever returns
1528    non-null, return that value.  */
1529
1530 tree
1531 search_tree (tp, func)
1532      tree *tp;
1533      tree (*func) PROTO((tree *));
1534 {
1535 #define TRY(ARG) if (tmp=search_tree (&ARG, func), tmp != NULL_TREE) return tmp
1536
1537   tree t = *tp;
1538   tree tmp;
1539   enum tree_code code;
1540
1541   if (t == NULL_TREE)
1542     return NULL_TREE;
1543
1544   tmp = func (tp);
1545   if (tmp)
1546     return tmp;
1547
1548   /* Handle some common cases up front.  */
1549   code = TREE_CODE (t);
1550   if (TREE_CODE_CLASS (code) == '1')
1551     {
1552       TRY (TREE_OPERAND (t, 0));
1553       return NULL_TREE;
1554     }
1555   else if (TREE_CODE_CLASS (code) == '2' || TREE_CODE_CLASS (code) == '<')
1556     {
1557       TRY (TREE_OPERAND (t, 0));
1558       TRY (TREE_OPERAND (t, 1));
1559       return NULL_TREE;
1560     }
1561
1562   switch (code)
1563     {
1564     case ERROR_MARK:
1565       break;
1566
1567     case IDENTIFIER_NODE:
1568       break;
1569
1570     case VAR_DECL:
1571     case FUNCTION_DECL:
1572     case CONST_DECL:
1573     case TEMPLATE_DECL:
1574     case NAMESPACE_DECL:
1575       break;
1576
1577     case TYPE_DECL:
1578       TRY (TREE_TYPE (t));
1579       break;
1580
1581     case PARM_DECL:
1582       TRY (TREE_TYPE (t));
1583       TRY (TREE_CHAIN (t));
1584       break;
1585
1586     case TREE_LIST:
1587       TRY (TREE_PURPOSE (t));
1588       TRY (TREE_VALUE (t));
1589       TRY (TREE_CHAIN (t));
1590       break;
1591
1592     case OVERLOAD:
1593       TRY (OVL_FUNCTION (t));
1594       TRY (OVL_CHAIN (t));
1595       break;
1596
1597     case TREE_VEC:
1598       {
1599         int len = TREE_VEC_LENGTH (t);
1600
1601         t = copy_node (t);
1602         while (len--)
1603           TRY (TREE_VEC_ELT (t, len));
1604       }
1605       break;
1606
1607     case INTEGER_CST:
1608     case REAL_CST:
1609     case STRING_CST:
1610     case DEFAULT_ARG:
1611       break;
1612
1613     case PTRMEM_CST:
1614       TRY (TREE_TYPE (t));
1615       break;
1616
1617     case COND_EXPR:
1618     case TARGET_EXPR:
1619     case AGGR_INIT_EXPR:
1620     case NEW_EXPR:
1621       TRY (TREE_OPERAND (t, 0));
1622       TRY (TREE_OPERAND (t, 1));
1623       TRY (TREE_OPERAND (t, 2));
1624       break;
1625
1626     case TRUTH_AND_EXPR:
1627     case TRUTH_OR_EXPR:
1628     case TRUTH_XOR_EXPR:
1629     case TRUTH_ANDIF_EXPR:
1630     case TRUTH_ORIF_EXPR:
1631     case PREDECREMENT_EXPR:
1632     case PREINCREMENT_EXPR:
1633     case POSTDECREMENT_EXPR:
1634     case POSTINCREMENT_EXPR:
1635     case ARRAY_REF:
1636     case SCOPE_REF:
1637     case TRY_CATCH_EXPR:
1638     case WITH_CLEANUP_EXPR:
1639     case CALL_EXPR:
1640     case COMPOUND_EXPR:
1641     case MODIFY_EXPR:
1642     case INIT_EXPR:
1643     case OFFSET_REF:
1644       TRY (TREE_OPERAND (t, 0));
1645       TRY (TREE_OPERAND (t, 1));
1646       break;
1647
1648     case SAVE_EXPR:
1649     case ADDR_EXPR:
1650     case INDIRECT_REF:
1651     case TRUTH_NOT_EXPR:
1652     case COMPONENT_REF:
1653     case CLEANUP_POINT_EXPR:
1654     case LOOKUP_EXPR:
1655     case THROW_EXPR:
1656     case EXIT_EXPR:
1657     case LOOP_EXPR:
1658     case BIT_FIELD_REF:
1659     case VA_ARG_EXPR:
1660       TRY (TREE_OPERAND (t, 0));
1661       break;
1662
1663     case MODOP_EXPR:
1664     case ARROW_EXPR:
1665     case DOTSTAR_EXPR:
1666     case TYPEID_EXPR:
1667     case PSEUDO_DTOR_EXPR:
1668       break;
1669
1670     case COMPLEX_CST:
1671       TRY (TREE_REALPART (t));
1672       TRY (TREE_IMAGPART (t));
1673       break;
1674
1675     case CONSTRUCTOR:
1676       TRY (CONSTRUCTOR_ELTS (t));
1677       break;
1678
1679     case TEMPLATE_TEMPLATE_PARM:
1680     case TEMPLATE_PARM_INDEX:
1681     case TEMPLATE_TYPE_PARM:
1682       break;
1683
1684     case BIND_EXPR:
1685     case STMT_EXPR:
1686       break;
1687
1688     case REAL_TYPE:
1689     case COMPLEX_TYPE:
1690     case VOID_TYPE:
1691     case BOOLEAN_TYPE:
1692     case TYPENAME_TYPE:
1693     case UNION_TYPE:
1694     case ENUMERAL_TYPE:
1695     case TYPEOF_TYPE:
1696       break;
1697
1698     case POINTER_TYPE:
1699     case REFERENCE_TYPE:
1700       TRY (TREE_TYPE (t));
1701       break;
1702
1703     case FUNCTION_TYPE:
1704     case METHOD_TYPE:
1705       TRY (TREE_TYPE (t));
1706       TRY (TYPE_ARG_TYPES (t));
1707       break;
1708
1709     case ARRAY_TYPE:
1710       TRY (TREE_TYPE (t));
1711       TRY (TYPE_DOMAIN (t));
1712       break;
1713
1714     case INTEGER_TYPE:
1715       TRY (TYPE_MAX_VALUE (t));
1716       break;
1717
1718     case OFFSET_TYPE:
1719       TRY (TREE_TYPE (t));
1720       TRY (TYPE_OFFSET_BASETYPE (t));
1721       break;
1722
1723     case RECORD_TYPE:
1724       if (TYPE_PTRMEMFUNC_P (t))
1725         TRY (TYPE_PTRMEMFUNC_FN_TYPE (t));
1726       break;
1727
1728     default:
1729       my_friendly_abort (19990803);
1730     }
1731
1732   return NULL_TREE;
1733
1734 #undef TRY
1735 }
1736
1737 /* Passed to search_tree.  Checks for the use of types with no linkage.  */
1738
1739 static tree
1740 no_linkage_helper (tp)
1741      tree *tp;
1742 {
1743   tree t = *tp;
1744
1745   if (TYPE_P (t)
1746       && (IS_AGGR_TYPE (t) || TREE_CODE (t) == ENUMERAL_TYPE)
1747       && (decl_function_context (TYPE_MAIN_DECL (t))
1748           || ANON_AGGRNAME_P (TYPE_IDENTIFIER (t))))
1749     return t;
1750   return NULL_TREE;
1751 }
1752
1753 /* Check if the type T depends on a type with no linkage and if so, return
1754    it.  */
1755
1756 tree
1757 no_linkage_check (t)
1758      tree t;
1759 {
1760   /* There's no point in checking linkage on template functions; we
1761      can't know their complete types.  */
1762   if (processing_template_decl)
1763     return NULL_TREE;
1764
1765   t = search_tree (&t, no_linkage_helper);
1766   if (t != error_mark_node)
1767     return t;
1768   return NULL_TREE;
1769 }
1770
1771
1772 /* Make copies of all the nodes below T.  If FUNC is non-NULL, call it
1773    for each node.  */
1774
1775 tree
1776 mapcar (t, func)
1777      tree t;
1778      tree (*func) PROTO((tree));
1779 {
1780   tree tmp;
1781   enum tree_code code;
1782
1783   if (t == NULL_TREE)
1784     return t;
1785
1786   if (func)
1787     {
1788       tmp = func (t);
1789       if (tmp)
1790         return tmp;
1791     }
1792
1793   /* Handle some common cases up front.  */
1794   code = TREE_CODE (t);
1795   if (TREE_CODE_CLASS (code) == '1')
1796     {
1797       t = copy_node (t);
1798       TREE_TYPE (t) = mapcar (TREE_TYPE (t), func);
1799       TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1800       return t;
1801     }
1802   else if (TREE_CODE_CLASS (code) == '2' || TREE_CODE_CLASS (code) == '<')
1803     {
1804       t = copy_node (t);
1805       TREE_TYPE (t) = mapcar (TREE_TYPE (t), func);
1806       TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1807       TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
1808       return t;
1809     }
1810
1811   switch (TREE_CODE (t))
1812     {
1813     case ERROR_MARK:
1814       return error_mark_node;
1815
1816     case VAR_DECL:
1817     case FUNCTION_DECL:
1818     case CONST_DECL:
1819       /* Rather than aborting, return error_mark_node.  This allows us
1820          to report a sensible error message on code like this:
1821
1822          void g() { int i; f<i>(7); }
1823
1824          In a case like:
1825
1826            void g() { const int i = 7; f<i>(7); }
1827
1828          however, we must actually return the constant initializer.  */
1829       if (TREE_READONLY_DECL_P (t))
1830         {
1831           tmp = decl_constant_value (t);
1832           if (tmp != t)
1833             return mapcar (tmp, func);
1834         }
1835       return error_mark_node;
1836
1837     case PARM_DECL:
1838       {
1839         tree chain = TREE_CHAIN (t);
1840         t = copy_node (t);
1841         TREE_CHAIN (t) = mapcar (chain, func);
1842         TREE_TYPE (t) = mapcar (TREE_TYPE (t), func);
1843         DECL_INITIAL (t) = mapcar (DECL_INITIAL (t), func);
1844         DECL_SIZE (t) = mapcar (DECL_SIZE (t), func);
1845         return t;
1846       }
1847
1848     case TREE_LIST:
1849       {
1850         tree chain = TREE_CHAIN (t);
1851         t = copy_node (t);
1852         TREE_PURPOSE (t) = mapcar (TREE_PURPOSE (t), func);
1853         TREE_VALUE (t) = mapcar (TREE_VALUE (t), func);
1854         TREE_CHAIN (t) = mapcar (chain, func);
1855         return t;
1856       }
1857
1858     case OVERLOAD:
1859       {
1860         tree chain = OVL_CHAIN (t);
1861         t = copy_node (t);
1862         OVL_FUNCTION (t) = mapcar (OVL_FUNCTION (t), func);
1863         OVL_CHAIN (t) = mapcar (chain, func);
1864         return t;
1865       }
1866
1867     case TREE_VEC:
1868       {
1869         int len = TREE_VEC_LENGTH (t);
1870
1871         t = copy_node (t);
1872         while (len--)
1873           TREE_VEC_ELT (t, len) = mapcar (TREE_VEC_ELT (t, len), func);
1874         return t;
1875       }
1876
1877     case INTEGER_CST:
1878     case REAL_CST:
1879     case STRING_CST:
1880       return copy_node (t);
1881
1882     case PTRMEM_CST:
1883       t = copy_node (t);
1884       TREE_TYPE (t) = mapcar (TREE_TYPE (t), func);
1885       PTRMEM_CST_MEMBER (t) = mapcar (PTRMEM_CST_MEMBER (t), func);
1886       return t;
1887
1888     case COND_EXPR:
1889     case TARGET_EXPR:
1890     case AGGR_INIT_EXPR:
1891       t = copy_node (t);
1892       TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1893       TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
1894       TREE_OPERAND (t, 2) = mapcar (TREE_OPERAND (t, 2), func);
1895       return t;
1896
1897     case TRUTH_AND_EXPR:
1898     case TRUTH_OR_EXPR:
1899     case TRUTH_XOR_EXPR:
1900     case TRUTH_ANDIF_EXPR:
1901     case TRUTH_ORIF_EXPR:
1902     case PREDECREMENT_EXPR:
1903     case PREINCREMENT_EXPR:
1904     case POSTDECREMENT_EXPR:
1905     case POSTINCREMENT_EXPR:
1906     case ARRAY_REF:
1907     case SCOPE_REF:
1908     case TRY_CATCH_EXPR:
1909     case WITH_CLEANUP_EXPR:
1910     case COMPOUND_EXPR:
1911     case MODIFY_EXPR:
1912     case INIT_EXPR:
1913     case OFFSET_REF:
1914       t = copy_node (t);
1915       TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1916       TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
1917       return t;
1918
1919     case CALL_EXPR:
1920       t = copy_node (t);
1921       TREE_TYPE (t) = mapcar (TREE_TYPE (t), func);
1922       TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1923       TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
1924       TREE_OPERAND (t, 2) = NULL_TREE;
1925       return t;
1926
1927     case SAVE_EXPR:
1928     case ADDR_EXPR:
1929     case INDIRECT_REF:
1930     case TRUTH_NOT_EXPR:
1931     case COMPONENT_REF:
1932     case CLEANUP_POINT_EXPR:
1933     case THROW_EXPR:
1934     case STMT_EXPR:
1935     case VA_ARG_EXPR:
1936       t = copy_node (t);
1937       TREE_TYPE (t) = mapcar (TREE_TYPE (t), func);
1938       TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1939       return t;
1940
1941     case POINTER_TYPE:
1942       tmp = build_pointer_type (mapcar (TREE_TYPE (t), func));
1943       return cp_build_qualified_type (tmp, TYPE_QUALS (t));
1944     case REFERENCE_TYPE:
1945       tmp = build_reference_type (mapcar (TREE_TYPE (t), func));
1946       return cp_build_qualified_type (tmp, TYPE_QUALS (t));
1947     case FUNCTION_TYPE:
1948       tmp = build_function_type (mapcar (TREE_TYPE (t), func),
1949                                  mapcar (TYPE_ARG_TYPES (t), func));
1950       return cp_build_qualified_type (tmp, TYPE_QUALS (t));
1951     case ARRAY_TYPE:
1952       tmp = build_cplus_array_type (mapcar (TREE_TYPE (t), func),
1953                                     mapcar (TYPE_DOMAIN (t), func));
1954       return cp_build_qualified_type (tmp, CP_TYPE_QUALS (t));
1955     case INTEGER_TYPE:
1956       tmp = build_index_type (mapcar (TYPE_MAX_VALUE (t), func));
1957       return cp_build_qualified_type (tmp, TYPE_QUALS (t));
1958     case OFFSET_TYPE:
1959       tmp = build_offset_type (mapcar (TYPE_OFFSET_BASETYPE (t), func),
1960                                mapcar (TREE_TYPE (t), func));
1961       return cp_build_qualified_type (tmp, TYPE_QUALS (t));
1962     case METHOD_TYPE:
1963       tmp = build_cplus_method_type
1964         (mapcar (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))), func),
1965          mapcar (TREE_TYPE (t), func),
1966          mapcar (TREE_CHAIN (TYPE_ARG_TYPES (t)), func));
1967       return cp_build_qualified_type (tmp, TYPE_QUALS (t));
1968
1969     case COMPLEX_CST:
1970       t = copy_node (t);
1971       TREE_REALPART (t) = mapcar (TREE_REALPART (t), func);
1972       TREE_IMAGPART (t) = mapcar (TREE_REALPART (t), func);
1973       return t;
1974
1975     case CONSTRUCTOR:
1976       t = copy_node (t);
1977       CONSTRUCTOR_ELTS (t) = mapcar (CONSTRUCTOR_ELTS (t), func);
1978       return t;
1979
1980     case TEMPLATE_TEMPLATE_PARM:
1981       return copy_template_template_parm (t);
1982
1983     case BIND_EXPR:
1984       t = copy_node (t);
1985       TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1986       TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
1987       TREE_OPERAND (t, 2) = NULL_TREE;
1988       return t;
1989
1990     case NEW_EXPR:
1991       t = copy_node (t);
1992       TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1993       TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
1994       TREE_OPERAND (t, 2) = mapcar (TREE_OPERAND (t, 2), func);
1995       return t;
1996
1997     case BIT_FIELD_REF:
1998       t = copy_node (t);
1999       TREE_TYPE (t) = mapcar (TREE_TYPE (t), func);
2000       TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
2001       TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
2002       TREE_OPERAND (t, 2) = mapcar (TREE_OPERAND (t, 2), func);
2003       return t;
2004
2005     case LOOKUP_EXPR:
2006     case EXIT_EXPR:
2007     case LOOP_EXPR:
2008       t = copy_node (t);
2009       TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
2010       return t;
2011
2012     case RTL_EXPR:
2013       t = copy_node (t);
2014       TREE_TYPE (t) = mapcar (TREE_TYPE (t), func);
2015       return t;
2016
2017     case RECORD_TYPE:
2018       if (TYPE_PTRMEMFUNC_P (t))
2019         return build_ptrmemfunc_type
2020           (mapcar (TYPE_PTRMEMFUNC_FN_TYPE (t), func));
2021       /* else fall through */
2022
2023     default:
2024       my_friendly_abort (19990815);
2025     }
2026   my_friendly_abort (107);
2027   /* NOTREACHED */
2028   return NULL_TREE;
2029 }
2030
2031 #ifdef GATHER_STATISTICS
2032 extern int depth_reached;
2033 #endif
2034
2035 void
2036 print_lang_statistics ()
2037 {
2038   print_search_statistics ();
2039   print_class_statistics ();
2040 #ifdef GATHER_STATISTICS
2041   fprintf (stderr, "maximum template instantiation depth reached: %d\n",
2042            depth_reached);
2043 #endif
2044 }
2045
2046 /* This is used by the `assert' macro.  It is provided in libgcc.a,
2047    which `cc' doesn't know how to link.  Note that the C++ front-end
2048    no longer actually uses the `assert' macro (instead, it calls
2049    my_friendly_assert).  But all of the back-end files still need this.  */
2050
2051 void
2052 __eprintf (string, expression, line, filename)
2053      const char *string;
2054      const char *expression;
2055      unsigned line;
2056      const char *filename;
2057 {
2058   fprintf (stderr, string, expression, line, filename);
2059   fflush (stderr);
2060   abort ();
2061 }
2062
2063 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2064    (which is an ARRAY_TYPE).  This counts only elements of the top
2065    array.  */
2066
2067 tree
2068 array_type_nelts_top (type)
2069      tree type;
2070 {
2071   return fold (build (PLUS_EXPR, sizetype,
2072                       array_type_nelts (type),
2073                       integer_one_node));
2074 }
2075
2076 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2077    (which is an ARRAY_TYPE).  This one is a recursive count of all
2078    ARRAY_TYPEs that are clumped together.  */
2079
2080 tree
2081 array_type_nelts_total (type)
2082      tree type;
2083 {
2084   tree sz = array_type_nelts_top (type);
2085   type = TREE_TYPE (type);
2086   while (TREE_CODE (type) == ARRAY_TYPE)
2087     {
2088       tree n = array_type_nelts_top (type);
2089       sz = fold (build (MULT_EXPR, sizetype, sz, n));
2090       type = TREE_TYPE (type);
2091     }
2092   return sz;
2093 }
2094
2095 /* When we parse a default argument expression, we may create
2096    temporary variables via TARGET_EXPRs.  When we actually use the
2097    default-argument expression, we make a copy of the expression, but
2098    we must relpace the temporaries with appropriate local versions.  */
2099
2100 /* A map from VAR_DECLs declared in TARGET_EXPRs in a default argument
2101    to corresponding "instantiations" of those variables.  */
2102 static splay_tree target_remap;
2103 static int target_remap_count;
2104
2105 /* Called from break_out_target_exprs via mapcar.  */
2106
2107 static tree
2108 bot_manip (t)
2109      tree t;
2110 {
2111   if (TREE_CODE (t) != TREE_LIST && ! TREE_SIDE_EFFECTS (t))
2112     return t;
2113   else if (TREE_CODE (t) == TARGET_EXPR)
2114     {
2115       tree u;
2116
2117       if (TREE_CODE (TREE_OPERAND (t, 1)) == AGGR_INIT_EXPR)
2118         {
2119           mark_used (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t, 1), 0), 0));
2120           u = build_cplus_new
2121             (TREE_TYPE (t), break_out_target_exprs (TREE_OPERAND (t, 1)));
2122         }
2123       else
2124         {
2125           u = copy_node (t);
2126           TREE_OPERAND (u, 0) = build (VAR_DECL, TREE_TYPE (t));
2127           layout_decl (TREE_OPERAND (u, 0), 0);
2128         }
2129
2130       /* Map the old variable to the new one.  */
2131       splay_tree_insert (target_remap,
2132                          (splay_tree_key) TREE_OPERAND (t, 0),
2133                          (splay_tree_value) TREE_OPERAND (u, 0));
2134       return u;
2135     }
2136   else if (TREE_CODE (t) == CALL_EXPR)
2137     mark_used (TREE_OPERAND (TREE_OPERAND (t, 0), 0));
2138
2139   return NULL_TREE;
2140 }
2141
2142 /* Replace all remapped VAR_DECLs in T with their new equivalents.  */
2143
2144 static tree
2145 bot_replace (t)
2146      tree *t;
2147 {
2148   if (TREE_CODE (*t) == VAR_DECL)
2149     {
2150       splay_tree_node n = splay_tree_lookup (target_remap,
2151                                              (splay_tree_key) *t);
2152       if (n)
2153         *t = (tree) n->value;
2154     }
2155
2156   return NULL_TREE;
2157 }
2158
2159 /* Actually, we'll just clean out the target exprs for the moment.  */
2160
2161 tree
2162 break_out_target_exprs (t)
2163      tree t;
2164 {
2165   if (!target_remap_count++)
2166     target_remap = splay_tree_new (splay_tree_compare_pointers,
2167                                    /*splay_tree_delete_key_fn=*/NULL,
2168                                    /*splay_tree_delete_value_fn=*/NULL);
2169   t = mapcar (t, bot_manip);
2170   search_tree (&t, bot_replace);
2171
2172   if (!--target_remap_count)
2173     {
2174       splay_tree_delete (target_remap);
2175       target_remap = NULL;
2176     }
2177
2178   return t;
2179 }
2180
2181 /* Obstack used for allocating nodes in template function and variable
2182    definitions.  */
2183
2184 /* Similar to `build_nt', except we build
2185    on the permanent_obstack, regardless.  */
2186
2187 tree
2188 build_min_nt VPROTO((enum tree_code code, ...))
2189 {
2190 #ifndef ANSI_PROTOTYPES
2191   enum tree_code code;
2192 #endif
2193   register struct obstack *ambient_obstack = expression_obstack;
2194   va_list p;
2195   register tree t;
2196   register int length;
2197   register int i;
2198
2199   VA_START (p, code);
2200
2201 #ifndef ANSI_PROTOTYPES
2202   code = va_arg (p, enum tree_code);
2203 #endif
2204
2205   expression_obstack = &permanent_obstack;
2206
2207   t = make_node (code);
2208   length = tree_code_length[(int) code];
2209   TREE_COMPLEXITY (t) = lineno;
2210
2211   for (i = 0; i < length; i++)
2212     {
2213       tree x = va_arg (p, tree);
2214       TREE_OPERAND (t, i) = x;
2215     }
2216
2217   va_end (p);
2218   expression_obstack = ambient_obstack;
2219   return t;
2220 }
2221
2222 /* Similar to `build', except we build
2223    on the permanent_obstack, regardless.  */
2224
2225 tree
2226 build_min VPROTO((enum tree_code code, tree tt, ...))
2227 {
2228 #ifndef ANSI_PROTOTYPES
2229   enum tree_code code;
2230   tree tt;
2231 #endif
2232   register struct obstack *ambient_obstack = expression_obstack;
2233   va_list p;
2234   register tree t;
2235   register int length;
2236   register int i;
2237
2238   VA_START (p, tt);
2239
2240 #ifndef ANSI_PROTOTYPES
2241   code = va_arg (p, enum tree_code);
2242   tt = va_arg (p, tree);
2243 #endif
2244
2245   expression_obstack = &permanent_obstack;
2246
2247   t = make_node (code);
2248   length = tree_code_length[(int) code];
2249   TREE_TYPE (t) = tt;
2250   TREE_COMPLEXITY (t) = lineno;
2251
2252   for (i = 0; i < length; i++)
2253     {
2254       tree x = va_arg (p, tree);
2255       TREE_OPERAND (t, i) = x;
2256     }
2257
2258   va_end (p);
2259   expression_obstack = ambient_obstack;
2260   return t;
2261 }
2262
2263 /* Same as `tree_cons' but make a permanent object.  */
2264
2265 tree
2266 min_tree_cons (purpose, value, chain)
2267      tree purpose, value, chain;
2268 {
2269   register tree node;
2270   register struct obstack *ambient_obstack = current_obstack;
2271   current_obstack = &permanent_obstack;
2272
2273   node = tree_cons (purpose, value, chain);
2274
2275   current_obstack = ambient_obstack;
2276   return node;
2277 }
2278
2279 tree
2280 get_type_decl (t)
2281      tree t;
2282 {
2283   if (TREE_CODE (t) == TYPE_DECL)
2284     return t;
2285   if (TREE_CODE_CLASS (TREE_CODE (t)) == 't')
2286     return TYPE_STUB_DECL (t);
2287
2288   my_friendly_abort (42);
2289
2290   /* Stop compiler from complaining control reaches end of non-void function.  */
2291   return 0;
2292 }
2293
2294 int
2295 can_free (obstack, t)
2296      struct obstack *obstack;
2297      tree t;
2298 {
2299   int size = 0;
2300
2301   if (TREE_CODE (t) == TREE_VEC)
2302     size = (TREE_VEC_LENGTH (t)-1) * sizeof (tree) + sizeof (struct tree_vec);
2303   else
2304     my_friendly_abort (42);
2305
2306 #define ROUND(x) ((x + obstack_alignment_mask (obstack)) \
2307                   & ~ obstack_alignment_mask (obstack))
2308   if ((char *)t + ROUND (size) == obstack_next_free (obstack))
2309     return 1;
2310 #undef ROUND
2311
2312   return 0;
2313 }
2314
2315 /* Return first vector element whose BINFO_TYPE is ELEM.
2316    Return 0 if ELEM is not in VEC.  VEC may be NULL_TREE.  */
2317
2318 tree
2319 vec_binfo_member (elem, vec)
2320      tree elem, vec;
2321 {
2322   int i;
2323
2324   if (vec)
2325     for (i = 0; i < TREE_VEC_LENGTH (vec); ++i)
2326       if (same_type_p (elem, BINFO_TYPE (TREE_VEC_ELT (vec, i))))
2327         return TREE_VEC_ELT (vec, i);
2328
2329   return NULL_TREE;
2330 }
2331
2332 /* Kludge around the fact that DECL_CONTEXT for virtual functions returns
2333    the wrong thing for decl_function_context.  Hopefully the uses in the
2334    backend won't matter, since we don't need a static chain for local class
2335    methods.  FIXME!  */
2336
2337 tree
2338 hack_decl_function_context (decl)
2339      tree decl;
2340 {
2341   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_FUNCTION_MEMBER_P (decl))
2342     return decl_function_context (TYPE_MAIN_DECL (DECL_CLASS_CONTEXT (decl)));
2343   return decl_function_context (decl);
2344 }
2345
2346 /* Returns the namespace that contains DECL, whether directly or
2347    indirectly.  */
2348
2349 tree
2350 decl_namespace_context (decl)
2351      tree decl;
2352 {
2353   while (1)
2354     {
2355       if (TREE_CODE (decl) == NAMESPACE_DECL)
2356         return decl;
2357       else if (TYPE_P (decl))
2358         decl = CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl));
2359       else
2360         decl = CP_DECL_CONTEXT (decl);
2361     }
2362 }
2363
2364 /* Return truthvalue of whether T1 is the same tree structure as T2.
2365    Return 1 if they are the same.
2366    Return 0 if they are understandably different.
2367    Return -1 if either contains tree structure not understood by
2368    this function.  */
2369
2370 int
2371 cp_tree_equal (t1, t2)
2372      tree t1, t2;
2373 {
2374   register enum tree_code code1, code2;
2375   int cmp;
2376
2377   if (t1 == t2)
2378     return 1;
2379   if (t1 == 0 || t2 == 0)
2380     return 0;
2381
2382   code1 = TREE_CODE (t1);
2383   code2 = TREE_CODE (t2);
2384
2385   if (code1 == NOP_EXPR || code1 == CONVERT_EXPR || code1 == NON_LVALUE_EXPR)
2386     {
2387       if (code2 == NOP_EXPR || code2 == CONVERT_EXPR || code2 == NON_LVALUE_EXPR)
2388         return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2389       else
2390         return cp_tree_equal (TREE_OPERAND (t1, 0), t2);
2391     }
2392   else if (code2 == NOP_EXPR || code2 == CONVERT_EXPR
2393            || code2 == NON_LVALUE_EXPR)
2394     return cp_tree_equal (t1, TREE_OPERAND (t2, 0));
2395
2396   if (code1 != code2)
2397     return 0;
2398
2399   switch (code1)
2400     {
2401     case INTEGER_CST:
2402       return TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
2403         && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2);
2404
2405     case REAL_CST:
2406       return REAL_VALUES_EQUAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
2407
2408     case STRING_CST:
2409       return TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
2410         && !bcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
2411                   TREE_STRING_LENGTH (t1));
2412
2413     case CONSTRUCTOR:
2414       /* We need to do this when determining whether or not two
2415          non-type pointer to member function template arguments
2416          are the same.  */
2417       if (!(same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
2418             /* The first operand is RTL.  */
2419             && TREE_OPERAND (t1, 0) == TREE_OPERAND (t2, 0)))
2420         return 0;
2421       return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
2422
2423     case TREE_LIST:
2424       cmp = cp_tree_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2));
2425       if (cmp <= 0)
2426         return cmp;
2427       cmp = cp_tree_equal (TREE_VALUE (t1), TREE_VALUE (t2));
2428       if (cmp <= 0)
2429         return cmp;
2430       return cp_tree_equal (TREE_CHAIN (t1), TREE_CHAIN (t2));
2431
2432     case SAVE_EXPR:
2433       return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2434
2435     case CALL_EXPR:
2436       cmp = cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2437       if (cmp <= 0)
2438         return cmp;
2439       return simple_cst_list_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
2440
2441     case TARGET_EXPR:
2442       /* Special case: if either target is an unallocated VAR_DECL,
2443          it means that it's going to be unified with whatever the
2444          TARGET_EXPR is really supposed to initialize, so treat it
2445          as being equivalent to anything.  */
2446       if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL
2447            && DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE
2448            && DECL_RTL (TREE_OPERAND (t1, 0)) == 0)
2449           || (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL
2450               && DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE
2451               && DECL_RTL (TREE_OPERAND (t2, 0)) == 0))
2452         cmp = 1;
2453       else
2454         cmp = cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2455       if (cmp <= 0)
2456         return cmp;
2457       return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
2458
2459     case WITH_CLEANUP_EXPR:
2460       cmp = cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2461       if (cmp <= 0)
2462         return cmp;
2463       return cp_tree_equal (TREE_OPERAND (t1, 2), TREE_OPERAND (t1, 2));
2464
2465     case COMPONENT_REF:
2466       if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1))
2467         return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2468       return 0;
2469
2470     case VAR_DECL:
2471     case PARM_DECL:
2472     case CONST_DECL:
2473     case FUNCTION_DECL:
2474       return 0;
2475
2476     case TEMPLATE_PARM_INDEX:
2477       return TEMPLATE_PARM_IDX (t1) == TEMPLATE_PARM_IDX (t2)
2478         && TEMPLATE_PARM_LEVEL (t1) == TEMPLATE_PARM_LEVEL (t2);
2479
2480     case SIZEOF_EXPR:
2481     case ALIGNOF_EXPR:
2482       if (TREE_CODE (TREE_OPERAND (t1, 0)) != TREE_CODE (TREE_OPERAND (t2, 0)))
2483         return 0;
2484       if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (t1, 0))) == 't')
2485         return same_type_p (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2486       break;
2487
2488     case PTRMEM_CST:
2489       /* Two pointer-to-members are the same if they point to the same
2490          field or function in the same class.  */
2491       return (PTRMEM_CST_MEMBER (t1) == PTRMEM_CST_MEMBER (t2)
2492               && same_type_p (PTRMEM_CST_CLASS (t1), PTRMEM_CST_CLASS (t2)));
2493
2494     default:
2495       break;
2496     }
2497
2498   switch (TREE_CODE_CLASS (code1))
2499     {
2500       int i;
2501     case '1':
2502     case '2':
2503     case '<':
2504     case 'e':
2505     case 'r':
2506     case 's':
2507       cmp = 1;
2508       for (i=0; i<tree_code_length[(int) code1]; ++i)
2509         {
2510           cmp = cp_tree_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i));
2511           if (cmp <= 0)
2512             return cmp;
2513         }
2514       return cmp;
2515     }
2516
2517   return -1;
2518 }
2519
2520 /* Similar to make_tree_vec, but build on the momentary_obstack.
2521    Thus, these vectors are really and truly temporary.  */
2522
2523 tree
2524 make_temp_vec (len)
2525      int len;
2526 {
2527   register tree node;
2528   push_expression_obstack ();
2529   node = make_tree_vec (len);
2530   pop_obstacks ();
2531   return node;
2532 }
2533
2534 /* Build a wrapper around some pointer PTR so we can use it as a tree.  */
2535
2536 tree
2537 build_ptr_wrapper (ptr)
2538      void *ptr;
2539 {
2540   tree t = make_node (WRAPPER);
2541   WRAPPER_PTR (t) = ptr;
2542   return t;
2543 }
2544
2545 /* Same, but on the expression_obstack.  */
2546
2547 tree
2548 build_expr_ptr_wrapper (ptr)
2549      void *ptr;
2550 {
2551   tree t;
2552   push_expression_obstack ();
2553   t = build_ptr_wrapper (ptr);
2554   pop_obstacks ();
2555   return t;
2556 }
2557
2558 /* Build a wrapper around some integer I so we can use it as a tree.  */
2559
2560 tree
2561 build_int_wrapper (i)
2562      int i;
2563 {
2564   tree t = make_node (WRAPPER);
2565   WRAPPER_INT (t) = i;
2566   return t;
2567 }
2568
2569 static tree
2570 build_srcloc (file, line)
2571      char *file;
2572      int line;
2573 {
2574   tree t;
2575
2576   t = make_node (SRCLOC);
2577   SRCLOC_FILE (t) = file;
2578   SRCLOC_LINE (t) = line;
2579
2580   return t;
2581 }
2582
2583 tree
2584 build_srcloc_here ()
2585 {
2586   return build_srcloc (input_filename, lineno);
2587 }
2588
2589 void
2590 push_expression_obstack ()
2591 {
2592   push_obstacks_nochange ();
2593   current_obstack = expression_obstack;
2594 }
2595
2596 /* Begin allocating on the permanent obstack.  When you're done
2597    allocating there, call pop_obstacks to return to the previous set
2598    of obstacks.  */
2599
2600 void
2601 push_permanent_obstack ()
2602 {
2603   push_obstacks_nochange ();
2604   end_temporary_allocation ();
2605 }
2606
2607 /* The type of ARG when used as an lvalue.  */
2608
2609 tree
2610 lvalue_type (arg)
2611      tree arg;
2612 {
2613   tree type = TREE_TYPE (arg);
2614   if (TREE_CODE (arg) == OVERLOAD)
2615     type = unknown_type_node;
2616   return type;
2617 }
2618
2619 /* The type of ARG for printing error messages; denote lvalues with
2620    reference types.  */
2621
2622 tree
2623 error_type (arg)
2624      tree arg;
2625 {
2626   tree type = TREE_TYPE (arg);
2627   if (TREE_CODE (type) == ARRAY_TYPE)
2628     ;
2629   else if (real_lvalue_p (arg))
2630     type = build_reference_type (lvalue_type (arg));
2631   else if (IS_AGGR_TYPE (type))
2632     type = lvalue_type (arg);
2633
2634   return type;
2635 }
2636
2637 /* Does FUNCTION use a variable-length argument list?  */
2638
2639 int
2640 varargs_function_p (function)
2641      tree function;
2642 {
2643   tree parm = TYPE_ARG_TYPES (TREE_TYPE (function));
2644   for (; parm; parm = TREE_CHAIN (parm))
2645     if (TREE_VALUE (parm) == void_type_node)
2646       return 0;
2647   return 1;
2648 }
2649
2650 /* Returns 1 if decl is a member of a class.  */
2651
2652 int
2653 member_p (decl)
2654      tree decl;
2655 {
2656   tree ctx = DECL_CONTEXT (decl);
2657   return (ctx && TREE_CODE_CLASS (TREE_CODE (ctx)) == 't');
2658 }
2659
2660 /* Create a placeholder for member access where we don't actually have an
2661    object that the access is against.  */
2662
2663 tree
2664 build_dummy_object (type)
2665      tree type;
2666 {
2667   tree decl = build1 (NOP_EXPR, build_pointer_type (type), void_zero_node);
2668   return build_indirect_ref (decl, NULL_PTR);
2669 }
2670
2671 /* We've gotten a reference to a member of TYPE.  Return *this if appropriate,
2672    or a dummy object otherwise.  If BINFOP is non-0, it is filled with the
2673    binfo path from current_class_type to TYPE, or 0.  */
2674
2675 tree
2676 maybe_dummy_object (type, binfop)
2677      tree type;
2678      tree *binfop;
2679 {
2680   tree decl, context;
2681
2682   if (current_class_type
2683       && get_base_distance (type, current_class_type, 0, binfop) != -1)
2684     context = current_class_type;
2685   else
2686     {
2687       /* Reference from a nested class member function.  */
2688       context = type;
2689       if (binfop)
2690         *binfop = TYPE_BINFO (type);
2691     }
2692
2693   if (current_class_ref && context == current_class_type)
2694     decl = current_class_ref;
2695   else
2696     decl = build_dummy_object (context);
2697
2698   return decl;
2699 }
2700
2701 /* Returns 1 if OB is a placeholder object, or a pointer to one.  */
2702
2703 int
2704 is_dummy_object (ob)
2705      tree ob;
2706 {
2707   if (TREE_CODE (ob) == INDIRECT_REF)
2708     ob = TREE_OPERAND (ob, 0);
2709   return (TREE_CODE (ob) == NOP_EXPR
2710           && TREE_OPERAND (ob, 0) == void_zero_node);
2711 }
2712
2713 /* Returns 1 iff type T is a POD type, as defined in [basic.types].  */
2714
2715 int
2716 pod_type_p (t)
2717      tree t;
2718 {
2719   while (TREE_CODE (t) == ARRAY_TYPE)
2720     t = TREE_TYPE (t);
2721
2722   if (INTEGRAL_TYPE_P (t))
2723     return 1;  /* integral, character or enumeral type */
2724   if (FLOAT_TYPE_P (t))
2725     return 1;
2726   if (TYPE_PTR_P (t))
2727     return 1; /* pointer to non-member */
2728   if (TYPE_PTRMEM_P (t))
2729     return 1; /* pointer to member object */
2730   if (TYPE_PTRMEMFUNC_P (t))
2731     return 1; /* pointer to member function */
2732
2733   if (! CLASS_TYPE_P (t))
2734     return 0; /* other non-class type (reference or function) */
2735   if (CLASSTYPE_NON_POD_P (t))
2736     return 0;
2737   return 1;
2738 }
2739
2740 /* Return a 1 if ATTR_NAME and ATTR_ARGS denote a valid C++-specific
2741    attribute for either declaration DECL or type TYPE and 0 otherwise.
2742    Plugged into valid_lang_attribute.  */
2743
2744 int
2745 cp_valid_lang_attribute (attr_name, attr_args, decl, type)
2746   tree attr_name;
2747   tree attr_args ATTRIBUTE_UNUSED;
2748   tree decl ATTRIBUTE_UNUSED;
2749   tree type ATTRIBUTE_UNUSED;
2750 {
2751   if (is_attribute_p ("com_interface", attr_name))
2752     {
2753       if (! flag_vtable_thunks)
2754         {
2755           error ("`com_interface' only supported with -fvtable-thunks");
2756           return 0;
2757         }
2758
2759       if (attr_args != NULL_TREE
2760           || decl != NULL_TREE
2761           || ! CLASS_TYPE_P (type)
2762           || type != TYPE_MAIN_VARIANT (type))
2763         {
2764           warning ("`com_interface' attribute can only be applied to class definitions");
2765           return 0;
2766         }
2767
2768       CLASSTYPE_COM_INTERFACE (type) = 1;
2769       return 1;
2770     }
2771   else if (is_attribute_p ("init_priority", attr_name))
2772     {
2773       tree initp_expr = (attr_args ? TREE_VALUE (attr_args): NULL_TREE);
2774       int pri;
2775
2776       if (initp_expr)
2777         STRIP_NOPS (initp_expr);
2778
2779       if (!initp_expr || TREE_CODE (initp_expr) != INTEGER_CST)
2780         {
2781           error ("requested init_priority is not an integer constant");
2782           return 0;
2783         }
2784
2785       pri = TREE_INT_CST_LOW (initp_expr);
2786
2787       while (TREE_CODE (type) == ARRAY_TYPE)
2788         type = TREE_TYPE (type);
2789
2790       if (decl == NULL_TREE
2791           || TREE_CODE (decl) != VAR_DECL
2792           || ! TREE_STATIC (decl)
2793           || DECL_EXTERNAL (decl)
2794           || (TREE_CODE (type) != RECORD_TYPE
2795               && TREE_CODE (type) != UNION_TYPE)
2796           /* Static objects in functions are initialized the
2797              first time control passes through that
2798              function. This is not precise enough to pin down an
2799              init_priority value, so don't allow it. */
2800           || current_function_decl)
2801         {
2802           error ("can only use init_priority attribute on file-scope definitions of objects of class type");
2803           return 0;
2804         }
2805
2806       if (pri > MAX_INIT_PRIORITY || pri <= 0)
2807         {
2808           error ("requested init_priority is out of range");
2809           return 0;
2810         }
2811
2812       /* Check for init_priorities that are reserved for
2813          language and runtime support implementations.*/
2814       if (pri <= MAX_RESERVED_INIT_PRIORITY)
2815         {
2816           warning
2817             ("requested init_priority is reserved for internal use");
2818         }
2819
2820       DECL_INIT_PRIORITY (decl) = pri;
2821       return 1;
2822     }
2823
2824   return 0;
2825 }
2826
2827 /* Return a new PTRMEM_CST of the indicated TYPE.  The MEMBER is the
2828    thing pointed to by the constant.  */
2829
2830 tree
2831 make_ptrmem_cst (type, member)
2832      tree type;
2833      tree member;
2834 {
2835   tree ptrmem_cst = make_node (PTRMEM_CST);
2836   /* If would seem a great convenience if make_node would set
2837      TREE_CONSTANT for things of class `c', but it does not.  */
2838   TREE_CONSTANT (ptrmem_cst) = 1;
2839   TREE_TYPE (ptrmem_cst) = type;
2840   PTRMEM_CST_MEMBER (ptrmem_cst) = member;
2841   return ptrmem_cst;
2842 }
2843
2844 /* Mark ARG (which is really a list_hash_table **) for GC.  */
2845
2846 static void
2847 mark_list_hash (arg)
2848      void *arg;
2849 {
2850   struct list_hash *lh;
2851
2852   for (lh = * ((struct list_hash **) arg); lh; lh = lh->next)
2853     ggc_mark_tree (lh->list);
2854 }
2855
2856 /* Initialize tree.c.  */
2857
2858 void
2859 init_tree ()
2860 {
2861   make_lang_type_fn = cp_make_lang_type;
2862   lang_unsave_expr_now = cplus_unsave_expr_now;
2863   ggc_add_root (list_hash_table,
2864                 sizeof (list_hash_table) / sizeof (struct list_hash *),
2865                 sizeof (struct list_hash *),
2866                 mark_list_hash);
2867 }
2868
2869 /* The C++ version of unsave_expr_now.
2870    See gcc/tree.c:unsave_expr_now for comments. */
2871
2872 void
2873 cplus_unsave_expr_now (expr)
2874      tree expr;
2875 {
2876   if (expr == NULL)
2877     return;
2878
2879   else if (TREE_CODE (expr) == AGGR_INIT_EXPR)
2880     {
2881       unsave_expr_now (TREE_OPERAND (expr,0));
2882       if (TREE_OPERAND (expr, 1)
2883           && TREE_CODE (TREE_OPERAND (expr, 1)) == TREE_LIST)
2884         {
2885           tree exp = TREE_OPERAND (expr, 1);
2886           while (exp)
2887             {
2888               unsave_expr_now (TREE_VALUE (exp));
2889               exp = TREE_CHAIN (exp);
2890             }
2891         }
2892       unsave_expr_now (TREE_OPERAND (expr,2));
2893       return;
2894     }
2895
2896   else
2897     return;
2898 }
2899