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