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)) != FUNCTION_TYPE
  91           && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE)
  92         return 1;
  93       break;
  94
  95       /* A currently unresolved scope ref.  */
  96     case SCOPE_REF:
  97       my_friendly_abort (103);
  98     case OFFSET_REF:
  99       if (TREE_CODE (TREE_OPERAND (ref, 1)) == FUNCTION_DECL)
 100         return 1;
 101       return (lvalue_p_1 (TREE_OPERAND (ref, 0),
 102                           treat_class_rvalues_as_lvalues)
 103               && lvalue_p_1 (TREE_OPERAND (ref, 1),
 104                              treat_class_rvalues_as_lvalues));
 105       break;
 106
 107     case COND_EXPR:
 108       return (lvalue_p_1 (TREE_OPERAND (ref, 1),
 109                           treat_class_rvalues_as_lvalues)
 110               && lvalue_p_1 (TREE_OPERAND (ref, 2),
 111                              treat_class_rvalues_as_lvalues));
 112
 113     case MODIFY_EXPR:
 114       return 1;
 115
 116     case COMPOUND_EXPR:
 117       return lvalue_p_1 (TREE_OPERAND (ref, 1),
 118                             treat_class_rvalues_as_lvalues);
 119
 120     case MAX_EXPR:
 121     case MIN_EXPR:
 122       return (lvalue_p_1 (TREE_OPERAND (ref, 0),
 123                           treat_class_rvalues_as_lvalues)
 124               && lvalue_p_1 (TREE_OPERAND (ref, 1),
 125                              treat_class_rvalues_as_lvalues));
 126
 127     case TARGET_EXPR:
 128       return treat_class_rvalues_as_lvalues;
 129
 130     case CALL_EXPR:
 131       return (treat_class_rvalues_as_lvalues
 132               && IS_AGGR_TYPE (TREE_TYPE (ref)));
 133
 134     case FUNCTION_DECL:
 135       /* All functions (except non-static-member functions) are
 136          lvalues.  */
 137       return !DECL_NONSTATIC_MEMBER_FUNCTION_P (ref);
 138
 139     default:
 140       break;
 141     }
 142
 143   return 0;
 144 }
 145
 146 /* Return nonzero if REF is an lvalue valid for this language.
 147    Lvalues can be assigned, unless they have TREE_READONLY, or unless
 148    they are FUNCTION_DECLs.  Lvalues can have their address taken,
 149    unless they have DECL_REGISTER.  */
 150
 151 int
 152 real_lvalue_p (ref)
 153      tree ref;
 154 {
 155   return lvalue_p_1 (ref, /*treat_class_rvalues_as_lvalues=*/0);
 156 }
 157
 158 /* This differs from real_lvalue_p in that class rvalues are considered
 159    lvalues.  */
 160
 161 int
 162 lvalue_p (ref)
 163      tree ref;
 164 {
 165   return lvalue_p_1 (ref, /*treat_class_rvalues_as_lvalues=*/1);
 166 }
 167
 168 /* Return nonzero if REF is an lvalue valid for this language;
 169    otherwise, print an error message and return zero.  */
 170
 171 int
 172 lvalue_or_else (ref, string)
 173      tree ref;
 174      char *string;
 175 {
 176   int win = lvalue_p (ref);
 177   if (! win)
 178     error ("non-lvalue in %s", string);
 179   return win;
 180 }
 181
 182 /* INIT is a CALL_EXPR which needs info about its target.
 183    TYPE is the type that this initialization should appear to have.
 184
 185    Build an encapsulation of the initialization to perform
 186    and return it so that it can be processed by language-independent
 187    and language-specific expression expanders.  */
 188
 189 tree
 190 build_cplus_new (type, init)
 191      tree type;
 192      tree init;
 193 {
 194   tree slot;
 195   tree rval;
 196
 197   if (TREE_CODE (init) != CALL_EXPR && TREE_CODE (init) != AGGR_INIT_EXPR)
 198     return init;
 199
 200   slot = build (VAR_DECL, type);
 201   DECL_ARTIFICIAL (slot) = 1;
 202   layout_decl (slot, 0);
 203   rval = build (AGGR_INIT_EXPR, type,
 204                 TREE_OPERAND (init, 0), TREE_OPERAND (init, 1), slot);
 205   TREE_SIDE_EFFECTS (rval) = 1;
 206   rval = build (TARGET_EXPR, type, slot, rval, NULL_TREE, NULL_TREE);
 207   TREE_SIDE_EFFECTS (rval) = 1;
 208
 209   return rval;
 210 }
 211
 212 /* Encapsulate the expression INIT in a TARGET_EXPR.  */
 213
 214 tree
 215 get_target_expr (init)
 216      tree init;
 217 {
 218   tree slot;
 219   tree rval;
 220
 221   slot = build (VAR_DECL, TREE_TYPE (init));
 222   DECL_ARTIFICIAL (slot) = 1;
 223   layout_decl (slot, 0);
 224   rval = build (TARGET_EXPR, TREE_TYPE (init), slot, init,
 225                 NULL_TREE, NULL_TREE);
 226   TREE_SIDE_EFFECTS (rval) = 1;
 227
 228   return rval;
 229 }
 230
 231 /* Recursively search EXP for CALL_EXPRs that need cleanups and replace
 232    these CALL_EXPRs with tree nodes that will perform the cleanups.  */
 233
 234 tree
 235 break_out_cleanups (exp)
 236      tree exp;
 237 {
 238   tree tmp = exp;
 239
 240   if (TREE_CODE (tmp) == CALL_EXPR
 241       && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (tmp)))
 242     return build_cplus_new (TREE_TYPE (tmp), tmp);
 243
 244   while (TREE_CODE (tmp) == NOP_EXPR
 245          || TREE_CODE (tmp) == CONVERT_EXPR
 246          || TREE_CODE (tmp) == NON_LVALUE_EXPR)
 247     {
 248       if (TREE_CODE (TREE_OPERAND (tmp, 0)) == CALL_EXPR
 249           && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (TREE_OPERAND (tmp, 0))))
 250         {
 251           TREE_OPERAND (tmp, 0)
 252             = build_cplus_new (TREE_TYPE (TREE_OPERAND (tmp, 0)),
 253                                TREE_OPERAND (tmp, 0));
 254           break;
 255         }
 256       else
 257         tmp = TREE_OPERAND (tmp, 0);
 258     }
 259   return exp;
 260 }
 261
 262 /* Recursively perform a preorder search EXP for CALL_EXPRs, making
 263    copies where they are found.  Returns a deep copy all nodes transitively
 264    containing CALL_EXPRs.  */
 265
 266 tree
 267 break_out_calls (exp)
 268      tree exp;
 269 {
 270   register tree t1, t2 = NULL_TREE;
 271   register enum tree_code code;
 272   register int changed = 0;
 273   register int i;
 274
 275   if (exp == NULL_TREE)
 276     return exp;
 277
 278   code = TREE_CODE (exp);
 279
 280   if (code == CALL_EXPR)
 281     return copy_node (exp);
 282
 283   /* Don't try and defeat a save_expr, as it should only be done once.  */
 284     if (code == SAVE_EXPR)
 285        return exp;
 286
 287   switch (TREE_CODE_CLASS (code))
 288     {
 289     default:
 290       abort ();
 291
 292     case 'c':  /* a constant */
 293     case 't':  /* a type node */
 294     case 'x':  /* something random, like an identifier or an ERROR_MARK.  */
 295       return exp;
 296
 297     case 'd':  /* A decl node */
 298 #if 0                               /* This is bogus.  jason 9/21/94 */
 299
 300       t1 = break_out_calls (DECL_INITIAL (exp));
 301       if (t1 != DECL_INITIAL (exp))
 302         {
 303           exp = copy_node (exp);
 304           DECL_INITIAL (exp) = t1;
 305         }
 306 #endif
 307       return exp;
 308
 309     case 'b':  /* A block node */
 310       {
 311         /* Don't know how to handle these correctly yet.   Must do a
 312            break_out_calls on all DECL_INITIAL values for local variables,
 313            and also break_out_calls on all sub-blocks and sub-statements.  */
 314         abort ();
 315       }
 316       return exp;
 317
 318     case 'e':  /* an expression */
 319     case 'r':  /* a reference */
 320     case 's':  /* an expression with side effects */
 321       for (i = tree_code_length[(int) code] - 1; i >= 0; i--)
 322         {
 323           t1 = break_out_calls (TREE_OPERAND (exp, i));
 324           if (t1 != TREE_OPERAND (exp, i))
 325             {
 326               exp = copy_node (exp);
 327               TREE_OPERAND (exp, i) = t1;
 328             }
 329         }
 330       return exp;
 331
 332     case '<':  /* a comparison expression */
 333     case '2':  /* a binary arithmetic expression */
 334       t2 = break_out_calls (TREE_OPERAND (exp, 1));
 335       if (t2 != TREE_OPERAND (exp, 1))
 336         changed = 1;
 337     case '1':  /* a unary arithmetic expression */
 338       t1 = break_out_calls (TREE_OPERAND (exp, 0));
 339       if (t1 != TREE_OPERAND (exp, 0))
 340         changed = 1;
 341       if (changed)
 342         {
 343           if (tree_code_length[(int) code] == 1)
 344             return build1 (code, TREE_TYPE (exp), t1);
 345           else
 346             return build (code, TREE_TYPE (exp), t1, t2);
 347         }
 348       return exp;
 349     }
 350
 351 }
 352 \f
 353 extern struct obstack *current_obstack;
 354 extern struct obstack permanent_obstack, class_obstack;
 355 extern struct obstack *saveable_obstack;
 356 extern struct obstack *expression_obstack;
 357
 358 /* Here is how primitive or already-canonicalized types' hash
 359    codes are made.  MUST BE CONSISTENT WITH tree.c !!! */
 360 #define TYPE_HASH(TYPE) ((HOST_WIDE_INT) (TYPE) & 0777777)
 361
 362 /* Construct, lay out and return the type of methods belonging to class
 363    BASETYPE and whose arguments are described by ARGTYPES and whose values
 364    are described by RETTYPE.  If each type exists already, reuse it.  */
 365
 366 tree
 367 build_cplus_method_type (basetype, rettype, argtypes)
 368      tree basetype, rettype, argtypes;
 369 {
 370   register tree t;
 371   tree ptype;
 372   int hashcode;
 373
 374   /* Make a node of the sort we want.  */
 375   t = make_node (METHOD_TYPE);
 376
 377   TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
 378   TREE_TYPE (t) = rettype;
 379   if (IS_SIGNATURE (basetype))
 380     ptype = build_signature_pointer_type (basetype);
 381   else
 382     ptype = build_pointer_type (basetype);
 383
 384   /* The actual arglist for this function includes a "hidden" argument
 385      which is "this".  Put it into the list of argument types.  */
 386
 387   argtypes = tree_cons (NULL_TREE, ptype, argtypes);
 388   TYPE_ARG_TYPES (t) = argtypes;
 389   TREE_SIDE_EFFECTS (argtypes) = 1;  /* Mark first argtype as "artificial".  */
 390
 391   /* If we already have such a type, use the old one and free this one.
 392      Note that it also frees up the above cons cell if found.  */
 393   hashcode = TYPE_HASH (basetype) + TYPE_HASH (rettype) + type_hash_list (argtypes);
 394   t = type_hash_canon (hashcode, t);
 395
 396   if (TYPE_SIZE (t) == 0)
 397     layout_type (t);
 398
 399   return t;
 400 }
 401
 402 static tree
 403 build_cplus_array_type_1 (elt_type, index_type)
 404      tree elt_type;
 405      tree index_type;
 406 {
 407   register struct obstack *ambient_obstack = current_obstack;
 408   register struct obstack *ambient_saveable_obstack = saveable_obstack;
 409   tree t;
 410
 411   /* We need a new one.  If both ELT_TYPE and INDEX_TYPE are permanent,
 412      make this permanent too.  */
 413   if (TREE_PERMANENT (elt_type)
 414       && (index_type == 0 || TREE_PERMANENT (index_type)))
 415     {
 416       current_obstack = &permanent_obstack;
 417       saveable_obstack = &permanent_obstack;
 418     }
 419
 420   if (processing_template_decl
 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 constp = TYPE_READONLY (elt_type);
 446   int volatilep = TYPE_VOLATILE (elt_type);
 447   elt_type = TYPE_MAIN_VARIANT (elt_type);
 448
 449   t = build_cplus_array_type_1 (elt_type, index_type);
 450
 451   if (constp || volatilep)
 452     t = cp_build_type_variant (t, constp, volatilep);
 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_type_variant (type, constp, volatilep)
 462      tree type;
 463      int constp, volatilep;
 464 {
 465   if (type == error_mark_node)
 466     return type;
 467
 468   if (TREE_CODE (type) == ARRAY_TYPE)
 469     {
 470       tree real_main_variant = TYPE_MAIN_VARIANT (type);
 471
 472       push_obstacks (TYPE_OBSTACK (real_main_variant),
 473                      TYPE_OBSTACK (real_main_variant));
 474       type = build_cplus_array_type_1 (cp_build_type_variant
 475                                        (TREE_TYPE (type), constp, volatilep),
 476                                        TYPE_DOMAIN (type));
 477
 478       /* TYPE must be on same obstack as REAL_MAIN_VARIANT.  If not,
 479          make a copy.  (TYPE might have come from the hash table and
 480          REAL_MAIN_VARIANT might be in some function's obstack.)  */
 481
 482       if (TYPE_OBSTACK (type) != TYPE_OBSTACK (real_main_variant))
 483         {
 484           type = copy_node (type);
 485           TYPE_POINTER_TO (type) = TYPE_REFERENCE_TO (type) = 0;
 486         }
 487
 488       TYPE_MAIN_VARIANT (type) = real_main_variant;
 489       pop_obstacks ();
 490       return type;
 491     }
 492   return build_type_variant (type, constp, volatilep);
 493 }
 494
 495 /* Returns the canonical version of TYPE.  In other words, if TYPE is
 496    a typedef, returns the underlying type.  The cv-qualification of
 497    the type returned matches the type input; they will always be
 498    compatible types.  */
 499
 500 tree
 501 canonical_type_variant (t)
 502      tree t;
 503 {
 504   int constp, volatilep;
 505   if (TREE_CODE (t) == ARRAY_TYPE)
 506     {
 507       constp = TYPE_READONLY (TREE_TYPE (t));
 508       volatilep = TYPE_VOLATILE (TREE_TYPE (t));
 509     }
 510   else
 511     {
 512       constp = TYPE_READONLY (t);
 513       volatilep = TYPE_VOLATILE (t);
 514     }
 515   return cp_build_type_variant (TYPE_MAIN_VARIANT (t), constp, volatilep);
 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 = TYPE_BINFO (binfo);
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   if (TREE_CODE (x) == TREE_LIST)
1300     {
1301       my_friendly_assert (TREE_CODE (TREE_PURPOSE (x)) == TREE_VEC
1302                           || TREE_CODE (TREE_PURPOSE (x)) == IDENTIFIER_NODE,
1303                           388);
1304       x = TREE_VALUE (x);
1305     }
1306   return (TREE_CODE (x) == FUNCTION_DECL
1307           || TREE_CODE (x) == TEMPLATE_ID_EXPR
1308           || DECL_FUNCTION_TEMPLATE_P (x)
1309           || TREE_CODE (x) == OVERLOAD);
1310 }
1311
1312 int
1313 really_overloaded_fn (x)
1314      tree x;
1315 {
1316   /* A baselink is also considered an overloaded function.
1317      This might also be an ambiguous class member. */
1318   if (TREE_CODE (x) == TREE_LIST)
1319     x = TREE_VALUE (x);
1320   return (TREE_CODE (x) == OVERLOAD
1321           && (TREE_CHAIN (x) != NULL_TREE
1322               || DECL_FUNCTION_TEMPLATE_P (OVL_FUNCTION (x))));
1323 }
1324
1325 tree
1326 get_first_fn (from)
1327      tree from;
1328 {
1329   my_friendly_assert (is_overloaded_fn (from), 9);
1330   /* A baselink is also considered an overloaded function. */
1331   if (TREE_CODE (from) == TREE_LIST)
1332     from = TREE_VALUE (from);
1333   return OVL_CURRENT (from);
1334 }
1335
1336 /* Return a new OVL node, concatenating it with the old one. */
1337
1338 tree
1339 ovl_cons (decl, chain)
1340      tree decl;
1341      tree chain;
1342 {
1343   tree result = make_node (OVERLOAD);
1344   TREE_TYPE (result) = unknown_type_node;
1345   OVL_FUNCTION (result) = decl;
1346   TREE_CHAIN (result) = chain;
1347
1348   return result;
1349 }
1350
1351 /* Same as ovl_cons, but on the scratch_obstack. */
1352
1353 tree
1354 scratch_ovl_cons (value, chain)
1355      tree value, chain;
1356 {
1357   register tree node;
1358   register struct obstack *ambient_obstack = current_obstack;
1359   extern struct obstack *expression_obstack;
1360   current_obstack = expression_obstack;
1361   node = ovl_cons (value, chain);
1362   current_obstack = ambient_obstack;
1363   return node;
1364 }
1365
1366 /* Build a new overloaded function. If this is the first one,
1367    just return it; otherwise, ovl_cons the _DECLs */
1368
1369 tree
1370 build_overload (decl, chain)
1371      tree decl;
1372      tree chain;
1373 {
1374   if (!chain)
1375     return decl;
1376   if (TREE_CODE (chain) != OVERLOAD)
1377     chain = ovl_cons (chain, NULL_TREE);
1378   return ovl_cons (decl, chain);
1379 }
1380
1381 /* True if fn is in ovl. */
1382
1383 int
1384 ovl_member (fn, ovl)
1385      tree fn;
1386      tree ovl;
1387 {
1388   if (ovl == NULL_TREE)
1389     return 0;
1390   if (TREE_CODE (ovl) != OVERLOAD)
1391     return decls_match (ovl, fn);
1392   for (; ovl; ovl = OVL_CHAIN (ovl))
1393     if (decls_match (OVL_FUNCTION (ovl), fn))
1394       return 1;
1395   return 0;
1396 }
1397
1398 int
1399 is_aggr_type_2 (t1, t2)
1400      tree t1, t2;
1401 {
1402   if (TREE_CODE (t1) != TREE_CODE (t2))
1403     return 0;
1404   return IS_AGGR_TYPE (t1) && IS_AGGR_TYPE (t2);
1405 }
1406 \f
1407 #define PRINT_RING_SIZE 4
1408
1409 char *
1410 lang_printable_name (decl, v)
1411      tree decl;
1412      int v;
1413 {
1414   static tree decl_ring[PRINT_RING_SIZE];
1415   static char *print_ring[PRINT_RING_SIZE];
1416   static int ring_counter;
1417   int i;
1418
1419   /* Only cache functions.  */
1420   if (v < 2
1421       || TREE_CODE (decl) != FUNCTION_DECL
1422       || DECL_LANG_SPECIFIC (decl) == 0)
1423     return lang_decl_name (decl, v);
1424
1425   /* See if this print name is lying around.  */
1426   for (i = 0; i < PRINT_RING_SIZE; i++)
1427     if (decl_ring[i] == decl)
1428       /* yes, so return it.  */
1429       return print_ring[i];
1430
1431   if (++ring_counter == PRINT_RING_SIZE)
1432     ring_counter = 0;
1433
1434   if (current_function_decl != NULL_TREE)
1435     {
1436       if (decl_ring[ring_counter] == current_function_decl)
1437         ring_counter += 1;
1438       if (ring_counter == PRINT_RING_SIZE)
1439         ring_counter = 0;
1440       if (decl_ring[ring_counter] == current_function_decl)
1441         my_friendly_abort (106);
1442     }
1443
1444   if (print_ring[ring_counter])
1445     free (print_ring[ring_counter]);
1446
1447   print_ring[ring_counter] = xstrdup (lang_decl_name (decl, v));
1448   decl_ring[ring_counter] = decl;
1449   return print_ring[ring_counter];
1450 }
1451 \f
1452 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
1453    listed in RAISES.  */
1454
1455 tree
1456 build_exception_variant (type, raises)
1457      tree type;
1458      tree raises;
1459 {
1460   tree v = TYPE_MAIN_VARIANT (type);
1461   int constp = TYPE_READONLY (type);
1462   int volatilep = TYPE_VOLATILE (type);
1463
1464   for (; v; v = TYPE_NEXT_VARIANT (v))
1465     {
1466       if (TYPE_READONLY (v) != constp
1467           || TYPE_VOLATILE (v) != volatilep)
1468         continue;
1469
1470       /* @@ This should do set equality, not exact match.  */
1471       if (simple_cst_list_equal (TYPE_RAISES_EXCEPTIONS (v), raises))
1472         /* List of exceptions raised matches previously found list.
1473
1474            @@ Nice to free up storage used in consing up the
1475            @@ list of exceptions raised.  */
1476         return v;
1477     }
1478
1479   /* Need to build a new variant.  */
1480   v = build_type_copy (type);
1481
1482   if (raises && ! TREE_PERMANENT (raises))
1483     {
1484       push_obstacks_nochange ();
1485       end_temporary_allocation ();
1486       raises = copy_list (raises);
1487       pop_obstacks ();
1488     }
1489
1490   TYPE_RAISES_EXCEPTIONS (v) = raises;
1491   return v;
1492 }
1493
1494 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new one together with its
1495    lang_specific field and its corresponding TEMPLATE_DECL node */
1496
1497 tree
1498 copy_template_template_parm (t)
1499      tree t;
1500 {
1501   tree template = TYPE_NAME (t);
1502   tree t2 = make_lang_type (TEMPLATE_TEMPLATE_PARM);
1503   template = copy_node (template);
1504   copy_lang_decl (template);
1505   TREE_TYPE (template) = t2;
1506   TYPE_NAME (t2) = template;
1507   TYPE_STUB_DECL (t2) = template;
1508
1509   /* No need to copy these */
1510   TYPE_FIELDS (t2) = TYPE_FIELDS (t);
1511   CLASSTYPE_TEMPLATE_INFO (t2) = CLASSTYPE_TEMPLATE_INFO (t);
1512   return t2;
1513 }
1514
1515 /* Walk through the tree structure T, applying func.  If func ever returns
1516    non-null, return that value.  */
1517
1518 static tree
1519 search_tree (t, func)
1520      tree t;
1521      tree (*func) PROTO((tree));
1522 {
1523 #define TRY(ARG) if (tmp=search_tree (ARG, func), tmp != NULL_TREE) return tmp
1524
1525   tree tmp;
1526
1527   if (t == NULL_TREE)
1528     return t;
1529
1530   if (tmp = func (t), tmp != NULL_TREE)
1531     return tmp;
1532
1533   switch (TREE_CODE (t))
1534     {
1535     case ERROR_MARK:
1536       break;
1537
1538     case IDENTIFIER_NODE:
1539       break;
1540
1541     case VAR_DECL:
1542     case FUNCTION_DECL:
1543     case CONST_DECL:
1544     case TEMPLATE_DECL:
1545     case NAMESPACE_DECL:
1546       break;
1547
1548     case TYPE_DECL:
1549       TRY (TREE_TYPE (t));
1550       break;
1551
1552     case PARM_DECL:
1553       TRY (TREE_TYPE (t));
1554       TRY (TREE_CHAIN (t));
1555       break;
1556
1557     case TREE_LIST:
1558       TRY (TREE_PURPOSE (t));
1559       TRY (TREE_VALUE (t));
1560       TRY (TREE_CHAIN (t));
1561       break;
1562
1563     case OVERLOAD:
1564       TRY (OVL_FUNCTION (t));
1565       TRY (OVL_CHAIN (t));
1566       break;
1567
1568     case TREE_VEC:
1569       {
1570         int len = TREE_VEC_LENGTH (t);
1571
1572         t = copy_node (t);
1573         while (len--)
1574           TRY (TREE_VEC_ELT (t, len));
1575       }
1576       break;
1577
1578     case INTEGER_CST:
1579     case REAL_CST:
1580     case STRING_CST:
1581     case DEFAULT_ARG:
1582       break;
1583
1584     case PTRMEM_CST:
1585       TRY (TREE_TYPE (t));
1586       break;
1587
1588     case COND_EXPR:
1589     case TARGET_EXPR:
1590     case AGGR_INIT_EXPR:
1591     case NEW_EXPR:
1592       TRY (TREE_OPERAND (t, 0));
1593       TRY (TREE_OPERAND (t, 1));
1594       TRY (TREE_OPERAND (t, 2));
1595       break;
1596
1597     case MODIFY_EXPR:
1598     case PLUS_EXPR:
1599     case MINUS_EXPR:
1600     case MULT_EXPR:
1601     case TRUNC_DIV_EXPR:
1602     case TRUNC_MOD_EXPR:
1603     case MIN_EXPR:
1604     case MAX_EXPR:
1605     case LSHIFT_EXPR:
1606     case RSHIFT_EXPR:
1607     case BIT_IOR_EXPR:
1608     case BIT_XOR_EXPR:
1609     case BIT_AND_EXPR:
1610     case BIT_ANDTC_EXPR:
1611     case TRUTH_ANDIF_EXPR:
1612     case TRUTH_ORIF_EXPR:
1613     case LT_EXPR:
1614     case LE_EXPR:
1615     case GT_EXPR:
1616     case GE_EXPR:
1617     case EQ_EXPR:
1618     case NE_EXPR:
1619     case CEIL_DIV_EXPR:
1620     case FLOOR_DIV_EXPR:
1621     case ROUND_DIV_EXPR:
1622     case CEIL_MOD_EXPR:
1623     case FLOOR_MOD_EXPR:
1624     case ROUND_MOD_EXPR:
1625     case COMPOUND_EXPR:
1626     case PREDECREMENT_EXPR:
1627     case PREINCREMENT_EXPR:
1628     case POSTDECREMENT_EXPR:
1629     case POSTINCREMENT_EXPR:
1630     case ARRAY_REF:
1631     case SCOPE_REF:
1632     case TRY_CATCH_EXPR:
1633     case WITH_CLEANUP_EXPR:
1634     case CALL_EXPR:
1635       TRY (TREE_OPERAND (t, 0));
1636       TRY (TREE_OPERAND (t, 1));
1637       break;
1638
1639     case SAVE_EXPR:
1640     case CONVERT_EXPR:
1641     case ADDR_EXPR:
1642     case INDIRECT_REF:
1643     case NEGATE_EXPR:
1644     case BIT_NOT_EXPR:
1645     case TRUTH_NOT_EXPR:
1646     case NOP_EXPR:
1647     case NON_LVALUE_EXPR:
1648     case COMPONENT_REF:
1649     case CLEANUP_POINT_EXPR:
1650     case LOOKUP_EXPR:
1651     case SIZEOF_EXPR:
1652     case ALIGNOF_EXPR:
1653       TRY (TREE_OPERAND (t, 0));
1654       break;
1655
1656     case MODOP_EXPR:
1657     case CAST_EXPR:
1658     case REINTERPRET_CAST_EXPR:
1659     case CONST_CAST_EXPR:
1660     case STATIC_CAST_EXPR:
1661     case DYNAMIC_CAST_EXPR:
1662     case ARROW_EXPR:
1663     case DOTSTAR_EXPR:
1664     case TYPEID_EXPR:
1665       break;
1666
1667     case COMPLEX_CST:
1668       TRY (TREE_REALPART (t));
1669       TRY (TREE_IMAGPART (t));
1670       break;
1671
1672     case CONSTRUCTOR:
1673       TRY (CONSTRUCTOR_ELTS (t));
1674       break;
1675
1676     case TEMPLATE_TEMPLATE_PARM:
1677     case TEMPLATE_PARM_INDEX:
1678     case TEMPLATE_TYPE_PARM:
1679       break;
1680
1681     case BIND_EXPR:
1682       break;
1683
1684     case REAL_TYPE:
1685     case COMPLEX_TYPE:
1686     case VOID_TYPE:
1687     case BOOLEAN_TYPE:
1688     case TYPENAME_TYPE:
1689     case UNION_TYPE:
1690     case ENUMERAL_TYPE:
1691       break;
1692
1693     case POINTER_TYPE:
1694     case REFERENCE_TYPE:
1695       TRY (TREE_TYPE (t));
1696       break;
1697
1698     case FUNCTION_TYPE:
1699     case METHOD_TYPE:
1700       TRY (TREE_TYPE (t));
1701       TRY (TYPE_ARG_TYPES (t));
1702       break;
1703
1704     case ARRAY_TYPE:
1705       TRY (TREE_TYPE (t));
1706       TRY (TYPE_DOMAIN (t));
1707       break;
1708
1709     case INTEGER_TYPE:
1710       TRY (TYPE_MAX_VALUE (t));
1711       break;
1712
1713     case OFFSET_TYPE:
1714       TRY (TREE_TYPE (t));
1715       TRY (TYPE_OFFSET_BASETYPE (t));
1716       break;
1717
1718     case RECORD_TYPE:
1719       if (TYPE_PTRMEMFUNC_P (t))
1720         TRY (TYPE_PTRMEMFUNC_FN_TYPE (t));
1721       break;
1722
1723       /*  This list is incomplete, but should suffice for now.
1724           It is very important that `sorry' not call
1725           `report_error_function'.  That could cause an infinite loop.  */
1726     default:
1727       sorry ("initializer contains unrecognized tree code");
1728       return error_mark_node;
1729
1730     }
1731
1732   return NULL_TREE;
1733
1734 #undef TRY
1735 }
1736
1737 /* Passed to search_tree.  Checks for the use of types with no linkage.  */
1738
1739 static tree
1740 no_linkage_helper (t)
1741      tree t;
1742 {
1743   if (TYPE_P (t)
1744       && (IS_AGGR_TYPE (t) || TREE_CODE (t) == ENUMERAL_TYPE)
1745       && (decl_function_context (TYPE_MAIN_DECL (t))
1746           || ANON_AGGRNAME_P (TYPE_IDENTIFIER (t))))
1747     return t;
1748   return NULL_TREE;
1749 }
1750
1751 /* Check if the type T depends on a type with no linkage and if so, return
1752    it.  */
1753
1754 tree
1755 no_linkage_check (t)
1756      tree t;
1757 {
1758   t = search_tree (t, no_linkage_helper);
1759   if (t != error_mark_node)
1760     return t;
1761   return NULL_TREE;
1762 }
1763
1764
1765 /* Subroutine of copy_to_permanent
1766
1767    Assuming T is a node build bottom-up, make it all exist on
1768    permanent obstack, if it is not permanent already.  */
1769
1770 tree
1771 mapcar (t, func)
1772      tree t;
1773      tree (*func) PROTO((tree));
1774 {
1775   tree tmp;
1776
1777   if (t == NULL_TREE)
1778     return t;
1779
1780   if (tmp = func (t), tmp != NULL_TREE)
1781     return tmp;
1782
1783   switch (TREE_CODE (t))
1784     {
1785     case ERROR_MARK:
1786       return error_mark_node;
1787
1788     case VAR_DECL:
1789     case FUNCTION_DECL:
1790     case CONST_DECL:
1791       /* Rather than aborting, return error_mark_node.  This allows us
1792          to report a sensible error message on code like this:
1793
1794          void g() { int i; f<i>(7); }
1795
1796          In a case like:
1797
1798            void g() { const int i = 7; f<i>(7); }
1799
1800          however, we must actually return the constant initializer.  */
1801       tmp = decl_constant_value (t);
1802       if (tmp != t)
1803         return mapcar (tmp, func);
1804       else
1805         return error_mark_node;
1806
1807     case PARM_DECL:
1808       {
1809         tree chain = TREE_CHAIN (t);
1810         t = copy_node (t);
1811         TREE_CHAIN (t) = mapcar (chain, func);
1812         TREE_TYPE (t) = mapcar (TREE_TYPE (t), func);
1813         DECL_INITIAL (t) = mapcar (DECL_INITIAL (t), func);
1814         DECL_SIZE (t) = mapcar (DECL_SIZE (t), func);
1815         return t;
1816       }
1817
1818     case TREE_LIST:
1819       {
1820         tree chain = TREE_CHAIN (t);
1821         t = copy_node (t);
1822         TREE_PURPOSE (t) = mapcar (TREE_PURPOSE (t), func);
1823         TREE_VALUE (t) = mapcar (TREE_VALUE (t), func);
1824         TREE_CHAIN (t) = mapcar (chain, func);
1825         return t;
1826       }
1827
1828     case OVERLOAD:
1829       {
1830         tree chain = OVL_CHAIN (t);
1831         t = copy_node (t);
1832         OVL_FUNCTION (t) = mapcar (OVL_FUNCTION (t), func);
1833         OVL_CHAIN (t) = mapcar (chain, func);
1834         return t;
1835       }
1836
1837     case TREE_VEC:
1838       {
1839         int len = TREE_VEC_LENGTH (t);
1840
1841         t = copy_node (t);
1842         while (len--)
1843           TREE_VEC_ELT (t, len) = mapcar (TREE_VEC_ELT (t, len), func);
1844         return t;
1845       }
1846
1847     case INTEGER_CST:
1848     case REAL_CST:
1849     case STRING_CST:
1850       return copy_node (t);
1851
1852     case PTRMEM_CST:
1853       t = copy_node (t);
1854       TREE_TYPE (t) = mapcar (TREE_TYPE (t), func);
1855       PTRMEM_CST_MEMBER (t) = mapcar (PTRMEM_CST_MEMBER (t), func);
1856       return t;
1857
1858     case COND_EXPR:
1859     case TARGET_EXPR:
1860     case AGGR_INIT_EXPR:
1861       t = copy_node (t);
1862       TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1863       TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
1864       TREE_OPERAND (t, 2) = mapcar (TREE_OPERAND (t, 2), func);
1865       return t;
1866
1867     case SAVE_EXPR:
1868       t = copy_node (t);
1869       TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1870       return t;
1871
1872     case MODIFY_EXPR:
1873     case PLUS_EXPR:
1874     case MINUS_EXPR:
1875     case MULT_EXPR:
1876     case TRUNC_DIV_EXPR:
1877     case TRUNC_MOD_EXPR:
1878     case MIN_EXPR:
1879     case MAX_EXPR:
1880     case LSHIFT_EXPR:
1881     case RSHIFT_EXPR:
1882     case BIT_IOR_EXPR:
1883     case BIT_XOR_EXPR:
1884     case BIT_AND_EXPR:
1885     case BIT_ANDTC_EXPR:
1886     case TRUTH_ANDIF_EXPR:
1887     case TRUTH_ORIF_EXPR:
1888     case LT_EXPR:
1889     case LE_EXPR:
1890     case GT_EXPR:
1891     case GE_EXPR:
1892     case EQ_EXPR:
1893     case NE_EXPR:
1894     case CEIL_DIV_EXPR:
1895     case FLOOR_DIV_EXPR:
1896     case ROUND_DIV_EXPR:
1897     case CEIL_MOD_EXPR:
1898     case FLOOR_MOD_EXPR:
1899     case ROUND_MOD_EXPR:
1900     case COMPOUND_EXPR:
1901     case PREDECREMENT_EXPR:
1902     case PREINCREMENT_EXPR:
1903     case POSTDECREMENT_EXPR:
1904     case POSTINCREMENT_EXPR:
1905     case ARRAY_REF:
1906     case SCOPE_REF:
1907     case TRY_CATCH_EXPR:
1908     case WITH_CLEANUP_EXPR:
1909       t = copy_node (t);
1910       TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1911       TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
1912       return t;
1913
1914     case CALL_EXPR:
1915       t = copy_node (t);
1916       TREE_TYPE (t) = mapcar (TREE_TYPE (t), func);
1917       TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1918       TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
1919
1920       /* tree.def says that operand two is RTL, but
1921          make_call_declarator puts trees in there.  */
1922       if (TREE_OPERAND (t, 2)
1923           && TREE_CODE (TREE_OPERAND (t, 2)) == TREE_LIST)
1924         TREE_OPERAND (t, 2) = mapcar (TREE_OPERAND (t, 2), func);
1925       else
1926         TREE_OPERAND (t, 2) = NULL_TREE;
1927       return t;
1928
1929     case CONVERT_EXPR:
1930     case ADDR_EXPR:
1931     case INDIRECT_REF:
1932     case NEGATE_EXPR:
1933     case BIT_NOT_EXPR:
1934     case TRUTH_NOT_EXPR:
1935     case NOP_EXPR:
1936     case COMPONENT_REF:
1937     case CLEANUP_POINT_EXPR:
1938       t = copy_node (t);
1939       TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1940       return t;
1941
1942     case POINTER_TYPE:
1943       tmp = build_pointer_type (mapcar (TREE_TYPE (t), func));
1944       return cp_build_type_variant (tmp, TYPE_READONLY (t), TYPE_VOLATILE (t));
1945     case REFERENCE_TYPE:
1946       tmp = build_reference_type (mapcar (TREE_TYPE (t), func));
1947       return cp_build_type_variant (tmp, TYPE_READONLY (t), TYPE_VOLATILE (t));
1948     case FUNCTION_TYPE:
1949       tmp = build_function_type (mapcar (TREE_TYPE (t), func),
1950                                  mapcar (TYPE_ARG_TYPES (t), func));
1951       return cp_build_type_variant (tmp, TYPE_READONLY (t), TYPE_VOLATILE (t));
1952     case ARRAY_TYPE:
1953       tmp = build_cplus_array_type (mapcar (TREE_TYPE (t), func),
1954                                     mapcar (TYPE_DOMAIN (t), func));
1955       return cp_build_type_variant (tmp, TYPE_READONLY (t), TYPE_VOLATILE (t));
1956     case INTEGER_TYPE:
1957       tmp = build_index_type (mapcar (TYPE_MAX_VALUE (t), func));
1958       return cp_build_type_variant (tmp, TYPE_READONLY (t), TYPE_VOLATILE (t));
1959     case OFFSET_TYPE:
1960       tmp = build_offset_type (mapcar (TYPE_OFFSET_BASETYPE (t), func),
1961                                mapcar (TREE_TYPE (t), func));
1962       return cp_build_type_variant (tmp, TYPE_READONLY (t), TYPE_VOLATILE (t));
1963     case METHOD_TYPE:
1964       tmp = build_cplus_method_type
1965         (mapcar (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))), func),
1966          mapcar (TREE_TYPE (t), func),
1967          mapcar (TREE_CHAIN (TYPE_ARG_TYPES (t)), func));
1968       return cp_build_type_variant (tmp, TYPE_READONLY (t), TYPE_VOLATILE (t));
1969
1970     case COMPLEX_CST:
1971       t = copy_node (t);
1972       TREE_REALPART (t) = mapcar (TREE_REALPART (t), func);
1973       TREE_IMAGPART (t) = mapcar (TREE_REALPART (t), func);
1974       return t;
1975
1976     case CONSTRUCTOR:
1977       t = copy_node (t);
1978       CONSTRUCTOR_ELTS (t) = mapcar (CONSTRUCTOR_ELTS (t), func);
1979       return t;
1980
1981     case TEMPLATE_TEMPLATE_PARM:
1982       return copy_template_template_parm (t);
1983
1984     case BIND_EXPR:
1985       t = copy_node (t);
1986       TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1987       TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
1988       TREE_OPERAND (t, 2) = NULL_TREE;
1989       return t;
1990
1991     case NEW_EXPR:
1992       t = copy_node (t);
1993       TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1994       TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
1995       TREE_OPERAND (t, 2) = mapcar (TREE_OPERAND (t, 2), func);
1996       return t;
1997
1998     case LOOKUP_EXPR:
1999       t = copy_node (t);
2000       TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
2001       return t;
2002
2003     case RECORD_TYPE:
2004       if (TYPE_PTRMEMFUNC_P (t))
2005         return build_ptrmemfunc_type
2006           (mapcar (TYPE_PTRMEMFUNC_FN_TYPE (t), func));
2007       /* else fall through */
2008
2009       /*  This list is incomplete, but should suffice for now.
2010           It is very important that `sorry' not call
2011           `report_error_function'.  That could cause an infinite loop.  */
2012     default:
2013       sorry ("initializer contains unrecognized tree code");
2014       return error_mark_node;
2015
2016     }
2017   my_friendly_abort (107);
2018   /* NOTREACHED */
2019   return NULL_TREE;
2020 }
2021
2022 static tree
2023 perm_manip (t)
2024      tree t;
2025 {
2026   if (TREE_PERMANENT (t))
2027     return t;
2028
2029   /* Support `void f () { extern int i; A<&i> a; }' */
2030   if ((TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == FUNCTION_DECL)
2031       && TREE_PUBLIC (t))
2032     {
2033       t = copy_node (t);
2034
2035       /* copy_rtx won't make a new SYMBOL_REF, so call make_decl_rtl again.  */
2036       DECL_RTL (t) = 0;
2037       make_decl_rtl (t, NULL_PTR, 1);
2038
2039       return t;
2040     }
2041   return NULL_TREE;
2042 }
2043
2044 /* Assuming T is a node built bottom-up, make it all exist on
2045    permanent obstack, if it is not permanent already.  */
2046
2047 tree
2048 copy_to_permanent (t)
2049      tree t;
2050 {
2051   if (t == NULL_TREE || TREE_PERMANENT (t))
2052     return t;
2053
2054   push_obstacks_nochange ();
2055   end_temporary_allocation ();
2056
2057   t = mapcar (t, perm_manip);
2058
2059   pop_obstacks ();
2060
2061   return t;
2062 }
2063
2064 #ifdef GATHER_STATISTICS
2065 extern int depth_reached;
2066 #endif
2067
2068 void
2069 print_lang_statistics ()
2070 {
2071   extern struct obstack decl_obstack;
2072   print_obstack_statistics ("class_obstack", &class_obstack);
2073   print_obstack_statistics ("decl_obstack", &decl_obstack);
2074   print_search_statistics ();
2075   print_class_statistics ();
2076 #ifdef GATHER_STATISTICS
2077   fprintf (stderr, "maximum template instantiation depth reached: %d\n",
2078            depth_reached);
2079 #endif
2080 }
2081
2082 /* This is used by the `assert' macro.  It is provided in libgcc.a,
2083    which `cc' doesn't know how to link.  Note that the C++ front-end
2084    no longer actually uses the `assert' macro (instead, it calls
2085    my_friendly_assert).  But all of the back-end files still need this.  */
2086
2087 void
2088 __eprintf (string, expression, line, filename)
2089 #ifdef __STDC__
2090      const char *string;
2091      const char *expression;
2092      unsigned line;
2093      const char *filename;
2094 #else
2095      char *string;
2096      char *expression;
2097      unsigned line;
2098      char *filename;
2099 #endif
2100 {
2101   fprintf (stderr, string, expression, line, filename);
2102   fflush (stderr);
2103   abort ();
2104 }
2105
2106 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2107    (which is an ARRAY_TYPE).  This counts only elements of the top
2108    array.  */
2109
2110 tree
2111 array_type_nelts_top (type)
2112      tree type;
2113 {
2114   return fold (build (PLUS_EXPR, sizetype,
2115                       array_type_nelts (type),
2116                       integer_one_node));
2117 }
2118
2119 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2120    (which is an ARRAY_TYPE).  This one is a recursive count of all
2121    ARRAY_TYPEs that are clumped together.  */
2122
2123 tree
2124 array_type_nelts_total (type)
2125      tree type;
2126 {
2127   tree sz = array_type_nelts_top (type);
2128   type = TREE_TYPE (type);
2129   while (TREE_CODE (type) == ARRAY_TYPE)
2130     {
2131       tree n = array_type_nelts_top (type);
2132       sz = fold (build (MULT_EXPR, sizetype, sz, n));
2133       type = TREE_TYPE (type);
2134     }
2135   return sz;
2136 }
2137
2138 static
2139 tree
2140 bot_manip (t)
2141      tree t;
2142 {
2143   if (TREE_CODE (t) != TREE_LIST && ! TREE_SIDE_EFFECTS (t))
2144     return t;
2145   else if (TREE_CODE (t) == TARGET_EXPR)
2146     {
2147       if (TREE_CODE (TREE_OPERAND (t, 1)) == AGGR_INIT_EXPR)
2148         {
2149           mark_used (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t, 1), 0), 0));
2150           return build_cplus_new
2151             (TREE_TYPE (t), break_out_target_exprs (TREE_OPERAND (t, 1)));
2152         }
2153       t = copy_node (t);
2154       TREE_OPERAND (t, 0) = build (VAR_DECL, TREE_TYPE (t));
2155       layout_decl (TREE_OPERAND (t, 0), 0);
2156       return t;
2157     }
2158   else if (TREE_CODE (t) == CALL_EXPR)
2159     mark_used (TREE_OPERAND (TREE_OPERAND (t, 0), 0));
2160
2161   return NULL_TREE;
2162 }
2163
2164 /* Actually, we'll just clean out the target exprs for the moment.  */
2165
2166 tree
2167 break_out_target_exprs (t)
2168      tree t;
2169 {
2170   return mapcar (t, bot_manip);
2171 }
2172
2173 /* Obstack used for allocating nodes in template function and variable
2174    definitions.  */
2175
2176 /* Similar to `build_nt', except we build
2177    on the permanent_obstack, regardless.  */
2178
2179 tree
2180 build_min_nt VPROTO((enum tree_code code, ...))
2181 {
2182 #ifndef __STDC__
2183   enum tree_code code;
2184 #endif
2185   register struct obstack *ambient_obstack = expression_obstack;
2186   va_list p;
2187   register tree t;
2188   register int length;
2189   register int i;
2190
2191   VA_START (p, code);
2192
2193 #ifndef __STDC__
2194   code = va_arg (p, enum tree_code);
2195 #endif
2196
2197   expression_obstack = &permanent_obstack;
2198
2199   t = make_node (code);
2200   length = tree_code_length[(int) code];
2201   TREE_COMPLEXITY (t) = lineno;
2202
2203   for (i = 0; i < length; i++)
2204     {
2205       tree x = va_arg (p, tree);
2206       TREE_OPERAND (t, i) = copy_to_permanent (x);
2207     }
2208
2209   va_end (p);
2210   expression_obstack = ambient_obstack;
2211   return t;
2212 }
2213
2214 /* Similar to `build', except we build
2215    on the permanent_obstack, regardless.  */
2216
2217 tree
2218 build_min VPROTO((enum tree_code code, tree tt, ...))
2219 {
2220 #ifndef __STDC__
2221   enum tree_code code;
2222   tree tt;
2223 #endif
2224   register struct obstack *ambient_obstack = expression_obstack;
2225   va_list p;
2226   register tree t;
2227   register int length;
2228   register int i;
2229
2230   VA_START (p, tt);
2231
2232 #ifndef __STDC__
2233   code = va_arg (p, enum tree_code);
2234   tt = va_arg (p, tree);
2235 #endif
2236
2237   expression_obstack = &permanent_obstack;
2238
2239   t = make_node (code);
2240   length = tree_code_length[(int) code];
2241   TREE_TYPE (t) = copy_to_permanent (tt);
2242   TREE_COMPLEXITY (t) = lineno;
2243
2244   for (i = 0; i < length; i++)
2245     {
2246       tree x = va_arg (p, tree);
2247       TREE_OPERAND (t, i) = copy_to_permanent (x);
2248     }
2249
2250   va_end (p);
2251   expression_obstack = ambient_obstack;
2252   return t;
2253 }
2254
2255 /* Same as `tree_cons' but make a permanent object.  */
2256
2257 tree
2258 min_tree_cons (purpose, value, chain)
2259      tree purpose, value, chain;
2260 {
2261   register tree node;
2262   register struct obstack *ambient_obstack = current_obstack;
2263   current_obstack = &permanent_obstack;
2264
2265   node = tree_cons (copy_to_permanent (purpose),
2266                     copy_to_permanent (value), chain);
2267   current_obstack = ambient_obstack;
2268   return node;
2269 }
2270
2271 tree
2272 get_type_decl (t)
2273      tree t;
2274 {
2275   if (TREE_CODE (t) == TYPE_DECL)
2276     return t;
2277   if (TREE_CODE_CLASS (TREE_CODE (t)) == 't')
2278     return TYPE_STUB_DECL (t);
2279
2280   my_friendly_abort (42);
2281
2282   /* Stop compiler from complaining control reaches end of non-void function.  */
2283   return 0;
2284 }
2285
2286 int
2287 can_free (obstack, t)
2288      struct obstack *obstack;
2289      tree t;
2290 {
2291   int size = 0;
2292
2293   if (TREE_CODE (t) == TREE_VEC)
2294     size = (TREE_VEC_LENGTH (t)-1) * sizeof (tree) + sizeof (struct tree_vec);
2295   else
2296     my_friendly_abort (42);
2297
2298 #define ROUND(x) ((x + obstack_alignment_mask (obstack)) \
2299                   & ~ obstack_alignment_mask (obstack))
2300   if ((char *)t + ROUND (size) == obstack_next_free (obstack))
2301     return 1;
2302 #undef ROUND
2303
2304   return 0;
2305 }
2306
2307 /* Return first vector element whose BINFO_TYPE is ELEM.
2308    Return 0 if ELEM is not in VEC.  VEC may be NULL_TREE.  */
2309
2310 tree
2311 vec_binfo_member (elem, vec)
2312      tree elem, vec;
2313 {
2314   int i;
2315
2316   if (vec)
2317     for (i = 0; i < TREE_VEC_LENGTH (vec); ++i)
2318       if (comptypes (elem, BINFO_TYPE (TREE_VEC_ELT (vec, i)), 1))
2319         return TREE_VEC_ELT (vec, i);
2320
2321   return NULL_TREE;
2322 }
2323
2324 /* Kludge around the fact that DECL_CONTEXT for virtual functions returns
2325    the wrong thing for decl_function_context.  Hopefully the uses in the
2326    backend won't matter, since we don't need a static chain for local class
2327    methods.  FIXME!  */
2328
2329 tree
2330 hack_decl_function_context (decl)
2331      tree decl;
2332 {
2333   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_FUNCTION_MEMBER_P (decl))
2334     return decl_function_context (TYPE_MAIN_DECL (DECL_CLASS_CONTEXT (decl)));
2335   return decl_function_context (decl);
2336 }
2337
2338 /* Return truthvalue of whether T1 is the same tree structure as T2.
2339    Return 1 if they are the same.
2340    Return 0 if they are understandably different.
2341    Return -1 if either contains tree structure not understood by
2342    this function.  */
2343
2344 int
2345 cp_tree_equal (t1, t2)
2346      tree t1, t2;
2347 {
2348   register enum tree_code code1, code2;
2349   int cmp;
2350
2351   if (t1 == t2)
2352     return 1;
2353   if (t1 == 0 || t2 == 0)
2354     return 0;
2355
2356   code1 = TREE_CODE (t1);
2357   code2 = TREE_CODE (t2);
2358
2359   if (code1 == NOP_EXPR || code1 == CONVERT_EXPR || code1 == NON_LVALUE_EXPR)
2360     {
2361       if (code2 == NOP_EXPR || code2 == CONVERT_EXPR || code2 == NON_LVALUE_EXPR)
2362         return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2363       else
2364         return cp_tree_equal (TREE_OPERAND (t1, 0), t2);
2365     }
2366   else if (code2 == NOP_EXPR || code2 == CONVERT_EXPR
2367            || code2 == NON_LVALUE_EXPR)
2368     return cp_tree_equal (t1, TREE_OPERAND (t2, 0));
2369
2370   if (code1 != code2)
2371     return 0;
2372
2373   switch (code1)
2374     {
2375     case INTEGER_CST:
2376       return TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
2377         && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2);
2378
2379     case REAL_CST:
2380       return REAL_VALUES_EQUAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
2381
2382     case STRING_CST:
2383       return TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
2384         && !bcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
2385                   TREE_STRING_LENGTH (t1));
2386
2387     case CONSTRUCTOR:
2388       /* We need to do this when determining whether or not two
2389          non-type pointer to member function template arguments
2390          are the same.  */
2391       if (!(comptypes (TREE_TYPE (t1), TREE_TYPE (t2), 1)
2392             /* The first operand is RTL.  */
2393             && TREE_OPERAND (t1, 0) == TREE_OPERAND (t2, 0)))
2394         return 0;
2395       return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
2396
2397     case TREE_LIST:
2398       cmp = cp_tree_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2));
2399       if (cmp <= 0)
2400         return cmp;
2401       cmp = cp_tree_equal (TREE_VALUE (t1), TREE_VALUE (t2));
2402       if (cmp <= 0)
2403         return cmp;
2404       return cp_tree_equal (TREE_CHAIN (t1), TREE_CHAIN (t2));
2405
2406     case SAVE_EXPR:
2407       return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2408
2409     case CALL_EXPR:
2410       cmp = cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2411       if (cmp <= 0)
2412         return cmp;
2413       return simple_cst_list_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
2414
2415     case TARGET_EXPR:
2416       /* Special case: if either target is an unallocated VAR_DECL,
2417          it means that it's going to be unified with whatever the
2418          TARGET_EXPR is really supposed to initialize, so treat it
2419          as being equivalent to anything.  */
2420       if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL
2421            && DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE
2422            && DECL_RTL (TREE_OPERAND (t1, 0)) == 0)
2423           || (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL
2424               && DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE
2425               && DECL_RTL (TREE_OPERAND (t2, 0)) == 0))
2426         cmp = 1;
2427       else
2428         cmp = cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2429       if (cmp <= 0)
2430         return cmp;
2431       return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
2432
2433     case WITH_CLEANUP_EXPR:
2434       cmp = cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2435       if (cmp <= 0)
2436         return cmp;
2437       return cp_tree_equal (TREE_OPERAND (t1, 2), TREE_OPERAND (t1, 2));
2438
2439     case COMPONENT_REF:
2440       if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1))
2441         return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2442       return 0;
2443
2444     case VAR_DECL:
2445     case PARM_DECL:
2446     case CONST_DECL:
2447     case FUNCTION_DECL:
2448       return 0;
2449
2450     case TEMPLATE_PARM_INDEX:
2451       return TEMPLATE_PARM_IDX (t1) == TEMPLATE_PARM_IDX (t2)
2452         && TEMPLATE_PARM_LEVEL (t1) == TEMPLATE_PARM_LEVEL (t2);
2453
2454     case SIZEOF_EXPR:
2455     case ALIGNOF_EXPR:
2456       if (TREE_CODE (TREE_OPERAND (t1, 0)) != TREE_CODE (TREE_OPERAND (t2, 0)))
2457         return 0;
2458       if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (t1, 0))) == 't')
2459         return comptypes (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0), 1);
2460       break;
2461
2462     case PTRMEM_CST:
2463       /* Two pointer-to-members are the same if they point to the same
2464          field or function in the same class.  */
2465       return (PTRMEM_CST_MEMBER (t1) == PTRMEM_CST_MEMBER (t2)
2466               && comptypes (PTRMEM_CST_CLASS (t1), PTRMEM_CST_CLASS (t2),
2467                             1));
2468
2469     default:
2470       break;
2471     }
2472
2473   switch (TREE_CODE_CLASS (code1))
2474     {
2475       int i;
2476     case '1':
2477     case '2':
2478     case '<':
2479     case 'e':
2480     case 'r':
2481     case 's':
2482       cmp = 1;
2483       for (i=0; i<tree_code_length[(int) code1]; ++i)
2484         {
2485           cmp = cp_tree_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i));
2486           if (cmp <= 0)
2487             return cmp;
2488         }
2489       return cmp;
2490     }
2491
2492   return -1;
2493 }
2494
2495 /* Similar to make_tree_vec, but build on a temporary obstack.  */
2496
2497 tree
2498 make_temp_vec (len)
2499      int len;
2500 {
2501   register tree node;
2502   register struct obstack *ambient_obstack = current_obstack;
2503   current_obstack = expression_obstack;
2504   node = make_tree_vec (len);
2505   current_obstack = ambient_obstack;
2506   return node;
2507 }
2508
2509 /* Build a wrapper around some pointer PTR so we can use it as a tree.  */
2510
2511 tree
2512 build_ptr_wrapper (ptr)
2513      void *ptr;
2514 {
2515   tree t = make_node (WRAPPER);
2516   WRAPPER_PTR (t) = ptr;
2517   return t;
2518 }
2519
2520 /* Same, but on the expression_obstack.  */
2521
2522 tree
2523 build_expr_ptr_wrapper (ptr)
2524      void *ptr;
2525 {
2526   tree t;
2527   push_expression_obstack ();
2528   t = build_ptr_wrapper (ptr);
2529   pop_obstacks ();
2530   return t;
2531 }
2532
2533 /* Build a wrapper around some integer I so we can use it as a tree.  */
2534
2535 tree
2536 build_int_wrapper (i)
2537      int i;
2538 {
2539   tree t = make_node (WRAPPER);
2540   WRAPPER_INT (t) = i;
2541   return t;
2542 }
2543
2544 tree
2545 build_srcloc (file, line)
2546      char *file;
2547      int line;
2548 {
2549   tree t;
2550
2551   /* Make sure that we put these on the permanent obstack; up in
2552      add_pending_template, we pass this return value into perm_tree_cons,
2553      which also puts it on the permanent_obstack.  However, this wasn't
2554      explicitly doing the same.  */
2555   register struct obstack *ambient_obstack = current_obstack;
2556   current_obstack = &permanent_obstack;
2557
2558   t = make_node (SRCLOC);
2559   SRCLOC_FILE (t) = file;
2560   SRCLOC_LINE (t) = line;
2561
2562   current_obstack = ambient_obstack;
2563
2564   return t;
2565 }
2566
2567 tree
2568 build_srcloc_here ()
2569 {
2570   return build_srcloc (input_filename, lineno);
2571 }
2572
2573 void
2574 push_expression_obstack ()
2575 {
2576   push_obstacks_nochange ();
2577   current_obstack = expression_obstack;
2578 }
2579
2580 /* The type of ARG when used as an lvalue.  */
2581
2582 tree
2583 lvalue_type (arg)
2584      tree arg;
2585 {
2586   tree type = TREE_TYPE (arg);
2587   if (TREE_CODE (arg) == OVERLOAD)
2588     type = unknown_type_node;
2589   return type;
2590 }
2591
2592 /* The type of ARG for printing error messages; denote lvalues with
2593    reference types.  */
2594
2595 tree
2596 error_type (arg)
2597      tree arg;
2598 {
2599   tree type = TREE_TYPE (arg);
2600   if (TREE_CODE (type) == ARRAY_TYPE)
2601     ;
2602   else if (real_lvalue_p (arg))
2603     type = build_reference_type (lvalue_type (arg));
2604   else if (IS_AGGR_TYPE (type))
2605     type = lvalue_type (arg);
2606
2607   return type;
2608 }
2609
2610 /* Does FUNCTION use a variable-length argument list?  */
2611
2612 int
2613 varargs_function_p (function)
2614      tree function;
2615 {
2616   tree parm = TYPE_ARG_TYPES (TREE_TYPE (function));
2617   for (; parm; parm = TREE_CHAIN (parm))
2618     if (TREE_VALUE (parm) == void_type_node)
2619       return 0;
2620   return 1;
2621 }
2622
2623 /* Returns 1 if decl is a member of a class.  */
2624
2625 int
2626 member_p (decl)
2627      tree decl;
2628 {
2629   tree ctx = DECL_CONTEXT (decl);
2630   return (ctx && TREE_CODE_CLASS (TREE_CODE (ctx)) == 't');
2631 }
2632
2633 /* Create a placeholder for member access where we don't actually have an
2634    object that the access is against.  */
2635
2636 tree
2637 build_dummy_object (type)
2638      tree type;
2639 {
2640   tree decl = build1 (NOP_EXPR, build_pointer_type (type), error_mark_node);
2641   return build_indirect_ref (decl, NULL_PTR);
2642 }
2643
2644 /* We've gotten a reference to a member of TYPE.  Return *this if appropriate,
2645    or a dummy object otherwise.  If BINFOP is non-0, it is filled with the
2646    binfo path from current_class_type to TYPE, or 0.  */
2647
2648 tree
2649 maybe_dummy_object (type, binfop)
2650      tree type;
2651      tree *binfop;
2652 {
2653   tree decl, context;
2654
2655   if (current_class_type
2656       && get_base_distance (type, current_class_type, 0, binfop) != -1)
2657     context = current_class_type;
2658   else
2659     {
2660       /* Reference from a nested class member function.  */
2661       context = type;
2662       if (binfop)
2663         *binfop = TYPE_BINFO (type);
2664     }
2665
2666   if (current_class_ref && context == current_class_type)
2667     decl = current_class_ref;
2668   else
2669     decl = build_dummy_object (context);
2670
2671   return decl;
2672 }
2673
2674 /* Returns 1 if OB is a placeholder object, or a pointer to one.  */
2675
2676 int
2677 is_dummy_object (ob)
2678      tree ob;
2679 {
2680   if (TREE_CODE (ob) == INDIRECT_REF)
2681     ob = TREE_OPERAND (ob, 0);
2682   return (TREE_CODE (ob) == NOP_EXPR
2683           && TREE_OPERAND (ob, 0) == error_mark_node);
2684 }