gcc/cp/tree.c

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