gcc/cp/tree.c

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