gcc/cp/tree.c

   1 /* Language-dependent node constructors for parse phase of GNU compiler.
   2    Copyright (C) 1987, 88, 92-97, 1998 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 (uses_template_parms (elt_type)
 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      As is an expression like X::f.  */
1299   if (TREE_CODE (x) == TREE_LIST)
1300     {
1301       if (TREE_PURPOSE (x) == error_mark_node)
1302         {
1303           x = TREE_VALUE (x);
1304           my_friendly_assert (TREE_CODE (x) == TREE_LIST, 981121);
1305         }
1306       my_friendly_assert (TREE_CODE (TREE_PURPOSE (x)) == TREE_VEC
1307                           || TREE_CODE (TREE_PURPOSE (x)) == IDENTIFIER_NODE,
1308                           388);
1309       x = TREE_VALUE (x);
1310     }
1311   return (TREE_CODE (x) == FUNCTION_DECL
1312           || TREE_CODE (x) == TEMPLATE_ID_EXPR
1313           || DECL_FUNCTION_TEMPLATE_P (x)
1314           || TREE_CODE (x) == OVERLOAD);
1315 }
1316
1317 int
1318 really_overloaded_fn (x)
1319      tree x;
1320 {
1321   /* A baselink is also considered an overloaded function.
1322      This might also be an ambiguous class member. */
1323   if (TREE_CODE (x) == TREE_LIST)
1324     x = TREE_VALUE (x);
1325   return (TREE_CODE (x) == OVERLOAD
1326           && (TREE_CHAIN (x) != NULL_TREE
1327               || DECL_FUNCTION_TEMPLATE_P (OVL_FUNCTION (x))));
1328 }
1329
1330 tree
1331 get_first_fn (from)
1332      tree from;
1333 {
1334   my_friendly_assert (is_overloaded_fn (from), 9);
1335   /* A baselink is also considered an overloaded function. */
1336   if (TREE_CODE (from) == TREE_LIST)
1337     from = TREE_VALUE (from);
1338   return OVL_CURRENT (from);
1339 }
1340
1341 /* Returns nonzero if T is a ->* or .* expression that refers to a
1342    member function.  */
1343
1344 int
1345 bound_pmf_p (t)
1346      tree t;
1347 {
1348   return (TREE_CODE (t) == OFFSET_REF
1349           && TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (t, 1))));
1350 }
1351
1352 /* Return a new OVL node, concatenating it with the old one. */
1353
1354 tree
1355 ovl_cons (decl, chain)
1356      tree decl;
1357      tree chain;
1358 {
1359   tree result = make_node (OVERLOAD);
1360   TREE_TYPE (result) = unknown_type_node;
1361   OVL_FUNCTION (result) = decl;
1362   TREE_CHAIN (result) = chain;
1363
1364   return result;
1365 }
1366
1367 /* Same as ovl_cons, but on the scratch_obstack. */
1368
1369 tree
1370 scratch_ovl_cons (value, chain)
1371      tree value, chain;
1372 {
1373   register tree node;
1374   register struct obstack *ambient_obstack = current_obstack;
1375   extern struct obstack *expression_obstack;
1376   current_obstack = expression_obstack;
1377   node = ovl_cons (value, chain);
1378   current_obstack = ambient_obstack;
1379   return node;
1380 }
1381
1382 /* Build a new overloaded function. If this is the first one,
1383    just return it; otherwise, ovl_cons the _DECLs */
1384
1385 tree
1386 build_overload (decl, chain)
1387      tree decl;
1388      tree chain;
1389 {
1390   if (! chain && TREE_CODE (decl) != TEMPLATE_DECL)
1391     return decl;
1392   if (chain && TREE_CODE (chain) != OVERLOAD)
1393     chain = ovl_cons (chain, NULL_TREE);
1394   return ovl_cons (decl, chain);
1395 }
1396
1397 /* True if fn is in ovl. */
1398
1399 int
1400 ovl_member (fn, ovl)
1401      tree fn;
1402      tree ovl;
1403 {
1404   if (ovl == NULL_TREE)
1405     return 0;
1406   if (TREE_CODE (ovl) != OVERLOAD)
1407     return decls_match (ovl, fn);
1408   for (; ovl; ovl = OVL_CHAIN (ovl))
1409     if (decls_match (OVL_FUNCTION (ovl), fn))
1410       return 1;
1411   return 0;
1412 }
1413
1414 int
1415 is_aggr_type_2 (t1, t2)
1416      tree t1, t2;
1417 {
1418   if (TREE_CODE (t1) != TREE_CODE (t2))
1419     return 0;
1420   return IS_AGGR_TYPE (t1) && IS_AGGR_TYPE (t2);
1421 }
1422 \f
1423 #define PRINT_RING_SIZE 4
1424
1425 char *
1426 lang_printable_name (decl, v)
1427      tree decl;
1428      int v;
1429 {
1430   static tree decl_ring[PRINT_RING_SIZE];
1431   static char *print_ring[PRINT_RING_SIZE];
1432   static int ring_counter;
1433   int i;
1434
1435   /* Only cache functions.  */
1436   if (v < 2
1437       || TREE_CODE (decl) != FUNCTION_DECL
1438       || DECL_LANG_SPECIFIC (decl) == 0)
1439     return lang_decl_name (decl, v);
1440
1441   /* See if this print name is lying around.  */
1442   for (i = 0; i < PRINT_RING_SIZE; i++)
1443     if (decl_ring[i] == decl)
1444       /* yes, so return it.  */
1445       return print_ring[i];
1446
1447   if (++ring_counter == PRINT_RING_SIZE)
1448     ring_counter = 0;
1449
1450   if (current_function_decl != NULL_TREE)
1451     {
1452       if (decl_ring[ring_counter] == current_function_decl)
1453         ring_counter += 1;
1454       if (ring_counter == PRINT_RING_SIZE)
1455         ring_counter = 0;
1456       if (decl_ring[ring_counter] == current_function_decl)
1457         my_friendly_abort (106);
1458     }
1459
1460   if (print_ring[ring_counter])
1461     free (print_ring[ring_counter]);
1462
1463   print_ring[ring_counter] = xstrdup (lang_decl_name (decl, v));
1464   decl_ring[ring_counter] = decl;
1465   return print_ring[ring_counter];
1466 }
1467 \f
1468 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
1469    listed in RAISES.  */
1470
1471 tree
1472 build_exception_variant (type, raises)
1473      tree type;
1474      tree raises;
1475 {
1476   tree v = TYPE_MAIN_VARIANT (type);
1477   int type_quals = TYPE_QUALS (type);
1478
1479   for (; v; v = TYPE_NEXT_VARIANT (v))
1480     {
1481       tree t;
1482       tree u;
1483
1484       if (TYPE_QUALS (v) != type_quals)
1485         continue;
1486
1487       for (t = TYPE_RAISES_EXCEPTIONS (v), u = raises;
1488            t != NULL_TREE && u != NULL_TREE;
1489            t = TREE_CHAIN (t), u = TREE_CHAIN (v))
1490         if (((TREE_VALUE (t) != NULL_TREE)
1491              != (TREE_VALUE (u) != NULL_TREE))
1492             || !same_type_p (TREE_VALUE (t), TREE_VALUE (u)))
1493           break;
1494
1495       if (!t && !u)
1496         /* There's a memory leak here; RAISES is not freed.  */
1497         return v;
1498     }
1499
1500   /* Need to build a new variant.  */
1501   v = build_type_copy (type);
1502
1503   if (raises && ! TREE_PERMANENT (raises))
1504     {
1505       push_obstacks_nochange ();
1506       end_temporary_allocation ();
1507       raises = copy_list (raises);
1508       pop_obstacks ();
1509     }
1510
1511   TYPE_RAISES_EXCEPTIONS (v) = raises;
1512   return v;
1513 }
1514
1515 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new one together with its
1516    lang_specific field and its corresponding TEMPLATE_DECL node */
1517
1518 tree
1519 copy_template_template_parm (t)
1520      tree t;
1521 {
1522   tree template = TYPE_NAME (t);
1523   tree t2 = make_lang_type (TEMPLATE_TEMPLATE_PARM);
1524   template = copy_node (template);
1525   copy_lang_decl (template);
1526   TREE_TYPE (template) = t2;
1527   TYPE_NAME (t2) = template;
1528   TYPE_STUB_DECL (t2) = template;
1529
1530   /* No need to copy these */
1531   TYPE_FIELDS (t2) = TYPE_FIELDS (t);
1532   TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2)
1533     = TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t);
1534   return t2;
1535 }
1536
1537 /* Walk through the tree structure T, applying func.  If func ever returns
1538    non-null, return that value.  */
1539
1540 static tree
1541 search_tree (t, func)
1542      tree t;
1543      tree (*func) PROTO((tree));
1544 {
1545 #define TRY(ARG) if (tmp=search_tree (ARG, func), tmp != NULL_TREE) return tmp
1546
1547   tree tmp;
1548
1549   if (t == NULL_TREE)
1550     return t;
1551
1552   if (tmp = func (t), tmp != NULL_TREE)
1553     return tmp;
1554
1555   switch (TREE_CODE (t))
1556     {
1557     case ERROR_MARK:
1558       break;
1559
1560     case IDENTIFIER_NODE:
1561       break;
1562
1563     case VAR_DECL:
1564     case FUNCTION_DECL:
1565     case CONST_DECL:
1566     case TEMPLATE_DECL:
1567     case NAMESPACE_DECL:
1568       break;
1569
1570     case TYPE_DECL:
1571       TRY (TREE_TYPE (t));
1572       break;
1573
1574     case PARM_DECL:
1575       TRY (TREE_TYPE (t));
1576       TRY (TREE_CHAIN (t));
1577       break;
1578
1579     case TREE_LIST:
1580       TRY (TREE_PURPOSE (t));
1581       TRY (TREE_VALUE (t));
1582       TRY (TREE_CHAIN (t));
1583       break;
1584
1585     case OVERLOAD:
1586       TRY (OVL_FUNCTION (t));
1587       TRY (OVL_CHAIN (t));
1588       break;
1589
1590     case TREE_VEC:
1591       {
1592         int len = TREE_VEC_LENGTH (t);
1593
1594         t = copy_node (t);
1595         while (len--)
1596           TRY (TREE_VEC_ELT (t, len));
1597       }
1598       break;
1599
1600     case INTEGER_CST:
1601     case REAL_CST:
1602     case STRING_CST:
1603     case DEFAULT_ARG:
1604       break;
1605
1606     case PTRMEM_CST:
1607       TRY (TREE_TYPE (t));
1608       break;
1609
1610     case COND_EXPR:
1611     case TARGET_EXPR:
1612     case AGGR_INIT_EXPR:
1613     case NEW_EXPR:
1614       TRY (TREE_OPERAND (t, 0));
1615       TRY (TREE_OPERAND (t, 1));
1616       TRY (TREE_OPERAND (t, 2));
1617       break;
1618
1619     case MODIFY_EXPR:
1620     case PLUS_EXPR:
1621     case MINUS_EXPR:
1622     case MULT_EXPR:
1623     case TRUNC_DIV_EXPR:
1624     case TRUNC_MOD_EXPR:
1625     case MIN_EXPR:
1626     case MAX_EXPR:
1627     case LSHIFT_EXPR:
1628     case RSHIFT_EXPR:
1629     case BIT_IOR_EXPR:
1630     case BIT_XOR_EXPR:
1631     case BIT_AND_EXPR:
1632     case BIT_ANDTC_EXPR:
1633     case TRUTH_ANDIF_EXPR:
1634     case TRUTH_ORIF_EXPR:
1635     case LT_EXPR:
1636     case LE_EXPR:
1637     case GT_EXPR:
1638     case GE_EXPR:
1639     case EQ_EXPR:
1640     case NE_EXPR:
1641     case CEIL_DIV_EXPR:
1642     case FLOOR_DIV_EXPR:
1643     case ROUND_DIV_EXPR:
1644     case CEIL_MOD_EXPR:
1645     case FLOOR_MOD_EXPR:
1646     case ROUND_MOD_EXPR:
1647     case COMPOUND_EXPR:
1648     case PREDECREMENT_EXPR:
1649     case PREINCREMENT_EXPR:
1650     case POSTDECREMENT_EXPR:
1651     case POSTINCREMENT_EXPR:
1652     case ARRAY_REF:
1653     case SCOPE_REF:
1654     case TRY_CATCH_EXPR:
1655     case WITH_CLEANUP_EXPR:
1656     case CALL_EXPR:
1657       TRY (TREE_OPERAND (t, 0));
1658       TRY (TREE_OPERAND (t, 1));
1659       break;
1660
1661     case SAVE_EXPR:
1662     case CONVERT_EXPR:
1663     case ADDR_EXPR:
1664     case INDIRECT_REF:
1665     case NEGATE_EXPR:
1666     case BIT_NOT_EXPR:
1667     case TRUTH_NOT_EXPR:
1668     case NOP_EXPR:
1669     case NON_LVALUE_EXPR:
1670     case COMPONENT_REF:
1671     case CLEANUP_POINT_EXPR:
1672     case LOOKUP_EXPR:
1673     case SIZEOF_EXPR:
1674     case ALIGNOF_EXPR:
1675       TRY (TREE_OPERAND (t, 0));
1676       break;
1677
1678     case MODOP_EXPR:
1679     case CAST_EXPR:
1680     case REINTERPRET_CAST_EXPR:
1681     case CONST_CAST_EXPR:
1682     case STATIC_CAST_EXPR:
1683     case DYNAMIC_CAST_EXPR:
1684     case ARROW_EXPR:
1685     case DOTSTAR_EXPR:
1686     case TYPEID_EXPR:
1687       break;
1688
1689     case COMPLEX_CST:
1690       TRY (TREE_REALPART (t));
1691       TRY (TREE_IMAGPART (t));
1692       break;
1693
1694     case CONSTRUCTOR:
1695       TRY (CONSTRUCTOR_ELTS (t));
1696       break;
1697
1698     case TEMPLATE_TEMPLATE_PARM:
1699     case TEMPLATE_PARM_INDEX:
1700     case TEMPLATE_TYPE_PARM:
1701       break;
1702
1703     case BIND_EXPR:
1704       break;
1705
1706     case REAL_TYPE:
1707     case COMPLEX_TYPE:
1708     case VOID_TYPE:
1709     case BOOLEAN_TYPE:
1710     case TYPENAME_TYPE:
1711     case UNION_TYPE:
1712     case ENUMERAL_TYPE:
1713     case TYPEOF_TYPE:
1714       break;
1715
1716     case POINTER_TYPE:
1717     case REFERENCE_TYPE:
1718       TRY (TREE_TYPE (t));
1719       break;
1720
1721     case FUNCTION_TYPE:
1722     case METHOD_TYPE:
1723       TRY (TREE_TYPE (t));
1724       TRY (TYPE_ARG_TYPES (t));
1725       break;
1726
1727     case ARRAY_TYPE:
1728       TRY (TREE_TYPE (t));
1729       TRY (TYPE_DOMAIN (t));
1730       break;
1731
1732     case INTEGER_TYPE:
1733       TRY (TYPE_MAX_VALUE (t));
1734       break;
1735
1736     case OFFSET_TYPE:
1737       TRY (TREE_TYPE (t));
1738       TRY (TYPE_OFFSET_BASETYPE (t));
1739       break;
1740
1741     case RECORD_TYPE:
1742       if (TYPE_PTRMEMFUNC_P (t))
1743         TRY (TYPE_PTRMEMFUNC_FN_TYPE (t));
1744       break;
1745
1746       /*  This list is incomplete, but should suffice for now.
1747           It is very important that `sorry' not call
1748           `report_error_function'.  That could cause an infinite loop.  */
1749     default:
1750       sorry ("initializer contains unrecognized tree code");
1751       return error_mark_node;
1752
1753     }
1754
1755   return NULL_TREE;
1756
1757 #undef TRY
1758 }
1759
1760 /* Passed to search_tree.  Checks for the use of types with no linkage.  */
1761
1762 static tree
1763 no_linkage_helper (t)
1764      tree t;
1765 {
1766   if (TYPE_P (t)
1767       && (IS_AGGR_TYPE (t) || TREE_CODE (t) == ENUMERAL_TYPE)
1768       && (decl_function_context (TYPE_MAIN_DECL (t))
1769           || ANON_AGGRNAME_P (TYPE_IDENTIFIER (t))))
1770     return t;
1771   return NULL_TREE;
1772 }
1773
1774 /* Check if the type T depends on a type with no linkage and if so, return
1775    it.  */
1776
1777 tree
1778 no_linkage_check (t)
1779      tree t;
1780 {
1781   t = search_tree (t, no_linkage_helper);
1782   if (t != error_mark_node)
1783     return t;
1784   return NULL_TREE;
1785 }
1786
1787
1788 /* Subroutine of copy_to_permanent
1789
1790    Assuming T is a node build bottom-up, make it all exist on
1791    permanent obstack, if it is not permanent already.  */
1792
1793 tree
1794 mapcar (t, func)
1795      tree t;
1796      tree (*func) PROTO((tree));
1797 {
1798   tree tmp;
1799
1800   if (t == NULL_TREE)
1801     return t;
1802
1803   if (tmp = func (t), tmp != NULL_TREE)
1804     return tmp;
1805
1806   switch (TREE_CODE (t))
1807     {
1808     case ERROR_MARK:
1809       return error_mark_node;
1810
1811     case VAR_DECL:
1812     case FUNCTION_DECL:
1813     case CONST_DECL:
1814       /* Rather than aborting, return error_mark_node.  This allows us
1815          to report a sensible error message on code like this:
1816
1817          void g() { int i; f<i>(7); }
1818
1819          In a case like:
1820
1821            void g() { const int i = 7; f<i>(7); }
1822
1823          however, we must actually return the constant initializer.  */
1824       tmp = decl_constant_value (t);
1825       if (tmp != t)
1826         return mapcar (tmp, func);
1827       else
1828         return error_mark_node;
1829
1830     case PARM_DECL:
1831       {
1832         tree chain = TREE_CHAIN (t);
1833         t = copy_node (t);
1834         TREE_CHAIN (t) = mapcar (chain, func);
1835         TREE_TYPE (t) = mapcar (TREE_TYPE (t), func);
1836         DECL_INITIAL (t) = mapcar (DECL_INITIAL (t), func);
1837         DECL_SIZE (t) = mapcar (DECL_SIZE (t), func);
1838         return t;
1839       }
1840
1841     case TREE_LIST:
1842       {
1843         tree chain = TREE_CHAIN (t);
1844         t = copy_node (t);
1845         TREE_PURPOSE (t) = mapcar (TREE_PURPOSE (t), func);
1846         TREE_VALUE (t) = mapcar (TREE_VALUE (t), func);
1847         TREE_CHAIN (t) = mapcar (chain, func);
1848         return t;
1849       }
1850
1851     case OVERLOAD:
1852       {
1853         tree chain = OVL_CHAIN (t);
1854         t = copy_node (t);
1855         OVL_FUNCTION (t) = mapcar (OVL_FUNCTION (t), func);
1856         OVL_CHAIN (t) = mapcar (chain, func);
1857         return t;
1858       }
1859
1860     case TREE_VEC:
1861       {
1862         int len = TREE_VEC_LENGTH (t);
1863
1864         t = copy_node (t);
1865         while (len--)
1866           TREE_VEC_ELT (t, len) = mapcar (TREE_VEC_ELT (t, len), func);
1867         return t;
1868       }
1869
1870     case INTEGER_CST:
1871     case REAL_CST:
1872     case STRING_CST:
1873       return copy_node (t);
1874
1875     case PTRMEM_CST:
1876       t = copy_node (t);
1877       TREE_TYPE (t) = mapcar (TREE_TYPE (t), func);
1878       PTRMEM_CST_MEMBER (t) = mapcar (PTRMEM_CST_MEMBER (t), func);
1879       return t;
1880
1881     case COND_EXPR:
1882     case TARGET_EXPR:
1883     case AGGR_INIT_EXPR:
1884       t = copy_node (t);
1885       TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1886       TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
1887       TREE_OPERAND (t, 2) = mapcar (TREE_OPERAND (t, 2), func);
1888       return t;
1889
1890     case SAVE_EXPR:
1891       t = copy_node (t);
1892       TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1893       return t;
1894
1895     case MODIFY_EXPR:
1896     case PLUS_EXPR:
1897     case MINUS_EXPR:
1898     case MULT_EXPR:
1899     case TRUNC_DIV_EXPR:
1900     case TRUNC_MOD_EXPR:
1901     case MIN_EXPR:
1902     case MAX_EXPR:
1903     case LSHIFT_EXPR:
1904     case RSHIFT_EXPR:
1905     case BIT_IOR_EXPR:
1906     case BIT_XOR_EXPR:
1907     case BIT_AND_EXPR:
1908     case BIT_ANDTC_EXPR:
1909     case TRUTH_ANDIF_EXPR:
1910     case TRUTH_ORIF_EXPR:
1911     case LT_EXPR:
1912     case LE_EXPR:
1913     case GT_EXPR:
1914     case GE_EXPR:
1915     case EQ_EXPR:
1916     case NE_EXPR:
1917     case CEIL_DIV_EXPR:
1918     case FLOOR_DIV_EXPR:
1919     case ROUND_DIV_EXPR:
1920     case CEIL_MOD_EXPR:
1921     case FLOOR_MOD_EXPR:
1922     case ROUND_MOD_EXPR:
1923     case COMPOUND_EXPR:
1924     case PREDECREMENT_EXPR:
1925     case PREINCREMENT_EXPR:
1926     case POSTDECREMENT_EXPR:
1927     case POSTINCREMENT_EXPR:
1928     case ARRAY_REF:
1929     case SCOPE_REF:
1930     case TRY_CATCH_EXPR:
1931     case WITH_CLEANUP_EXPR:
1932       t = copy_node (t);
1933       TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1934       TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
1935       return t;
1936
1937     case CALL_EXPR:
1938       t = copy_node (t);
1939       TREE_TYPE (t) = mapcar (TREE_TYPE (t), func);
1940       TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1941       TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
1942
1943       /* tree.def says that operand two is RTL, but
1944          make_call_declarator puts trees in there.  */
1945       if (TREE_OPERAND (t, 2)
1946           && TREE_CODE (TREE_OPERAND (t, 2)) == TREE_LIST)
1947         TREE_OPERAND (t, 2) = mapcar (TREE_OPERAND (t, 2), func);
1948       else
1949         TREE_OPERAND (t, 2) = NULL_TREE;
1950       return t;
1951
1952     case CONVERT_EXPR:
1953     case ADDR_EXPR:
1954     case INDIRECT_REF:
1955     case NEGATE_EXPR:
1956     case BIT_NOT_EXPR:
1957     case TRUTH_NOT_EXPR:
1958     case NOP_EXPR:
1959     case COMPONENT_REF:
1960     case CLEANUP_POINT_EXPR:
1961       t = copy_node (t);
1962       TREE_TYPE (t) = mapcar (TREE_TYPE (t), func);
1963       TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1964       return t;
1965
1966     case POINTER_TYPE:
1967       tmp = build_pointer_type (mapcar (TREE_TYPE (t), func));
1968       return cp_build_qualified_type (tmp, TYPE_QUALS (t));
1969     case REFERENCE_TYPE:
1970       tmp = build_reference_type (mapcar (TREE_TYPE (t), func));
1971       return cp_build_qualified_type (tmp, TYPE_QUALS (t));
1972     case FUNCTION_TYPE:
1973       tmp = build_function_type (mapcar (TREE_TYPE (t), func),
1974                                  mapcar (TYPE_ARG_TYPES (t), func));
1975       return cp_build_qualified_type (tmp, TYPE_QUALS (t));
1976     case ARRAY_TYPE:
1977       tmp = build_cplus_array_type (mapcar (TREE_TYPE (t), func),
1978                                     mapcar (TYPE_DOMAIN (t), func));
1979       return cp_build_qualified_type (tmp, CP_TYPE_QUALS (t));
1980     case INTEGER_TYPE:
1981       tmp = build_index_type (mapcar (TYPE_MAX_VALUE (t), func));
1982       return cp_build_qualified_type (tmp, TYPE_QUALS (t));
1983     case OFFSET_TYPE:
1984       tmp = build_offset_type (mapcar (TYPE_OFFSET_BASETYPE (t), func),
1985                                mapcar (TREE_TYPE (t), func));
1986       return cp_build_qualified_type (tmp, TYPE_QUALS (t));
1987     case METHOD_TYPE:
1988       tmp = build_cplus_method_type
1989         (mapcar (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))), func),
1990          mapcar (TREE_TYPE (t), func),
1991          mapcar (TREE_CHAIN (TYPE_ARG_TYPES (t)), func));
1992       return cp_build_qualified_type (tmp, TYPE_QUALS (t));
1993
1994     case COMPLEX_CST:
1995       t = copy_node (t);
1996       TREE_REALPART (t) = mapcar (TREE_REALPART (t), func);
1997       TREE_IMAGPART (t) = mapcar (TREE_REALPART (t), func);
1998       return t;
1999
2000     case CONSTRUCTOR:
2001       t = copy_node (t);
2002       CONSTRUCTOR_ELTS (t) = mapcar (CONSTRUCTOR_ELTS (t), func);
2003       return t;
2004
2005     case TEMPLATE_TEMPLATE_PARM:
2006       return copy_template_template_parm (t);
2007
2008     case BIND_EXPR:
2009       t = copy_node (t);
2010       TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
2011       TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
2012       TREE_OPERAND (t, 2) = NULL_TREE;
2013       return t;
2014
2015     case NEW_EXPR:
2016       t = copy_node (t);
2017       TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
2018       TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
2019       TREE_OPERAND (t, 2) = mapcar (TREE_OPERAND (t, 2), func);
2020       return t;
2021
2022     case LOOKUP_EXPR:
2023       t = copy_node (t);
2024       TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
2025       return t;
2026
2027     case RECORD_TYPE:
2028       if (TYPE_PTRMEMFUNC_P (t))
2029         return build_ptrmemfunc_type
2030           (mapcar (TYPE_PTRMEMFUNC_FN_TYPE (t), func));
2031       /* else fall through */
2032
2033       /*  This list is incomplete, but should suffice for now.
2034           It is very important that `sorry' not call
2035           `report_error_function'.  That could cause an infinite loop.  */
2036     default:
2037       sorry ("initializer contains unrecognized tree code");
2038       return error_mark_node;
2039
2040     }
2041   my_friendly_abort (107);
2042   /* NOTREACHED */
2043   return NULL_TREE;
2044 }
2045
2046 static tree
2047 perm_manip (t)
2048      tree t;
2049 {
2050   if (TREE_PERMANENT (t))
2051     return t;
2052
2053   /* Support `void f () { extern int i; A<&i> a; }' */
2054   if ((TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == FUNCTION_DECL)
2055       && TREE_PUBLIC (t))
2056     {
2057       t = copy_node (t);
2058
2059       /* copy_rtx won't make a new SYMBOL_REF, so call make_decl_rtl again.  */
2060       DECL_RTL (t) = 0;
2061       make_decl_rtl (t, NULL_PTR, 1);
2062
2063       return t;
2064     }
2065   return NULL_TREE;
2066 }
2067
2068 /* Assuming T is a node built bottom-up, make it all exist on
2069    permanent obstack, if it is not permanent already.  */
2070
2071 tree
2072 copy_to_permanent (t)
2073      tree t;
2074 {
2075   if (t == NULL_TREE || TREE_PERMANENT (t))
2076     return t;
2077
2078   push_obstacks_nochange ();
2079   end_temporary_allocation ();
2080
2081   t = mapcar (t, perm_manip);
2082
2083   pop_obstacks ();
2084
2085   return t;
2086 }
2087
2088 #ifdef GATHER_STATISTICS
2089 extern int depth_reached;
2090 #endif
2091
2092 void
2093 print_lang_statistics ()
2094 {
2095   extern struct obstack decl_obstack;
2096   print_obstack_statistics ("class_obstack", &class_obstack);
2097   print_obstack_statistics ("decl_obstack", &decl_obstack);
2098   print_search_statistics ();
2099   print_class_statistics ();
2100 #ifdef GATHER_STATISTICS
2101   fprintf (stderr, "maximum template instantiation depth reached: %d\n",
2102            depth_reached);
2103 #endif
2104 }
2105
2106 /* This is used by the `assert' macro.  It is provided in libgcc.a,
2107    which `cc' doesn't know how to link.  Note that the C++ front-end
2108    no longer actually uses the `assert' macro (instead, it calls
2109    my_friendly_assert).  But all of the back-end files still need this.  */
2110
2111 void
2112 __eprintf (string, expression, line, filename)
2113 #ifdef __STDC__
2114      const char *string;
2115      const char *expression;
2116      unsigned line;
2117      const char *filename;
2118 #else
2119      char *string;
2120      char *expression;
2121      unsigned line;
2122      char *filename;
2123 #endif
2124 {
2125   fprintf (stderr, string, expression, line, filename);
2126   fflush (stderr);
2127   abort ();
2128 }
2129
2130 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2131    (which is an ARRAY_TYPE).  This counts only elements of the top
2132    array.  */
2133
2134 tree
2135 array_type_nelts_top (type)
2136      tree type;
2137 {
2138   return fold (build (PLUS_EXPR, sizetype,
2139                       array_type_nelts (type),
2140                       integer_one_node));
2141 }
2142
2143 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2144    (which is an ARRAY_TYPE).  This one is a recursive count of all
2145    ARRAY_TYPEs that are clumped together.  */
2146
2147 tree
2148 array_type_nelts_total (type)
2149      tree type;
2150 {
2151   tree sz = array_type_nelts_top (type);
2152   type = TREE_TYPE (type);
2153   while (TREE_CODE (type) == ARRAY_TYPE)
2154     {
2155       tree n = array_type_nelts_top (type);
2156       sz = fold (build (MULT_EXPR, sizetype, sz, n));
2157       type = TREE_TYPE (type);
2158     }
2159   return sz;
2160 }
2161
2162 static
2163 tree
2164 bot_manip (t)
2165      tree t;
2166 {
2167   if (TREE_CODE (t) != TREE_LIST && ! TREE_SIDE_EFFECTS (t))
2168     return t;
2169   else if (TREE_CODE (t) == TARGET_EXPR)
2170     {
2171       if (TREE_CODE (TREE_OPERAND (t, 1)) == AGGR_INIT_EXPR)
2172         {
2173           mark_used (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t, 1), 0), 0));
2174           return build_cplus_new
2175             (TREE_TYPE (t), break_out_target_exprs (TREE_OPERAND (t, 1)));
2176         }
2177       t = copy_node (t);
2178       TREE_OPERAND (t, 0) = build (VAR_DECL, TREE_TYPE (t));
2179       layout_decl (TREE_OPERAND (t, 0), 0);
2180       return t;
2181     }
2182   else if (TREE_CODE (t) == CALL_EXPR)
2183     mark_used (TREE_OPERAND (TREE_OPERAND (t, 0), 0));
2184
2185   return NULL_TREE;
2186 }
2187
2188 /* Actually, we'll just clean out the target exprs for the moment.  */
2189
2190 tree
2191 break_out_target_exprs (t)
2192      tree t;
2193 {
2194   return mapcar (t, bot_manip);
2195 }
2196
2197 /* Obstack used for allocating nodes in template function and variable
2198    definitions.  */
2199
2200 /* Similar to `build_nt', except we build
2201    on the permanent_obstack, regardless.  */
2202
2203 tree
2204 build_min_nt VPROTO((enum tree_code code, ...))
2205 {
2206 #ifndef __STDC__
2207   enum tree_code code;
2208 #endif
2209   register struct obstack *ambient_obstack = expression_obstack;
2210   va_list p;
2211   register tree t;
2212   register int length;
2213   register int i;
2214
2215   VA_START (p, code);
2216
2217 #ifndef __STDC__
2218   code = va_arg (p, enum tree_code);
2219 #endif
2220
2221   expression_obstack = &permanent_obstack;
2222
2223   t = make_node (code);
2224   length = tree_code_length[(int) code];
2225   TREE_COMPLEXITY (t) = lineno;
2226
2227   for (i = 0; i < length; i++)
2228     {
2229       tree x = va_arg (p, tree);
2230       TREE_OPERAND (t, i) = copy_to_permanent (x);
2231     }
2232
2233   va_end (p);
2234   expression_obstack = ambient_obstack;
2235   return t;
2236 }
2237
2238 /* Similar to `build', except we build
2239    on the permanent_obstack, regardless.  */
2240
2241 tree
2242 build_min VPROTO((enum tree_code code, tree tt, ...))
2243 {
2244 #ifndef __STDC__
2245   enum tree_code code;
2246   tree tt;
2247 #endif
2248   register struct obstack *ambient_obstack = expression_obstack;
2249   va_list p;
2250   register tree t;
2251   register int length;
2252   register int i;
2253
2254   VA_START (p, tt);
2255
2256 #ifndef __STDC__
2257   code = va_arg (p, enum tree_code);
2258   tt = va_arg (p, tree);
2259 #endif
2260
2261   expression_obstack = &permanent_obstack;
2262
2263   t = make_node (code);
2264   length = tree_code_length[(int) code];
2265   TREE_TYPE (t) = copy_to_permanent (tt);
2266   TREE_COMPLEXITY (t) = lineno;
2267
2268   for (i = 0; i < length; i++)
2269     {
2270       tree x = va_arg (p, tree);
2271       TREE_OPERAND (t, i) = copy_to_permanent (x);
2272     }
2273
2274   va_end (p);
2275   expression_obstack = ambient_obstack;
2276   return t;
2277 }
2278
2279 /* Same as `tree_cons' but make a permanent object.  */
2280
2281 tree
2282 min_tree_cons (purpose, value, chain)
2283      tree purpose, value, chain;
2284 {
2285   register tree node;
2286   register struct obstack *ambient_obstack = current_obstack;
2287   current_obstack = &permanent_obstack;
2288
2289   node = tree_cons (copy_to_permanent (purpose),
2290                     copy_to_permanent (value), chain);
2291   current_obstack = ambient_obstack;
2292   return node;
2293 }
2294
2295 tree
2296 get_type_decl (t)
2297      tree t;
2298 {
2299   if (TREE_CODE (t) == TYPE_DECL)
2300     return t;
2301   if (TREE_CODE_CLASS (TREE_CODE (t)) == 't')
2302     return TYPE_STUB_DECL (t);
2303
2304   my_friendly_abort (42);
2305
2306   /* Stop compiler from complaining control reaches end of non-void function.  */
2307   return 0;
2308 }
2309
2310 int
2311 can_free (obstack, t)
2312      struct obstack *obstack;
2313      tree t;
2314 {
2315   int size = 0;
2316
2317   if (TREE_CODE (t) == TREE_VEC)
2318     size = (TREE_VEC_LENGTH (t)-1) * sizeof (tree) + sizeof (struct tree_vec);
2319   else
2320     my_friendly_abort (42);
2321
2322 #define ROUND(x) ((x + obstack_alignment_mask (obstack)) \
2323                   & ~ obstack_alignment_mask (obstack))
2324   if ((char *)t + ROUND (size) == obstack_next_free (obstack))
2325     return 1;
2326 #undef ROUND
2327
2328   return 0;
2329 }
2330
2331 /* Return first vector element whose BINFO_TYPE is ELEM.
2332    Return 0 if ELEM is not in VEC.  VEC may be NULL_TREE.  */
2333
2334 tree
2335 vec_binfo_member (elem, vec)
2336      tree elem, vec;
2337 {
2338   int i;
2339
2340   if (vec)
2341     for (i = 0; i < TREE_VEC_LENGTH (vec); ++i)
2342       if (same_type_p (elem, BINFO_TYPE (TREE_VEC_ELT (vec, i))))
2343         return TREE_VEC_ELT (vec, i);
2344
2345   return NULL_TREE;
2346 }
2347
2348 /* Kludge around the fact that DECL_CONTEXT for virtual functions returns
2349    the wrong thing for decl_function_context.  Hopefully the uses in the
2350    backend won't matter, since we don't need a static chain for local class
2351    methods.  FIXME!  */
2352
2353 tree
2354 hack_decl_function_context (decl)
2355      tree decl;
2356 {
2357   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_FUNCTION_MEMBER_P (decl))
2358     return decl_function_context (TYPE_MAIN_DECL (DECL_CLASS_CONTEXT (decl)));
2359   return decl_function_context (decl);
2360 }
2361
2362 /* Return truthvalue of whether T1 is the same tree structure as T2.
2363    Return 1 if they are the same.
2364    Return 0 if they are understandably different.
2365    Return -1 if either contains tree structure not understood by
2366    this function.  */
2367
2368 int
2369 cp_tree_equal (t1, t2)
2370      tree t1, t2;
2371 {
2372   register enum tree_code code1, code2;
2373   int cmp;
2374
2375   if (t1 == t2)
2376     return 1;
2377   if (t1 == 0 || t2 == 0)
2378     return 0;
2379
2380   code1 = TREE_CODE (t1);
2381   code2 = TREE_CODE (t2);
2382
2383   if (code1 == NOP_EXPR || code1 == CONVERT_EXPR || code1 == NON_LVALUE_EXPR)
2384     {
2385       if (code2 == NOP_EXPR || code2 == CONVERT_EXPR || code2 == NON_LVALUE_EXPR)
2386         return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2387       else
2388         return cp_tree_equal (TREE_OPERAND (t1, 0), t2);
2389     }
2390   else if (code2 == NOP_EXPR || code2 == CONVERT_EXPR
2391            || code2 == NON_LVALUE_EXPR)
2392     return cp_tree_equal (t1, TREE_OPERAND (t2, 0));
2393
2394   if (code1 != code2)
2395     return 0;
2396
2397   switch (code1)
2398     {
2399     case INTEGER_CST:
2400       return TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
2401         && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2);
2402
2403     case REAL_CST:
2404       return REAL_VALUES_EQUAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
2405
2406     case STRING_CST:
2407       return TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
2408         && !bcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
2409                   TREE_STRING_LENGTH (t1));
2410
2411     case CONSTRUCTOR:
2412       /* We need to do this when determining whether or not two
2413          non-type pointer to member function template arguments
2414          are the same.  */
2415       if (!(same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
2416             /* The first operand is RTL.  */
2417             && TREE_OPERAND (t1, 0) == TREE_OPERAND (t2, 0)))
2418         return 0;
2419       return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
2420
2421     case TREE_LIST:
2422       cmp = cp_tree_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2));
2423       if (cmp <= 0)
2424         return cmp;
2425       cmp = cp_tree_equal (TREE_VALUE (t1), TREE_VALUE (t2));
2426       if (cmp <= 0)
2427         return cmp;
2428       return cp_tree_equal (TREE_CHAIN (t1), TREE_CHAIN (t2));
2429
2430     case SAVE_EXPR:
2431       return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2432
2433     case CALL_EXPR:
2434       cmp = cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2435       if (cmp <= 0)
2436         return cmp;
2437       return simple_cst_list_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
2438
2439     case TARGET_EXPR:
2440       /* Special case: if either target is an unallocated VAR_DECL,
2441          it means that it's going to be unified with whatever the
2442          TARGET_EXPR is really supposed to initialize, so treat it
2443          as being equivalent to anything.  */
2444       if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL
2445            && DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE
2446            && DECL_RTL (TREE_OPERAND (t1, 0)) == 0)
2447           || (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL
2448               && DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE
2449               && DECL_RTL (TREE_OPERAND (t2, 0)) == 0))
2450         cmp = 1;
2451       else
2452         cmp = cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2453       if (cmp <= 0)
2454         return cmp;
2455       return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
2456
2457     case WITH_CLEANUP_EXPR:
2458       cmp = cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2459       if (cmp <= 0)
2460         return cmp;
2461       return cp_tree_equal (TREE_OPERAND (t1, 2), TREE_OPERAND (t1, 2));
2462
2463     case COMPONENT_REF:
2464       if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1))
2465         return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2466       return 0;
2467
2468     case VAR_DECL:
2469     case PARM_DECL:
2470     case CONST_DECL:
2471     case FUNCTION_DECL:
2472       return 0;
2473
2474     case TEMPLATE_PARM_INDEX:
2475       return TEMPLATE_PARM_IDX (t1) == TEMPLATE_PARM_IDX (t2)
2476         && TEMPLATE_PARM_LEVEL (t1) == TEMPLATE_PARM_LEVEL (t2);
2477
2478     case SIZEOF_EXPR:
2479     case ALIGNOF_EXPR:
2480       if (TREE_CODE (TREE_OPERAND (t1, 0)) != TREE_CODE (TREE_OPERAND (t2, 0)))
2481         return 0;
2482       if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (t1, 0))) == 't')
2483         return same_type_p (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2484       break;
2485
2486     case PTRMEM_CST:
2487       /* Two pointer-to-members are the same if they point to the same
2488          field or function in the same class.  */
2489       return (PTRMEM_CST_MEMBER (t1) == PTRMEM_CST_MEMBER (t2)
2490               && same_type_p (PTRMEM_CST_CLASS (t1), PTRMEM_CST_CLASS (t2)));
2491
2492     default:
2493       break;
2494     }
2495
2496   switch (TREE_CODE_CLASS (code1))
2497     {
2498       int i;
2499     case '1':
2500     case '2':
2501     case '<':
2502     case 'e':
2503     case 'r':
2504     case 's':
2505       cmp = 1;
2506       for (i=0; i<tree_code_length[(int) code1]; ++i)
2507         {
2508           cmp = cp_tree_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i));
2509           if (cmp <= 0)
2510             return cmp;
2511         }
2512       return cmp;
2513     }
2514
2515   return -1;
2516 }
2517
2518 /* Similar to make_tree_vec, but build on the momentary_obstack.
2519    Thus, these vectors are really and truly temporary.  */
2520
2521 tree
2522 make_temp_vec (len)
2523      int len;
2524 {
2525   register tree node;
2526   push_expression_obstack ();
2527   node = make_tree_vec (len);
2528   pop_obstacks ();
2529   return node;
2530 }
2531
2532 /* Build a wrapper around some pointer PTR so we can use it as a tree.  */
2533
2534 tree
2535 build_ptr_wrapper (ptr)
2536      void *ptr;
2537 {
2538   tree t = make_node (WRAPPER);
2539   WRAPPER_PTR (t) = ptr;
2540   return t;
2541 }
2542
2543 /* Same, but on the expression_obstack.  */
2544
2545 tree
2546 build_expr_ptr_wrapper (ptr)
2547      void *ptr;
2548 {
2549   tree t;
2550   push_expression_obstack ();
2551   t = build_ptr_wrapper (ptr);
2552   pop_obstacks ();
2553   return t;
2554 }
2555
2556 /* Build a wrapper around some integer I so we can use it as a tree.  */
2557
2558 tree
2559 build_int_wrapper (i)
2560      int i;
2561 {
2562   tree t = make_node (WRAPPER);
2563   WRAPPER_INT (t) = i;
2564   return t;
2565 }
2566
2567 tree
2568 build_srcloc (file, line)
2569      char *file;
2570      int line;
2571 {
2572   tree t;
2573
2574   /* Make sure that we put these on the permanent obstack; up in
2575      add_pending_template, we pass this return value into perm_tree_cons,
2576      which also puts it on the permanent_obstack.  However, this wasn't
2577      explicitly doing the same.  */
2578   register struct obstack *ambient_obstack = current_obstack;
2579   current_obstack = &permanent_obstack;
2580
2581   t = make_node (SRCLOC);
2582   SRCLOC_FILE (t) = file;
2583   SRCLOC_LINE (t) = line;
2584
2585   current_obstack = ambient_obstack;
2586
2587   return t;
2588 }
2589
2590 tree
2591 build_srcloc_here ()
2592 {
2593   return build_srcloc (input_filename, lineno);
2594 }
2595
2596 void
2597 push_expression_obstack ()
2598 {
2599   push_obstacks_nochange ();
2600   current_obstack = expression_obstack;
2601 }
2602
2603 /* The type of ARG when used as an lvalue.  */
2604
2605 tree
2606 lvalue_type (arg)
2607      tree arg;
2608 {
2609   tree type = TREE_TYPE (arg);
2610   if (TREE_CODE (arg) == OVERLOAD)
2611     type = unknown_type_node;
2612   return type;
2613 }
2614
2615 /* The type of ARG for printing error messages; denote lvalues with
2616    reference types.  */
2617
2618 tree
2619 error_type (arg)
2620      tree arg;
2621 {
2622   tree type = TREE_TYPE (arg);
2623   if (TREE_CODE (type) == ARRAY_TYPE)
2624     ;
2625   else if (real_lvalue_p (arg))
2626     type = build_reference_type (lvalue_type (arg));
2627   else if (IS_AGGR_TYPE (type))
2628     type = lvalue_type (arg);
2629
2630   return type;
2631 }
2632
2633 /* Does FUNCTION use a variable-length argument list?  */
2634
2635 int
2636 varargs_function_p (function)
2637      tree function;
2638 {
2639   tree parm = TYPE_ARG_TYPES (TREE_TYPE (function));
2640   for (; parm; parm = TREE_CHAIN (parm))
2641     if (TREE_VALUE (parm) == void_type_node)
2642       return 0;
2643   return 1;
2644 }
2645
2646 /* Returns 1 if decl is a member of a class.  */
2647
2648 int
2649 member_p (decl)
2650      tree decl;
2651 {
2652   tree ctx = DECL_CONTEXT (decl);
2653   return (ctx && TREE_CODE_CLASS (TREE_CODE (ctx)) == 't');
2654 }
2655
2656 /* Create a placeholder for member access where we don't actually have an
2657    object that the access is against.  */
2658
2659 tree
2660 build_dummy_object (type)
2661      tree type;
2662 {
2663   tree decl = build1 (NOP_EXPR, build_pointer_type (type), error_mark_node);
2664   return build_indirect_ref (decl, NULL_PTR);
2665 }
2666
2667 /* We've gotten a reference to a member of TYPE.  Return *this if appropriate,
2668    or a dummy object otherwise.  If BINFOP is non-0, it is filled with the
2669    binfo path from current_class_type to TYPE, or 0.  */
2670
2671 tree
2672 maybe_dummy_object (type, binfop)
2673      tree type;
2674      tree *binfop;
2675 {
2676   tree decl, context;
2677
2678   if (current_class_type
2679       && get_base_distance (type, current_class_type, 0, binfop) != -1)
2680     context = current_class_type;
2681   else
2682     {
2683       /* Reference from a nested class member function.  */
2684       context = type;
2685       if (binfop)
2686         *binfop = TYPE_BINFO (type);
2687     }
2688
2689   if (current_class_ref && context == current_class_type)
2690     decl = current_class_ref;
2691   else
2692     decl = build_dummy_object (context);
2693
2694   return decl;
2695 }
2696
2697 /* Returns 1 if OB is a placeholder object, or a pointer to one.  */
2698
2699 int
2700 is_dummy_object (ob)
2701      tree ob;
2702 {
2703   if (TREE_CODE (ob) == INDIRECT_REF)
2704     ob = TREE_OPERAND (ob, 0);
2705   return (TREE_CODE (ob) == NOP_EXPR
2706           && TREE_OPERAND (ob, 0) == error_mark_node);
2707 }
2708
2709 /* Returns 1 iff type T is a POD type, as defined in [basic.types].  */
2710
2711 int
2712 pod_type_p (t)
2713      tree t;
2714 {
2715   tree f;
2716
2717   while (TREE_CODE (t) == ARRAY_TYPE)
2718     t = TREE_TYPE (t);
2719
2720   if (! IS_AGGR_TYPE (t))
2721     return 1;
2722
2723   if (CLASSTYPE_NON_AGGREGATE (t)
2724       || TYPE_HAS_COMPLEX_ASSIGN_REF (t)
2725       || TYPE_HAS_DESTRUCTOR (t))
2726     return 0;
2727
2728   for (f = TYPE_FIELDS (t); f; f = TREE_CHAIN (f))
2729     {
2730       if (TREE_CODE (f) != FIELD_DECL)
2731         continue;
2732
2733       if (TREE_CODE (TREE_TYPE (f)) == REFERENCE_TYPE
2734           || TYPE_PTRMEMFUNC_P (TREE_TYPE (f))
2735           || TYPE_PTRMEM_P (TREE_TYPE (f)))
2736         return 0;
2737     }
2738
2739   return 1;
2740 }