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